diff options
Diffstat (limited to 'Pb')
| -rw-r--r-- | Pb/Break/.__init__.py.swl | bin | 0 -> 20480 bytes | |||
| -rw-r--r-- | Pb/Break/.__init__.py.swm | bin | 0 -> 16384 bytes | |||
| -rwxr-xr-x | Pb/Break/__init__.py | 179 | ||||
| -rwxr-xr-x | Pb/Break/__init__.py~ (renamed from Pb/Breaker/__init__.py) | 15 | ||||
| -rwxr-xr-x | Pb/Generate/__init__.py | 2 | ||||
| -rwxr-xr-x | Pb/Gradient/__init__.py | 2 | ||||
| -rwxr-xr-x | Pb/Grid/__init__.py (renamed from Pb/Imgrid/__init__.py) | 151 | ||||
| -rwxr-xr-x | Pb/Landscape/__init__.py (renamed from Pb/Imlandscape/__init__.py) | 0 | ||||
| -rwxr-xr-x | Pb/Landscape/landscape (renamed from Pb/Imlandscape/landscape) | 0 | ||||
| -rw-r--r-- | Pb/Params/__init__.py | 10 | ||||
| -rwxr-xr-x | Pb/Pattern/__init__.py | 6 | ||||
| -rw-r--r-- | Pb/__init__.py | 167 | ||||
| -rw-r--r-- | Pb/inspect_objects_example.py | 15 |
13 files changed, 316 insertions, 231 deletions
diff --git a/Pb/Break/.__init__.py.swl b/Pb/Break/.__init__.py.swl Binary files differnew file mode 100644 index 0000000..e2bd941 --- /dev/null +++ b/Pb/Break/.__init__.py.swl diff --git a/Pb/Break/.__init__.py.swm b/Pb/Break/.__init__.py.swm Binary files differnew file mode 100644 index 0000000..0fcc095 --- /dev/null +++ b/Pb/Break/.__init__.py.swm diff --git a/Pb/Break/__init__.py b/Pb/Break/__init__.py new file mode 100755 index 0000000..db9daaf --- /dev/null +++ b/Pb/Break/__init__.py @@ -0,0 +1,179 @@ +#!/usr/bin/python2.7 +import os +import sys +import random +import re +import urllib +import inspect +from Config import * +from Pb import Pb +from Params import Params + +DEFAULT_FINALFORMAT = "png"; + +_subtle_break_mark = 'pron' +_extreme_break_mark = 'sugar' + +_header_offset = 2000 + +class PbBreak(Pb): #FIXME in db gallery + def __init__(self, + url=None, + breaktype=None, + finalformat=DEFAULT_FINALFORMAT, + breakmode=None, + breakangle=None, + username=None, + expanded=None, + ): + + super(PbBreak,self).__init__(); + + self.params.set_val("breaktype", self._get_breaktype(breaktype), value_type="string"); + self.params.set_val("finalformat", finalformat, value_type="string") + self.params.set_val("breakmode", breakmode, value_type="enum", enum_values=["subtle", "extreme", "gradual"]) + self.params.set_val("breakangle", breakangle, value_type="float") + self.params.set_val("expanded", expanded, value_type="bool") + self.params.set_val("url", url, value_type="img_url"); + self._files_created.append(self.params.url['path']) + +# if not self.params.finalformat and self._gif_frames: +# self.params.finalformat = 'gif' +# if self.params.breaktype == 'miff': +# self.params.finalformat = 'jpg' +# self.params.breakmode = 'subtle' + #final filepath is stored in self.filepath + self.filename, self.filepath = self._filename_filepath_create(url=self.params.url['url']) + self._conversion_file = self._tempfilepath_create() + + def _get_breaktype(self, key): + #{{{ conversion table + breaktypeTranslate = { + 'CLASSIC':'jpg', + 'REDUX':'pcds', + 'BLURRY_BREAK':'viff', + 'BLURRY_BREAK_2':'mat', + 'SWIPE':'miff', + 'RGB_WASH':'psd', + 'RGB_WASH_2':'psb', + 'NOISY_BREAK':'palm', + 'NOISY_BREAK_2':'fig', + 'BROKEN_VIGNETTE':'pbm', + 'FAX_MACHINE':'cals', + 'STRIPES':'exr', + 'PHOTOCOPY':'art', + } + #}}} + return breaktypeTranslate[key] + +#{{{#########rotatefunctions####################################### + def _rotate(self): + cmd = [BIN_CONVERT,self.params.url['path'],"-rotate",self.params.breakangle,"+repage",self.params.url['path']] + self._call_cmd(cmd) + + def _rotate_back(self): + angle = str(360-int(self.params.breakangle)) + cmd = [BIN_CONVERT,self.filepath,"-rotate",angle,"+repage",self.filepath] + self._call_cmd(cmd) + if not self.params.expanded: + cmd = [BIN_CONVERT,self.filepath,"-gravity","Center","-crop","{}x{}+0+0".format( + self.width, self.height),"+repage",self.filepath] + self._call_cmd(cmd) +#}}} + + def _subtle_break(self): + #assume the header is no longer than _header_offset bytes + breakpoint = random.randint(_header_offset, len(self.file_data)) + newfile = self.file_data[0:breakpoint] \ + + _subtle_break_mark \ + + self.file_data[breakpoint:] + self.file_data = newfile[0:len(self.file_data)] + + def _extreme_break(self): + increment = len(self.file_data)/10; + i = 0 + newfile = ""; + for b in self.file_data: + if i > _header_offset and not (i % increment): + b += _extreme_break_mark + newfile += b + i += 1 + self.file_data = newfile[0:len(self.file_data)] + + def _choose_frame(self, filepath): + _gif_frames = PbBreak.gif_frames(filepath) + frame = random.choice(_gif_frames) + self._call_cmd([BIN_CONVERT, frame, filepath]) + + def _enforce_jpg(self): + if self.params.breaktype in [ "exr", "bmp", "miff" ] and not re.match(r'jpe?g$', self.params.url['mimetype'], re.IGNORECASE): + jpg_file = self.tempname_create(basename=self.basename, fmt="jpg") + self._call_cmd([BIN_CONVERT,self.params.url['path'], jpg_file]) + self._call_cmd(["rm",self.params.url['path']]) + #FIXME create logical separation between params and files created by the module + #FIXME add appropriate methods to the master class, to create temporary filenames, + #to create appropriate output names + #FIXME add flask methods when you can + self.params.url = { 'path': jpg_file, 'mimetype': "jpg" } + + def _first_conversion(self): + if self.params.url['mimetype'] == self.params.breaktype: + self.params.url['path'] = self._conversion_file + return + self._call_cmd([BIN_CONVERT, self.params.url['path'], self._conversion_file]) + self.files_created.append(self._conversion_file) + + def _prepare_filedata(self): + if self.params.url['mimetype'] == "gif": + self._choose_frame(self.params.url['path']) + if self.params.breakangle: + self._rotate() + self._enforce_jpg(); + self._first_conversion(); + self.file_data = self._file_read(self._conversion_file) + if not self.file_data: + self.err_warn("Unable to get file data"); + + def _add_false_data(self, breakmode): + if breakmode == "subtle": + self._subtle_break() + elif breakmode == "extreme": + self._extreme_break() + f = open(self._conversion_file, 'w') + f.write(self.file_data) + f.close(); + + def _final_conversion(self): + self._call_cmd( [BIN_CONVERT, self._conversion_file, self.filepath]) + def psd_psbfilepath(num): + return os.path.join(self._working_dir, "{}-{}.{}".format(self.basename, num, self.params.finalformat)) + if self.params.breaktype == 'psd': + self._call_cmd(['mv', psd_psbfilepath(1), self.filepath]) + self.files_created.append(psd_psbfilepath(0)) + if self.params.breaktype == 'psb': + self._call_cmd(['mv', psd_psbfilepath(0), self.filepath]) + self.files_created.append(psd_psbfilepath(1)) + if self.params.breakangle: + self._rotate_back() + + def create(self, breakmode=""): + if not breakmode: breakmode = self.params.breakmode + self._prepare_filedata(); + self._add_false_data(breakmode); + self._final_conversion() + self._cleanup() + + @classmethod + def test(cls): + TEST_PARAMS = { + "url" : "http://i.asdf.us/im/27/1424816234661dumpfmpfifferkinggr_1424816412_pfifferking.gif" , + "breaktype" : "RGB_WASH", + "finalformat" : "png", + "breakmode" : "extreme", + "breakangle" : "10", + "username" : "donkey", + "expanded" : "false" + } + b = cls(**TEST_PARAMS) + b.create(); + print b.filepath diff --git a/Pb/Breaker/__init__.py b/Pb/Break/__init__.py~ index 2d2f573..c1064e2 100755 --- a/Pb/Breaker/__init__.py +++ b/Pb/Break/__init__.py~ @@ -28,21 +28,28 @@ class Breaker(Pb): for arg in _args_vals.args: if arg == "self": continue + sys.stderr.write(str(arg) + "\n") try: if arg not in ['breaktype', 'url']: - self.params.__setattr__(arg, self.bool_correct(str(_args_vals.locals.get(arg)))) + sys.stderr.write("Yoooo"); + sys.stderr.write(arg) + strarg = str(_args_vals.locals.get(arg)) + django self.bool_correct(strarg) + self.params.__setattr__("dingo", django) +# self.params.__setattr__(arg, self.bool_correct(_args_vals.locals.get(arg))) except Exception as e: sys.stderr.write("\n"+str(e)+"\n") + sys.exit(1); + self.params = Params(**self.params); self.tag = "imBreak" self.commands = []; self._now = self.now() self.files_created = [] - self.basename, self._first_format = self._get_filename_and_type_from_url(self.params.url); + self.basename, self._first_format = self._get_filename_and_type_from_url(); self._downloaded_file = self.tempname_create(basename=self.basename, fmt=self._first_format) - try: self.download(self.params.url, self._downloaded_file) self.files_created.append(self._downloaded_file) @@ -64,7 +71,7 @@ class Breaker(Pb): self._conversion_file = self.tempname_create(basename=self.basename, fmt=self.params.breaktype); def _call_cmd(self, cmd): - super(Breaker,self)._call_cmd(cmd) + super(Breaker,self)._call_cmd(cmd, error) self.commands.append(" ".join(cmd)); def _get_breaktype(self, key): diff --git a/Pb/Generate/__init__.py b/Pb/Generate/__init__.py index 385591e..191d600 100755 --- a/Pb/Generate/__init__.py +++ b/Pb/Generate/__init__.py @@ -22,7 +22,7 @@ DISPOSE_DEFAULT = "None" def debuglog(s): sys.stderr.write(str(s) + "\n"); -class Generate(Pb): +class Im(Pb): def __init__(self, **kwargs): self.params = {} self._now = self.now() diff --git a/Pb/Gradient/__init__.py b/Pb/Gradient/__init__.py index 5120c7d..c384df2 100755 --- a/Pb/Gradient/__init__.py +++ b/Pb/Gradient/__init__.py @@ -44,7 +44,7 @@ HALFTONEVALUES = { }
-class Gradient(Pb):
+class Imgradient(Pb):
def __init__(self, **kwargs):
self.tag = "imGradient"
self.directory = WORKING_DIR
diff --git a/Pb/Imgrid/__init__.py b/Pb/Grid/__init__.py index 52cb748..09718bd 100755 --- a/Pb/Imgrid/__init__.py +++ b/Pb/Grid/__init__.py @@ -4,112 +4,73 @@ import re import os import simplejson as json import random -from Config import * +from Config import DEFAULT_FINALFORMAT, DEFAULT_HEIGHT, DEFAULT_WIDTH, WORKING_DIR +from Config import THREEDROTATE, GRID import tempfile from Pb import Pb -DEFAULT_HEIGHT = 400 -DEFAULT_WIDTH = 600 -DEFAULT_LINE_COLOR = "silver" +_default_line_color = "silver" class Imgrid(Pb): - def __init__(self, **kwargs): - self.tag = "imGrid" - self.files_created = [] - self.commands = []; - self._required_keys = [ -#{{{ required_keys - "width", - "height", - "linethickness", - "opacity", - "linecolor", - "spacing", - "vlines", - "hlines", - "shadow", - "bgimage", - "bgcolor", - "imageinstead", - "planebgcolor", - "planebgimage", - "swing", - "tilt", - "roll", - "zoom", - "skycolor", - "transition", - "trim", - "format", - "username" -#}}} - ] - self._now = self.now() - - #Work out params ... - #note, tmpfile lib is pretty much useless here, given imagemagick's behavior with gifs (it splits them) etc... - #instead we're just making our own in /var/www/cache (tmpfs mounted there) - self.params = {} - for k in self._required_keys: - if k in kwargs: - if k in [ 'bgimage', 'planebgimage', 'imageinstead' ] and self.bool_correct(kwargs[k]): - self.params[k] = { - 'url' : kwargs[k], - 'filename' : self._make_tempname(k), - 'path' : os.path.join(WORKING_DIR, self._make_tempname(k)) , - } - try: - self.download(self.params[k]['url'], self.params[k]['path']) - self.files_created.append(self.params[k]['path']) - self.params[k]['mimetype'] = self.get_mimetype(self.params[k]['path']) - frames = self.gif_frames(self.params[k]['path']) - if len(frames) > 1: - self.params[k]['path'] = random.choice(frames) - - except Exception: - sys.stderr.write(str(e)) - raise Exception ("BAD PARAMS"); - elif k in [ 'skycolor', 'bgcolor', 'planebgcolor','linecolor' ]: - try: - self.params[k] = self.is_color(kwargs[k]) - except Exception: - sys.stderr.write(kwargs[k] + "\n") - raise Exception("Unable to process color for:\n{}".format(k)) - elif k == 'opacity': - self.params[k] = str(float(kwargs[k])) - elif k == 'zoom': - self.params[k] = int(float(kwargs[k])) - else: - self.params[k] = self.bool_correct(self.sanitize(kwargs[k])) - else: - self.params[k] = None; + def __init__(self, + width=None, + height=None, + linethickness=None, + opacity=None, + linecolor=None, + spacing=None, + vlines=None, + hlines=None, + shadow=None, + bgimage=None, + bgcolor=None, + imageinstead=None, + planebgcolor=None, + planebgimage=None, + swing=None, + tilt=None, + roll=None, + zoom=None, + skycolor=None, + transition=None, + trim=None, + finalformat=DEFAULT_FINALFORMAT, + username=None + ): + super(Imgrid,self).__init__(); - self.params = self.make_dotdict(self.params) + _frame = inspect.currentframe(); + _args_vals = inspect.getargvalues(_frame); + for arg in _args_vals.args: + if arg == "self": + continue + argval = _args_vals.locals.get(arg) + try: + if arg in [ 'skycolor', 'bgcolor', 'planebgcolor','linecolor' ]: + self.params.set_val(arg, argval, value_type="color") + elif arg == 'opacity': + self.params.set_val(arg, argval, value_type="float") + elif arg == 'zoom': + self.params.set_val(arg, argval, value_type="int") + elif arg in [ 'bgimage', 'planebgimage', 'imageinstead' ]: + self.params.set_val(arg, argval, value_type="img_url") + if self.params.get_mimetype(arg) == 'gif': + self.params.gif_convert_to_still(arg) + self.files_created.append(self.params.get_filepath(arg)) + elif arg in ['finalformat', 'username' ] : + self.params.set_val(arg, argval, value_type="string") + else: + self.params.set_val(arg, argval, value_type="bool") + + except Exception as e: + self.log_err(str(e)) + #FIXME these need to be bumped up to the parent class self.basename = self._get_filename(); - - if not self.params.finalformat: - self.params.finalformat = DEFAULT_FINALFORMAT self.filename = "{}.{}".format(self.basename, self.params.finalformat) #final filepath is stored in self.filepath self.filepath = os.path.join(WORKING_DIR, self.filename) - def _get_filename(self): - return "{}_{}_{}".format( - self.tag, - self._now, - self.params.username or "" - ); - - def _call_cmd(self, cmd): - try: - self.call_cmd(cmd) - self.commands.append(" ".join(cmd)); - except Exception: - raise Exception("Unable to call cmd {}".format(str(cmd))) - - def _make_tempname(self, s): - return "IMGRIDTMP{}{}".format(self._now, s); #makes a canvas file...step 1 (if not bgimage) @@ -136,7 +97,7 @@ class Imgrid(Pb): cmd += ["-s", "{},{}".format(height,self.params.spacing)] else: cmd += ["-s",self.params.spacing] - cmd += [ "-c", self.params.linecolor or DEFAULT_LINE_COLOR] + cmd += [ "-c", self.params.linecolor or _default_line_color] if self.params.linethickness: cmd += ['-t',self.params.linethickness] if self.params.opacity: cmd += ['-o',self.params.opacity] cmd += [ self.filepath, self.filepath ] diff --git a/Pb/Imlandscape/__init__.py b/Pb/Landscape/__init__.py index 59212a6..59212a6 100755 --- a/Pb/Imlandscape/__init__.py +++ b/Pb/Landscape/__init__.py diff --git a/Pb/Imlandscape/landscape b/Pb/Landscape/landscape index 10e8ede..10e8ede 100755 --- a/Pb/Imlandscape/landscape +++ b/Pb/Landscape/landscape diff --git a/Pb/Params/__init__.py b/Pb/Params/__init__.py deleted file mode 100644 index 2285e7a..0000000 --- a/Pb/Params/__init__.py +++ /dev/null @@ -1,10 +0,0 @@ -class Params(object): - def __init__(self, **kwargs): - for key, value in kwargs.items(): - setattr(self, key, value) - def __getattr__(self, attr): - return self.get(attr, None) - def __iter__(self): - for key, value in vars(self).iteritems(): - yield key, value - diff --git a/Pb/Pattern/__init__.py b/Pb/Pattern/__init__.py index 905ddf9..7c53746 100755 --- a/Pb/Pattern/__init__.py +++ b/Pb/Pattern/__init__.py @@ -11,9 +11,9 @@ import simplejson as json from PIL import Image import uuid -FUSE_MODE="Pin_Light" +_fuse_mode="Pin_Light" -class Pattern(Pb): +class Impattern(Pb): def __init__(self, **kwargs): self.params = {} self.tag = "imPattern"; @@ -149,7 +149,7 @@ class Pattern(Pb): self._call_cmd(cmd) #third step - def _fuse_mask(self, fuse_mode=FUSE_MODE): + def _fuse_mask(self, fuse_mode=_fuse_mode): cmd = [BIN_CONVERT, "-dispose", "2", self.filepath, "null:", self._downloaded_file, "-matte", "-compose", fuse_mode, "-layers", "composite", self.filepath] diff --git a/Pb/__init__.py b/Pb/__init__.py index 909f03b..0212235 100644 --- a/Pb/__init__.py +++ b/Pb/__init__.py @@ -7,33 +7,64 @@ import sys import os import random from subprocess import Popen,PIPE,call -from Pb.Params import Params +from Params import Params +import time Request = urllib2.Request urlencode = urllib.urlencode urlopen = urllib2.urlopen +_max_filename_length = 20; class Pb(object): def __init__(self): - self.params = Params(); + self._now = str(int(time.time())); + self.params = Params(classname=self.__class__.__name__, now=self._now); + self._files_created = [] + self.commands = []; self._working_dir = WORKING_DIR + def _filename_create(self, url=None, namepart=""): + if url: + _basename = os.path.basename(url) + namepart = re.split(r'\.')[0] + namepart = self.params.sanitize(_namepart)[0:_max_filename_length] + name = "" + if namepart: name += "%s-" % namepart + name += "%s_%s" % (self.__class__.__name__, self._now) + if self.params.username : name += "_%s" % self.params.username + return name + + def _filepath_create(self, filename, directory=WORKING_DIR): + return os.path.join(directory, filename) + + def _filename_filepath_create(self, url=None, namepart="", directory=WORKING_DIR): + _filename = self._filename_create(url=url, namepart=namepart); + _filepath = _filename_create(_filename, directory=directory); + return _filename, _filepath + + def _tempfilepath_create(self, namepart="temp", directory=WORKING_DIR): + _filename = self._filename_create(namepart=namepart) + return _filepath_create(_filename, directory=directory) + def _call_cmd(self, cmd): - try: - call(cmd) - except Exception as e: - self.err_warn("Could not call cmd: {}".format(str(cmd))) - self.err_warn(str(e)) + try: + self.call_cmd(cmd) + self.commands.append(" ".join(cmd)); + except Exception: + raise Exception("Unable to call cmd {}".format(str(cmd))) @staticmethod - def is_color(s): - if s == "": - return "transparent" - if re.match('(rgba?\([0-9]+,[0-9]+,[0-9]+\))|([a-zA-Z]+)|(\#[A-Ha-h0-9]+)', s): - return s.replace(' ', ''); - else: - sys.stderr.write("Not a color: {}\n".format(s)) - raise ValueError + def gif_frames(filepath): + try: + info = Popen([BIN_IDENTIFY,filepath], stdout=PIPE).communicate()[0] + frames = filter((lambda x: x), map( + (lambda x: x.split(" ")[0]), + (info).split('\n') + )) + return frames + except Exception as e: + self.err_warn("couldn't get gif frames") + raise e; @staticmethod def dimensions (filepath): @@ -42,77 +73,6 @@ class Pb(object): return ident[2].split("x") @staticmethod - def is_number(s): - try: - return int(s) - except (ValueError, TypeError): - return False - - def bool_correct(self, s): - try: - if re.match(r'^false$', str(s), re.IGNORECASE): - return False - elif re.match(r'^true$', str(s), re.IGNORECASE): - return True - else: - return s - except Exception as e: - sys.stderr.write("WHAT THE FUCK") - - @staticmethod - def get_mimetype(f): - try: - mimetype = Popen( - [BIN_IDENTIFY, f], stdout=PIPE - ).communicate()[0].split(" ")[1].lower() - return mimetype - except Exception as e: - sys.stderr.write("couldn't determine mimetype") - sys.stderr.write(str(e)) - raise; - - def sanitize (self, s): - return re.sub(r'\W+', '', s) - - @staticmethod - def now(): - return int(time.time()) - - @staticmethod - def browser_request (url, data=None): - headers = { - 'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)', - 'Accept': '*/*', - } - try: - req = Request(url, data, headers) - response = urlopen(req) - except IOError, e: - if hasattr(e, 'code'): - sys.stderr.write( '%s - ERROR %s' % (url, e.code) ) - raise; - return None - else: - return response - - def download(self, url, destination, max_size=MAX_SIZE): - response = self.browser_request(url, None) - rawimg = response.read() - if len(rawimg) == 0: - sys.stderr.write("got zero-length file") - raise; - if len(rawimg) > max_size: - sys.stderr.write("file too big: max size {} KB / {} is {} KB".format( - str(MAX_SIZE/1024), - destination, - str(len(rawimg)/1024) - )) - raise; - f = open(destination, "w") - f.write(rawimg) - f.close() - - @staticmethod def file_size (filepath): try: return os.stat(filepath)[6] @@ -121,37 +81,6 @@ class Pb(object): sys.stderr.write(str(e)+"\n") raise; - def gif_frames(self, filepath): - try: - info = Popen([BIN_IDENTIFY,filepath], stdout=PIPE).communicate()[0] - frames = filter((lambda x: x), map( - (lambda x: x.split(" ")[0]), - (info).split('\n') - )) - return frames - except Exception as e: - sys.stderr.write("{} couldn't get gif frames".format(self.__class__.__name__)) - sys.stderr.write(str(e)) - raise; - - def tempname_create(self, basename=None, fmt="png"): - if not basename: basename = self.random_string_create() - return os.path.join(self._working_dir, "{}{}.{}".format(self.__class__.__name__, basename, fmt)) # this - - def _get_filename_and_type_from_url (self, url): - name = re.sub(r'(?:\s|\?.*|.*/)', '', urllib.unquote(url)); - try: - basename, ext = map(lambda s: self.sanitize(s), re.search(r'(^.*)\.(.*$)', name).groups()); - except Exception as e: - self.err_warn("Incompatible input file type") - if (len(basename) > 20): - basename = basename[:-20] - return "{}{}_{}_{}".format(self.tag, basename, self._now, self.params.username or ""), ext - - def random_string_create(self): - return "{}".format(random.uniform(0, 100000)); - - def _file_read(self, filepath): f = open(filepath, 'r'); data = f.read() @@ -161,6 +90,10 @@ class Pb(object): def err_warn(self, s): sys.stderr.write("ERROR:{} - {}\n".format(self.__class__.__name__, s)) + def _cleanup(self): + cmd = ["rm"]+self._files_created + self._call_cmd(cmd) + def err_fatal(self, s): sys.stderr.write("ERROR[FATAL]:{} - {}\n".format(self.__class__.__name__, s)) sys.exit(1); diff --git a/Pb/inspect_objects_example.py b/Pb/inspect_objects_example.py new file mode 100644 index 0000000..92e28b7 --- /dev/null +++ b/Pb/inspect_objects_example.py @@ -0,0 +1,15 @@ +class Test(object): + def __init__(self, one="la", two="di"): + self._test_args(inspect.getargvalues(inspect.currentframe())); + + def _test_args(self, _args_vals): + for arg in _args_vals.args: + if arg == "self": + continue + try: + sys.stdout.write("%s\n" % arg) + sys.stdout.write("\t%s\n" % _args_vals.locals.get(arg)) + except Exception as e: + sys.stderr.write("%s\n" % e ); + +t = Test(); |