def __init__(self, specification, mixin_modules=None, mixin_classes=None, binding_module='mesh.standard.python'): if isinstance(specification, basestring): specification = import_object(specification) if isinstance(specification, Bundle): specification = specification.specify() elif not isinstance(specification, Specification): specification = Specification(specification) if isinstance(binding_module, basestring): binding_module = import_object(binding_module) self.cache = {} self.binding_module = binding_module self.mixins = {} self.specification = specification if mixin_classes: for mixin_class in mixin_classes: self._associate_mixin_class(mixin_class) if mixin_modules: self._enumerate_mixin_classes(mixin_modules)
def construct(self, bundle): """Constructs this mount for ``bundle``.""" resource = self.resource if isinstance(resource, basestring): resource = self.resource = import_object(resource, True) if not resource: return False controller = self.controller if isinstance(controller, basestring): try: controller = import_object(controller) except Exception: log('exception', 'failed to import %r for %r', controller, bundle.name) controller = None if not controller: controller = resource.configuration.create_controller(resource) self.controller = controller self.min_version = self._validate_version(resource, controller, self.min_version, 'minimum_version') self.max_version = self._validate_version(resource, controller, self.max_version, 'maximum_version') self.versions = [] for candidate in controller.versions.keys(): if candidate >= self.min_version and candidate <= self.max_version: self.versions.append(candidate) self.versions.sort() return True
def _enumerate_mixin_classes(self, modules): if isinstance(modules, basestring): modules = modules.split(' ') for name in modules: module = import_object(name) for attr in dir(module): self._associate_mixin_class(getattr(module, attr))
def generate_dynamically(self, bundle): if isinstance(bundle, basestring): bundle = import_object(bundle) source = self._generate_binding(bundle) module = new_module(bundle.name) exec source in module.__dict__ return module
def bind(binding, name, mixin_modules=None): if isinstance(binding, basestring): binding = import_object(binding) if isinstance(binding, ModuleType): binding = getattr(binding, 'binding', None) if isinstance(binding, Bundle): binding = binding.specify() if isinstance(binding, (Specification, dict)): binding = Binding(binding, mixin_modules) if not isinstance(binding, Binding): raise TypeError(binding) return binding.generate(name)
def _generate_mixins(self): if not self.mixin_modules: return '', '' mixins = [] mixin_classes = [] for name in self.mixin_modules: module = import_object(name) for attr in dir(module): value = getattr(module, attr) try: targets = value.mixin except Exception: continue mixins.append(getsource(value)) mixin_classes.append(attr) return '\n'.join(mixins), ', '.join(mixin_classes)
def bind(binding, name, mixin_modules=None): """Generates a client binding for the resource identified by ``name``, using the resource definition specified by ``binding``. :param binding: The resource bundle to bind, specified as either: (a) a binding module, either pre-generated or generated through the import of a .mesh file; (b) a :class:`mesh.bundle.Bundle` instance; (c) a serialized description of a bundle, as a ``dict``; (d) a :class:`mesh.bundle.Specification` instance; or (e) a ``str`` containing the full package path to one of the above. :param str name: The mesh designation of either a specific versioned resource (i.e., ``'bundle/1.0/resource'``) or a specific bundle version (``'bundle/1.0'``) to bind. :param list mixin_modules: Optional, default is ``None``; if specified, indicates one or more modules which can provide mixin functionality to the generated binding. """ try: provide_binding = binding._provide_binding except AttributeError: pass else: return Binding(provide_binding(), mixin_modules).generate(name) if isinstance(binding, basestring): binding = import_object(binding) if isinstance(binding, ModuleType): binding = getattr(binding, 'binding', None) elif isinstance(binding, Bundle): binding = binding.specify() if isinstance(binding, (Specification, dict)): binding = Binding(binding, mixin_modules) if isinstance(binding, Binding): return binding.generate(name) else: raise TypeError(binding)
def generate(self, bundle): if isinstance(bundle, basestring): bundle = import_object(bundle) source = self._generate_binding(bundle) return '%s.py' % bundle.name, source