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

some style corrections

Browse Source
This commit is contained in:
collerek
2020-08-09 06:51:12 +02:00
parent 39e44b1985
commit 9d9346fb13
6 changed files with 43 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
orm/__init__.py
View File

@ -1,7 +1,7 @@
from orm.fields import Integer, BigInteger, Boolean, Time, Text, String, JSON, DateTime, Date, Decimal, Float, \
ForeignKey
from orm.exceptions import ModelDefinitionError, ModelNotSet, MultipleMatches, NoMatch
from orm.fields import BigInteger, Boolean, Date, DateTime, Decimal, Float, ForeignKey, Integer, JSON, String, Text, \
Time
from orm.models import Model
from orm.exceptions import ModelDefinitionError, MultipleMatches, NoMatch, ModelNotSet
__version__ = "0.0.1"
__all__ = [
@ -17,5 +17,9 @@ __all__ = [
"Decimal",
"Float",
"ForeignKey",
"Model"
"Model",
"ModelDefinitionError",
"ModelNotSet",
"MultipleMatches",
"NoMatch"
]

50
orm/fields.py
View File

@ -1,9 +1,9 @@
import datetime
import decimal
from typing import Optional, List, Type, TYPE_CHECKING
from typing import List, Optional, TYPE_CHECKING, Type, Any, Union
import sqlalchemy
from pydantic import Json
from pydantic import Json, BaseModel
from pydantic.fields import ModelField
import orm
@ -22,9 +22,7 @@ class BaseField:
if args:
if isinstance(args[0], str):
if name is not None:
raise ModelDefinitionError(
'Column name cannot be passed positionally and as a keyword.'
)
raise ModelDefinitionError('Column name cannot be passed positionally and as a keyword.')
name = args.pop(0)
self.name = name
@ -43,20 +41,20 @@ class BaseField:
raise ModelDefinitionError('Primary key column cannot be pydantic only.')
@property
def is_required(self):
def is_required(self) -> bool:
return not self.nullable and not self.has_default and not self.is_auto_primary_key
@property
def default_value(self):
def default_value(self) -> Any:
default = self.default if self.default is not None else self.server_default
return default() if callable(default) else default
@property
def has_default(self):
def has_default(self) -> bool:
return self.default is not None or self.server_default is not None
@property
def is_auto_primary_key(self):
def is_auto_primary_key(self) -> bool:
if self.primary_key:
return self.autoincrement
return False
@ -83,7 +81,7 @@ class BaseField:
def get_constraints(self) -> Optional[List]:
return []
def expand_relationship(self, value, child):
def expand_relationship(self, value, child) -> Any:
return value
@ -95,70 +93,70 @@ class String(BaseField):
self.length = kwargs.pop('length')
super().__init__(*args, **kwargs)
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.String(self.length)
class Integer(BaseField):
__type__ = int
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.Integer()
class Text(BaseField):
__type__ = str
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.Text()
class Float(BaseField):
__type__ = float
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.Float()
class Boolean(BaseField):
__type__ = bool
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.Boolean()
class DateTime(BaseField):
__type__ = datetime.datetime
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.DateTime()
class Date(BaseField):
__type__ = datetime.date
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.Date()
class Time(BaseField):
__type__ = datetime.time
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.Time()
class JSON(BaseField):
__type__ = Json
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.JSON()
class BigInteger(BaseField):
__type__ = int
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.BigInteger()
@ -172,11 +170,11 @@ class Decimal(BaseField):
self.precision = kwargs.pop('precision')
super().__init__(*args, **kwargs)
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
return sqlalchemy.DECIMAL(self.length, self.precision)
def create_dummy_instance(fk: Type['Model'], pk: int = None):
def create_dummy_instance(fk: Type['Model'], pk: int = None) -> 'Model':
init_dict = {fk.__pkname__: pk or -1}
init_dict = {**init_dict, **{k: create_dummy_instance(v.to)
for k, v in fk.__model_fields__.items()
@ -192,18 +190,18 @@ class ForeignKey(BaseField):
self.to = to
@property
def __type__(self):
def __type__(self) -> Type[BaseModel]:
return self.to.__pydantic_model__
def get_constraints(self):
def get_constraints(self) -> List[sqlalchemy.schema.ForeignKey]:
fk_string = self.to.__tablename__ + "." + self.to.__pkname__
return [sqlalchemy.schema.ForeignKey(fk_string)]
def get_column_type(self):
def get_column_type(self) -> sqlalchemy.Column:
to_column = self.to.__model_fields__[self.to.__pkname__]
return to_column.get_column_type()
def expand_relationship(self, value, child):
def expand_relationship(self, value, child) -> Union['Model', List['Model']]:
if not isinstance(value, (self.to, dict, int, str, list)) or (
isinstance(value, orm.models.Model) and not isinstance(value, self.to)):
raise RelationshipInstanceError(

12
orm/queryset.py
View File

@ -75,7 +75,6 @@ class QuerySet:
to_table = model_cls.__table__.name
alias = model_cls._orm_relationship_manager.resolve_relation_join(join_params.from_table, to_table)
# print(f'resolving tables alias from {join_params.from_table}, to: {to_table} -> {alias}')
if alias not in self.used_aliases:
if join_params.prev_model.__model_fields__[part].virtual:
to_key = next((v for k, v in model_cls.__model_fields__.items()
@ -110,30 +109,19 @@ class QuerySet:
def extract_auto_required_relations(self, join_params: JoinParameters,
rel_part: str = '', nested: bool = False, parent_virtual: bool = False):
# print(f'checking model {join_params.prev_model}, {rel_part}')
for field_name, field in join_params.prev_model.__model_fields__.items():
# print(f'checking_field {field_name}')
if self.field_is_a_foreign_key_and_no_circular_reference(field, field_name, rel_part):
rel_part = field_name if not rel_part else rel_part + '__' + field_name
if not field.nullable:
# print(f'field {field_name} is not nullable, appending to auto, curr rel: {rel_part}')
if rel_part not in self._select_related:
self.auto_related.append("__".join(rel_part.split("__")[:-1]))
rel_part = ''
elif self.field_qualifies_to_deeper_search(field, parent_virtual, nested, rel_part):
# print(
# f'field {field_name} is nullable, going down, curr rel: '
# f'{rel_part}, nested:{nested}, virtual:{field.virtual}, virtual_par:{parent_virtual}, '
# f'injoin: {"__".join(rel_part.split("__")[:-1]) in self._select_related}')
join_params = JoinParameters(field.to, join_params.previous_alias,
join_params.from_table, join_params.prev_model)
self.extract_auto_required_relations(join_params=join_params,
rel_part=rel_part, nested=True, parent_virtual=field.virtual)
else:
# print(
# f'field {field_name} is out, going down, curr rel: '
# f'{rel_part}, nested:{nested}, virtual:{field.virtual}, virtual_par:{parent_virtual}, '
# f'injoin: {"__".join(rel_part.split("__")[:-1]) in self._select_related}')
rel_part = ''
def build_select_expression(self):

7
orm/relations.py
View File

@ -5,8 +5,6 @@ from random import choices
from typing import TYPE_CHECKING, List
from weakref import proxy
from sqlalchemy import text
from orm.fields import ForeignKey
if TYPE_CHECKING: # pragma no cover
@ -55,11 +53,6 @@ class RelationshipManager:
child, parent = parent, proxy(child)
else:
child = proxy(child)
# print(
# f'setting up relationship, {parent_id}, {child_id}, '
# f'{parent.__class__.__name__}, {child.__class__.__name__}, '
# f'{parent.pk if parent.values is not None else None}, '
# f'{child.pk if child.values is not None else None}')
parents_list = self._relations[parent_name.lower().title() + '_' + child_name + 's'].setdefault(parent_id, [])
self.append_related_model(parents_list, child)
children_list = self._relations[child_name.lower().title() + '_' + parent_name].setdefault(child_id, [])