Redesign connection schemat.

source/__init__.py

@@ -1,10 +1,12 @@
-from .protocol import protocol
+from .field_encoder import field_encoder
+from .field_decoder import field_decoder
+from .field import field
+from .message_coder import message_coder
+from .message_encoder import message_encoder
+from .cutter import cutter
 from .message import message
-from .message_builder import message_builder
-from .message_step_builder import message_step_builder
-from .string_builder import string_builder
-from .encoder import encoder
-from .decoder import decoder
-from .builder_template import builder_template
+from .message_decoder import message_decoder
+from .message_receiver import message_receiver
 from .position_message import position_message
-from .position_message import position_message_builder
+from .state_message import state_message
+

source/builder_template.py

@@ -1,63 +0,0 @@
-from .template import template
-from .message import message
-from .message_builder import message_builder
-
-class builder_template(message_builder):
-    def __init__(self, result_type: type) -> None:
-        super().__init__()
-        self.__required = set()
-        self.__result_type = result_type
-
-    def _import_template(self, target: template) -> None:
-        default_keys = target.default_keys
-
-        for key in default_keys:
-            name = "set_" + key
-
-            setattr(self, name, self._create_setter(key))
-
-        for section in target.sections_names:
-            for key in target.get_section_keys(section):
-                name = "set_" + key
-
-                if name in default_keys:
-                    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:
-            return "kn_" + key
-        
-        return "ks_" + key + section
-
-    def _set_required_key(
-        self,
-        key: str, 
-        target: str, 
-        section: str | None
-    ) -> object:
-        name = self.__create_setter_name(key, section)
-
-        if not name in self.__required:
-            raise RuntimeError("Key " + key + " had been already set.")
-
-        self.__required.remove(name)
-        return self.set_key(key, target, section)
-
-    def _create_setter(self, key: str, section: str | None = None) -> object:
-        self.__required.add(self.__create_setter_name(key, section)) 
-
-        return lambda target: self._set_required_key(key, target, section)
-
-    def build(self) -> message:
-
-        if len(self.__required) > 0:
-            raise RuntimeError("One or more required keys are not set.")
-
-        return super().build(help_type = self.__result_type)
-
-
-

source/control_message.py

@@ -0,0 +1,13 @@
+from .field import field
+from .message import message
+
+class state_message(message):
+    _type = 0x0012
+    
+    def __init__(self) -> None:
+        super().__init__()
+        
+        self._add_field(field("move_x", int, 2))
+        self._add_field(field("move_y", int, 2))
+        self._add_field(field("move_z", int, 2))
+        self._add_field(field("rotate", int, 2))

source/cutter.py

@@ -0,0 +1,45 @@
+class cutter:
+    def __init__(self, target: bytes) -> None:
+        self.__current = target
+
+    def __check(self, count: int) -> None:
+        if count == 0:
+            raise RuntimeError("Cutter is already empty.")
+
+        if count > len(self.size):
+            raise RuntimeError("Count is higher than size.")
+        
+    def from_start(self, count: int) -> bytes:
+        self.__check(count)
+
+        result = self.__current[:count]
+        self.__current = self.__current[count:]
+
+        return result
+
+    def from_end(self, count: int) -> bytes:
+        self.__check(count)
+
+        result = self.__current[self.size - count:]
+        self.__current = self.__current[:self.size - count]
+
+        return result
+
+    def cut(self, count: int) -> bytes:
+        return self.from_end(count)
+
+    def trim(self, count: int) -> bytes:
+        return self.from_start(count)
+
+    @property
+    def content(self) -> bytes:
+        return self.__current
+
+    @property
+    def size(self) -> int:  
+        return len(self.__current)
+
+    def __len__(self) -> int:
+        return self.size
+
+

source/decoder.py

