DynamicObject.py
816 lines
| 35.9 KiB
| text/x-python
|
PythonLexer
ebocanegra
|
r965 | ''' | ||
| The DynamicObject module supports dynamic loading of YAML | ||||
| defined objects into Python class objects. Object can | ||||
| be sub-classed to allow direct binding of methods having | ||||
| matching signatures. | ||||
| $Id$ | ||||
| ''' | ||||
| import urllib | ||||
| import os | ||||
| import re | ||||
| import yaml # YAML Ain't Markup Language | ||||
| import numpy as np | ||||
| import copy | ||||
| import inspect | ||||
| import PrecisionTime | ||||
| import time | ||||
| import sys | ||||
| import datetime | ||||
| import collections | ||||
| # Replacement Loader for PyYAML to keep dictionaries in-order: | ||||
| import OrderedYAML | ||||
| #OrderedYAML.collections | ||||
| class Object(object): | ||||
| """ Loads a YAML defined python class dynamically using the supplied URI, | ||||
| which may be a file, directory, web hyper-link, or hyper-linked directory. """ | ||||
| # Dictionary containing all known Object class names and corresponding class objects | ||||
| dynamicClasses = collections.OrderedDict() | ||||
| def __init__(self, object_uri=None, revision=None, recursive=False): | ||||
| if isinstance(object_uri, file): | ||||
| # URI is a yaml file - read it. | ||||
| self.yaml = file.read() | ||||
| elif object_uri == None: | ||||
| self.yaml = None | ||||
| elif isinstance(object_uri, str): | ||||
| if object_uri.endswith('.yml'): | ||||
| # URI is a web hyper-linked yaml file - read it. | ||||
| self.yaml = urllib.urlopen(object_uri).read() | ||||
| else: | ||||
| # URI is a (hyper-linked?) directory - try reading it. | ||||
| #print "URI is a directory." | ||||
| try: | ||||
| self.files = self.__parseLink(object_uri, recursive) | ||||
| except IOError: | ||||
| # URI is a local directory - get a list of YAML files in it | ||||
| self.files = self.__getYamlFiles(object_uri, recursive) | ||||
| # For each YAML file found, create a new DynamicObject of it: | ||||
| self.yaml = [] | ||||
| for fn in self.files: | ||||
| self.yaml.append(Object(fn)) | ||||
| else: | ||||
| print "Invalid URI supplied: %s"%(object_uri,) | ||||
| def __parseLink(self, object_uri, recursive): | ||||
| """ Returns a listing of all YAML files located in the | ||||
| hyper-link directory given by page. """ | ||||
| page = urllib.urlopen(object_uri).read() | ||||
| #print "URI is a URL directory: %s"%(object_uri,) | ||||
| pattern = re.compile(r'<a href="[^"]*">') | ||||
| # List of files contained in the directory at the given URL, ignoring | ||||
| # any "?" / GET query-string locations given: | ||||
| files = [x[9:-2] for x in pattern.findall(page) if not x[9:-2].startswith('?')] | ||||
| #print files | ||||
| yamlFiles = [] | ||||
| dirs = [] | ||||
| for fn in files: | ||||
| if not fn.startswith('/'): # Ignore absolute paths... | ||||
| path = os.path.join(object_uri, fn) | ||||
| #print path | ||||
| # Keep list of YAML files found... | ||||
| if fn.endswith('.yml'): | ||||
| yamlFiles.append(path) | ||||
| # Keep list of directories found... | ||||
| elif recursive and fn.endswith('/'): | ||||
| dirs.append(path) | ||||
| if recursive: | ||||
| #print dirs | ||||
| for path in dirs: | ||||
| yamlFiles += self.__parseLink(path,recursive) | ||||
| return yamlFiles | ||||
| def __getYamlFiles(self, local_dir, recursive): | ||||
| """ Returns a listing of all YAML files located in the given | ||||
| directory, recursing if requested. """ | ||||
| yamlFiles = [] | ||||
| dirs = [] | ||||
| for fn in os.listdir(local_dir): | ||||
| path = os.path.join(local_dir, fn) | ||||
| # List of YAML files found... | ||||
| if fn.endswith('.yml'): | ||||
| yamlFiles.append(path) | ||||
| # List of directories found... | ||||
| elif recursive and os.path.isdir(path): | ||||
| dirs.append(path) | ||||
| # Recurse if desired: | ||||
| if recursive: | ||||
| for path in dirs: | ||||
| yamlFiles += self.__getYamlFiles(path,recursive) | ||||
| return yamlFiles | ||||
| def equals(self, obj, compare_time_created=True): | ||||
| """ Returns True iff self has identical attributes | ||||
| (numerically) to obj (no extras) """ | ||||
| if not isinstance(obj, Object): return False | ||||
| self_keys = self.__dict__.keys() | ||||
| obj_keys = obj.__dict__.keys() | ||||
| if not self_keys == obj_keys: | ||||
| return False | ||||
| for key in self_keys: | ||||
| obj_keys.remove(key) | ||||
| self_value, obj_value = self.__dict__[key], obj.__dict__[key] | ||||
| if isinstance(self_value, Object): | ||||
| if not self_value.equals(obj_value, compare_time_created): | ||||
| return False | ||||
| elif isinstance(self_value, np.ndarray): | ||||
| m1 = map(repr,self_value.flat) | ||||
| m2 = map(repr,obj_value.flat) | ||||
| ret = m1 == m2 | ||||
| if not ret: | ||||
| return False | ||||
| else: | ||||
| if not self_value == obj_value: | ||||
| # Return False iff the different times are important | ||||
| return key == '__time_created' and not compare_time_created | ||||
| return obj_keys == [] # no more keys --> the objects are identical | ||||
| def sizeof(self): | ||||
| """ Recursively computes the size in bytes of the given Dynamic Object """ | ||||
| sz = 0 | ||||
| values = self.__dict__.values() | ||||
| for val in values: | ||||
| if isinstance(val, Object): sz += val.sizeof() | ||||
| elif isinstance(val, np.ndarray): sz += val.nbytes | ||||
| elif hasattr(val, 'dtype') and hasattr(val.dtype, 'itemsize'): sz += val.dtype.itemsize | ||||
| else: sz += sys.getsizeof(val) | ||||
| return sz | ||||
| # Automatic methods for accessing meta-data | ||||
| getters = ['__object_name', '__revision_number', '__revision_id', '__revision_source', '__revision_tag', '__time_created'] | ||||
| def getObjectName(self): return self.__class__.meta_attributes['__object_name'] | ||||
| def getRevisionNumber(self): return self.__class__.meta_attributes['__revision_number'] | ||||
| def getRevisionId(self): return self.__class__.meta_attributes['__revision_id'] | ||||
| def getRevisionSource(self): return self.__class__.meta_attributes['__revision_source'] | ||||
| def getRevisionTag(self): return self.__class__.meta_attributes['__revision_tag'] | ||||
| def getTimeCreated(self): return getattr(self, "__time_created") | ||||
| """ | ||||
| __getters = [('ObjectName', getObjectName), ('RevisionNumber', getRevisionNumber), | ||||
| ('RevisionId', getRevisionId), ('RevisionSource', getRevisionSource), | ||||
| ('RevisionTag', getRevisionTag)] | ||||
| def __repr__(self): | ||||
| meta_atts = repr([(x[0], x[1](self)) for x in Object.__getters]) | ||||
| atts = repr(self.__dict__) | ||||
| return "Object(%s, %s)"%(atts, meta_atts) | ||||
| """ | ||||
| class SignatureException(Exception): | ||||
| """ Exception thrown when a data or method signature is unknown or invalid | ||||
| for a particular Object. """ | ||||
| def __init__(self, value): self.value = value | ||||
| def __str__(self): return repr(self.value) | ||||
| class _IDLTag(object): | ||||
| """ IDLTag (aka Interface Definition Language Tag) is an abstract helper class | ||||
| used by the Factory to define built-in tags used | ||||
| specifically for our IDL """ | ||||
| def __init__(self, yamlString): | ||||
| self.yamlString = yamlString | ||||
| def __repr__(self): | ||||
| return self.yamlString | ||||
| class _Reference(_IDLTag): | ||||
| """ Helper class for Factory: Objects can be composed | ||||
| of other objects, requiring a Reference to the other object. """ | ||||
| def __repr__(self): | ||||
| return "Ref(%s)"%(self.yamlString,) | ||||
| class _Method(_IDLTag): | ||||
| """ Helper class for Factory: Objects have methods | ||||
| associated with them - this tag tells the Factory that a method | ||||
| signature follows (in dict format) """ | ||||
| def __repr__(self): | ||||
| return "Method(%r)"%(self.yamlString,) | ||||
| class Binary(Object): | ||||
| def __init__(self, binary_type, value=None): | ||||
| self.binary_type = binary_type | ||||
| self.value = value | ||||
| import Lookup | ||||
| class BuiltinDtype(_IDLTag): | ||||
| """ Helper class for Factory: Object parameters each | ||||
| have a certain data type (either dtype.xxxx for numpy compatible data | ||||
| types, or one of the generic python data types (i.e. int, bool, str...) | ||||
| __addYamlConstructor in Factory registers all of the tags | ||||
| listed as keys in the dtypes dictionary.""" | ||||
| def __init__(self, yamlString, tag=None): | ||||
| self.tag = tag[1:] | ||||
| super(BuiltinDtype, self).__init__(yamlString) | ||||
| #print self.tag | ||||
| try: self.dtype = Lookup.numpy_dtypes[self.tag] | ||||
| except KeyError: self.dtype = Lookup.builtin_objects[self.tag] | ||||
| def __repr__(self): | ||||
| return "_BuiltinType(%s,%s)"%(self.yamlString, self.tag) | ||||
| # Register hexadecimal representation of numpy dtypes in YAML | ||||
| class _Parameter: | ||||
| """ Helper class for Factory: Contains the name, default | ||||
| value, and length (if an array) of an object initialization parameter. """ | ||||
| def __init__(self, name, hasDefault=False, default=None, length=None, classType=None): | ||||
| self.name = name | ||||
| self.hasDefault = hasDefault | ||||
| self.default = default | ||||
| self.length = length | ||||
| if isinstance(classType, None.__class__) and not isinstance(default, None.__class__): | ||||
| self.classType = default.__class__ | ||||
| else: | ||||
| self.classType = classType | ||||
| class _UnresolvedType: | ||||
| """ Used to indicate a data type which has not yet been parsed (i.e. for | ||||
| recursive data-types. """ | ||||
| def __init__(self, yamlObject): | ||||
| # Either the name of the class we couldn't resolve, or a dictionary | ||||
| # containing the name and a default value | ||||
| self.yamlObject = yamlObject | ||||
| class UnresolvedTypeException(Exception): | ||||
| """ Raised when a !ref tag is used, but the reference cannot be resolved """ | ||||
| pass | ||||
| def get_class(kls): | ||||
| """ Returns a pointer to the class instance with the name kls | ||||
| Function acquired from http://stackoverflow.com/questions/452969/ """ | ||||
| parts = kls.split('.') | ||||
| module = ".".join(parts[:-1]) | ||||
| m = __import__( module ) | ||||
| for comp in parts[1:]: | ||||
| m = getattr(m, comp) | ||||
| return m | ||||
| # Aliased constructor & representer adders for easily swapping between Ordered and non-Ordered: | ||||
| def add_constructor(tag, constructor): | ||||
| #yaml.add_constructor(tag, constructor) | ||||
| OrderedYAML.Loader.add_constructor(tag, constructor) | ||||
| def add_representer(cls, representer): | ||||
| #yaml.add_representer(cls, representer) | ||||
| OrderedYAML.Dumper.add_representer(cls, representer) | ||||
| # Implicit constructor for _Reference objects using the !ref tag: | ||||
| def __ref_constructor(loader, node): | ||||
| if isinstance(node, yaml.nodes.MappingNode): | ||||
| return _Reference(loader.construct_mapping(node)) | ||||
| else: | ||||
| return _Reference(loader.construct_scalar(node)) | ||||
| add_constructor(u'!ref', __ref_constructor) | ||||
| # Method constructor using !method tag: | ||||
| def __method_constructor(loader, node): | ||||
| if isinstance(node, yaml.nodes.MappingNode): | ||||
| return _Method(loader.construct_mapping(node)) | ||||
| else: | ||||
| return _Method(loader.construct_scalar(node)) | ||||
| add_constructor(u'!method', __method_constructor) | ||||
| # Generic constructor for any _BuiltinDtype | ||||
| def __dtype_constructor(loader, node): | ||||
| if isinstance(node, yaml.nodes.SequenceNode): | ||||
| ret = BuiltinDtype(loader.construct_sequence(node), tag=node.tag) | ||||
| elif isinstance(node, yaml.nodes.MappingNode): | ||||
| ret = BuiltinDtype(loader.construct_mapping(node), tag=node.tag) | ||||
| else: | ||||
| ret = BuiltinDtype(loader.construct_scalar(node), tag=node.tag) | ||||
| return ret | ||||
| # Register YAML constructors for each builtin type: | ||||
| for dtype in Lookup.numpy_dtypes.keys() + Lookup.builtin_objects.keys(): | ||||
| add_constructor(u'!%s'%(dtype,), __dtype_constructor) | ||||
| class FactoryLoader(OrderedYAML.Loader): | ||||
| """ A YAML Loader specifically designed to load YAML object definitions | ||||
| (as opposed to actual instances of the objects) """ | ||||
| def construct_yaml_timestamp(self, node): | ||||
| """ Make empty timestamps (None/null) acceptable, otherwise parse the timestamp """ | ||||
| if node.value == u'': | ||||
| name = 'YAML_DEFN_LOADED_INCORRECTLY' # in case we forget to fix the name... | ||||
| return _Parameter(name, hasDefault=False, classType=datetime.datetime) | ||||
| else: | ||||
| return yaml.constructor.SafeConstructor.construct_yaml_timestamp(self, node) | ||||
| # Override default timestamp constructor: | ||||
| FactoryLoader.add_constructor( | ||||
| u'tag:yaml.org,2002:timestamp', | ||||
| FactoryLoader.construct_yaml_timestamp | ||||
| ) | ||||
| import DynamicYAML | ||||
| class Factory: | ||||
| """ Load a YAML defined python class and create a class with initialization | ||||
| provided by this factory. This is intended as an abstract class to be sub-classed | ||||
| to enable complex initialization on object instantiation. | ||||
| Factory subclasses should override __buildClass().""" | ||||
| def __init__(self, dynamic_object=None, yaml=None, typeCheck='strong', parse=True, revision_dict=None): | ||||
| if revision_dict != None: self.revision_dict = revision_dict # Remember for when we build each individual class | ||||
| else: | ||||
| self.revision_dict = {\ | ||||
| "__revision_number": 0, | ||||
| "__revision_id": 'unknown', | ||||
| "__revision_source": 'unknown', | ||||
| "__revision_tag": 'unknown'} | ||||
| if parse: | ||||
| if dynamic_object: | ||||
| self.parse(dynamic_object, typeCheck=typeCheck) | ||||
| else: | ||||
| dyno = Object() | ||||
| dyno.yaml = yaml | ||||
| self.parse(dyno, typeCheck=typeCheck) | ||||
| def parse(self, dynamic_object, typeCheck='strong'): | ||||
| """ | ||||
| Initializer for a Factory, converting the given dynamic_object | ||||
| containing a (text) YAML object definition into the corresponding class-type | ||||
| with initializer. | ||||
| typeCheck parameter can be one of 'strong' or 'cast': | ||||
| 'strong': Class initializer should raise a TypeError when given | ||||
| anything but the correct type | ||||
| 'cast': Class initializer should attempt to cast any input to the correct type | ||||
| """ | ||||
| # Remember what kind of type-checking to do: | ||||
| if typeCheck not in ['strong', 'cast']: | ||||
| raise Exception('Incorrect input for typeCheck: %s\nExpected "strong" or "cast"'%(typeCheck)) | ||||
| self.typeCheck = typeCheck | ||||
| # Get a list of the objects to build: | ||||
| if isinstance(dynamic_object.yaml, list): | ||||
| objects = dynamic_object.yaml | ||||
| else: | ||||
| objects = [dynamic_object] | ||||
| # Generate a dictionary of classes from the DynamicObjects given: | ||||
| self.classes = dict() | ||||
| for obj in objects: | ||||
| # This loader breaks nothing anymore #everything currently | ||||
| loader = FactoryLoader(obj.yaml) | ||||
| #loader = yaml.Loader(obj.yaml) | ||||
| # Dictionary with method and data signatures for the current object: | ||||
| objDefn = [] | ||||
| while loader.check_data(): | ||||
| objDefn.append(loader.get_data()) | ||||
| loader.dispose() | ||||
| # Parse the dictionary into a class definition: | ||||
| objClass = self.__buildClass(objDefn) | ||||
| self.classes.update(objClass) | ||||
| def parseMethodSignature(self, sigName, methDict): | ||||
| """ Returns the python method corresponding to the given signature | ||||
| (given signature should be in the loaded YAML dict format. | ||||
| Override this method for recognizing complex method signatures. """ | ||||
| raise SignatureException("Object abstract base class doesn't support any method signatures.") | ||||
| def parseDataSignature(self, sigName, sig): | ||||
| """ Returns the Parameter object corresponding to the given signature. | ||||
| This method should be overridden for recognizing complex data signatures | ||||
| (don't forget to call super(sig) for built-in data types though!) """ | ||||
| # Is the object an array with explicit default elements?: | ||||
| if isinstance(sig.yamlString, list): | ||||
| #length = len(sig.yamlString) | ||||
| if 'dtype' in sig.tag: | ||||
| default = np.array(sig.yamlString, dtype=sig.dtype) | ||||
| elif 'binary' == sig.tag: | ||||
| default = Binary(sig.yamlString["type"]) | ||||
| else: | ||||
| default = sig.yamlString | ||||
| return _Parameter(sigName, True, default, length=None) | ||||
| # Is the object an array with length and default value given?: | ||||
| if isinstance(sig.yamlString, dict) and "len" in sig.yamlString.keys(): | ||||
| length = sig.yamlString["len"] | ||||
| # Shape is given as something like [[],[]], not [2,2] - convert | ||||
| if isinstance(length, list): | ||||
| def get_shape(lst): | ||||
| """ Gets the shape of a list recursively filled with empty lists """ | ||||
| if lst == []: return [0] | ||||
| return [len(lst)] + get_shape(lst[0]) | ||||
| if len(length) > 0: | ||||
| if isinstance(length[0], list): | ||||
| length = get_shape(length) | ||||
| else: | ||||
| pass | ||||
| else: | ||||
| length = [0] # convert [] to [0] (numpy interprets [] as [1] for shapes) | ||||
| if 'complex' in sig.tag: | ||||
| imag = sig.yamlString["default"]["imag"] | ||||
| real = sig.yamlString["default"]["real"] | ||||
| default = sig.dtype(real) + sig.dtype(imag*1j) | ||||
| elif 'binary' == sig.tag: | ||||
| default = Binary(sig.yamlString["type"]) | ||||
| else: | ||||
| default = sig.dtype(sig.yamlString["default"]) | ||||
| return _Parameter(sigName, True, default, length) | ||||
| # The object is singular, with a given value: | ||||
| if 'complex' in sig.tag: | ||||
| imag = sig.yamlString["imag"] | ||||
| real = sig.yamlString["real"] | ||||
| default = sig.dtype(real) + sig.dtype(imag*1j) | ||||
| return _Parameter(sigName, True, default) | ||||
| elif 'binary' == sig.tag: | ||||
| default = Binary(sig.yamlString["type"]) | ||||
| return _Parameter(sigName, False, default, classType=Binary) | ||||
| elif 'timestamp' in sig.tag: | ||||
| if isinstance(sig.yamlString, dict): | ||||
| if sig.tag in ['timestamp_picosecond', 'timestamp_ps']: | ||||
| try: s = sig.yamlString['second'] | ||||
| except KeyError: s = sig.yamlString['s'] | ||||
| try: ps = sig.yamlString['picosecond'] | ||||
| except KeyError: ps = sig.yamlString['ps'] | ||||
| return _Parameter(sigName, True, PrecisionTime.psTime(s, ps)) | ||||
| elif sig.tag in ['timestamp_nanosecond', 'timestamp_ns']: | ||||
| try: s = sig.yamlString['second'] | ||||
| except KeyError: s = sig.yamlString['s'] | ||||
| try: ns = sig.yamlString['nanosecond'] | ||||
| except KeyError: ns = sig.yamlString['ns'] | ||||
| return _Parameter(sigName, True, PrecisionTime.nsTime(s, ns)) | ||||
| else: | ||||
| if sig.tag in ['timestamp_picosecond', 'timestamp_ps']: | ||||
| return _Parameter(sigName, False, classType=PrecisionTime.psTime) | ||||
| elif sig.tag in ['timestamp_nanosecond', 'timestamp_ns']: | ||||
| return _Parameter(sigName, False, classType=PrecisionTime.nsTime) | ||||
| else: | ||||
| default = sig.dtype(sig.yamlString) | ||||
| return _Parameter(sigName, True, default) # not binary | ||||
| def __parsePythonType(self, sigName, sig): | ||||
| """ Returns a _Parameter object, similar to parseDataSignature, but | ||||
| for a basic python type. """ | ||||
| if isinstance(sig, collections.OrderedDict): | ||||
| default = dict(sig) # Type-check user-defined !!maps as dicts, not OrderedDicts. | ||||
| else: | ||||
| default = sig # The signature sig is the default value itself | ||||
| return _Parameter(sigName, True, default) | ||||
| def __parseReferenceSignature(self, sigName, ref_object, objClasses): | ||||
| """ Takes a reference object ref_object to be named sigName, and | ||||
| produces a _Parameter object with default value of None. """ | ||||
| # List of names of classes we've created so far: | ||||
| #print [x for x in objClasses] | ||||
| names = objClasses.keys() | ||||
| if ref_object.yamlString in names: | ||||
| defaultType = objClasses[ref_object.yamlString] | ||||
| return _Parameter(sigName, classType=defaultType) | ||||
| else: | ||||
| try: | ||||
| # Try to find the class type in globals: | ||||
| className = objClasses[str(ref_object.yamlString)] | ||||
| defaultType = get_class(className) | ||||
| except (ValueError, KeyError): | ||||
| defaultType = _UnresolvedType(ref_object.yamlString) | ||||
| #raise NameError("Invalid reference to module %s"%(className,)) | ||||
| return _Parameter(sigName, classType=defaultType) | ||||
| def __buildInitializer(self, className, classData): | ||||
| """ Constructs the initializer for an object which expects parameters | ||||
| listed in classData as input upon initialization. """ | ||||
| # Type of type-checking to use: | ||||
| strong = (self.typeCheck == 'strong') | ||||
| #cast = (self.typeCheck == 'cast') | ||||
| def typeCheck(param, arg): | ||||
| """ | ||||
| Checks to see if the type of arg matches that of the corresponding param, | ||||
| casting arg to the correct type if desired. | ||||
| """ | ||||
| if isinstance(arg, param.classType): return arg | ||||
| if isinstance(arg, np.ndarray) and arg.dtype.type == param.classType: | ||||
| if not param.hasDefault: return arg | ||||
| if param.default.shape == (): return arg | ||||
| if param.default.shape[-1] == 0: return arg | ||||
| if arg.shape == param.default.shape: return arg | ||||
| if isinstance(arg, None.__class__): return arg | ||||
| if strong: | ||||
| raise TypeError("Incorrect input type on strong type-checking."+\ | ||||
| " Expected %s - got %s"%(param.classType,arg.__class__)) | ||||
| else: | ||||
| # If the parameter corresponding to the given argument has a non-NoneType default | ||||
| # value, then attempt to cast the argument into the correct parameter type | ||||
| if param.hasDefault and param.default != None: | ||||
| if isinstance(param.default, np.ndarray): | ||||
| return np.array(arg, dtype=param.default.dtype) | ||||
| else: | ||||
| return param.default.__class__(arg) | ||||
| else: | ||||
| return param.classType(arg) | ||||
| """ | ||||
| attributes = {"__object_name": className, | ||||
| "__revision_number": self.svn_revision_number, | ||||
| "__revision_id": 'unknown', | ||||
| "__revision_source": 'unknown', | ||||
| "__revision_tag": 'unknown'} | ||||
| """ | ||||
| attributes = {} # Create new attributes dict for this particular class object | ||||
| attributes.update(self.revision_dict) # Revision info now passed into the factory | ||||
| attributes['__object_name'] = className | ||||
| def init(_self, *args, **kwargs): | ||||
| """ Dynamically generated initializer. """ | ||||
| # meta-data goes in the class, not the objects (commented the following out): | ||||
| """ | ||||
| # Initialize automatic class data | ||||
| for attr,value in attributes.items(): | ||||
| try: | ||||
| value = kwargs[attr] # Are we given a value to over-ride with? | ||||
| del kwargs[attr] # Ignore the meta attribute later | ||||
| except KeyError: | ||||
| pass | ||||
| setattr(_self, attr, value) | ||||
| """ | ||||
| # Set default values first (assume no parameters): | ||||
| for param in classData: | ||||
| if param.length: | ||||
| if isinstance(param.length, int): param.length = [param.length] | ||||
| default = np.empty(param.length, dtype=param.classType) | ||||
| if param.hasDefault: | ||||
| # Initialize array with default array value given: | ||||
| flatIter = default.flat | ||||
| for i in range(len(flatIter)): | ||||
| flatIter[i] = copy.deepcopy(param.default) | ||||
| else: | ||||
| # Initialize to None if no default given: | ||||
| default.fill(None) | ||||
| else: | ||||
| default = param.default | ||||
| setattr(_self, param.name, copy.deepcopy(default)) | ||||
| # Set attributes given by standard args: | ||||
| for i in range(len(args)): | ||||
| arg = typeCheck(classData[i], args[i]) | ||||
| setattr(_self, classData[i].name, arg) | ||||
| # Set named attributes (given by dictionary kwargs): | ||||
| for key,value in kwargs.items(): | ||||
| try: keyIndex = [param.name for param in classData].index(key) | ||||
| except ValueError: | ||||
| raise TypeError("'%s' is an invalid keyword argument"%(key,)) | ||||
| arg = typeCheck(classData[keyIndex],value) | ||||
| #setattr(_self, key, value) | ||||
| setattr(_self, key, arg) | ||||
| # Object instantiation / creation time (if not already present): | ||||
| if not kwargs.has_key('__time_created'): | ||||
| setattr(_self, "__time_created", np.float64(time.time())) | ||||
| return init, attributes | ||||
| def __findClass(self, className, localClasses): | ||||
| """ Looks for the given className first in the given dictionary of localClasses | ||||
| then in the global definitions, returning the corresponding class object. Raises | ||||
| a KeyError if the class cannot be found. """ | ||||
| # If class definition was in the YAML file, extend that one: | ||||
| if className in localClasses.keys(): | ||||
| return localClasses[className] | ||||
| # Else try finding the class definition in our global scope: | ||||
| try: classObj = get_class(className) | ||||
| except KeyError: | ||||
| raise KeyError("Class '%s' not found in given YAML scope or global scope."%(className,)) | ||||
| return classObj | ||||
| def __buildClass(self, objDefn): | ||||
| """ Takes an object definition list / dictionary objDefn (loaded from a YAML | ||||
| object definition file) and creates a class, dynamically binding | ||||
| method and data signatures to the new class. | ||||
| This method only performs a basic binding of method and data signatures to | ||||
| the new class. Object(s) having more complex initialization requirements | ||||
| should be given their own Factory subclass, overriding this | ||||
| and other methods.""" | ||||
| # objDefn is a list of dictionaries found in the YAML file - build each one... | ||||
| objClasses = dict() | ||||
| objClassesRev = dict() | ||||
| # A list of all _Parameter objects created, used to resolve recursive | ||||
| # or "tangled" data structures | ||||
| allClassData = [] | ||||
| for document in objDefn: | ||||
| # Each document can contain multiple objects - build each one. | ||||
| # (NOTE: objects can cross reference each other in the same document | ||||
| # need to resolve Reference objects as last step) | ||||
| for objClassName in document.keys(): | ||||
| # The dictionary containing method & data signatures: | ||||
| objDict = document[objClassName] | ||||
| # Extract data / attribute definitions (signatures) from the YAML dictionary | ||||
| # as well as method signatures and which classes this class extends: | ||||
| classData = [] | ||||
| classMethods = dict() | ||||
| classBases = [Object] | ||||
| # List structured documents result in a list of dicts each with one key: | ||||
| if isinstance(objDict, list): keys = [param.keys()[0] for param in objDict] | ||||
| # Otherwise the parameter names are just the keys of the dict | ||||
| else: keys = objDict.keys() # if key not found, raises AttributeError | ||||
| for sigName in keys: | ||||
| #print sigName | ||||
| sig = objDict[sigName] | ||||
| #for f in _BuiltinDtype.python_dtypes: print f.__class__ | ||||
| if sigName == '__extends': | ||||
| if isinstance(sig, str): | ||||
| sig = [sig] | ||||
| if isinstance(sig, list): | ||||
| for className in sig: | ||||
| newBase = self.__findClass(className, objClasses) | ||||
| # Remove Object extension if newBase extends it already: | ||||
| if Object in classBases and Object in inspect.getmro(newBase): | ||||
| classBases.remove(Object) | ||||
| classBases += [newBase] | ||||
| else: | ||||
| raise TypeError("Incorrect format for extending classes - %s"%(sig,)) | ||||
| elif isinstance(sig, BuiltinDtype): | ||||
| classData.append(self.parseDataSignature(sigName, sig)) | ||||
| elif isinstance(sig, Lookup.python_dtypes): | ||||
| classData.append(self.__parsePythonType(sigName, sig)) | ||||
| elif isinstance(sig, _Reference): | ||||
| classData.append(self.__parseReferenceSignature(sigName, sig, objClasses)) | ||||
| elif isinstance(sig, _Method): | ||||
| classMethods[sigName] = self.parseMethodSignature(sigName, sig.yamlString) | ||||
| elif isinstance(sig, (PrecisionTime.nsTime, PrecisionTime.psTime)): | ||||
| classData.append(_Parameter(sigName, True, sig)) | ||||
| elif isinstance(sig, _Parameter): # sig is already a parameter (we skipped a step) | ||||
| sig.name = sigName # we didn't know the name during load time - fill that in now | ||||
| classData.append(sig) | ||||
| else: | ||||
| msg = "Factory abstract base class doesn't " +\ | ||||
| "support the following signature: %r \"%s\""%(sig.__class__,str(sig)) | ||||
| print sig.__class__ | ||||
| raise SignatureException(msg) | ||||
| # Built-in attribute for all Dynamic Objects: | ||||
| classData.append(_Parameter('__time_created', classType=np.float64)) | ||||
| # Turn the object data / attributes into a usable __init__ method: | ||||
| classMethods["__init__"], meta_attributes = self.__buildInitializer(objClassName, classData) | ||||
| # Keep a record of the _Parameters created for later type resolution | ||||
| allClassData.extend(classData) | ||||
| """ | ||||
| __automaticMethods = { | ||||
| "getObjectName": lambda _self: getattr(_self, '__object_name'), | ||||
| "getRevisionNumber": lambda _self: getattr(_self, '__revision_number'), | ||||
| "getRevisionId": lambda _self: getattr(_self, '__revision_id'), | ||||
| "getRevisionSource": lambda _self: getattr(_self, '__revision_source'), | ||||
| "getRevisionTag": lambda _self: getattr(_self, '__revision_tag') | ||||
| } | ||||
| classMethods.update(__automaticMethods) | ||||
| """ | ||||
| # Put the method signatures into a namespace for the new class, | ||||
| # then dynamically build the class from this namespace. | ||||
| classNamespace = classMethods | ||||
| classNamespace["meta_attributes"] = meta_attributes | ||||
| cls = type(str(objClassName), tuple(classBases), classNamespace) | ||||
| objClasses[objClassName] = cls | ||||
| objClassesRev['%s.%s'%(objClassName,cls.meta_attributes["__revision_number"])] = cls | ||||
| # Create and register a constructor (loading) and representer (dumping) for the new class cls | ||||
| def construct_dynamic_object(loader, node): | ||||
| kwargs = loader.construct_mapping(node) | ||||
| # Remove revision control from loaded objects (info is in the class object!) | ||||
| for arg in kwargs.keys(): | ||||
| if arg in getattr(Object, 'getters') and arg != '__time_created': | ||||
| del kwargs[arg] | ||||
| return cls(**kwargs) | ||||
| revision = cls.meta_attributes["__revision_number"] | ||||
| DynamicYAML.Loader.add_constructor(u'!%s.%s'%(str(objClassName),revision), construct_dynamic_object) | ||||
| represent_dynamic_object = DynamicYAML.Dumper.represent_dynamic_object | ||||
| DynamicYAML.Dumper.add_representer(cls, represent_dynamic_object) | ||||
| def findClass(className): | ||||
| """ Search for the most recently added class object with given className """ | ||||
| try: | ||||
| return objClasses[className] # Look for reference to object in same YAML defn file: | ||||
| except KeyError: | ||||
| # Now look for reference to class object loaded from any YAML defn file, loading the | ||||
| # most recent version / revision (number) of the definition | ||||
| for dynClass in Object.dynamicClasses.keys()[::-1]: | ||||
| if dynClass.startswith(className): | ||||
| return Object.dynamicClasses[dynClass] | ||||
| # Still unresolved - raise exception: | ||||
| allDynamicClasses = repr(objClasses.keys() + Object.dynamicClasses.keys()) | ||||
| raise UnresolvedTypeException("Cannot resolve type '%s': Name not found in %s"%(className,allDynamicClasses)) | ||||
| def resolve(param): | ||||
| # Reference is just a string - that's the class name: | ||||
| if isinstance(param.classType.yamlObject, (str, unicode)): | ||||
| className = str(param.classType.yamlObject) | ||||
| param.classType = findClass(className) | ||||
| return | ||||
| # Reference is a dict containing class name and / or default values: | ||||
| if not isinstance(param.classType.yamlObject, dict): | ||||
| raise UnresolvedTypeException("Cannot resolve reference of type '%s'"%(param.classType.yamlObject.__class__,)) | ||||
| # Definitely a dict: | ||||
| refDict = param.classType.yamlObject | ||||
| # Determine the name of the class being referenced | ||||
| try: | ||||
| className = refDict["type"] | ||||
| except KeyError: | ||||
| raise KeyError("No 'type' key in reference dictionary for parameter '%s'"%(param.name,)) | ||||
| # Determine the class object corresponding to the class name | ||||
| param.classType = findClass(className) | ||||
| try: | ||||
| defaultParams = refDict["default"] | ||||
| except KeyError: | ||||
| defaultParams = None | ||||
| if defaultParams != None: | ||||
| for sub_param in defaultParams: | ||||
| if isinstance(sub_param.classType, _UnresolvedType): | ||||
| resolve(sub_param) | ||||
| param.default = param.classType( **defaultParams ) # Create the default object | ||||
| param.hasDefault = True | ||||
| else: | ||||
| param.hasDefault = False # for good measure | ||||
| # Is it an object array?: | ||||
| if "len" in refDict.keys(): | ||||
| param.length = refDict["len"] | ||||
| # Resolve any unresolved data-types: | ||||
| for param in allClassData: | ||||
| if isinstance(param.classType, _UnresolvedType): | ||||
| resolve(param) | ||||
| Object.dynamicClasses.update(objClassesRev) | ||||
| return objClasses | ||||
| def load_defn(yaml): | ||||
| """ Shortcut for producing a single DynamicObject class object from | ||||
| the provided yaml definition in string format """ | ||||
| return Factory(yaml=yaml).classes.values()[0] | ||||