def finish(db, schema_module=None): """Unlock the schema import mutex and return the schema definition.""" if schema_module is None: import_lock.release() return schema_def = schevo.namespace.SCHEMADEF # Reset the global namespace SCHEMADEF. schevo.namespace.SCHEMADEF = None schevo.namespace.SCHEMADB = None schevo.namespace.EVOLVING = False # Remove this class now that the schema has been processed. del schema_def.E.Entity # Force all Entity field classes to readonly. for entity_name in schema_def.E: EntityClass = schema_def.E[entity_name] for FieldClass in EntityClass._field_spec.itervalues(): FieldClass.readonly = True # Decorate all Transaction classes with the current database. for transaction_name in schema_def.T: TransactionClass = schema_def.T[transaction_name] TransactionClass._db = db # Decorate all Entity transaction classes with the current database. for entity_name in schema_def.E: EntityClass = schema_def.E[entity_name] for v in EntityClass.__dict__.itervalues(): if (inspect.isclass(v) and issubclass(v, schevo.transaction.Transaction)): v._db = db # Decorate all View transaction classes with the current database. for view_name in schema_def.V: ViewClass = schema_def.V[view_name] for v in ViewClass.__dict__.itervalues(): if (inspect.isclass(v) and issubclass(v, schevo.transaction.Transaction)): v._db = db # Add relationship metadata to each Entity class. for parent, spec in schema_def.relationships.iteritems(): E = schema_def.E # Catch non-existence errors. parentClass = getattr(E, parent, None) if parentClass is None: raise schevo.error.ExtentDoesNotExist(parent) # Make sure spec is sorted in field definition order. other_map = {} for other_extent_name, other_field_name in spec: other_extent_field_set = other_map.setdefault( other_extent_name, set()) other_extent_field_set.add(other_field_name) spec = [] for other_extent_name, other_extent_field_set in other_map.items(): other_class = getattr(E, other_extent_name) spec.extend( (other_extent_name, other_field_name) for other_field_name in other_class._field_spec if other_field_name in other_extent_field_set ) # Record final spec. parentClass._relationships = spec del schema_def.relationships # Create database-level query function namespace. q = schema_def.q for name, func in schema_module.__dict__.iteritems(): if isinstance(func, FunctionType) and name.startswith('q_'): # Strip q_ prefix. name = name[2:] # Give it a label if necessary. if getattr(func, '_label', None) is None: func._label = schevo.label.label_from_name(name) q._set(name, func) # Create database-level transaction function namespace. t = schema_def.t for name, func in schema_module.__dict__.iteritems(): if isinstance(func, FunctionType) and name.startswith('t_'): # Strip t_ prefix. name = name[2:] # Give it a label if necessary. if getattr(func, '_label', None) is None: func._label = schevo.label.label_from_name(name) t._set(name, func) # Get rid of the temporary null database. del schema_module.db # Optimize the module. optimize.bind_all(schema_module) # Install the actual database. schema_module.db = db # Release import lock. import_lock.release() return schema_def
def open(filename, backend_name=None, backend_args=None): """Open an existing database and return it. - `filename`: Name of the file containing the database. - `backend_name`: (optional) Name of the backend to use if auto-detection is not desired. - `backend_args`: (optional) Arguments to pass to the backend. """ backend = new_backend(filename, backend_name, backend_args) # Make sure the database already exists. root = backend.get_root() if 'SCHEVO' not in root: backend.close() raise DatabaseDoesNotExist(filename) # Determine the version of the database. schevo = root['SCHEVO'] format = schevo['format'] # Determine database class based on format number. Database = format_dbclass[format] # Create the Database instance. db = Database(backend) db._sync() # Install icon support and finalize opening of database. icon.install(db) return db optimize.bind_all(sys.modules[__name__]) # Last line of module.
def update(self, other, reorder=False): """Update values in this odict based on the `other` odict.""" if not isinstance(other, odict): raise ValueError('other must be an odict') if other is self: raise ValueError('other cannot be the same odict') dict.update(self, other) keys = self._keys if not reorder: for key in other: if key not in keys: keys.append(key) else: for key in other: if key in keys: keys.remove(key) keys.append(key) def values(self): return [self[key] for key in self._keys] optimize.bind_all(odict) ## # Bind the docstrings from dict to odict. ## for k, v in odict.__dict__.iteritems(): ## if k != '_keys' and hasattr(v, '__doc__') and v.__doc__ is None: ## v.__doc__ = getattr(dict, v.__name__).__doc__