org.models.file

Contains the models describing files and images.

Attributes

_T
FileT

Classes

DateInterval
GroupFilesByDateMixin	Abstract base class for generic types.
GeneralFile	A general file (image, document, pdf, etc), referenced in the database.
ImageFile	A general file (image, document, pdf, etc), referenced in the database.
ImageSet	A set of files that belong together. Each file may be part of
ImageSetCollection	Manages filesets.
GeneralFileCollection	Manages files.
BaseImageFileCollection	Manages files.
ImageFileCollection	Manages files.

Module Contents

org.models.file._T

org.models.file.FileT

class org.models.file.DateInterval

Bases: NamedTuple

name: str

start: datetime.datetime

end: datetime.datetime

class org.models.file.GroupFilesByDateMixin

Bases: Generic[FileT]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

query() → sqlalchemy.orm.Query[FileT]

get_date_intervals(today: datetime.datetime) → Iterator[DateInterval]

query_intervals(intervals: Iterable[DateInterval], before_filter: Callable[[Query[FileT]], Query[_RowT]], process: Callable[[_RowT], _T]) → Iterator[tuple[str, _T]]

query_intervals(intervals: Iterable[DateInterval], before_filter: None, process: Callable[[FileT], _T]) → Iterator[tuple[str, _T]]

query_intervals(intervals: Iterable[DateInterval], before_filter: None = None, *, process: Callable[[FileT], _T]) → Iterator[tuple[str, _T]]

query_intervals(intervals: Iterable[DateInterval], before_filter: Callable[[Query[FileT]], Query[Any]] | None = None, process: None = None) → Iterator[tuple[str, Any]]

grouped_by_date(today: datetime.datetime | None = None, id_only: Literal[True] = True) → groupby[str, tuple[str, str]]

grouped_by_date(today: datetime.datetime | None, id_only: Literal[False]) → groupby[str, tuple[str, FileT]]

grouped_by_date(today: datetime.datetime | None = None, *, id_only: Literal[False]) → groupby[str, tuple[str, FileT]]

Returns all files grouped by natural language dates.

By default, only ids are returned, as this is enough to build the necessary links, which is what you usually want from a file.

The given date is expected to be in UTC.

class org.models.file.GeneralFile

Bases: onegov.file.File, onegov.file.SearchableFile

A general file (image, document, pdf, etc), referenced in the database.

Thanks to the use of Depot files can be seemingly stored in the database (with transaction guarantees), without actually storing it in the database.

__mapper_args__

linked_accesses: onegov.core.orm.mixins.dict_property[dict[str, str]]

property access: str

property es_public: bool

Returns True if the model is available to be found by the public. If false, only editors/admins will see this object in the search results.

class org.models.file.ImageFile

Bases: onegov.file.File

A general file (image, document, pdf, etc), referenced in the database.

Thanks to the use of Depot files can be seemingly stored in the database (with transaction guarantees), without actually storing it in the database.

__mapper_args__

class org.models.file.ImageSet

Bases: onegov.file.FileSet, onegov.org.models.extensions.AccessExtension, onegov.search.ORMSearchable

A set of files that belong together. Each file may be part of none, one or many sets. Each set may containe none, one or many files.

The fileset uses uuids for public urls instead of a readable url-safe name, because files are meant to be always public with an unguessable url, and so the filesets containing files must also have the same property.

Otherwise we might not be able to guess the name the of the file, but we will be able to guess the name of a fileset containing files.

__mapper_args__

es_properties

Returns the type mapping of this model. Each property in the mapping will be read from the model instance.

The returned object needs to be a dict or an object that provides a to_dict method.

Internally, onegov.search stores differing languages in different indices. It does this automatically through langauge detection, or by manually specifying a language.

Note that objects with multiple languages are not supported (each object is supposed to have exactly one language).

Onegov.search will automatically insert the right analyzer for types like these.

There’s currently only limited support for properties here, namely objects and nested mappings do not work! This is going to be added in the future though.

property es_public: bool

Returns True if the model is available to be found by the public. If false, only editors/admins will see this object in the search results.

property es_suggestions: dict[str, list[str]]

lead: onegov.core.orm.mixins.dict_property[str | None]

view: onegov.core.orm.mixins.dict_property[str | None]

show_images_on_homepage: onegov.core.orm.mixins.dict_property[bool | None]

class org.models.file.ImageSetCollection(session: sqlalchemy.orm.Session)

Bases: onegov.file.FileSetCollection[ImageSet]

Manages filesets.

class org.models.file.GeneralFileCollection(session: sqlalchemy.orm.Session, order_by: str = 'name')

Bases: onegov.file.FileCollection[GeneralFile], GroupFilesByDateMixin[GeneralFile]

Manages files.

Parameters:

• session – The SQLAlchemy db session to use.

• type – The polymorphic type to use and to filter for, or ‘*’ for all.

• allow_duplicates –

  Prevents duplicates if set to false. Duplicates are detected before pre-processing, so already stored files may be downloaded and added again, as they might have changed during the upload.

  Note that this does not change existing files. It only prevents new duplicates from being added.

supported_content_types = 'all'

file_list

order_by

direction

_last_interval: DateInterval | None = None

for_order(order: str) → Self

property intervals: tuple[DateInterval, Ellipsis]

property statement: sqlalchemy.sql.Select

property files: Query[FileRow]

group(record: FileRow) → str

class org.models.file.BaseImageFileCollection(session: sqlalchemy.orm.Session, type: Literal['*', 'generic'] = '*', allow_duplicates: bool = True)

class org.models.file.BaseImageFileCollection(session: sqlalchemy.orm.Session, type: str, allow_duplicates: bool = True)

Bases: onegov.file.FileCollection[FileT], GroupFilesByDateMixin[FileT]

Manages files.

Parameters:

• session – The SQLAlchemy db session to use.

• type – The polymorphic type to use and to filter for, or ‘*’ for all.

• allow_duplicates –

  Prevents duplicates if set to false. Duplicates are detected before pre-processing, so already stored files may be downloaded and added again, as they might have changed during the upload.

  Note that this does not change existing files. It only prevents new duplicates from being added.

supported_content_types

class org.models.file.ImageFileCollection(session: sqlalchemy.orm.Session)

Bases: BaseImageFileCollection[ImageFile]

Manages files.

Parameters:

• session – The SQLAlchemy db session to use.

• type – The polymorphic type to use and to filter for, or ‘*’ for all.

• allow_duplicates –

  Prevents duplicates if set to false. Duplicates are detected before pre-processing, so already stored files may be downloaded and added again, as they might have changed during the upload.

  Note that this does not change existing files. It only prevents new duplicates from being added.