kotti.resources

The resources module contains all the classes for Kotti’s persistance layer, which is based on SQLAlchemy.

Inheritance Diagram

Inheritance diagram of kotti.resources

class kotti.resources.ContainerMixin[source]

Bases: object, UserDict.DictMixin

Containers form the API of a Node that’s used for subitem access and in traversal.

keys()[source]
Result:children names
Return type:list
children_with_permission(request, permission='view')[source]

Return only those children for which the user initiating the request has the asked permission.

Parameters:
  • request (kotti.request.Request) – current request
  • permission (str) – The permission for which you want the allowed children
Result:

List of child nodes

Return type:

list

class kotti.resources.LocalGroup(node, principal_name, group_name)[source]

Bases: sqlalchemy.ext.declarative.api.Base

Local groups allow the assignment of groups or roles to principals (users or groups) for a certain context (i.e. a Node in the content tree).

id

Primary key for the node in the DB (sqlalchemy.types.Integer)

node_id

ID of the node for this assignment (sqlalchemy.types.Integer)

principal_name

Name of the principal (user or group) (sqlalchemy.types.Unicode)

group_name

Name of the assigned group or role (sqlalchemy.types.Unicode)

class kotti.resources.Node(name=None, parent=None, title=u'', annotations=None, **kwargs)[source]

Bases: sqlalchemy.ext.declarative.api.Base, kotti.resources.ContainerMixin, kotti.security.PersistentACLMixin

Basic node in the persistance hierarchy.

id

Primary key for the node in the DB (sqlalchemy.types.Integer)

type

Lowercase class name of the node instance (sqlalchemy.types.String)

parent_id

ID of the node’s parent (sqlalchemy.types.Integer)

position

Position of the node within its container / parent (sqlalchemy.types.Integer)

path

The path can be used to efficiently filter for child objects (sqlalchemy.types.Unicode).

name

Name of the node as used in the URL (sqlalchemy.types.Unicode)

title

Title of the node, e.g. as shown in search results (sqlalchemy.types.Unicode)

annotations

Annotations can be used to store arbitrary data in a nested dictionary (kotti.sqla.NestedMustationDict)

copy(**kwargs)[source]
Result:A copy of the current instance
Return type:Node
class kotti.resources.TypeInfo(**kwargs)[source]

Bases: object

TypeInfo instances contain information about the type of a node.

You can pass arbitrary keyword arguments in the constructor, they will become instance attributes. The most common are:

  • name
  • title
  • add_view
  • addable_to
  • edit_links
  • selectable_default_views
  • uploadable_mimetypes
copy(**kwargs)[source]
Result:a copy of the current TypeInfo instance
Return type:TypeInfo
addable(context, request)[source]
Parameters:
  • context (Content or subclass thereof (or anything that has a type_info attribute of type TypeInfo)) –
  • request (kotti.request.Request) – current request
Result:

True if the type described in ‘self’ may be added to ‘context’, False otherwise.

Return type:

Boolean

add_selectable_default_view(name, title)[source]

Add a view to the list of default views selectable by the user in the UI.

Parameters:
  • name (str) – Name the view is registered with
  • title (unicode or TranslationString) – Title for the view for display in the UI.
is_uploadable_mimetype(mimetype)[source]

Check if uploads of the given MIME type are allowed.

