finish fields docs intial ver,add test for related name, fix child_name(s) in reverse relations

orm/fields/base.py

@@ -35,12 +35,12 @@ class BaseField:
     @property
     def is_required(self) -> bool:
         return (
-            not self.nullable and not self.has_default and not self.is_auto_primary_key
+                not self.nullable and not self.has_default and not self.is_auto_primary_key
         )
 
     @property
     def default_value(self) -> Any:
-        default = self.default if self.default is not None else self.server_default
+        default = self.default
         return default() if callable(default) else default
 
     @property

orm/fields/foreign_key.py

@@ -25,12 +25,12 @@ def create_dummy_instance(fk: Type["Model"], pk: Any = None) -> "Model":
 
 class ForeignKey(BaseField):
     def __init__(
-        self,
-        to: Type["Model"],
-        name: str = None,
-        related_name: str = None,
-        nullable: bool = True,
-        virtual: bool = False,
+            self,
+            to: Type["Model"],
+            name: str = None,
+            related_name: str = None,
+            nullable: bool = True,
+            virtual: bool = False,
     ) -> None:
         super().__init__(nullable=nullable, name=name)
         self.virtual = virtual
@@ -50,7 +50,7 @@ class ForeignKey(BaseField):
         return to_column.get_column_type()
 
     def _extract_model_from_sequence(
-        self, value: List, child: "Model"
+            self, value: List, child: "Model"
     ) -> Union["Model", List["Model"]]:
         return [self.expand_relationship(val, child) for val in value]
 
@@ -75,10 +75,11 @@ class ForeignKey(BaseField):
         return model
 
     def register_relation(self, model: "Model", child: "Model") -> None:
-        model._orm_relationship_manager.add_relation(model, child, virtual=self.virtual)
+        child_model_name = self.related_name or child.get_name()
+        model._orm_relationship_manager.add_relation(model, child, child_model_name, virtual=self.virtual)
 
     def expand_relationship(
-        self, value: Any, child: "Model"
+            self, value: Any, child: "Model"
     ) -> Optional[Union["Model", List["Model"]]]:
 
         if value is None:

orm/models/metaclass.py

@@ -28,8 +28,8 @@ def parse_pydantic_field_from_model_fields(object_dict: dict) -> Dict[str, Tuple
 
 
 def register_relation_on_build(table_name: str, field: ForeignKey, name: str) -> None:
-    child_relation_name = field.to.get_name(title=True) + "_" + name.lower() + "s"
-    reverse_name = field.related_name or child_relation_name
+    child_relation_name = field.to.get_name(title=True) + "_" + (field.related_name or (name.lower() + "s"))
+    reverse_name = child_relation_name
     relation_name = name.lower().title() + "_" + field.to.get_name()
     relationship_manager.add_relation_type(
         relation_name, reverse_name, field, table_name
@@ -43,14 +43,14 @@ def expand_reverse_relationships(model: Type["Model"]) -> None:
             parent_model = model_field.to
             child = model
             if (
-                child_model_name not in parent_model.__fields__
-                and child.get_name() not in parent_model.__fields__
+                    child_model_name not in parent_model.__fields__
+                    and child.get_name() not in parent_model.__fields__
             ):
                 register_reverse_model_fields(parent_model, child, child_model_name)
 
 
 def register_reverse_model_fields(
-    model: Type["Model"], child: Type["Model"], child_model_name: str
+        model: Type["Model"], child: Type["Model"], child_model_name: str
 ) -> None:
     model.__fields__[child_model_name] = ModelField(
         name=child_model_name,
@@ -64,7 +64,7 @@ def register_reverse_model_fields(
 
 
 def sqlalchemy_columns_from_model_fields(
-    name: str, object_dict: Dict, table_name: str
+        name: str, object_dict: Dict, table_name: str
 ) -> Tuple[Optional[str], List[sqlalchemy.Column], Dict[str, BaseField]]:
     columns = []
     pkname = None

orm/relations.py

@@ -37,25 +37,28 @@ class RelationshipManager:
                     del self._relations[rel_type][model._orm_id]
 
     def add_relation(
-        self, parent: "FakePydantic", child: "FakePydantic", virtual: bool = False,
+        self,
+            parent: "FakePydantic",
+            child: "FakePydantic",
+            child_model_name: str,
+            virtual: bool = False,
     ) -> None:
         parent_id, child_id = parent._orm_id, child._orm_id
-        parent_name, child_name = (
-            parent.get_name(title=True),
-            child.get_name(title=True),
-        )
+        parent_name =parent.get_name(title=True)
+        child_name = child_model_name if child.get_name() != child_model_name else child.get_name()+'s'
         if virtual:
-            child_name, parent_name = parent_name, child_name
+            child_name, parent_name = parent_name, child.get_name()
             child_id, parent_id = parent_id, child_id
             child, parent = parent, proxy(child)
+            child_name = child_name.lower()+'s'
         else:
             child = proxy(child)
 
-        parent_relation_name = parent_name + "_" + child_name.lower() + "s"
+        parent_relation_name = parent_name.title() + "_" + child_name
         parents_list = self._relations[parent_relation_name].setdefault(parent_id, [])
         self.append_related_model(parents_list, child)
 
-        child_relation_name = child_name + "_" + parent_name.lower()
+        child_relation_name = child.get_name(title=True) + "_" + parent_name.lower()
         children_list = self._relations[child_relation_name].setdefault(child_id, [])
         self.append_related_model(children_list, parent)