@@ -1,69 +0,0 @@
-from .message import message
-from .message_builder import message_builder
-from .message_step_builder import message_step_builder
-from .protocol import protocol
-
-class decoder(protocol):
-    def __init__(self, content: str) -> None:
-        self.__content = content
-        self.__builder = message_step_builder()
-
-    def process(self) -> object:
-        if self.__content is None:
-            return self
-
-        for line in self._lines:
-            self.__parse_line(line)
-
-        self.__content = None
-        return self
-
-    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 message_type(self._builder.build())
-
-    @property
-    def _lines(self) -> str:
-        return self.__content.split(self._line_separator)
-    
-    @property 
-    def _builder(self) -> message_step_builder:
-        return self.__builder
-
-    def __parse_line(self, line: str) -> None:
-        line = line.strip()
-
-        if self.__is_section(line):
-            self.__parse_section(line)
-            return
-
-        self.__parse_key_value(line)
-
-    def __is_section(self, line: str) -> bool:
-        if len(line) < 1:
-            return False
-
-        return line[0] == self._section_buckles[0]
-
-    def __parse_key_value(self, line: str) -> None:
-        position = line.find("=")
-        
-        if position == -1:    
-            return
-
-        key = line[:position].strip()
-        position = position + 1
-        value = line[position:].strip()
-
-        self._builder.add(key, value)
-
-    def __parse_section(self, line: str) -> None:
-        for char in self._section_buckles:
-            line = line.replace(char, "")
-        
-        self._builder.change_section(line)

source/encoder.py

@@ -1,55 +0,0 @@
-import types
-import functools
-
-from .message import message
-from .protocol import protocol
-from .string_builder import string_builder
-
-class encoder(protocol):
-    def __init__(self, target: message) -> None:
-        self.__target = target
-
-    @property
-    def _target(self) -> message:
-        return self.__target
-
-    @functools.cache
-    def process(self) -> str:
-        result = string_builder()
-        result.add(self.__code_section_body(self._target.default))
-
-        for section, content in self._target.sections.items():
-            result.add(self.__code_section_header(section))
-            result.add(self.__code_section_body(content))
-
-        return result.build()
-
-    def __code_section_body(self, content: dict) -> str:
-        result = string_builder()
-        
-        for key, value in content.items():
-            result.add(self.__code_key_value(key, value))
-
-        return result.build()
-
-    def __code_section_header(self, section: str) -> str:
-        return string_builder() \
-        .add(self._section_buckles[0]) \
-        .add(section) \
-        .add(self._section_buckles[1]) \
-        .add(self._line_separator) \
-        .build()
-    
-    def __code_key_value(self, key: str, value: str) -> str:
-        return string_builder() \
-        .add(key) \
-        .add(self._setter) \
-        .add(value) \
-        .add(self._line_separator) \
-        .build()
-
-    def __str__(self) -> str:
-        return self.process()
-
-    def __repr(self) -> str:
-        return "Message encoder:\n" + str(self)

source/field.py

@@ -0,0 +1,51 @@
+from .field_encoder import field_encoder
+from .field_decoder import field_decoder
+
+class field:
+    def __init__(self, title: str, target: type, size: int = 4) -> None:
+        self.__title = title
+        self.__target_type = target
+        self.__size = size
+        self.__content = None
+        self.__float_precission = 2
+
+    def set_precission(self, target: int) -> object:
+        self.__precission = target
+        return self
+
+    @property
+    def precission(self) -> int:
+        return self.__precission
+
+    def set(self, target: any) -> object:
+        if type(target) is not self.__target_type:
+            raise TypeError("Field type is frong.")
+
+        self.__content = target
+        return self
+
+    def get(self) -> any:
+        return self.__content
+
+    @property
+    def size(self) -> int:
+        return len(self)
+
+    @property
+    def title(self) -> str:
+        return self.__title
+
+    @property
+    def target_type(self) -> type:
+        return self.__target_type
+
+    def __len__(self) -> int:   
+        return self.__size
+
+    def encoder(self) -> field_encoder:
+        return field_encoder(self)
+
+    def decoder(self) -> field_decoder:
+        return field_decoder(self)
+
+

source/field_decoder.py

@@ -0,0 +1,36 @@
+class field_decoder:
+    def __init__(self, target: object) -> None:
+        self.__field = target 
+   
+    def load(self, content: bytes) -> object:
+        self.__field.set(self.__bytes_decode(content))
+        return self
+
+    def __bytes_decode(self, content: bytes) -> any:
+        if self.__field.target_type is str:
+            return self.__decode_str(content)
+
+        if self.__field.target_type is bytes:
+            return content
+
+        if self.__field.target_type is int:
+            return self.__decode_int(content)
+        
+        if self.__field.target_type is float:
+            return self.__decode_float(content)
+        
+        if self.__field.target_type is bool:
+            return self.__decode_bool(content)
+
+    def __decode_bool(self, content: bytes) -> bool:
+        return True if int.from_bytes(content) != 0 else False
+
+    def __decode_float(self, content: bytes) -> float:
+        return self.__decode_int(content) / pow(10, self.__field.precission)
+
+    def __decode_str(self, content: bytes) -> str:
+        return content.decode("UTF-8")
+
+    def __decode_int(self, content: bytes) -> int:
+        return int.from_bytes(content)
+ 

