Major update : views
This commit is contained in:
Celine Mercier
@ -6,16 +6,12 @@ from obitools3.utils cimport bytes2str, str2bytes
|
||||
|
||||
from .capi.obidms cimport obi_dms, \
|
||||
obi_close_dms
|
||||
from .capi.obidmscolumn cimport obi_column_get_header_from_name, \
|
||||
obi_unmap_header, \
|
||||
obi_column_get_latest_version_from_name, \
|
||||
obi_create_column, \
|
||||
obi_clone_column, \
|
||||
obi_open_column, \
|
||||
obi_close_column, \
|
||||
|
||||
from .capi.obidmscolumn cimport obi_truncate_and_close_column, \
|
||||
obi_column_format_date, \
|
||||
obi_grep_line, \
|
||||
OBIDMS_column_p, \
|
||||
OBIDMS_column_header_p
|
||||
|
||||
from .capi.obitypes cimport const_char_p, \
|
||||
OBIType_t, \
|
||||
OBI_INT, \
|
||||
@ -24,42 +20,486 @@ from .capi.obitypes cimport const_char_p, \
|
||||
OBI_CHAR, \
|
||||
OBI_STR, \
|
||||
OBI_SEQ, \
|
||||
name_data_type
|
||||
name_data_type, \
|
||||
only_ATGC # discuss
|
||||
|
||||
|
||||
from ._obidms cimport OBIDMS
|
||||
from ._obidms cimport OBIDMS_column
|
||||
from ._obidms cimport OBIView_line
|
||||
|
||||
from ._obidmscolumn_int cimport OBIDMS_column_int, \
|
||||
OBIDMS_column_int_writable, \
|
||||
OBIDMS_column_int_multi_elts, \
|
||||
OBIDMS_column_int_multi_elts_writable
|
||||
OBIDMS_column_multi_elts_int
|
||||
|
||||
from ._obidmscolumn_float cimport OBIDMS_column_float, \
|
||||
OBIDMS_column_float_writable, \
|
||||
OBIDMS_column_float_multi_elts, \
|
||||
OBIDMS_column_float_multi_elts_writable
|
||||
OBIDMS_column_multi_elts_float
|
||||
|
||||
from ._obidmscolumn_bool cimport OBIDMS_column_bool, \
|
||||
OBIDMS_column_bool_writable, \
|
||||
OBIDMS_column_bool_multi_elts, \
|
||||
OBIDMS_column_bool_multi_elts_writable
|
||||
OBIDMS_column_multi_elts_bool
|
||||
|
||||
from ._obidmscolumn_char cimport OBIDMS_column_char, \
|
||||
OBIDMS_column_char_writable, \
|
||||
OBIDMS_column_char_multi_elts, \
|
||||
OBIDMS_column_char_multi_elts_writable
|
||||
OBIDMS_column_multi_elts_char
|
||||
|
||||
from ._obidmscolumn_str cimport OBIDMS_column_str, \
|
||||
OBIDMS_column_str_writable, \
|
||||
OBIDMS_column_str_multi_elts, \
|
||||
OBIDMS_column_str_multi_elts_writable
|
||||
OBIDMS_column_multi_elts_str
|
||||
|
||||
from ._obidmscolumn_seq cimport OBIDMS_column_seq, \
|
||||
OBIDMS_column_seq_writable, \
|
||||
OBIDMS_column_seq_multi_elts, \
|
||||
OBIDMS_column_seq_multi_elts_writable
|
||||
OBIDMS_column_multi_elts_seq
|
||||
|
||||
from ._obidms cimport OBIView, OBIView_line
|
||||
|
||||
from .capi.obiview cimport Obiview_p, \
|
||||
obi_new_view, \
|
||||
obi_new_view_cloned_from_name, \
|
||||
obi_open_view, \
|
||||
obi_view_delete_column, \
|
||||
obi_view_add_column, \
|
||||
obi_view_get_column, \
|
||||
obi_view_get_pointer_on_column_in_view, \
|
||||
obi_select_line, \
|
||||
obi_select_lines, \
|
||||
obi_save_and_close_view
|
||||
|
||||
from libc.stdlib cimport malloc
|
||||
from cpython.pycapsule cimport PyCapsule_New, PyCapsule_GetPointer
|
||||
|
||||
|
||||
cdef class OBIDMS_column :
|
||||
|
||||
# Should only be initialized through a subclass
|
||||
def __init__(self, OBIView view, str column_name):
|
||||
|
||||
cdef OBIDMS_column_p column_p
|
||||
cdef OBIDMS_column_p* column_pp
|
||||
|
||||
column_pp = <OBIDMS_column_p*> PyCapsule_GetPointer(((view.columns_pp)[column_name]), NULL) # or use C function
|
||||
column_p = column_pp[0] # TODO ugly cython dereferencing but can't find better
|
||||
|
||||
# Fill structure
|
||||
self.pointer = column_pp
|
||||
self.dms = view.dms
|
||||
self.view = view.pointer # TODO pointer or instance?
|
||||
self.data_type = bytes2str(name_data_type((column_p.header).returned_data_type))
|
||||
self.column_name = bytes2str((column_p.header).name)
|
||||
self.nb_elements_per_line = (column_p.header).nb_elements_per_line
|
||||
self.elements_names = (bytes2str((column_p.header).elements_names)).split(';')
|
||||
|
||||
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 __len__(self):
|
||||
return (self.pointer)[0].header.lines_used
|
||||
|
||||
def __sizeof__(self):
|
||||
return ((self.pointer)[0].header.header_size + (self.pointer)[0].header.data_size)
|
||||
|
||||
def __iter__(self):
|
||||
|
||||
# Declarations
|
||||
cdef index_t lines_used
|
||||
cdef index_t line_nb
|
||||
|
||||
# Yield each line
|
||||
lines_used = (self.pointer)[0].header.lines_used
|
||||
for line_nb in range(lines_used):
|
||||
yield self.get_line(line_nb)
|
||||
|
||||
cpdef update_pointer(self):
|
||||
self.pointer = <OBIDMS_column_p*> obi_view_get_pointer_on_column_in_view(self.view, str2bytes(self.column_name))
|
||||
|
||||
cpdef list get_elements_names(self):
|
||||
return self.elements_names
|
||||
|
||||
cpdef str get_data_type(self):
|
||||
return self.data_type
|
||||
|
||||
cpdef index_t get_nb_lines_used(self):
|
||||
return (self.pointer)[0].header.lines_used
|
||||
|
||||
cpdef str get_creation_date(self):
|
||||
return bytes2str(obi_column_format_date((self.pointer)[0].header.creation_date))
|
||||
|
||||
cpdef str get_comments(self):
|
||||
return bytes2str((self.pointer)[0].header.comments)
|
||||
|
||||
def __repr__(self) :
|
||||
cdef str to_print
|
||||
to_print = ''
|
||||
for line in self :
|
||||
to_print = to_print + str(line) + "\n"
|
||||
return to_print
|
||||
|
||||
cpdef close(self):
|
||||
if obi_truncate_and_close_column((self.pointer)[0]) < 0 :
|
||||
raise Exception("Problem closing a column")
|
||||
|
||||
|
||||
@staticmethod
|
||||
cdef object get_subclass_type(OBIDMS_column_p column_p) :
|
||||
|
||||
cdef object subclass
|
||||
cdef OBIDMS_column_header_p header
|
||||
cdef OBIType_t col_type
|
||||
cdef bint col_writable
|
||||
cdef bint col_one_element_per_line
|
||||
|
||||
header = column_p.header
|
||||
col_type = header.returned_data_type
|
||||
col_writable = column_p.writable
|
||||
col_one_element_per_line = ((header.nb_elements_per_line) == 1)
|
||||
|
||||
if col_type == OBI_INT :
|
||||
if col_one_element_per_line :
|
||||
subclass = OBIDMS_column_int
|
||||
else :
|
||||
subclass = OBIDMS_column_multi_elts_int
|
||||
elif col_type == OBI_FLOAT :
|
||||
if col_one_element_per_line :
|
||||
subclass = OBIDMS_column_float
|
||||
else :
|
||||
subclass = OBIDMS_column_multi_elts_float
|
||||
elif col_type == OBI_BOOL :
|
||||
if col_one_element_per_line :
|
||||
subclass = OBIDMS_column_bool
|
||||
else :
|
||||
subclass = OBIDMS_column_multi_elts_bool
|
||||
elif col_type == OBI_CHAR :
|
||||
if col_one_element_per_line :
|
||||
subclass = OBIDMS_column_char
|
||||
else :
|
||||
subclass = OBIDMS_column_multi_elts_char
|
||||
elif col_type == OBI_STR :
|
||||
if col_one_element_per_line :
|
||||
subclass = OBIDMS_column_str
|
||||
else :
|
||||
subclass = OBIDMS_column_multi_elts_str
|
||||
elif col_type == OBI_SEQ :
|
||||
if col_one_element_per_line :
|
||||
subclass = OBIDMS_column_seq
|
||||
else :
|
||||
subclass = OBIDMS_column_multi_elts_seq
|
||||
else :
|
||||
raise Exception("Problem with the data type")
|
||||
|
||||
return subclass
|
||||
|
||||
|
||||
######################################################################################################
|
||||
|
||||
cdef class OBIDMS_column_multi_elts(OBIDMS_column) :
|
||||
|
||||
def __getitem__(self, index_t line_nb):
|
||||
return OBIDMS_column_line(self, line_nb)
|
||||
|
||||
cpdef set_line(self, index_t line_nb, dict values):
|
||||
for element_name in values :
|
||||
self.set_item(line_nb, element_name, values[element_name])
|
||||
|
||||
######################################################################################################
|
||||
|
||||
cdef class OBIDMS_column_line :
|
||||
|
||||
def __init__(self, OBIDMS_column column, index_t line_nb) :
|
||||
self.index = line_nb
|
||||
self.column = column
|
||||
|
||||
def __getitem__(self, str element_name) :
|
||||
return self.column.get_item(self.index, element_name)
|
||||
|
||||
def __setitem__(self, str element_name, object value):
|
||||
self.column.set_item(self.index, element_name, 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))
|
||||
|
||||
##########################################
|
||||
|
||||
|
||||
cdef class OBIView :
|
||||
|
||||
def __init__(self, OBIDMS dms, str view_name, bint new=False, object view_to_clone=None, list line_selection=None):
|
||||
|
||||
cdef Obiview_p view = NULL
|
||||
cdef int i
|
||||
cdef list col_list
|
||||
cdef str col_name
|
||||
cdef OBIDMS_column column
|
||||
cdef OBIDMS_column_p column_p
|
||||
cdef OBIDMS_column_p* column_pp
|
||||
cdef OBIDMS_column_header_p header
|
||||
cdef index_t* line_selection_p
|
||||
|
||||
self.dms = dms
|
||||
|
||||
if line_selection is not None :
|
||||
line_selection_p = <index_t*> malloc((len(line_selection) + 1) * sizeof(index_t))
|
||||
for i in range(len(line_selection)) :
|
||||
line_selection_p[i] = line_selection[i] # TODO type problem?
|
||||
print(line_selection_p[i], line_selection[i])
|
||||
line_selection_p[len(line_selection)] = -1
|
||||
else :
|
||||
line_selection_p = NULL
|
||||
|
||||
if new :
|
||||
if view_to_clone is not None :
|
||||
if type(view_to_clone) == str :
|
||||
view = obi_new_view_cloned_from_name(dms.pointer, str2bytes(view_name), str2bytes(view_to_clone), line_selection_p)
|
||||
else :
|
||||
view = obi_new_view(dms.pointer, str2bytes(view_name), (<OBIView> view_to_clone).pointer, line_selection_p)
|
||||
elif view_to_clone is None :
|
||||
view = obi_new_view(dms.pointer, str2bytes(view_name), NULL, line_selection_p)
|
||||
elif not new :
|
||||
if view_name is not None :
|
||||
view = obi_open_view(dms.pointer, str2bytes(view_name))
|
||||
elif view_name is None :
|
||||
view = obi_open_view(dms.pointer, NULL)
|
||||
|
||||
if view == NULL :
|
||||
raise Exception("Error creating/opening view")
|
||||
|
||||
self.pointer = view
|
||||
self.name = bytes2str(view.name)
|
||||
|
||||
# go through columns to build list and open python object (TODO make separate function?)
|
||||
self.columns = {}
|
||||
self.columns_pp = {}
|
||||
|
||||
i = 0
|
||||
while i < view.column_count :
|
||||
column_pp = <OBIDMS_column_p*> ((view.columns)+i)
|
||||
column_p = <OBIDMS_column_p> (view.columns)[i]
|
||||
header = (column_p).header
|
||||
|
||||
col_name = bytes2str(header.name)
|
||||
col_capsule = PyCapsule_New(column_pp, NULL, NULL) # TODO discuss
|
||||
(self.columns_pp)[col_name] = col_capsule
|
||||
|
||||
subclass = OBIDMS_column.get_subclass_type(column_p)
|
||||
self.columns[col_name] = subclass(self, col_name)
|
||||
|
||||
i+=1
|
||||
|
||||
|
||||
def __repr__(self) :
|
||||
|
||||
cdef str s
|
||||
cdef OBIDMS_column column
|
||||
cdef OBIDMS_column_p column_p
|
||||
|
||||
s = self.name
|
||||
s = s + ", " + str(self.pointer.line_count) + " lines"
|
||||
for column_name in self.columns : # TODO make function in OBIDMS_column class
|
||||
column = self.columns[column_name]
|
||||
column_p = (column.pointer)[0]
|
||||
s = s + "\n" + column_name + ", version " + str(column_p.header.version) + ", data type: " + column.data_type
|
||||
return s
|
||||
|
||||
|
||||
cpdef delete_column(self, str column_name) :
|
||||
|
||||
cdef int i
|
||||
cdef Obiview_p view
|
||||
cdef OBIDMS_column column
|
||||
cdef OBIDMS_column_p column_p
|
||||
cdef OBIDMS_column_p* column_pp
|
||||
cdef OBIDMS_column_header_p header
|
||||
cdef str column_n
|
||||
|
||||
view = self.pointer
|
||||
|
||||
if obi_view_delete_column(view, str2bytes(column_name)) < 0 :
|
||||
raise Exception("Problem deleting a column from a view")
|
||||
|
||||
# Update the dictionaries of column pointers and column objects, and update pointers in column objects (make function?):
|
||||
(self.columns).pop(column_name)
|
||||
(self.columns_pp).pop(column_name)
|
||||
|
||||
i = 0
|
||||
while i < view.column_count :
|
||||
column_pp = <OBIDMS_column_p*> ((view.columns)+i)
|
||||
column_p = <OBIDMS_column_p> (view.columns)[i]
|
||||
header = (column_p).header
|
||||
col_name = bytes2str(header.name)
|
||||
col_capsule = PyCapsule_New(column_pp, NULL, NULL)
|
||||
(self.columns_pp)[col_name] = col_capsule
|
||||
i+=1
|
||||
|
||||
for column_n in self.columns :
|
||||
(self.columns[column_n]).update_pointer()
|
||||
|
||||
|
||||
cpdef add_column(self,
|
||||
str column_name,
|
||||
obiversion_t version_number=-1,
|
||||
str type='',
|
||||
index_t nb_lines=0,
|
||||
index_t nb_elements_per_line=1, # TODO 1?
|
||||
list elements_names=None,
|
||||
str avl_name="default_AVL_tree",
|
||||
str comments="",
|
||||
bint create=True # TODO
|
||||
) :
|
||||
|
||||
cdef bytes column_name_b
|
||||
cdef bytes elements_names_b
|
||||
cdef object subclass
|
||||
cdef OBIDMS_column_p* column_pp
|
||||
cdef OBIDMS_column_p column_p
|
||||
|
||||
column_name_b = str2bytes(column_name)
|
||||
|
||||
if nb_elements_per_line > 1 :
|
||||
elements_names_b = str2bytes(';'.join(elements_names))
|
||||
elif nb_elements_per_line == 1 :
|
||||
elements_names_b = column_name_b
|
||||
|
||||
if type :
|
||||
if type == 'OBI_INT' :
|
||||
data_type = OBI_INT
|
||||
elif type == 'OBI_FLOAT' :
|
||||
data_type = OBI_FLOAT
|
||||
elif type == 'OBI_BOOL' :
|
||||
data_type = OBI_BOOL
|
||||
elif type == 'OBI_CHAR' :
|
||||
data_type = OBI_CHAR
|
||||
elif type == 'OBI_STR' :
|
||||
data_type = OBI_STR
|
||||
elif type == 'OBI_SEQ' :
|
||||
data_type = OBI_SEQ
|
||||
else :
|
||||
raise Exception("Invalid provided data type")
|
||||
|
||||
if (obi_view_add_column(self.pointer, column_name_b, version_number, # should return pointer on column?
|
||||
data_type, nb_lines, nb_elements_per_line,
|
||||
elements_names_b, str2bytes(avl_name),
|
||||
str2bytes(comments), create) < 0) :
|
||||
raise Exception("Problem adding a column in a view")
|
||||
|
||||
# Store the column pointer
|
||||
|
||||
column_pp = obi_view_get_pointer_on_column_in_view(self.pointer, column_name_b)
|
||||
if column_pp == NULL :
|
||||
raise Exception("Problem getting a column in a view")
|
||||
|
||||
col_capsule = PyCapsule_New(column_pp, NULL, NULL) # TODO
|
||||
(self.columns_pp)[column_name] = col_capsule
|
||||
|
||||
# Open and store the subclass
|
||||
column_p = column_pp[0] # TODO ugly cython dereferencing
|
||||
subclass = OBIDMS_column.get_subclass_type(column_p)
|
||||
(self.columns)[column_name] = subclass(self, column_name)
|
||||
|
||||
|
||||
cpdef save_and_close(self) :
|
||||
if (obi_save_and_close_view(self.pointer) < 0) :
|
||||
raise Exception("Problem closing a view")
|
||||
|
||||
|
||||
def __iter__(self):
|
||||
# iter on each line of all columns
|
||||
|
||||
# Declarations
|
||||
cdef index_t lines_used
|
||||
cdef index_t line_nb
|
||||
cdef OBIView_line line
|
||||
|
||||
# Yield each line TODO line class
|
||||
lines_used = (self.pointer).line_count
|
||||
|
||||
for line_nb in range(lines_used) :
|
||||
line = self[line_nb]
|
||||
yield line
|
||||
|
||||
|
||||
def __getitem__(self, object item) :
|
||||
if type(item) == str :
|
||||
return (self.columns)[item]
|
||||
elif type(item) == int : # TODO int?
|
||||
return OBIView_line(self, item)
|
||||
|
||||
|
||||
cpdef select_line(self, index_t line_nb) :
|
||||
if obi_select_line(self.pointer, line_nb) < 0 :
|
||||
raise Exception("Problem selecting a line")
|
||||
|
||||
|
||||
cpdef select_lines(self, list line_selection) :
|
||||
cdef index_t* line_selection_p
|
||||
line_selection_p = <index_t*> malloc((len(line_selection) + 1) * sizeof(index_t))
|
||||
for i in range(len(line_selection)) :
|
||||
line_selection_p[i] = line_selection[i] # TODO type problem?
|
||||
line_selection_p[len(line_selection)] = -1
|
||||
if obi_select_lines(self.pointer, line_selection_p) < 0 :
|
||||
raise Exception("Problem selecting a list of lines")
|
||||
|
||||
|
||||
def __contains__(self, str column_name):
|
||||
return (column_name in self.columns)
|
||||
|
||||
|
||||
def __str__(self) :
|
||||
cdef OBIView_line line
|
||||
cdef str to_print
|
||||
to_print = ""
|
||||
for line in self.__iter__() :
|
||||
to_print = to_print + str(line) + "\n"
|
||||
return to_print
|
||||
|
||||
#############################################
|
||||
|
||||
cdef class OBIView_line :
|
||||
|
||||
def __init__(self, OBIView view, index_t line_nb) :
|
||||
self.index = line_nb
|
||||
self.view = view
|
||||
|
||||
def __getitem__(self, str column_name) :
|
||||
return ((self.view).columns)[column_name][self.index]
|
||||
|
||||
def __setitem__(self, str column_name, object value):
|
||||
# TODO detect multiple elements (dict type)? put somewhere else? but more risky (in get)
|
||||
cdef type value_type
|
||||
cdef str value_obitype
|
||||
if column_name not in self.view :
|
||||
if value == None :
|
||||
raise Exception("Trying to create a column from a None value (can't guess type)")
|
||||
value_type = type(value)
|
||||
if value_type == int :
|
||||
value_obitype = 'OBI_INT'
|
||||
elif value_type == float :
|
||||
value_obitype = 'OBI_FLOAT'
|
||||
elif value_type == bool :
|
||||
value_obitype = 'OBI_BOOL'
|
||||
elif value_type == str :
|
||||
if only_ATGC(str2bytes(value)) : # TODO
|
||||
value_obitype = 'OBI_SEQ'
|
||||
elif len(value) == 1 :
|
||||
value_obitype = 'OBI_CHAR'
|
||||
elif (len(value) > 1) :
|
||||
value_obitype = 'OBI_STR'
|
||||
else :
|
||||
raise Exception("Could not guess the type of a value to create a new column")
|
||||
self.view.add_column(column_name, type=value_obitype)
|
||||
|
||||
(((self.view).columns)[column_name]).set_line(self.index, value)
|
||||
|
||||
def __contains__(self, str column_name):
|
||||
return (column_name in self.view)
|
||||
|
||||
def __repr__(self):
|
||||
cdef dict line
|
||||
cdef str column_name
|
||||
line = {}
|
||||
for column_name in self.view.columns :
|
||||
line[column_name] = self[column_name]
|
||||
return str(line)
|
||||
|
||||
##########################################
|
||||
|
||||
cdef class OBIDMS :
|
||||
|
||||
@ -81,310 +521,12 @@ cdef class OBIDMS :
|
||||
cpdef close(self) :
|
||||
if (obi_close_dms(self.pointer)) < 0 :
|
||||
raise Exception("Problem closing an OBIDMS")
|
||||
|
||||
|
||||
cpdef dict list(self): # TDODO This is a temporary function that will be rewritten
|
||||
|
||||
# Declarations
|
||||
cdef object p
|
||||
cdef dict dms = {}
|
||||
cdef str column_name
|
||||
cdef bytes column_name_b
|
||||
cdef str data_type
|
||||
cdef str creation_date
|
||||
cdef obiversion_t latest_version
|
||||
cdef index_t line_count
|
||||
cdef OBIDMS_column_header_p header
|
||||
|
||||
p = Path(self.dms_name+'.obidms')
|
||||
|
||||
print("{:<30} {:<12} {:<25} {:<30} {:<40}".format('-Column name-',
|
||||
'-Data type-',
|
||||
'-Latest version number-',
|
||||
'-Line count of latest version-',
|
||||
'-Creation date of latest version-'))
|
||||
for entry in p.iterdir():
|
||||
if entry.suffix == ".obicol":
|
||||
column_name = entry.stem
|
||||
column_name_b = str2bytes(column_name)
|
||||
dms[column_name] = {}
|
||||
header = obi_column_get_header_from_name(self.pointer, column_name_b, -1)
|
||||
data_type = bytes2str(name_data_type(header.returned_data_type))
|
||||
line_count = header.line_count
|
||||
creation_date = bytes2str(obi_column_format_date(header.creation_date))
|
||||
obi_unmap_header(header)
|
||||
latest_version = obi_column_get_latest_version_from_name(self.pointer, column_name_b)
|
||||
dms[column_name]['data_type'] = data_type
|
||||
dms[column_name]['latest_version'] = latest_version
|
||||
dms[column_name]['line_count'] = line_count
|
||||
dms[column_name]['creation_date'] = creation_date
|
||||
print("{:<30} {:<12} {:<25} {:<30} {:<40}".format(column_name, data_type, latest_version, line_count, creation_date))
|
||||
|
||||
return dms
|
||||
|
||||
|
||||
cpdef OBIDMS_column open_column(self,
|
||||
str column_name,
|
||||
bint create=False,
|
||||
bint clone=False, bint clone_data=True,
|
||||
bint referring=False,
|
||||
obiversion_t version_number=-1,
|
||||
str type='',
|
||||
index_t nb_lines=0,
|
||||
index_t nb_elements_per_line=0,
|
||||
list elements_names=None,
|
||||
str avl_name="default_AVL_tree",
|
||||
str comments=""):
|
||||
|
||||
# Declarations
|
||||
cdef OBIDMS_column column
|
||||
cdef object subclass # TODO object?
|
||||
cdef bytes column_name_b
|
||||
cdef OBIDMS_column_header_p header
|
||||
cdef OBIType_t data_type
|
||||
|
||||
header = NULL
|
||||
|
||||
# Format the character string to send to C function
|
||||
column_name_b = str2bytes(column_name)
|
||||
|
||||
# Get the header of the latest version of the column if
|
||||
# some needed informations are not provided
|
||||
if ((not type or not nb_elements_per_line) and not create) :
|
||||
header = obi_column_get_header_from_name(self.pointer, column_name_b, version_number)
|
||||
|
||||
# Get the data type if not provided
|
||||
if not type :
|
||||
if create :
|
||||
raise Exception("A data type must be specified")
|
||||
else :
|
||||
data_type = header.returned_data_type
|
||||
else :
|
||||
if type == 'OBI_INT' :
|
||||
data_type = OBI_INT
|
||||
elif type == 'OBI_FLOAT' :
|
||||
data_type = OBI_FLOAT
|
||||
elif type == 'OBI_BOOL' :
|
||||
data_type = OBI_BOOL
|
||||
elif type == 'OBI_CHAR' :
|
||||
data_type = OBI_CHAR
|
||||
elif type == 'OBI_STR' :
|
||||
data_type = OBI_STR
|
||||
elif type == 'OBI_SEQ' :
|
||||
data_type = OBI_SEQ
|
||||
else :
|
||||
raise Exception("Invalid provided data type")
|
||||
|
||||
# Get the number of elements per line if not provided and needed
|
||||
if not nb_elements_per_line :
|
||||
if create : # Set to one if not provided (default value)
|
||||
nb_elements_per_line = 1
|
||||
else :
|
||||
nb_elements_per_line = header.returned_nb_elements_per_line
|
||||
if nb_elements_per_line > 1 :
|
||||
elements_names = bytes2str(header.elements_names).split(';')
|
||||
|
||||
if header != NULL :
|
||||
obi_unmap_header(header) # TODO check if error? but C will already warn and there's nothing to do
|
||||
|
||||
# Open the column with the right subclass depending on the data type, the mode
|
||||
# (read-only or writable) and whether there are multiple elements per line or not
|
||||
if data_type == OBI_INT :
|
||||
if (create or clone) :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_int_writable
|
||||
else :
|
||||
subclass = OBIDMS_column_int_multi_elts_writable
|
||||
else :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_int
|
||||
else :
|
||||
subclass = OBIDMS_column_int_multi_elts
|
||||
elif data_type == OBI_FLOAT :
|
||||
if (create or clone) :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_float_writable
|
||||
else :
|
||||
subclass = OBIDMS_column_float_multi_elts_writable
|
||||
else :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_float
|
||||
else :
|
||||
subclass = OBIDMS_column_float_multi_elts
|
||||
elif data_type == OBI_BOOL :
|
||||
if (create or clone) :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_bool_writable
|
||||
else :
|
||||
subclass = OBIDMS_column_bool_multi_elts_writable
|
||||
else :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_bool
|
||||
else :
|
||||
subclass = OBIDMS_column_bool_multi_elts
|
||||
elif data_type == OBI_CHAR :
|
||||
if (create or clone) :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_char_writable
|
||||
else :
|
||||
subclass = OBIDMS_column_char_multi_elts_writable
|
||||
else :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_char
|
||||
else :
|
||||
subclass = OBIDMS_column_char_multi_elts
|
||||
elif data_type == OBI_STR :
|
||||
if (create or clone) :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_str_writable
|
||||
else :
|
||||
subclass = OBIDMS_column_str_multi_elts_writable
|
||||
else :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_str
|
||||
else :
|
||||
subclass = OBIDMS_column_str_multi_elts
|
||||
elif data_type == OBI_SEQ :
|
||||
if (create or clone) :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_seq_writable
|
||||
else :
|
||||
subclass = OBIDMS_column_seq_multi_elts_writable
|
||||
else :
|
||||
if nb_elements_per_line == 1 :
|
||||
subclass = OBIDMS_column_seq
|
||||
else :
|
||||
subclass = OBIDMS_column_seq_multi_elts
|
||||
else :
|
||||
raise Exception("Problem with the data type")
|
||||
|
||||
column = subclass(self, column_name,
|
||||
create, clone, clone_data,
|
||||
referring,
|
||||
version_number, data_type,
|
||||
nb_lines, nb_elements_per_line,
|
||||
elements_names, avl_name,
|
||||
comments)
|
||||
|
||||
return column
|
||||
|
||||
|
||||
|
||||
cdef class OBIDMS_column :
|
||||
|
||||
# Should only be initialized through a subclass
|
||||
def __init__(self,
|
||||
OBIDMS dms,
|
||||
str column_name,
|
||||
bint create,
|
||||
bint clone, bint clone_data,
|
||||
bint referring,
|
||||
obiversion_t version_number,
|
||||
OBIType_t type,
|
||||
index_t nb_lines,
|
||||
index_t nb_elements_per_line,
|
||||
list elements_names,
|
||||
str avl_name,
|
||||
str comments):
|
||||
|
||||
# Declarations
|
||||
cdef bytes column_name_b
|
||||
cdef bytes dms_name_b
|
||||
cdef bytes avl_name_b
|
||||
cdef bytes elements_names_b
|
||||
cdef bytes comments_b
|
||||
|
||||
# Fill structure
|
||||
self.dms = dms
|
||||
self.data_type = bytes2str(name_data_type(type))
|
||||
self.column_name = column_name
|
||||
self.nb_elements_per_line = nb_elements_per_line
|
||||
self.elements_names = elements_names
|
||||
|
||||
# Format the character strings to send them to C functions
|
||||
column_name_b = str2bytes(column_name)
|
||||
dms_name_b = str2bytes(self.dms.dms_name)
|
||||
avl_name_b = str2bytes(avl_name)
|
||||
comments_b = str2bytes(comments)
|
||||
|
||||
# Create, clone or open column
|
||||
if create :
|
||||
if elements_names == None :
|
||||
elements_names_b = column_name_b
|
||||
else :
|
||||
elements_names_b = str2bytes(";".join(elements_names))
|
||||
self.pointer = obi_create_column(self.dms.pointer, column_name_b, type,
|
||||
nb_lines, nb_elements_per_line,
|
||||
elements_names_b, avl_name_b, comments_b,
|
||||
referring)
|
||||
else :
|
||||
if clone :
|
||||
self.pointer = obi_clone_column(self.dms.pointer, column_name_b, version_number, referring, clone_data)
|
||||
elif referring :
|
||||
self.pointer = obi_clone_column(self.dms.pointer, column_name_b, version_number, referring, False)
|
||||
referred_column_pointer = self.pointer.referred_column
|
||||
else :
|
||||
self.pointer = obi_open_column(self.dms.pointer, column_name_b, version_number)
|
||||
|
||||
|
||||
def __len__(self):
|
||||
return self.pointer.header.lines_used
|
||||
|
||||
|
||||
def __sizeof__(self):
|
||||
return (self.pointer.header.header_size + self.pointer.header.data_size)
|
||||
|
||||
|
||||
def __iter__(self):
|
||||
|
||||
# Declarations
|
||||
cdef index_t lines_used
|
||||
cdef index_t line_nb
|
||||
|
||||
# Yield each line
|
||||
lines_used = self.pointer.header.lines_used
|
||||
for line_nb in range(lines_used):
|
||||
yield self.get_line(line_nb)
|
||||
cpdef OBIView open_view(self, str view_name) :
|
||||
return OBIView(self, view_name)
|
||||
|
||||
|
||||
cpdef OBIView new_view(self, str view_name, object view_to_clone=None, list line_selection=None) :
|
||||
return OBIView(self, view_name, new=True, view_to_clone=view_to_clone, line_selection=line_selection)
|
||||
|
||||
|
||||
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)
|
||||
|
||||
|
||||
# cpdef object get_item(self, index_t line_nb, str element_name): TODO
|
||||
# raise NotImplementedError
|
||||
|
||||
|
||||
# cpdef set_item(self, index_t line_nb, str element_name, object value): TODO
|
||||
# raise NotImplementedError
|
||||
|
||||
cpdef grep_line(self, index_t line_nb):
|
||||
if obi_grep_line(self.pointer, line_nb) < 0 :
|
||||
raise Exception("Error grepping line")
|
||||
|
||||
cpdef list get_elements_names(self):
|
||||
return self.elements_names
|
||||
|
||||
|
||||
cpdef str get_data_type(self):
|
||||
return self.data_type
|
||||
|
||||
|
||||
cpdef index_t get_nb_lines_used(self):
|
||||
return self.pointer.header.lines_used
|
||||
|
||||
|
||||
cpdef str get_creation_date(self):
|
||||
return bytes2str(obi_column_format_date(self.pointer.header.creation_date))
|
||||
|
||||
cpdef str get_comments(self):
|
||||
return bytes2str(self.pointer.header.comments)
|
||||
|
||||
cpdef close(self):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user