Module Hierarchy

• Modeling: The Modeling Framework is an Object-Relational Bridge for python
  • Adaptor: Adaptor
  • AdaptorChannel: AdaptorChannel
  • AdaptorContext: AdaptorContext
  • AdaptorOperation: AdaptorOperation
  • Attribute: ...
  • ClassDescription: ClassDescription
  • CooperatingObjectStore: CooperatingObjectStore
  • CustomObject: CustomObject
  • Database: Database
  • DatabaseAdaptors
    • AbstractDBAPI2AdaptorLayer: AbstractDBAPI2AdaptorLayer
      • AbstractDBAPI2Adaptor: AbstractDBAPI2Adaptor
      • AbstractDBAPI2AdaptorChannel: AbstractDBAPI2Adaptor
      • AbstractDBAPI2AdaptorContext: AbstractDBAPI2AdaptorContext
      • AbstractDBAPI2SchemaGeneration: AbstractDBAPI2SchemaGeneration
    • MySQLAdaptorLayer: MySQLAdaptorLayer
      • mysql_utils: MySQL Adaptor Layer's utils
      • MySQLAdaptor: MySQLAdaptor
      • MySQLAdaptorChannel: MySQLAdaptor
      • MySQLAdaptorContext: MySQLAdaptorContext
      • MySQLSchemaGeneration: MySQLSchemaGeneration
      • MySQLSQLExpression: MySQLSQLExpression
    • OracleAdaptorLayer: This package is the db-adaptor for Oracle databases.
      • oracle_utils: Oracle Adaptor Layer's utils
      • OracleAdaptor: OracleAdaptor
      • OracleAdaptorChannel: OracleAdaptorChannel
      • OracleAdaptorContext: OracleAdaptorContext
      • OracleSchemaGeneration: OracleSchemaGeneration
      • OracleSQLExpression: OracleSQLExpression
    • PostgresqlAdaptorLayer: PostgresqlAdaptorLayer
      • pg_utils: Postgresql Adaptor Layer's utils
      • PostgresqlAdaptor: PostgresqlAdaptor
      • PostgresqlAdaptorChannel: PostgresqlAdaptorChannel
      • PostgresqlAdaptorContext: PostgresqlAdaptorContext
      • PostgresqlSchemaGeneration: PostgresqlSchemaGeneration
      • PostgresqlSQLExpression: PostgresqlSQLExpression
    • SQLiteAdaptorLayer: This package is the db-adaptor for SQLite databases.
      • SQLiteAdaptor: SQLiteAdaptor requires 'pysqlite' (http://pysqlite.sourceforge.net/)
      • SQLiteAdaptorChannel: SQLiteAdaptorChannel
      • SQLiteAdaptorContext: SQLiteAdaptorContext
      • SQLiteSchemaGeneration: Extends/changes the default behaviour to cope with unsupported SQL92 features in SQLite (see http://www.sqlite.org/omitted.html).
      • SQLiteSQLExpression: Supports generation of SQL statements for SQLite
  • DatabaseChannel: DatabaseContext
  • DatabaseContext
  • DatabaseObject: DatabaseObject
  • DatabaseOperation: AdaptorOperation API
  • delegation: delegation module.
  • dynamic: Documentation not written yet --see doc/README.dynamic.txt for details.
  • EditingContext: EditingContext
  • Entity: ...
  • EntityClassDescription: EntityClassDescription
  • Exceptions: ...
  • FaultHandler: FaultHandler & subclasses
  • FetchSpecification: FetchSpecification
  • GlobalID: GlobalID
  • interfaces
    • Adaptor: Adaptor API
    • AdaptorChannel: AdaptorContext API
    • AdaptorContext: AdaptorContext API
    • AdaptorOperation: AdaptorOperation API
    • ClassDescription: ClassDescription API
    • ClassDescriptionDelegate: ClassDescription API
    • CooperatingObjectStoreInterface: CooperatingObjectStore
    • DatabaseObject: DatabaseObject interface
    • DatabaseOperation: DatabaseOperation API
    • EditingContext: EditingContext API
    • Faulting: Faulting interface
    • FetchSpecification: FetchSpecification API
    • GlobalID: GlobalID API
    • KeyValueCoding: KeyValueCoding API
    • ObjectStoreInterface: ObjectStore Interface __TBD In addition, the module declares the following constants for use by the posted Notifications: - DeletedKey - InsertedKey - InvalidatedKey - UpdatedKey The posted notifications are identified by strings declared in the module as well: - InvalidatedAllObjectsInStoreNotification: __TBD when/what (object, userInfo) Posted when the method 'invalidateAllObjects' - ObjectsChangedInStoreNotification: __TBD when/what (object, userInfo) Posted every time an ObjectStore notices that some of its objects has changed.
    • ObserverCenter: ObserverCenter
    • Observing: Observing Interface
    • ObservingInterface: Observing Interface
    • Qualifier: Qualifier API
    • Relationship: ClassDescription API
    • RelationshipManipulation: Relationship manipulation API
    • SchemaGeneration: SchemaGeneration API
    • SortOrdering: SortOrdering API
    • Validation: Validation API
    • XMLCapability: XMLCapability API
  • Join: ...
  • KeyValueCoding: KeyValueCoding Mix-in class
  • logging: Module logging
  • Model: ...
  • ModelMasons
    • CMFModelMason: ModelMason
    • ModelMason: ModelMason contains the base class for every ''mason'' and is of no interest except if you plan to design a new module to generate code/files from a Model.
    • PyModelMason: PyModelMason generates the python package, modules and classes described in a model, ready to be used w/ the modeling framework.
    • Python_bricks
      • base_module
      • init
      • init_base
      • model
      • module_base
      • module_compact
      • setup_tmpl
  • ModelSet: A ModelSet holds a set of models that can co-exist and/or co-operate at runtime.
  • ModelValidation: ModelValidation
  • ObjectStore: ObjectStore
  • ObjectStoreCoordinator: ObjectStoreCoordinator __TBD Notifications The following notifications are defined and posted: - 'CooperatingObjectStoreWasAddedNotification' object: the 'ObjectStoreCoordinator' instance - 'CooperatingObjectStoreWasRemovedNotification' object: the removed 'ObjectStoreCoordinator' instance - 'CooperatingObjectStoreNeededNotification' object: the ObjectStoreCoordinator posting the request userInfo: either a GlobalID, an object ('DatabaseObject') or a FetchSpecification.
  • ObserverCenter: ObserverCenter
  • PyModel: Pythonic Description of an OO-RDBM Model Rules: - a model is an object of type Model - a model may specify a list of entities, each of type Entity - an entity may specify a list of properties, that are either of type Attribute or \of type Relation - all references to attributes, relations, entities, models, is by their "name" i.e.
  • Qualifier: Qualifier
  • QualifierParser: This module is where any Qualifier strings are interpreted and turned into real qualifier.
  • Relationship: ...
  • RelationshipManipulation: Allows the generic manipulation of objects in relation by inspecting the underlying model and taking appropriate actions.
  • SchemaGeneration: SchemaGeneration
  • SnapshotsHandling
  • SortOrdering: Module SortOrdering holds a "command" pattern for sorting objects, and the appropriate methods for building and using the commands.
  • SQLExpression: SQLExpression
  • utilities
    • EditingContextSessioning: EditingContextSessioning provides a set of functions that can be used to bind to an existing sessioning mechanism so that each existing session has its own EditingContext.
  • utils: Some useful functions to be used within the Modeling package, or by tools using this framework.
  • Validation: Validation
  • XMLutils: XMLutils provides standard imports along with error messages when these imports fail.

Class Hierarchy

• Cheetah.CacheRegion.CacheItem: A CacheItem is a container storing:
• Cheetah.CacheRegion.CacheRegion: A CacheRegion stores some CacheItem instances.
• Cheetah.Compiler.GenUtils: An abstract baseclass for the Compiler classes that provides methods that perform generic utility functions or generate pieces of output code from information passed in by the Parser baseclass.
  • Cheetah.Compiler.ClassCompiler
    • Cheetah.Compiler.AutoClassCompiler
  • Cheetah.Compiler.MethodCompiler
    • Cheetah.Compiler.AutoMethodCompiler
  • Cheetah.Compiler.ModuleCompiler
• Cheetah.SettingsManager._SettingsCollector: An abstract base class that provides the methods SettingsManager uses to collect settings from config files and SettingsContainers.
  • Cheetah.SettingsManager.SettingsManager: A mixin class that provides facilities for managing application settings.
    • Cheetah.Compiler.ModuleCompiler
• Cheetah.SourceReader.SourceReader
  • Cheetah.Parser._LowLevelParser: This class implements the methods to match or extract ('get*') the basic elements of Cheetah's grammar.
    • Cheetah.Parser._HighLevelParser: This class is a StateMachine for parsing Cheetah source and sending state dependent code generation commands to Cheetah.Compiler.Compiler.
• Cheetah.Template.TemplatePreprocessor: This is used with the preprocessors argument to Template.compile().
• ConfigParser.RawConfigParser
  • ConfigParser.ConfigParser
    • Cheetah.SettingsManager.ConfigParserCaseSensitive: A case sensitive version of the standard Python ConfigParser.
• Modeling.Adaptor.Adaptor: See interfaces.Adaptor for details
  • Modeling.DatabaseAdaptors.AbstractDBAPI2AdaptorLayer.AbstractDBAPI2Adaptor.AbstractDBAPI2Adaptor: Your inheriting concrete Adaptor class must override:
    • Modeling.DatabaseAdaptors.MySQLAdaptorLayer.MySQLAdaptor.MySQLAdaptor
    • Modeling.DatabaseAdaptors.OracleAdaptorLayer.OracleAdaptor.OracleAdaptor: Concrete AdaptorContext for Oracle [module DCOracle2]
    • Modeling.DatabaseAdaptors.PostgresqlAdaptorLayer.PostgresqlAdaptor.PostgresqlAdaptor: Concrete AdaptorContext for Postgresql [module psycopg or pgdb]
    • Modeling.DatabaseAdaptors.SQLiteAdaptorLayer.SQLiteAdaptor.SQLiteAdaptor: Concrete AdaptorContext for SQLite [module psycopg or pgdb]
• Modeling.AdaptorChannel.AdaptorChannel: See interfaces.AdaptorChannel for details
  • Modeling.DatabaseAdaptors.AbstractDBAPI2AdaptorLayer.AbstractDBAPI2AdaptorChannel.AbstractDBAPI2AdaptorChannel: Your inheriting concrete Adaptor class must override:
    • Modeling.DatabaseAdaptors.MySQLAdaptorLayer.MySQLAdaptorChannel.MySQLAdaptorChannel: Concrete AdaptorChannel for MySQL [module MySQLdb]
    • Modeling.DatabaseAdaptors.OracleAdaptorLayer.OracleAdaptorChannel.OracleAdaptorChannel: Concrete AdaptorChannel for Oracle
    • Modeling.DatabaseAdaptors.PostgresqlAdaptorLayer.PostgresqlAdaptorChannel.PostgresqlAdaptorChannel: Concrete AdaptorChannel for Postgresql [module psycopg or pgdb]
    • Modeling.DatabaseAdaptors.SQLiteAdaptorLayer.SQLiteAdaptorChannel.SQLiteAdaptorChannel: Concrete AdaptorChannel for SQLite [module pysqlite]
• Modeling.AdaptorContext.AdaptorContext: See interfaces.AdaptorContext for details
  • Modeling.DatabaseAdaptors.AbstractDBAPI2AdaptorLayer.AbstractDBAPI2AdaptorContext.AbstractDBAPI2AdaptorContext: Your inheriting concrete Adaptor class must override:
    • Modeling.DatabaseAdaptors.MySQLAdaptorLayer.MySQLAdaptorContext.MySQLAdaptorContext: Concrete AdaptorContext for MySQL [module MySQLdb]
    • Modeling.DatabaseAdaptors.OracleAdaptorLayer.OracleAdaptorContext.OracleAdaptorContext: Concrete AdaptorContext for Oracle
    • Modeling.DatabaseAdaptors.PostgresqlAdaptorLayer.PostgresqlAdaptorContext.PostgresqlAdaptorContext: Concrete AdaptorContext for Postgresql [module psycopg,pgdb or pypgsql]
    • Modeling.DatabaseAdaptors.SQLiteAdaptorLayer.SQLiteAdaptorContext.SQLiteAdaptorContext: Concrete AdaptorContext for SQLite [module pysqlite]
• Modeling.AdaptorOperation.AdaptorOperation
• Modeling.Attribute.Index
• Modeling.CustomObject.Snapshot_ToManyFault: Snapshot_ToManyFault is used in CustomObject.snapshot(), when returning the value for a to-many relationship which is still a fault.
• Modeling.DatabaseChannel.DatabaseChannel: The DatabaseChannel's reponsability is to fetch objects on behalf of a DatabaseContext.
• Modeling.DatabaseOperation.DatabaseOperation: A DatabaseOperation holds all the informations needed to make changes of an object persistent --this can be either the creation of that object, an update of its values, or the deletion of that object.
• Modeling.FaultHandler.FaultHandler: A FaultHandler works with any object implementing the Faulting interface ; its purpose is to help any conforming object, postponing their initialization until needed, to get their actual datas from DB.
  • Modeling.FaultHandler.AccessGenericFaultHandler: This is an abstract class providing the following capabilities:
    • Modeling.FaultHandler.AccessArrayFaultHandler: Handles to-many relationships
    • Modeling.FaultHandler.AccessFaultHandler: Handles to-one relationships
• Modeling.FetchSpecification.FetchSpecification: See interfaces.FetchSpecification for documentation
• Modeling.GlobalID.KeyGlobalID: KeyGlobalID
• Modeling.GlobalID.TemporaryGlobalID: TemporaryGlobalID
• Modeling.KeyValueCoding.KeyValueCoding: See interfaces.KeyValueCoding for details
  • Modeling.Attribute.Attribute: Describes an attribute
  • Modeling.DatabaseObject.DatabaseObject: --
    • Modeling.CustomObject.CustomObject: Validation
  • Modeling.Entity.Entity: Describes an entity An entity defines a class and its corresponding persistence schema.
  • Modeling.Model.Model: Describes a model
  • Modeling.Relationship.Relationship: See interfaces.Relationship for detail
    • Modeling.Relationship.FlattenedRelationship: See interfaces.Relationship for details
    • Modeling.Relationship.SimpleRelationship: Describes a relationship
• Modeling.ModelMasons.ModelMason.ModelMason: This class should be the base class for every masons.
  • Modeling.ModelMasons.CMFModelMason.CMFModelMason
  • Modeling.ModelMasons.PyModelMason.PyModelMason: See the module's documentation for details
• Modeling.ObjectStore.ObjectStore
  • Modeling.CooperatingObjectStore.CooperatingObjectStore: See 'Modeling.interfaces.CooperatingObjectStoreInterface' for details
    • Modeling.DatabaseContext.DatabaseContext
  • Modeling.EditingContext.EditingContext: EditingContext: an in-memory world/graph of objects, with the ability to ensure its own persistence, to check its consistency, etc.
  • Modeling.ObjectStoreCoordinator.ObjectStoreCoordinator: ObjectStoreCoordinator API
• Modeling.PyModel.BaseDescription: Base description class (should not be exported to client code)
  • Modeling.PyModel.Association: Describes an Association between 2 entities
  • Modeling.PyModel.Attribute: Describes an Attribute
    • Modeling.PyModel.ADateTime
    • Modeling.PyModel.AFloat
    • Modeling.PyModel.AInteger
      • Modeling.PyModel.AForeignKey
      • Modeling.PyModel.APrimaryKey
    • Modeling.PyModel.AString
  • Modeling.PyModel.BaseRelation: Describes a Relation
    • Modeling.PyModel.RToMany
    • Modeling.PyModel.RToOne
  • Modeling.PyModel.Entity: Describes an Entity
  • Modeling.PyModel.Model: Describes a Model
• Modeling.PyModel.MP
• Modeling.Qualifier.Qualifier
  • Modeling.Qualifier.AndQualifier
  • Modeling.Qualifier.KeyComparisonQualifier
  • Modeling.Qualifier.KeyValueQualifier
  • Modeling.Qualifier.NotQualifier
  • Modeling.Qualifier.OrQualifier
• Modeling.QualifierParser.AST
• Modeling.QualifierParser.Token
• Modeling.RelationshipManipulation.RelationshipManipulation: This mix-in class provides the default implementation for RelationshipManipulation interface to all subclasses.
  • Modeling.CustomObject.CustomObject: Validation
• Modeling.SQLExpression.Internals
• Modeling.SchemaGeneration.SchemaGeneration: ...
  • Modeling.DatabaseAdaptors.AbstractDBAPI2AdaptorLayer.AbstractDBAPI2SchemaGeneration.AbstractDBAPI2SchemaGeneration: This class is here for information only ; it does not contain any reusable logic.
  • Modeling.DatabaseAdaptors.MySQLAdaptorLayer.MySQLSchemaGeneration.MySQLSchemaGeneration: Implements the details db-schema generation which differ from the standard behaviour implemented by SchemaGeneration.
  • Modeling.DatabaseAdaptors.OracleAdaptorLayer.OracleSchemaGeneration.OracleSchemaGeneration: Concrete SchemaGeneration for Oracle
  • Modeling.DatabaseAdaptors.PostgresqlAdaptorLayer.PostgresqlSchemaGeneration.PostgresqlSchemaGeneration: Concrete SchemaGeneration for Postgresql [module psycopg or pgdb]
  • Modeling.DatabaseAdaptors.SQLiteAdaptorLayer.SQLiteSchemaGeneration.SQLiteSchemaGeneration: See Modeling.interfaces.SchemaGeneration for further details
• Modeling.SortOrdering.SortOrdering: The canonical sorting command has a key and an operator.
• Modeling.Validation.Validation: Mix-in class for validation: it defined the default mechanisms used in CustomObject.
• Modeling.XMLutils.XMLCapability: Mix-in class ...
  • Modeling.Attribute.Attribute: Describes an attribute
  • Modeling.Entity.Entity: Describes an entity An entity defines a class and its corresponding persistence schema.
  • Modeling.Join.Join: Describe a join
  • Modeling.Model.Model: Describes a model
  • Modeling.Relationship.Relationship: See interfaces.Relationship for detail
    • Modeling.Relationship.FlattenedRelationship: See interfaces.Relationship for details
    • Modeling.Relationship.SimpleRelationship: Describes a relationship
• Modeling.delegation.DelegateWrapper: The DelegateWrapper:
• Modeling.interfaces.Adaptor.Base
  • Modeling.interfaces.Adaptor.IAdaptor: Implemented in base class:...
• Modeling.interfaces.AdaptorChannel.Base
  • Modeling.interfaces.AdaptorChannel.IAdaptorChannel: setDelegate
• Modeling.interfaces.AdaptorContext.Base
  • Modeling.interfaces.AdaptorContext.IAdaptorContext: hasOpenTransaction transactionDidBegin transactionDidCommit transactionDidRollback
• Modeling.interfaces.AdaptorOperation.Base
  • Modeling.interfaces.AdaptorOperation.IAdaptorOperation
• Modeling.interfaces.ClassDescription.Base
  • Modeling.interfaces.ClassDescription.ClassDescriptionInterface: Documentation forthcoming
  • Modeling.interfaces.ClassDescription.ClassDescriptionManagerInterface: Responsible for class descriptions
• Modeling.interfaces.ClassDescriptionDelegate.Base
  • Modeling.interfaces.ClassDescriptionDelegate.ClassDescriptionDelegate
• Modeling.interfaces.DatabaseObject.Base
• Modeling.interfaces.DatabaseOperation.Base
  • Modeling.interfaces.DatabaseOperation.IDatabaseOperation
• Modeling.interfaces.EditingContext.Base
• Modeling.interfaces.Faulting.Base
  • Modeling.interfaces.Faulting.FaultingInterface: Handling of Faults, i.e.
    • Modeling.interfaces.DatabaseObject.DatabaseObjectInterface
• Modeling.interfaces.FetchSpecification.Base
  • Modeling.interfaces.FetchSpecification.IFetchSpecification: A FetchSpecification gathers all information needed to fetch objects, either from a database or (in-memory) in an EditingContext.
• Modeling.interfaces.GlobalID.Base
  • Modeling.interfaces.GlobalID.GlobalIDInterface: GlobalID
    • Modeling.interfaces.GlobalID.IKeyGlobalID: KeyGlobalID
    • Modeling.interfaces.GlobalID.ITemporaryGlobalID: TemporaryGlobalID
• Modeling.interfaces.KeyValueCoding.Base
  • Modeling.interfaces.KeyValueCoding.KeyValueCodingInterface: Mix-in class providing a common API to access or assign values to object's properties.
    • Modeling.interfaces.DatabaseObject.DatabaseObjectInterface
    • Modeling.interfaces.RelationshipManipulation.RelationshipManipulationInterface: The RelationshipManipulation interface defines all methods needed to manipulates relationships defined in a Model (see Model, Entity, Relationship and ClassDescription).
      • Modeling.interfaces.DatabaseObject.DatabaseObjectInterface
• Modeling.interfaces.ObjectStoreInterface.Base
  • Modeling.interfaces.ObjectStoreInterface.ObjectStoreInterface: ObjectStore API
    • Modeling.interfaces.CooperatingObjectStoreInterface.CooperatingObjectStoreInterface: CooperatingObjectStore
    • Modeling.interfaces.EditingContext.IEditingContext: EditingContext: an in-memory world/graph of objects, with the ability to ensure its own persistance, to check its consistency, etc.
• Modeling.interfaces.Observing.Base
  • Modeling.interfaces.Observing.ObservingInterface: Must be implemented by observers for use by the ObserverCenter.
• Modeling.interfaces.ObservingInterface.Base
  • Modeling.interfaces.ObservingInterface.ObservingInterface: Must be implemented by observers for use by the ObserverCenter.
    • Modeling.interfaces.EditingContext.IEditingContext: EditingContext: an in-memory world/graph of objects, with the ability to ensure its own persistance, to check its consistency, etc.
• Modeling.interfaces.Qualifier.Base
  • Modeling.interfaces.Qualifier.QualifierInterface
• Modeling.interfaces.Relationship.Base
  • Modeling.interfaces.Relationship.RelationshipInterface: Responsible for class descriptions class Relationship(Persistent, XMLCapability): Describes a relationship Implementation notes: - join semantic is not used for the moment being, and defaults to INNER_JOIN Features added to the EOF standard API: - cardinality of the relationship [Tableau suivant à verifier avec le Modeler]:: SimpleRel.
• Modeling.interfaces.RelationshipManipulation.Base
• Modeling.interfaces.SchemaGeneration.Base
  • Modeling.interfaces.SchemaGeneration.ISchemaGeneration: ...
• Modeling.interfaces.SortOrdering.Base
  • Modeling.interfaces.SortOrdering.SortOrderingInterface: SortOrdering
• Modeling.interfaces.Validation.Base
  • Modeling.interfaces.Validation.ValidationExceptionInterface: Raised by validation methods 'validateValue()' on 'Entity', 'Attributes' and 'Relationships' when they fail
  • Modeling.interfaces.Validation.ValidationInterface: Mix-in class for validation
    • Modeling.interfaces.DatabaseObject.DatabaseObjectInterface
• Modeling.interfaces.XMLCapability.Base
  • Modeling.interfaces.XMLCapability.XMLCapabilityInterface: Mix-in class ...
• __builtin__.object: The most base type
  • Cheetah.CacheStore.AbstractCacheStore
    • Cheetah.CacheStore.MemoryCacheStore
  • Modeling.Attribute.Attribute: Describes an attribute
  • Cheetah.Servlet.BaseServlet
    • Cheetah.Servlet.Servlet: This class is an abstract baseclass for Cheetah.Template.Template.
      • Cheetah.Template.Template: This class provides a) methods used by templates at runtime and b) methods for compiling Cheetah source code into template classes.
        • Modeling.ModelMasons.Python_bricks.base_module.base_module
        • Modeling.ModelMasons.Python_bricks.init.init
        • Modeling.ModelMasons.Python_bricks.init_base.init_base
        • Modeling.ModelMasons.Python_bricks.model.model
        • Modeling.ModelMasons.Python_bricks.module_base.module_base
        • Modeling.ModelMasons.Python_bricks.module_compact.module_compact
        • Modeling.ModelMasons.Python_bricks.setup_tmpl.setup_tmpl
  • Modeling.ClassDescription.ClassDescription: This class is an abstract class ; all methods defined in ClassDescriptionInterface raises and should be overridden in concrete subclasses.
    • Modeling.EntityClassDescription.EntityClassDescription: Documentation forthcoming
  • Modeling.CustomObject.CustomObject: Validation
  • Modeling.Database.Database: corresponds to one DB server
  • Modeling.EditingContext.EditingContext: EditingContext: an in-memory world/graph of objects, with the ability to ensure its own persistence, to check its consistency, etc.
  • Modeling.Entity.Entity: Describes an entity An entity defines a class and its corresponding persistence schema.
  • Modeling.Model.Model: Describes a model
  • Modeling.ModelSet.ModelSet: Holds a set of Modeling.Models that can co-exist at runtime
  • Modeling.Relationship.Relationship: See interfaces.Relationship for detail
    • Modeling.Relationship.FlattenedRelationship: See interfaces.Relationship for details
    • Modeling.Relationship.SimpleRelationship: Describes a relationship
  • Modeling.SnapshotsHandling.SnapshotsTable: __TBD
    • Modeling.Database.SnapshotsTable: Internally used to handle snapshots, so that this is handled as a whole
    • Modeling.DatabaseContext.SnapshotsTable: Internally used to handle local snapshots.
  • Modeling.SQLExpression.SQLExpression
    • Modeling.DatabaseAdaptors.MySQLAdaptorLayer.MySQLSQLExpression.MySQLSQLExpression: Sub-class of SQLExpression for the MySQLAdaptor.
    • Modeling.DatabaseAdaptors.OracleAdaptorLayer.OracleSQLExpression.OracleSQLExpression: Sub-class of SQLExpression for the OracleAdaptor.
    • Modeling.DatabaseAdaptors.PostgresqlAdaptorLayer.PostgresqlSQLExpression.PostgresqlSQLExpression: Sub-class of SQLExpression for the PostgresqlAdaptor.
    • Modeling.DatabaseAdaptors.SQLiteAdaptorLayer.SQLiteSQLExpression.SQLiteSQLExpression: Sub-class of SQLExpression for the SQLiteAdaptor.
  • __builtin__.type: type(object) -> the object's type type(name, bases, dict) -> a new type
    • Modeling.dynamic.CustomObjectMeta
  • Modeling.EditingContext.UniquingTable: The uniquing table - encapsulate the dictionary structure Defines the standard behaviour for methods: 'globalIDForObject()', 'objectForGlobalID', etc.