source/field_encoder.py

@@ -0,0 +1,51 @@
+class field_encoder:    
+    def __init__(self, target: object) -> None:
+        self.__target = target
+
+    def code(self) -> bytes:
+        if self.__target.target_type is str:
+            return self.__code_str(self.__target.get())
+
+        if self.__target.target_type is int:
+            return self.__code_int(self.__target.get())
+
+        if self.__target.target_type is float:
+            return self.__code_float(self.__target.get())
+
+        if self.__target.target_type is bytes:
+            return self.__target.get()
+
+        if self.__target.target_type is bool:
+            return self.__code_bool(self.__target.get())
+
+        raise TypeError("Can not encode field, unsupported type.")
+
+    def __code_str(self, content: str) -> bytes:   
+        result = content.encode()
+        difference = self.__target.size - len(result)
+
+        if difference > 0:
+            return result + bytes(difference)
+        
+        if difference < 0:
+            return result[0:self.__target.size]
+
+        return result
+
+    def __code_int(self, content: int) -> bytes:
+        return content.to_bytes(self.__target.size)
+
+    def __code_float(self, content: float) -> bytes:
+        precission = pow(10, self.float_precission)
+        as_int = int(content * precission)
+        result = as_int.to_bytes(self.__target.size)
+
+        return result
+    
+    def __code_bool(self, content: bool) -> bytes:
+        as_int = int(1 if content else 0)
+        result = as_int.to_bytes(self.__target.size)
+
+        return result
+
+

source/message.py

@@ -1,67 +1,49 @@
-import types
+from .field import field
+from .message_coder import message_coder
+from .message_encoder import message_encoder
 
 class message:
-    def __init__(self, *args, **kwargs) -> None:
-        if "clone_it" in kwargs:
-            self.__from_clone(kwargs["clone_it"])
-            return 
+    _type = None
 
-        self.__from_dicts(args[0], args[1])
+    def __init__(self) -> None:
+        self.__fields = list()
 
-    def __from_clone(self, clone_it: object) -> None:
-        self.__sections = clone_it.sections
-        self.__default = clone_it.default
+        if self._type is None:
+            raise RuntimeError("Message type can not being None.")
 
-    def __from_dicts(self, default: dict, sections: dict) -> None:
-        sections_proxy = dict()
+    @classmethod
+    def get_type(cls) -> int:
+        return cls._type
 
-        for key, value in sections.items():
-            sections_proxy[key] = types.MappingProxyType(value)
-
-        self.__sections = types.MappingProxyType(sections_proxy)
-        self.__default = types.MappingProxyType(default)
-
-    def get_key(self, key: str, section: str | None = None) -> str:
-        if section is None:
-            return self.get_from_default(key)
+    @property
+    def fields(self) -> tuple:
+        return tuple(self.__fields)
 
-        return self.get_from_section(section, key)
+    def _add_field(self, target: field) -> None:
+        if target in self.__fields:
+            return
 
-    def key_exists(self, key: str, section: str | None = None) -> bool:
-        if section is None:
-            return key in self.default
-        
-        if not section in self.sections:
-            return False
+        self.__fields.append(target)
 
-        return key in self.sections[section]
-    
-    def get_from_default(self, key: str) -> str:
-        if not key in self.__default:
-            raise KeyError("Not found key " + key + " in message.")
+        title = target.title
+        setter = lambda content: target.set(content)
+        setter = lambda : target.get()
 
-        return self.__default[key]
+        setattr(self, "set_" + title, setter)
+        setattr(self, "get_" + title, getter)
 
-    def get_from_section(self, section: str, key: str) -> str:
-        if not section in self.__sections:
-            raise KeyError("Not found section " + section + " in message.")
+    @property
+    def size(self) -> int:
+        result = 0
 
