sticky_pi_api.database package

Submodules

sticky_pi_api.database.images_table module

class sticky_pi_api.database.images_table.Images(file, api_user=None)[source]

Bases: sticky_pi_api.database.utils.BaseCustomisations

alt
api_user
api_version
datetime
datetime_created
device
device_version
property file_blob
property filename
height
hum
id
lat
lng
md5
no_flash_bv
no_flash_exposure_time
no_flash_iso
no_flash_shutter_speed
temp
property thumbnail
property thumbnail_mini
uid_annotations
width

sticky_pi_api.database.uid_annotations_table module

class sticky_pi_api.database.uid_annotations_table.UIDAnnotations(info, api_user=None)[source]

Bases: sticky_pi_api.database.utils.BaseCustomisations

algo_name
algo_version
api_user
api_version
datetime_created
id
json
n_objects
parent_image
parent_image_id

sticky_pi_api.database.users_tables module

class sticky_pi_api.database.users_tables.Users(password, api_user=None, **kwargs)[source]

Bases: sticky_pi_api.database.utils.BaseCustomisations

api_user
api_version
can_write
datetime_created
email
generate_auth_token(api_secret_key, expiration=86400)[source]
id
is_admin
password_hash
username
verify_password(password)[source]

sticky_pi_api.database.utils module

class sticky_pi_api.database.utils.BaseCustomisations(api_user=None, **kwargs)[source]

Bases: sqlalchemy.ext.declarative.api.Base

A simple constructor that allows initialization from kwargs.

Sets attributes on the constructed instance using the names and values in kwargs.

Only keys that are present as attributes of the instance’s class are allowed. These could be, for example, any mapped columns or relationships.

api_user = Column(None, String(length=32), table=None)
api_version = Column(None, String(length=8), table=None, default=ColumnDefault('1.0.0'))
classmethod column_names()[source]
datetime_created = Column(None, DateTime(), table=None, nullable=False)
to_dict()[source]
class sticky_pi_api.database.utils.DescribedColumn(col_type, description='', *args, **kwargs)[source]

Bases: sqlalchemy.sql.schema.Column

Construct a new Column object.

Parameters

  • name –

    The name of this column as represented in the database. This argument may be the first positional argument, or specified via keyword.

    Names which contain no upper case characters will be treated as case insensitive names, and will not be quoted unless they are a reserved word. Names with any number of upper case characters will be quoted and sent exactly. Note that this behavior applies even for databases which standardize upper case names as case insensitive such as Oracle.

    The name field may be omitted at construction time and applied later, at any time before the Column is associated with a _schema.Table. This is to support convenient usage within the declarative extension.

  • type_ –

    The column’s type, indicated using an instance which subclasses TypeEngine. If no arguments are required for the type, the class of the type can be sent as well, e.g.:

    # use a type with arguments
Column('data', String(50))

# use no arguments
Column('level', Integer)

    The type argument may be the second positional argument or specified by keyword.

    If the type is None or is omitted, it will first default to the special type NullType. If and when this _schema.Column is made to refer to another column using _schema.ForeignKey and/or _schema.ForeignKeyConstraint, the type of the remote-referenced column will be copied to this column as well, at the moment that the foreign key is resolved against that remote _schema.Column object.

    Changed in version 0.9.0: Support for propagation of type to a _schema.Column from its _schema.ForeignKey object has been improved and should be more reliable and timely.

  • *args – Additional positional arguments include various SchemaItem derived constructs which will be applied as options to the column. These include instances of Constraint, _schema.ForeignKey, ColumnDefault, Sequence, Computed. In some cases an equivalent keyword argument is available such as server_default, default and unique.

  • autoincrement –

    Set up “auto increment” semantics for an integer primary key column. The default value is the string "auto" which indicates that a single-column primary key that is of an INTEGER type with no stated client-side or python-side defaults should receive auto increment semantics automatically; all other varieties of primary key columns will not. This includes that DDL such as PostgreSQL SERIAL or MySQL AUTO_INCREMENT will be emitted for this column during a table create, as well as that the column is assumed to generate new integer primary key values when an INSERT statement invokes which will be retrieved by the dialect.

    The flag may be set to True to indicate that a column which is part of a composite (e.g. multi-column) primary key should have autoincrement semantics, though note that only one column within a primary key may have this setting. It can also be set to True to indicate autoincrement semantics on a column that has a client-side or server-side default configured, however note that not all dialects can accommodate all styles of default as an “autoincrement”. It can also be set to False on a single-column primary key that has a datatype of INTEGER in order to disable auto increment semantics for that column.

    Changed in version 1.1: The autoincrement flag now defaults to "auto" which indicates autoincrement semantics by default for single-column integer primary keys only; for composite (multi-column) primary keys, autoincrement is never implicitly enabled; as always, autoincrement=True will allow for at most one of those columns to be an “autoincrement” column. autoincrement=True may also be set on a _schema.Column that has an explicit client-side or server-side default, subject to limitations of the backend database and dialect.

    The setting only has an effect for columns which are:

    • Integer derived (i.e. INT, SMALLINT, BIGINT).

    • Part of the primary key

    • Not referring to another column via _schema.ForeignKey, unless the value is specified as 'ignore_fk':

      # turn on autoincrement for this column despite
