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 class_(value, name, default_name=None, version_spec=None):
     object_store = None if this is None else this.object_store
     if not default_name:
         default_name = name
     murano_class = name.type
     if value is None:
         return None
     if isinstance(value, dsl_types.MuranoObject):
         obj = value
     elif isinstance(value, dsl_types.MuranoObjectInterface):
         obj = value.object
     elif isinstance(value, utils.MappingType):
         obj = helpers.instantiate(
             value, owner, object_store, root_context,
             calling_type, default_name)
     elif isinstance(value, six.string_types) and object_store:
         obj = object_store.get(value)
         if obj is None:
             if not object_store.initializing:
                 raise exceptions.NoObjectFoundError(value)
             else:
                 return TypeScheme.ObjRef(value)
     else:
         raise exceptions.ContractViolationException(
             'Value {0} cannot be represented as class {1}'.format(
                 format_scalar(value), name))
     if not helpers.is_instance_of(
             obj, murano_class.name,
             version_spec or helpers.get_type(root_context)):
         raise exceptions.ContractViolationException(
             'Object of type {0} is not compatible with '
             'requested type {1}'.format(obj.type.name, name))
     return obj

    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_property(name)
        if context is None:
            context = self.object_store.executor.create_object_context(self)
        if len(declared_properties) > 0:
            declared_properties = self.type.find_property(name)
            values_to_assign = []
            for mc in declared_properties:
                spec = mc.get_property(name)
                if (caller_class is not None and
                        not helpers.are_property_modifications_allowed(context)
                        and (spec.usage not in typespec.PropertyUsages.Writable
                             or not derived)):
                    raise exceptions.NoWriteAccessError(name)

                default = self.__config.get(name, spec.default)
                default = self.__defaults.get(name, default)
                default = helpers.evaluate(default, context)

                obj = self.cast(mc)
                values_to_assign.append((obj, spec.validate(
                    value, self.real_this,
                    self.real_this, default=default)))
            for obj, value in values_to_assign:
                obj.__properties[name] = value
        elif derived:
            obj = self.cast(caller_class)
            obj.__properties[name] = value
        else:
            raise exceptions.PropertyWriteError(name, start_type)

    def setAttr(self, _context, name, value, owner=None):
        if owner is None:
            owner = helpers.get_type(helpers.get_caller_context(_context))
        if not isinstance(owner, murano_class.MuranoClass):
            raise TypeError()

        attribute_store = helpers.get_attribute_store(_context)
        attribute_store.set(self, owner, name, value)

    def get_attr(self, this, context, name, default=None, owner=None):
        if owner is None:
            owner = helpers.get_type(helpers.get_caller_context(context))

        attribute_store = helpers.get_attribute_store(context)

        result = attribute_store.get(this.object, owner, name)
        return default if result is None else result

 def _get_package(owner, receiver):
     if owner is None:
         if isinstance(receiver, dsl_types.MuranoObjectInterface):
             return receiver.extension._package
         murano_class = helpers.get_type(helpers.get_caller_context())
     else:
         murano_class = owner.type
     return murano_class.package

 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, _context, name, default=None, owner=None):
        if owner is None:
            owner = helpers.get_type(helpers.get_caller_context(_context))
        if not isinstance(owner, murano_class.MuranoClass):
            raise TypeError()

        attribute_store = helpers.get_attribute_store(_context)

        result = attribute_store.get(self, owner, name)
        return default if result is None else result

def _get_container(context, obj, class_name):
    namespace_resolver = helpers.get_type(context).namespace_resolver
    class_loader = helpers.get_class_loader(context)
    class_name = namespace_resolver.resolve_name(class_name)
    murano_class = class_loader.get_class(class_name)
    p = obj.owner
    while p is not None:
        if murano_class.is_compatible(p):
            return p
        p = p.owner
    return None