-        if not key in self.__sections[section]:
-            raise KeyError( \
-                "Not found key " \
-                + key \
-                + " in section " \
-                + section \
-                + " of message." \
-            )
+        for count in self.__fields:
+            result += count.size
 
-        return self.__sections[section][key]
+        return result
 
-    @property
-    def default(self) -> types.MappingProxyType:
-        return self.__default
+    def __len__(self) -> int:
+        return self.size
 
-    @property
-    def sections(self) -> types.MappingProxyType:
-        return self.__sections
+    def encoder(self) -> message_encoder:
+        return message_encoder(self)
 

source/message_builder.py

@@ -1,50 +0,0 @@
-from .message import message
-
-class message_builder:
-    def __init__(self) -> None:
-        self.__sections = dict()
-        self.__default = dict()
-
-    def __add_section(self, section: str) -> object:
-        if not section in self.__sections.keys():
-            self.__sections[section] = dict()
-
-    def __set_section_key(self, section: str, key: str, value: str) -> None:
-        self.__sections[section][key] = value
-
-    def __set_default_key(self, key: str, value: str) -> None:
-        self.__default[key] = value
-
-    def set_key(
-        self, 
-        key: str, 
-        value: str, 
-        section: str | None = None
-    ) -> object:
-        key = key.strip()
-        value = value.strip()
-
-        if len(key) == 0:
-            raise RuntimeError("Key name can nob being empty.")
-
-        if section is None:
-            self.__set_default_key(key, value)
-            return self
-
-        section = section.strip()
-        
-        if len(section) == 0:
-            raise RuntimeError("Section name can not being empty.")
-
-        self.__add_section(section)
-        self.__set_section_key(section, key, value)
-
-        return self
-
-    def build(self, help_type: type | None = None) -> message:
-        result = message(self.__default, self.__sections)
-
-        if help_type is None:
-            return result
-
-        return help_type(result)

source/message_coder.py

@@ -0,0 +1,16 @@
+import hashlib
+
+class message_coder:
+    @staticmethod
+    def type_size() -> int:
+        return 2
+
+    @staticmethod
+    def hash_size() -> int:
+        return 20
+
+    @staticmethod
+    def _get_hash(target: bytes) -> bytes:
+        return hashlib.sha1(target, usedforsecurity = False).digest()
+
+

source/message_decoder.py

@@ -0,0 +1,44 @@
+from .message_coder import message_coder
+from .field_decoder import field_decoder
+from .message import message
+from .cutter import cutter
+
+class message_decoder(message_coder):
+    def __init__(self, content: bytes) -> None:
+        self.__content = content
+
+    def extract_type(self) -> int:
+        return int.from_bytes(self.__content[:self.type_size()])
+
+    def __check_crc(self, target: bytes, crc: bytes) -> bool:
+        return self._get_hash(target) == crc
+
+    def build(self, target: type) -> message:
+        if not issubclass(target, message):
+            raise RuntimeError("Target must be subclass of message.")
+
+        result = target()
+        self.fill(result)
+
+        return result
+
+    def fill(self, target: message) -> object:
+        handler = cutter(self.__content)
+        crc = handler.cut(self.hash_size())
+
+        if not self.__check_crc(handler.content, crc):
+            raise ConnectionError("Message CRC checksum is not correct.")
+
+        type_bytes = handler.trim(self.type_size())
+        type_id = int.from_bytes(type_bytes)
+
+        if type_id != target.get_type():
+            raise TypeError("Received message ID is not correct.")
+
+        for count in target.fields:
+            field_bytes = handler.trim(count.size)
+            count.decoder().load(field_bytes)
+
+        return self
+
+

source/message_encoder.py

@@ -0,0 +1,14 @@
+class message_encoder(message_coder):
+    def __init__(self, target: message) -> None:
+        self.__target = target
+
+    def code(self) -> bytes:
+        result = self.__target.get_type().to_bytes(self.type_size())
+
+        for count in self.__target.fields:
+            result += count.encoder().code()
+
+        result += self._get_hash(result)
+        return result
+
+

source/message_receiver.py