# the ForeignKey()
Column('id', ForeignKey('other.id'),
            primary_key=True, autoincrement='ignore_fk')

      It is typically not desirable to have “autoincrement” enabled on a column that refers to another via foreign key, as such a column is required to refer to a value that originates from elsewhere.

    The setting has these two effects on columns that meet the above criteria:

    • DDL issued for the column will include database-specific keywords intended to signify this column as an “autoincrement” column, such as AUTO INCREMENT on MySQL, SERIAL on PostgreSQL, and IDENTITY on MS-SQL. It does not issue AUTOINCREMENT for SQLite since this is a special SQLite flag that is not required for autoincrementing behavior.

      See also

      SQLite Auto Incrementing Behavior

    • The column will be considered to be available using an “autoincrement” method specific to the backend database, such as calling upon cursor.lastrowid, using RETURNING in an INSERT statement to get at a sequence-generated value, or using special functions such as “SELECT scope_identity()”. These methods are highly specific to the DBAPIs and databases in use and vary greatly, so care should be taken when associating autoincrement=True with a custom default generation function.

  • default –

    A scalar, Python callable, or _expression.ColumnElement expression representing the default value for this column, which will be invoked upon insert if this column is otherwise not specified in the VALUES clause of the insert. This is a shortcut to using ColumnDefault as a positional argument; see that class for full detail on the structure of the argument.

    Contrast this argument to :paramref:`_schema.Column.server_default` which creates a default generator on the database side.

    See also

    Column INSERT/UPDATE Defaults

  • doc – optional String that can be used by the ORM or similar to document attributes on the Python side. This attribute does not render SQL comments; use the :paramref:`_schema.Column.comment` parameter for this purpose.

  • key – An optional string identifier which will identify this Column object on the _schema.Table. When a key is provided, this is the only identifier referencing the Column within the application, including ORM attribute mapping; the name field is used only when rendering SQL.

  • index –

    When True, indicates that a _schema.Index construct will be automatically generated for this _schema.Column, which will result in a “CREATE INDEX” statement being emitted for the _schema.Table when the DDL create operation is invoked.

    Using this flag is equivalent to making use of the _schema.Index construct explicitly at the level of the _schema.Table construct itself:

    Table(
    "some_table",
    metadata,
    Column("x", Integer),
    Index("ix_some_table_x", "x")
)

    To add the :paramref:`_schema.Index.unique` flag to the _schema.Index, set both the :paramref:`_schema.Column.unique` and :paramref:`_schema.Column.index` flags to True simultaneously, which will have the effect of rendering the “CREATE UNIQUE INDEX” DDL instruction instead of “CREATE INDEX”.

    The name of the index is generated using the default naming convention which for the _schema.Index construct is of the form ix_<tablename>_<columnname>.

    As this flag is intended only as a convenience for the common case of adding a single-column, default configured index to a table definition, explicit use of the _schema.Index construct should be preferred for most use cases, including composite indexes that encompass more than one column, indexes with SQL expressions or ordering, backend-specific index configuration options, and indexes that use a specific name.

    Note

    the _schema.Column.index attribute on _schema.Column does not indicate if this column is indexed or not, only if this flag was explicitly set here. To view indexes on a column, view the _schema.Table.indexes collection or use _reflection.Inspector.get_indexes().

    See also

    Indexes

    Configuring Constraint Naming Conventions

    :paramref:`_schema.Column.unique`

  • info – Optional data dictionary which will be populated into the SchemaItem.info attribute of this object.

  • nullable – When set to False, will cause the “NOT NULL” phrase to be added when generating DDL for the column. When True, will normally generate nothing (in SQL this defaults to “NULL”), except in some very specific backend-specific edge cases where “NULL” may render explicitly. Defaults to True unless :paramref:`_schema.Column.primary_key` is also True, in which case it defaults to False. This parameter is only used when issuing CREATE TABLE statements.

  • onupdate –

    A scalar, Python callable, or ClauseElement representing a default value to be applied to the column within UPDATE statements, which will be invoked upon update if this column is not present in the SET clause of the update. This is a shortcut to using ColumnDefault as a positional argument with for_update=True.

    See also

    Column INSERT/UPDATE Defaults - complete discussion of onupdate

  • primary_key – If True, marks this column as a primary key column. Multiple columns can have this flag set to specify composite primary keys. As an alternative, the primary key of a _schema.Table can be specified via an explicit PrimaryKeyConstraint object.

  • server_default –

    A FetchedValue instance, str, Unicode or text() construct representing the DDL DEFAULT value for the column.

    String types will be emitted as-is, surrounded by single quotes:

    Column('x', Text, server_default="val")

