def make_foo_type(self, FooType): class Foo(object): def __init__(self, value): self.value = value @register_model(FooType) class FooModel(models.StructModel): def __init__(self, dmm, fe_type): members = [("value", types.intp)] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(FooType, "value", "value") @type_callable(Foo) def type_foo(context): def typer(value): return FooType() return typer @lower_builtin(Foo, types.intp) def impl_foo(context, builder, sig, args): typ = sig.return_type [value] = args foo = cgutils.create_struct_proxy(typ)(context, builder) foo.value = value return foo._getvalue() @typeof_impl.register(Foo) def typeof_foo(val, c): return FooType() return Foo, FooType
def _build_model(self, Type): # pylint: disable=unused-variable @register_model(Type) class Model(models.StructModel): def __init__(self, dmm, fe_type): members = [("ptr", numba.types.voidptr)] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(Type, "ptr", "ptr") @imputils.lower_constant(Type) def constant(context, builder, ty, pyval): # pylint: disable=unused-argument ptr = ir.Constant(ir.IntType(64), self.get_value_address(pyval)).inttoptr(ir.PointerType(ir.IntType(8))) ret = ir.Constant.literal_struct((ptr,)) return ret
def setUp(self): class Dummy(object): def __init__(self, value): self.value = value class DummyType(types.Type): def __init__(self): super(DummyType, self).__init__(name='Dummy') dummy_type = DummyType() @register_model(DummyType) class DummyModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('value', types.intp), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(DummyType, 'value', 'value') @type_callable(Dummy) def type_dummy(context): def typer(value): return dummy_type return typer @lower_builtin(Dummy, types.intp) def impl_dummy(context, builder, sig, args): typ = sig.return_type [value] = args dummy = cgutils.create_struct_proxy(typ)(context, builder) dummy.value = value return dummy._getvalue() @typeof_impl.register(Dummy) def typeof_dummy(val, c): return DummyType() # Store attributes self.Dummy = Dummy self.DummyType = DummyType
def setUp(self): class Dummy(object): def __init__(self, value): self.value = value class DummyType(types.Type): def __init__(self): super(DummyType, self).__init__(name='Dummy') dummy_type = DummyType() @register_model(DummyType) class DummyModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('value', types.intp), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(DummyType, 'value', 'value') @type_callable(Dummy) def type_dummy(context): def typer(value): return dummy_type return typer @lower_builtin(Dummy, types.intp) def impl_dummy(context, builder, sig, args): typ = sig.return_type [value] = args dummy = cgutils.create_struct_proxy(typ)(context, builder) dummy.value = value return dummy._getvalue() # Store attributes self.Dummy = Dummy self.DummyType = DummyType
('data', types.CPointer(char_typ)), ('null_bitmap', types.CPointer(char_typ)), ] models.StructModel.__init__(self, dmm, fe_type, members) str_arr_model_members = [ ('num_items', types.uint64), ('num_total_chars', types.uint64), ('offsets', types.CPointer(offset_typ)), ('data', types.CPointer(char_typ)), ('null_bitmap', types.CPointer(char_typ)), ('meminfo', types.MemInfoPointer(str_arr_payload_type)), ] make_attribute_wrapper(StringArrayType, 'null_bitmap', 'null_bitmap') @register_model(StringArrayType) class StringArrayModel(models.StructModel): def __init__(self, dmm, fe_type): models.StructModel.__init__(self, dmm, fe_type, str_arr_model_members) class StringArrayIterator(types.SimpleIteratorType): """ Type class for iterators of string arrays. """ def __init__(self): name = "iter(String)"
@register_model(types.UnicodeType) class UnicodeModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('data', types.voidptr), ('length', types.intp), ('kind', types.int32), ('hash', _Py_hash_t), ('meminfo', types.MemInfoPointer(types.voidptr)), # A pointer to the owner python str/unicode object ('parent', types.pyobject), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(types.UnicodeType, 'data', '_data') make_attribute_wrapper(types.UnicodeType, 'length', '_length') make_attribute_wrapper(types.UnicodeType, 'kind', '_kind') make_attribute_wrapper(types.UnicodeType, 'hash', '_hash') ### CAST def compile_time_get_string_data(obj): """Get string data from a python string for use at compile-time to embed the string data into the LLVM module. """ from ctypes import ( CFUNCTYPE, c_void_p, c_int, c_long, c_ssize_t, c_ubyte, py_object, POINTER, byref, cast,
def test_interval_class_usage(self): # magictoken.interval_py_class.begin class Interval(object): """ A half-open interval on the real number line. """ def __init__(self, lo, hi): self.lo = lo self.hi = hi def __repr__(self): return 'Interval(%f, %f)' % (self.lo, self.hi) @property def width(self): return self.hi - self.lo # magictoken.interval_py_class.end # magictoken.interval_type_class.begin from numba import types class IntervalType(types.Type): def __init__(self): super(IntervalType, self).__init__(name='Interval') interval_type = IntervalType() # magictoken.interval_type_class.end # magictoken.interval_typeof_register.begin from numba.extending import typeof_impl @typeof_impl.register(Interval) def typeof_index(val, c): return interval_type # magictoken.interval_typeof_register.end # magictoken.numba_type_register.begin from numba.extending import as_numba_type as_numba_type.register(Interval, interval_type) # magictoken.numba_type_register.end # magictoken.numba_type_callable.begin from numba.extending import type_callable @type_callable(Interval) def type_interval(context): def typer(lo, hi): if isinstance(lo, types.Float) and isinstance(hi, types.Float): return interval_type return typer # magictoken.numba_type_callable.end # magictoken.interval_model.begin from numba.extending import models, register_model @register_model(IntervalType) class IntervalModel(models.StructModel): def __init__(self, dmm, fe_type): members = [('lo', types.float64), ('hi', types.float64),] models.StructModel.__init__(self, dmm, fe_type, members) # magictoken.interval_model.end # magictoken.interval_attribute_wrapper.begin from numba.extending import make_attribute_wrapper make_attribute_wrapper(IntervalType, 'lo', 'lo') make_attribute_wrapper(IntervalType, 'hi', 'hi') # magictoken.interval_attribute_wrapper.end # magictoken.interval_overload_attribute.begin from numba.extending import overload_attribute @overload_attribute(IntervalType, "width") def get_width(interval): def getter(interval): return interval.hi - interval.lo return getter # magictoken.interval_overload_attribute.end # magictoken.interval_lower_builtin.begin from numba.extending import lower_builtin from numba.core import cgutils @lower_builtin(Interval, types.Float, types.Float) def impl_interval(context, builder, sig, args): typ = sig.return_type lo, hi = args interval = cgutils.create_struct_proxy(typ)(context, builder) interval.lo = lo interval.hi = hi return interval._getvalue() # magictoken.interval_lower_builtin.end # magictoken.interval_unbox.begin from numba.extending import unbox, NativeValue @unbox(IntervalType) def unbox_interval(typ, obj, c): """ Convert a Interval object to a native interval structure. """ lo_obj = c.pyapi.object_getattr_string(obj, "lo") hi_obj = c.pyapi.object_getattr_string(obj, "hi") interval = cgutils.create_struct_proxy(typ)(c.context, c.builder) interval.lo = c.pyapi.float_as_double(lo_obj) interval.hi = c.pyapi.float_as_double(hi_obj) c.pyapi.decref(lo_obj) c.pyapi.decref(hi_obj) is_error = cgutils.is_not_null(c.builder, c.pyapi.err_occurred()) return NativeValue(interval._getvalue(), is_error=is_error) # magictoken.interval_unbox.end # magictoken.interval_box.begin from numba.extending import box @box(IntervalType) def box_interval(typ, val, c): """ Convert a native interval structure to an Interval object. """ interval = cgutils.create_struct_proxy(typ)(c.context, c.builder, value=val) lo_obj = c.pyapi.float_from_double(interval.lo) hi_obj = c.pyapi.float_from_double(interval.hi) class_obj = c.pyapi.unserialize(c.pyapi.serialize_object(Interval)) res = c.pyapi.call_function_objargs(class_obj, (lo_obj, hi_obj)) c.pyapi.decref(lo_obj) c.pyapi.decref(hi_obj) c.pyapi.decref(class_obj) return res # magictoken.interval_box.end # magictoken.interval_usage.begin from numba import njit @njit def inside_interval(interval, x): return interval.lo <= x < interval.hi @njit def interval_width(interval): return interval.width @njit def sum_intervals(i, j): return Interval(i.lo + j.lo, i.hi + j.hi) # magictoken.interval_usage.end def check_equal_intervals(x, y): self.assertIsInstance(x, Interval) self.assertIsInstance(y, Interval) self.assertEquals(x.lo, y.lo) self.assertEquals(x.hi, y.hi) a = Interval(2, 3) b = Interval(4, 5) c = Interval(6, 8) # Test box-unbox return_func = njit(lambda x: x) check_equal_intervals(a, return_func(a)) # Test .width attribute self.assertEqual(a.width, interval_width(a)) # Test .low and .high usage self.assertFalse(inside_interval(a, 5)) # Test native Interval constructor check_equal_intervals(c, sum_intervals(a, b))
# register_model(SeriesType)(models.ArrayModel) # need to define model since fix_df_array overload goes to native code @register_model(SeriesType) class SeriesModel(models.StructModel): def __init__(self, dmm, fe_type): name_typ = string_type if fe_type.is_named else types.none members = [ ('data', fe_type.data), ('index', fe_type.index), ('name', name_typ), ] super(SeriesModel, self).__init__(dmm, fe_type, members) make_attribute_wrapper(SeriesType, 'data', '_data') make_attribute_wrapper(SeriesType, 'index', '_index') make_attribute_wrapper(SeriesType, 'name', '_name') @lower_builtin('getiter', SeriesType) def getiter_series(context, builder, sig, args): """ Getting iterator for the Series type :param context: context descriptor :param builder: llvmlite IR Builder :param sig: iterator signature :param args: tuple with iterator arguments, such as instruction, operands and types :param result: iternext result :return: reference to iterator
class PositionalIndexType(types.IterableType): dtype = types.int64 def __init__(self, is_named=False): self.data = RangeIndexType(is_named) self.is_named = is_named super(PositionalIndexType, self).__init__(name='PositionalIndexType({})'.format(is_named)) @property def iterator_type(self): res = self.data.iterator_type return res @register_model(PositionalIndexType) class PositionalIndexModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('data', fe_type.data), ] models.StructModel.__init__(self, dmm, fe_type, members) # FIXME_Numba#3372: add into numba.types to allow returning from objmode types.PositionalIndexType = PositionalIndexType make_attribute_wrapper(PositionalIndexType, 'data', '_data')
class EmptyIndexType(types.Type): # this index represents special case of pd.Index([]) with dtype='object' # for overload typing functions assume it has following dtype dtype = types.pyobject def __init__(self, is_named=False): self.is_named = is_named super(EmptyIndexType, self).__init__( name='EmptyIndexType({})'.format(is_named)) @register_model(EmptyIndexType) class EmptyIndexModel(models.StructModel): def __init__(self, dmm, fe_type): name_type = types.unicode_type if fe_type.is_named else types.none members = [ ('name', name_type), ] models.StructModel.__init__(self, dmm, fe_type, members) # FIXME_Numba#3372: add into numba.types to allow returning from objmode types.EmptyIndexType = EmptyIndexType make_attribute_wrapper(EmptyIndexType, 'name', '_name')
class UnicodeModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('data', types.voidptr), ('length', types.intp), ('kind', types.int32), ('is_ascii', types.uint32), ('hash', _Py_hash_t), ('meminfo', types.MemInfoPointer(types.voidptr)), # A pointer to the owner python str/unicode object ('parent', types.pyobject), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(types.UnicodeType, 'data', '_data') make_attribute_wrapper(types.UnicodeType, 'length', '_length') make_attribute_wrapper(types.UnicodeType, 'kind', '_kind') make_attribute_wrapper(types.UnicodeType, 'is_ascii', '_is_ascii') make_attribute_wrapper(types.UnicodeType, 'hash', '_hash') @register_default(types.UnicodeIteratorType) class UnicodeIteratorModel(StructModel): def __init__(self, dmm, fe_type): members = [('index', types.EphemeralPointer(types.uintp)), ('data', fe_type.data)] super(UnicodeIteratorModel, self).__init__(dmm, fe_type, members) # CAST
def __init__(self, dmm, fe_type): members = [ ("year", types.int64), ("month", types.int32), ("day", types.int32), ("hour", types.int32), ("min", types.int32), ("sec", types.int32), ("us", types.int32), ("ps", types.int32), ("as", types.int32), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(PandasDtsType, 'year', 'year') make_attribute_wrapper(PandasDtsType, 'month', 'month') make_attribute_wrapper(PandasDtsType, 'day', 'day') @type_callable(PANDAS_DATETIMESTRUCT) def type_pandas_dts(context): def typer(): return pandas_dts_type return typer @lower_builtin(PANDAS_DATETIMESTRUCT) def impl_ctor_pandas_dts(context, builder, sig, args): typ = sig.return_type ts = cgutils.create_struct_proxy(typ)(context, builder)
return types.iterators.ArrayIterator(_dt_index_data_typ) # @typeof_impl.register(pd.DatetimeIndex) @register_model(DatetimeIndexType) class DatetimeIndexModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('data', _dt_index_data_typ), ('name', string_type), ] super(DatetimeIndexModel, self).__init__(dmm, fe_type, members) make_attribute_wrapper(DatetimeIndexType, 'data', '_data') make_attribute_wrapper(DatetimeIndexType, 'name', '_name') @box(DatetimeIndexType) def box_dt_index(typ, val, c): """ """ mod_name = c.context.insert_const_string(c.builder.module, "pandas") pd_class_obj = c.pyapi.import_module_noblock(mod_name) dt_index = numba.cgutils.create_struct_proxy( typ)(c.context, c.builder, val) arr = box_array(_dt_index_data_typ, dt_index.data, c)
@register_model(IndexType) class IndexModel(models.StructModel): def __init__(self, dmm, fe_type): members = [('data', fe_type.as_array)] models.StructModel.__init__(self, dmm, fe_type, members) @register_model(SeriesType) class SeriesModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('index', fe_type.index), ('values', fe_type.as_array), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(IndexType, 'data', '_data') make_attribute_wrapper(SeriesType, 'index', '_index') make_attribute_wrapper(SeriesType, 'values', '_values') def make_index(context, builder, typ, **kwargs): return cgutils.create_struct_proxy(typ)(context, builder, **kwargs) def make_series(context, builder, typ, **kwargs): return cgutils.create_struct_proxy(typ)(context, builder, **kwargs) @lower_builtin('__array__', IndexType) def index_as_array(context, builder, sig, args): val = make_index(context, builder, sig.args[0], ref=args[0]) return val._get_ptr_by_name('data') @lower_builtin('__array__', SeriesType)
# @property # def iterator_type(self): # return ArrowTableIteratorType(self).iterator_type @register_model(ArrowTableType) class ArrowTableModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('table_ptr', types.CPointer(types.uint8)), ('meminfo', types.MemInfoPointer(types.voidptr)), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(ArrowTableType, 'table_ptr', '_table_ptr') class PyarrowTableType(types.Type): def __init__(self): super(PyarrowTableType, self).__init__(name="PyarrowTableType()") register_model(PyarrowTableType)(models.OpaqueModel) # FIXME_Numba#3372: add into numba.types to allow returning from objmode types.PyarrowTableType = PyarrowTableType
def iterator_type(self): return ConcDictKeysIterableType(self).iterator_type @register_model(ConcurrentDictType) class ConcurrentDictModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('data_ptr', types.CPointer(types.uint8)), ('meminfo', types.MemInfoPointer(types.voidptr)), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(ConcurrentDictType, 'data_ptr', '_data_ptr') class ConcurrentDict(MutableMapping): def __new__(cls, dcttype=None, meminfo=None): return object.__new__(cls) @classmethod def empty(cls, key_type, value_type): return cls(dcttype=ConcurrentDictType(key_type, value_type)) @classmethod def from_arrays(cls, keys, values): return cls(dcttype=ConcurrentDictType(keys.dtype, values.dtype)) @classmethod
def is_precise(self): return all(a.is_precise() for a in self.data) and self.index.is_precise() @register_model(DataFrameType) class DataFrameModel(models.StructModel): def __init__(self, dmm, fe_type): types_unique = set() df_types = [] for col_type in fe_type.data: if col_type in types_unique: continue types_unique.add(col_type) df_types.append(col_type) members = [ ('data', types.Tuple([types.List(typ) for typ in df_types])), ('index', fe_type.index), ('columns', types.List(string_type)), ('parent', types.pyobject), ] super(DataFrameModel, self).__init__(dmm, fe_type, members) make_attribute_wrapper(DataFrameType, 'data', '_data') make_attribute_wrapper(DataFrameType, 'index', '_index') make_attribute_wrapper(DataFrameType, 'columns', '_columns') make_attribute_wrapper(DataFrameType, 'unboxed', '_unboxed') make_attribute_wrapper(DataFrameType, 'parent', '_parent')
def iterator_type(self): return None @register_model(StringMethodsType) class StringMethodsTypeModel(StructModel): """ Model for StringMethodsType type All members must be the same as main type for this model """ def __init__(self, dmm, fe_type): members = [('data', fe_type.data)] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(StringMethodsType, 'data', '_data') @intrinsic def _hpat_pandas_stringmethods_init(typingctx, data): """ Internal Numba required function to register StringMethodsType and connect it with corresponding Python type mentioned in @overload(pandas.core.strings.StringMethods) """ def _hpat_pandas_stringmethods_init_codegen(context, builder, signature, args): """ It is looks like it creates StringMethodsModel structure - Fixed number of parameters. Must be 4 - increase reference count for the data
@register_default(SeriesGroupByTypeIterator) class SeriesGroupByTypeIteratorModel(StructModel): """ Model for SeriesGroupByTypeIterator type All members must be the same as main type for this model Test: """ def __init__(self, dmm, fe_type): members = [('data', fe_type.data)] super(SeriesGroupByTypeIteratorModel, self).__init__(dmm, fe_type, members) make_attribute_wrapper(SeriesGroupByTypeIterator, 'data', '_data') class SeriesGroupByType(types.IterableType): """ Type definition for SeriesGroupBy functions handling. Members ---------- _data: :class:`SeriesType` input arg """ def __init__(self, data): self.data = data super(SeriesGroupByType, self).__init__('SeriesGroupByType')
('index_offsets', types.CPointer(offset_typ)), ('data_offsets', types.CPointer(offset_typ)), ('data', data_ctypes_type), #('null_bitmap', types.CPointer(char_typ)), ('meminfo', types.MemInfoPointer(str_arr_split_view_payload_type)), ] @register_model(StringArraySplitViewType) class StringArrayModel(models.StructModel): def __init__(self, dmm, fe_type): models.StructModel.__init__(self, dmm, fe_type, str_arr_model_members) make_attribute_wrapper(StringArraySplitViewType, 'num_items', '_num_items') make_attribute_wrapper(StringArraySplitViewType, 'index_offsets', '_index_offsets') make_attribute_wrapper(StringArraySplitViewType, 'data_offsets', '_data_offsets') make_attribute_wrapper(StringArraySplitViewType, 'data', '_data') def construct_str_arr_split_view(context, builder): """Creates meminfo and sets dtor. """ alloc_type = context.get_data_type(str_arr_split_view_payload_type) alloc_size = context.get_abi_sizeof(alloc_type) llvoidptr = context.get_value_type(types.voidptr) llsize = context.get_value_type(types.uintp)
self.accessor = accessor super(SeriesGetitemAccessorType, self).__init__('SeriesGetitemAccessorType({}, {})\ '.format(series, accessor)) @register_model(SeriesGetitemAccessorType) class SeriesGetitemAccessorTypeModel(StructModel): def __init__(self, dmm, fe_type): members = [ ('series', fe_type.series), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(SeriesGetitemAccessorType, 'series', '_series') @intrinsic def series_getitem_accessor_init(typingctx, series, accessor): if not (isinstance(series, SeriesType) and isinstance(accessor, types.StringLiteral)): return None, None def series_getitem_accessor_init_codegen(context, builder, signature, args): series_val, accessor_val = args getitem_accessor = cgutils.create_struct_proxy(signature.return_type)( context, builder) getitem_accessor.series = series_val
return signature(types.Array(types.boolean, 1, 'C'), va, vb) @infer class CmpOpNEqStringArray(CmpOpEqStringArray): key = '!=' @infer_global(len) class LenStringArray(AbstractTemplate): def generic(self, args, kws): if not kws and len(args) == 1 and args[0] == string_array_type: return signature(types.intp, *args) make_attribute_wrapper(StringArrayType, 'size', 'size') make_attribute_wrapper(StringArrayType, 'offsets', 'offsets') make_attribute_wrapper(StringArrayType, 'data', 'data') # @lower_builtin(StringArray, types.Type, types.Type) # def impl_string_array(context, builder, sig, args): # typ = sig.return_type # offsets, data = args # string_array = cgutils.create_struct_proxy(typ)(context, builder) # string_array.offsets = offsets # string_array.data = data # return string_array._getvalue() from numba.targets.listobj import ListInstance from llvmlite import ir as lir import llvmlite.binding as ll
def __init__(self, dmm, fe_type): by_series_dtype = fe_type.parent.data[ fe_type.col_id.literal_value].dtype ty_data = types.containers.DictType( by_series_dtype, types.containers.ListType(types.int64)) n_target_cols = len(fe_type.target_columns) members = [('parent', fe_type.parent), ('col_id', types.int64), ('data', ty_data), ('sort', types.bool_), ('target_default', types.bool_), ('target_columns', types.UniTuple(string_type, n_target_cols))] super(DataFrameGroupByModel, self).__init__(dmm, fe_type, members) make_attribute_wrapper(DataFrameGroupByType, 'parent', '_parent') make_attribute_wrapper(DataFrameGroupByType, 'col_id', '_col_id') make_attribute_wrapper(DataFrameGroupByType, 'data', '_data') make_attribute_wrapper(DataFrameGroupByType, 'sort', '_sort') make_attribute_wrapper(DataFrameGroupByType, 'target_default', '_target_default') make_attribute_wrapper(DataFrameGroupByType, 'target_columns', '_target_columns') class SeriesGroupByType(types.Type): """ Type definition for SeriesGroupBy functions handling. """ def __init__(self, parent, by_data): self.parent = parent
args = c.pyapi.tuple_pack([coords_obj, data_obj, shape_obj]) c.pyapi.decref(shape_obj) c.pyapi.decref(coords_obj) c.pyapi.decref(data_obj) with cgutils.if_unlikely(c.builder, cgutils.is_null(c.builder, args)): c.pyapi.decref(fill_value_obj) c.pyapi.decref(class_obj) c.builder.store(fail_obj, ret_ptr) ret() kwargs = c.pyapi.dict_pack([("fill_value", fill_value_obj)]) c.pyapi.decref(fill_value_obj) with cgutils.if_unlikely(c.builder, cgutils.is_null(c.builder, kwargs)): c.pyapi.decref(class_obj) c.builder.store(fail_obj, ret_ptr) ret() c.builder.store(c.pyapi.call(class_obj, args, kwargs), ret_ptr) c.pyapi.decref(class_obj) c.pyapi.decref(args) c.pyapi.decref(kwargs) return c.builder.load(ret_ptr) make_attribute_wrapper(COOType, "data", "data") make_attribute_wrapper(COOType, "coords", "coords") make_attribute_wrapper(COOType, "shape", "shape") make_attribute_wrapper(COOType, "fill_value", "fill_value")
@register_model(types.UnicodeType) class UnicodeModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('data', types.voidptr), ('length', types.intp), ('kind', types.int32), ('meminfo', types.MemInfoPointer(types.voidptr)), # A pointer to the owner python str/unicode object ('parent', types.pyobject), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(types.UnicodeType, 'data', '_data') make_attribute_wrapper(types.UnicodeType, 'length', '_length') make_attribute_wrapper(types.UnicodeType, 'kind', '_kind') ### CAST def compile_time_get_string_data(obj): """Get string data from a python string for use at compile-time to embed the string data into the LLVM module. """ from ctypes import ( CFUNCTYPE, c_void_p, c_int, py_object, c_ssize_t, POINTER, byref, cast, c_ubyte, )
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, # EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ***************************************************************************** from numba import types from numba.extending import (models, register_model, make_attribute_wrapper, ) # class StdStringViewType(types.IterableType): # TO-DO: make iterable? class StdStringViewType(types.Type): def __init__(self): super(StdStringViewType, self).__init__( name='StdStringViewType()'.format()) @register_model(StdStringViewType) class StdStringViewModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('data_ptr', types.voidptr), # pointer to std::string_view ('meminfo', types.MemInfoPointer(types.voidptr)), # NRT meminfo managing this memory ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(StdStringViewType, 'data_ptr', '_data_ptr')
class DataFrameTypeIteratorModel(StructModel): """ Model for DataFrameTypeIterator type All members must be the same as main type for this model Test: """ def __init__(self, dmm, fe_type): members = [ ('data', fe_type.data), ] super(DataFrameTypeIteratorModel, self).__init__(dmm, fe_type, members) make_attribute_wrapper(DataFrameTypeIterator, 'data', '_data') class DataFrameType(types.IterableType): """ Type definition for DataFrame functions handling. Members ---------- data: Dictinary of :class:`SeriesType` input arg index: DataFrame index *unsupported* Dictinary looks a bit ambigous due to keys are column names which already presented in Series.
self.dataframe = dataframe self.accessor = accessor super(DataFrameGetitemAccessorType, self).__init__('DataFrameGetitemAccessorType({}, {})\ '.format(dataframe, accessor)) @register_model(DataFrameGetitemAccessorType) class DataFrameGetitemAccessorTypeModel(StructModel): def __init__(self, dmm, fe_type): members = [ ('dataframe', fe_type.dataframe), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(DataFrameGetitemAccessorType, 'dataframe', '_dataframe') @intrinsic def dataframe_getitem_accessor_init(typingctx, dataframe, accessor): def dataframe_getitem_accessor_init_codegen(context, builder, signature, args): dataframe_val, accessor_val = args getitem_accessor = cgutils.create_struct_proxy( signature.return_type)(context, builder) getitem_accessor.dataframe = dataframe_val if context.enable_nrt: context.nrt.incref(builder, signature.args[0], dataframe_val) return getitem_accessor._getvalue()
class RangeIndexType(types.IterableType): dtype = types.int64 def __init__(self, is_named=False): self.is_named = is_named super(RangeIndexType, self).__init__( name='RangeIndexType({})'.format(is_named)) @property def iterator_type(self): res = RangeIndexDataType.iterator_type return res @register_model(RangeIndexType) class RangeIndexModel(models.StructModel): def __init__(self, dmm, fe_type): name_type = types.unicode_type if fe_type.is_named else types.none members = [ ('data', RangeIndexDataType), ('name', name_type), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(RangeIndexType, 'data', '_data') make_attribute_wrapper(RangeIndexType, 'name', '_name')
super(IndexValueType, self).__init__( name='IndexValueType({})'.format(val_typ)) @typeof_impl.register(IndexValue) def typeof_index(val, c): val_typ = typeof_impl(val.value, c) return IndexValueType(val_typ) @type_callable(IndexValue) def type_index_value(context): def typer(ind, mval): if ind == types.intp or ind == types.uintp: return IndexValueType(mval) return typer @register_model(IndexValueType) class IndexValueModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('index', types.intp), ('value', fe_type.val_typ), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(IndexValueType, 'index', 'index') make_attribute_wrapper(IndexValueType, 'value', 'value')
self).__init__(name='IndexValueType({})'.format(val_typ)) @typeof_impl.register(IndexValue) def typeof_index(val, c): val_typ = typeof_impl(val.value, c) return IndexValueType(val_typ) @type_callable(IndexValue) def type_index_value(context): def typer(ind, mval): if ind == types.intp or ind == types.uintp: return IndexValueType(mval) return typer @register_model(IndexValueType) class IndexValueModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('index', types.intp), ('value', fe_type.val_typ), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(IndexValueType, 'index', 'index') make_attribute_wrapper(IndexValueType, 'value', 'value')
members = [ ('data', fe_type.data), # window is able to be offset ('window', types.intp), ('min_periods', types.intp), ('center', types.boolean), ('win_type', fe_type.win_type), ('on', fe_type.on), # axis is able to be unicode type ('axis', types.intp), ('closed', fe_type.closed), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(RollingType, 'data', '_data') make_attribute_wrapper(RollingType, 'window', '_window') make_attribute_wrapper(RollingType, 'min_periods', '_min_periods') make_attribute_wrapper(RollingType, 'center', '_center') make_attribute_wrapper(RollingType, 'win_type', '_win_type') make_attribute_wrapper(RollingType, 'on', '_on') make_attribute_wrapper(RollingType, 'axis', '_axis') make_attribute_wrapper(RollingType, 'closed', '_closed') def gen_hpat_pandas_rolling_init(ty): """Generate rolling initializer based on data type""" def _hpat_pandas_rolling_init(typingctx, self, window, min_periods=None,
def __init__(self, dmm, fe_type): members = [('data', fe_type.as_array)] models.StructModel.__init__(self, dmm, fe_type, members) @register_model(SeriesType) class SeriesModel(models.StructModel): def __init__(self, dmm, fe_type): members = [ ('index', fe_type.index), ('values', fe_type.as_array), ] models.StructModel.__init__(self, dmm, fe_type, members) make_attribute_wrapper(IndexType, 'data', '_data') make_attribute_wrapper(SeriesType, 'index', '_index') make_attribute_wrapper(SeriesType, 'values', '_values') def make_index(context, builder, typ, **kwargs): return cgutils.create_struct_proxy(typ)(context, builder, **kwargs) def make_series(context, builder, typ, **kwargs): return cgutils.create_struct_proxy(typ)(context, builder, **kwargs) @lower_builtin('__array__', IndexType) def index_as_array(context, builder, sig, args): val = make_index(context, builder, sig.args[0], ref=args[0])
class DataFrameModel(models.StructModel): def __init__(self, dmm, fe_type): types_unique = set() df_types = [] for col_type in fe_type.data: if col_type in types_unique: continue types_unique.add(col_type) df_types.append(col_type) members = [ ('data', types.Tuple([types.List(typ) for typ in df_types])), ('index', fe_type.index), ('parent', types.pyobject), ] super(DataFrameModel, self).__init__(dmm, fe_type, members) class ColumnLoc(NamedTuple): type_id: int col_id: int # FIXME_Numba#3372: add into numba.types to allow returning from objmode types.DataFrameType = DataFrameType types.ColumnLoc = ColumnLoc make_attribute_wrapper(DataFrameType, 'data', '_data') make_attribute_wrapper(DataFrameType, 'index', '_index') make_attribute_wrapper(DataFrameType, 'parent', '_parent')