• exceptions.Exception: Common base class for all exceptions.
  • Modeling.Database.GeneralDatabaseException
  • Modeling.ModelMasons.PyModelMason.InvalidModelError: Raised by checkModelIsValid()
  • Modeling.Model.InvalidNameException: ...
  • Modeling.Model.ModelError: ...
  • Modeling.Exceptions.ModelValidationError: Raised by model-related validation methods on ModelSet, Model, Entity, Attributes and Relationships when they fail
  • Modeling.ModelValidation.ModelValidationException
  • Modeling.EditingContext.ObjectNotRegisteredError: Raised whenever an object is accessed that should be inserted in an EditingContext but is not.
  • Modeling.Exceptions.ObjectValidationError
  • Modeling.Relationship.RelationshipError: ...
  • Modeling.interfaces.Relationship.RelationshipErrorInterface: ...
  • exceptions.StandardError: Base class for all standard Python exceptions.
    • exceptions.ImportError: Import can't find module, or can't find name in module.
      • Modeling.Adaptor.AdaptorImportError
    • exceptions.RuntimeError: Unspecified run-time error.
      • Modeling.dynamic.EntityNotFound
      • Modeling.Adaptor.GeneralAdaptorException
        • Modeling.Adaptor.CannotSerializeException
      • Modeling.PyModel.IncompatibleVersionError
    • exceptions.ValueError: Inappropriate argument value (of correct type).
      • Modeling.SQLExpression.InvalidSQLTypeError: Raised by SQLExpression.formatValueForAttribute() when an unknown SQL type is encountered at runtime
      • Cheetah.Utils.WebInputMixin.NonNumericInputError
  • Modeling.Validation.ValidationException: Raised by validation methods validateValue() on Entity, Attributes and Relationships when they fail
  • Modeling.XMLutils.XMLImportError: Raised when a xml import fails
• spark.GenericASTTraversal
  • Modeling.QualifierParser.Interpret
  • Modeling.QualifierParser.TypeCheck
• spark.GenericParser
  • Modeling.QualifierParser.ExprParser
• spark.GenericScanner
  • Modeling.QualifierParser.QualifierScanner