Merge pull request #1 from vinyguedess/stage

v2021.11.07

.github/workflows/deploy.yml

@@ -1,7 +1,8 @@
 name: Deploy
 
 on:
-  - release
+  release:
+    types: [ created ]
 
 jobs:
   build:

.github/workflows/main.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches:
   pull_request:
-    branches: [ master ]
+    branches: [ master, stage ]
 
 jobs:
   build:

Makefile

@@ -10,14 +10,10 @@ deploy:
 	python setup.py sdist bdist_wheel
 	twine upload dist/*
 
-doc:
-	rm -rf README.rst
-	m2r README.md
-
 lint:
 	black alcherializer tests
 	isort alcherializer tests
 
 test:
-	python -m pytest -p no:warnings --cov=alcherializer -v
+	python -m pytest -p no:warnings --cov=alcherializer -vv
 	coverage html

README.md

@@ -15,13 +15,20 @@ This instantly maps all fields declared in model.
 from datetime import datetime
 from alcherializer import Serializer
 import sqlalchemy
+from sqlalchemy.orm import relationship
+
+
+class Manager:
+    name = sqlalchemy.Column(sqlalchemy.String(100))
 
 
 class User:
     name = sqlalchemy.Column(sqlalchemy.String(100))
     age = sqlalchemy.Column(sqlalchemy.Integer)
     is_active = sqlalchemy.Column(sqlalchemy.Boolean)
     created_at = sqlalchemy.Column(sqlalchemy.DateTime, default=datetime.utcnow)
+
+    organization = relationship(Manager, uselist=False)
 
 
 class UserSerializer(Serializer):
@@ -53,6 +60,52 @@ serializer = UserSerializer([model], many=True)
 serializer.data  # [{ "name": "Clark Kent", ... }]
 ```
 
+### Related Serializers
+```python
+class ManagerSerializer(Serializer):
+    class Meta:
+        model = Manager
+
+
+class UserSerializer(Serializer):
+    manager = ManagerSerializer()
+
+    class Meta:
+        model = User
+
+
+model = User(
+    name="Peter Parker",
+    manager=Manager(
+        name="J. Jonah Jameson"
+    )
+)
+serializer = UserSerializer(model)
+serializer.data # {"name": "Peter Parker", "manager": {"name": "J. Jonah Jameson"}}
+```
+
+### Custom fields
+```python
+from datetime import datetime, timedelta
+from alcherializer import fields
+
+class UserSerializer(Serializer):
+    year_of_birth = fields.MethodField()
+
+    def get_year_of_birth(self, user: User) -> datetime:
+        return datetime.utcnow() - timedelta(days=user.age * 365)
+
+    class Meta:
+        model = User
+        fields = ["id", "name", "year_of_birth"]
+
+
+model = User(id=1, name="Batman", age=30)
+
+serializer = UserSerializer(model)
+serializer.data # {"id": 1, "name": "Batman", "year_of_birth": 1991}
+```
+
 ## Validation
 To validate a payload, it's possible to send it through data argument while
 instantiating the serializer and call **.is_valid** method.

alcherializer/fields.py

@@ -84,3 +84,7 @@ def check_if_length_is_under_limit(
             return False, f"Limit of characters is {self.field.type.length}"
 
         return True, None
+
+
+class MethodField(BaseField):
+    pass

alcherializer/serializer.py

@@ -4,6 +4,7 @@
 )
 
 import sqlalchemy
+from sqlalchemy.ext.declarative import DeclarativeMeta
 
 from alcherializer import fields
 from alcherializer.exceptions import MalformedMetaClassException
@@ -32,7 +33,7 @@ def data(self) -> Dict[str, Any]:
         for instance in instances:
             obj_dict = {}
             for key in self.fields.keys():
-                obj_dict[key] = getattr(instance, key)
+                obj_dict[key] = self._get_instance_field_value(instance, key)
 
             results.append(obj_dict)
 
@@ -64,17 +65,39 @@ def _has_errors(self) -> bool:
         return len(self.errors.keys()) <= 0
 
     def _get_fields(self) -> Dict[str, Any]:
+        required_fields = []
+        if hasattr(self.meta, "fields"):
+            required_fields = self.meta.fields
+
         columns = {}
         for key, value in self.meta.model.__dict__.items():
             if key.startswith("_"):
                 continue
 
+            if required_fields and key not in required_fields:
+                continue
+
             columns[key] = {
-                "type": value.type,
-                "required": value.nullable is False,
+                "type": value.type if hasattr(value, "type") else value,
+                "required": value.nullable is False
+                if hasattr(value, "nullable")
+                else False,
                 "validator": self._get_field_validator(key, value),
             }
 
+        for field in required_fields:
+            if field in columns:
+                continue
+
+            if not hasattr(self, field):
+                continue
+
+            columns[field] = {
+                "type": getattr(self, field),
+                "required": False,
+                "validator": self._get_field_validator(field, field),
+            }
+
         return columns
 
     def _get_field_validator(self, key: str, field):
@@ -95,3 +118,27 @@ def _get_field_validator(self, key: str, field):
             return fields.BooleanField(key, field)
 
         return fields.BaseField(key, field)
+
+    def _get_instance_field_value(self, instance, field: str) -> Any:
+        if isinstance(self.fields[field].get("type"), fields.MethodField):
+            return getattr(self, f"get_{field}", lambda o: None)(instance)
+
+        value = getattr(instance, field)
+        if isinstance(value.__class__, DeclarativeMeta):
+            serializer = self.fields[field]["validator"]
+            if isinstance(serializer, Serializer):
+                serializer.instance = value
+                return serializer.data
+
+        if (
+            isinstance(value, list)
+            and len(value) > 0
+            and isinstance(value[0].__class__, DeclarativeMeta)
+        ):
+            serializer = self.fields[field]["validator"]
+            if isinstance(serializer, Serializer):
+                serializer.instance = value
+                serializer.many = True
+                return serializer.data
+
+        return value