@@ -0,0 +1,23 @@
+from .message import message
+from .message_decoder import message_decoder
+
+class message_receiver:
+    def __init__(self) -> None: 
+        self.__types = dict()
+    
+    def register(self, target: type) -> object:
+        if not issubclass(target, message):
+            raise RuntimeError("Can not register type which is not message.")
+
+        self.__types[target.get_type()] = target
+        return self
+
+    def receive(self, content: bytes) -> message:
+        decoder = message_decoder(content)
+        type_id = decoder.extract_type()
+
+        if type_id in self.__types:
+            return decoder.build(self.__types[type_id])
+
+        raise RuntimeError("Can nof find message type ID in registered.")
+      

source/message_step_builder.py

@@ -1,15 +0,0 @@
-from .message import message
-from .message_builder import message_builder
-
-class message_step_builder(message_builder):
-    def __init__(self):
-        super().__init__()
-        self.__current_section = None
-
-    def add(self, key: str, value: str) -> object:
-        return self.set_key(key, value, self.__current_section)
-   
-    def change_section(self, section: str) -> object:
-        self.__current_section = section
-        return self
-

source/message_template.py

@@ -1,33 +0,0 @@
-from .message import message
-from .template import template
-
-class message_template(message):
-    def __init__(self, target: message) -> None:
-        super().__init__(clone_it = target)
-
-    def _import_template(self, target: template) -> None:
-        default_keys = target.default_keys
-
-        for key in default_keys:
-            name = "get_" + key
-
-            setattr(self, name, self._create_getter(key))
-
-        for section in target.sections_names:
-            for key in target.get_section_keys(section):
-                name = "get_" + key
-
-                if name in default_keys:
-                    name = "get_" + key + "_" + section
-
-                setattr(self, name, self._create_getter(key, section))
-
-    def _create_getter(self, key: str, section: str | None = None) -> object:
-        if not self.key_exists(key, section):
-            raise RuntimeError("Message not have required key " + key + ".")
-
-        return lambda: self.get_key(key, section)
-
-
-   
-

source/package.py

@@ -1,19 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,26 +1,18 @@
-from .template import template
-from .message_template import message_template
-from .builder_template import builder_template
+from .field import field
+from .message import message
 
-class position_template(template):
-    def __init__(self) -> None:
-        super().__init__("position")
+class position_message(message):
+    _type = 0x0010
 
-        self._add_key("x", "move")
-        self._add_key("y", "move")
-        self._add_key("z", "move")
+    def __init__(self) -> None:
+        super().__init__()
 
-        self._add_key("yaw", "rotate")
-        self._add_key("roll", "rotate")
-        self._add_key("pitch", "rotate")
+        self._add_field(field("accell_x", float).set_precission(2))
+        self._add_field(field("accell_y", float).set_precission(2))
+        self._add_field(field("accell_z", float).set_precission(2))
 
-class position_message(message_template):
-    def __init__(self, target: message) -> None:
-        super().__init__(target)
-        self._import_template(position_template())
+        self._add_field(field("rotate_yaw", float).set_precission(2))
+        self._add_field(field("rotate_pitch", float).set_precission(2))
+        self._add_field(field("rotate_roll", float).set_precission(2))
 
-class position_message_builder(builder_template):
-    def __init__(self) -> None:
-        super().__init__(position_message)
-        self._import_template(position_template())
 

source/protocol.py

@@ -1,24 +0,0 @@
-class protocol: 
-    @staticmethod
-    def line_separator() -> str:
-        return str("\n")
-
-    @staticmethod
-    def setter() -> str:
-        return str("=")
-
-    @staticmethod
-    def section_buckles() -> [str, str]:
-        return ("[", "]")
-
-    @property
-    def _line_separator(self) -> str:
-        return self.__class__.line_separator()
-
-    @property
-    def _setter(self) -> str:
-        return self.__class__.setter()
-        
-    @property
-    def _section_buckles(self) -> [str, str]:
-        return ("[", "]")

source/state_message.py

@@ -0,0 +1,11 @@
+from .field import field
+from .message import message
+
+class state_message(message):
+    _type = 0x0001
+    
+    def __init__(self) -> None:
+        super().__init__()
+        
+        self._add_field(field("ignition", bool, 1))
+        self._add_field(field("leds", int, 1))

source/string_builder.py

@@ -1,10 +0,0 @@
-class string_builder:
-    def __init__(self) -> None: 
-        self.__content = list()
-
-    def add(self, content: str) -> object:
-        self.__content.append(content)
-        return self
-
-    def build(self) -> str:
-        return str().join(self.__content)

