Sync work progress.

server_source/__init__.py

@@ -15,7 +15,6 @@ from .config import config_processor
 from .config import config_loader
 
 from .category import category
-from .category import category_proxy
 
 from .author import author
 from .author import author_proxy

server_source/category.py

@@ -4,6 +4,7 @@ from .single_set_proxy import single_set_proxy
 from .single_set_model import single_set_model
 from .field_generator import field_generator
 from .validators import validators
+from .single_set_manager import single_set_manager
 
 class category(single_set_model):
     content = field_generator.name()
@@ -11,8 +12,10 @@ class category(single_set_model):
     def _single_validator(self) -> callable:
         return validators.name
 
-class category_proxy(single_set_proxy):
-    @classmethod
-    def create(cls, content: str) -> proxy:
-        return cls._create(category, content)
+class caterogy_manager(
+    single_set_manager, 
+    target_model = category, 
+    related_models = "items"
+):
+    pass
 

server_source/constants.py

@@ -3,6 +3,10 @@ class constants:
     def empty_text() -> str:
         return str()
 
+    @staticmethod
+    def app_name() -> str:
+        return str("app")
+
     @staticmethod
     def related_name(
         target: str,

server_source/field_generator.py

@@ -1,6 +1,5 @@
 import tortoise.fields
 
-from .model import model
 from .constants import constants
 
 class field_generator:
@@ -58,11 +57,8 @@ class field_generator:
 
     @staticmethod
     def __connected_names(target: type, field: str | None) -> [str, str]:
-        if not issubclass(target, model):
-            raise TypeError("Foreign key target is not child of model.")
-
         name = target.__name__
-        model_name = model.Meta.app + "." + name
+        model_name = constants.app_name() + "." + name
         related_name = constants.related_name(name, field)
 
         return model_name, related_name

server_source/manager.py

@@ -1,5 +1,4 @@
 from .model import model
 
 class manager:
-    def _get_target_model(self) -> type:
-        raise NotImplementedError()
+    pass

server_source/model.py

@@ -1,9 +1,10 @@
 import tortoise.models
 
 from .field_generator import field_generator
+from .constants import constants
 
 class model(tortoise.models.Model):
-    id = field_generator.primary_key()
+    id = field_generator.id()
 
     def _validators(self) -> dict:
         return dict()
@@ -36,4 +37,4 @@ class model(tortoise.models.Model):
         return self
 
     class Meta:
-        app = "class"
+        app = constants.app_name()

server_source/single_set_manager.py

@@ -2,12 +2,76 @@ from .manager import manager
 from .single_set_model import single_set_model
 
 class single_set_manager(manager):
-    def add(self, target: str) -> single_set_model:
-        target_model = self._get_target_model()
+    def __init_subclass__(
+        cls, 
+        target_model: type, 
+        related_models: str | tuple | list
+    ) -> None: 
+        super().__init_subclass__()
+
+        if not issubclass(target_model, single_set_model):
+            raise TypeError("Target must be subclass of single_set_model.")
+
+        if type(related_models) is str:
+            related_models = tuple([ related_models ])
+
+        if type(related_models) is list:
+            related_models = tuple(related_models)
+
+        if type(related_models) is not tuple:
+            raise TypeError("Related model must be str, list or tuple.")
+
+        cls.__related_models = related_models
+        cls.__target_model = target_model
+
+    @classmethod
+    def _get_related_models(cls) -> tuple:
+        return cls.__related_models
+    
+    @classmethod
+    def _get_model(cls) -> type:
+        return cls.__target_model
+    
+    @classmethod
+    async def add(cls, target: str) -> single_set_model:
+        target_model = cls._get_model()
         
         result = await target_model \
-        .filter(target_model.content = target) \
+        .filter(target_model.content == target) \
         .first()
 
         if result is None:
-            result = self._create(target)
+            return await cls._create(target)
+
+        return result
+
+    @classmethod
+    async def _create(cls, content: str) -> single_set_model:
+        result = self \
+        ._get_target_model() \
+        .get_proxy() \
+        .create(content) \
+        .result()
+
+        await result.save()
+        return result
+
+    @classmethod
+    async def clean(cls, target: str) -> None:  
+        target_model = cls._get_model()
+        related_models = cls._get_related_models()
+
+        target = await target_model \
+        .filter(target_model.content == target) \
+        .first()
+
+        await target.fetch_related(*related_models)
+
+        for count in related_models:
+            if len(target.__getattribute__(count)) > 1:
+                return
+
+        await target.delete()
+
+        has_
+

server_source/single_set_model.py

@@ -1,8 +1,16 @@
 from .model import model
+from .single_set_proxy import single_set_proxy
 
 class single_set_model(model):
     content = NotImplemented
 
+    @classmethod
+    def get_proxy(cls) -> single_set_proxy:
+        class model_proxy(single_set_proxy, target_model = cls):
+            pass
+
+        return model_proxy
+
     def _single_validator(self) -> callable:
         raise NotImplementedError()
 

server_source/single_set_proxy.py

@@ -1,5 +1,5 @@
 from .proxy import proxy
-from .single_set_model import single_set_model
+from .model import model
 
 class single_set_proxy(proxy):
     def set(self, target: str) -> None:
@@ -7,17 +7,18 @@ class single_set_proxy(proxy):
 
     def get(self) -> str:
         return self._target.content
+    
+    def __init_subclass__(cls, target_model: type) -> None:
+        super().__init_subclass__()
 
-    @classmethod
-    def _create(cls, target: type, content: str) -> proxy:
-        if type(target) is not type:
+        if type(target_model) is not type:
             raise TypeError("Target must be an class.")
 
-        if not issubclass(target, single_set_model):
+        if not issubclass(target_model, model):
             raise TypeError("Target must be subclass of single_set_model.")
 
-            return cls(target(content = content))
-    
+        cls.__target_model = target_model
+        
     @classmethod    
     def create(cls, content: str) -> proxy:
-        raise NotImplementedError()
+        return cls(cls.__target_model(content = content))