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

Refactoring ...

Browse Source
This commit is contained in:
Eric Coissac
2016-12-29 18:22:05 +01:00
parent 0526386337
commit 65f3b16e6d
9 changed files with 1015 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
python/obitools3/dms/column/__init__.py Normal file
View File

@ -0,0 +1 @@
from .column import column # @UnresolvedImport

56
python/obitools3/dms/column/bool.pxd Normal file
View File

@ -0,0 +1,56 @@
#cython: language_level=3
from cpython.bool cimport bool, PyBool_FromLong
from ..capi.obitypes cimport index_t, \
const_char_p, \
OBIType_t, \
obibool_t, \
OBI_BOOL, \
OBIBool_NA
from ..capi.obiview cimport obi_get_bool_with_elt_name_and_col_p_in_view, \
obi_get_bool_with_elt_idx_and_col_p_in_view, \
obi_set_bool_with_elt_name_and_col_p_in_view, \
obi_set_bool_with_elt_idx_and_col_p_in_view
from ..capi.obidmscolumn cimport obi_column_get_obibool_with_elt_name, \
obi_column_get_obibool_with_elt_idx, \
obi_column_set_obibool_with_elt_name, \
obi_column_set_obibool_with_elt_idx, \
OBIDMS_column_p
from ..capi.obierrno cimport obi_errno
from .column cimport Column, \
Column_line, \
register_column_class
from obitools3.utils cimport str2bytes, bytes2str
cdef class Column_line_bool(OBIDMS_column_line) :
@staticmethod
cdef bool obibool_t2bool(obibool_t value)
@staticmethod
cdef bool2obibool_t(bool value)
cpdef bool get_bool_item_by_name(self,bytes element_name)
cpdef bool get_bool_item_by_idx(self,index_t index)
cpdef set_bool_item_by_name(self,bytes element_name,bool value)
cpdef set_bool_item_by_idx(self,index_t index,bool value)
# cdef obibool_t [:] _data_view
cdef class Column_bool(OBIDMS_column):
cdef Column _new(OBIView view,
bytes column_name,
index_t nb_elements_per_line=1,
object elements_names=None,
bytes comments=b""):
cpdef object get_line(self, index_t line_nb)
cpdef set_line(self, index_t line_nb, object value)

294
python/obitools3/dms/column/bool.pyx Normal file
View File