def compose_stack_frame(context):
    instruction = helpers.get_current_instruction(context)
    return {
        'instruction': None if instruction is None
        else str(instruction),

        'location': None if instruction is None
        else instruction.source_file_position,

        'method': helpers.get_current_method(context),
        'class': helpers.get_type(context)
    }

 def convert(self, value, sender, context, function_spec, engine,
             *args, **kwargs):
     context = self._context or context
     if isinstance(value, yaql_expressions.Expression):
         value = value(utils.NO_VALUE, context, engine)
     value = super(MuranoTypeName, self).convert(
         value, sender, context, function_spec, engine)
     if isinstance(value, types.StringTypes):
         murano_type = helpers.get_type(context)
         value = dsl_types.MuranoClassReference(
             helpers.get_class(
                 murano_type.namespace_resolver.resolve_name(
                     value), context))
     return value

 def get_property(self, name, 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
     if name in start_type.properties:
         return self.cast(start_type)._get_property_value(name)
     else:
         declared_properties = start_type.find_single_property(name)
         if declared_properties:
             return self.cast(declared_properties).__properties[name]
         elif derived:
             return self.cast(caller_class)._get_property_value(name)
         else:
             raise exceptions.PropertyReadError(name, start_type)

 def convert(self, value, sender, context, function_spec, engine,
             *args, **kwargs):
     context = self._context or context
     if isinstance(value, yaql_expressions.Expression):
         value = value(utils.NO_VALUE, context, engine)
     value = super(MuranoTypeName, self).convert(
         value, sender, context, function_spec, engine)
     if isinstance(value, six.string_types):
         if function_spec.meta.get(constants.META_MURANO_METHOD):
             context = helpers.get_caller_context(context)
         murano_type = helpers.get_type(context)
         value = helpers.get_class(
             murano_type.namespace_resolver.resolve_name(value),
             context).get_reference()
     return value

 def check(self, value, context, *args, **kwargs):
     if not super(MuranoType, self).check(
             value, context, *args, **kwargs):
         return False
     if isinstance(value, MuranoObjectInterface):
         value = value.object
     if value is None or isinstance(value, yaql_expressions.Expression):
         return True
     murano_class = self.murano_class
     if isinstance(murano_class, six.string_types):
         murano_class_name = murano_class
     else:
         murano_class_name = murano_class.name
     return helpers.is_instance_of(
         value, murano_class_name,
         self.version_spec or helpers.get_type(context))

    def initialize(self, _context, includeNativeFrames=True):
        frames = []
        context = _context
        while True:
            if not context:
                break
            instruction = helpers.get_current_instruction(context)
            frames.append({
                'instruction': None if instruction is None
                else str(instruction),

                'location': None if instruction is None
                else instruction.source_file_position,

                'method': helpers.get_current_method(context),
                'class': helpers.get_type(context)
            })
            context = helpers.get_caller_context(context)
        frames.pop()
        frames.reverse()

        if includeNativeFrames:
            class InstructionStub(object):
                def __init__(self, title, position):
                    self._title = title
                    self.source_file_position = position

                def __str__(self):
                    return self._title

            native_frames = []
            for frame in inspect.trace()[1:]:
                info = inspect.getframeinfo(frame[0])
                position = yaql_expression.YaqlExpressionFilePosition(
                    os.path.abspath(info.filename), info.lineno,
                    -1, -1, -1, -1, -1)
                instruction = InstructionStub(
                    info.code_context[0].strip(), position)
                method = info.function
                native_frames.append({
                    'instruction': instruction,
                    'method': method,
                    'class': None
                })
            frames.extend(native_frames)

        self.set_property('frames', frames)

def _new(context, name, *args):
    murano_class = helpers.get_type(context)
    name = murano_class.namespace_resolver.resolve_name(name)
    parameters = {}
    arg_values = [t() for t in args]
    if len(arg_values) == 1 and isinstance(arg_values[0], types.DictionaryType):
        parameters = arg_values[0]
    elif len(arg_values) > 0:
        for p in arg_values:
            if not isinstance(p, types.TupleType) or not isinstance(p[0], types.StringType):
                raise SyntaxError()
            parameters[p[0]] = p[1]

    object_store = helpers.get_object_store(context)
    class_loader = helpers.get_class_loader(context)
    new_context = yaql.context.Context(parent_context=context)
    for key, value in parameters.iteritems():
        new_context.set_data(value, key)
    return class_loader.get_class(name).new(None, object_store, new_context, parameters=parameters)

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 check(self, value, context, *args, **kwargs):
     if not super(MuranoObjectParameter, self).check(
             value, context, *args, **kwargs):
         return False
     if value is None or isinstance(value, yaql_expressions.Expression):
         return True
     if isinstance(value, MuranoObjectInterface):
         value = value.object
     if not isinstance(value, dsl_types.MuranoObject):
         return False
     if self.murano_class:
         murano_class = self.murano_class
         if isinstance(murano_class, six.string_types):
             return helpers.is_instance_of(
                 value, murano_class,
                 self.version_spec or helpers.get_type(context))
         else:
             return murano_class.is_compatible(value)
     else:
         return True

        def class_(value, name, default_name=None, version_spec=None):
            object_store = this.object_store
            if not default_name:
                default_name = name
            murano_class = name.murano_class
            if value is None:
                return None
            if isinstance(value, dsl_types.MuranoObject):
                obj = value
            elif isinstance(value, dsl_types.MuranoObjectInterface):
                obj = value.object
            elif isinstance(value, utils.MappingType):
                if '?' not in value:
                    new_value = {'?': {
                        'id': uuid.uuid4().hex,
                        'type': default_name.murano_class.name,
                        'classVersion': str(default_name.murano_class.version)
                    }}
                    new_value.update(value)
                    value = new_value

                obj = object_store.load(
                    value, owner, root_context, defaults=default)
            elif isinstance(value, types.StringTypes):
                obj = object_store.get(value)
                if obj is None:
                    if not object_store.initializing:
                        raise exceptions.NoObjectFoundError(value)
                    else:
                        return TypeScheme.ObjRef(value)
            else:
                raise exceptions.ContractViolationException(
                    'Value {0} cannot be represented as class {1}'.format(
                        value, name))
            if not helpers.is_instance_of(
                    obj, murano_class.name,
                    version_spec or helpers.get_type(root_context)):
                raise exceptions.ContractViolationException(
                    'Object of type {0} is not compatible with '
                    'requested type {1}'.format(obj.type.name, name))
            return obj

    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 = self.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)
                    # default = helpers.evaluate(default, context)

                    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)