Prodream/ormar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

introduce docs -> models section mostly finished

Browse Source
This commit is contained in:
collerek
2020-08-12 16:24:45 +02:00
parent dd20fd9f01
commit 24eb0b30e7
23 changed files with 475 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
orm/fields/base.py
View File

@ -11,18 +11,8 @@ if TYPE_CHECKING: # pragma no cover
class BaseField:
__type__ = None
def __init__(self, *args: Any, **kwargs: Any) -> None:
name = kwargs.pop("name", None)
args = list(args)
if args:
if isinstance(args[0], str):
if name is not None:
raise ModelDefinitionError(
"Column name cannot be passed positionally and as a keyword."
)
name = args.pop(0)
self.name = name
def __init__(self, **kwargs: Any) -> None:
self.name = None
self._populate_from_kwargs(kwargs)
def _populate_from_kwargs(self, kwargs: Dict) -> None:
@ -64,7 +54,7 @@ class BaseField:
return False
def get_column(self, name: str = None) -> sqlalchemy.Column:
self.name = self.name or name
self.name = name
constraints = self.get_constraints()
return sqlalchemy.Column(
self.name,
@ -87,3 +77,6 @@ class BaseField:
def expand_relationship(self, value: Any, child: "Model") -> Any:
return value
def __repr__(self): # pragma no cover
return str(self.__dict__)

4
orm/fields/decorators.py
View File

@ -14,8 +14,8 @@ class RequiredParams:
old_init = model_field_class.__init__
model_field_class._old_init = old_init
def __init__(instance: "BaseField", *args: Any, **kwargs: Any) -> None:
super(instance.__class__, instance).__init__(*args, **kwargs)
def __init__(instance: "BaseField", **kwargs: Any) -> None:
super(instance.__class__, instance).__init__(**kwargs)
for arg in self._required:
if arg not in kwargs:
raise ModelDefinitionError(

5
orm/models/metaclass.py
View File

@ -75,6 +75,8 @@ def sqlalchemy_columns_from_model_fields(
}
for field_name, field in model_fields.items():
if field.primary_key:
if pkname is not None:
raise ModelDefinitionError("Only one primary key column is allowed.")
pkname = field_name
if not field.pydantic_only:
columns.append(field.get_column(field_name))
@ -100,7 +102,8 @@ class ModelMetaclass(type):
if attrs.get("__abstract__"):
return new_model
tablename = attrs["__tablename__"]
tablename = attrs.get("__tablename__", name.lower() + "s")
attrs["__tablename__"] = tablename
metadata = attrs["__metadata__"]
# sqlalchemy table creation

24
orm/queryset/clause.py
View File

@ -144,19 +144,21 @@ class QueryClause:
) -> Tuple[str, bool]:
has_escaped_character = False
if op in ["contains", "icontains"]:
if isinstance(value, orm.Model):
raise QueryDefinitionError(
"You cannot use contains and icontains with instance of the Model"
)
if op not in ["contains", "icontains"]:
return value, has_escaped_character
has_escaped_character = any(c for c in ESCAPE_CHARACTERS if c in value)
if isinstance(value, orm.Model):
raise QueryDefinitionError(
"You cannot use contains and icontains with instance of the Model"
)
if has_escaped_character:
# enable escape modifier
for char in ESCAPE_CHARACTERS:
value = value.replace(char, f"\\{char}")
value = f"%{value}%"
has_escaped_character = any(c for c in ESCAPE_CHARACTERS if c in value)
if has_escaped_character:
# enable escape modifier
for char in ESCAPE_CHARACTERS:
value = value.replace(char, f"\\{char}")
value = f"%{value}%"
return value, has_escaped_character

3
orm/queryset/query.py
View File

@ -52,8 +52,7 @@ class Query:
if (
not self.model_cls.__model_fields__[key].nullable
and isinstance(
self.model_cls.__model_fields__[key],
orm.fields.foreign_key.ForeignKey,
self.model_cls.__model_fields__[key], orm.fields.ForeignKey,
)
and key not in self._select_related
):

51
orm/relations.py
View File

@ -2,7 +2,7 @@ import pprint
import string
import uuid
from random import choices
from typing import Dict, List, TYPE_CHECKING, Union
from typing import List, TYPE_CHECKING, Union
from weakref import proxy
from orm import ForeignKey
@ -15,38 +15,20 @@ def get_table_alias() -> str:
return "".join(choices(string.ascii_uppercase, k=2)) + uuid.uuid4().hex[:4]
def get_relation_config(
relation_type: str, table_name: str, field: ForeignKey
) -> Dict[str, str]:
alias = get_table_alias()
config = {
"type": relation_type,
"table_alias": alias,
"source_table": table_name
if relation_type == "primary"
else field.to.__tablename__,
"target_table": field.to.__tablename__
if relation_type == "primary"
else table_name,
}
return config
class RelationshipManager:
def __init__(self) -> None:
self._relations = dict()
self._aliases = dict()
def add_relation_type(
self, relations_key: str, reverse_key: str, field: ForeignKey, table_name: str
) -> None:
if relations_key not in self._relations:
self._relations[relations_key] = get_relation_config(
"primary", table_name, field
)
self._relations[relations_key] = {"type": "primary"}
self._aliases[f"{table_name}_{field.to.__tablename__}"] = get_table_alias()
if reverse_key not in self._relations:
self._relations[reverse_key] = get_relation_config(
"reverse", table_name, field
)
self._relations[reverse_key] = {"type": "reverse"}
self._aliases[f"{field.to.__tablename__}_{table_name}"] = get_table_alias()
def deregister(self, model: "FakePydantic") -> None:
for rel_type in self._relations.keys():
@ -57,10 +39,11 @@ class RelationshipManager:
def add_relation(
self, parent: "FakePydantic", child: "FakePydantic", virtual: bool = False,
) -> None:
parent_id = parent._orm_id
child_id = child._orm_id
parent_name = parent.get_name()
child_name = child.get_name()
parent_id, child_id = parent._orm_id, child._orm_id
parent_name, child_name = (
parent.get_name(title=True),
child.get_name(title=True),
)
if virtual:
child_name, parent_name = parent_name, child_name
child_id, parent_id = parent_id, child_id
@ -68,11 +51,11 @@ class RelationshipManager:
else:
child = proxy(child)
parent_relation_name = parent_name.lower().title() + "_" + child_name + "s"
parent_relation_name = parent_name + "_" + child_name.lower() + "s"
parents_list = self._relations[parent_relation_name].setdefault(parent_id, [])
self.append_related_model(parents_list, child)
child_relation_name = child_name.lower().title() + "_" + parent_name
child_relation_name = child_name + "_" + parent_name.lower()
children_list = self._relations[child_relation_name].setdefault(child_id, [])
self.append_related_model(children_list, parent)
@ -102,13 +85,7 @@ class RelationshipManager:
return self._relations[relations_key][instance._orm_id]
def resolve_relation_join(self, from_table: str, to_table: str) -> str:
for relation_name, relation in self._relations.items():
if (
relation["source_table"] == from_table
and relation["target_table"] == to_table
):
return self._relations[relation_name]["table_alias"]
return ""
return self._aliases.get(f"{from_table}_{to_table}", "")
def __str__(self) -> str: # pragma no cover
return pprint.pformat(self._relations, indent=4, width=1)