def map_field(cls, exporter, entity_name, field_name, model_object): try: try: if hasattr(cls, "get_" + field_name): mthd = getattr(cls, "get_" + field_name) value = mthd(exporter, DynamicProxy.return_value(model_object)) elif hasattr(cls, "map") and field_name in cls.map: value = cls.map[field_name]( exporter, DynamicProxy.return_value(model_object)) else: value = getattr(model_object, field_name) # copy dict and sequence proxy before passing it to handler code if isinstance(value, (DynamicProxy, SequenceProxy)): value = serialize_proxy(value) return value except UnknownException as e: return e.unknown except AttributeError as e: raise AttributeError( "Attribute %s does not exist on entity of type %s" % (field_name, entity_name))
def _load_resources(self, types): """ Load all registered resources """ entities = resource.get_entity_resources() resource_mapping = {} ignored_set = set() for entity in entities: if entity not in types: continue instances = types[entity].get_all_instances() if len(instances) > 0: for instance in instances: try: res = Resource.create_from_model( self, entity, DynamicProxy.return_value(instance)) resource_mapping[instance] = res self.add_resource(res) except UnknownException: ignored_set.add(instance) # We get this exception when the attribute that is used to create the object id contains an unknown. # We can safely ignore this resource == prune it LOGGER.debug( "Skipped resource of type %s because its id contains an unknown (location: %s)", entity, instance.location) except IgnoreResourceException: ignored_set.add(instance) LOGGER.info( "Ignoring resource of type %s because it requested to ignore it. (location: %s)", entity, instance.location) Resource.convert_requires(resource_mapping, ignored_set)
def new_arg(arg: object) -> object: if isinstance(arg, Context): return arg elif isinstance(arg, Unknown) and self.is_accept_unknowns(): return arg else: return DynamicProxy.return_value(arg)
def proxy_object(snippetcompiler, snippet, var): snippetcompiler.setup_for_snippet(snippet) (_, root) = compiler.do_compile() scope = root.get_child("__config__").scope value = scope.lookup(var).get_value() return DynamicProxy.return_value(value)
def __getitem__(self, key): instance = self._get_instance() if not isinstance(key, str): raise RuntimeException( self, "Expected string key, but got %s, %s is a dict" % (key, self._get_instance()), ) return DynamicProxy.return_value(instance[key])
def _get_instance_proxies_of_types(self, types): """ Returns a dict of instances for the given types """ proxies = {} for t in types: if self.types is not None and t in self.types: proxies[t] = [DynamicProxy.return_value(i) for i in self.types[t].get_all_instances()] else: proxies[t] = [] return proxies
def __call__(self, *args): """ The function call itself """ self.check_requirements() new_args = [] for arg in args: if isinstance(arg, Context): new_args.append(arg) else: new_args.append(DynamicProxy.return_value(arg)) value = self.call(*new_args) value = DynamicProxy.unwrap(value) if self.returntype is not None and not isinstance(value, Unknown): valid = False exception = None try: valid = (value is None or self._is_instance(value, self.returntype)) except RuntimeException as e: raise e except Exception as exp: exception = exp if not valid: msg = "" if exception is not None: msg = "\n\tException details: " + str(exception) raise Exception( "Plugin %s should return value of type %s ('%s' was returned) %s" % (self.__class__.__function_name__, self.returntype, value, msg)) return value
def _get_instance_proxies_of_types( self, types: List[str]) -> Dict[str, Sequence[ProxiedType]]: """Returns a dict of instances for the given types""" proxies: Dict[str, Sequence[ProxiedType]] = {} for t in types: if self.types is not None and t in self.types: proxies[t] = [ DynamicProxy.return_value(i) for i in self.types[t].get_all_instances() ] else: proxies[t] = [] return proxies
def __call__(self, *args: object, **kwargs: object) -> object: """ The function call itself """ self.check_requirements() def new_arg(arg: object) -> object: if isinstance(arg, Context): return arg elif isinstance(arg, Unknown) and self.is_accept_unknowns(): return arg else: return DynamicProxy.return_value(arg) new_args = [new_arg(arg) for arg in args] new_kwargs = {k: new_arg(v) for k, v in kwargs.items()} value = self.call(*new_args, **new_kwargs) value = DynamicProxy.unwrap(value) if self.returntype is not None and not isinstance(value, Unknown): valid = False exception = None try: valid = value is None or self._is_instance( value, self.returntype) except RuntimeException as e: raise e except Exception as exp: exception = exp if not valid: msg = "" if exception is not None: msg = "\n\tException details: " + str(exception) raise Exception( "Plugin %s should return value of type %s ('%s' was returned) %s" % (self.__class__.__function_name__, self.returntype, value, msg)) return value
def get_instances(self, fortype: str = "std::Entity"): # extract all objects of a specific type from the compiler allof = self.types[fortype].get_all_instances() # wrap in DynamicProxy to hide internal compiler structure # and get inmanta objects as if they were python objects return [DynamicProxy.return_value(port) for port in allof]
def get_variable(self, name, scope): """ Get the given variable """ return DynamicProxy.return_value( self._scope.get_variable(name, scope).value)
def test_unwrap_dict_key_validation(): with pytest.raises(RuntimeException): DynamicProxy.unwrap({1: 2})
def test_unwrap_list_dict_recurse(): assert DynamicProxy.unwrap([{"null": None, "nulls": [None]}]) == [{"null": NoneValue(), "nulls": [NoneValue()]}]
def test_unwrap_none(): assert DynamicProxy.unwrap(None) == NoneValue()
def __init__(self, mydict): DynamicProxy.__init__(self, mydict)