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 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 _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 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 __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 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 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 _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
def generate(self, bundle):
if isinstance(bundle, basestring):
bundle = import_object(bundle)
source = self._generate_binding(bundle)
return '%s.py' % bundle.name, source