source/template.py

@@ -1,34 +0,0 @@
-class template:
-    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:
-            self.__default.add(key)
-            return
-            
-        if not section in self.__sections:
-            self.__sections[section] = set()
-
-        self.__sections[section].add(key)
-        
-    @property
-    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())
-
-    def get_section_keys(self, section: str) -> set:
-        if not section in self.__sections:
-            raise RuntimeError("Section " + section + " not exists.")
-
-        return self.__sections[section].copy()
-

tests/001-message.py

@@ -1,40 +0,0 @@
-import pathlib
-
-test_file = pathlib.Path(__file__)
-test_dir = test_file.parent
-project_dir = test_dir.parent
-
-import sys
-sys.path.append(str(project_dir.absolute()))
-
-import source as communication
-
-def main():
-    message = communication \
-    .message_builder() \
-    .set_key("test_key", "10") \
-    .set_key("other", "20") \
-    .set_key("in_section", "a", "sect") \
-    .set_key("protocol", "https", "conn") \
-    .set_key("ip", "10.0.0.1", "conn") \
-    .build()
-
-    def check_key(key: str, section: str | None, value: any) -> None:
-        result = message.get_key(key, section) == value
-        section = "default" if section is None else section
-        
-        if result:
-            print("Work [" + section + "." + key + "]!")
-            return
-
-        print("Not work [" + section + "." + key + "]!")
-        raise RuntimeError("Not property value!.")
-
-    check_key("test_key", None, "10")
-    check_key("other", None, "20")
-    check_key("in_section", "sect", "a")
-    check_key("protocol", "conn", "https")
-    check_key("ip", "conn", "10.0.0.1")
-    
-if __name__ == "__main__":
-    main()

tests/002-encoder.py

@@ -1,30 +0,0 @@
-import pathlib
-
-test_file = pathlib.Path(__file__)
-test_dir = test_file.parent
-project_dir = test_dir.parent
-
-import sys
-sys.path.append(str(project_dir.absolute()))
-
-import source as communication
-
-def main():
-    print("Building message.")
-
-    message = communication.message_builder() \
-    .set_key("name", "cx-copter") \
-    .set_key("version", "1.1") \
-    .set_key("ssid", "UwUUwU", "wifi") \
-    .set_key("key", "password", "wifi") \
-    .set_key("TLS", "false", "socket") \
-    .build()
-
-    print("Encoding.")
-    encoded = communication.encoder(message).process()
-
-    print("Result:")
-    print(encoded)
-
-if __name__ == "__main__":
-    main()

tests/003-decoder.py

@@ -1,42 +0,0 @@
-import pathlib
-
-test_file = pathlib.Path(__file__)
-test_dir = test_file.parent
-project_dir = test_dir.parent
-
-import sys
-sys.path.append(str(project_dir.absolute()))
-
-import source as communication
-
-def main():
-    message = "\
-width=200\n\
-height=100\n\
-\n\
-[first]\n\
-my=iam\n\
-\n\
-[conn]\n\
-ip=dhcp\n\
-ssid=name\n\
-"
-
-    result = communication.decoder(message).process().result()
-
-    def check(key: str, value: str, section: str | None = None) -> None:
-        if result.get_key(key, section) == value:
-            print("Key " + key + " work.")
-            return
-        
-        section = "default" if section is None else section
-        print("Key " + key + " in section " + section + " NOT WORK.")
-    
-    check("width", "200")
-    check("height", "100")
-    check("my", "iam", "first")
-    check("ip", "dhcp", "conn")
-    check("ssid", "name", "conn")
-    
-if __name__ == "__main__":
-    main()

tests/004-template.py

@@ -1,28 +0,0 @@
-import pathlib
-
-test_file = pathlib.Path(__file__)
-test_dir = test_file.parent
-project_dir = test_dir.parent
-
-import sys
-sys.path.append(str(project_dir.absolute()))
-
-import source as communication
-
-def main():
-    helper = communication.position_message_builder()
-    
-    helper.set_x("10")
-    helper.set_y("15")
-    helper.set_z("11")
-    
-    helper.set_yaw("0")
-    helper.set_roll("90")
-    helper.set_pitch("70")
-
-    result = helper.build()
-
-    print(type(result)) 
-
-if __name__ == "__main__":
-    main()