Changeset 42


Ignore:
Timestamp:
May 11, 2009, 4:07:55 PM (11 years ago)
Author:
marchulsman
Message:

Many changes

Files:
12 edited

Legend:

Unmodified
Added
Removed
  • container/capcon.py

    r37 r42  
    11import container
    22import utility
    3 import srccon
    43import numpy
    54import operator
    65import traceback
    76import opcon
     7import itypes_py
    88
    99concaptypes = dict()
     
    5151                   return #property does already exist :(
    5252           newprops = numpy.vstack((newprops,obj._props))
    53            newprops.colnames = srccon._propfields_names
     53           newprops.colnames = itypes_py._propfields_names
    5454       else:
    5555           newprops = newprops
     
    6060    @classmethod
    6161    def _create_props(cls,obj,name,params):
    62        newprops = srccon.createProps([name],[cls],None,None,[srccon.IH_ALWAYS])
     62       newprops = itypes_py.createProps([name],[cls],None,None,[itypes_py.IH_ALWAYS])
    6363       return newprops
    6464
     
    123123    def _create_props(cls,obj,name,params):
    124124       fields = cls._find_fields(obj,params)
    125        newprops = srccon.createProps([name],[cls],[fields],None,[srccon.IH_FIELDALL])
     125       newprops = itypes_py.createProps([name],[cls],[fields],None,[itypes_py.IH_FIELDALL])
    126126       return newprops
    127127
     
    173173    def _create_props(cls,obj,name,params):
    174174       fields = cls._find_fields(obj,params)
    175        newprops = srccon.createProps([name],[cls],[fields],None,[srccon.IH_FIELDANY | srccon.AC_FIELDALL])
     175       newprops = itypes_py.createProps([name],[cls],[fields],None,[itypes_py.IH_FIELDANY | itypes_py.AC_FIELDALL])
    176176       return newprops
    177177   
     
    214214    @classmethod
    215215    def _create_props(cls,obj,name,params):
    216        newprops = srccon.createProps([name],[cls],None,[params["container_set"]],[srccon.IH_ALWAYS])
     216       newprops = itypes_py.createProps([name],[cls],None,[params["container_set"]],[itypes_py.IH_ALWAYS])
    217217       return newprops
    218218
     
    223223    def _create_props(cls,obj,name,params):
    224224       f = numpy.arange(obj.ncol,dtype="int32")
    225        newprops = srccon.createProps([name],[cls],[f],[params["con"]],[srccon.IH_ALWAYS])
     225       newprops = itypes_py.createProps([name],[cls],[f],[params["con"]],[itypes_py.IH_ALWAYS])
    226226       return newprops
    227227
  • container/container.py

    r38 r42  
    4242        if(key in self.cache):
    4343            obj._invar = self.cache[key]
    44             obj.__dict__.update(obj._invar.update)
     44            for k,v in obj._invar.update.iteritems():
     45                setattr(obj,k,v)
    4546            if(not obj._invar.vclass is None):
    4647                obj.__class__ = obj._invar.vclass
     
    103104        if(not '_fieldscon' in self.__dict__):
    104105            data = tuple((self._activefields[:,i] for i in range(self._activefields.shape[1])))
    105             self._fieldscon = srccon.PySrcCon(srccon._fieldfields,data,False)
     106            self._fieldscon = srccon.PySrcCon(itypes_py._fieldfields,data,False)
    106107        return self._fieldscon
    107108   
     
    111112
    112113        self._fields = value.matrix().view(xnumpy.XArray)
    113         self._fields.colnames = srccon._fieldfields.colnames
     114        self._fields.colnames = itypes_py._fieldfields.colnames
    114115        self._fieldscon = value
    115116
     
    128129        if(not '_propscon' in self.__dict__):
    129130            data = tuple((self._props[:,i] for i in range(self._props.shape[1])))
    130             self._propscon = srccon.PySrcCon(srccon._propfields,data,False)
     131            self._propscon = srccon.PySrcCon(itypes_py._propfields,data,False)
    131132        return self._propcon
    132133   
     
    135136        version in _propscon"""
    136137        self._props = value.matrix().view(xnumpy.XArray)
    137         self._props.colnames = srccon._propfields.name
     138        self._props.colnames = itypes_py._propfields.name
    138139        self._propcon = value
    139140   
    140141    props=property(fget=_getProps)
    141142    def _getActiveProps(self):
    142         return self._props[self._props.props & srccon.P_ACTIVE != 0]
     143        return self._props[self._props.props & itypes_py.P_ACTIVE != 0]
    143144    _activeprops=property(fget=_getActiveProps)
    144145
  • container/ibidas.py

    r4 r42  
    11import capcon
    2 import srccon
     2import itypes_py
    33import itypes_py
    44import utility
     
    1010    _nfields = 1
    1111    _fnames = ["type_id"]
    12 #    _varfields = srccon.createFields(("type_id",),(itypes_py.createType("int32"),))
     12#    _varfields = itypes_py.createFields(("type_id",),(itypes_py.createType("int32"),))
    1313
    1414    def require_type(self,*names):
     
    2929    _nfields = 1
    3030    _fnames = ["dataset_id"]
    31 #    _varfields = srccon.createFields(("dataset_id",),(itypes_py.createType("int32"),))
     31#    _varfields = itypes_py.createFields(("dataset_id",),(itypes_py.createType("int32"),))
    3232
    3333    def require_dataset(self,*names):
     
    4848
    4949    _nfields = 2
    50     _varfields = srccon.createFields(("term_id","name"),(itypes_py.createType("int32"),itypes_py.createType("str")))
     50    _varfields = itypes_py.createFields(("term_id","name"),(itypes_py.createType("int32"),itypes_py.createType("str")))
    5151
    5252class DatasetCap(capcon.VarCap):
     
    5454
    5555    _nfields = 2
    56     _varfields = srccon.createFields(("dataset_id","name"),(itypes_py.createType("int32"),itypes_py.createType("str")))
     56    _varfields = itypes_py.createFields(("dataset_id","name"),(itypes_py.createType("int32"),itypes_py.createType("str")))
    5757   
    5858    def _getChildren(self):
     
    100100    _nfields = 1
    101101    _fnames = ["bioentry_id"]
    102 #    _varfields = srccon.createFields(("dataset_id",),(itypes_py.createType("int32"),))
     102#    _varfields = itypes_py.createFields(("dataset_id",),(itypes_py.createType("int32"),))
    103103
    104104    def _getTaxons(self):
     
    127127
    128128    _nfields = 2
    129     _varfields = srccon.createFields(("taxon_id","parent_taxon_id"),(itypes_py.createType("int32"),itypes_py.createType("int32")))
     129    _varfields = itypes_py.createFields(("taxon_id","parent_taxon_id"),(itypes_py.createType("int32"),itypes_py.createType("int32")))
    130130
    131131class TaxonNamesCap(capcon.VarCap):
     
    133133
    134134    _nfields = 1
    135     _varfields = srccon.createFields(("taxon_id",),(itypes_py.createType("int32"),))
     135    _varfields = itypes_py.createFields(("taxon_id",),(itypes_py.createType("int32"),))
    136136
    137137    def _getBioentrys(self):
     
    147147
    148148    _nfields = 3
    149     _varfields = srccon.createFields(("biorelationship_id","source_bioentry_id","target_bioentry_id"),(itypes_py.createType("int32"),) * 3)
     149    _varfields = itypes_py.createFields(("biorelationship_id","source_bioentry_id","target_bioentry_id"),(itypes_py.createType("int32"),) * 3)
    150150
    151151    def _getTargets(self):
     
    171171    _name = "accessioncap"
    172172    _nfields = 2
    173     _varfields = srccon.createFields(("accession_id","accession"),(itypes_py.createType("int32"),itypes_py.createType("str")))
     173    _varfields = itypes_py.createFields(("accession_id","accession"),(itypes_py.createType("int32"),itypes_py.createType("str")))
    174174
    175175    def _getBioentrys(self):
     
    184184    _name = "bioentrycap"
    185185    _nfields = 1
    186     _varfields = srccon.createFields(("bioentry_id",),(itypes_py.createType("int32"),))
     186    _varfields = itypes_py.createFields(("bioentry_id",),(itypes_py.createType("int32"),))
    187187
    188188    def _getChildren(self):
  • container/itypes_py.py

    r4 r42  
    11from itypes import *
    22import numpy
     3import xnumpy
     4import utility
    35
    46
     
    2123    k[tc.name] = tc
    2224
     25class _NotNull(object):
     26    __slots__ = []
     27   
     28    def __repr__(self):
     29        return "NOT NULL"
     30
     31NotNull = _NotNull()
     32
     33
     34
     35######### FIELDS ###################
     36
     37#field flags
     38F_ANONYMOUS = 1 << 0
     39F_RESULT = 1 << 1
     40
     41
     42_fieldfields = numpy.array([('name',    0,  0,  createType(str),          None, NotNull), \
     43                            ('id',      10, 0,  createType("uint32"),     None, 0), \
     44                            ('props',   20, 0,  createType("uint32"),     None, 0),
     45                            ('type',    30, 0,  createType(object),       None, createType(object)), \
     46                            ('subfields',    40, 0,  createType(object),       None, None), \
     47                            ('defval',  50, 0,  createType(object),       None, None)],dtype="object").view(xnumpy.XArray)
     48_fieldfields.colnames = _fieldfields[:,0].copy() #copy to prevent recursion
     49
     50
     51########## PROPERTIES ##################
     52
     53
     54#is the property inherited?
     55IH_NONE = 1 << 0
     56IH_FIELDALL = 1 << 2
     57IH_FIELDANY = 1 << 3
     58IH_CHECK = 1 << 4
     59IH_ALWAYS = 1 << 5
     60
     61
     62#when is the property/capability active? (default: always)
     63AC_FIELDANY = 1 << 9
     64AC_FIELDALL = 1 << 10
     65AC_CHECK = 1 << 11
     66
     67#flags
     68FL_NOMODFIELD = 1 << 17 #no change field contents
     69FL_NOROWCHANGE = 1 << 18 #no change in nr. of rows
     70
     71#property props
     72P_ACTIVE = 1 << 19  #property is active
     73
     74_propfields = numpy.array([('name',     40, 0, createType(str),           None, ""),\
     75                           ('type',     50, 0, createType(object),        None, None),\
     76                           ('fields',   60, 0, createType("numpy(int32)"),None, numpy.empty((0,),dtype="int32")),\
     77                           ('nfields',  70, 0, createType("object"),      None, None),\
     78                           ('value',    80, 0, createType("object"),      None, None),\
     79                           ('props',   90, 0, createType("uint32"),       None, IH_NONE)],dtype=object).view(xnumpy.XArray)
     80_propfields_names = _propfields[:,0]
     81_propfields.colnames = _fieldfields.colnames
     82
     83
     84
     85def createProps(pname,ptype,pfields=None,pvalue=None,pihtype=None):
     86    rows = len(ptype)
     87    if(pfields is None):
     88        pfields = [_propfields[2].defval] * rows
     89    if(pvalue is None):
     90        pvalue = [_propfields[4].defval] * rows
     91    if(pihtype is None):
     92        pihtype = [_propfields[6].defval] * rows
     93
     94    nfields = []
     95    for p in pfields:
     96        nfields.append(sum(p >= 0))
     97    active = [True] * rows
     98       
     99    p = xnumpy.dimarray(transpose((pname,ptype,pfields,nfields,pvalue,active,pihtype)),object,2,2)
     100    p.colnames = _propfields_names
     101    return p
     102
     103
     104
     105idgen = utility.seqgen(1000).next
     106def createFields(fname,ftype=None,fdefval=None):
     107    rows = len(fname)
     108    if(ftype is None):
     109        ftype = [createType("unknown")] * rows
     110    if(fdefval is None):
     111        fdefval = to_defval(ftype)
     112    fidgen = [idgen() for i in range(rows)]
     113    flags = [0] * rows
     114
     115    f = xnumpy.dimarray(transpose((fname,fidgen,flags,ftype,fdefval)),object,2,2)
     116    f.colnames = _fieldfields.colnames
     117    return f
    23118
    24119
    25120def binop_type(left,right,operator):
    26     ltype=to_numpy(left)
    27     rtype=to_numpy(right)
    28     restype=getattr(numpy.array([], dtype=ltype), operator)(numpy.array([], \
    29         dtype=rtype)).dtype
    30    
    31     restype=from_numpy(restype)
    32     return restype
    33 
     121    if(isinstance(left,IType)):
     122        if(isinstance(right,IType)):
     123            if(not left.typecode & types['RSEQUENCE']):
     124                if(not right.typecode & types['RSEQUENCE']): #both types are scalars
     125                    r = chooseType(getConvertableTypes(left.typecode) & getConvertableTypes(right.typecode))
     126
     127                    #handle str,unicode,bytes data type
     128                    if(not left.typelength is None):
     129                        if(not right.typelength is None):
     130                            if(operator == '__add__'):
     131                                tl = left.typelength + right.typelength
     132                            else:
     133                                raise TypeError, "Operation not supported on these types"
     134                        else:
     135                            if(right.typecode & types['INTEGER'] and operator == '__mul__'):
     136                                tl = -1 #we could do better if we now the content, however, we don't
     137                            else:
     138                                raise TypeError, "Operation not supported on these types"
     139
     140                    else:
     141                        if(not right.typelength is None):
     142                            if(left.typecode & types['INTEGER'] and operator == '__mul__'):
     143                                tl = -1
     144                            else:
     145                                raise TypeError, "Operation not supported on these types"
     146                        else:
     147                            tl = None
     148
     149                    if(tl is None or r == types['object']):
     150                       return IType(typecode=r)
     151                    else:
     152                       return IType(typecode=r,typelength=tl)
     153
     154                else: #right type is a sequence
     155                    if(right.typecode & (types['tuple'] | types['list'] | types['array'])):
     156                        if(left.typecode & types['INTEGER'] and operator == '__mul__'):
     157                            return IType(typecode=right.typecode,typelength=-1, subtype=right.subtype)
     158                        else:
     159                            raise TypeError, "Operation not supported on these types"
     160                    else: #right type is numpy or container
     161                        subtype = binop_type(left,right.subtype,operator)
     162                        return IType(typecode=right.typecode,typelength=right.typelength,subtype=subtype)
     163
     164            else: #left type is a sequence
     165                if(not right.typecode & types['RSEQUENCE']): #left sequence, right scalar
     166                    if(left.typecode & (types['tuple'] | types['list'] | types['array'])):
     167                        if(right.typecode & types['INTEGER'] and operator == '__mul__'):
     168                            return IType(typecode=left.typecode,typelength=-1, subtype=left.subtype)
     169                        else:
     170                            raise TypeError, "Operation not supported on these types"
     171                    else: #right type is numpy or container
     172                        subtype = binop_type(left.subtype,right,operator)
     173                        return IType(typecode=left.typecode,typelength=left.typelength,subtype=subtype)
     174                else: #both are sequence
     175                    if(left.typecode & (types['tuple'] | types['list'] | types['array'])):
     176                        if(right.typecode == left.typecode and operator == '__add__'):
     177                            subtype = binop_type(left.subtype,right.subtype,'cat')
     178                            return IType(typecode=left.typecode,typelength=left.typelength + right.typelength,subtype=subtype)
     179                        else:
     180                            raise TypeError, "Operation not supported on these types"
     181                    else: #left is numpy or container
     182                        subtype = binop_type(left.subtype,right.subtype,operator)
     183
     184                        if(left.typecode == types['container'] or right.typecode == types['container']):
     185                            r = types['container']
     186                        else:
     187                            r = types['numpy']
     188
     189                        if(isinstance(left.typelength,int)):
     190                            if(isinstance(right.typelength,int)): #two one-dim sequences
     191                                tl = max(left.typelength,right.typelength)
     192                                assert ((left.typelength == 1  or left.typelength == tl) and
     193                                        (right.typelength == 1 or right.typelength == tl)), "Incompapatible type lengths"
     194                            else: #right dim is higher dimensional
     195                                assert (left.typelength == 1 or left.typelength == right.typelength[-1]), "Incompatible type lengths"
     196                                tl = right.typelength
     197                        else: #left is higher dimensional
     198                            if(isinstance(right.typelength,int)): #left highdim, right one-dim
     199                                assert (right.typelength == 1 or right.typelength == left.typelength[-1]), "Incompatible type lengths"
     200                                tl = left.typelength
     201                            else: #both higher-dim
     202                                if(len(right.typelength) < len(left.typelength)):
     203                                    assert (left.typelength[-len(right.typelength)] == right.typelength), "Incompatible type lengths"
     204                                    tl = left.typelength
     205                                else:
     206                                    assert (right.typelength[-len(left.typelength)] == left.typelength), "Incompatible type lengths"
     207                                    tl = right.typelength
     208                       
     209                        return IType(typecode=r,typelength=tl,subtype=subtype)
     210        else: #left type, right not
     211           nr = right.copy()
     212           for j in enumerate(nr.type):
     213               nr.type[j] = binop_type(left,nr.type[j],operator)
     214           return nr
     215    else: #left not a type
     216        if(isinstance(right,IType)): #left not a type, right type
     217           
     218           nr = left.copy()
     219           for i,ltype in enumerate(nr.type):
     220               nr.type[i] = binop_type(ltype,right,operator)
     221        else: #both not a type
     222            assert (len(left) > 0 and len(right) > 0),"Containers with 0 fields cannot be operated on"
     223            if(len(left) == 1):
     224                if(len(right) == 1):
     225                    nr = left.copy()
     226                    nr.name = "result"
     227                    nr.type = binop_type(left.type[0],right.type[0],operator)
     228                else:
     229                    nr = right.copy()
     230                    for i,rtype in enumerate(nr.type):
     231                        nr.type[i] = binop_type(left.type[0],rtype,operator)
     232                   
     233            else:
     234                if(len(right)==1):
     235                    nr = left.copy()
     236                    for i,ltype in enumerate(nr.type):
     237                        nr.type[i] = binop_type(ltype,right.type[0],operator)
     238                else:
     239                    if(not len(left) == len(right)):
     240                        raise TypeError, "Containers with unequal number of fields > 1 cannot be operated on"
     241                    else: #both are larger than 1
     242                        nr = left.copy()
     243                        nr.name = "result"
     244                        for i,ltype in enumerate(nr.type):
     245                            nr.type[i] = binop_type(ltype,right.type[j],operator)
     246
     247        return nr
     248
  • container/opcon.py

    r39 r42  
    44import traceback
    55import numpy
    6 import srccon
    76import utility
    87from multi_visitor import VisitorFactory,NF_ELSE
     
    1615            if('_props' in source.__dict__):
    1716                p = source._props
    18                 noih = numpy.cast[bool](p.ihtype & srccon.IH_NONE)
     17                noih = numpy.cast[bool](p.ihtype & itypes_py.IH_NONE)
    1918                if(rowchange):
    20                     noih |= numpy.cast[bool](p.ihtype & srccon.FL_NOROWCHANGE)
     19                    noih |= numpy.cast[bool](p.ihtype & itypes_py.FL_NOROWCHANGE)
    2120               
    2221                if(modfield and nfields == source.ncol):
    23                     noih |= numpy.cast[bool](p.ihtype & srccon.FL_NOMODFIELD)
     22                    noih |= numpy.cast[bool](p.ihtype & itypes_py.FL_NOMODFIELD)
    2423
    2524                #when fields are not used, they are indicated by -1's
     
    2928                        if(len(npf) > 0):
    3029                            np[i,2] = npf[sidx]
    31                     check = numpy.cast[bool](np.ihtype & (srccon.IH_FIELDALL | srccon.IH_FIELDANY))
     30                    check = numpy.cast[bool](np.ihtype & (itypes_py.IH_FIELDALL | itypes_py.IH_FIELDANY))
    3231                    if(check.any()):
    3332                        checkidx = utility.find(check)
    3433                        for i,(oldf,newf) in enumerate(zip(p.fields[check],np.fields[check])):
    3534                            ri = checkidx[i]
    36                             if(np[ri].ihtype & srccon.IH_FIELDANY):
     35                            if(np[ri].ihtype & itypes_py.IH_FIELDANY):
    3736                                check[ri] = sum(newf>=0) == 0
    3837                            else:
     
    4342                    pass
    4443                elif(fpos == -1): #no fields inherited
    45                     check = numpy.cast[bool](p.ihtype & (srccon.IH_FIELDALL | srccon.IH_FIELDANY))
     44                    check = numpy.cast[bool](p.ihtype & (itypes_py.IH_FIELDALL | itypes_py.IH_FIELDANY))
    4645                    noih |= check
    47                     np[:,2] = srccon._propfields[2,:].defval
     46                    np[:,2] = itypes_py._propfields[2,:].defval
    4847                else:   #all fields inherited, but not same place (or diff number of fields)
    4948                    if(sidx is None):
     
    5857                p = np
    5958
    60                 ihcheck = utility.find(p.ihtype == srccon.IH_CHECK)
     59                ihcheck = utility.find(p.ihtype == itypes_py.IH_CHECK)
    6160                for i in ihcheck:
    6261                    noih[i] = p[i].type.check(self,p[i])
     
    7069        if(len(propl) > 0):
    7170            props = numpy.vstack(propl)
    72             props.colnames = srccon._propfields_names
     71            props.colnames = itypes_py._propfields_names
    7372           
    7473            #check for duplicate names, while keeping ordering
     
    8988            #check if props should be active
    9089            for i,prop in enumerate(props):
    91                 if(prop.ihtype & srccon.AC_FIELDANY):
     90                if(prop.ihtype & itypes_py.AC_FIELDANY):
    9291                    props[i].active = sum(prop.fields >= 0) > 0
    93                 elif(prop.ihtype & srccon.AC_FIELDALL):
     92                elif(prop.ihtype & itypes_py.AC_FIELDALL):
    9493                    props[i].active = sum(prop.fields >= 0) == prop.nfields
    95                 elif(prop.ihtype & srccon.AC_CHECK):
     94                elif(prop.ihtype & itypes_py.AC_CHECK):
    9695                    props[i].active = prop.type.active_check(prop)
    9796                else:
     
    110109    """Binary operator container."""
    111110    def __init__(self, *source):
    112         self.source = source
     111        self._source = source
    113112   
    114113class InCon(MultiOpCon):
     
    118117       
    119118        if(sleft._invar.register(self,(sright._invar))):
    120             self._fields = srccon.createFields(('result',),(itypes_py.createType(bool),))
     119            self._fields = itypes_py.createFields(('result',),(itypes_py.createType(bool),))
    121120            self._invar.update['_fields'] = self._fields
    122121            self.deriveMultipleProps((sleft,),(None,),(0,),sleft.ncol,True)
     
    124123        MultiOpCon.__init__(self, sleft, sright)
    125124
    126 class ArithmeticOpCon(MultiOpCon, VisitorFactory(prefixes=("_arithtrans",),flags=NF_ELSE)):
     125class ArithmeticOpCon(MultiOpCon):
    127126    def __init__(self, sleft, sright, operator):
    128127        if(not isinstance(sright,container.Container)):
    129             cckey = sleft.__class__
     128            cckey = sleft.__class__ #class enough for invariant?
    130129        else:
    131130            cckey = sright._invar
    132131           
    133          
    134 
    135         assert (sleft.ncol == sright.ncol or sleft.ncol == 1 or sright.ncol == 1), \
    136             "Left and righthand number of columns should be eqaul for operator " + operator
    137        
    138132        if(sleft._invar.register(self,(operator,cckey))):
    139             restype = itypes_py.binop_type(sleft._fields.type,sright._fields.type,operator)
    140             self._fields = srccon.createFields(('result',),(restype,))
     133            if(not isinstance(sright,container.Container)):
     134                rtype = itypes_py.getType(sright)
     135                self._fields = itypes_py.binop_type(sleft._activefields,rtype,operator)
     136                self._actidx = range(len(self._fields))
     137            else:
     138                self._fields = itypes_py.binop_type(sleft._activefields,sright._activefields,operator)
     139                self._actidx = range(len(self._fields))
     140
    141141            self._invar.update['_fields'] = self._fields
    142142            self.deriveMultipleProps((sleft,sright),(None,None),(-1,-1),1,True)
    143143
    144144        MultiOpCon.__init__(self, sleft, sright,operator)
    145 
    146 
    147     def _atseq(self):
    148         if(isinstance(data[0],(list,tuple,numpy.ndarray))):
    149             pass
    150 
    151     _arithtranstuple = _atseq
    152     _arithtranslist = _atseq
    153145
    154146
     
    164156            self._fields = left._fields.copy()
    165157            self._fields.lastid = self._fields.id
    166             self._fields.id = [srccon.idgen() for i in range(left.ncol)]
     158            self._fields.id = [itypes_py.idgen() for i in range(left.ncol)]
    167159            self._invar.update['_fields'] = self._fields
    168160        MultiOpCon.__init__(self,left,right)
     
    189181            self._fields.type = [itypes_py.createType(object)] * (left.ncol + right.ncol)
    190182           
    191         self._fields.id = [srccon.idgen() for i in range(left.ncol + right.ncol)]
     183        self._fields.id = [itypes_py.idgen() for i in range(left.ncol + right.ncol)]
    192184       
    193185        if(left._invar.register(self,(right._invar,operator))):
     
    208200            self._fields = left._fields.copy()
    209201            self._fields.lastid = self._fields.id
    210             self._fields.id = [srccon.idgen() for i in range(left.ncol)]
     202            self._fields.id = [itypes_py.idgen() for i in range(left.ncol)]
    211203            self._invar.update['_fields'] = self._fields
    212204            self.deriveMultipleProps((left,right),(None,None),(0,0),left.ncol,True)
     
    340332            self._fields = source._fields.copy()
    341333            self._fields.lastid = self._fields.id
    342             self._fields.id = [srccon.idgen() for i in range(source.ncol)]
     334            self._fields.id = [itypes_py.idgen() for i in range(source.ncol)]
    343335            self._invar.update['_fields'] = self._fields
    344336
     
    346338    def __init__(self,source):
    347339        if(source._invar.register(self)):
    348             f = srccon.createFields(["result%d" % colnr for colnr in range(source.ncol)],[itypes_py.createType("bool")] * source.ncol)
     340            f = itypes_py.createFields(["result%d" % colnr for colnr in range(source.ncol)],[itypes_py.createType("bool")] * source.ncol)
    349341            self._fields = f
    350342            self._invar.update['_fields'] = f
     
    355347    def __init__(self,source):
    356348        if(source._invar.register(self)):
    357             f = srccon.createFields(["result%d" % colnr for colnr in range(source.ncol)],[itypes_py.createType("bool")] * source.ncol)
     349            f = itypes_py.createFields(["result%d" % colnr for colnr in range(source.ncol)],[itypes_py.createType("bool")] * source.ncol)
    358350            self._fields = f
    359351            self._invar.update['_fields'] = f
     
    364356    def __init__(self,source):
    365357        if(source._invar.register(self)):
    366             f = srccon.createFields(["result%d" % colnr for colnr in range(source.ncol)],utility.ensure_seq(source._fields.type))
     358            f = itypes_py.createFields(["result%d" % colnr for colnr in range(source.ncol)],utility.ensure_seq(source._fields.type))
    367359            self._fields = f
    368360            self._invar.update['_fields'] = f
     
    373365    def __init__(self,source):
    374366        if(source._invar.register(self)):
    375             f = srccon.createFields(["result%d" % colnr for colnr in range(source.ncol)],utility.ensure_seq(source._fields.type))
     367            f = itypes_py.createFields(["result%d" % colnr for colnr in range(source.ncol)],utility.ensure_seq(source._fields.type))
    376368            self._fields = f
    377369            self._invar.update['_fields'] = f
     
    382374    def __init__(self,source):
    383375       if(source._invar.register(self)):
    384             f = srccon.createFields(["result%d" % colnr for colnr in range(source.ncol)],utility.ensure_seq(source._fields.type))
     376            f = itypes_py.createFields(["result%d" % colnr for colnr in range(source.ncol)],utility.ensure_seq(source._fields.type))
    385377            self._fields = f
    386378            self._invar.update['_fields'] = f
     
    394386        if(source._invar.register(self,restype)):
    395387            restype = tuple(utility.ensure_seq(restype));
    396             f = srccon.createFields(["result%d" % colnr for colnr in range(len(restype))],restype)
     388            f = itypes_py.createFields(["result%d" % colnr for colnr in range(len(restype))],restype)
    397389            self._fields = f
    398390            self._invar.update['_fields'] = f
  • container/queryengine.py

    r37 r42  
    1111import xnumpy
    1212import numpy
    13 import srccon
    1413
    1514class Query(object):
     
    978977                nf[i].id = idconf[nf[i].id]
    979978            else:
    980                 nf[i].id = srccon.idgen()
     979                nf[i].id = itypes_py.idgen()
    981980                res.append(nf[i].id)
    982981        node.fields = nf
  • container/srccon.py

    r37 r42  
    105105                    if(isinstance(d,types.GeneratorType)):
    106106                        seq.append(d.next())
    107                     elif(d is utility.NotNull):
     107                    elif(d is itypes_py.NotNull):
    108108                        raise RuntimeError, "Field %s should be given" % field.name
    109109                    else:
     
    259259        self._res.cacheable = True
    260260
    261 ######### FIELDS ###################
    262 
    263 #field flags
    264 F_ANONYMOUS = 1 << 0
    265 F_RESULT = 1 << 1
    266 
    267 
    268 _fieldfields = numpy.array([('name',    0,  0,  itypes_py.createType(str),          None, utility.NotNull), \
    269                             ('id',      10, 0,  itypes_py.createType("uint32"),     None, 0), \
    270                             ('props',   20, 0,  itypes_py.createType("uint32"),     None, 0),
    271                             ('type',    30, 0,  itypes_py.createType(object),       None, itypes_py.createType(object)), \
    272                             ('subfields',    40, 0,  itypes_py.createType(object),       None, None), \
    273                             ('defval',  50, 0,  itypes_py.createType(object),       None, None)],dtype="object").view(xnumpy.XArray)
    274 _fieldfields.colnames = _fieldfields[:,0].copy() #copy to prevent recursion
    275 
    276 
    277 ########## PROPERTIES ##################
    278 
    279 
    280 #is the property inherited?
    281 IH_NONE = 1 << 0
    282 IH_FIELDALL = 1 << 2
    283 IH_FIELDANY = 1 << 3
    284 IH_CHECK = 1 << 4
    285 IH_ALWAYS = 1 << 5
    286 
    287 
    288 #when is the property/capability active? (default: always)
    289 AC_FIELDANY = 1 << 9
    290 AC_FIELDALL = 1 << 10
    291 AC_CHECK = 1 << 11
    292 
    293 #flags
    294 FL_NOMODFIELD = 1 << 17 #no change field contents
    295 FL_NOROWCHANGE = 1 << 18 #no change in nr. of rows
    296 
    297 #property props
    298 P_ACTIVE = 1 << 19  #property is active
    299 
    300 _propfields = numpy.array([('name',     40, 0, itypes_py.createType(str),           None, ""),\
    301                            ('type',     50, 0, itypes_py.createType(object),        None, None),\
    302                            ('fields',   60, 0, itypes_py.createType("numpy(int32)"),None, numpy.empty((0,),dtype="int32")),\
    303                            ('nfields',  70, 0, itypes_py.createType("object"),      None, None),\
    304                            ('value',    80, 0, itypes_py.createType("object"),      None, None),\
    305                            ('props',   90, 0, itypes_py.createType("uint32"),       None, IH_NONE)],dtype=object).view(xnumpy.XArray)
    306 _propfields_names = _propfields[:,0]
    307 _propfields.colnames = _fieldfields.colnames
    308 
    309 
    310 
    311 def createProps(pname,ptype,pfields=None,pvalue=None,pihtype=None):
    312     rows = len(ptype)
    313     if(pfields is None):
    314         pfields = [_propfields[2].defval] * rows
    315     if(pvalue is None):
    316         pvalue = [_propfields[4].defval] * rows
    317     if(pihtype is None):
    318         pihtype = [_propfields[6].defval] * rows
    319 
    320     nfields = []
    321     for p in pfields:
    322         nfields.append(sum(p >= 0))
    323     active = [True] * rows
    324        
    325     p = xnumpy.dimarray(itypes_py.transpose((pname,ptype,pfields,nfields,pvalue,active,pihtype)),object,2,2)
    326     p.colnames = _propfields_names
    327     return p
    328 
    329 
    330 
    331 idgen = utility.seqgen(1000).next
    332 def createFields(fname,ftype=None,fdefval=None):
    333     rows = len(fname)
    334     if(ftype is None):
    335         ftype = [itypes_py.createType("unknown")] * rows
    336     if(fdefval is None):
    337         fdefval = itypes_py.to_defval(ftype)
    338     fidgen = [idgen() for i in range(rows)]
    339     flags = [0] * rows
    340 
    341     f = xnumpy.dimarray(itypes_py.transpose((fname,fidgen,flags,ftype,fdefval)),object,2,2)
    342     f.colnames = _fieldfields.colnames
    343     return f
    344 
     261
  • container/user_if.py

    r37 r42  
    4949    #create fields
    5050    defvals = itypes_py.to_defval(fieldtypes)
    51     fields = srccon.createFields(fieldnames,fieldtypes,defvals)
     51    fields = itypes_py.createFields(fieldnames,fieldtypes,defvals)
    5252
    5353    #transform data to internally used column based form
     
    8080    #create fields
    8181    defval = itypes_py.to_defval(fieldtype)
    82     fields = srccon.createFields(fieldname,fieldtype,defval)
     82    fields = itypes_py.createFields(fieldname,fieldtype,defval)
    8383
    8484    #transform data to internally used column based form
     
    108108    #create fields
    109109    defval = itypes_py.to_defval(fieldtype)
    110     fields = srccon.createFields(fieldname,fieldtype,defval)
     110    fields = itypes_py.createFields(fieldname,fieldtype,defval)
    111111
    112112    #transform data to internally used column based form
  • container/utility.py

    r37 r42  
    3535 
    3636
    37 class _NotNull(object):
    38     __slots__ = []
    39    
    40     def __repr__(self):
    41         return "NOT NULL"
    42 
    43 NotNull = _NotNull()
    4437
    4538
  • src/itypes.c

    r31 r42  
    11#include "itypes.h"
     2#include "base_container.h"
    23#include <math.h>
    34
     
    89    PyObject_HEAD
    910    it_code typecode;
    10     long typelength;
    11     PyObject * subtypes;
     11    PyObject * typelength;
     12    PyObject * subtype;
    1213} IType;
    1314
     
    1516IType_dealloc(IType* self)
    1617{
    17     Py_XDECREF(self->subtypes);
     18    Py_XDECREF(self->subtype);
    1819    self->ob_type->tp_free((PyObject*)self);
    1920}
    2021
    21 static PyObject * _itypenew(PyTypeObject * cls,it_code typecode,long typelength,PyObject *subtypes)
     22
     23/* Creates new type. If a certain type is already in the cache that one is returned instead
     24 * Typelength: NULL if scalar
     25 *             int if dim1
     26 *             tuple with ints if dim2
     27 * Subtype:    NULL if scalar, else subtype object
     28 */
     29
     30static PyObject * _itypenew(PyTypeObject * cls,it_code typecode,PyObject * typelength,PyObject *subtype)
    2231{
    2332    IType *self = NULL;
    24     PyObject * cache, *key;
    25 
    26     key = PyString_FromString("__cache__");
    27     if(key == NULL)
    28         return NULL;
    29 
    30     cache = PyDict_GetItem(cls->tp_dict,key);
    31     if(cache == NULL || !PyDict_Check(cache))
    32     {
    33         cache = PyDict_New();
    34         if(cache == NULL)
    35             return NULL;
    36         if(PyDict_SetItem(cls->tp_dict,key,cache) == -1)
    37         {
    38             Py_DECREF(cache);
    39             return NULL;
    40         }
    41     }
    42     else
    43     {
    44         Py_INCREF(cache);
    45     }
    46     Py_DECREF(key);
    47     key = NULL;
    48    
     33    PyObject * cache, *key = NULL;
     34    int i;
     35
     36    cache = cls->tp_dict;
     37   
    4938    if(!VALID_TYPE(typecode))
    5039    {
     
    5342    }
    5443   
     44
     45    /* Fill in typelength, subtype for str, unicode, bytes type if not already done so by
     46     * caller */
    5547    if(IS_TYPE(typecode,STR | UNICODE | BYTES))
    5648    {
    5749        it_code stcode;
     50        PyObject *tmp;
    5851        switch(typecode)
    5952        {
     
    7164                break;
    7265        }
    73 
    74         if(PyTuple_Check(subtypes))
    75         {
    76             if(PyTuple_GET_SIZE(subtypes) != 1)
    77             {
    78                 PyErr_SetString(PyExc_TypeError,"Invalid subtypes set.");
     66        tmp = _itypenew(cls,stcode,NULL,NULL);
     67
     68        if(subtype != NULL && subtype != tmp)
     69        {
     70            PyErr_SetString(PyExc_TypeError,"Subtype contains invalid object");
     71            goto error;
     72        }
     73        else
     74            subtype = tmp;
     75
     76        if(typelength != NULL)
     77        {
     78            if(!PyInt_Check(typelength))
     79            {
     80                PyErr_SetString(PyExc_TypeError,"Invalid length set");
    7981                goto error;
    8082            }
    81             if(!PyObject_IsInstance(PyTuple_GET_ITEM(subtypes,0),(PyObject *)&ITypeType))
    82             {
    83                 PyErr_SetString(PyExc_TypeError,"Subtypes should contain IType objects");
    84                 goto error;
    85             }
    86             if(((IType *)PyTuple_GET_ITEM(subtypes,0))->typecode != stcode)
    87             {
    88                 PyErr_SetString(PyExc_TypeError,"Subtype not compatible with parent type");
    89                 goto error;
    90             }
    91         }
    92         else if(subtypes == Py_None)
    93         {
    94             subtypes = Py_BuildValue("(N)",_itypenew(cls,stcode,-2,Py_None));
    95         }
    96         if(typelength == -2)
    97             typelength = -1;
    98 
    99     }
    100    
    101     if(!((IS_TYPE(typecode,SEQUENCE) && typelength >= -1) || (!IS_TYPE(typecode,SEQUENCE) && typelength == -2)))
     83        }
     84        else
     85            typelength = PyInt_FromLong(L_UNKNOWN);
     86    }
     87
     88    if(typelength != NULL)
     89    {
     90        if(PyTuple_Check(typelength))
     91        {
     92            for(i = 0; i < PyTuple_GET_SIZE(typelength); i++)
     93            {
     94                if(!PyInt_Check(PyTuple_GET_ITEM(typelength,i)))
     95                {
     96                    PyErr_SetString(PyExc_TypeError,"Typelength tuple should contain integers.");
     97                    goto error;
     98                }
     99            }
     100        }
     101        else if(!PyInt_Check(typelength))
     102        {
     103            PyErr_SetString(PyExc_TypeError,"Typelength should be an integer or a tuple of integers.");
     104            goto error;
     105        }
     106    }
     107   
     108   
     109    if(!((IS_TYPE(typecode,SEQUENCE)  && typelength != NULL) ||
     110         (!IS_TYPE(typecode,SEQUENCE) && typelength == NULL)))
    102111    {
    103112        PyErr_SetString(PyExc_TypeError,"Invalid typelength set");
     
    106115
    107116   
    108     if(!((IS_TYPE(typecode,SEQUENCE) && PyTuple_Check(subtypes) && PyTuple_GET_SIZE(subtypes) > 0) ||
    109             (!IS_TYPE(typecode,SEQUENCE) && subtypes == Py_None)))
    110     {
    111         PyErr_SetString(PyExc_TypeError,"Invalid subtypes set.");
     117    if(!((IS_TYPE(typecode,SEQUENCE)  && subtype != NULL) ||
     118         (!IS_TYPE(typecode,SEQUENCE) && subtype == NULL)))
     119    {
     120        PyErr_SetString(PyExc_TypeError,"Invalid subtype set.");
    112121        goto error;
    113122    }
    114     if(PyTuple_Check(subtypes))
    115     {
    116         int st_size;
    117         int i;
    118         st_size = PyTuple_GET_SIZE(subtypes);
    119         for(i = 0; i < st_size; i++)
    120         {
    121             if(!PyObject_IsInstance(PyTuple_GET_ITEM(subtypes,i),(PyObject *)&ITypeType))
    122             {
    123                 PyErr_SetString(PyExc_TypeError,"Subtypes should contain IType objects");
    124                 goto error;
    125             }
    126         }
    127     }
    128  
    129 
    130     key = Py_BuildValue("klO",typecode,typelength,subtypes);
     123
     124    if(typelength == NULL)
     125        key = Py_BuildValue("kl",typecode,(long) subtype);
     126    else
     127        key = Py_BuildValue("kOl",typecode,typelength,(long) subtype);
     128
    131129    if(key == NULL)
    132130        goto error;
     
    134132    self = (IType *) PyDict_GetItem(cache,key);
    135133    if(self != NULL)
    136     {
    137134        Py_INCREF(self);
    138     }
    139135    else
    140136    {
     
    144140
    145141        self->typecode = typecode;
     142        Py_XINCREF(typelength);
    146143        self->typelength = typelength;
    147         Py_INCREF(subtypes);
    148         self->subtypes = subtypes;
     144        Py_XINCREF(subtype);
     145        self->subtype = subtype;
     146
    149147        if(PyDict_SetItem(cache,key,(PyObject *) self) == -1)
    150148            goto error;
    151149    }
    152     Py_DECREF(cache);
    153150    Py_DECREF(key);
    154151    return (PyObject *)self;
    155152error:
    156     Py_DECREF(cache);
    157153    Py_XDECREF(key);
    158154    Py_XDECREF(self);
     
    161157}
    162158
    163 
     159/* Main new function for IType calls from python */
    164160static PyObject * IType_new(PyTypeObject * cls, PyObject *args, PyObject *kwds)
    165161{
    166162    it_code typecode;
    167     PyObject * typec, * typec2;
    168     long typelength = -2;
    169     PyObject * subtypes = NULL;
    170     static char *kwlist[] = {"typecode", "typelength", "subtypes", NULL};
    171     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|lO", kwlist,
    172                 &typec, &typelength,&subtypes))
    173         return NULL;
    174    
     163    PyObject * typec;
     164    PyObject * typelength = NULL;
     165    PyObject * subtype = NULL, * tmp, * res;
     166    static char *kwlist[] = {"typecode", "typelength", "subtype", NULL};
     167    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist,
     168                &typec, &typelength,&subtype))
     169        return NULL;
     170   
     171    /* Typecode can also be name, convert using dict lookup */
    175172    if(!PyDict_Check(typedict))
    176173    {
     
    178175        return NULL;
    179176    }
    180     typec2 = PyDict_GetItem(typedict,typec);
    181     if(typec2 != NULL)
    182         typec = typec2;
    183        
     177    tmp = PyDict_GetItem(typedict,typec);
     178    /* replace type code if conversion found */
     179    if(tmp != NULL)
     180        typec = tmp;
     181
     182    /* Check / convert typecode to long */
    184183    if(PyInt_Check(typec))
    185184        typecode = PyInt_AsLong(typec);
     
    193192    if(PyErr_Occurred())  //Possible error in PYint/long to long conversion
    194193        return NULL;
    195 
    196     if(subtypes == NULL)
    197     {
    198         Py_INCREF(Py_None);
    199         subtypes = Py_None;
    200     }
    201    
    202     return _itypenew(cls,typecode,typelength,subtypes);
     194   
     195    /* Check typelength, ensure its a tuple (own incref after)*/
     196    if(typelength != NULL)
     197    {
     198        if(PyLong_Check(typelength))
     199        {
     200            tmp = PyInt_FromLong(PyLong_AsLong(typelength));
     201            Py_DECREF(typelength);
     202            typelength = tmp;
     203        }
     204        else if(!PyTuple_Check(typelength) && !PyInt_Check(typelength))
     205        {
     206            PyErr_SetString(PyExc_TypeError,"Incorrect typelength format (should be scalar or tuple)");
     207            return NULL;
     208        }
     209        else
     210            Py_INCREF(typelength);
     211    }
     212
     213    res = _itypenew(cls,typecode,typelength,subtype);
     214    Py_XDECREF(typelength);
     215    return res;
    203216}
    204217
     
    219232IType_gettypecode(IType *self, void *closure)
    220233{
    221     return Py_typecodes[get_type_nr(self->typecode)];
     234    PyObject * tmp = Py_typecodes[get_type_nr(self->typecode)];
     235    Py_XINCREF(tmp);
     236    return tmp;
    222237}
    223238
     
    226241IType_gettypelength(IType *self, void *closure)
    227242{
    228     return PyInt_FromLong(self->typelength);
    229 }
     243    if(self->typelength != NULL)
     244    {
     245        Py_INCREF(self->typelength);
     246        return self->typelength;
     247    }
     248    else
     249        Py_RETURN_NONE;
     250}
     251
    230252static PyObject *
    231 IType_getsubtypes(IType *self, void *closure)
    232 {
    233     Py_INCREF(self->subtypes);
    234     return self->subtypes;
     253IType_getsubtype(IType *self, void *closure)
     254{
     255    if(self->subtype != NULL)
     256    {
     257        Py_INCREF(self->subtype);
     258        return self->subtype;
     259    }
     260    else
     261        Py_RETURN_NONE;
    235262}
    236263
     
    245272     "typelength",
    246273     NULL},
    247     {"subtypes",
    248      (getter)IType_getsubtypes, NULL,
    249      "subtypes tuple",
     274    {"subtype",
     275     (getter)IType_getsubtype, NULL,
     276     "subtype",
    250277     NULL},
    251278    {NULL}  /* Sentinel */
     
    256283IType_repr(IType *self)
    257284{
    258    PyObject * res;
    259    int i,sl;
     285   PyObject * res, *tmp;;
     286   int i,ll;
     287   long tl;
     288
    260289   res = PyString_FromString(type_names[get_type_nr(self->typecode)]);
    261290   if(res == NULL)
     
    263292
    264293   /* somewhat inefficient ... */
    265    if(self->subtypes != Py_None)
     294   if(self->subtype != NULL)
    266295   {
    267        PyString_ConcatAndDel(&res,PyString_FromString("("));
     296       tmp = PyObject_Repr(self->subtype);
     297       if(tmp == NULL)
     298           return NULL;
     299       PyString_ConcatAndDel(&res,PyString_FromFormat("(%s)",PyString_AS_STRING(tmp)));
    268300       if(res == NULL)
    269301            return NULL;
    270 
    271        sl = PyTuple_GET_SIZE(self->subtypes);
    272        for(i = 0; i < sl; i++)
     302   }
     303
     304   if(self->typelength != NULL)
     305   {
     306       if(PyInt_Check(self->typelength))
    273307       {
    274            PyString_ConcatAndDel(&res,PyObject_Repr(PyTuple_GET_ITEM(self->subtypes,i)));
     308           tl = PyInt_AsLong(self->typelength);
     309           if(tl == L_UNKNOWN)
     310               PyString_ConcatAndDel(&res,PyString_FromString("[]"));
     311           else
     312               PyString_ConcatAndDel(&res,PyString_FromFormat("[%ld]",tl));
     313       }
     314       else
     315       {
     316           ll = PyTuple_GET_SIZE(self->typelength);
     317           PyString_ConcatAndDel(&res,PyString_FromString("["));
    275318           if(res == NULL)
    276319               return NULL;
    277            if(i < (sl - 1))
     320           for(i = 0; i < ll; i++)
    278321           {
    279                PyString_ConcatAndDel(&res,PyString_FromString(","));
     322               tl = PyInt_AsLong(PyTuple_GET_ITEM(self->typelength,i));
     323               if(PyErr_Occurred())
     324                  return NULL;
     325               if(tl == L_UNKNOWN)
     326                   PyString_ConcatAndDel(&res,PyString_FromString(":"));
     327               else
     328                   PyString_ConcatAndDel(&res,PyString_FromFormat("%ld",tl));
    280329               if(res == NULL)
    281330                   return NULL;
     331               
     332               if(i < (ll -1))
     333                    PyString_ConcatAndDel(&res,PyString_FromString(","));
    282334           }
     335           PyString_ConcatAndDel(&res,PyString_FromString("]"));
    283336       }
    284        PyString_ConcatAndDel(&res,PyString_FromString(")"));
    285        if(res == NULL)
    286             return NULL;
    287337   }
    288 
    289    if(self->typelength == -1)
    290        PyString_ConcatAndDel(&res,PyString_FromString("[]"));
    291    else if(self->typelength >= 0)
    292        PyString_ConcatAndDel(&res,PyString_FromFormat("[%ld]",self->typelength));
    293338   return res;
    294339}
     
    339384IType_constructor(PyObject *self, PyObject * args)
    340385{
    341     PyObject *name = NULL, *subtypes = NULL, *tsubtypes = NULL, *length = NULL;
    342     PyObject *tmp, *tmp2, *nargs = NULL, *keywords = NULL;
     386    PyObject *name = NULL, *subtype = NULL, *tlength = NULL, *length = NULL;
     387    PyObject *tmp, *tmp2, *nargs = NULL;
    343388    PyObject * res = NULL;
    344     if(!(PyString_Check(args)  || PyUnicode_Check(args)) && PySequence_Check(args))
     389    int pcounter = 0;
     390    int state = 0;
     391    int i;
     392
     393    if(!PyString_Check(args) && PySequence_Check(args))
    345394       return _callback_wrapper(self,args,IType_constructor);
    346  
     395
    347396    if(PyString_Check(args))
    348397    {
    349398        char * descr;
    350         int pcounter = 0;
    351         int state = 0;
    352         int pos = 0, oldpos = 0, i;
     399        int pos = 0, oldpos = 0;
     400
    353401        descr = PyString_AsString(args);
    354         subtypes = PyList_New(0);
     402       
     403        length = PyList_New(0);
    355404        while(descr[pos])
    356405        {
     
    359408               case '(':
    360409                    pcounter++;
    361                     if(state == 0)
     410                    if(state == STATE_START)
    362411                    {
    363412                        name =  PySequence_GetSlice(args,oldpos,pos);
     
    365414                            return NULL;
    366415                        oldpos = pos;
    367                         state = 1;
     416                        state = STATE_INSUBTYPE;
    368417                    }
    369                     else if(state > 1)
     418                    else if(state != STATE_INSUBTYPE)
    370419                    {
    371420                        PyErr_SetString(PyExc_TypeError,"Unexpected ( encoutered");
     
    374423                    break;
    375424               case ')':
    376                case ',':
    377                     if(state != 1)
     425                    if(state != STATE_INSUBTYPE)
    378426                    {
    379427                        PyErr_SetString(PyExc_TypeError,"Unexpected , or ) encoutered");
     
    382430                    else if(pcounter == 1)
    383431                    {
    384                         tmp2 = PySequence_GetSlice(args,oldpos + 1,pos);
    385                         if(tmp2 == NULL) return NULL;
    386                         tmp = IType_constructor(self,tmp2);
    387                         Py_DECREF(tmp2);
    388                         if(tmp == NULL)
     432                        tmp = PySequence_GetSlice(args,oldpos + 1,pos);
     433                        if(tmp == NULL) return NULL;
     434                        subtype = IType_constructor(self,tmp);
     435                        Py_DECREF(tmp);
     436                        if(subtype == NULL)
    389437                            goto error;
    390                        
    391                         if(PyList_Append(subtypes,tmp) == -1)
    392                         {
    393                             Py_DECREF(tmp);
    394                             goto error;
    395                         }
    396                         Py_DECREF(tmp);
    397438                        oldpos = pos;
    398                         if(descr[pos] == ')')
    399                             state = 2;
     439                        state = STATE_ENDSUBTYPE;
    400440                    }
    401                     if(descr[pos] == ')')
    402                         pcounter--;
     441                    pcounter--;
    403442                    break;
    404443               case '[':
    405                         if(state == 1)
    406                             state = 5;
    407                         else if(state == 2)
     444                        if(state == STATE_INSUBTYPE)
     445                            state = STATE_SUBTYPEINBLOCK;
     446                        else if(state == STATE_ENDSUBTYPE)
    408447                        {
     448                            state = STATE_INBLOCK;
     449                            oldpos = pos;
    409450                            pcounter++;
    410                             state = 3;
    411                             oldpos = pos;
    412451                        }
    413452                        else
     
    417456                        }
    418457                        break;
     458               case ',':
    419459               case ']':
    420                         if(state == 5)
    421                             state = 1;
    422                         else if(state == 3)
     460                        if(state == STATE_SUBTYPEINBLOCK && descr[pos] == ']')
     461                            state = STATE_INSUBTYPE;
     462                        else if(state == STATE_INBLOCK)
    423463                        {
    424                             pcounter--;
    425                        
    426                             tmp = PySequence_GetSlice(args,oldpos+1,pos);
    427                             if(tmp == NULL)
     464                            if(oldpos + 1 < pos)
     465                            {
     466                                tmp = PySequence_GetSlice(args,oldpos+1,pos);
     467                                if(tmp == NULL)
     468                                    return NULL;
     469                                char * k = PyString_AsString(tmp);
     470                                tmp2 = PyInt_FromString(k,NULL,10);
     471                                Py_DECREF(tmp);
     472                            }
     473                            else
     474                                tmp2 = PyInt_FromLong(L_UNKNOWN);
     475                            if(tmp2 == NULL)
    428476                                return NULL;
    429                             else
     477                            if(PyList_Append(length,tmp2) < 0)
     478                                return NULL;
     479                            Py_DECREF(tmp2);
     480                            oldpos = pos;
     481                            if(descr[pos] == ']')
    430482                            {
    431                                 char * k = PyString_AsString(tmp);
    432                                 length = PyInt_FromString(k,NULL,10);
    433                                 if(length == NULL)
    434                                 {
    435                                     Py_DECREF(tmp);
    436                                     return NULL;
    437                                 }
     483                                pcounter--;
     484                                state = 4;
    438485                            }
    439                             Py_DECREF(tmp);
    440                             state = 4;
    441486                        }
    442487                        else
     
    449494           pos ++;
    450495        }
    451         if(pcounter > 0 || state == 1 || state == 3)
     496
     497        if(pcounter > 0 || state == STATE_INSUBTYPE || state == STATE_INBLOCK)
    452498        {
    453499             PyErr_SetString(PyExc_TypeError,"Unexpected end of descriptor");
    454500             goto error;
    455501        }
    456         keywords = PyDict_New();
    457         tsubtypes = PyTuple_New(PyList_GET_SIZE(subtypes));
    458         for(i = 0; i < PyList_GET_SIZE(subtypes); i++)
    459         {
    460             tmp = PyList_GET_ITEM(subtypes,i);
    461             Py_INCREF(tmp);
    462             PyTuple_SET_ITEM(tsubtypes,i,PyList_GET_ITEM(subtypes,i));
    463         }
    464 
    465 
    466         if(state == 0)
    467             nargs = Py_BuildValue("(OiO)",args,-2,Py_None);
    468         else if(state == 2)
    469             nargs = Py_BuildValue("(NiN)",name,-1,tsubtypes);
    470         else if(state == 4)
    471             nargs = Py_BuildValue("(NNN)",name,length,tsubtypes);
     502       
     503        /* copy lengths from list to integer or tuple of integers */
     504        if(PyList_GET_SIZE(length) == 1)
     505        {
     506            tlength = PyList_GET_ITEM(length,0);
     507            Py_INCREF(tlength);
     508        }
     509        else if(PyList_GET_SIZE(length) != 0)
     510        {
     511            tlength = PyTuple_New(PyList_GET_SIZE(length));
     512            for(i = 0; i < PyList_GET_SIZE(length); i++)
     513            {
     514                tmp = PyList_GET_ITEM(length,i);
     515                Py_INCREF(tmp);
     516                PyTuple_SET_ITEM(tlength,i,PyList_GET_ITEM(length,i));
     517            }
     518        }
     519
     520        /* create args for constructor call */
     521        if(state == STATE_START)
     522            nargs = PyTuple_Pack(1,args);
     523        else if(state == STATE_ENDSUBTYPE)
     524            nargs = Py_BuildValue("(NiN)",name,L_UNKNOWN,subtype);
     525        else if(state == STATE_ENDBLOCK)
     526            nargs = Py_BuildValue("(NNN)",name,tlength,subtype);
    472527       
    473528        if(nargs == NULL)
    474529            goto error;
    475530       
    476         res = IType_new(&ITypeType,nargs,keywords);
     531        res = IType_new(&ITypeType,nargs,NULL);
    477532       
    478533
    479         Py_DECREF(nargs); //should decref name, length, tsubtypes
    480         Py_DECREF(keywords);
    481         Py_DECREF(subtypes);
     534        Py_DECREF(nargs); //should decref name, tlength,subtype
     535        Py_DECREF(length);
    482536    }
    483537    else
     
    497551error:
    498552    Py_XDECREF(name);
    499     Py_XDECREF(subtypes);
    500     Py_XDECREF(tsubtypes);
     553    Py_XDECREF(subtype);
     554    Py_XDECREF(tlength);
    501555    Py_XDECREF(length);
    502     Py_XDECREF(keywords);
    503556    return NULL;
    504557}
    505558
     559/* returns type of object in args */
    506560static PyObject *
    507561IType_getType(PyObject *self, PyObject *args)
    508562{
    509563    PyObject * pytc;
     564    it_code typecode;
     565    PyObject * ar_length = NULL;
     566    PyObject * subtype = NULL;
    510567    PyObject * res;
    511     PyObject * subtypes;
    512     long arlength = -2;
    513     it_code typecode;
     568
    514569    if(convdict == NULL)
    515570        return NULL;
    516    
     571   
     572    /* obtain type code */
    517573    pytc = register_pytype(args);
    518574    if(pytc == NULL)
     
    523579        return NULL;
    524580
     581    /* get sequence length */
    525582    if(IS_TYPE(typecode,SEQUENCE))
    526         arlength = PySequence_Length(args);
    527    
     583    {
     584        long tlength = PySequence_Length(args);
     585        ar_length = PyInt_FromLong(tlength);
     586        if(ar_length == NULL)
     587            return NULL;
     588    }
     589   
     590    /* get subtype */
    528591    if(IS_TYPE(typecode,RSEQUENCE))
    529592    {
    530        subtypes = _getseqtype(self,args,typecode,1);
    531         if(subtypes == NULL)
    532             return NULL;
    533     }
    534     else
    535     {
    536         Py_INCREF(Py_None);
    537         subtypes = Py_None;
    538     }
    539    
    540     res = _itypenew(&ITypeType,typecode,arlength,subtypes);
    541     Py_DECREF(subtypes);
     593       subtype = _getseqtype(self,args,typecode,1);
     594       if(subtype == NULL)
     595            return NULL;
     596    }
     597   
     598    res = _itypenew(&ITypeType,typecode,ar_length,subtype);
     599    Py_XDECREF(ar_length);
     600    Py_XDECREF(subtype);
    542601    return res;
    543602}
     603
    544604
    545605static PyObject * IType_getSeqType(PyObject * self, PyObject *args)
     
    556616        return NULL;
    557617
    558     res2 = ((IType *)res)->subtypes;
    559     if(PyTuple_Check(res2) && PyTuple_GET_SIZE(res2) == 1)
    560         res2 = PyTuple_GET_ITEM(res2,0);
    561  
    562    
     618    res2 = ((IType *)res)->subtype;
    563619    Py_XINCREF(res2);
    564620    Py_DECREF(res);
     
    579635    }
    580636    argslength = PySequence_Length(args);
    581     if(argslength == -1)
     637    if(argslength == L_UNKNOWN)
    582638        return NULL;
    583639   
     
    591647        if(type == NULL)
    592648            return NULL;
    593         stype = type->subtypes;
    594        
    595         if(PyTuple_Check(stype) && PyTuple_GET_SIZE(stype) == 1)
    596             stype = PyTuple_GET_ITEM(stype,0);
    597            
     649        stype = type->subtype;
    598650        Py_XINCREF(stype);
    599651        Py_DECREF(type);
    600         PyTuple_SET_ITEM(res,i,stype);
     652        if(stype != NULL)
     653            PyTuple_SET_ITEM(res,i,stype);
     654        else
     655        {
     656           
     657            PyErr_SetString(PyExc_TypeError,"Incorrect subtype.");
     658            return NULL;
     659        }
    601660    }
    602661    return res;
     
    608667    int i;
    609668    Py_ssize_t nrow;
    610     Py_ssize_t ncol = -1, currow = 0;
     669    Py_ssize_t ncol = L_UNKNOWN, currow = 0;
    611670    PyObject * res = NULL, * tmp;
    612671    PyObject * iter = NULL;
     
    625684    }
    626685    nrow = PySequence_Length(obj);
    627     if(nrow == -1)
     686    if(nrow == L_UNKNOWN)
    628687        return NULL;
    629688
     
    640699    while((item = PyIter_Next(iter)))
    641700    {
    642         if(ncol == -1) //initialization
     701        if(ncol == L_UNKNOWN) //initialization
    643702        {
    644703            if(!PySequence_Check(item))
     
    648707            }
    649708            ncol = PySequence_Length(item);
    650             if(ncol == -1)
     709            if(ncol == L_UNKNOWN)
    651710                goto error;
    652711
     
    745804{
    746805    it_code typecode;
    747     long typelength;
     806    PyObject *typelength;
    748807    PyObject *name;
    749808    PyObject *dtype;
     
    765824    {
    766825        typelength = ((IType *)obj)->typelength;
    767         if(typelength == -1)
     826        if(typelength == NULL || PyTuple_Check(typelength) || (PyInt_Check(typelength) && PyInt_AsLong(typelength) == L_UNKNOWN))
    768827        {
    769828            Py_DECREF(name);
     
    771830        }
    772831        else
    773             PyString_ConcatAndDel(&name,PyString_FromFormat("%ld",typelength)); 
     832            PyString_ConcatAndDel(&name,PyString_FromFormat("%ld",PyInt_AsLong(typelength))); 
    774833        if(name == NULL)
    775834            return NULL;
     
    799858
    800859        if(IS_TYPE(typecode,~(SEQUENCE)))
    801         {
    802             res = _itypenew(&ITypeType,typecode,-2,Py_None);
    803         }
     860            res = _itypenew(&ITypeType,typecode,NULL,NULL);
    804861        else
    805862        {
     
    834891                return NULL;
    835892            if(length == 0)
    836                 length = -1;
    837             res = _itypenew(&ITypeType,typecode,length,Py_None);
     893                length = L_UNKNOWN;
     894            res = _itypenew(&ITypeType,typecode,PyInt_FromLong(length),NULL);
    838895            Py_DECREF(itemsize);
    839896        }
     
    856913        int i;
    857914        Py_ssize_t length = PySequence_Length(args);
    858         if(length == -1)
     915        if(length == L_UNKNOWN)
    859916            return NULL;
    860917        res = PyTuple_New(length);
     
    874931        return res;
    875932    }
     933}
     934
     935
     936
     937
     938
     939static PyObject * chooseType(PyObject *self, PyObject *typecodes)
     940{
     941    if(PyInt_Check(typecodes))
     942    {
     943        PyObject * res;
     944        long tcs = PyInt_AsLong(typecodes);
     945        if(PyErr_Occurred())
     946            return NULL;
     947        tcs = choose_type(tcs);
     948        res = PyInt_FromLong(tcs);
     949        return res;
     950    }
     951
     952    PyErr_SetString(PyExc_TypeError,"Argument should be an integer");
     953    return NULL;
     954}
     955
     956
     957static PyObject * getConvertableTypes(PyObject * self, PyObject *typecode)
     958{
     959    if(PyInt_Check(typecode))
     960    {
     961        PyObject * res;
     962        long tcs = PyInt_AsLong(typecode);
     963        if(PyErr_Occurred())
     964            return NULL;
     965        tcs = get_convertable_types(tcs);
     966        res = PyInt_FromLong(tcs);
     967        return res;
     968    }
     969
     970    PyErr_SetString(PyExc_TypeError,"Argument should be an integer");
     971    return NULL;
     972}
     973
     974static PyObject * getCompatibleTypes(PyObject * self, PyObject *typecode)
     975{
     976    if(PyInt_Check(typecode))
     977    {
     978        PyObject * res;
     979        long tcs = PyInt_AsLong(typecode);
     980        if(PyErr_Occurred())
     981            return NULL;
     982        tcs = get_compatible_types(tcs);
     983        res = PyInt_FromLong(tcs);
     984        return res;
     985    }
     986
     987    PyErr_SetString(PyExc_TypeError,"Argument should be an integer");
     988    return NULL;
    876989}
    877990
     
    886999    {"to_numpy", (PyCFunction) IType_to_numpy, METH_O, "Type to numpy dtype convertor"},
    8871000    {"to_defval", (PyCFunction) IType_to_defval, METH_O, "Return default value for this type."},
     1001    {"chooseType", (PyCFunction) chooseType, METH_O, "Returns most specific/smallest type."},
     1002    {"getConvertableTypes", (PyCFunction) getConvertableTypes, METH_O, "Returns the types a specific type can be converted to."},
     1003    {"getCompatibleTypes", (PyCFunction) getCompatibleTypes, METH_O, "Returns the types a specific type can be converted to without loss."},
    8881004    {NULL}  /* Sentinel */
    8891005};
    8901006
    891 static PyObject * _common_subtypes(PyObject * args1,PyObject * args2)
     1007
     1008/* combine two type descriptions, finds common supertype, otherwise returns NULL */
     1009static PyObject * _common_subtype(IType * args1,IType * args2)
    8921010{
    8931011    PyObject * res;
    894     IType * tmp1, * tmp2;
    895     int i, nst;
    896     long nlength;
     1012    PyObject * tmp1, * tmp2;
     1013    int i;
    8971014    it_code ntc;
    8981015    if(args1 == NULL || args2 == NULL)
     
    9011018        {
    9021019            Py_INCREF(args2);
    903             return args2;
     1020            return (PyObject *) args2;
    9041021        }
    9051022        else if(args1 != NULL && args2 == NULL)
    9061023        {
    9071024            Py_INCREF(args1);
    908             return args1;
     1025            return (PyObject *) args1;
    9091026        }
    9101027        else return NULL;
    9111028    }
    912     if(!PyTuple_Check(args1) || !PyTuple_Check(args2))
    913         return NULL;
    914     if(PyTuple_GET_SIZE(args1) != PyTuple_GET_SIZE(args2))
    915         return Py_BuildValue("(O)",Py_typecodes[IUNKNOWN]);
    916    
    917     nst = PyTuple_GET_SIZE(args1);
    918     res = PyTuple_New(nst);
    919     for(i = 0; i < nst; i++)
    920     {
    921         tmp1 = (IType *)  PyTuple_GET_ITEM(args1,i);
    922         tmp2 = (IType *) PyTuple_GET_ITEM(args2,i);
    923         if(tmp1 == tmp2)
    924         {
    925             Py_INCREF(tmp1);
    926             PyTuple_SET_ITEM(res,i,(PyObject *)tmp1);
    927         }
    928         ntc = choose_type(get_compatible_types(tmp1->typecode) & get_compatible_types(tmp2->typecode));
    929         if(IS_TYPE(ntc,SEQUENCE))
    930         {
    931             nlength = MAX(tmp1->typelength,tmp2->typelength);
    932             PyTuple_SET_ITEM(res,i,_itypenew(&ITypeType,ntc,nlength,_common_subtypes(tmp1->subtypes,tmp2->subtypes)));
     1029 
     1030    if(!PyObject_IsInstance((PyObject *)args1,(PyObject *)&ITypeType) ||
     1031       !PyObject_IsInstance((PyObject *)args2,(PyObject *)&ITypeType))
     1032        return NULL;
     1033
     1034    if(args1 == args2)
     1035    {
     1036        Py_INCREF(args1);
     1037        res = (PyObject *) args1;
     1038    }
     1039    ntc = choose_type(get_compatible_types(args1->typecode) & get_compatible_types(args2->typecode));
     1040    if(IS_TYPE(ntc,SEQUENCE))
     1041    {
     1042        PyObject * length;
     1043        if(args1->typelength == NULL && args2->typelength == NULL)
     1044            length = NULL;
     1045        else if(PyInt_Check(args1->typelength) && PyInt_Check(args2->typelength))
     1046        {
     1047           length = (PyObject *) ((PyInt_AsLong((PyObject *)args1->typelength) > PyInt_AsLong((PyObject *)args2->typelength)) ? args1->typelength : args2->typelength);
     1048           Py_INCREF(length);
     1049        }
     1050        else if(PyTuple_Check(args1->typelength) && PyTuple_Check(args2->typelength) && PyTuple_GET_SIZE(args1->typelength) == PyTuple_GET_SIZE(args2->typelength))
     1051        {
     1052            length = PyTuple_New(PyTuple_GET_SIZE(args1->typelength));
     1053            if(length == NULL)
     1054                return NULL;
     1055            for(i = 0; i < PyTuple_GET_SIZE(args1->typelength); i++)
     1056            {
     1057                tmp1 = PyTuple_GET_ITEM(args1->typelength,i);
     1058                tmp2 = PyTuple_GET_ITEM(args2->typelength,i);
     1059                tmp1 = ((PyInt_AsLong(tmp1) > PyInt_AsLong(tmp2)) ? tmp1 : tmp2);
     1060                Py_INCREF(tmp1);
     1061                PyTuple_SET_ITEM(length,i,tmp1);
     1062            }
    9331063        }
    9341064        else
    9351065        {
    936             if(tmp1->typecode == ntc)
    937             {
    938                 Py_INCREF(tmp1);
    939                 PyTuple_SET_ITEM(res,i,(PyObject *)tmp1);
    940             }
    941             else if(tmp2->typecode == ntc)
    942             {
    943                 Py_INCREF(tmp2);
    944                 PyTuple_SET_ITEM(res,i,(PyObject *)tmp2);
    945             }
    946             else
    947                 PyTuple_SET_ITEM(res,i,_itypenew(&ITypeType,ntc,-2,Py_None));
    948            
    949         }
     1066            ntc = OBJECT;
     1067            length = NULL;
     1068        }
     1069       
     1070        res = _itypenew(&ITypeType,ntc,length,_common_subtype((IType *)args1->subtype,(IType *)args2->subtype));
     1071    }
     1072    else
     1073    {
     1074        if(args1->typecode == ntc)
     1075        {
     1076            Py_INCREF(args1);
     1077            res = (PyObject *)args1;
     1078        }
     1079        else if(args2->typecode == ntc)
     1080        {
     1081            Py_INCREF(args2);
     1082            res = (PyObject *)args2;
     1083        }
     1084        else
     1085            res = _itypenew(&ITypeType,ntc,NULL,NULL);
     1086       
    9501087    }
    9511088    return res;
     
    9861123        if(IS_TYPE(ntc,~(OBJECT | UNKNOWN | SEQUENCE)))
    9871124        {
    988             res = _itypenew(&ITypeType,ntc,-2,Py_None);
    989             return Py_BuildValue("(N)",res);
     1125            res = _itypenew(&ITypeType,ntc,NULL,NULL);
     1126            return res;
    9901127        }
    9911128    }
     
    9961133    PyObject *item;
    9971134    PyObject *typelist = PyList_New(0);
    998     PyObject *subtypes = NULL;
     1135    PyObject * elemlength = NULL;
     1136    PyObject *subtype = NULL;
    9991137   
    10001138    int curlength = 0;
    10011139    int i;
    1002     long elemlength;
    10031140
    10041141    if(typelist == NULL)
    10051142        return NULL;
    1006    
     1143
    10071144    while((item = PyIter_Next(iter)))
    10081145    {
    10091146        for(i = 0; i < curlength; i++)
    1010         {
    10111147            if(PyList_GET_ITEM(typelist,i) == (PyObject *)item->ob_type)
    10121148                break;
    1013         }
    10141149        if(i == curlength) //not found
    10151150        {
     
    10441179    else
    10451180        ntc = UNKNOWN;
    1046    
     1181   
     1182
    10471183    Py_DECREF(typelist);
    1048    
     1184   
     1185
    10491186    ntc = choose_type(ntc);
    10501187    if(IS_TYPE(ntc,SEQUENCE))
     
    10521189        long maxlength = 0;
    10531190        long ilength = 0;
    1054         PyObject *isubtypes= NULL,*tmp;
     1191        PyObject *isubtype= NULL,*tmp;
    10551192       
    10561193        iter = PyObject_GetIter(args);
    10571194        if(iter == NULL || PyErr_Occurred() || !PyIter_Check(iter))
    10581195            return NULL;
    1059         subtypes = NULL;
     1196        subtype = NULL;
    10601197        while((item = PyIter_Next(iter)))
    10611198        {
     
    10651202            if(IS_TYPE(ntc,RSEQUENCE))
    10661203            {
    1067                 isubtypes = _getseqtype(self,item,ntc,depth + 1);
    1068                 if(isubtypes == NULL)
     1204                isubtype = _getseqtype(self,item,ntc,depth + 1);
     1205                if(isubtype == NULL)
    10691206                    return NULL;
    1070                 tmp = _common_subtypes(subtypes,isubtypes);
    1071                 Py_XDECREF(subtypes);
    1072                 Py_XDECREF(isubtypes);
    1073                 subtypes = tmp;
     1207                tmp = _common_subtype((IType *) subtype,(IType *)isubtype);
     1208                Py_XDECREF(subtype);
     1209                Py_XDECREF(isubtype);
     1210                subtype = tmp;
    10741211            }
    10751212            Py_DECREF(item);
    10761213        }
    10771214        Py_DECREF(iter);
    1078         elemlength = maxlength;
    1079     }
    1080     else elemlength = -2;
     1215        elemlength = PyInt_FromLong(maxlength);
     1216    }
    10811217   
    1082     if(subtypes == NULL)
    1083     {
    1084         Py_INCREF(Py_None);
    1085         subtypes = Py_None;
    1086     }
    1087     res = _itypenew(&ITypeType,ntc,elemlength,subtypes);
    1088     Py_DECREF(subtypes);
    1089     res = Py_BuildValue("(N)",res);
     1218   
     1219    res = _itypenew(&ITypeType,ntc,elemlength,subtype);
     1220    Py_XDECREF(subtype);
    10901221    return res;
    10911222}
     
    11451276    if(typecode == NULL)
    11461277    {
    1147         PyErr_SetString(PyExc_TypeError,"Unknown numpy dtype encoutered.");
     1278        PyErr_SetString(PyExc_TypeError,"Unknown numpy dtype encountered.");
    11481279        Py_DECREF(typename);
    11491280        return NULL;
     
    11561287
    11571288
    1158 
     1289/* Converts types to a typecode, caches in dictionary */
    11591290static PyObject * register_pytype(PyObject *obj)
    11601291{
     
    12051336    else if(PyUnicode_Check(obj))
    12061337        typecode = Py_typecodes[IUNICODE];
     1338    else if(PyObject_IsInstance((PyObject *) obj->ob_type,(PyObject *)BaseContainer_Type))
     1339        typecode = Py_typecodes[ICONTAINER];
    12071340    else
    12081341        typecode = Py_typecodes[IOBJECT];
     
    12271360
    12281361    import_array();
     1362    import_base_container();
    12291363    if (PyType_Ready(&ITypeType) < 0)
    12301364        return;
     
    12481382        Py_defval[i] = get_defval(1 << i);
    12491383        if(Py_typecodes[i] == NULL)
    1250         {
    1251             PyErr_SetString(PyExc_RuntimeError,"Initialization of typecodes failed.");
    1252             return;
    1253         }
     1384            goto error_tc;
     1385
    12541386        if(PyDict_SetItemString(typedict,type_names[i],Py_typecodes[i]) < 0)
    1255         {
    1256             PyErr_SetString(PyExc_RuntimeError,"Initialization of typecodes failed.");
    1257             return;
    1258         }
    1259     }
     1387            goto error_tc;
     1388       
     1389    }
     1390    if(PyDict_SetItemString(typedict,"SEQUENCE",PyInt_FromLong(SEQUENCE)) < 0)
     1391        goto error_tc;
     1392    if(PyDict_SetItemString(typedict,"RSEQUENCE",PyInt_FromLong(RSEQUENCE)) < 0)
     1393        goto error_tc;
     1394    if(PyDict_SetItemString(typedict,"UINT",PyInt_FromLong(UINT)) < 0)
     1395        goto error_tc;
     1396    if(PyDict_SetItemString(typedict,"INT",PyInt_FromLong(INT)) < 0)
     1397        goto error_tc;
     1398    if(PyDict_SetItemString(typedict,"INTEGER",PyInt_FromLong(INTEGER)) < 0)
     1399        goto error_tc;
     1400    if(PyDict_SetItemString(typedict,"FLOAT",PyInt_FromLong(FLOAT)) < 0)
     1401        goto error_tc;
     1402    if(PyDict_SetItemString(typedict,"COMPLEX",PyInt_FromLong(COMPLEX)) < 0)
     1403        goto error_tc;
     1404    if(PyDict_SetItemString(typedict,"NUMBER",PyInt_FromLong(NUMBER)) < 0)
     1405        goto error_tc;
     1406
     1407
    12601408    Py_INCREF(typedict);
    12611409    PyModule_AddObject(m, "types", typedict);
     
    12661414        return;
    12671415    }
    1268 }
    1269 
    1270 
     1416    return;
     1417
     1418error_tc:
     1419    PyErr_SetString(PyExc_RuntimeError,"Initialization of typecodes failed.");
     1420    return;
     1421}
     1422
     1423
  • src/itypes.h

    r4 r42  
    8989#define VALID_TYPE(x) (((bitcount((x)) == 1) && !(x & NOTYPE)) ? 1 : 0)
    9090
     91
     92#define L_UNKNOWN -1
    9193
    9294static char * type_names[NRTYPE] = {"int8","int16","int32","int64","uint8","uint16",
     
    100102                     "object","object","object","object","object",
    101103                     "S","U","V","object","object"};
    102 static char type_priority[NRTYPE] = {100,90,80,70,  //ints
    103                                      101,91,91,71,  //uints
    104                                      102,92,82,     //floats
    105                                      103,93,83,     //complex
    106                                      104,           //bool
    107                                      50,49,51,52,48,//seqs
     104static char type_priority[NRTYPE] = {102,92,82,72,  //ints
     105                                     103,93,83,73,  //uints
     106                                     81,71,61,     //floats
     107                                     70,60,50,     //complex
     108                                     114,           //bool
     109                                     40,39,41,42,38,//seqs
    108110                                     20,15,11,10,0}; //str,unicode,bytes,object,unknown
    109111PyObject * Py_typecodes[NRTYPE];
     
    133135
    134136
     137static it_code get_convertable_types(it_code typecode)
     138{   
     139    it_code res = 0;
     140    switch(typecode)
     141    {
     142        case INT8:      res = OBJECT | INT | FLOAT | COMPLEX; break;
     143        case INT16:     res = ((OBJECT | INT) & ~INT8) | FLOAT | COMPLEX; break;
     144        case INT32:     res = OBJECT | INT64 | FLOAT64 | FLOAT128 | COMPLEX128 | COMPLEX256; break;
     145        case INT64:     res = OBJECT | FLOAT64 | FLOAT128 | COMPLEX128 | COMPLEX256; break;
     146        case UINT8:     res = ((OBJECT | INTEGER) & ~INT8) | FLOAT | COMPLEX; break;
     147        case UINT16:    res = ((OBJECT | INTEGER) & ~(UINT8 | INT8 | INT16)) | FLOAT | COMPLEX; break;
     148        case UINT32:    res = OBJECT | UINT64 | INT64 | FLOAT64 | FLOAT128 | COMPLEX128 | COMPLEX256; break;
     149        case UINT64:    res = OBJECT | FLOAT64 | FLOAT128 | COMPLEX128 | COMPLEX256; break;
     150        case FLOAT32:   res = OBJECT | FLOAT64 | FLOAT128 | COMPLEX; break;
     151        case FLOAT64:   res = OBJECT | FLOAT128 | COMPLEX128 | COMPLEX256; break;
     152        case FLOAT128:  res = OBJECT | COMPLEX256; break;
     153        case COMPLEX64: res = OBJECT | COMPLEX128 | COMPLEX256; break;
     154        case COMPLEX128:res = OBJECT | COMPLEX256; break;
     155        case COMPLEX256:res = OBJECT; break;
     156        case BOOL:      res = OBJECT | INTEGER | FLOAT | COMPLEX; break;
     157        case TUPLE:     
     158        case LIST:     
     159        case ARRAY:     
     160        case NUMPY:     
     161        case CONTAINER:
     162        case STR:       
     163        case UNICODE:   
     164        case BYTES:     
     165        case OBJECT:   
     166        case UNKNOWN:   res = OBJECT; break;
     167    }
     168    res |= typecode;
     169    return res;
     170}
     171
    135172static it_code get_compatible_types(it_code typecode)
    136173{   
     
    138175    switch(typecode)
    139176    {
    140         case INT8:      res = OBJECT | INT;
    141         case INT16:     res = (OBJECT | INT) & ~INT8;
    142         case INT32:     res = OBJECT | INT64;
    143         case INT64:     res = OBJECT;
    144         case UINT8:     res = (OBJECT | INTEGER) & ~INT8;
    145         case UINT16:    res = (OBJECT | INTEGER) & ~(UINT8 | INT8 | INT16);
    146         case UINT32:    res = OBJECT | UINT64 | INT64;
    147         case UINT64:    res = OBJECT;
    148         case FLOAT32:   res = OBJECT | FLOAT64 | FLOAT128;
    149         case FLOAT64:   res = OBJECT | FLOAT128;
    150         case FLOAT128:  res = OBJECT;
    151         case COMPLEX64: res = OBJECT | COMPLEX128 | COMPLEX256;
    152         case COMPLEX128:res = OBJECT | COMPLEX256;
    153         case COMPLEX256:res = OBJECT;
    154         case BOOL:      res = OBJECT | INTEGER;
    155         case TUPLE:     res = OBJECT;
    156         case LIST:      res = OBJECT;
    157         case ARRAY:     res = OBJECT;
    158         case NUMPY:     res = OBJECT;
    159         case CONTAINER: res = OBJECT;
    160         case STR:       res = OBJECT;
    161         case UNICODE:   res = OBJECT;
    162         case BYTES:     res = OBJECT;
    163         case OBJECT:    res = OBJECT;
    164         case UNKNOWN:   res = OBJECT;
     177        case INT8:      res = OBJECT | INT; break;
     178        case INT16:     res = (OBJECT | INT) & ~INT8; break;
     179        case INT32:     res = OBJECT | INT64; break;
     180        case INT64:     res = OBJECT; break;
     181        case UINT8:     res = (OBJECT | INTEGER) & ~INT8; break;
     182        case UINT16:    res = (OBJECT | INTEGER) & ~(UINT8 | INT8 | INT16); break;
     183        case UINT32:    res = OBJECT | UINT64 | INT64; break;
     184        case UINT64:    res = OBJECT; break;
     185        case FLOAT32:   res = OBJECT | FLOAT64 | FLOAT128; break;
     186        case FLOAT64:   res = OBJECT | FLOAT128; break;
     187        case FLOAT128:  res = OBJECT; break;
     188        case COMPLEX64: res = OBJECT | COMPLEX128 | COMPLEX256; break;
     189        case COMPLEX128:res = OBJECT | COMPLEX256; break;
     190        case COMPLEX256:res = OBJECT; break;
     191        case BOOL:      res = OBJECT | INTEGER; break;
     192        case TUPLE:     
     193        case LIST:     
     194        case ARRAY:     
     195        case NUMPY:     
     196        case CONTAINER:
     197        case STR:       
     198        case UNICODE:   
     199        case BYTES:     
     200        case OBJECT:   
     201        case UNKNOWN:   res = OBJECT; break;
    165202    }
    166203    res = res | typecode;
    167204    return res;
    168205}
     206
    169207
    170208int bitcount (it_code typecode)
     
    245283}
    246284
     285#define STATE_START 0
     286#define STATE_INSUBTYPE 1
     287#define STATE_ENDSUBTYPE 2
     288#define STATE_INBLOCK 3
     289#define STATE_ENDBLOCK 4
     290#define STATE_SUBTYPEINBLOCK 5
     291
    247292static PyObject * _getseqtype(PyObject * self, PyObject * args, it_code typecode,int depth);
    248293static PyObject * _dtype_to_typecode(PyObject *dtype);
  • src/setup_itypes.py

    r4 r42  
    44from distutils.debug import DEBUG
    55
    6 #include_dir = distutils.sysconfig.get_python_lib() + "/numpy/core/include"
    7 include_dir = "/usr/lib64/python2.5/site-packages" + "/numpy/core/include"
     6include_dir = distutils.sysconfig.get_python_lib() + "/numpy/core/include"
     7#include_dir = "/usr/lib64/python2.5/site-packages" + "/numpy/core/include"
    88
    99setup(name="itypes", version="1.0",
Note: See TracChangeset for help on using the changeset viewer.