def impl_numba_typeref_ctor(cls): """ Defines ``Dict()``, the type-inferred version of the dictionary ctor. Parameters ---------- cls : TypeRef Expecting a TypeRef of a precise DictType. See also: `redirect_type_ctor` in numba/target/bulitins.py """ dict_ty = cls.instance_type if not isinstance(dict_ty, types.DictType): msg = "expecting a DictType but got {}".format(dict_ty) return # reject # Ensure the dictionary is precisely typed. if not dict_ty.is_precise(): msg = "expecting a precise DictType but got {}".format(dict_ty) raise errors.LoweringError(msg) key_type = types.TypeRef(dict_ty.key_type) value_type = types.TypeRef(dict_ty.value_type) def impl(cls): # Simply call .empty() with the key/value types from *cls* return Dict.empty(key_type, value_type) return impl
def __getattr__(self, attr): # print("DEREF", attr) if(attr == 'fact_type'): fact_type = self._numba_type_.field_dict['fact_type'] return fact_type.instance_type if(fact_type != types.Any) else None elif(attr == 'head_type'): head_type = self._numba_type_.field_dict['head_type'] return head_type.instance_type if(head_type != types.Any) else None elif(attr == 'deref_attrs'): return var_get_deref_attrs(self) elif(attr == 'alias'): return var_get_alias(self) elif(attr == 'fact_type_name'): return var_get_fact_type_name(self) elif(True): typ = self._numba_type_ fact_type = typ.field_dict['fact_type'].instance_type fact_type_name = fact_type._fact_name head_type = fact_type.field_dict[attr] fd = fact_type.field_dict offset = fact_type._attr_offsets[list(fd.keys()).index(attr)] struct_type = get_var_definition(types.TypeRef(fact_type), types.TypeRef(head_type)) new = var_ctor(struct_type, fact_type_name, var_get_alias(self)) copy_and_append(self, new,attr, offset) return new
def typeof_typeref(val, c): if isinstance(val, types.BaseFunction): return val elif isinstance(val, (types.Number, types.Boolean)): return types.NumberClass(val) else: return types.TypeRef(val)
def impl_numba_typeref_ctor(cls): """ Defines ``List()``, the type-inferred version of the list ctor. Parameters ---------- cls : TypeRef Expecting a TypeRef of a precise ListType. See also: `redirect_type_ctor` in numba/target/bulitins.py """ list_ty = cls.instance_type if not isinstance(list_ty, types.ListType): msg = "expecting a ListType but got {}".format(list_ty) return # reject # Ensure the list is precisely typed. if not list_ty.is_precise(): msg = "expecting a precise ListType but got {}".format(list_ty) raise errors.LoweringError(msg) item_type = types.TypeRef(list_ty.item_type) def impl(cls): # Simply call .empty_list with the item types from *cls* return List.empty_list(item_type) return impl
def typeof_type(val, c): """ Type various specific Python types. """ if issubclass(val, BaseException): return types.ExceptionClass(val) if issubclass(val, tuple) and hasattr(val, "_asdict"): return types.NamedTupleClass(val) if issubclass(val, np.generic): return types.NumberClass(numpy_support.from_dtype(val)) from numba.typed import Dict if issubclass(val, Dict): return types.TypeRef(types.DictType) from numba.typed import List if issubclass(val, List): return types.TypeRef(types.ListType)
def generic_resolve(self, typ, attr): if attr in typ.field_dict: attrty = typ.field_dict[attr] return attrty head_type = typ.field_dict['head_type'].instance_type #TODO Should check that all subtype references are valid if(not hasattr(head_type,'field_dict')): raise AttributeError(f"Cannot dereference attribute '{attr}' of {typ}.") fact_type = typ.field_dict['fact_type'] if(attr in head_type.field_dict): new_head_type = types.TypeRef(head_type.field_dict[attr]) field_dict = { **var_fields_dict, **{"fact_type" : fact_type, "head_type" : new_head_type} } attrty = VarTypeTemplate([(k,v) for k,v, in field_dict.items()]) return attrty else: raise AttributeError(f"Var[{fact_type}] has no attribute '{attr}'")
} from pprint import pprint basepredicate_node_fields = [(k,v) for k,v, in base_predicate_node_field_dict.items()] # pprint(basepredicate_node_fields) BasePredicateNode, BasePredicateNodeType = define_structref("BasePredicateNode", base_subscriber_fields + basepredicate_node_fields) alpha_predicate_node_field_dict = { **base_predicate_node_field_dict, # "truth_values" : u1[:], #### Attributes filled in at definition time ### "filter_func" : alpha_filter_func_type, "left_type" : types.TypeRef(BaseFactType), #<- Filled in at definition "right_val" : types.float64, #<- Can be specialized to something else } alpha_predicate_node_fields = [(k,v) for k,v, in alpha_predicate_node_field_dict.items()] # pprint(alpha_predicate_node_fields) AlphaPredicateNode, AlphaPredicateNodeTemplate = define_structref_template("AlphaPredicateNode", base_subscriber_fields + alpha_predicate_node_fields, define_constructor=False) GenericAlphaPredicateNodeType = AlphaPredicateNodeTemplate(base_subscriber_fields + alpha_predicate_node_fields) # print(GenericAlphaPredicateNodeType) beta_predicate_node_field_dict = { **base_predicate_node_field_dict,
def __new__(cls, typ, alias=None): fact_type_name = typ._fact_name typ = types.TypeRef(typ) struct_type = get_var_definition(typ,typ) st = var_ctor(struct_type, fact_type_name, alias) return st