obitools/obitools3
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 66 Wiki Activity

Cython Column API

Browse Source
This commit is contained in:
Celine Mercier
2017-04-06 14:42:11 +02:00
parent 255f3c92ae
commit 8cd3e3604f
3 changed files with 372 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
python/obitools3/dms/column/__init__.py
View File

@ -1 +1 @@
from .column import column # @UnresolvedImport from .column import Column # @UnresolvedImport

39
python/obitools3/dms/column/column.pxd
View File

@ -1,7 +1,9 @@
#cython: language_level=3 #cython: language_level=3
from ..capi.obitypes cimport index_t, \ from ..capi.obitypes cimport index_t, \
obitype_t obitype_t
from ..capi.obidmscolumn cimport OBIDMS_column_p from ..capi.obidmscolumn cimport OBIDMS_column_p
from ..view.view cimport View from ..view.view cimport View
@ -9,26 +11,41 @@ from ..view.view cimport View
from ..object cimport OBIWrapper from ..object cimport OBIWrapper
cdef dict __OBIDMS_COLUMN_CLASS__
cdef class Column(OBIWrapper) : cdef class Column(OBIWrapper) :
cdef View _view cdef View _view
cdef bytes _alias
cdef inline OBIDMS_column_p pointer(self)
cpdef close(self) cpdef close(self)
@staticmethod @staticmethod
cdef type get_column_class(obitype_t obitype) cdef type get_column_class(obitype_t obitype, bint multi_elts)
@staticmethod
cdef type get_python_type(obitype_t obitype, bint multi_elts)
cdef class Column_multi_elts(Column) :
cpdef set_line(self, index_t line_nb, dict values)
cdef class Column_line:
cdef Column _column
cdef index_t _index
cpdef update(self, data)
#
# cdef class Column_line:
#
# cdef Column _column
# cdef index_t _index
#
# cpdef update(self, data)
#
#
cdef register_column_class(obitype_t obitype, cdef register_column_class(obitype_t obitype,
type classe, bint multi_elts,
type obiclass,
type python) type python)
cdef register_all_column_classes()

572
python/obitools3/dms/column/column.pyx
View File