@ -0,0 +1,294 @@
#cython: language_level=3
cdef class OBIDMS_column_line_bool(OBIDMS_column_line) :
cdef update_pointer(self):
"""
Checks if the obicolumn address changed since the last call and update
if need the `_column_p` and `_data_view` data structure fields.
"""
cdef OBIDMS_column_p column_p = self._column_pp[0]
if column_p != self._column_p:
self._column_p = column_p
# self._data_view = (<obibool_t*> (column_p.data)) + \
# self._index * column_p.header.nb_elements_per_line
@staticmethod
cdef bool obibool_t2bool(obibool_t value):
cdef bool result
if value == OBIBool_NA :
result = None
else :
result = PyBool_FromLong(value)
return result
@staticmethod
cdef bool2obibool_t(bool value):
cdef obibool_t result
if value is None:
result=OBIBool_NA
else:
result= <obibool_t> <int> value
return result
def __init__(self, OBIDMS_column column, index_t line_nb) :
"""
Creates a new `OBIDMS_column_line_bool`
@param column: an OBIDMS_column instance
@param line_nb: the line in the column
"""
OBIDMS_column_line.__init__(self,column,line_nb)
self.update_pointer()
cpdef bool get_bool_item_by_name(self,bytes element_name):
"""
Returns the value associated to the name `element_name` of the current line
@param element_name: a `bytes` instance containing the name of the element
@return: the `bool` value corresponding to the name
"""
cdef char* cname = element_name
cdef obibool_t value
global obi_errno
self.update_pointer()
value = obi_column_get_obibool_with_elt_name(self._column_p,
self._index,
cname)
if obi_errno > 0 :
obi_errno = 0
raise KeyError("Cannot access to key %s" % bytes2str(element_name))
return OBIDMS_column_line_bool.obibool_t2bool(value)
cpdef bool get_bool_item_by_idx(self,index_t index):
"""
Returns the value associated to the name `element_name` of the current line
@param index: a `int` instance containing the index of the element
@return: the `bool` value corresponding to the name
"""
cdef obibool_t value # @DuplicatedSignature
global obi_errno
self.update_pointer()
value = obi_column_get_obibool_with_elt_idx(self._column_p,
self._index,
index)
if obi_errno > 0 :
obi_errno = 0
raise IndexError("Cannot access to element %d" % index)
return OBIDMS_column_line_bool.obibool_t2bool(value)
def __getitem__(self, object element_name) :
cdef bytes name
cdef int cindex
cdef obibool_t value
cdef type typearg = type(element_name)
cdef bool result
if typearg == int:
cindex=element_name
if cindex < 0:
cindex = self._len - cindex
result=self.get_bool_item_by_idx(cindex)
elif typearg == bytes:
result=self.get_bool_item_by_name(element_name)
elif typearg == str:
name = str2bytes(element_name)
result=self.get_bool_item_by_name(name)
return result
cpdef set_bool_item_by_name(self,bytes element_name,bool value):
"""
Sets the value associated to the name `element_name` of the current line
@param element_name: a `bytes` instance containing the name of the element
@param value: a `bool` instance of the new value
@return: the `bool` value corresponding to the name
"""
cdef char* cname = element_name
cdef obibool_t cvalue
self.update_pointer()
cvalue = OBIDMS_column_line_bool.bool2obibool_t(value)
if ( obi_column_set_obibool_with_elt_name(self._column_p,
self._index,
cname,
cvalue) < 0 ):
raise KeyError("Cannot access to key %s" % bytes2str(element_name))
cpdef set_bool_item_by_idx(self,index_t index,bool value):
"""
Sets the value associated to the name `element_name` of the current line
@param index: a `int` instance containing the index of the element
@param value: a `bool` instance of the new value
@return: the `bool` value corresponding to the name
"""
cdef obibool_t cvalue # @DuplicatedSignature
self.update_pointer()
cvalue = OBIDMS_column_line_bool.bool2obibool_t(value)
if ( obi_column_set_obibool_with_elt_idx(self._column_p,
self._index,
index,
cvalue) < 0 ):
raise IndexError("Cannot access to item index %d" % index)
def __setitem__(self, object element_name, object value):
cdef bytes name
cdef int cindex
cdef type typearg = type(element_name)
cdef bool result
if typearg == int:
cindex=element_name
if cindex < 0:
cindex = self._len - cindex
self.set_bool_item_by_idx(cindex,value)
elif typearg == bytes:
self.set_bool_item_by_name(element_name,value)
elif typearg == str:
name = str2bytes(element_name)
self.set_bool_item_by_name(name,value)
def __repr__(self) :
return str(self._column.get_line(self._index))
def __len__(self):
return self._len
cdef class OBIDMS_column_bool(OBIDMS_column):
@staticmethod
cdef OBIDMS_column _new(OBIView view,
bytes column_name,
index_t nb_elements_per_line=1,
object elements_names=None,
bytes comments=b""):
cdef bytes elements_names_b
cdef char* elements_names_p
cdef OBIDMS_column new_column
if elements_names is not None:
elements_names_b = b''.join([tobytes(x) for x in elements_names])
elements_names_p = elements_names_b
else:
elements_names_p = NULL
if (obi_view_add_column(view = view._pointer,
column_name = column_name,
version_number = -1,
alias = NULL,
data_type = OBI_BOOL,
nb_lines = len(view),
nb_elements_per_line = nb_elements_per_line,
elements_names = elements_names_p,
indexer_name = NULL,
associated_column_name = NULL,
associated_column_version = -1,
comments = comments,
create = True)<0):
raise RuntimeError("Cannot create column %s in view %s" % (bytes2str(column_name),
bytes2str(view.name)))
view.__init_columns__()
new_column = self._columns[column_name]
return new_column
@staticmethod
def new(OBIView view,
object column_name,
index_t nb_elements_per_line=1,
object elements_names=None,
object comments=b""):
return OBIDMS_column_bool._new(view,
tobytes(column_name),
nb_elements_per_line,
elements_names,
tobytes(comments))
cpdef add_to_view(self,
OBIView view,
object column_name=None,
object comments=b""):
cdef OBIDMS_column_p column_p = self._column_pp[0]
cdef bytes alias
if (column_name is None):
alias = self._alias
else:
alias = tobytes(column_name)
obi_view_add_column(view = view._ponter,
column_name = column_p.header.name,
version_number = column_p.header.version,
alias = alias,
data_type = OBI_BOOL,
nb_lines = column_p.header.lines_used,
nb_elements_per_line = column_p.header.nb_elements_per_line,
elements_names = column_p.header.elements_names,
indexer_name = NULL,
associated_column_name = NULL,
associated_column_version = NULL,
comments = tobytes(comments),
create = False)
cpdef object get_line(self, index_t line_nb):
cdef obibool_t value
cdef object result
global obi_errno
value = obi_get_bool_with_elt_idx_and_col_p_in_view(self._view._pointer, (self._pointer)[0], line_nb, 0)
if obi_errno > 0 :
raise IndexError(line_nb)
if value == OBIBool_NA :
result = None
else :
result = PyBool_FromLong(value)
return result
cpdef set_line(self, index_t line_nb, object value):
if value is None :
value = OBIBool_NA
if obi_set_bool_with_elt_idx_and_col_p_in_view(self._view._pointer, (self._pointer)[0], line_nb, 0, <obibool_t> value) < 0:
raise Exception("Problem setting a value in a column")
register_column_class(OBI_BOOL,OBIDMS_column_bool)

