788 lines
26 KiB
Python
788 lines
26 KiB
Python
|
import sys
|
||
|
|
|
||
|
|
from pymongo.asynchronous.database import AsyncDatabase
|
||
|
|
from typing_extensions import Sequence, get_args, get_origin
|
||
|
|
|
||
|
|
from beanie.odm.utils.pydantic import (
|
||
|
|
IS_PYDANTIC_V2,
|
||
|
|
get_extra_field_info,
|
||
|
|
get_model_fields,
|
||
|
|
parse_model,
|
||
|
|
)
|
||
|
|
from beanie.odm.utils.typing import get_index_attributes
|
||
|
|
|
||
|
|
if sys.version_info >= (3, 10):
|
||
|
|
from types import UnionType as TypesUnionType
|
||
|
|
else:
|
||
|
|
TypesUnionType = ()
|
||
|
|
|
||
|
|
import importlib
|
||
|
|
import inspect
|
||
|
|
from typing import ( # type: ignore
|
||
|
|
List,
|
||
|
|
Optional,
|
||
|
|
Type,
|
||
|
|
Union,
|
||
|
|
_GenericAlias,
|
||
|
|
)
|
||
|
|
|
||
|
|
from pydantic import BaseModel
|
||
|
|
from pydantic.fields import FieldInfo
|
||
|
|
from pymongo import AsyncMongoClient, IndexModel
|
||
|
|
|
||
|
|
from beanie.exceptions import Deprecation, MongoDBVersionError
|
||
|
|
from beanie.odm.actions import ActionRegistry
|
||
|
|
from beanie.odm.cache import LRUCache
|
||
|
|
from beanie.odm.documents import DocType, Document
|
||
|
|
from beanie.odm.fields import (
|
||
|
|
BackLink,
|
||
|
|
ExpressionField,
|
||
|
|
Link,
|
||
|
|
LinkInfo,
|
||
|
|
LinkTypes,
|
||
|
|
)
|
||
|
|
from beanie.odm.interfaces.detector import ModelType
|
||
|
|
from beanie.odm.registry import DocsRegistry
|
||
|
|
from beanie.odm.settings.document import DocumentSettings, IndexModelField
|
||
|
|
from beanie.odm.settings.union_doc import UnionDocSettings
|
||
|
|
from beanie.odm.settings.view import ViewSettings
|
||
|
|
from beanie.odm.union_doc import UnionDoc, UnionDocType
|
||
|
|
from beanie.odm.views import View
|
||
|
|
|
||
|
|
|
||
|
|
class Output(BaseModel):
|
||
|
|
class_name: str
|
||
|
|
collection_name: str
|
||
|
|
|
||
|
|
|
||
|
|
class Initializer:
|
||
|
|
def __init__(
|
||
|
|
self,
|
||
|
|
database: AsyncDatabase = None,
|
||
|
|
connection_string: Optional[str] = None,
|
||
|
|
document_models: Optional[
|
||
|
|
Sequence[
|
||
|
|
Union[Type["DocType"], Type["UnionDocType"], Type["View"], str]
|
||
|
|
]
|
||
|
|
] = None,
|
||
|
|
allow_index_dropping: bool = False,
|
||
|
|
recreate_views: bool = False,
|
||
|
|
skip_indexes: bool = False,
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Beanie initializer
|
||
|
|
|
||
|
|
:param database: AsyncDatabase - pymongo database instance
|
||
|
|
:param connection_string: str - MongoDB connection string
|
||
|
|
:param document_models: List[Union[Type[DocType], Type[UnionDocType], str]] - model classes
|
||
|
|
or strings with dot separated paths
|
||
|
|
:param allow_index_dropping: bool - if index dropping is allowed.
|
||
|
|
Default False
|
||
|
|
:param recreate_views: bool - if views should be recreated. Default False
|
||
|
|
it will patch the pymongo client to use process's event loop.
|
||
|
|
:param skip_indexes: bool - if you want to skip working with indexes. Default False
|
||
|
|
:return: None
|
||
|
|
"""
|
||
|
|
|
||
|
|
self.inited_classes: List[Type] = []
|
||
|
|
self.allow_index_dropping = allow_index_dropping
|
||
|
|
self.skip_indexes = skip_indexes
|
||
|
|
self.recreate_views = recreate_views
|
||
|
|
|
||
|
|
self.models_with_updated_forward_refs: List[Type[BaseModel]] = []
|
||
|
|
|
||
|
|
if (connection_string is None and database is None) or (
|
||
|
|
connection_string is not None and database is not None
|
||
|
|
):
|
||
|
|
raise ValueError(
|
||
|
|
"connection_string parameter or database parameter must be set"
|
||
|
|
)
|
||
|
|
|
||
|
|
if document_models is None:
|
||
|
|
raise ValueError("document_models parameter must be set")
|
||
|
|
if connection_string is not None:
|
||
|
|
database = AsyncMongoClient(
|
||
|
|
connection_string
|
||
|
|
).get_default_database()
|
||
|
|
|
||
|
|
self.database: AsyncDatabase = database
|
||
|
|
|
||
|
|
sort_order = {
|
||
|
|
ModelType.UnionDoc: 0,
|
||
|
|
ModelType.Document: 1,
|
||
|
|
ModelType.View: 2,
|
||
|
|
}
|
||
|
|
|
||
|
|
self.document_models: List[
|
||
|
|
Union[Type[DocType], Type[UnionDocType], Type[View]]
|
||
|
|
] = [
|
||
|
|
self.get_model(model) if isinstance(model, str) else model
|
||
|
|
for model in document_models
|
||
|
|
]
|
||
|
|
|
||
|
|
self.fill_docs_registry()
|
||
|
|
|
||
|
|
self.document_models.sort(
|
||
|
|
key=lambda val: sort_order[val.get_model_type()]
|
||
|
|
)
|
||
|
|
|
||
|
|
def __await__(self):
|
||
|
|
for model in self.document_models:
|
||
|
|
yield from self.init_class(model).__await__()
|
||
|
|
|
||
|
|
# General
|
||
|
|
def fill_docs_registry(self):
|
||
|
|
for model in self.document_models:
|
||
|
|
module = inspect.getmodule(model)
|
||
|
|
members = inspect.getmembers(module)
|
||
|
|
for name, obj in members:
|
||
|
|
if inspect.isclass(obj) and issubclass(obj, BaseModel):
|
||
|
|
DocsRegistry.register(name, obj)
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def get_model(dot_path: str) -> Type["DocType"]:
|
||
|
|
"""
|
||
|
|
Get the model by the path in format bar.foo.Model
|
||
|
|
|
||
|
|
:param dot_path: str - dot seprated path to the model
|
||
|
|
:return: Type[DocType] - class of the model
|
||
|
|
"""
|
||
|
|
module_name, class_name = None, None
|
||
|
|
try:
|
||
|
|
module_name, class_name = dot_path.rsplit(".", 1)
|
||
|
|
return getattr(importlib.import_module(module_name), class_name)
|
||
|
|
|
||
|
|
except ValueError:
|
||
|
|
raise ValueError(
|
||
|
|
f"'{dot_path}' doesn't have '.' path, eg. path.to.your.model.class"
|
||
|
|
)
|
||
|
|
|
||
|
|
except AttributeError:
|
||
|
|
raise AttributeError(
|
||
|
|
f"module '{module_name}' has no class called '{class_name}'"
|
||
|
|
)
|
||
|
|
|
||
|
|
def init_settings(
|
||
|
|
self, cls: Union[Type[Document], Type[View], Type[UnionDoc]]
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Init Settings
|
||
|
|
|
||
|
|
:param cls: Union[Type[Document], Type[View], Type[UnionDoc]] - Class
|
||
|
|
to init settings
|
||
|
|
:return: None
|
||
|
|
"""
|
||
|
|
settings_class = getattr(cls, "Settings", None)
|
||
|
|
settings_vars = {}
|
||
|
|
if settings_class is not None:
|
||
|
|
# get all attributes of the Settings subclass (including inherited ones)
|
||
|
|
# without magic dunder methods
|
||
|
|
settings_vars = {
|
||
|
|
attr: getattr(settings_class, attr)
|
||
|
|
for attr in dir(settings_class)
|
||
|
|
if not attr.startswith("__")
|
||
|
|
}
|
||
|
|
if issubclass(cls, Document):
|
||
|
|
cls._document_settings = parse_model(
|
||
|
|
DocumentSettings, settings_vars
|
||
|
|
)
|
||
|
|
if issubclass(cls, View):
|
||
|
|
cls._settings = parse_model(ViewSettings, settings_vars)
|
||
|
|
if issubclass(cls, UnionDoc):
|
||
|
|
cls._settings = parse_model(UnionDocSettings, settings_vars)
|
||
|
|
|
||
|
|
if not IS_PYDANTIC_V2:
|
||
|
|
|
||
|
|
def update_forward_refs(self, cls: Type[BaseModel]):
|
||
|
|
"""
|
||
|
|
Update forward refs
|
||
|
|
|
||
|
|
:param cls: Type[BaseModel] - class to update forward refs
|
||
|
|
:return: None
|
||
|
|
"""
|
||
|
|
if cls not in self.models_with_updated_forward_refs:
|
||
|
|
cls.update_forward_refs()
|
||
|
|
self.models_with_updated_forward_refs.append(cls)
|
||
|
|
|
||
|
|
# General. Relations
|
||
|
|
|
||
|
|
def detect_link(
|
||
|
|
self, field: FieldInfo, field_name: str
|
||
|
|
) -> Optional[LinkInfo]:
|
||
|
|
"""
|
||
|
|
It detects link and returns LinkInfo if any found.
|
||
|
|
|
||
|
|
:param field: ModelField
|
||
|
|
:return: Optional[LinkInfo]
|
||
|
|
"""
|
||
|
|
|
||
|
|
origin = get_origin(field.annotation)
|
||
|
|
args = get_args(field.annotation)
|
||
|
|
classes = [
|
||
|
|
Link,
|
||
|
|
BackLink,
|
||
|
|
]
|
||
|
|
|
||
|
|
for cls in classes:
|
||
|
|
# Check if annotation is one of the custom classes
|
||
|
|
if (
|
||
|
|
isinstance(field.annotation, _GenericAlias)
|
||
|
|
and field.annotation.__origin__ is cls
|
||
|
|
):
|
||
|
|
if cls is Link:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=field_name,
|
||
|
|
document_class=DocsRegistry.evaluate_fr(args[0]), # type: ignore
|
||
|
|
link_type=LinkTypes.DIRECT,
|
||
|
|
)
|
||
|
|
if cls is BackLink:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=get_extra_field_info(
|
||
|
|
field, "original_field"
|
||
|
|
), # type: ignore
|
||
|
|
document_class=DocsRegistry.evaluate_fr(args[0]), # type: ignore
|
||
|
|
link_type=LinkTypes.BACK_DIRECT,
|
||
|
|
)
|
||
|
|
|
||
|
|
# Check if annotation is List[custom class]
|
||
|
|
elif (
|
||
|
|
(origin is List or origin is list)
|
||
|
|
and len(args) == 1
|
||
|
|
and isinstance(args[0], _GenericAlias)
|
||
|
|
and args[0].__origin__ is cls
|
||
|
|
):
|
||
|
|
if cls is Link:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=field_name,
|
||
|
|
document_class=DocsRegistry.evaluate_fr(
|
||
|
|
get_args(args[0])[0]
|
||
|
|
), # type: ignore
|
||
|
|
link_type=LinkTypes.LIST,
|
||
|
|
)
|
||
|
|
if cls is BackLink:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=get_extra_field_info( # type: ignore
|
||
|
|
field, "original_field"
|
||
|
|
),
|
||
|
|
document_class=DocsRegistry.evaluate_fr(
|
||
|
|
get_args(args[0])[0]
|
||
|
|
), # type: ignore
|
||
|
|
link_type=LinkTypes.BACK_LIST,
|
||
|
|
)
|
||
|
|
|
||
|
|
# Check if annotation is Optional[custom class] or Optional[List[custom class]]
|
||
|
|
elif (
|
||
|
|
(origin is Union or origin is TypesUnionType)
|
||
|
|
and len(args) == 2
|
||
|
|
and type(None) in args
|
||
|
|
):
|
||
|
|
if args[1] is type(None):
|
||
|
|
optional = args[0]
|
||
|
|
else:
|
||
|
|
optional = args[1]
|
||
|
|
optional_origin = get_origin(optional)
|
||
|
|
optional_args = get_args(optional)
|
||
|
|
|
||
|
|
if (
|
||
|
|
isinstance(optional, _GenericAlias)
|
||
|
|
and optional.__origin__ is cls
|
||
|
|
):
|
||
|
|
if cls is Link:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=field_name,
|
||
|
|
document_class=DocsRegistry.evaluate_fr(
|
||
|
|
optional_args[0]
|
||
|
|
), # type: ignore
|
||
|
|
link_type=LinkTypes.OPTIONAL_DIRECT,
|
||
|
|
)
|
||
|
|
if cls is BackLink:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=get_extra_field_info(
|
||
|
|
field, "original_field"
|
||
|
|
),
|
||
|
|
document_class=DocsRegistry.evaluate_fr(
|
||
|
|
optional_args[0]
|
||
|
|
), # type: ignore
|
||
|
|
link_type=LinkTypes.OPTIONAL_BACK_DIRECT,
|
||
|
|
)
|
||
|
|
|
||
|
|
elif (
|
||
|
|
(optional_origin is List or optional_origin is list)
|
||
|
|
and len(optional_args) == 1
|
||
|
|
and isinstance(optional_args[0], _GenericAlias)
|
||
|
|
and optional_args[0].__origin__ is cls
|
||
|
|
):
|
||
|
|
if cls is Link:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=field_name,
|
||
|
|
document_class=DocsRegistry.evaluate_fr(
|
||
|
|
get_args(optional_args[0])[0]
|
||
|
|
), # type: ignore
|
||
|
|
link_type=LinkTypes.OPTIONAL_LIST,
|
||
|
|
)
|
||
|
|
if cls is BackLink:
|
||
|
|
return LinkInfo(
|
||
|
|
field_name=field_name,
|
||
|
|
lookup_field_name=get_extra_field_info(
|
||
|
|
field, "original_field"
|
||
|
|
),
|
||
|
|
document_class=DocsRegistry.evaluate_fr(
|
||
|
|
get_args(optional_args[0])[0]
|
||
|
|
), # type: ignore
|
||
|
|
link_type=LinkTypes.OPTIONAL_BACK_LIST,
|
||
|
|
)
|
||
|
|
return None
|
||
|
|
|
||
|
|
def check_nested_links(self, link_info: LinkInfo, current_depth: int):
|
||
|
|
if current_depth == 1:
|
||
|
|
return
|
||
|
|
for k, v in get_model_fields(link_info.document_class).items():
|
||
|
|
nested_link_info = self.detect_link(v, k)
|
||
|
|
if nested_link_info is None:
|
||
|
|
continue
|
||
|
|
|
||
|
|
if link_info.nested_links is None:
|
||
|
|
link_info.nested_links = {}
|
||
|
|
link_info.nested_links[k] = nested_link_info
|
||
|
|
new_depth = (
|
||
|
|
current_depth - 1 if current_depth is not None else None
|
||
|
|
)
|
||
|
|
self.check_nested_links(nested_link_info, current_depth=new_depth)
|
||
|
|
|
||
|
|
# Document
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def set_default_class_vars(cls: Type[Document]):
|
||
|
|
"""
|
||
|
|
Set default class variables.
|
||
|
|
|
||
|
|
:param cls: Union[Type[Document], Type[View], Type[UnionDoc]] - Class
|
||
|
|
to init settings
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
cls._children = dict()
|
||
|
|
cls._parent = None
|
||
|
|
cls._inheritance_inited = False
|
||
|
|
cls._class_id = None
|
||
|
|
cls._link_fields = None
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def init_cache(cls) -> None:
|
||
|
|
"""
|
||
|
|
Init model's cache
|
||
|
|
:return: None
|
||
|
|
"""
|
||
|
|
if cls.get_settings().use_cache:
|
||
|
|
cls._cache = LRUCache(
|
||
|
|
capacity=cls.get_settings().cache_capacity,
|
||
|
|
expiration_time=cls.get_settings().cache_expiration_time,
|
||
|
|
)
|
||
|
|
|
||
|
|
def init_document_fields(self, cls) -> None:
|
||
|
|
"""
|
||
|
|
Init class fields
|
||
|
|
:return: None
|
||
|
|
"""
|
||
|
|
|
||
|
|
if not IS_PYDANTIC_V2:
|
||
|
|
self.update_forward_refs(cls)
|
||
|
|
|
||
|
|
if cls._link_fields is None:
|
||
|
|
cls._link_fields = {}
|
||
|
|
for k, v in get_model_fields(cls).items():
|
||
|
|
path = v.alias or k
|
||
|
|
setattr(cls, k, ExpressionField(path))
|
||
|
|
|
||
|
|
link_info = self.detect_link(v, k)
|
||
|
|
depth_level = cls.get_settings().max_nesting_depths_per_field.get(
|
||
|
|
k, None
|
||
|
|
)
|
||
|
|
if depth_level is None:
|
||
|
|
depth_level = cls.get_settings().max_nesting_depth
|
||
|
|
if link_info is not None:
|
||
|
|
if depth_level > 0 or depth_level is None:
|
||
|
|
cls._link_fields[k] = link_info
|
||
|
|
self.check_nested_links(
|
||
|
|
link_info, current_depth=depth_level
|
||
|
|
)
|
||
|
|
elif depth_level <= 0:
|
||
|
|
link_info.is_fetchable = False
|
||
|
|
cls._link_fields[k] = link_info
|
||
|
|
|
||
|
|
cls._check_hidden_fields()
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def init_actions(cls):
|
||
|
|
"""
|
||
|
|
Init event-based actions
|
||
|
|
"""
|
||
|
|
ActionRegistry.clean_actions(cls)
|
||
|
|
for attr in dir(cls):
|
||
|
|
f = getattr(cls, attr)
|
||
|
|
if inspect.isfunction(f):
|
||
|
|
if hasattr(f, "has_action"):
|
||
|
|
ActionRegistry.add_action(
|
||
|
|
document_class=cls,
|
||
|
|
event_types=f.event_types, # type: ignore
|
||
|
|
action_direction=f.action_direction, # type: ignore
|
||
|
|
funct=f,
|
||
|
|
)
|
||
|
|
|
||
|
|
async def init_document_collection(self, cls):
|
||
|
|
"""
|
||
|
|
Init collection for the Document-based class
|
||
|
|
:param cls:
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
cls.set_database(self.database)
|
||
|
|
|
||
|
|
document_settings = cls.get_settings()
|
||
|
|
|
||
|
|
# register in the Union Doc
|
||
|
|
|
||
|
|
if document_settings.union_doc is not None:
|
||
|
|
name = cls.get_settings().name or cls.__name__
|
||
|
|
document_settings.name = document_settings.union_doc.register_doc(
|
||
|
|
name, cls
|
||
|
|
)
|
||
|
|
document_settings.union_doc_alias = name
|
||
|
|
|
||
|
|
# set a name
|
||
|
|
|
||
|
|
if not document_settings.name:
|
||
|
|
document_settings.name = cls.__name__
|
||
|
|
|
||
|
|
# check mongodb version fits
|
||
|
|
if (
|
||
|
|
document_settings.timeseries is not None
|
||
|
|
and cls._database_major_version < 5
|
||
|
|
):
|
||
|
|
raise MongoDBVersionError(
|
||
|
|
"Timeseries are supported by MongoDB version 5 and higher"
|
||
|
|
)
|
||
|
|
|
||
|
|
# create pymongo collection
|
||
|
|
if (
|
||
|
|
document_settings.timeseries is not None
|
||
|
|
and document_settings.name
|
||
|
|
not in await self.database.list_collection_names(
|
||
|
|
authorizedCollections=True, nameOnly=True
|
||
|
|
)
|
||
|
|
):
|
||
|
|
collection = await self.database.create_collection(
|
||
|
|
**document_settings.timeseries.build_query(
|
||
|
|
document_settings.name
|
||
|
|
)
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
collection = self.database[document_settings.name]
|
||
|
|
|
||
|
|
cls.set_collection(collection)
|
||
|
|
|
||
|
|
async def init_indexes(self, cls, allow_index_dropping: bool = False):
|
||
|
|
"""
|
||
|
|
Async indexes initializer
|
||
|
|
"""
|
||
|
|
collection = cls.get_pymongo_collection()
|
||
|
|
document_settings = cls.get_settings()
|
||
|
|
|
||
|
|
index_information = await collection.index_information()
|
||
|
|
|
||
|
|
old_indexes = IndexModelField.from_pymongo_index_information(
|
||
|
|
index_information
|
||
|
|
)
|
||
|
|
new_indexes = []
|
||
|
|
|
||
|
|
# Indexed field wrapped with Indexed()
|
||
|
|
indexed_fields = (
|
||
|
|
(k, fvalue, get_index_attributes(fvalue))
|
||
|
|
for k, fvalue in get_model_fields(cls).items()
|
||
|
|
)
|
||
|
|
found_indexes = [
|
||
|
|
IndexModelField(
|
||
|
|
IndexModel(
|
||
|
|
[
|
||
|
|
(
|
||
|
|
fvalue.alias or k,
|
||
|
|
indexed_attrs[0],
|
||
|
|
)
|
||
|
|
],
|
||
|
|
**indexed_attrs[1],
|
||
|
|
)
|
||
|
|
)
|
||
|
|
for k, fvalue, indexed_attrs in indexed_fields
|
||
|
|
if indexed_attrs is not None
|
||
|
|
]
|
||
|
|
|
||
|
|
if document_settings.merge_indexes:
|
||
|
|
result: List[IndexModelField] = []
|
||
|
|
for subclass in reversed(cls.mro()):
|
||
|
|
if issubclass(subclass, Document) and not subclass == Document:
|
||
|
|
if (
|
||
|
|
subclass not in self.inited_classes
|
||
|
|
and not subclass == cls
|
||
|
|
):
|
||
|
|
await self.init_class(subclass)
|
||
|
|
if subclass.get_settings().indexes:
|
||
|
|
result = IndexModelField.merge_indexes(
|
||
|
|
result, subclass.get_settings().indexes
|
||
|
|
)
|
||
|
|
found_indexes = IndexModelField.merge_indexes(
|
||
|
|
found_indexes, result
|
||
|
|
)
|
||
|
|
|
||
|
|
else:
|
||
|
|
if document_settings.indexes:
|
||
|
|
found_indexes = IndexModelField.merge_indexes(
|
||
|
|
found_indexes, document_settings.indexes
|
||
|
|
)
|
||
|
|
|
||
|
|
new_indexes += found_indexes
|
||
|
|
|
||
|
|
# delete indexes
|
||
|
|
# Only drop indexes if the user specifically allows for it
|
||
|
|
if allow_index_dropping:
|
||
|
|
for index in IndexModelField.list_difference(
|
||
|
|
old_indexes, new_indexes
|
||
|
|
):
|
||
|
|
await collection.drop_index(index.name)
|
||
|
|
|
||
|
|
# create indices
|
||
|
|
if found_indexes:
|
||
|
|
new_indexes += await collection.create_indexes(
|
||
|
|
IndexModelField.list_to_index_model(new_indexes)
|
||
|
|
)
|
||
|
|
|
||
|
|
async def init_document(self, cls: Type[Document]) -> Optional[Output]:
|
||
|
|
"""
|
||
|
|
Init Document-based class
|
||
|
|
|
||
|
|
:param cls:
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
if cls is Document:
|
||
|
|
return None
|
||
|
|
|
||
|
|
# get db version
|
||
|
|
build_info = await self.database.command({"buildInfo": 1})
|
||
|
|
mongo_version = build_info["version"]
|
||
|
|
cls._database_major_version = int(mongo_version.split(".")[0])
|
||
|
|
if cls not in self.inited_classes:
|
||
|
|
self.set_default_class_vars(cls)
|
||
|
|
self.init_settings(cls)
|
||
|
|
|
||
|
|
bases = [b for b in cls.__bases__ if issubclass(b, Document)]
|
||
|
|
if len(bases) > 1:
|
||
|
|
return None
|
||
|
|
parent = bases[0]
|
||
|
|
output = await self.init_document(parent)
|
||
|
|
if cls.get_settings().is_root and (
|
||
|
|
parent is Document or not parent.get_settings().is_root
|
||
|
|
):
|
||
|
|
if cls.get_collection_name() is None:
|
||
|
|
cls.set_collection_name(cls.__name__)
|
||
|
|
output = Output(
|
||
|
|
class_name=cls.__name__,
|
||
|
|
collection_name=cls.get_collection_name(),
|
||
|
|
)
|
||
|
|
cls._class_id = cls.__name__
|
||
|
|
cls._inheritance_inited = True
|
||
|
|
elif output is not None:
|
||
|
|
output.class_name = f"{output.class_name}.{cls.__name__}"
|
||
|
|
cls._class_id = output.class_name
|
||
|
|
cls.set_collection_name(output.collection_name)
|
||
|
|
parent.add_child(cls._class_id, cls)
|
||
|
|
cls._parent = parent
|
||
|
|
cls._inheritance_inited = True
|
||
|
|
|
||
|
|
await self.init_document_collection(cls)
|
||
|
|
if not self.skip_indexes:
|
||
|
|
await self.init_indexes(cls, self.allow_index_dropping)
|
||
|
|
self.init_document_fields(cls)
|
||
|
|
self.init_cache(cls)
|
||
|
|
self.init_actions(cls)
|
||
|
|
|
||
|
|
self.inited_classes.append(cls)
|
||
|
|
|
||
|
|
return output
|
||
|
|
|
||
|
|
else:
|
||
|
|
if cls._inheritance_inited is True:
|
||
|
|
return Output(
|
||
|
|
class_name=cls._class_id,
|
||
|
|
collection_name=cls.get_collection_name(),
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
return None
|
||
|
|
|
||
|
|
# Views
|
||
|
|
|
||
|
|
def init_view_fields(self, cls) -> None:
|
||
|
|
"""
|
||
|
|
Init class fields
|
||
|
|
:return: None
|
||
|
|
"""
|
||
|
|
|
||
|
|
if cls._link_fields is None:
|
||
|
|
cls._link_fields = {}
|
||
|
|
for k, v in get_model_fields(cls).items():
|
||
|
|
path = v.alias or k
|
||
|
|
setattr(cls, k, ExpressionField(path))
|
||
|
|
link_info = self.detect_link(v, k)
|
||
|
|
depth_level = cls.get_settings().max_nesting_depths_per_field.get(
|
||
|
|
k, None
|
||
|
|
)
|
||
|
|
if depth_level is None:
|
||
|
|
depth_level = cls.get_settings().max_nesting_depth
|
||
|
|
if link_info is not None:
|
||
|
|
if depth_level > 0:
|
||
|
|
cls._link_fields[k] = link_info
|
||
|
|
self.check_nested_links(
|
||
|
|
link_info, current_depth=depth_level
|
||
|
|
)
|
||
|
|
elif depth_level <= 0:
|
||
|
|
link_info.is_fetchable = False
|
||
|
|
cls._link_fields[k] = link_info
|
||
|
|
|
||
|
|
def init_view_collection(self, cls):
|
||
|
|
"""
|
||
|
|
Init collection for View
|
||
|
|
|
||
|
|
:param cls:
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
view_settings = cls.get_settings()
|
||
|
|
|
||
|
|
if view_settings.name is None:
|
||
|
|
view_settings.name = cls.__name__
|
||
|
|
|
||
|
|
if inspect.isclass(view_settings.source):
|
||
|
|
view_settings.source = view_settings.source.get_collection_name()
|
||
|
|
|
||
|
|
view_settings.pymongo_db = self.database
|
||
|
|
view_settings.pymongo_collection = self.database[view_settings.name]
|
||
|
|
|
||
|
|
async def init_view(self, cls: Type[View]):
|
||
|
|
"""
|
||
|
|
Init View-based class
|
||
|
|
|
||
|
|
:param cls:
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
self.init_settings(cls)
|
||
|
|
self.init_view_collection(cls)
|
||
|
|
self.init_view_fields(cls)
|
||
|
|
self.init_cache(cls)
|
||
|
|
|
||
|
|
collection_names = await self.database.list_collection_names(
|
||
|
|
authorizedCollections=True, nameOnly=True
|
||
|
|
)
|
||
|
|
if self.recreate_views or cls._settings.name not in collection_names:
|
||
|
|
if cls._settings.name in collection_names:
|
||
|
|
await cls.get_pymongo_collection().drop()
|
||
|
|
|
||
|
|
await self.database.command(
|
||
|
|
{
|
||
|
|
"create": cls.get_settings().name,
|
||
|
|
"viewOn": cls.get_settings().source,
|
||
|
|
"pipeline": cls.get_settings().pipeline,
|
||
|
|
}
|
||
|
|
)
|
||
|
|
|
||
|
|
# Union Doc
|
||
|
|
|
||
|
|
async def init_union_doc(self, cls: Type[UnionDoc]):
|
||
|
|
"""
|
||
|
|
Init Union Doc based class
|
||
|
|
|
||
|
|
:param cls:
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
self.init_settings(cls)
|
||
|
|
if cls._settings.name is None:
|
||
|
|
cls._settings.name = cls.__name__
|
||
|
|
|
||
|
|
cls._settings.pymongo_db = self.database
|
||
|
|
cls._settings.pymongo_collection = self.database[cls._settings.name]
|
||
|
|
cls._is_inited = True
|
||
|
|
|
||
|
|
# Deprecations
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def check_deprecations(
|
||
|
|
cls: Union[Type[Document], Type[View], Type[UnionDoc]],
|
||
|
|
):
|
||
|
|
if hasattr(cls, "Collection"):
|
||
|
|
raise Deprecation(
|
||
|
|
"Collection inner class is not supported more. "
|
||
|
|
"Please use Settings instead. "
|
||
|
|
"https://beanie-odm.dev/tutorial/defining-a-document/#settings"
|
||
|
|
)
|
||
|
|
|
||
|
|
# Final
|
||
|
|
|
||
|
|
async def init_class(
|
||
|
|
self, cls: Union[Type[Document], Type[View], Type[UnionDoc]]
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Init Document, View or UnionDoc based class.
|
||
|
|
|
||
|
|
:param cls:
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
self.check_deprecations(cls)
|
||
|
|
|
||
|
|
if issubclass(cls, Document):
|
||
|
|
await self.init_document(cls)
|
||
|
|
|
||
|
|
if issubclass(cls, View):
|
||
|
|
await self.init_view(cls)
|
||
|
|
|
||
|
|
if issubclass(cls, UnionDoc):
|
||
|
|
await self.init_union_doc(cls)
|
||
|
|
|
||
|
|
if hasattr(cls, "custom_init"):
|
||
|
|
await cls.custom_init() # type: ignore
|
||
|
|
|
||
|
|
|
||
|
|
async def init_beanie(
|
||
|
|
database: Optional[AsyncDatabase] = None,
|
||
|
|
connection_string: Optional[str] = None,
|
||
|
|
document_models: Optional[
|
||
|
|
Sequence[Union[Type[Document], Type[UnionDoc], Type["View"], str]]
|
||
|
|
] = None,
|
||
|
|
allow_index_dropping: bool = False,
|
||
|
|
recreate_views: bool = False,
|
||
|
|
skip_indexes: bool = False,
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Beanie initialization
|
||
|
|
|
||
|
|
:param database: Optional[AsyncDatabase] - pymongo database instance. Defaults to None.
|
||
|
|
:param connection_string: Optional[str] - MongoDB connection string. Defaults to None.
|
||
|
|
:param document_models: List[Union[Type[DocType], Type[UnionDocType], str]] - model classes
|
||
|
|
or strings with dot separated paths. Defaults to None.
|
||
|
|
:param allow_index_dropping: bool - if index dropping is allowed.
|
||
|
|
Defaults to False.
|
||
|
|
:param recreate_views: bool - if views should be recreated. Defaults to False.
|
||
|
|
:param skip_indexes: bool - if you want to skip working with the indexes.
|
||
|
|
Defaults to False.
|
||
|
|
:return: None
|
||
|
|
"""
|
||
|
|
|
||
|
|
await Initializer(
|
||
|
|
database=database,
|
||
|
|
connection_string=connection_string,
|
||
|
|
document_models=document_models,
|
||
|
|
allow_index_dropping=allow_index_dropping,
|
||
|
|
recreate_views=recreate_views,
|
||
|
|
skip_indexes=skip_indexes,
|
||
|
|
)
|