Sync.

source/builder_template.py

@@ -24,7 +24,8 @@ class builder_template(message_builder):
                     name = "set_" + key + "_" + section
 
                 setattr(self, name, self._create_setter(key, section))
-
+        
+        self.set_key("typename", target.typename)
 
     def __create_setter_name(self, key: str, section: str | None) -> str:
         if section is None:

source/decoder.py

@@ -18,11 +18,14 @@ class decoder(protocol):
         self.__content = None
         return self
 
-    def result(self) -> message:
+    def result(self, message_type: type | None = None) -> message:
         if self.__content is not None:
             self.process()
+        
+        if message_type is None:
+            return self._builder.build()
 
-        return self._builder.build()
+        return message_type(self._builder.build())
 
     @property
     def _lines(self) -> str:

source/package.py

@@ -0,0 +1,19 @@
+class package:
+    @staticmethod
+    def _get_encoding() -> str:
+        return str("UTF-8")
+    
+    def __init__(self, content: str) -> None:
+        self.__content = content.encode("UTF-8")
+
+    @property
+    def size(self) -> int:
+        return len(self.content)
+
+    @property
+    def content(self) -> bytes:
+        return self.__content
+
+    def get_part(self, begin: int, end: int) -> None:   
+        return self.__content[begin: end]
+

source/package_part.py

@@ -0,0 +1,34 @@
+class package_part:
+    def __init__(self, content: bytes) -> None:
+        self.__content = content
+        self.__current_count = None
+        self.__packages_count = None
+
+    def set_counter(self, current: int, packages_count: int) -> object:
+        self.__current_count = current
+        self.__packages_count = packages_count
+
+        return self
+
+    @staticmethod
+    def get_header_size() -> None:
+        return self.__number_size() * 3 + self.__crc_size()
+
+    @classmethod
+    def __number_to_bytes(cls, target: int) -> bytes:
+        return target.to_bytes(cls.__number_size(), "big")
+
+    @staticmethod
+    def __number_size() -> int:
+        return 5
+
+    @staticmethod
+    def __crc_size() -> int:
+        return 20
+
+    @staticmethod 
+    def __calc_crt(target: bytes) -> bytes:
+        return hashlib.sha1(target, usedforsecurity = False).digest()
+
+
+

source/package_spliter.py

@@ -0,0 +1,39 @@
+import math
+import hashlib
+
+from package import package
+
+class package_spliter:
+    def __init__(self, target: package, mtu: int = 256) -> None:
+        self.__target = target
+        self.__mtu = mtu
+
+    @property
+    def mtu(self) -> int:
+        return self.__mtu
+    
+    def __get_number_size(self) -> int:
+        return 4
+
+    def __get_header_size(self) -> int:
+        return self.__get_number_size() * 3 + self.__get_crc_size()
+
+    def __get_crc_size(self) -> int:
+        return 20
+
+    def __convert_number(self, number: int) -> bytes:
+        return number.to_bytes(self.__get_number_size(), "big")
+
+    def __calc_crc(self, part: bytes) -> bytes:
+        return hashlib.sha1(part, usedforsecurity = False).digest()
+
+    def __count_parts(self) -> int:
+        single_package = self.mtu - self.__count_header_size()
+
+        if single_package <= 0:
+            raise RuntimeError("Package size is lower than zero.")
+
+        return math.ceil(len(self.__content) / single_package)
+
+
+

source/position_message.py

@@ -4,7 +4,7 @@ from .builder_template import builder_template
 
 class position_template(template):
     def __init__(self) -> None:
-        super().__init__()
+        super().__init__("position")
 
         self._add_key("x", "move")
         self._add_key("y", "move")

source/template.py

@@ -1,7 +1,8 @@
 class template:
-    def __init__(self) -> None:
+    def __init__(self, typename: str) -> None:
         self.__default = set()
         self.__sections = dict()
+        self.__typename = typename
 
     def _add_key(self, key: str, section: str | None = None) -> None:
         if section is None:
@@ -17,6 +18,10 @@ class template:
     def default_keys(self) -> set:
         return self.__default.copy()
 
+    @property
+    def typename(self) -> str:
+        return self.__typename
+
     @property
     def sections_names(self) -> set:
         return set(self.__sections.keys())