x TEXT DEFAULT 'val'

    A text() expression will be rendered as-is, without quotes:

    Column('y', DateTime, server_default=text('NOW()'))

y DATETIME DEFAULT NOW()

    Strings and text() will be converted into a DefaultClause object upon initialization.

    Use FetchedValue to indicate that an already-existing column will generate a default value on the database side which will be available to SQLAlchemy for post-fetch after inserts. This construct does not specify any DDL and the implementation is left to the database, such as via a trigger.

    See also

    Server-invoked DDL-Explicit Default Expressions - complete discussion of server side defaults

  • server_onupdate –

    A FetchedValue instance representing a database-side default generation function, such as a trigger. This indicates to SQLAlchemy that a newly generated value will be available after updates. This construct does not actually implement any kind of generation function within the database, which instead must be specified separately.

    Warning

    This directive does not currently produce MySQL’s “ON UPDATE CURRENT_TIMESTAMP()” clause. See Rendering ON UPDATE CURRENT TIMESTAMP for MySQL’s explicit_defaults_for_timestamp for background on how to produce this clause.

    See also

    Marking Implicitly Generated Values, timestamps, and Triggered Columns

  • quote – Force quoting of this column’s name on or off, corresponding to True or False. When left at its default of None, the column identifier will be quoted according to whether the name is case sensitive (identifiers with at least one upper case character are treated as case sensitive), or if it’s a reserved word. This flag is only needed to force quoting of a reserved word which is not known by the SQLAlchemy dialect.

  • unique –

    When True, and the :paramref:`_schema.Column.index` parameter is left at its default value of False, indicates that a _schema.UniqueConstraint construct will be automatically generated for this _schema.Column, which will result in a “UNIQUE CONSTRAINT” clause referring to this column being included in the CREATE TABLE statement emitted, when the DDL create operation for the _schema.Table object is invoked.

    When this flag is True while the :paramref:`_schema.Column.index` parameter is simultaneously set to True, the effect instead is that a _schema.Index construct which includes the :paramref:`_schema.Index.unique` parameter set to True is generated. See the documentation for :paramref:`_schema.Column.index` for additional detail.

    Using this flag is equivalent to making use of the _schema.UniqueConstraint construct explicitly at the level of the _schema.Table construct itself:

    Table(
    "some_table",
    metadata,
    Column("x", Integer),
    UniqueConstraint("x")
)

    The :paramref:`_schema.UniqueConstraint.name` parameter of the unique constraint object is left at its default value of None; in the absence of a naming convention for the enclosing _schema.MetaData, the UNIQUE CONSTRAINT construct will be emitted as unnamed, which typically invokes a database-specific naming convention to take place.

    As this flag is intended only as a convenience for the common case of adding a single-column, default configured unique constraint to a table definition, explicit use of the _schema.UniqueConstraint construct should be preferred for most use cases, including composite constraints that encompass more than one column, backend-specific index configuration options, and constraints that use a specific name.

    Note

    the _schema.Column.unique attribute on _schema.Column does not indicate if this column has a unique constraint or not, only if this flag was explicitly set here. To view indexes and unique constraints that may involve this column, view the _schema.Table.indexes and/or _schema.Table.constraints collections or use _reflection.Inspector.get_indexes() and/or _reflection.Inspector.get_unique_constraints()

    See also

    UNIQUE Constraint

    Configuring Constraint Naming Conventions

    :paramref:`_schema.Column.index`

  • system –

    When True, indicates this is a “system” column, that is a column which is automatically made available by the database, and should not be included in the columns list for a CREATE TABLE statement.

    For more elaborate scenarios where columns should be conditionally rendered differently on different backends, consider custom compilation rules for CreateColumn.

  • comment –

    Optional string that will render an SQL comment on table creation.

    New in version 1.2: Added the :paramref:`_schema.Column.comment` parameter to _schema.Column.

Module contents