How to add a new Type /core

Type and Core are both Declarations.

Difference between Core and Type

Core is also an Entry Type. But it is a particular entry Type. Core is used to define low level at the entry Type. For example the Core.Base is the low level at all the Model. Modify the behaviours of the Core.Base is equal to modify the behaviours of all the Model.

this is the inheritance model of the Model Type

Entry Type inheritance Types Core
Model Model / Mixin Base

Declare a new Type

The declaration of new Type, is declarations of a new type of declaration. The known Type declarations are:

  • Model
  • Mixin
  • Core
  • Field
  • Exception

Some are directly see as a database declaration (entry Type):

  • Model
  • Mixin
  • Core

Other have not depends with the installation of not of the bloks:

  • Field
  • Exception

Warning

All declaration of new entry must be done out of any bloks

This is an example to declare new entry Type:

from anyblok import Declarations


@Declarations.add_declaration_type()
class MyType:

    @classmethod
    def register(cls, parent, name, cls_, **kwargs):
        ...

    @classmethod
    def unregister(cls, child, cls_):
        ...

The Type must implement:

Method name Description
register This classmethod describe what append when a a declaration is done by he decorator Declarations.register
unregister This classmethod describe what append when an undeclaration is done.

The add_declaration_type can define the arguments:

Argument’s name Description
isAnEntry Boolean Define if the new Type is an entry, depend of the installation or not of the bloks
assemble

Only for the entry ``Type`` Waiting the name of the classmethod which make the action to group and create a new class with the complete inheritance tree:

@add_declaration_type(isAnEntry=True,
                      assemble='assemble')
class MyTpe:
    ...

    @classmethod
    def assemble(cls, registry):
        ...

Warning

registry is the registry of the database

initialize

Only for the entry ``Type`` Waiting the name of the classmethod which make the action to initialize the registry:

@add_declaration_type(isAnEntry=True,
                      initialize='initialize')
class MyTpe:
    ...

    @classmethod
    def initialize(cls, registry):
        ...

Warning

registry is the registry of the database

Declare a Mixin entry type

Mixin is a Type to add behaviours, it is not a particular Type. But it is always very interresting to use it.

AnyBlok had already a Mixin Type for the Model Type. The Mixin Type must not be the same for all the entry Type, then Model inherit only other Model or Declarations.Mixin. If you add an another Declarations.AnotherMixin then Model won’t inherit this Mixin Type.

The new Mixin Type is easy to add:

from anyblok import Declarations
from anyblok.mixin import MixinType


@Declarations.add_declaration_type(isAnEntry=True)
class MyMixin(MixinType):
    pass

Declare a new Core

The definition of a Core and the Declaration is in different parts

Declarations of a new Core:

from anyblok.registry import RegistryManager


RegistryManager.declare_core('MyCore')

Definition or register of an overload of the Core declaration:

from anyblok import Declarations


@Declarations.register(Declarations.Core)
class MyCore:
    ...

The declaration must be done in the application, not in the blok. The is only done in the blok.

Warning

Core can’t inherit Model, Mixin or other Type