@ -1,267 +1,361 @@
#cython: language_level=3 #cython: language_level=3
from ..capi.obitypes cimport name_data_type
__OBIDMS_COLUMN_CLASS__ = {}
from ..capi.obitypes cimport name_data_type, \
obitype_t, \
OBI_BOOL
from ..capi.obidmscolumn cimport OBIDMS_column_header_p, \ from ..capi.obidmscolumn cimport OBIDMS_column_header_p, \
obi_close_column obi_close_column, \
obi_get_elements_names
from ..capi.obiutils cimport obi_format_date from ..capi.obiutils cimport obi_format_date
from ..dms cimport __OBIDMS_COLUMN_CLASS__ from ..capi.obiview cimport obi_view_add_column, \
obi_view_get_pointer_on_column_in_view, \
Obiview_p
from obitools3.utils cimport bytes2str from ..object cimport OBIObjectClosedInstance
from obitools3.utils cimport tobytes, \
bytes2str, \
str2bytes
import importlib
import inspect
import pkgutil
cdef class Column(OBIWrapper) : cdef class Column(OBIWrapper) :
""" '''
The obitools3.dms.column.Column class wraps a C instance of a column in the context of a View The obitools3.dms.column.Column class wraps a C instance of a column in the context of a View
"""
# Note: should only be initialized through a subclass
def __init__(self,
View view,
int __internalCall__):
'''
Create a new OBDMS column objected referring to a already created column
in the context of a view.
This constructor is normally only called by subclass constructor.
@param view: The view object containing the column.
@type view: OBIView
''' '''
if __internalCall__ != 987654: cdef inline OBIDMS_column_p pointer(self) :
raise RuntimeError('OBIView constructor cannot be called directly') return <OBIDMS_column_p>(<OBIDMS_column_p*>(self._pointer))[0]
OBIWrapper.__init__(self)
# Check that the class is only created as a subclass instance
if type(self)==Column or not isinstance(self, Column):
raise RuntimeError('OBIDMS.Column constructor cannot be called directly')
# Fill structure
self._pointer = NULL
self._view = view
@staticmethod @staticmethod
cdef type get_column_class(obitype_t obitype): cdef type get_column_class(obitype_t obitype, bint multi_elts):
""" '''
Internal function returning the python class representing Internal function returning the python class representing
a column for a given obitype. a column for a given obitype.
""" '''
return __OBIDMS_COLUMN_CLASS__[obitype][0] return __OBIDMS_COLUMN_CLASS__[(obitype, multi_elts)][0]
# @staticmethod @staticmethod
# def new(OBIView view, cdef type get_python_type(obitype_t obitype, bint multi_elts): # TODO
# object column_name, '''
# index_t nb_elements_per_line=1, Internal function returning the python type representing
# object elements_names=None, an instance for a given obitype.
# object comments=b""): '''
# return __OBIDMS_COLUMN_CLASS__[(obitype, multi_elts)][1]
# cdef bytes column_name_b = tobytes(column_name)
# cdef bytes comments_b
# cdef bytes elements_names_b @staticmethod
# cdef char* elements_names_p def new_column(View view,
# cdef OBIDMS_column new_column object column_name,
# obitype_t data_type,
# if comments is not None: index_t nb_elements_per_line=1,
# comments_b = tobytes(comments) object elements_names=None,
# else: object comments=b""):
# comments_b = b''
# cdef bytes column_name_b = tobytes(column_name)
# if elements_names is not None: cdef bytes comments_b
# elements_names_b = b''.join([tobytes(x) for x in elements_names]) cdef bytes elements_names_b
# elements_names_p = elements_names_b cdef char* elements_names_p
# else:
# elements_names_p = NULL if not view.active() :
# raise OBIObjectClosedInstance()
# if (obi_view_add_column(view = view._pointer,
# column_name = column_name_b, if comments is not None:
# version_number = -1, comments_b = tobytes(comments)
# alias = NULL, else:
# data_type = self.pointer.header.returned_data_type, comments_b = b''
# nb_lines = len(view),
# nb_elements_per_line = nb_elements_per_line, if elements_names is not None:
# elements_names = elements_names_p, elements_names_b = b''.join([tobytes(x) for x in elements_names])
# indexer_name = NULL, elements_names_p = elements_names_b
# associated_column_name = NULL, else:
# associated_column_version = -1, elements_names_p = NULL
# comments = comments_b,
# create = True)<0): if (obi_view_add_column(view = view.pointer(),
# raise RuntimeError("Cannot create column %s in view %s" % (bytes2str(column_name), column_name = column_name_b,
# bytes2str(view.name))) version_number = -1,
# alias = NULL,
# return Column.open(view,column_name) data_type = <obitype_t>data_type,
# nb_lines = len(view),
# nb_elements_per_line = nb_elements_per_line,
# @staticmethod elements_names = elements_names_p,
# def open(OBIView view, indexer_name = NULL,
# object column_name): associated_column_name = NULL,
# cdef bytes column_name_b = tobytes(column_name) associated_column_version = -1,
# cdef OBIDMS_column_p* column_pp comments = comments_b,
# cdef OBIDMS_column_p column_p create = True)<0):
# cdef Column column raise RuntimeError("Cannot create column %s in view %s" % (bytes2str(column_name_b),
# cdef obitype_t column_type bytes2str(view.name)))
#
# column_pp = obi_view_get_pointer_on_column_in_view(view._pointer, return Column.open(view, column_name)
# column_name_b)
#
# if column_pp == NULL: @staticmethod
# raise KeyError("Cannot access to column %s in view %s" % ( def open(View view,
# bytes2str(column_name_b), object column_name):
# bytes2str(self.name) cdef bytes column_name_b = tobytes(column_name)
# )) cdef OBIDMS_column_p* column_pp
# cdef OBIDMS_column_p column_p
# column_p = column_pp[0] cdef Column column
# column_type = column_p.header.returned_data_type cdef obitype_t column_type
# cdef type column_class
# column = DMS.get_column_class(column_type)(view, 987654)
# column._pointer = column_pp if not view.active() :
# raise OBIObjectClosedInstance()
# return column
# column_pp = obi_view_get_pointer_on_column_in_view(view.pointer(),
# column_name_b)
# def __len__(self):
# ''' if column_pp == NULL:
# implements the len() function for the Column class raise KeyError("Cannot access to column %s in view %s" % (
# bytes2str(column_name_b),
# @rtype: `int` bytes2str(view.name)
# ''' ))
# return self.lines_used
# column_p = column_pp[0]
# column_type = column_p.header.returned_data_type
# def __sizeof__(self): column_class = Column.get_column_class(column_type, (column_p.header.nb_elements_per_line > 1))
# ''' column = OBIWrapper.new(column_class, column_pp)
# returns the size of the C object wrapped by the Column instance column._view = view
# ''' column._alias = column_name_b
# cdef OBIDMS_column_header_p header = self._pointer[0].header view.register(column)
# return header.header_size + header.data_size
# return column
#
# def __iter__(self):
# cdef index_t line_nb def add_to_view(self,
# View view,
# for line_nb in range(self.lines_used): object column_name=None) :
# yield self[line_nb]
# cdef bytes alias
# cdef OBIDMS_column_p column_p = self.pointer()
# def __str__(self) :
# cdef str to_print if not view.active() :
# to_print = '' raise OBIObjectClosedInstance()
# for line in self :
# to_print = to_print + str(line) + "\n" if (column_name is None):
# return to_print alias = self._alias
# else:
# alias = tobytes(column_name)
# def __repr__(self) :
# return b"%s, original name: %s, version %d, data type: %d" % ( if (obi_view_add_column(view = view.pointer(),
# self._alias, column_name = column_p.header.name,
# self.original_name, version_number = column_p.header.version,
# self.version, alias = alias,
# self.data_type data_type = <obitype_t>0,
# ) nb_lines = -1,
# nb_elements_per_line = -1,
# elements_names = NULL,
# cpdef close(self): indexer_name = NULL,
# if self._pointer != NULL: associated_column_name = NULL,
# if obi_close_column(self._pointer[0]) < 0 : associated_column_version = -1,
comments = NULL,
create = False) < 0):
raise RuntimeError("Cannot insert column %s (%s@%d) into view %s" %
( bytes2str(alias),
bytes2str(column_p.header.name),
column_p.header.version,
bytes2str(view.name)
))
view.register(self)
def __len__(self):
'''
implements the len() function for the Column class
@rtype: `int`
'''
return self.lines_used
def __sizeof__(self):
'''
returns the size of the C object wrapped by the Column instance
'''
cdef OBIDMS_column_header_p header = self.pointer().header
return header.header_size + header.data_size
def __iter__(self):
cdef index_t line_nb
for line_nb in range(self.lines_used):
yield self[line_nb]
def __setitem__(self, index_t line_nb, object value):
self.set_line(line_nb, value)
def __getitem__(self, index_t line_nb):
return self.get_line(line_nb)
def __str__(self) :
cdef str to_print
cdef Column_line line
to_print = ''
for line in self :
to_print = to_print + str(line) + "\n"
return to_print
def __repr__(self) :
cdef bytes s
s = self._alias + b", original name: " + self.original_name + b", version " + str2bytes(str(self.version)) + b", data type: " + self.data_type
return bytes2str(s) # TODO can't return bytes
cpdef close(self): # TODO discuss, can't be called bc then bug when closing view that tries to close it in C
cdef OBIDMS_column_p pointer
if self.active() :
pointer = self.pointer()
self._view.unregister(self)
OBIWrapper.close(self)
#if obi_close_column(pointer) < 0 :
# raise Exception("Problem closing column %s" % bytes2str(self.name)) # raise Exception("Problem closing column %s" % bytes2str(self.name))
#
#
# # Column alias property getter and setter # Column alias property getter and setter
# @property @property
# def name(self): def name(self):
# return self._alias return self._alias
# @name.setter @name.setter
# def name(self, new_alias): # @DuplicatedSignature def name(self, new_alias): # @DuplicatedSignature
# self._view.change_column_alias(self._alias, new_alias) self._view.change_column_alias(self._alias, new_alias)
#
# # elements_names property getter # elements_names property getter
# @property @property
# def elements_names(self): def elements_names(self):
# return (((self._pointer)[0].header).elements_names).split(b';') return obi_get_elements_names(self.pointer()).split(b';')
#
# # nb_elements_per_line property getter # nb_elements_per_line property getter
# @property @property
# def nb_elements_per_line(self): def nb_elements_per_line(self):
# return ((self._pointer)[0].header).nb_elements_per_line return self.pointer().header.nb_elements_per_line
#
# # data_type property getter # data_type property getter
# @property @property
# def data_type(self): def data_type(self):
# return name_data_type(((self._pointer)[0].header).returned_data_type) return name_data_type(self.pointer().header.returned_data_type)
#
# # original_name property getter # original_name property getter
# @property @property
# def original_name(self): def original_name(self):
# return ((self._pointer)[0].header).name return self.pointer().header.name
#
# # version property getter # version property getter
# @property @property
# def version(self): def version(self):
# return ((self._pointer)[0].header).version return self.pointer().header.version
#
# # lines_used property getter # lines_used property getter
# @property @property
# def lines_used(self): def lines_used(self):
# return (self._pointer)[0].header.lines_used return self.pointer().header.lines_used
#
# # comments property getter # comments property getter
# @property @property
# def comments(self): def comments(self):
# return (self._pointer)[0].header.comments return self.pointer().header.comments
#
# # creation_date property getter # creation_date property getter
# @property @property
# def creation_date(self): def creation_date(self):
# return obi_format_date((self._pointer)[0].header.creation_date) return obi_format_date(self.pointer().header.creation_date)
#
#
# ###################################################################################################### ######################################################################################################
#
#
# cdef class Column_line : cdef class Column_multi_elts(Column) :
#
# def __init__(self, Column column, index_t line_nb) : def __getitem__(self, index_t line_nb):
# self._index = line_nb return Column_line(self, line_nb)
# self._column = column
# cpdef set_line(self, index_t line_nb, dict values):
# if obi_column_prepare_to_get_value(self._column._pointer[0],line_nb) < 0: for element_name in values :
# raise IndexError("Cannot access to the line %d" % line_nb) self.set_item(line_nb, element_name, values[element_name])
#
#
# def __contains__(self, str element_name): ######################################################################################################
# pass
# #return (element_name in self._column.elements_names)
# cdef class Column_line :
#
# def __repr__(self) : def __init__(self, Column column, index_t line_nb) :
# return str(self._column.get_line(self._index)) self._index = line_nb
# self._column = column
#
# cpdef update(self, data):
# if isinstance(data, dict): def __getitem__(self, object elt_id) :
# data=data.items() return self._column.get_item(self._index, elt_id)
# for key,value in data:
# if key in self:
# self[key]=value def __setitem__(self, object elt_id, object value):
# self._column.set_item(self._index, elt_id, value)
#
# ######################################################################################################
# def __contains__(self, str element_name):
# return (element_name in self._column.elements_names)
def __repr__(self) :
return str(self._column.get_line(self._index))
cpdef update(self, data): # TODO ?????
if isinstance(data, dict):
data=data.items()
for key,value in data:
if key in self:
self[key]=value
######################################################################################################
cdef register_column_class(obitype_t obitype, cdef register_column_class(obitype_t obitype,
type classe, bint multi_elts,
type python): type obiclass,
""" type python_type):
'''
Each sub class of `OBIDMS_column` needs to be registered after its declaration Each sub class of `OBIDMS_column` needs to be registered after its declaration
to declare its relationship with an `OBIType_t` to declare its relationship with an `OBIType_t`
""" '''
global __OBIDMS_COLUMN_CLASS__ global __OBIDMS_COLUMN_CLASS__
assert issubclass(classe,Column) assert issubclass(obiclass, Column)
__OBIDMS_COLUMN_CLASS__[(obitype, multi_elts)] = (obiclass, python_type)
cdef register_all_column_classes() :
#obi3 = importlib.import_module("obitools3")
x = list(pkgutil.walk_packages()) # TODO restrain the walking
all_modules = [importlib.import_module(a[1]) for a in x if a[1].startswith("obitools3.dms.column.typed_column.")]
for mod in all_modules :
getattr(mod, 'register_class')()
register_all_column_classes()
__OBIDMS_COLUMN_CLASS__[obitype]=(classe,python)