Contact: fumanchu@aminus.org

Log in as guest/dejavu to create tickets

I think I've seen this ORM somewhere before...

Changeset 242

Show
Ignore:
Timestamp:
07/25/06 18:11:28
Author:
fumanchu
Message:

Some API changes to make the dejavu top level cleaner:

  1. Moved dejavu.LOGxxx -> dejavu.logflags.xxx.
  2. Moved CrossTab?, COUNT, SUM to analysis namespace only.
  3. Pushed errors and containers back down one level.

Unrelated: fixed decimal tests when prec > getcontext().prec.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/__init__.py

    r241 r242  
    77"Dejavu", to quote Flying Circus episode 16, means "that strange feeling 
    88we sometimes get that we've lived through something before." What better 
    9 name for an object server? Our terminology reflects this cognitive bent: 
     9name for a persistence system? Our terminology reflects this cognitive bent: 
    1010sandboxes "memorize", "recall" and "forget" Units. 
    1111 
    …… 
    3636 
    3737 
    38 import datetime 
     38import datetime as _datetime 
    3939 
    40 from dejavu.analysis import * 
     40import analysis 
     41sort = analysis.sort 
     42 
    4143from dejavu.arenas import * 
    42 from dejavu.containers import * 
    43 from dejavu.errors import * 
    4444from dejavu.schemas import * 
    4545from dejavu.units import * 
    …… 
    9797def year(value): 
    9898    """The year attribute of a date.""" 
    99     if isinstance(value, (datetime.date, datetime.datetime)): 
     99    if isinstance(value, (_datetime.date, _datetime.datetime)): 
    100100        return value.year 
    101101    else: 
    …… 
    104104def month(value): 
    105105    """The month attribute of a date.""" 
    106     if isinstance(value, (datetime.date, datetime.datetime)): 
     106    if isinstance(value, (_datetime.date, _datetime.datetime)): 
    107107        return value.month 
    108108    else: 
    …… 
    111111def now(): 
    112112    """Late-bound datetime.datetime.now(). Taint this when early binding.""" 
    113     return datetime.datetime.now() 
     113    return _datetime.datetime.now() 
    114114now.bind_late = True 
    115115 
    116116def today(): 
    117117    """Late-bound datetime.date.today(). Taint this when early binding.""" 
    118     return datetime.date.today() 
     118    return _datetime.date.today() 
    119119today.bind_late = True 
    120120 
    121121def iscurrentweek(value): 
    122122    """If value is in the current week, return True, else False.""" 
    123     if isinstance(value, (datetime.date, datetime.datetime)): 
    124         return datetime.date.today().strftime('%W%Y') == value.strftime('%W%Y') 
     123    if isinstance(value, (_datetime.date, _datetime.datetime)): 
     124        return _datetime.date.today().strftime('%W%Y') == value.strftime('%W%Y') 
    125125    else: 
    126126        return False 
    …… 
    134134    setattr(_d, _name, globals()[_name]) 
    135135logic.dejavu = _d 
     136del _name, _d, _Empty 

  • trunk/arenas.py

    r241 r242  
    88import xray 
    99 
    10 __all__ = ['Arena', 'Sandbox', 
    11            'LOGFORGET', 'LOGIO', 'LOGMEMORIZE', 'LOGRECALL', 
    12            'LOGREPRESS', 'LOGSANDBOX', 'LOGSQL', 'LOGVIEW', 
     10__all__ = ['Arena', 'Sandbox', 'logflags', 
    1311           ] 
    1412 
    1513 
     14class Enum(object): 
     15    pass 
     16 
    1617# logging flags (see Arena.logflags) 
    17 LOGIO = 1 
    18 LOGSQL = 4 
    19  
    20 LOGMEMORIZE = 128 
    21 LOGRECALL = 256 
    22 LOGVIEW = 512 
    23 LOGREPRESS = 1024 
    24 LOGFORGET = 2048 
    25 LOGSANDBOX = LOGMEMORIZE | LOGRECALL | LOGVIEW | LOGREPRESS | LOGFORGET 
     18logflags = Enum() 
     19logflags.IO = 1 
     20logflags.SQL = 4 
     21 
     22logflags.MEMORIZE = 128 
     23logflags.RECALL = 256 
     24logflags.VIEW = 512 
     25logflags.REPRESS = 1024 
     26logflags.FORGET = 2048 
     27logflags.SANDBOX = logflags.MEMORIZE | logflags.RECALL | logflags.VIEW | logflags.REPRESS | logflags.FORGET 
    2628 
    2729 
    …… 
    253255        id = unit.identity() 
    254256        self._cache(cls)[id] = unit 
    255         self.arena.log("MEMORIZE %s: %s" % (cls.__name__, id), LOGMEMORIZE) 
     257        self.arena.log("MEMORIZE %s: %s" % (cls.__name__, id), logflags.MEMORIZE) 
    256258         
    257259        # Do this at the end of the func, since most on_memorize 
    …… 
    265267         
    266268        id = unit.identity() 
    267         self.arena.log("FORGET %s: %s" % (cls.__name__, id), LOGFORGET) 
     269        self.arena.log("FORGET %s: %s" % (cls.__name__, id), logflags.FORGET) 
    268270        self.arena.storage(cls).destroy(unit) 
    269271         
    …… 
    285287         
    286288        cls = classes 
    287         self.arena.log("RECALL %s: %s" % (cls.__name__, expr), LOGRECALL) 
     289        self.arena.log("RECALL %s: %s" % (cls.__name__, expr), logflags.RECALL) 
    288290         
    289291        # Collect all registered subclasses of cls. 
    …… 
    371373        self.arena.log("RECALL %s %s" % 
    372374                       (", ".join([c.__name__ for c in classes]), expr), 
    373                        LOGRECALL) 
     375                       logflags.RECALL) 
    374376         
    375377        stores = [self.arena.storage(cls) for cls in classes] 
    …… 
    426428    def view(self, cls, attrs, expr=None): 
    427429        """view(cls, attrs, expr=None) -> Iterator of all Property tuples.""" 
    428         self.arena.log("VIEW %s [%s]: %s" % (cls.__name__, attrs, expr), LOGVIEW) 
     430        self.arena.log("VIEW %s [%s]: %s" % (cls.__name__, attrs, expr), logflags.VIEW) 
    429431         
    430432        cache = self._cache(cls) 
    …… 
    462464        (in fact it's the only way to do it) by using attrs = ['ID']. 
    463465        """ 
    464         self.arena.log("DISTINCT %s [%s]: %s" % (cls.__name__, attrs, expr), LOGVIEW) 
     466        self.arena.log("DISTINCT %s [%s]: %s" % (cls.__name__, attrs, expr), logflags.VIEW) 
    465467         
    466468        seen = {} 
    …… 
    507509        cls = unit.__class__ 
    508510        id = unit.identity() 
    509         self.arena.log("REPRESS %s: %s" % (cls.__name__, id), LOGREPRESS) 
     511        self.arena.log("REPRESS %s: %s" % (cls.__name__, id), logflags.REPRESS) 
    510512         
    511513        if hasattr(unit, "on_repress"): 
    …… 
    536538            while cache: 
    537539                unitid, unit = cache.popitem() 
    538                 self.arena.log("REPRESS %s: %s" % (cls.__name__, unitid), LOGREPRESS) 
     540                self.arena.log("REPRESS %s: %s" % (cls.__name__, unitid), logflags.REPRESS) 
    539541                store.save(unit) 
    540542 

  • trunk/engines.py

    r241 r242  
    1616 
    1717import dejavu 
    18 from dejavu import logic 
     18from dejavu import errors, logic 
    1919 
    2020 
    …… 
    2727            if self.Expiration <= datetime.datetime.now(): 
    2828                self.forget() 
    29                 raise dejavu.UnrecallableError 
     29                raise errors.UnrecallableError 
    3030            else: 
    3131                self.decay(minutes=15) 

  • trunk/storage/db.py

    r241 r242  
    5050 
    5151import dejavu 
    52 from dejavu import logic, storage, LOGSQL, xray 
     52from dejavu import errors, logic, storage, logflags, xray 
    5353from dbmodel import * 
    5454 
    …… 
    319319                          "since each unit must be fully-formed. %s" 
    320320                          % (cls.__name__, self.__class__.__name__, expr), 
    321                           dejavu.StorageWarning) 
     321                          errors.StorageWarning) 
    322322            for unit in self.recall(cls, expr): 
    323323                # Use tuples for hashability 
    …… 
    342342                          "since each unit must be fully-formed. %s" 
    343343                          % (cls.__name__, self.__class__.__name__, expr), 
    344                           dejavu.StorageWarning) 
     344                          errors.StorageWarning) 
    345345            vals = {} 
    346346            for unit in self.recall(cls, expr): 
    …… 
    382382        if ua is None: 
    383383            msg = ("No association found between %s and %s." % (name1, name2)) 
    384             raise dejavu.AssociationError(msg) 
     384            raise errors.AssociationError(msg) 
    385385         
    386386        t = self.db 
    …… 
    536536     
    537537    def rename_storage(self, oldname, newname): 
    538         self.arena.log("rename table %s to %s" % (oldname, newname), LOGSQL) 
     538        self.arena.log("rename table %s to %s" % (oldname, newname), logflags.SQL) 
    539539        self.db.rename(oldname, newname) 
    540540     

  • trunk/storage/dbmodel.py

    r241 r242  
    7272 
    7373import dejavu 
    74 from dejavu import codewalk, LOGSQL 
     74from dejavu import codewalk, errors, logflags 
    7575 
    7676 
    …… 
    810810 
    811811 
    812 class OutOfConnectionsError(dejavu.DejavuError): 
     812class OutOfConnectionsError(errors.DejavuError): 
    813813    """Exception raised when a database store has run out of connections.""" 
    814814    pass 
    …… 
    12271227            warnings.warn("The name '%s' is longer than the maximum of " 
    12281228                          "%s characters." % (key, maxlen), 
    1229                           dejavu.StorageWarning) 
     1229                          errors.StorageWarning) 
    12301230            key = key[:maxlen] 
    12311231         
    …… 
    13421342        if isinstance(query, unicode): 
    13431343            query = query.encode(self.adaptertosql.encoding) 
    1344         self.log(query, LOGSQL) 
     1344        self.log(query, logflags.SQL) 
    13451345        return conn.query(query) 
    13461346     

  • trunk/storage/storeado.py

    r241 r242  
    1717 
    1818import dejavu 
    19 from dejavu import storage, logic 
     19from dejavu import errors, logic, storage 
    2020from dejavu.storage import db 
    2121 
    …… 
    502502        if isinstance(query, unicode): 
    503503            query = query.encode(self.adaptertosql.encoding) 
    504         self.log(query, dejavu.LOGSQL) 
     504        self.log(query, dejavu.logflags.SQL) 
    505505        try: 
    506506            conn.Execute(query) 
    …… 
    519519                res = conn.OpenSchema(query) 
    520520            else: 
    521                 self.log(query, dejavu.LOGSQL) 
     521                self.log(query, dejavu.logflags.SQL) 
    522522                res = win32com.client.Dispatch(r'ADODB.Recordset') 
    523523                if hasattr(conn, "conn"): 
    …… 
    642642                          "not allow comparisons on string fields larger " 
    643643                          "than 8000 characters. Some of your data may be " 
    644                           "truncated.", dejavu.StorageWarning) 
     644                          "truncated.", errors.StorageWarning) 
    645645            bytes = 8000 
    646646         
    …… 
    10131013                    warnings.warn("Memo fields cannot be used as join keys. " 
    10141014                                  "You should set %s.%s(hints={'bytes': 255})" 
    1015                                   % (cls.__name__, key), dejavu.StorageWarning) 
     1015                                  % (cls.__name__, key), errors.StorageWarning) 
    10161016        return col 
    10171017 

  • trunk/storage/storefirebird.py

    r241 r242  
    7575            if isinstance(query, unicode): 
    7676                query = query.encode(self.toAdapter.encoding) 
    77             self.arena.log(query, dejavu.LOGSQL) 
     77            self.arena.log(query, dejavu.logflags.SQL) 
    7878            cur = conn.cursor() 
    7979            cur.execute(query) 
    …… 
    9999            if isinstance(query, unicode): 
    100100                query = query.encode(self.toAdapter.encoding) 
    101             self.arena.log(query, dejavu.LOGSQL) 
     101            self.arena.log(query, dejavu.logflags.SQL) 
    102102            cur = conn.cursor() 
    103103            cur.execute(query) 

  • trunk/storage/storemysql.py

    r241 r242  
    1818 
    1919import dejavu 
    20 from dejavu import storage, logic, LOGSQL 
     20from dejavu import storage, logic, logflags 
    2121from dejavu.storage import db 
    2222 
    …… 
    402402        if isinstance(query, unicode): 
    403403            query = query.encode(self.adaptertosql.encoding) 
    404         self.log(query, LOGSQL) 
     404        self.log(query, logflags.SQL) 
    405405        try: 
    406406            return conn.query(query) 

  • trunk/storage/storeodbc.py

    r241 r242  
    55import warnings 
    66import datetime 
    7 from dejavu import logic, LOGSQL 
     7from dejavu import errors, logic, logflags 
    88from dejavu.storage import db 
    99 
    …… 
    1919        warnings.warn("The precision of %s.%s cannot be determined for " 
    2020                      "ODBC stores. Values may be stored incorrectly." 
    21                       % (cls.__name__, key), dejavu.StorageWarning) 
     21                      % (cls.__name__, key), errors.StorageWarning) 
    2222        return u"NUMERIC" 
    2323     
    …… 
    2525        warnings.warn("The precision of %s.%s cannot be determined for " 
    2626                      "ODBC stores. Values may be stored incorrectly." 
    27                       % (cls.__name__, key), dejavu.StorageWarning) 
     27                      % (cls.__name__, key), errors.StorageWarning) 
    2828        return u"NUMERIC" 
    2929     
    …… 
    3939        warnings.warn("The precision of %s.%s cannot be determined for " 
    4040                      "ODBC stores. Values may be stored incorrectly." 
    41                       % (cls.__name__, key), dejavu.StorageWarning) 
     41                      % (cls.__name__, key), errors.StorageWarning) 
    4242        return u"NUMERIC" 
    4343 
    …… 
    104104        if conn is None: 
    105105            conn = self.connection() 
    106         self.arena.log(query, LOGSQL) 
     106        self.arena.log(query, logflags.SQL) 
    107107        try: 
    108108            cursor = conn.cursor() 

  • trunk/storage/storeshelve.py

    r241 r242  
    1616 
    1717import dejavu 
    18 from dejavu import storage, logic 
     18from dejavu import errors, logic, storage 
    1919 
    2020 
    …… 
    5959                if x.args[0] == "need 'c' or 'n' flag to open new db": 
    6060                    msg = "You must call create_storage() before recall()." 
    61                     raise dejavu.UnrecallableError(msg) 
     61                    raise errors.UnrecallableError(msg) 
    6262                raise 
    6363            self.shelves[clsname] = s 
    …… 
    202202            if ua is None: 
    203203                msg = ("No association found between %s and %s." % (cls1, cls2)) 
    204                 raise dejavu.AssociationError(msg) 
     204                raise errors.AssociationError(msg) 
    205205             
    206206            unitrows = [] 

  • trunk/storage/storesqlite.py

    r241 r242  
    33 
    44import dejavu 
    5 from dejavu import storage, logic 
     5from dejavu import errors, logic, storage 
    66from dejavu.storage import db 
    77 
    …… 
    1717                       "wildcard literals." % _version) 
    1818    import warnings 
    19     warnings.warn(_escape_warning, dejavu.StorageWarning) 
     19    warnings.warn(_escape_warning, errors.StorageWarning) 
    2020 
    2121_add_column_support = (_version >= storage.Version([3, 2, 0])) 
    …… 
    489489            if isinstance(query, unicode): 
    490490                query = query.encode(self.adaptertosql.encoding) 
    491             self.log(query, dejavu.LOGSQL) 
     491            self.log(query, dejavu.logflags.SQL) 
    492492            while True: 
    493493                try: 
    …… 
    568568        if ua is None: 
    569569            msg = ("No association found between %s and %s." % (name1, name2)) 
    570             raise dejavu.AssociationError(msg) 
     570            raise errors.AssociationError(msg) 
    571571         
    572572        near = '%s.%s' % (self.db.quote(self.db.table_name(nearClass)), 

  • trunk/test/test_dejavu.py

    r241 r242  
    44 
    55import dejavu 
    6 from dejavu import logic, storage 
     6from dejavu import errors, logic, storage 
    77from dejavu.test.zoo_fixture import * 
    88 
    …… 
    175175            trees.append( (Animal & Zoo) >> Exhibit ) 
    176176         
    177         warnings.filterwarnings("error", category=dejavu.StorageWarning) 
     177        warnings.filterwarnings("error", category=errors.StorageWarning) 
    178178        try: 
    179             self.assertRaises(dejavu.StorageWarning, make_tree) 
     179            self.assertRaises(errors.StorageWarning, make_tree) 
    180180        finally: 
    181181            warnings.filters.pop(0) 
    182182         
    183183        # Since we raised the warning, our first make_tree failed. 
    184         warnings.filterwarnings("ignore", category=dejavu.StorageWarning) 
     184        warnings.filterwarnings("ignore", category=errors.StorageWarning) 
    185185        try: 
    186186            make_tree() 

  • trunk/test/zoo_fixture.py

    r241 r242  
    3838 
    3939import dejavu 
    40 from dejavu import logic 
     40from dejavu import errors, logic 
    4141from dejavu import Unit, UnitProperty, ToOne, ToMany, UnitSequencerInteger 
    4242from dejavu.test import tools 
    …… 
    572572        def make_tree(): 
    573573            trees.append( (Animal & Zoo) >> Vet ) 
    574         warnings.filterwarnings("ignore", category=dejavu.StorageWarning) 
     574        warnings.filterwarnings("ignore", category=errors.StorageWarning) 
    575575        try: 
    576576            make_tree() 
    …… 
    871871        else: 
    872872            overflow_prec = 8 
     873         
     874        dc = decimal.getcontext() 
     875         
    873876        for prec in xrange(overflow_prec + 1): 
    874877            p = 2 ** prec 
    875878            print p, 
     879            if p > dc.prec: 
     880                dc.prec = p 
     881             
    876882            # We don't need to test <type long> at different 'scales'. 
    877883            long_done = False 
    …… 
    986992    arena = dejavu.Arena() 
    987993    arena.log = _djvlog 
    988     arena.logflags = dejavu.LOGSQL + dejavu.LOGIO + dejavu.LOGRECALL 
     994    arena.logflags = dejavu.logflags.SQL + dejavu.logflags.IO + dejavu.logflags.RECALL 
    989995 
    990996 

  • trunk/units.py

    r241 r242  
    1616           'UnitSequencerInteger', 'UnitSequencerNull', 
    1717           'UnitSequencerUnicode', 
    18            '_define_fixedpoint_states', '_fix_fixedpoint_cmp', 
     18##           '_define_fixedpoint_states', '_fix_fixedpoint_cmp', 
    1919           ] 
    2020