Parameters:mimetype (str) – MIME type
Result:Upload allowed (>0) or forbidden (0). The greater the result, the better is the match. E.g. image/* (6) is a better match for image/png than * (1).
Return type:int
class kotti.resources.Tag(**kwargs)[source]

Bases: sqlalchemy.ext.declarative.api.Base

Basic tag implementation. Instances of this class are just the tag itself and can be mapped to instances of Content (or any of its descendants) via instances of TagsToContents.

id

Primary key column in the DB (sqlalchemy.types.Integer)

title

Title of the tag sqlalchemy.types.Unicode

items
Result:
Return type:list
class kotti.resources.TagsToContents(**kwargs)[source]

Bases: sqlalchemy.ext.declarative.api.Base

Tags to contents mapping

tag_id

Foreign key referencing Tag.id (sqlalchemy.types.Integer)

content_id

Foreign key referencing Content.id (sqlalchemy.types.Integer)

tag

Relation that adds a content_tags sqlalchemy.orm.backref() to Tag instances to allow easy access to all content tagged with that tag. (sqlalchemy.orm.relationship())

position

Ordering position of the tag sqlalchemy.types.Integer

title

title of the associated Tag instance (sqlalchemy.ext.associationproxy.association_proxy)

class kotti.resources.Content(name=None, parent=None, title=u'', annotations=None, default_view=None, description=u'', language=None, owner=None, creation_date=None, modification_date=None, in_navigation=True, tags=None, **kwargs)[source]

Bases: kotti.resources.Node

Content adds some attributes to Node that are useful for content objects in a CMS.

id

Primary key column in the DB (sqlalchemy.types.Integer)

state

Workflow state of the content object (sqlalchemy.types.String)

type_info = <kotti.resources.TypeInfo object>

type_info is a class attribute (TypeInfo)

default_view

Name of the view that should be displayed to the user when visiting an URL without a explicit view name appended (sqlalchemy.types.String)

description

Description of the content object. In default Kotti this is used e.g. in the description tag in the HTML, in the search results and rendered below the title in most views. (sqlalchemy.types.Unicode)

language

Language code (ISO 639) of the content object (sqlalchemy.types.Unicode)

owner

Owner (username) of the content object (sqlalchemy.types.Unicode)

in_navigation

Shall the content be visible in the navigation? (sqlalchemy.types.Boolean)

creation_date

Date / time the content was created (sqlalchemy.types.DateTime)

modification_date

Date / time the content was last modified (sqlalchemy.types.DateTime)

tags

Tags assigned to the content object (list of str)

class kotti.resources.Document(body=u'', mime_type='text/html', **kwargs)[source]

Bases: kotti.resources.Content

Document extends Content with a body and its mime_type. In addition Document and its descendants implement IDefaultWorkflow and therefore are associated with the default workflow (at least in unmodified Kotti installations).

id

Primary key column in the DB (sqlalchemy.types.Integer)

type_info = <kotti.resources.TypeInfo object>

type_info is a class attribute (TypeInfo)

body

Body text of the Document (sqlalchemy.types.Unicode)

mime_type

MIME type of the Document (sqlalchemy.types.String)

kotti.resources.and_(*clauses)

Produce a conjunction of expressions joined by AND.

E.g.:

from sqlalchemy import and_

stmt = select([users_table]).where(
                and_(
                    users_table.c.name == 'wendy',
                    users_table.c.enrolled == True
                )
            )

The and_() conjunction is also available using the Python & operator (though note that compound expressions need to be parenthesized in order to function with Python operator precedence behavior):

stmt = select([users_table]).where(
                (users_table.c.name == 'wendy') &
                (users_table.c.enrolled == True)
            )

The and_() operation is also implicit in some cases; the Select.where() method for example can be invoked multiple times against a statement, which will have the effect of each clause being combined using and_():

stmt = select([users_table]).\
            where(users_table.c.name == 'wendy').\
            where(users_table.c.enrolled == True)

See also

or_()

kotti.resources.select(columns=None, whereclause=None, from_obj=None, distinct=False, having=None, correlate=True, prefixes=None, **kwargs)

Construct a new Select.

Similar functionality is also available via the FromClause.select() method on any FromClause.

All arguments which accept ClauseElement arguments also accept string arguments, which will be converted as appropriate into either text() or literal_column() constructs.

See also

Selecting - Core Tutorial description of select().

Parameters:
  • columns

    A list of ColumnElement or FromClause objects which will form the columns clause of the resulting statement. For those objects that are instances of FromClause (typically Table or Alias objects), the FromClause.c collection is extracted to form a collection of ColumnElement objects.

    This parameter will also accept Text constructs as given, as well as ORM-mapped classes.

    Note

    The :paramref:`.select.columns` parameter is not available in the method form of select(), e.g. FromClause.select().

    See also

    Select.column()

    Select.with_only_columns()

  • whereclause

    A ClauseElement expression which will be used to form the WHERE clause. It is typically preferable to add WHERE criterion to an existing Select using method chaining with Select.where().

    See also

    Select.where()

  • from_obj

    A list of ClauseElement objects which will be added to the FROM clause of the resulting statement. This is equivalent to calling Select.select_from() using method chaining on an existing Select object.

    See also

    Select.select_from() - full description of explicit FROM clause specification.

  • autocommit

    Deprecated. Use .execution_options(autocommit=<True|False>) to set the autocommit option.

    See also

    Executable.execution_options()

  • bind=None – an Engine or Connection instance to which the resulting Select object will be bound. The Select object will otherwise automatically bind to whatever Connectable instances can be located within its contained ClauseElement members.
  • correlate=True

    indicates that this Select object should have its contained FromClause elements “correlated” to an enclosing Select object. It is typically preferable to specify correlations on an existing Select construct using Select.correlate().

    See also

    Select.correlate() - full description of correlation.

  • distinct=False

    when True, applies a DISTINCT qualifier to the columns clause of the resulting statement.

    The boolean argument may also be a column expression or list of column expressions - this is a special calling form which is understood by the Postgresql dialect to render the DISTINCT ON (<columns>) syntax.

    distinct is also available on an existing Select object via the distinct() method.

    See also

    Select.distinct()

  • for_update=False
    when True, applies FOR UPDATE to the end of the resulting statement.

    Deprecated since version 0.9.0: - use Select.with_for_update() to specify the structure of the FOR UPDATE clause.

    for_update accepts various string values interpreted by specific backends, including:

    • "read" - on MySQL, translates to LOCK IN SHARE MODE; on Postgresql, translates to FOR SHARE.
    • "nowait" - on Postgresql and Oracle, translates to FOR UPDATE NOWAIT.
    • "read_nowait" - on Postgresql, translates to FOR SHARE NOWAIT.

    See also

    Select.with_for_update() - improved API for specifying the FOR UPDATE clause.

  • group_by

    a list of ClauseElement objects which will comprise the GROUP BY clause of the resulting select. This parameter is typically specified more naturally using the Select.group_by() method on an existing Select.

    See also

    Select.group_by()

  • having

    a ClauseElement that will comprise the HAVING clause of the resulting select when GROUP BY is used. This parameter is typically specified more naturally using the Select.having() method on an existing Select.

    See also

    Select.having()

  • limit=None

    a numerical value which usually renders as a LIMIT expression in the resulting select. Backends that don’t support LIMIT will attempt to provide similar functionality. This parameter is typically specified more naturally using the Select.limit() method on an existing Select.

    See also

    Select.limit()

  • offset=None

    a numeric value which usually renders as an OFFSET expression in the resulting select. Backends that don’t support OFFSET will attempt to provide similar functionality. This parameter is typically specified more naturally using the Select.offset() method on an existing Select.

    See also

    Select.offset()

  • order_by

    a scalar or list of ClauseElement objects which will comprise the ORDER BY clause of the resulting select. This parameter is typically specified more naturally using the Select.order_by() method on an existing Select.

    See also

    Select.order_by()

  • use_labels=False

    when True, the statement will be generated using labels for each column in the columns clause, which qualify each column with its parent table’s (or aliases) name so that name conflicts between columns in different tables don’t occur. The format of the label is <tablename>_<column>. The “c” collection of the resulting Select object will use these names as well for targeting column members.

    This parameter can also be specified on an existing Select object using the Select.apply_labels() method.

    See also

    Select.apply_labels()

class kotti.resources.File(data=None, filename=None, mimetype=None, size=None, **kwargs)[source]

Bases: kotti.resources.Content

File adds some attributes to Content that are useful for storing binary data.

id

Primary key column in the DB (sqlalchemy.types.Integer)

filename

The filename is used in the attachment view to give downloads the original filename it had when it was uploaded. (sqlalchemy.types.Unicode)

mimetype

MIME type of the file (sqlalchemy.types.String)

size

Size of the file in bytes (sqlalchemy.types.Integer)

data

Filedepot mapped blob (depot.fileds.sqlalchemy.UploadedFileField)

classmethod from_field_storage(fs)[source]
Create and return an instance of this class from a file upload
through a webbrowser.
Parameters:fs (cgi.FieldStorage) – FieldStorage instance as found in a kotti.request.Request‘s POST MultiDict.
Result:The created instance.
Return type:kotti.resources.File
class kotti.resources.Image(data=None, filename=None, mimetype=None, size=None, **kwargs)[source]

Bases: kotti.resources.File

Image doesn’t add anything to File, but images have different views, that e.g. support on the fly scaling.

kotti.resources.get_root(request=None)[source]
Call the function defined by the kotti.root_factory setting and
return its result.
Parameters:request (kotti.request.Request) – current request (optional)
Result:a node in the node tree
Return type:Node or descendant;
kotti.resources.default_get_root(request=None)[source]

Default implementation for get_root().

Parameters:request (kotti.request.Request) – Current request (optional)
Result:Node in the object tree that has no parent.
Return type:Node or descendant; in a fresh Kotti site with Kotti’s default populator this will be an instance of Document.