25
python/obitools3/dms/column/column.pxd Normal file
View File

@ -0,0 +1,25 @@
#cython: language_level=3
from .capi.obitypes cimport index_t, \
obitype_t
from .capi.obidmscolumn cimport OBIDMS_column_p
from .view cimport View
cdef class Column:
cdef OBIDMS_column_p* _pointer
cdef View _view
cpdef close(self)
cdef class Column_line:
cdef Column _column
cdef index_t _index
cpdef update(self, data)
cdef register_column_class(obitype_t obitype,
type classe,
type python)

180
python/obitools3/dms/column/column.pyx Normal file
View File

@ -0,0 +1,180 @@
#cython: language_level=3
from .capi.obitypes cimport name_data_type
from .capi.obidmscolumn cimport OBIDMS_column_header_p, \
obi_close_column, \
obi_column_prepare_to_get_value
from .capi.obiutils cimport obi_format_date
from .dms cimport __OBIDMS_COLUMN_CLASS__
from obitools3.utils cimport bytes2str
cdef class Column :
"""
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
'''
cdef OBIDMS_column_p* column_pp
if __internalCall__!=987654:
raise RuntimeError('OBIView constructor cannot be called directly')
# 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
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[0].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 __str__(self) :
cdef str to_print
to_print = ''
for line in self :
to_print = to_print + str(line) + "\n"
return to_print
def __repr__(self) :
return b"%s, original name: %s, version %d, data type: %d" % (
self._alias,
self.original_name,
self.version,
self.data_type
)
cpdef close(self):
if self._pointer != NULL:
if obi_close_column(self._pointer[0]) < 0 :
raise Exception("Problem closing column %s" % bytes2str(self.name))
# Column alias property getter and setter
@property
def name(self):
return self._alias
@name.setter
def name(self, new_alias): # @DuplicatedSignature
self._view.change_column_alias(self._alias, new_alias)
# elements_names property getter
@property
def elements_names(self):
return (((self._pointer)[0].header).elements_names).split(b';')
# nb_elements_per_line property getter
@property
def nb_elements_per_line(self):
return ((self._pointer)[0].header).nb_elements_per_line
# data_type property getter
@property
def data_type(self):
return name_data_type(((self._pointer)[0].header).returned_data_type)
# original_name property getter
@property
def original_name(self):
return ((self._pointer)[0].header).name
# version property getter
@property
def version(self):
return ((self._pointer)[0].header).version
# lines_used property getter
@property
def lines_used(self):
return (self._pointer)[0].header.lines_used
# comments property getter
@property
def comments(self):
return (self._pointer)[0].header.comments
# creation_date property getter
@property
def creation_date(self):
return obi_format_date((self._pointer)[0].header.creation_date)
######################################################################################################
cdef class Column_line :
def __init__(self, Column column, index_t line_nb) :
self._index = line_nb
self._column = column
if obi_column_prepare_to_get_value(self._column._pointer[0],line_nb) < 0:
raise IndexError("Cannot access to the line %d" % line_nb)
def __contains__(self, str element_name):
pass
#return (element_name in self._column.elements_names)
def __repr__(self) :
return str(self._column.get_line(self._index))
cpdef update(self, data):
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,
type classe,
type python):
"""
Each sub class of `OBIDMS_column` needs to be registered after its declaration
to declare its relationship with an `OBIType_t`
"""
global __OBIDMS_COLUMN_CLASS__
assert issubclass(classe,Column)
__OBIDMS_COLUMN_CLASS__[obitype]=(classe,python)