tisserande.db

Submodules

• tisserande.db.base
• tisserande.db.data_types
• tisserande.db.edges
• tisserande.db.execution
• tisserande.db.function_types
• tisserande.db.nodes

Classes

ArrayTable	Declarative base for all database models.
ClassTable	Declarative base for all database models.
ConfigDictTypeTable	Declarative base for all database models.
ConfigFileTypeTable	Declarative base for all database models.
DataFileTypeTable	Declarative base for all database models.
ParameterTable	Declarative base for all database models.
EdgeTable	Declarative base for all database models.
ExecutionTable	Declarative base for all database models.
MemberFunctionTable	Declarative base for all database models.
PythonFunctionTable	Declarative base for all database models.
ShellFunctionTable	Declarative base for all database models.
NodeTable	Declarative base for all database models.

Package Contents

class tisserande.db.ArrayTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

n_dim: sqlalchemy.orm.Mapped[int]

shape: sqlalchemy.orm.Mapped[list[int]]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.ClassTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

module_: sqlalchemy.orm.Mapped[str]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.ConfigDictTypeTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.ConfigFileTypeTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.DataFileTypeTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.ParameterTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.EdgeTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

from_id: sqlalchemy.orm.Mapped[uuid.UUID]

to_id: sqlalchemy.orm.Mapped[uuid.UUID]

execution_id: sqlalchemy.orm.Mapped[uuid.UUID | None]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.ExecutionTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[uuid.UUID]

function_node_id: sqlalchemy.orm.Mapped[uuid.UUID | None]

status: sqlalchemy.orm.Mapped[str]

start_time: sqlalchemy.orm.Mapped[datetime.datetime | None]

end_time: sqlalchemy.orm.Mapped[datetime.datetime | None]

duration_seconds: sqlalchemy.orm.Mapped[float | None]

error_message: sqlalchemy.orm.Mapped[str | None]

error_traceback: sqlalchemy.orm.Mapped[str | None]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.MemberFunctionTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

class_id: sqlalchemy.orm.Mapped[int]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.PythonFunctionTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

module_: sqlalchemy.orm.Mapped[str]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.ShellFunctionTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[int]

name: sqlalchemy.orm.Mapped[str]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes

class tisserande.db.NodeTable

Bases: tisserande.db.base.Base

Declarative base for all database models.

Provides:

• Schema assignment from configuration

• Consistent constraint naming for migrations

• Shared metadata for all models

• Required interface for Pydantic integration

• Lifecycle hooks for create, update, and delete operations

Subclasses must implement the abstract methods for Pydantic model integration. Subclasses may override hook methods to add custom behavior at various points in the row lifecycle.

id_: sqlalchemy.orm.Mapped[uuid.UUID]

type_: sqlalchemy.orm.Mapped[str]

execution_id: sqlalchemy.orm.Mapped[uuid.UUID | None]

path: sqlalchemy.orm.Mapped[str | None]

config_data: sqlalchemy.orm.Mapped[dict | None]

value_float: sqlalchemy.orm.Mapped[float | None]

value_json: sqlalchemy.orm.Mapped[dict | list | None]

arg_name: sqlalchemy.orm.Mapped[str | None]

data_file_type_id: sqlalchemy.orm.Mapped[int | None]

config_file_type_id: sqlalchemy.orm.Mapped[int | None]

config_dict_type_id: sqlalchemy.orm.Mapped[int | None]

parameter_id: sqlalchemy.orm.Mapped[int | None]

array_id: sqlalchemy.orm.Mapped[int | None]

class_id: sqlalchemy.orm.Mapped[int | None]

python_function_id: sqlalchemy.orm.Mapped[int | None]

member_function_id: sqlalchemy.orm.Mapped[int | None]

shell_function_id: sqlalchemy.orm.Mapped[int | None]

classmethod pydantic_create_class() → type[pydantic.BaseModel]

Pydantic model used to create rows in this table.

This model defines the schema for input validation when creating new rows. It may differ from pydantic_model_class() if creation requires different fields than the full model representation.

Returns:

The Pydantic model class for row creation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_create_class(cls) -> type[BaseModel]:
...         return UserCreate  # Excludes id, created_at, etc.

classmethod pydantic_model_class() → type[pydantic.BaseModel]

Pydantic model class for this table.

This model defines the complete schema for serialization and validation of existing rows, typically including all fields.

Returns:

The Pydantic model class for row serialization/validation

Examples

>>> class User(Base):
...     @classmethod
...     def pydantic_model_class(cls) -> type[BaseModel]:
...         return UserModel  # Includes all fields

classmethod class_string() → str

Name to use for help functions and descriptions.

Override this if you want a custom display name different from __name__.

Returns:

The class name for display purposes