def property_set_value(context, property_, object_, value): if object_ is None: helpers.get_executor().set_static_property( property_.declaring_type, name=property_.name, value=value, context=context) else: object_.cast(property_.declaring_type).set_property( name=property_.name, value=value, context=context)
def extension_payload(__context, __receiver, *args, **kwargs): executor = helpers.get_executor(__context) args = tuple(dsl.to_mutable(arg, engine) for arg in args) kwargs = dsl.to_mutable(kwargs, engine) return helpers.evaluate(murano_method.invoke( executor, murano_method.declaring_type, (__receiver,) + args, kwargs, __context, True), __context)
def op_dot(context, sender, expr, operator): executor = helpers.get_executor(context) type_context = executor.context_manager.create_class_context(sender.type) obj_context = executor.context_manager.create_object_context(sender) ctx2 = linked_context.link(linked_context.link(context, type_context), obj_context) return operator(ctx2, sender, expr)
def op_dot(context, receiver, expr, operator): executor = helpers.get_executor() type_context = executor.context_manager.create_type_context(receiver.type) obj_context = executor.context_manager.create_object_context(receiver) ctx2 = helpers.link_contexts(helpers.link_contexts(context, type_context), obj_context) return operator(ctx2, receiver, expr)
def __init__(self, murano_class, owner, object_id=None, name=None, known_classes=None, this=None, metadata=None): self._initialized = False self._destroyed = False if known_classes is None: known_classes = {} if this is None: self._owner = owner self._object_id = object_id or helpers.generate_id() self._type = murano_class self._properties = {} self._parents = {} self._this = this self._name = name self._extension = None self._executor = helpers.weak_ref(helpers.get_executor()) self._config = murano_class.package.get_class_config( murano_class.name) self._metadata = metadata if not isinstance(self._config, dict): self._config = {} known_classes[murano_class.name] = self for parent_class in murano_class.parents: name = parent_class.name if name not in known_classes: obj = MuranoObject( parent_class, owner, object_id=self._object_id, known_classes=known_classes, this=self.real_this) self._parents[name] = known_classes[name] = obj else: self._parents[name] = known_classes[name] self._destruction_dependencies = []
def convert(self, value, sender, context, function_spec, engine, *args, **kwargs): this = helpers.get_this(context) if isinstance(this, dsl_types.MuranoObject): executor = helpers.get_executor(context) return MuranoObjectInterface(this, executor) return this
def create_stack_trace(context, include_native_frames=True): stacktrace = yaql_integration.call_func( context, 'new', 'io.murano.StackTrace', includeNativeFrames=include_native_frames) executor = helpers.get_executor(context) return dsl.MuranoObjectInterface( stacktrace, executor)
def get_meta(self, context): if self._meta_values is None: executor = helpers.get_executor() context = executor.create_type_context( self, caller_context=context) self._meta_values = dslmeta.merge_providers( self, lambda cls: cls._meta, context) return self._meta_values
def create_stack_trace(context, include_native_frames=True): stacktrace = yaql_integration.call_func( context, 'new', 'io.murano.StackTrace', includeNativeFrames=include_native_frames) executor = helpers.get_executor(context) return dsl.MuranoObjectInterface(stacktrace, executor)
def op_dot(context, sender, expr, operator): executor = helpers.get_executor(context) type_context = executor.context_manager.create_class_context(sender.type) obj_context = executor.context_manager.create_object_context(sender) ctx2 = linked_context.link( linked_context.link(context, type_context), obj_context) return operator(ctx2, sender, expr)
def new(__context, __type_name, __owner=None, __object_name=None, __extra=None, **parameters): object_store = helpers.get_object_store(__context) executor = helpers.get_executor(__context) new_context = __context.create_child_context() for key, value in six.iteritems(parameters): if utils.is_keyword(key): new_context[key] = value return __type_name.murano_class.new(__owner, object_store, executor, name=__object_name)(new_context, **parameters)
def get_meta(self, context): if self._meta is None: executor = helpers.get_executor(context) store = object_store.ObjectStore(executor) self._meta = list(map( lambda x: x(context, store), self._meta_factories)) return self._meta
def op_dot(context, receiver, expr, operator): executor = helpers.get_executor() type_context = executor.context_manager.create_type_context(receiver.type) obj_context = executor.context_manager.create_object_context(receiver) ctx2 = helpers.link_contexts( helpers.link_contexts(context, type_context), obj_context) return operator(ctx2, receiver, expr)
def dump(obj, serialization_type=serializer.DumpTypes.Serializable, ignore_upcasts=True): if serialization_type not in serializer.DumpTypes.All: raise ValueError('Invalid Serialization Type') executor = helpers.get_executor() if ignore_upcasts: obj = obj.real_this return serializer.serialize(obj, executor, serialization_type)
def invoke(context, this, *args): try: executor = helpers.get_executor(context) murano_class = helpers.get_type(context) return executor.invoke_method(name, this, context, murano_class, *args) except exceptions.NoMethodFound: raise yaql.exceptions.YaqlExecutionException() except exceptions.AmbiguousMethodName: raise yaql.exceptions.YaqlExecutionException()
def __getattr__(self, item): executor = self.__executor or helpers.get_executor() def func(*args, **kwargs): self._insert_instruction() return self.__object.type.invoke( item, executor, self.__object, args, kwargs, helpers.get_context()) return func
def dump(obj, serialization_type=dsl_types.DumpTypes.Serializable, ignore_upcasts=True): if serialization_type not in dsl_types.DumpTypes.All: raise ValueError('Invalid Serialization Type') executor = helpers.get_executor() if ignore_upcasts: obj = obj.real_this return serializer.serialize(obj, executor, serialization_type)
def __getattr__(self, item): executor = self.__executor or helpers.get_executor() def func(*args, **kwargs): self._insert_instruction() return self.__object.type.invoke(item, executor, self.__object, args, kwargs, helpers.get_context()) return func
def new(__context, __type_name, __owner=None, __object_name=None, __extra=None, **parameters): object_store = helpers.get_object_store(__context) executor = helpers.get_executor(__context) new_context = __context.create_child_context() for key, value in six.iteritems(parameters): if utils.is_keyword(key): new_context[key] = value return __type_name.type.new( __owner, object_store, executor, name=__object_name)( new_context, **parameters)
def setter(src_property, value): src = src_property.get() if isinstance(src, utils.MappingType): src_property.set( utils.FrozenDict( itertools.chain(six.iteritems(src), ((key, value), )))) elif isinstance(src, dsl_types.MuranoObject): src.set_property(key, value, context['#root_context']) elif isinstance( src, (dsl_types.MuranoTypeReference, dsl_types.MuranoType)): if isinstance(src, dsl_types.MuranoTypeReference): mc = src.type else: mc = src helpers.get_executor().set_static_property( mc, key, value, context['#root_context']) else: raise ValueError('attribution may only be applied to ' 'objects and dictionaries')
def validate(self, value, this, owner, context, default=None): if default is None: default = self.default executor = helpers.get_executor(context) if isinstance(this, dsl_types.MuranoClass): return self._contract( value, executor.create_object_context(this), None, None, default) else: return self._contract( value, executor.create_object_context( this.cast(self._container_class())), this, owner, default)
def transform(self, value, this, owner, context, default=None): if default is None: default = self.default executor = helpers.get_executor(context) if isinstance(this, dsl_types.MuranoType): return self._contract.transform( value, executor.create_object_context(this), None, None, default, helpers.get_type(context)) else: return self._contract.transform( value, executor.create_object_context( this.cast(self._container_type())), this, owner, default, helpers.get_type(context))
def get_meta(self, context): def meta_producer(cls): method = cls.methods.get(self.name) if method is None: return None return method._meta if self._meta_values is None: executor = helpers.get_executor(context) context = executor.create_type_context( self.declaring_type, caller_context=context) self._meta_values = meta.merge_providers( self.declaring_type, meta_producer, context) return self._meta_values
def get_meta(self, context): def meta_producer(cls): method = cls.methods.get(self.name) if method is None: return None return method._meta if self._meta_values is None: executor = helpers.get_executor() context = executor.create_type_context(self.declaring_type, caller_context=context) self._meta_values = meta.merge_providers(self.declaring_type, meta_producer, context) return self._meta_values
def invoke(self, this, args, kwargs, context=None, skip_stub=False): if isinstance(this, dsl.MuranoObjectInterface): this = this.object if this and not self.declaring_type.is_compatible(this): raise Exception("'this' must be of compatible type") if not this and not self.is_static: raise Exception("A class instance is required") if isinstance(this, dsl_types.MuranoObject): this = this.cast(self.declaring_type) else: this = self.declaring_type executor = helpers.get_executor() return executor.invoke_method( self, this, context, args, kwargs, skip_stub)
def invoke(self, this, args, kwargs, context=None, skip_stub=False): if isinstance(this, dsl.MuranoObjectInterface): this = this.object if this and not self.declaring_type.is_compatible(this): raise Exception("'this' must be of compatible type") if not this and not self.is_static: raise Exception("A class instance is required") if isinstance(this, dsl_types.MuranoObject): this = this.cast(self.declaring_type) else: this = self.declaring_type executor = helpers.get_executor() return executor.invoke_method(self, this, context, args, kwargs, skip_stub)
def load(self, value, owner, context, defaults=None): if value is None: return None if '?' not in value or 'type' not in value['?']: raise ValueError() system_key = value['?'] object_id = system_key['id'] obj_type = system_key['type'] class_obj = self._class_loader.get_class(obj_type) if not class_obj: raise ValueError() if object_id in self._store: obj = self._store[object_id] else: obj = class_obj.new(owner, self, context=context, object_id=object_id, defaults=defaults) self._store[object_id] = obj self._designer_attributes_store[object_id] = \ ObjectStore._get_designer_attributes(system_key) argspec = inspect.getargspec(obj.initialize).args if '_context' in argspec: value['_context'] = context if '_parent' in argspec: value['_owner'] = owner try: if owner is None: self._initializing = True obj.initialize(**value) if owner is None: self._initializing = False obj.initialize(**value) finally: if owner is None: self._initializing = False if not self.initializing: executor = helpers.get_executor(context) methods = obj.type.find_all_methods('initialize') methods.reverse() for method in methods: method.invoke(executor, obj, {}) return obj
def set_property(self, name, value, context=None): if self is not self.real_this: return self.real_this.set_property(name, value, context) start_type, derived = self.__type, False caller_class = None if not context else helpers.get_type(context) if caller_class is not None and caller_class.is_compatible(self): start_type, derived = caller_class, True declared_properties = start_type.find_properties( lambda p: p.name == name) if context is None: context = helpers.get_executor().create_object_context(self) if len(declared_properties) > 0: values_to_assign = [] classes_for_static_properties = [] first = True for spec in self._list_properties(name): if (caller_class is not None and not helpers.are_property_modifications_allowed(context) and (spec.usage not in dsl_types.PropertyUsages.Writable or not derived)): raise exceptions.NoWriteAccessError(name) if spec.usage == dsl_types.PropertyUsages.Static: classes_for_static_properties.append(spec.declaring_type) else: default = self.__config.get(name, spec.default) obj = self.cast(spec.declaring_type) res = spec.transform(value, self.real_this, self.real_this, context, default=default) if first: value = res first = False values_to_assign.append((obj, res)) for obj, value in values_to_assign: obj.__properties[name] = value for cls in classes_for_static_properties: cls.set_property(name, value, context) elif derived: obj = self.cast(caller_class) obj.__properties[name] = value else: raise exceptions.PropertyWriteError(name, start_type)
def load(self, value, parent, context, defaults=None): #tmp_store = ObjectStore(self._class_loader, self) if value is None: return None if '?' not in value or 'type' not in value['?']: raise ValueError() system_key = value['?'] object_id = system_key['id'] obj_type = system_key['type'] class_obj = self._class_loader.get_class(obj_type) if not class_obj: raise ValueError() if object_id in self._store: obj = self._store[object_id] else: obj = class_obj.new(parent, self, context=context, object_id=object_id, defaults=defaults) self._store[object_id] = obj self._designer_attributes_store[object_id] = \ ObjectStore._get_designer_attributes(system_key) argspec = inspect.getargspec(obj.initialize).args if '_context' in argspec: value['_context'] = context if '_parent' in argspec: value['_parent'] = parent try: if parent is None: self._initializing = True obj.initialize(**value) if parent is None: self._initializing = False obj.initialize(**value) finally: if parent is None: self._initializing = False if not self.initializing: executor = helpers.get_executor(context) methods = obj.type.find_all_methods('initialize') methods.reverse() for method in methods: method.invoke(executor, obj, {}) return obj
def inject_method_with_str(context, target, target_method, mock_object, mock_name): ctx_manager = helpers.get_executor().context_manager current_class = helpers.get_type(context) mock_func = current_class.find_single_method(mock_name) original_class = target.type original_function = original_class.find_single_method(target_method) result_fd = original_function.instance_stub.clone() def payload_adapter(__context, __sender, *args, **kwargs): return mock_func.invoke(mock_object, args, kwargs, __context, True) result_fd.payload = payload_adapter existing_mocks = ctx_manager.class_mock_ctx.setdefault( original_class.name, []) existing_mocks.append(result_fd)
def inject_method_with_str(context, target, target_method, mock_object, mock_name): ctx_manager = helpers.get_executor().context_manager current_class = helpers.get_type(context) mock_func = current_class.find_single_method(mock_name) original_class = target.type original_function = original_class.find_single_method(target_method) result_fd = original_function.instance_stub.clone() def payload_adapter(__context, __sender, *args, **kwargs): return mock_func.invoke( mock_object, args, kwargs, __context, True) result_fd.payload = payload_adapter existing_mocks = ctx_manager.class_mock_ctx.setdefault( original_class.name, []) existing_mocks.append(result_fd)
def inject_method_with_yaql_expr(context, target, target_method, expr): ctx_manager = helpers.get_executor(context).context_manager original_class = target.type original_function = original_class.find_single_method(target_method) result_fd = original_function.instance_stub.clone() def payload_adapter(__super, __context, __sender, *args, **kwargs): new_context = context.create_child_context() new_context[constants.CTX_ORIGINAL_CONTEXT] = __context mock_obj = context[constants.CTX_THIS] new_context.register_function(lambda: __super(*args, **kwargs), name='originalMethod') return expr(new_context, mock_obj, *args, **kwargs) result_fd.payload = payload_adapter result_fd.insert_parameter('__super', yaqltypes.Super()) existing_mocks = ctx_manager.class_mock_ctx.setdefault( original_class.name, []) existing_mocks.append(result_fd)
def getter(src): if isinstance(src, utils.MappingType): return src.get(key, {}) elif isinstance(src, dsl_types.MuranoObject): try: return src.get_property(key, context['#root_context']) except exceptions.UninitializedPropertyAccessError: return {} elif isinstance( src, (dsl_types.MuranoTypeReference, dsl_types.MuranoType)): if isinstance(src, dsl_types.MuranoTypeReference): mc = src.type else: mc = src return helpers.get_executor().get_static_property( mc, key, context['#root_context']) else: raise ValueError('attribution may only be applied to ' 'objects and dictionaries')
def inject_method_with_yaql_expr(context, target, target_method, expr): ctx_manager = helpers.get_executor().context_manager original_class = target.type original_function = original_class.find_single_method(target_method) result_fd = original_function.instance_stub.clone() def payload_adapter(__super, __context, __sender, *args, **kwargs): new_context = context.create_child_context() new_context[constants.CTX_ORIGINAL_CONTEXT] = __context mock_obj = context[constants.CTX_THIS] new_context.register_function(lambda: __super(*args, **kwargs), name='originalMethod') return expr(new_context, mock_obj, *args, **kwargs) result_fd.payload = payload_adapter result_fd.insert_parameter('__super', yaqltypes.Super()) existing_mocks = ctx_manager.class_mock_ctx.setdefault( original_class.name, []) existing_mocks.append(result_fd)
def set_property(self, name, value, context=None): start_type, derived = self.__type, False caller_class = None if not context else helpers.get_type(context) if caller_class is not None and caller_class.is_compatible(self): start_type, derived = caller_class, True declared_properties = start_type.find_properties( lambda p: p.name == name) if context is None: context = helpers.get_executor().create_object_context(self) if len(declared_properties) > 0: declared_properties = self.type.find_properties( lambda p: p.name == name) values_to_assign = [] classes_for_static_properties = [] for spec in declared_properties: if (caller_class is not None and not helpers.are_property_modifications_allowed(context) and (spec.usage not in dsl_types.PropertyUsages.Writable or not derived)): raise exceptions.NoWriteAccessError(name) if spec.usage == dsl_types.PropertyUsages.Static: classes_for_static_properties.append(spec.declaring_type) else: default = self.__config.get(name, spec.default) obj = self.cast(spec.declaring_type) values_to_assign.append((obj, spec.transform( value, self.real_this, self.real_this, context, default=default))) for obj, value in values_to_assign: obj.__properties[name] = value for cls in classes_for_static_properties: cls.set_property(name, value, context) elif derived: obj = self.cast(caller_class) obj.__properties[name] = value else: raise exceptions.PropertyWriteError(name, start_type)
def payload(__context, __sender, *args, **kwargs): executor = helpers.get_executor(__context) args = tuple(dsl.to_mutable(arg, engine) for arg in args) kwargs = dsl.to_mutable(kwargs, engine) return murano_method.invoke(executor, __sender, args, kwargs, __context, True)
def get_meta(self, context): if six.callable(self._meta): executor = helpers.get_executor() context = executor.create_package_context(self) self._meta = self._meta().get_meta(context) return self._meta
def op_dot_static(context, sender, expr, operator): executor = helpers.get_executor(context) type_context = executor.context_manager.create_class_context(sender.murano_class) ctx2 = helpers.link_contexts(context, type_context) return operator(ctx2, None, expr)
def load(self, model): exc = helpers.get_executor() return exc.load(model)
def get_meta(self, context): executor = helpers.get_executor(context) context = executor.create_type_context( self.murano_method.declaring_type, caller_context=context) return self._meta.get_meta(context)
def get_meta(self, context): if six.callable(self._meta): executor = helpers.get_executor(context) context = executor.create_package_context(self) self._meta = self._meta().get_meta(context) return self._meta
def method_invoke(context, method, __object, *args, **kwargs): executor = helpers.get_executor(context) return method.invoke(executor, __object, args, kwargs, context)
def payload(__context, __receiver, *args, **kwargs): executor = helpers.get_executor(__context) return murano_method.invoke( executor, murano_method.declaring_type, (__receiver,) + args, kwargs, __context, True)
def property_get_value(context, property_, object_): if object_ is None: return helpers.get_executor().get_static_property( property_.declaring_type, name=property_.name, context=context) return object_.cast(property_.declaring_type).get_property( name=property_.name, context=context)
def op_dot_static(context, receiver, expr, operator): executor = helpers.get_executor(context) type_context = executor.context_manager.create_type_context( receiver.type) ctx2 = helpers.link_contexts(context, type_context) return operator(ctx2, receiver, expr)
def obj_attribution_static(context, cls, property_name): return helpers.get_executor().get_static_property(cls.type, property_name, context)
def attributes(self): executor = helpers.get_executor() return executor.attribute_store
def payload(__context, __sender, *args, **kwargs): executor = helpers.get_executor(__context) return murano_method.invoke( executor, __sender, args, kwargs, __context, True)
def payload(__context, __sender, *args, **kwargs): executor = helpers.get_executor(__context) args = tuple(dsl.to_mutable(arg, engine) for arg in args) kwargs = dsl.to_mutable(kwargs, engine) return helpers.evaluate(murano_method.invoke( executor, __sender, args, kwargs, __context, True), __context)
def payload_adapter(__context, __sender, *args, **kwargs): executor = helpers.get_executor(__context) return mock_func.invoke( executor, mock_object, args, kwargs, __context, True)
def initialize(self, context, object_store, params): if self.__initialized: return for property_name in self.__type.properties: spec = self.__type.get_property(property_name) if spec.usage == typespec.PropertyUsages.Config: if property_name in self.__config: property_value = self.__config[property_name] else: property_value = dsl.NO_VALUE self.set_property(property_name, property_value) init = self.type.methods.get('.init') used_names = set() names = set(self.__type.properties) if init: names.update(init.arguments_scheme.iterkeys()) last_errors = len(names) init_args = {} while True: errors = 0 for property_name in names: if init and property_name in init.arguments_scheme: spec = init.arguments_scheme[property_name] is_init_arg = True else: spec = self.__type.get_property(property_name) is_init_arg = False if property_name in used_names: continue if spec.usage == typespec.PropertyUsages.Config: used_names.add(property_name) continue if spec.usage == typespec.PropertyUsages.Runtime: if not spec.has_default: used_names.add(property_name) continue property_value = dsl.NO_VALUE else: property_value = params.get(property_name, dsl.NO_VALUE) try: if is_init_arg: init_args[property_name] = property_value else: self.set_property(property_name, property_value) used_names.add(property_name) except exceptions.UninitializedPropertyAccessError: errors += 1 except exceptions.ContractViolationException: if spec.usage != typespec.PropertyUsages.Runtime: raise if not errors: break if errors >= last_errors: raise exceptions.CircularExpressionDependenciesError() last_errors = errors executor = helpers.get_executor(context) if not object_store.initializing and self.__extension is None: method = self.type.methods.get('__init__') if method: filtered_params = yaql_integration.filter_parameters( method.body, **params) self.__extension = method.invoke( executor, self, filtered_params[0], filtered_params[1], context) for parent in self.__parents.values(): parent.initialize(context, object_store, params) if not object_store.initializing and init: context[constants.CTX_ARGUMENT_OWNER] = self.real_this init.invoke(executor, self.real_this, (), init_args, context) self.__initialized = True
def payload(__context, __sender, *args, **kwargs): executor = helpers.get_executor(__context) return murano_method.invoke(executor, __sender, args, kwargs, __context, True)