Contents
- AnyBlok framework
- anyblok module
- anyblok.declarations module
- anyblok.model module
- anyblok.mapper module
- anyblok.config module
- anyblok.logging module
- anyblok.imp module
- anyblok.environment module
- anyblok.blok module
- anyblok.registry module
- anyblok.migration module
- anyblok.field module
- anyblok.column module
- anyblok.relationship module
- anyblok._graphviz module
- anyblok.scripts module
AnyBlok framework¶
anyblok module¶
-
anyblok.
start
(processName, configuration_groups=None, entry_points=None, useseparator=False, loadwithoutmigration=False, config=None, **kwargs) Function which initialize the application
registry = start('My application', configuration_groups=['config', 'database'], entry_points=['AnyBlok'])
Parameters: - processName – Name of the application
- version – Version of the application
- prompt – Prompt message for the help
- configuration_groups – list of the group of option for argparse
- entry_points – entry point where load blok
- useseparator – boolean, indicate if configuration option are split betwwen two application
- withoutautomigration – if True, any
Return type: registry if the database name is in the configuration
anyblok.declarations module¶
-
exception
anyblok.declarations.
DeclarationsException
Bases:
AttributeError
Simple Exception for Declarations
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.declarations.
Declarations
Represents all the declarations done by the bloks
Warning
This is a global information, during the execution you must use the registry. The registry is the real assembler of the python classes based on the installed bloks
from anyblok import Declarations
-
class
AuthorizationBinding
Encodes which policy to use per model or (model, permission).
In the assembly phase, copies of the policy are issued, and the registry is set as an attribute on them. This is a bit memory inefficient, but otherwise, passing the registry would have to be in all AuthorizationRule API calls.
-
class
Declarations.
Core
The Core class is the base of all the AnyBlok models
Add new core model:
@Declarations.register(Declarations.Core) class Base: pass
Remove the core model:
Declarations.unregister(Declarations.Core, 'Base', Base, blok='MyBlok')
-
classmethod
register
(parent, name, cls_, **kwargs) Add new sub registry in the registry
Parameters: - parent – Existing declaration
- name – Name of the new declaration to add it
- cls – Class Interface to add in the declaration
-
classmethod
unregister
(entry, cls_) Remove the Interface from the registry
Parameters: - entry – entry declaration of the model where the
cls_
must be removed - cls – Class Interface to remove in the declaration
- entry – entry declaration of the model where the
-
classmethod
-
class
Declarations.
Mixin
The Mixin class are used to define a behaviours on models:
Add new mixin class:
@Declarations.register(Declarations.Mixin) class MyMixinclass: pass
Remove a mixin class:
Declarations.unregister(Declarations.Mixin.MyMixinclass, MyMixinclass)
-
class
Declarations.
Model
The Model class is used to define or inherit an SQL table.
Add new model class:
@Declarations.register(Declarations.Model) class MyModelclass: pass
Remove a model class:
Declarations.unregister(Declarations.Model.MyModelclass, MyModelclass)
There are three Model families:
- No SQL Model: These models have got any field, so any table
- SQL Model:
- SQL View Model: it is a model mapped with a SQL View, the insert, update delete method are forbidden by the database
Each model has a:
- registry name: compose by the parent + . + class model name
- table name: compose by the parent + ‘_’ + class model name
The table name can be overloaded by the attribute tablename. the wanted value are a string (name of the table) of a model in the declaration.
..warning:
Two models can have the same table name, both models are mapped on the table. But they must have the same column.
-
classmethod
apply_event_listner
(attr, method, registry, namespace, base, properties) Find the event listener methods in the base to save the namespace and the method in the registry
Parameters: - attr – name of the attibute
- method – method pointer
- registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- properties – the properties of the model
-
classmethod
apply_hybrid_method
(base, registry, namespace, bases, transformation_properties, properties) Create overload to define the write declaration of sqlalchemy hybrid method, add the overload in the declared bases of the namespace
Parameters: - registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- transformation_properties – the properties of the model
- properties – assembled attributes of the namespace
-
classmethod
apply_sqlalchemy_event_listner
(attr, method, registry, namespace, base, properties) declare in the registry the sqlalchemy event
Parameters: - attr – name of the attibute
- method – method pointer
- registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- properties – the properties of the model
-
classmethod
apply_table_and_mapper_args
(base, registry, namespace, bases, transformation_properties, properties) Create overwrite to define table and mapper args to define some options for SQLAlchemy
Parameters: - registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- transformation_properties – the properties of the model
- properties – assembled attributes of the namespace
-
classmethod
apply_view
(namespace, tablename, base, registry, properties) Transform the sqlmodel to view model
Parameters: - namespace – Namespace of the model
- tablename – Name od the table of the model
- base – Model cls
- registry – current registry
- properties – properties of the model
Exception: MigrationException
Exception: ViewException
-
classmethod
assemble_callback
(registry) Assemble callback is called to assemble all the Model from the installed bloks
Parameters: registry – registry to update
-
classmethod
declare_field
(registry, name, field, namespace, properties) Declare the field/column/relationship to put in the properties of the model
Parameters: - registry – the current registry
- name – name of the field / column or relationship
- field – the declaration field / column or relationship
- namespace – the namespace of the model
- properties – the properties of the model
-
classmethod
detect_hybrid_method
(attr, method, registry, namespace, base, properties) Find the sqlalchemy hybrid methods in the base to save the namespace and the method in the registry
Parameters: - attr – name of the attibute
- method – method pointer
- registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- properties – the properties of the model
-
classmethod
detect_table_and_mapper_args
(registry, namespace, base, properties) Test if define_table/mapper_args are in the base, and call them save the value in the properties
if __table/mapper_args__ are in the base then raise ModelException
Parameters: - registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- properties – the properties of the model
Exception: ModelException
-
classmethod
initialize_callback
(registry) initialize callback is called after assembling all entries
This callback updates the database information about
- Model
- Column
- RelationShip
Parameters: registry – registry to update
-
classmethod
insert_in_bases
(registry, namespace, bases, transformation_properties, properties) Add in the declared namespaces new base.
Parameters: - registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- transformation_properties – the properties of the model
- properties – assembled attributes of the namespace
-
classmethod
load_namespace_first_step
(registry, namespace) Return the properties of the declared bases for a namespace. This is the first step because some actions need to known all the properties
Parameters: - registry – the current registry
- namespace – the namespace of the model
Return type: dict of the known properties
-
classmethod
load_namespace_second_step
(registry, namespace, realregistryname=None, transformation_properties=None) Return the bases and the properties of the namespace
Parameters: - registry – the current registry
- namespace – the namespace of the model
- realregistryname – the name of the model if the namespace is a mixin
Return type: the list od the bases and the properties
Exception: ModelException
-
classmethod
register
(parent, name, cls_, **kwargs) add new sub registry in the registry
Parameters: - parent – Existing global registry
- name – Name of the new registry to add it
- cls – Class Interface to add in registry
-
classmethod
transform_base
(registry, namespace, base, properties) Detect specific declaration which must define by registry
Parameters: - registry – the current registry
- namespace – the namespace of the model
- base – One of the base of the model
- properties – the properties of the model
Return type: new base
-
classmethod
unregister
(entry, cls_) Remove the Interface from the registry
Parameters: - entry – entry declaration of the model where the
cls_
must be removed - cls – Class Interface to remove in registry
- entry – entry declaration of the model where the
-
classmethod
Declarations.
add_declaration_type
(cls_=None, isAnEntry=False, assemble=None, initialize=None, unload=None) Add a declaration type
Parameters: - cls – The
class
object to add as a world of the MetaData - isAnEntry – if true the type will be assembled by the registry
- assemble – name of the method callback to call (classmethod)
- initialize – name of the method callback to call (classmethod)
- unload – name of the method callback to call (classmethod)
Exception: DeclarationsException
- cls – The
-
classmethod
Declarations.
register
(parent, cls_=None, **kwargs) Method to add the blok in the registry under a type of declaration
Parameters: - parent – An existing blok class in the Declaration
- cls_ – The
class
object to add in the Declaration
Return type: cls_
Exception: DeclarationsException
-
classmethod
Declarations.
unregister
(entry, cls_) Method to remove the blok from a type of declaration
Parameters: - entry – declaration entry of the model where the
cls_
must be removed - cls_ – The
class
object to remove from the Declaration
Return type: cls_
- entry – declaration entry of the model where the
-
class
anyblok.model module¶
-
exception
anyblok.model.
ModelException
Bases:
Exception
Exception for Model declaration
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
exception
anyblok.model.
ViewException
Bases:
anyblok.model.ModelException
Exception for View declaration
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
anyblok.mapper module¶
-
exception
anyblok.mapper.
ModelAttributeException
Bases:
Exception
Exception for Model attribute
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
exception
anyblok.mapper.
ModelReprException
Bases:
Exception
Exception for Model attribute
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
exception
anyblok.mapper.
ModelAttributeAdapterException
Bases:
Exception
Exception for Model attribute adapter
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
exception
anyblok.mapper.
MapperException
Bases:
AttributeError
Simple Exception for Mapper
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.mapper.
ModelRepr
(model_name) Pseudo class to represent a model
mr = ModelRepr('registry name')
-
check_model
(registry) Check if the model exist else raise an exception
Parameters: registry – instance of the registry Return type: dict which represent the first step of the model Exceptions: ModelReprException
-
foreign_keys_for
(registry, remote_model) Return the of the primary keys
Parameters: registry – instance of the registry Return type: list of ModelAttribute
-
primary_keys
(registry) Return the of the primary keys
Parameters: registry – instance of the registry Return type: list of ModelAttribute
-
tablename
(registry) Return the real tablename of the Model
Parameters: registry – instance of the registry Return type: string
-
-
class
anyblok.mapper.
ModelAttribute
(model_name, attribute_name) The Model attribute represente the using of a declared attribute, in the goal of get the real attribute after of the foreign_key:
ma = ModelAttribute('registry name', 'attribute name')
-
get_attribute
(registry, usehybrid=True) Return the assembled attribute, the model need to be assembled
Parameters: - registry – instance of the registry
- usehybrid – if True return the hybrid property if exist
Return type: instance of the attribute
Exceptions: ModelAttributeException
-
get_column_name
(registry) Return the name of the column
the need of foreign key may be before the creation of the model in the registry, so we must use the first step of assembling
Parameters: registry – instance of the registry Return type: str of the foreign key (tablename.columnname) Exceptions: ModelAttributeException
-
get_fk
(registry) Return the foreign key which represent the attribute in the data base
Parameters: registry – instance of the sqlalchemy ForeignKey Return type: instance of the attribute
-
get_fk_column
(registry) Return the foreign key which represent the attribute in the data base
Parameters: registry – instance of the sqlalchemy ForeignKey Return type: instance of the attribute
-
get_fk_mapper
(registry) Return the foreign key which represent the attribute in the data base
Parameters: registry – instance of the sqlalchemy ForeignKey Return type: instance of the attribute
-
get_fk_name
(registry) Return the name of the foreign key
the need of foreign key may be before the creation of the model in the registry, so we must use the first step of assembling
Parameters: registry – instance of the registry Return type: str of the foreign key (tablename.columnname) Exceptions: ModelAttributeException
-
options
(**kwargs) Add foreign key options to create the sqlalchemy ForeignKey
Parameters: **kwargs – options Return type: the instance of the ModelAttribute
-
-
class
anyblok.mapper.
ModelMapper
(mapper, event, *args, **kwargs)
-
class
anyblok.mapper.
ModelAttributeMapper
(mapper, event, *args, **kwargs)
-
anyblok.mapper.
ModelAttributeAdapter
(Model) Return a ModelAttribute
Parameters: Model – ModelAttribute or string (‘registry name’=>’attribute name’) Return type: instance of ModelAttribute Exceptions: ModelAttributeAdapterException
-
anyblok.mapper.
ModelAdapter
(Model) Return a ModelRepr
Parameters: Model – ModelRepr or string Return type: instance of ModelRepr Exceptions: ModelAdapterException
-
anyblok.mapper.
MapperAdapter
(mapper, *args, **kwargs)
anyblok.config module¶
-
exception
anyblok.config.
ConfigurationException
Bases:
LookupError
Simple Exception for Configuration
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.config.
Configuration
Configuration
is used to define the options of the real argparse and its default values. Each application or blok can declare needed options here.This class stores three attributes:
- groups: lists of options indexed by part, a part is a
ConfigParser
group, or a process name - labels: if a group has got a label then all the options in group are gathered in a parser group
- configuration: result of the
Configuration
after loading
-
classmethod
add
(group, part='bloks', label=None, function_=None, must_be_loaded_by_unittest=False) Add a function in a part and a group.
The function must have two arguments:
parser
: the parser instance of argparsedefault
: A dict with the default value
This function is called to know what the options of this must do. You can declare this group:
either by calling the
add
method as a function:def foo(parser, default): pass Configuration.add('create-db', function_=foo)
or by calling the
add
method as a decorator:@Configuration.add('create-db') def bar(parser, default): pass
By default the group is unnamed, if you want a named group, you must set the
label
attribute:@Configuration.add('create-db', label="Name of the group") def bar(parser, default): pass
Parameters: - part – ConfigParser group or process name
- group – group is a set of parser option
- label – If the group has a label then all the functions in the group are put in group parser
- function – function to add
- must_be_loaded_by_unittest – unittest call this function to init configuration of AnyBlok for run unittest”
-
classmethod
get
(opt, default=None) Get a value from the configuration dict after loading
After the loading of the application, all the options are saved in the Configuration. And all the applications have free access to these options:
from anyblok._configuration import Configuration database = Configuration.get('db_name')
..warning:
Some options are used as a default value not real value, such as the db_name
Parameters: - opt – name of the option
- default – default value if the option doesn’t exist
-
classmethod
has
(option) Check if the option exist in the configuration dict
Return True if the option is in the configuration dict and the value is not None. A None value is diferent that a ConfigOption with None value
Parameters: opt – option key to check Return type: boolean True is exist
-
classmethod
load
(application, configuration_groups=None, parts_to_load=('bloks', ), useseparator=False, **kwargs) Load the argparse definition and parse them
Parameters: - application – name of the application
- configuration_groups – iterable configuration group to load
- parts_to_load – group of blok to load
- useseparator – boolean(default False)
- **kwargs – ArgumentParser named arguments
-
classmethod
load_config_for_test
() Load the argparse configuration need for the unittest
-
classmethod
remove
(group, function_, part='bloks') Remove an existing function
If your application inherits some unwanted options from a specific function, you can unlink this function:
def foo(opt, default): pass Configuration.add('create-db', function_=foo) Configuration.remove('create-db', function_=foo)
Parameters: - part – ConfigParser group or process name
- group – group is a set of parser option
- function – function to add
-
classmethod
remove_label
(group, part='bloks') Remove an existing label
The goal of this function is to remove an existing label of a specific group:
@Configuration.add('create-db', label="Name of the group") def bar(parser, defaul): pass Configuration.remove_label('create-db')
Parameters: - part – ConfigParser group or process name
- group – group is a set of parser option
-
classmethod
set
(opt, value) Set a value to the configuration dict
Parameters: - opt – name of the option
- value – value to set
- groups: lists of options indexed by part, a part is a
anyblok.logging module¶
-
class
anyblok.logging.
consoleFormatter
(fmt=None, datefmt=None, style='%') Bases:
logging.Formatter
Define the format for console logging
-
converter
() - localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,
- tm_sec,tm_wday,tm_yday,tm_isdst)
Convert seconds since the Epoch to a time tuple expressing local time. When ‘seconds’ is not passed in, convert the current time instead.
-
format
(record) Add color to the message
Parameters: record – logging record instance Return type: logging record formatted
-
formatException
(ei) Format and return the specified exception information as a string.
This default implementation just uses traceback.print_exception()
-
formatStack
(stack_info) This method is provided as an extension point for specialized formatting of stack information.
The input data is a string as returned from a call to
traceback.print_stack()
, but with the last trailing newline removed.The base implementation just returns the value passed in.
-
formatTime
(record, datefmt=None) Return the creation time of the specified LogRecord as formatted text.
This method should be called from format() by a formatter which wants to make use of a formatted time. This method can be overridden in formatters to provide for any specific requirement, but the basic behaviour is as follows: if datefmt (a string) is specified, it is used with time.strftime() to format the creation time of the record. Otherwise, the ISO8601 format is used. The resulting string is returned. This function uses a user-configurable function to convert the creation time to a tuple. By default, time.localtime() is used; to change this for a particular formatter instance, set the ‘converter’ attribute to a function with the same signature as time.localtime() or time.gmtime(). To change it for all formatters, for example if you want all logging times to be shown in GMT, set the ‘converter’ attribute in the Formatter class.
-
usesTime
() Check if the format uses the creation time of the record.
-
-
class
anyblok.logging.
anyblokFormatter
(fmt=None, datefmt=None, style='%') Bases:
logging.Formatter
Define the format for console logging
-
converter
() - localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,
- tm_sec,tm_wday,tm_yday,tm_isdst)
Convert seconds since the Epoch to a time tuple expressing local time. When ‘seconds’ is not passed in, convert the current time instead.
-
format
(record) Add color to the message
Parameters: record – logging record instance Return type: logging record formatted
-
formatException
(ei) Format and return the specified exception information as a string.
This default implementation just uses traceback.print_exception()
-
formatStack
(stack_info) This method is provided as an extension point for specialized formatting of stack information.
The input data is a string as returned from a call to
traceback.print_stack()
, but with the last trailing newline removed.The base implementation just returns the value passed in.
-
formatTime
(record, datefmt=None) Return the creation time of the specified LogRecord as formatted text.
This method should be called from format() by a formatter which wants to make use of a formatted time. This method can be overridden in formatters to provide for any specific requirement, but the basic behaviour is as follows: if datefmt (a string) is specified, it is used with time.strftime() to format the creation time of the record. Otherwise, the ISO8601 format is used. The resulting string is returned. This function uses a user-configurable function to convert the creation time to a tuple. By default, time.localtime() is used; to change this for a particular formatter instance, set the ‘converter’ attribute to a function with the same signature as time.localtime() or time.gmtime(). To change it for all formatters, for example if you want all logging times to be shown in GMT, set the ‘converter’ attribute in the Formatter class.
-
usesTime
() Check if the format uses the creation time of the record.
-
-
anyblok.logging.
log
(logger, level='info', withargs=False) decorator to log the entry of a method
There are 5 levels of logging * debug * info (default) * warning * error * critical
example:
from logging import getLogger logger = getLogger(__name__) @log(logger) def foo(...): ...
Parameters: - level – AnyBlok log level
- withargs – If True, add args and kwargs in the log message
anyblok.imp module¶
-
exception
anyblok.imp.
ImportManagerException
Bases:
AttributeError
Exception for Import Manager
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.imp.
ImportManager
Use to import the blok or reload the blok imports
Add a blok and imports its modules:
blok = ImportManager.add('my blok') blok.imports()
Reload the modules of a blok:
if ImportManager.has('my blok'): blok = ImportManager.get('my blok') blok.reload() # import the unimported module
-
classmethod
add
(blok) Store the blok so that we know which bloks to reload if needed
Parameters: blok – name of the blok to add Return type: loader instance Exception: ImportManagerException
-
classmethod
get
(blok) Return the module imported for this blok
Parameters: blok – name of the blok to add Return type: loader instance Exception: ImportManagerException
-
classmethod
has
(blok) Return True if the blok was imported
Parameters: blok – name of the blok to add Return type: boolean
-
classmethod
anyblok.environment module¶
-
exception
anyblok.environment.
EnvironmentException
Bases:
AttributeError
Exception for the Environment
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.environment.
EnvironmentManager
Manage the Environment for an application
-
classmethod
define_environment_cls
(Environment) Define the class used for the environment
Parameters: Environment – class of environment Exception: EnvironmentException
-
environment
alias of
ThreadEnvironment
-
classmethod
get
(key, default=None) Load the value of the key in the environment
Parameters: - key – the key of the value to load
- default – return this value if not value loaded for the key
Return type: the value of the key
Exception: EnvironmentException
-
classmethod
scoped_function_for_session
() Save the value of the key in the environment
-
classmethod
set
(key, value) Save the value of the key in the environment
Parameters: - key – the key of the value to save
- value – the value to save
Exception: EnvironmentException
-
classmethod
-
class
anyblok.environment.
ThreadEnvironment
Use the thread, to get the environment
-
classmethod
getter
(key, default) Get the value of the key in the environment
Parameters: - key – the key of the value to retrieve
- default – return this value if no value loaded for the key
Return type: the value of the key
-
scoped_function_for_session
= None No scoped function here because for none value sqlalchemy already uses a thread to save the session
-
classmethod
setter
(key, value) Save the value of the key in the environment
Parameters: - key – the key of the value to save
- value – the value to save
-
classmethod
anyblok.blok module¶
-
exception
anyblok.blok.
BlokManagerException
(*args, **kwargs) Bases:
LookupError
Simple exception to BlokManager
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.blok.
BlokManager
Manage the bloks for one process
A blok has a setuptools entrypoint, this entry point is defined by the
entry_points
attribute in the first loadThe
bloks
attribute is a dict with all the loaded entry pointsUse this class to import all the bloks in the entrypoint:
BlokManager.load()
-
classmethod
add_importer
(key, cls_name) Add a new importer
Parameters: - key – key of the importer
- cls_name – name of the model to import
-
classmethod
get
(blok) Return the loaded blok
Parameters: blok – blok name Return type: blok instance Exception: BlokManagerException
-
classmethod
getPath
(blok) Return the path of the blok
Parameters: blok – blok name in ordered_bloks
Return type: absolute path
-
classmethod
get_importer
(key) Get the importer class name
Parameters: key – key of the importer Return type: name of the model to import Exception: BlokManagerException
-
classmethod
has
(blok) Return True if the blok is loaded
Parameters: blok – blok name Return type: bool
-
classmethod
has_importer
(key) Check if an importer
-
classmethod
list
() Return the ordered bloks
Return type: list of blok name ordered by loading
-
classmethod
load
(entry_points=('bloks', )) Load all the bloks and import them
Parameters: entry_points – Use by iter_entry_points
to get the blokException: BlokManagerException
-
classmethod
reload
() Reload the entry points
Empty the
bloks
dict and use theentry_points
attribute to load bloks :exception: BlokManagerException
-
classmethod
set
(blokname, blok) Add a new blok
Parameters: - blokname – blok name
- blok – blok instance
Exception: BlokManagerException
-
classmethod
unload
() Unload all the bloks but not the registry
-
classmethod
-
class
anyblok.blok.
Blok
(registry) Super class for all the bloks
define the default value for:
- priority: order to load the blok
- required: list of the bloks needed to install this blok
- optional: list of the bloks to be installed if present in the blok list
- conditional: if all the bloks of this list are installed then install this blok
-
classmethod
import_declaration_module
() Do the python import for the Declaration of the model or other
-
import_file
(importer_name, model, *file_path, **kwargs) Import data file
Parameters: - importer_name – Name of the importer (need installation of the Blok which have the importer)
- model – Model of the data to import
- *file_path – relative path of the path in this Blok
- **kwargs – Option for the importer
Return type: return dict of result
-
load
() Call at the launch of the application
-
post_migration
(latest_version) Call at update, after the automigration
Parameters: latest_version – latest version installed, if the blok have not been installing the latest_version will be None
-
pre_migration
(latest_version) Call at update, before the automigration
Warning
You can not use the ORM
Parameters: latest_version – latest version installed, if the blok have not been installing the latest_version will be None
-
uninstall
() Call at the uninstallation
-
update
(latest_version) Call at the installation or update
Parameters: latest_version – latest version installed, if the blok have not been installing the latest_version will be None
anyblok.registry module¶
-
exception
anyblok.registry.
RegistryManagerException
Bases:
Exception
Simple Exception for Registry
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
exception
anyblok.registry.
RegistryException
Bases:
Exception
Simple Exception for Registry
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.registry.
RegistryManager
Manage the global registry
Add new entry:
RegistryManager.declare_entry('newEntry') RegistryManager.init_blok('newBlok') EnvironmentManager.set('current_blok', 'newBlok') RegistryManager.add_entry_in_register( 'newEntry', 'oneKey', cls_) EnvironmentManager.set('current_blok', None)
Remove an existing entry:
if RegistryManager.has_entry_in_register('newBlok', 'newEntry', 'oneKey'): RegistryManager.remove_entry_in_register( 'newBlok', 'newEntry', 'oneKey', cls_)
get a new registry for a database:
registry = RegistryManager.get('my database')
-
classmethod
add_core_in_register
(core, cls_) Load core in blok
warning the global var current_blok must be filled on the good blok
Parameters: - core – is the existing core name
- cls_ – Class of the Core to save in loaded blok target registry
-
classmethod
add_entry_in_register
(entry, key, cls_, **kwargs) Load entry in blok
warning the global var current_blok must be filled on the good blok :param entry: is the existing entry name :param key: is the existing key in the entry :param
cls_
: Class of the entry / key to remove in loaded blok
-
classmethod
add_or_replace_blok_property
(property_, value) Save the value in the properties
Parameters: - property_ – name of the property
- value – the value to save, the type is not important
-
classmethod
clear
() Clear the registry dict to force the creation of new registry
-
classmethod
declare_core
(core) Add new core in the declared cores
RegistryManager.declare_core('Core name') ----------------------------------------- @Declarations.register(Declarations.Core) class ``Core name``: ...
Warning
The core must be declared in the application, not in the bloks The declaration must be done before the loading of the bloks
Parameters: core – core name
-
classmethod
declare_entry
(entry, assemble_callback=None, initialize_callback=None) Add new entry in the declared entries
def assemble_callback(registry): ... def initialize_callback(registry): ... RegistryManager.declare_entry( 'Entry name', assemble_callback=assemble_callback, initialize_callback=initialize_callback) @Declarations.register(Declarations.``Entry name``) class MyClass: ...
Warning
The entry must be declared in the application, not in the bloks The declaration must be done before the loading of the bloks
Parameters: - entry – entry name
- assemble_callback – function callback to call to assemble
- initialize_callback – function callback to call to init after assembling
-
classmethod
declare_unload_callback
(entry, unload_callback) Save a unload callback in registry Manager
Parameters: - entry – declaration type name
- unload_callback – classmethod pointer
-
classmethod
get
(db_name, loadwithoutmigration=False, **kwargs) Return an existing Registry
If the Registry doesn’t exist then the Registry are created and added to registries dict
Parameters: db_name – the name of the database linked to this registry Return type: Registry
-
classmethod
get_blok_property
(property_, default=None) Return the value in the properties
Parameters: - property_ – name of the property
- default – return default If not entry in the property
-
classmethod
has_blok
(blok) Return True if the blok is already loaded
Parameters: blok – name of the blok Return type: boolean
-
classmethod
has_blok_property
(property_) Return True if the property exists in blok
Parameters: property_ – name of the property
-
classmethod
has_core_in_register
(blok, core) Return True if One Class exist in this blok for this core
Parameters: - blok – name of the blok
- core – is the existing core name
-
classmethod
has_entry_in_register
(blok, entry, key) Return True if One Class exist in this blok for this entry
Parameters: - blok – name of the blok
- entry – is the existing entry name
- key – is the existing key in the entry
-
classmethod
init_blok
(blokname) init one blok to be known by the RegistryManager
All bloks loaded must be initialized because the registry will be created with this information
Parameters: blokname – name of the blok
-
classmethod
reload
() Reload the blok
The purpose is to reload the python module to get changes in python file
-
classmethod
remove_blok_property
(property_) Remove the property if exist
Parameters: property_ – name of the property
-
classmethod
remove_in_register
(cls_) Remove Class in blok and in entry
Parameters: cls_ – Class of the entry / key to remove in loaded blok
-
classmethod
unload
() Call all the unload callbacks
-
classmethod
-
class
anyblok.registry.
Registry
(db_name, loadwithoutmigration=False, unittest=False, **kwargs) Define one registry
A registry is linked to a database, and stores the definition of the installed Bloks, Models, Mixins for this database:
registry = Registry('My database')
-
add_in_registry
(namespace, base) Add a class as an attribute of the registry
Parameters: - namespace – tree path of the attribute
- base – class to add
-
apply_state
(blok_name, state, in_states) Apply the state of the blok name
Parameters: - blok_name – the name of the blok
- state – the state to apply
- in_states – the blok must be in this state
Exception: RegistryException
-
check_permission
(target, principals, permission) Check that one of the principals has permisson on target.
Parameters: - target – model instance (record) or class. Checking a permission on a model class with a policy that needs to work on records is considered a configuration error: the policy has the right to fail.
- principals – list, set or tuple of strings
Return type: bool
-
clean_model
() Clean the registry of all the namespaces
-
close
() Release the session, connection and engine
-
close_session
() Close only the session, not the registry After the call of this method the registry won’t be usable you should use close method which call this method
-
commit
(*args, **kwargs) Overload the commit method of the SqlAlchemy session
-
complete_reload
() Reload the code and registry
-
create_session_factory
() Create the SQLA Session factory
in function of the Core Session class ans the Core Qery class
-
engine
property to get the engine
-
expire
(obj, attribute_names=None) Expire object in session, you can define some attribute which are expired:
registry.expire(instance, ['attr1', 'attr2', ...])
Parameters: - obj – instance of
Model
- attribute_names – list of string, names of the attr to expire
- obj – instance of
-
get
(namespace) Return the namespace Class
Parameters: namespace – namespace to get from the registry str Return type: namespace cls Exception: RegistryManagerException
-
get_bloks_by_states
(*states) Return the bloks in these states
Parameters: states – list of the states Return type: list of blok’s name
-
get_bloks_to_install
(loaded) Return the bloks to install in the registry
Return type: list of blok’s name
-
get_bloks_to_load
() Return the bloks to load by the registry
Return type: list of blok’s name
-
ini_var
() Initialize the var to load the registry
-
init_bind
() Initialize the bind
-
init_engine
(db_name=None) Define the engine
Parameters: db_name – name of the database to link
-
init_engine_options
() Define the options to initialize the engine
-
load
() Load all the namespaces of the registry
Create all the table, make the shema migration Update Blok, Model, Column rows
-
load_blok
(blok, toinstall, toload) load on blok, load all the core and all the entry for one blok
Parameters: blok – name of the blok Exception: RegistryManagerException
-
load_core
(blok, core) load one core type for one blok
Parameters: - blok – name of the blok
- core – the core name to load
-
load_entry
(blok, entry) load one entry type for one blok
Parameters: - blok – name of the blok
- entry – declaration type to load
-
lookup_policy
(target, permission) Return the policy instance that applies to target or its model.
Parameters: target – model class or instance If a policy is declared for the precise permission, it is returned. Otherwise, the default policy for that model is returned. By ultimate default the special
anyblok.authorization.rule.DenyAll
is returned.
-
must_recreate_session_factory
() Check if the SQLA Session Factory must be destroy and recreate
Return type: Boolean, True if nb Core Session/Query inheritance change
-
precommit_hook
(registryname, method, *args, **kwargs) Add a method in the precommit_hook list
a precommit hook is a method called just after the commit, it is used to call this method once, because a hook is saved only once
Parameters: - registryname – namespace of the model
- method – method to call on the registryname
- put_at_the_end_if_exist – if true and hook allready exist then the hook are moved at the end
-
refresh
(obj, attribute_names=None) Expire and reload object in session, you can define some attribute which are refreshed:
registry.refresh(instance, ['attr1', 'attr2', ...])
Parameters: - obj – instance of
Model
- attribute_names – list of string, names of the attr to refresh
- obj – instance of
-
reload
() Reload the registry, close session, clean registry, reinit var
-
upgrade
(install=None, update=None, uninstall=None) Upgrade the current registry
Parameters: - install – list of the blok to install
- update – list of the blok to update
- uninstall – list of the blok to uninstall
Exception: RegistryException
-
wrap_query_permission
(query, principals, permission, models=()) Wrap query to return only authorized results
Parameters: - principals – list, set or tuple of strings
- models – models on which to apply security filtering. If not supplied, it will be infered from the query. The length and ordering much match that of expected results.
Returns: a query-like object, implementing the results fetching API, but that can’t be further filtered.
This method calls all the relevant policies to apply pre- and post-filtering. Although postfiltering is discouraged in authorization policies for performance and expressiveness (limit, offset), there are cases for which it is unavoidable, or in which the tradeoff goes the other way.
In normal operation, the relevant models are infered directly from the query. For join situations, and more complex queries, the caller has control on the models on which to exert permission checking.
For instance, it might make sense to use a join between Model1 and Model2 to actually constrain Model1 (on which permission filtering should occur) by information contained in Model2, even if the passed principals should not grant access to the relevant Model2 records.
-
anyblok.migration module¶
Warning
AnyBlok use Alembic to do the dynamic migration, but Alembic does’nt detect all the change (primary key, ...), we must wait the Alembic or implement it in Alembic project before use it in AnyBlok
-
exception
anyblok.migration.
MigrationException
Bases:
AttributeError
Simple Exception class for Migration
-
with_traceback
() Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.
-
-
class
anyblok.migration.
MigrationReport
(migration, diffs) Change report
Get a new report:
report = MigrationReport(migrationinstance, change_detected)
-
apply_change
() Apply the migration
this method parses the detected change and calls the Migration system to apply the change with the api of Declarations
-
log_has
(log) return True id the log is present
Warning
this method is only used for the unittest
Parameters: log – log sentence expected
-
-
class
anyblok.migration.
MigrationConstraintForeignKey
(table, name) Used to apply a migration on a foreign key
You can add:
table.column('my column').foreign_key().add(Blok.name)
Or drop:
table.column('my column').foreign_key().drop()
-
add
(local_columns, remote_columns, **kwargs) Add a new foreign key
Parameters: remote_field – The column of the remote model Return type: MigrationConstraintForeignKey instance
-
drop
() Drop the foreign key
-
-
class
anyblok.migration.
MigrationColumn
(table, name) get or add a column
Add a new column:
table.column().add(Sqlachemy column)
Get a column:
c = table.column('My column name')
Alter the column:
c.alter(new_column_name='Another column name')
Drop the column:
c.drop()
-
add
(column) Add a new column
The column is added in two phases, the last phase is only for the the nullable, if nullable can not be applied, a warning is logged
Parameters: column – sqlalchemy column Return type: MigrationColumn instance
-
alter
(**kwargs) Alter an existing column
Alter the column in two phases, because the nullable column has not locked the migration
Warning
See Alembic alter_column, the existing_* param are used for some dialect like mysql, is importante to filled them for these dialect
Parameters: - new_column_name – New name for the column
- type – New sqlalchemy type
- existing_type – Old sqlalchemy type
- server_default – The default value in database server
- existing_server_default – Old default value
- nullable – New nullable value
- existing_nullable – Old nullable value
- autoincrement – New auto increment use for Integer whith primary key only
- existing_autoincrement – Old auto increment
Return type: MigrationColumn instance
-
drop
() Drop the column
-
nullable
() Use for unittest return if the column is nullable
-
server_default
() Use for unittest: return the default database value
-
type
() Use for unittest: return the column type
-
-
class
anyblok.migration.
MigrationConstraintCheck
(table, name) Used for the Check constraint
Add a new constraint:
table('My table name').check().add('check_my_column', 'mycolumn > 5')
Get and drop the constraint:
table('My table name').check('check_my_column').drop()
-
add
(condition) Add the constraint
Parameters: condition – constraint to apply Return type: MigrationConstraintCheck instance
-
drop
() Drop the constraint
-
-
class
anyblok.migration.
MigrationConstraintUnique
(table, name) Used for the Unique constraint
Add a new constraint:
table('My table name').unique('constraint name').add('col1', 'col2')
Get and drop the constraint:
table('My table name').unique('constraint name').drop()
Let AnyBlok to define the name of the constraint:
table('My table name').unique(None).add('col1', 'col2')
-
add
(*columns) Add the constraint
Parameters: *column – list of column name Return type: MigrationConstraintUnique instance Exception: MigrationException
-
drop
() Drop the constraint
-
-
class
anyblok.migration.
MigrationConstraintPrimaryKey
(table) Used for the primary key constraint
Add a new constraint:
table('My table name').primarykey().add('col1', 'col2')
Get and drop the constraint:
table('My table name').primarykey('col1', 'col2').drop()
-
add
(*columns) Add the constraint
Parameters: *column – list of column name Return type: MigrationConstraintPrimaryKey instance Exception: MigrationException
-
drop
() Drop the constraint
-
-
class
anyblok.migration.
MigrationIndex
(table, *columns, **kwargs) Used for the index constraint
Add a new constraint:
table('My table name').index().add('col1', 'col2')
Get and drop the constraint:
table('My table name').index('col1', 'col2').drop()
-
add
(*columns) Add the constraint
Parameters: *column – list of column name Return type: MigrationIndex instance Exception: MigrationException
-
drop
() Drop the constraint
-
-
class
anyblok.migration.
MigrationTable
(migration, name) Use to manipulate tables
Add a table:
table().add('New table')
Get an existing table:
t = table('My table name')
Alter the table:
t.alter(name='Another table name')
Drop the table:
t.drop()
-
add
(name) Add a new table
Parameters: name – name of the table Return type: MigrationTable instance
-
alter
(**kwargs) Atler the current table
Parameters: name – New table name Return type: MigrationTable instance Exception: MigrationException
-
check
(name=None) Get check
Parameters: *columns – List of the column’s name Return type: MigrationConstraintCheck instance
-
column
(name=None) Get Column
Parameters: name – Column name Return type: MigrationColumn instance
-
drop
() Drop the table
-
foreign_key
(name) Get a foreign key
Return type: MigrationConstraintForeignKey instance
-
index
(*columns, **kwargs) Get index
Parameters: *columns – List of the column’s name Return type: MigrationIndex instance
-
primarykey
() Get primary key
Parameters: *columns – List of the column’s name Return type: MigrationConstraintPrimaryKey instance
-
unique
(name) Get unique
Parameters: *columns – List of the column’s name Return type: MigrationConstraintUnique instance
-
-
class
anyblok.migration.
Migration
(registry) Migration Main entry
This class allows to manipulate all the migration class:
migration = Migration(Session(), Base.Metadata) t = migration.table('My table name') c = t.column('My column name from t')
-
auto_upgrade_database
() Upgrade the database automaticly
-
detect_changed
() Detect the difference between the metadata and the database
Return type: MigrationReport instance
-
release_savepoint
(name) Release the save point
Parameters: name – name of the savepoint
-
rollback_savepoint
(name) Rollback to the savepoint
Parameters: name – name of the savepoint
-
savepoint
(name=None) Add a savepoint
Parameters: name – name of the save point Return type: return the name of the save point
-
table
(name=None) Get a table
Return type: MigrationTable instance
-
anyblok.field module¶
-
class
anyblok.field.
Field
(*args, **kwargs) Field class
This class must not be instanciated
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known of the model
Return type: instance of Field
-
must_be_declared_as_attr
() Return False, it is the default value
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
Exception: FieldException
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.field.
Function
(*args, **kwargs) Bases:
anyblok.field.Field
Function Field
from anyblok.declarations import Declarations from anyblok.field import Function @Declarations.register(Declarations.Model) class Test: x = Function(fget='fget', fset='fset', fdel='fdel', fexp='fexpr') ..warning:: fexp must be a classmethod
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the property of the field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
must_be_declared_as_attr
() Return False, it is the default value
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
Exception: FieldException
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
anyblok.column module¶
-
class
anyblok.column.
Column
(*args, **kwargs) Bases:
anyblok.field.Field
Column class
This class can’t be instanciated
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Integer
(*args, **kwargs) Bases:
anyblok.column.Column
Integer column
from anyblok.declarations import Declarations from anyblok.column import Integer @Declarations.register(Declarations.Model) class Test: x = Integer(default=1)
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
Integer
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
SmallInteger
(*args, **kwargs) Bases:
anyblok.column.Column
Small integer column
from anyblok.declarations import Declarations from anyblok.column import SmallInteger @Declarations.register(Declarations.Model) class Test: x = SmallInteger(default=1)
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
SmallInteger
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
BigInteger
(*args, **kwargs) Bases:
anyblok.column.Column
Big integer column
from anyblok.declarations import Declarations from anyblok.column import BigInteger @Declarations.register(Declarations.Model) class Test: x = BigInteger(default=1)
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
BigInteger
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Boolean
(*args, **kwargs) Bases:
anyblok.column.Column
Boolean column
from anyblok.declarations import Declarations from anyblok.column import Boolean @Declarations.register(Declarations.Model) class Test: x = Boolean(default=True)
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
Boolean
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Float
(*args, **kwargs) Bases:
anyblok.column.Column
Float column
from anyblok.declarations import Declarations from anyblok.column import Float @Declarations.register(Declarations.Model) class Test: x = Float(default=1.0)
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
Float
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Decimal
(*args, **kwargs) Bases:
anyblok.column.Column
Decimal column
from decimal import Decimal as D from anyblok.declarations import Declarations from anyblok.column import Decimal @Declarations.register(Declarations.Model) class Test: x = Decimal(default=D('1.1'))
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
DECIMAL
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Date
(*args, **kwargs) Bases:
anyblok.column.Column
Date column
from datetime import date from anyblok.declarations import Declarations from anyblok.column import Date @Declarations.register(Declarations.Model) class Test: x = Date(default=date.today())
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
Date
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
DateTime
(*args, **kwargs) Bases:
anyblok.column.Column
DateTime column
from datetime import datetime from anyblok.declarations import Declarations from anyblok.column import DateTime @Declarations.register(Declarations.Model) class Test: x = DateTime(default=datetime.now)
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Time
(*args, **kwargs) Bases:
anyblok.column.Column
Time column
from datetime import time from anyblok.declarations import Declarations from anyblok.column import Time @Declarations.register(Declarations.Model) class Test: x = Time(default=time())
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
Time
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Interval
(*args, **kwargs) Bases:
anyblok.column.Column
Datetime interval column
from datetime import timedelta from anyblok.declarations import Declarations from anyblok.column import Interval @Declarations.register(Declarations.Model) class Test: x = Interval(default=timedelta(days=5))
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
Interval
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
String
(*args, **kwargs) Bases:
anyblok.column.Column
String column
from anyblok.declarations import Declarations from anyblok.column import String @Declarations.register(Declarations.Model) class Test: x = String(default='test')
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
uString
(*args, **kwargs) Bases:
anyblok.column.Column
Unicode column
from anyblok.declarations import Declarations from anyblok.column import uString @Declarations.register(Declarations.Model) class Test: x = uString(de", default=u'test')
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Text
(*args, **kwargs) Bases:
anyblok.column.Column
Text column
from anyblok.declarations import Declarations from anyblok.column import Text @Declarations.register(Declarations.Model) class Test: x = Text(default='test')
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
uText
(*args, **kwargs) Bases:
anyblok.column.Column
Unicode text column
from anyblok.declarations import Declarations from anyblok.column import uText @Declarations.register(Declarations.Model) class Test: x = uText(default=u'test')
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
StrSelection
Class representing the data of one column Selection
-
class
anyblok.column.
SelectionType
(selections, size, registry=None, namespace=None) Generic type for Column Selection
-
impl
alias of
String
-
-
class
anyblok.column.
Selection
(*args, **kwargs) Bases:
anyblok.column.Column
Selection column
from anyblok.declarations import Declarations from anyblok.column import Selection @Declarations.register(Declarations.Model) class Test: STATUS = ( (u'draft', u'Draft'), (u'done', u'Done'), ) x = Selection(selections=STATUS, size=64, default=u'draft')
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return True because the field selection in a mixin must be copied else the selection method can be wrond
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
JsonType
(*args, **kwargs) Generic type for Column JSON
-
impl
alias of
Unicode
-
-
class
anyblok.column.
Json
(*args, **kwargs) Bases:
anyblok.column.Column
JSON column
from anyblok.declarations import Declarations from anyblok.column import Json @Declarations.register(Declarations.Model) class Test: x = Json()
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
JsonType
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
LargeBinary
(*args, **kwargs) Bases:
anyblok.column.Column
Large binary column
from os import urandom from anyblok.declarations import Declarations from anyblok.column import LargeBinary blob = urandom(100000) @Declarations.register(Declarations.Model) class Test: x = LargeBinary(default=blob)
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
sqlalchemy_type
alias of
LargeBinary
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Color
(*args, **kwargs) Bases:
anyblok.column.Column
Color column. See coulour pakage
from anyblok.declarations import Declarations from anyblok.column import Color @Declarations.register(Declarations.Model) class Test: x = Color(default='green')
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.column.
Password
(*args, **kwargs) Bases:
anyblok.column.Column
String column
from anyblok.declarations import Declarations from anyblok.column import Password @Declarations.register(Declarations.Model) class Test: x = Password(crypt_context={'schemes': ['md5_crypt']}) ========================================= test = Test.insert() test.x = 'mypassword' test.x ==> Password object with encrypt value, the value can not be read test.x == 'mypassword' ==> True
..warning:
the column type Password can not be querying:: Test.query().filter(Test.x == 'mypassword').count() ==> 0
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – known properties of the model
Return type: sqlalchemy column instance
-
must_be_declared_as_attr
() Return True if the column have a foreign key to a remote column
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
anyblok.relationship module¶
-
class
anyblok.relationship.
RelationShip
(*args, **kwargs) Bases:
anyblok.field.Field
RelationShip class
The RelationShip class is used to define the type of SQL field Declarations
Add a new relation ship type:
@Declarations.register(Declarations.RelationShip) class Many2one: pass
the relationship column are forbidden because the model can be used on the model
-
apply_instrumentedlist
(registry, namespace, fieldname) Add the InstrumentedList class to replace List class as result of the query
Parameters: registry – current registry
-
define_backref_properties
(registry, namespace, properties) Add in the backref_properties, new property for the backref
Parameters: - registry – current registry
- namespace – name of the model
- properties – properties known of the model
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_backref
(registry, namespace, fieldname, properties) Create the real backref, with the backref string and the backref properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known of the model
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Return the instance of the real field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known of the model
Return type: sqlalchemy relation ship instance
-
init_expire_attributes
(registry, namespace, fieldname) Init dict of expiration properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
-
must_be_declared_as_attr
() Return True, because it is a relationship
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
Exception: FieldException
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
-
class
anyblok.relationship.
Many2One
(**kwargs) Bases:
anyblok.relationship.RelationShip
Define a relationship attribute on the model
@register(Model) class TheModel: relationship = Many2One(label="The relationship", model=Model.RemoteModel, remote_columns="The remote column", column_names="The column which have the " "foreigh key", nullable=True, unique=False, one2many="themodels")
If the
remote_columns
are not define then, the system takes the primary key of the remote modelIf the column doesn’t exist, the column will be created. Use the nullable option. If the name is not filled, the name is “‘remote table’_’remote colum’”
Parameters: - model – the remote model
- remote_columns – the column name on the remote model
- column_names – the column on the model which have the foreign key
- nullable – If the column_names is nullable
- unique – If True, add the unique constraint on the column
- one2many – create the one2many link with this many2one
-
apply_instrumentedlist
(registry, namespace, fieldname) Add the InstrumentedList class to replace List class as result of the query
Parameters: registry – current registry
-
define_backref_properties
(registry, namespace, properties) Add in the backref_properties, new property for the backref
Parameters: - registry – current registry
- namespace – name of the model
- properties – properties known of the model
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_backref
(registry, namespace, fieldname, properties) Create the real backref, with the backref string and the backref properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known of the model
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Create the relationship
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- fieldname – fieldname of the relationship
- propertie – the properties known
Return type: Many2One relationship
-
init_expire_attributes
(registry, namespace, fieldname) Init dict of expiration properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
-
must_be_declared_as_attr
() Return True, because it is a relationship
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
Exception: FieldException
-
update_properties
(registry, namespace, fieldname, properties) Create the column which has the foreign key if the column doesn’t exist
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- fieldname – fieldname of the relationship
- propertie – the properties known
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
class
anyblok.relationship.
One2One
(**kwargs) Bases:
anyblok.relationship.Many2One
Define a relationship attribute on the model
@register(Model) class TheModel: relationship = One2One(label="The relationship", model=Model.RemoteModel, remote_columns="The remote column", column_names="The column which have the " "foreigh key", nullable=False, backref="themodels")
If the remote_columns are not define then, the system take the primary key of the remote model
If the column doesn’t exist, then the column will be create. Use the nullable option. If the name is not filled then the name is “‘remote table’_’remote colum’”
Parameters: - model – the remote model
- remote_columns – the column name on the remote model
- column_names – the column on the model which have the foreign key
- nullable – If the column_names is nullable
- backref – create the one2one link with this one2one
-
apply_instrumentedlist
(registry, namespace, fieldname) Add the InstrumentedList class to replace List class as result of the query
Parameters: registry – current registry
-
define_backref_properties
(registry, namespace, properties) Add option uselist = False
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- propertie – the properties known
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_backref
(registry, namespace, fieldname, properties) Create the real backref, with the backref string and the backref properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known of the model
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Create the relationship
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- fieldname – fieldname of the relationship
- propertie – the properties known
Return type: Many2One relationship
-
init_expire_attributes
(registry, namespace, fieldname) Init dict of expiration properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
-
must_be_declared_as_attr
() Return True, because it is a relationship
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
Exception: FieldException
-
update_properties
(registry, namespace, fieldname, properties) Create the column which has the foreign key if the column doesn’t exist
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- fieldname – fieldname of the relationship
- propertie – the properties known
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
class
anyblok.relationship.
Many2Many
(**kwargs) Bases:
anyblok.relationship.RelationShip
Define a relationship attribute on the model
@register(Model) class TheModel: relationship = Many2Many(label="The relationship", model=Model.RemoteModel, join_table="many2many table", remote_columns="The remote column", m2m_remote_columns="Name in many2many" local_columns="local primary key" m2m_local_columns="Name in many2many" many2many="themodels")
- if the join_table is not defined, then the table join is
- “join_’local table’_and_’remote table’”
Warning
The join_table must be filled when the declaration of the Many2Many is done in a Mixin
If the remote_columns are not define then, the system take the primary key of the remote model
- if the local_columns are not define the take the primary key of the local
- model
Parameters: - model – the remote model
- join_table – the many2many table to join local and remote models
- remote_columns – the column name on the remote model
- m2m_remote_columns – the column name to remote model in m2m table
- local_columns – the column on the model
- m2m_local_columns – the column name to local model in m2m table
- many2many – create the opposite many2many on the remote model
-
apply_instrumentedlist
(registry, namespace, fieldname) Add the InstrumentedList class to replace List class as result of the query
Parameters: registry – current registry
-
define_backref_properties
(registry, namespace, properties) Add in the backref_properties, new property for the backref
Parameters: - registry – current registry
- namespace – name of the model
- properties – properties known of the model
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_backref
(registry, namespace, fieldname, properties) Create the real backref, with the backref string and the backref properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known of the model
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Create the relationship
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- fieldname – fieldname of the relationship
- properties – the properties known
Return type: Many2One relationship
-
init_expire_attributes
(registry, namespace, fieldname) Init dict of expiration properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
-
must_be_declared_as_attr
() Return True, because it is a relationship
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
Exception: FieldException
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
-
class
anyblok.relationship.
One2Many
(**kwargs) Bases:
anyblok.relationship.RelationShip
Define a relationship attribute on the model
@register(Model) class TheModel: relationship = One2Many(label="The relationship", model=Model.RemoteModel, remote_columns="The remote column", primaryjoin="Join condition" many2one="themodel")
- If the primaryjoin is not filled then the join condition is
- “‘local table’.’local promary key’ == ‘remote table’.’remote colum’”
Parameters: - model – the remote model
- remote_columns – the column name on the remote model
- primaryjoin – the join condition between the remote column
- many2one – create the many2one link with this one2many
-
apply_instrumentedlist
(registry, namespace, fieldname) Add the InstrumentedList class to replace List class as result of the query
Parameters: registry – current registry
-
define_backref_properties
(registry, namespace, properties) Add option in the backref if both model and remote model are the same, it is for the One2Many on the same model
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- propertie – the properties known
-
find_foreign_key
(registry, properties, tablename) Return the primary key come from the first step property
Parameters: - registry – the registry which load the relationship
- properties – first step properties for the model
- tablename – the name of the table for the foreign key
Return type: column name of the primary key
-
forbid_instance
(cls) Raise an exception if the cls is an instance of this __class__
Parameters: cls – instance of the class Exception: FieldException
-
format_backref
(registry, namespace, fieldname, properties) Create the real backref, with the backref string and the backref properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known of the model
-
format_label
(fieldname) Return the label for this field
Parameters: fieldname – if no label filled, the fieldname will be capitalized and returned Return type: the label for this field
-
get_property
(registry, namespace, fieldname, properties) Return the property of the field
Warning
In the case of the get is called in classattribute, SQLAlchemy wrap for each call the column, the id of the wrapper is not the same
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
get_sqlalchemy_mapping
(registry, namespace, fieldname, properties) Create the relationship
Parameters: - registry – the registry which load the relationship
- namespace – the name space of the model
- fieldname – fieldname of the relationship
- propertie – the properties known
Return type: Many2One relationship
-
init_expire_attributes
(registry, namespace, fieldname) Init dict of expiration properties
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
-
must_be_declared_as_attr
() Return True, because it is a relationship
-
must_be_duplicate_before_added
() Return False, it is the default value
-
native_type
() Return the native SqlAlchemy type
Exception: FieldException
-
update_properties
(registry, namespace, fieldname, properties) Update the propertie use to add new column
Parameters: - registry – current registry
- namespace – name of the model
- fieldname – name of the field
- properties – properties known to the model
-
wrap_expr_column
(fieldname) Return a default expr for the field
Parameters: fieldname – name of the field
-
wrap_getter_column
(fieldname) Return a default getter for the field
Parameters: fieldname – name of the field
anyblok._graphviz module¶
-
class
anyblok._graphviz.
BaseSchema
(name, format='png') Common class extended by the type of schema
-
add_edge
(cls_1, cls_2, attr=None) Add new edge between 2 node
dot.add_edge(node1, node2)
Parameters: - cls_1 – node (string or object) for the from
- cls_2 – node (string or object) for the to
Paam attr: attribute of the edge
-
render
() Call graphviz to do the schema
-
save
() render and create the output file
-
-
class
anyblok._graphviz.
SQLSchema
(name, format='png') Create a schema to display the table model
dot = SQLSchema('the name of my schema') t1 = dot.add_table('Table 1') t1.add_column('c1', 'Integer') t1.add_column('c2', 'Integer') t2 = dot.add_table('Table 2') t2.add_column('c1', 'Integer') t2.add_foreign_key(t1, 'c2') dot.save()
-
add_label
(name) Add a new node TableSchema without column
Parameters: name – name of the table Return type: return the instance of TableSchema
-
add_table
(name) Add a new node TableSchema with column
Parameters: name – name of the table Return type: return the instance of TableSchema
-
get_table
(name) Return the instance of TableSchema linked with the name of table
Parameters: name – name of the table Return type: return the instance of TableSchema
-
-
class
anyblok._graphviz.
TableSchema
(name, parent, islabel=False) Describe one table
-
add_column
(name, type_, primary_key=False) Add a new column in the table
Parameters: - name – name of the column
- type – type of the column
- primary_key – if True, the string PK will be add
-
add_foreign_key
(node, label=None, nullable=True) Add a new foreign key
Parameters: - node – node (string or object) of the table linked
- label – name of the column of the foreign key
- nullable – bool to select the multiplicity of the association
-
render
(dot) Call graphviz to create the schema
-
-
class
anyblok._graphviz.
ModelSchema
(name, format='png') Create a schema to display the UML model
dot = ModelSchema('The name of my UML schema') cls = dot.add_class('My class') cls.add_method('insert') cls.add_property('items') cls.add_column('my column') dot.save()
-
add_class
(name) Add a new node ClassSchema with column
Parameters: name – name of the class Return type: return the instance of ClassSchema
-
add_label
(name) Return the instance of ClassSchema linked with the name of class
Parameters: name – name of the class Return type: return the instance of ClassSchema
-
get_class
(name) Add a new node ClassSchema without column
Parameters: name – name of the class Return type: return the instance of ClassSchema
-
-
class
anyblok._graphviz.
ClassSchema
(name, parent, islabel=False) Use to display a class
-
add_column
(name) add a column in the class
Parameters: name – name of the column
-
add_method
(name) add a method in the class
Parameters: name – name of the method
-
add_property
(name) add a property in the class
Parameters: name – name of the property
-
agregate
(node, label_from=None, multiplicity_from=None, label_to=None, multiplicity_to=None) add an edge with agregate shape to the node
Parameters: - node – node (string or object)
- label_from – attribute name
- multiplicity_from – multiplicity of the attribute
- label_to – attribute name
- multiplicity_to – multiplicity of the attribute
-
associate
(node, label_from=None, multiplicity_from=None, label_to=None, multiplicity_to=None) add an edge with associate shape to the node
Parameters: - node – node (string or object)
- label_from – attribute name
- multiplicity_from – multiplicity of the attribute
- label_to – attribute name
- multiplicity_to – multiplicity of the attribute
-
extend
(node) add an edge with extend shape to the node
Parameters: node – node (string or object)
-
render
(dot) Call graphviz to do the schema
-
strong_agregate
(node, label_from=None, multiplicity_from=None, label_to=None, multiplicity_to=None) add an edge with strong agregate shape to the node
Parameters: - node – node (string or object)
- label_from – attribute name
- multiplicity_from – multiplicity of the attribute
- label_to – attribute name
- multiplicity_to – multiplicity of the attribute
-
anyblok.scripts module¶
-
anyblok.scripts.
createdb
(application, configuration_groups, **kwargs) Create a database and install blok from config
Parameters: - application – name of the application
- configuration_groups – list configuration groupe to load
- **kwargs – ArgumentParser named arguments
-
anyblok.scripts.
updatedb
(application, configuration_groups, **kwargs) Update an existing database
Parameters: - application – name of the application
- configuration_groups – list configuration groupe to load
- **kwargs – ArgumentParser named arguments
-
anyblok.scripts.
interpreter
(application, configuration_groups, **kwargs) Execute a script or open an interpreter
Parameters: - application – name of the application
- configuration_groups – list configuration groupe to load
- **kwargs – ArgumentParser named arguments
-
anyblok.scripts.
run_exit
(application, configuration_groups, **kwargs) Run nose unit test for the registry
Parameters: - application – name of the application
- configuration_groups – list configuration groupe to load
- **kwargs – ArgumentParser named arguments
-
anyblok.scripts.
cron_worker
(application, configuration_groups, **kwargs) Execute a cron worker
Parameters: - application – name of the application
- configuration_groups – list configuration groupe to load
- **kwargs – ArgumentParser named arguments
-
anyblok.scripts.
registry2doc
(application, configuration_groups, **kwargs) Return auto documentation for the registry
Parameters: - application – name of the application
- configuration_groups – list configuration groupe to load
- **kwargs – ArgumentParser named arguments