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')
