protobin 0.0.6__tar.gz → 0.0.8__tar.gz

{protobin-0.0.6 → protobin-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: protobin
-Version: 0.0.6
+Version: 0.0.8
 Summary: Python library for encode and decode data in protobin format
 Project-URL: Homepage, https://github.com/drmelectronic/protobin-python
 Project-URL: Bug Tracker, https://github.com/drmelectronic/protobin-python/issues
@@ -33,6 +33,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
+Requires-Dist: pyyaml~=6.0
 Description-Content-Type: text/markdown
 
 # protobin

{protobin-0.0.6 → protobin-0.0.8}/protobin/fields.py

@@ -13,6 +13,7 @@ class FieldEnum(enum.StrEnum):
     CHAR = 'char'
     DATE = 'date'
     DATETIME = 'datetime'
+    ID = 'id'
     FLAGS = 'flags'
     FLOAT = 'float'
     SIGNED = 'signed'
@@ -27,9 +28,9 @@ class FieldBase:
     key: Union[str, List[str]]
     type: FieldEnum
 
-    def __init__(self, js):
+    def __init__(self, k, js):
+        self.key = k
         self.type = js['type']
-        self.key = js.get('key')
         self.bytes = js.get('bytes')
 
     def decode(self, binary):
@@ -77,19 +78,13 @@ class FieldBase:
             return binary[:self.bytes], binary[self.bytes:]
         return binary[1:binary[0] + 1], binary[binary[0] + 1:]
 
-    def to_dict(self):
-        return {
-            'key': self.key,
-            'bytes': self.bytes,
-            'type': self.type
-        }
 
 
 class FieldArray(FieldBase):
     length: int
 
-    def __init__(self, js):
-        super().__init__(js)
+    def __init__(self, k, js):
+        super().__init__(k, js)
         self.array = js['array']
 
     def decode(self, binary):
@@ -98,17 +93,12 @@ class FieldArray(FieldBase):
         val, binary = self.from_binary(binary)
         return val, binary
 
-    def to_dict(self):
-        d = super().to_dict()
-        d['array'] = self.array
-        return d
-
     def to_binary(self, val):
         binary = b''
         length = len(val)
         binary += length.to_bytes(1, 'big')
         for i in range(length):
-            fields = [FIELD_MAP[f['type']](f) for f in self.array]
+            fields = [FIELD_MAP[f['type']](k, f) for k, f in self.array.items()]
             for f in fields:
                 binary += f.encode(val[i])
         return binary
@@ -117,7 +107,7 @@ class FieldArray(FieldBase):
         lista = []
         for i in range(self.length):
             data = {}
-            fields = [FIELD_MAP[f['type']](f) for f in self.array]
+            fields = [FIELD_MAP[f['type']](k, f) for k, f in self.array.items()]
             for f in fields:
                 val, binary = f.decode(binary)
                 data[f.key] = val
@@ -128,8 +118,8 @@ class FieldArray(FieldBase):
 class FieldBits(FieldBase):
     length: int
 
-    def __init__(self, js):
-        super().__init__(js)
+    def __init__(self, k, js):
+        super().__init__(k, js)
         self.length = js.get('length', 0)
         self.bytes = math.ceil(self.length / 8)
 
@@ -177,10 +167,21 @@ class FieldBool(FieldBase):
     bytes = 1
 
     def to_binary(self, val):
-        return bool(val).to_bytes(1, 'big', signed=False)
+        if val is None:
+            val = 2
+        else:
+            val = bool(val)
+
+        return val.to_bytes(1, 'big', signed=False)
 
     def from_binary(self, binary):
-        return bool(int.from_bytes(binary, 'big', signed=False))
+        val = int.from_bytes(binary, 'big', signed=False)
+        if val == 0:
+            return False
+        elif val == 1:
+            return True
+        else:
+            return None
 
 
 class FieldChar(FieldBase):
@@ -197,8 +198,8 @@ class FieldChar(FieldBase):
 
 class FieldDate(FieldBase):
 
-    def __init__(self, js):
-        super().__init__(js)
+    def __init__(self, k, js):
+        super().__init__(k, js)
         self.bytes = 3
 
     def to_binary(self, val: datetime.datetime | str):
@@ -219,12 +220,16 @@ class FieldDate(FieldBase):
 
 class FieldDateTime(FieldBase):
 
-    def __init__(self, js):
-        super().__init__(js)
+    def __init__(self, k, js):
+        super().__init__(k, js)
         self.bytes = 6
 
     def to_binary(self, val: datetime.datetime | str):
-        if isinstance(val, str):
+        if val is None:
+            val = datetime.datetime(2000, 1, 1)
+        elif not isinstance(val, datetime.datetime):
+                raise ValueError(f'Error en el campo "{self.key}" se espera un datetime pero se recibe {val}')
+        elif isinstance(val, str):
             val = datetime.datetime.strptime(val, '%Y-%m-%d %H:%M:%S').date()
         return bytes([
             self.to_nible(val.day),
@@ -246,12 +251,11 @@ class FieldDateTime(FieldBase):
 
 
 class FieldFlags(FieldBase):
-    keys: List[str]
 
-    def __init__(self, js):
-        super().__init__(js)
-        self.keys = js.get('keys')
-        self.length = len(self.keys)
+    def __init__(self, k, js):
+        super().__init__(k, js)
+        self.key = self.key.split(',')
+        self.length = len(self.key)
         self.bytes = math.ceil(self.length / 8)
 
     def encode(self, data):
@@ -264,23 +268,23 @@ class FieldFlags(FieldBase):
         for b in bits:
             flags.append(b == '1')
         val = {}
-        order = -len(self.keys)
-        for k in self.keys:
+        order = -len(self.key)
+        for k in self.key:
             val[k] = flags[order]
             order += 1
         return val
 
     def to_binary(self, data):
-        bits = '0' * (8 - (len(self.keys) % 8))
-        for k in self.keys:
+        bits = '0' * (8 - (len(self.key) % 8))
+        for k in self.key:
             bits += '1' if data[k] else '0'
         return int(bits, 2).to_bytes(self.bytes, 'big', signed=False)
 
 
 class FieldFloat(FieldBase):
 
-    def __init__(self, js):
-        super().__init__(js)
+    def __init__(self, k, js):
+        super().__init__(k, js)
         self.decimals = js['decimals']
 
     def from_binary(self, binary):
@@ -290,10 +294,23 @@ class FieldFloat(FieldBase):
     def to_binary(self, val):
         return int(round(val * (10 ** self.decimals))).to_bytes(self.bytes, 'big', signed=True)
 
-    def to_dict(self):
-        d = super().to_dict()
-        d['decimals'] = self.decimals
-        return d
+
+class FieldId(FieldBase):
+
+    def to_binary(self, val):
+        if val is None:
+            val = 0
+        max_value = 256 ** self.bytes - 1
+        val = min(val, max_value)
+        if val < 0:
+            raise ValueError('Negative values not allowed')
+        return int(val).to_bytes(self.bytes, 'big', signed=False)
+
+    def from_binary(self, binary):
+        val = int.from_bytes(binary[:self.bytes], 'big', signed=False)
+        if val == 0:
+            val = None
+        return val
 
 
 class FieldSigned(FieldBase):
@@ -327,8 +344,12 @@ class FieldTime(FieldBase):
 
     bytes = 2
 
-    def to_binary(self, val: datetime.datetime | str):
-        if isinstance(val, str):
+    def to_binary(self, val: datetime.datetime | datetime.time | str):
+        if val is None:
+            val = datetime.time(0, 0)
+        elif not isinstance(val, datetime.datetime) and not isinstance(val, datetime.time):
+                raise ValueError(f'Error en el campo "{self.key}" se espera un datetime o time pero se recibe {val}')
+        elif isinstance(val, str):
             val = datetime.datetime.strptime(val, '%H:%M').date()
         return bytes([
             self.to_nible(val.hour),
@@ -338,13 +359,15 @@ class FieldTime(FieldBase):
     def from_binary(self, binary):
         H, binary = self.get_nible(binary)
         M, binary = self.get_nible(binary)
+        if H == 0 and M == 0:
+            return None
         return datetime.time(H, M)
 
 
 class FieldTimestamp(FieldBase):
 
-    def __init__(self, js):
-        super().__init__(js)
+    def __init__(self, k, js):
+        super().__init__(k, js)
         self.bytes = 8
 
     def to_binary(self, val: datetime.datetime | str):
@@ -360,11 +383,11 @@ class FieldUnsigned(FieldBase):
 
     def to_binary(self, val):
         if val is None:
-            val = 0
+            raise ValueError(f'Error en el campo "{self.key}" no se permite None')
         max_value = 256 ** self.bytes - 1
         val = min(val, max_value)
         if val < 0:
-            raise ValueError('Negative values not allowed')
+            raise ValueError(f'Error en el campo "{self.key}" se espera enteros positivos y se recibió {val}')
         return int(val).to_bytes(self.bytes, 'big', signed=False)
 
     def from_binary(self, binary):
@@ -380,6 +403,7 @@ FIELD_MAP = {
     'datetime': FieldDateTime,
     'flags': FieldFlags,
     'float': FieldFloat,
+    'id': FieldId,
     'signed': FieldSigned,
     'string': FieldString,
     'time': FieldTime,

protobin-0.0.8/protobin/protocol.py

@@ -0,0 +1,76 @@
+import json
+import yaml
+from protobin.fields import FieldBase, FIELD_MAP
+
+
+class Format:
+
+    input_fields: [FieldBase]
+    output_fields: [FieldBase]
+
+    def __init__(self, name: str, format, server: bool):
+        self.name = name
+        self.input_fields = []
+        self.output_fields = []
+        self.header = format['header']
+        if server is None:
+            input_mode = 'fields'
+            output_mode = 'fields'
+        else:
+            input_mode = 'device' if server else 'server'
+            output_mode = 'server' if server else 'device'
+        for k, f in format[input_mode].items():
+            self.input_fields.append(FIELD_MAP[f['type']](k, f))
+        for k, f in format[output_mode].items():
+            self.output_fields.append(FIELD_MAP[f['type']](k, f))
+
+    def encode(self, data):
+        binary = self.header.encode('utf') + b'='
+        for f in self.output_fields:
+            binary += f.encode(data)
+        return binary
+
+    def decode(self, binary):
+        data = {}
+        for f in self.input_fields:
+            val, binary = f.decode(binary)
+            if isinstance(f.key, list):
+                for k in f.key:
+                    data[k] = val[k]
+            else:
+                data[f.key] = val
+        return data
+
+
+class Protocol:
+
+    def __init__(self, server: bool = None, file=None, js=None):
+        self.server = server
+        self.headers = {}
+        if file:
+            with open(file, 'r') as f:
+                if 'json' in file:
+                    js = json.loads(f.read())
+                    self.load_format(js)
+                elif 'yaml' in file:
+                    js = yaml.full_load(f.read())
+                    self.load_format(js)
+        else:
+            self.load_format(js)
+
+    def load_format(self, js):
+        self.formats = {}
+        for k in js.keys():
+            self.formats[k] = Format(name=k, format=js[k], server=self.server)
+            self.headers[js[k]['header']] = k
+
+    def get_format(self, h):
+        return self.formats[self.headers[h.decode('utf')]]
+
+    def encode(self, data, format):
+        return self.formats[format].encode(data)
+
+    def decode(self, binary):
+        h, binary = binary.split(b'=')
+        format = self.get_format(h)
+        return format.name, format.decode(binary)

{protobin-0.0.6 → protobin-0.0.8}/pyproject.toml

@@ -4,10 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "protobin"
-version = "0.0.6"
+version = "0.0.8"
 authors = [
     { name="Daniel Robles", email="drm.electronic@gmail.com" },
 ]
+dependencies = [
+  'PyYAML ~= 6.0'
+]
 description = "Python library for encode and decode data in protobin format"
 readme = "README.md"
 license = { file="LICENSE.txt" }

protobin-0.0.8/tests/demo.json

@@ -0,0 +1,43 @@
+{
+    "login": {
+        "header": "T",
+        "device": {
+            "serial": {"bytes": 0, "type": "string"}
+        },
+         "server": {
+            "id": {"bytes": 2, "type": "id"},
+            "bus_number": {"bytes": 2, "type": "id"},
+            "route": {"bytes": 1, "type": "id"},
+            "direction": {"bytes": 1, "type": "bool"},
+            "geofence": {"bytes": 2, "type": "id"},
+            "state": {"bytes": 1, "type": "char"},
+            "trip": {"bytes": 4, "type": "id"},
+            "driver": {"bytes": 4, "type": "id"}
+         }
+    },
+    "report": {
+        "header": "P",
+        "device": {
+            "positions": {"bytes": 19, "type": "array", "array": {
+                "time": {"bytes": 6, "type": "datetime"},
+                "lng": {"bytes": 4, "type": "float", "decimals": 6},
+                "lat": {"bytes": 4, "type": "float", "decimals": 6},
+                "speed": {"bytes": 1, "type": "unsigned"},
+                "mark": {"bytes": 2, "type": "id"},
+                "busstop": {"bytes": 2, "type": "id"}}
+            },
+            "trip": {"bytes": 4, "type": "unsigned"},
+            "route": {"bytes": 1, "type": "unsigned"},
+            "direction": {"bytes": 1, "type": "bool"},
+            "state": {"bytes": 1, "type": "char"},
+            "sales": {"bytes": 3, "type": "unsigned"},
+            "events": {"bytes": 3, "type": "array", "array": {
+                "id": {"bytes": 2, "type": "unsigned"},
+                "value": {"bytes": 1, "type": "unsigned"}}
+            }
+        },
+        "server": {
+            "positions": {"bytes":  1, "type":  "unsigned"}
+        }
+    }
+}

{protobin-0.0.6 → protobin-0.0.8}/tests/demo.yaml

@@ -1,53 +1,55 @@
 report:
-  positions:
-    bytes: 19
-    type: array
-    array:
-      time:
-        bytes: 6
-        type: datetime
-      lng:
-        bytes: 4
-        decimals: 6
-        type: float
-      lat:
-        bytes: 4
-        decimals: 6
-        type: float
-      speed:
-        bytes: 1
-        type: unsigned
-      mark:
-        bytes: 2
-        type: unsigned
-      busstop:
-        bytes: 2
-        type: unsigned
-  trip:
-    bytes: 4
-    type: unsigned
-  route:
-    bytes: 1
-    type: unsigned
-  direction:
-    bytes: 1
-    type: bool
-  state:
-    bytes: 1
-    type: char
-  sales:
-    bytes: 3
-    type: unsigned
-  events:
-    bytes: 3
-    type: array
-    array:
-      id:
-        bytes: 2
-        type: unsigned
-      value:
-        bytes: 1
-        type: unsigned
+  header: P
+  format:
+    positions:
+      bytes: 19
+      type: array
+      array:
+        time:
+          bytes: 6
+          type: datetime
+        lng:
+          bytes: 4
+          decimals: 6
+          type: float
+        lat:
+          bytes: 4
+          decimals: 6
+          type: float
+        speed:
+          bytes: 1
+          type: unsigned
+        mark:
+          bytes: 2
+          type: unsigned
+        busstop:
+          bytes: 2
+          type: unsigned
+    trip:
+      bytes: 4
+      type: unsigned
+    route:
+      bytes: 1
+      type: unsigned
+    direction:
+      bytes: 1
+      type: bool
+    state:
+      bytes: 1
+      type: char
+    sales:
+      bytes: 3
+      type: unsigned
+    events:
+      bytes: 3
+      type: array
+      array:
+        id:
+          bytes: 2
+          type: unsigned
+        value:
+          bytes: 1
+          type: unsigned
 
 ask_schedule:
   id:

{protobin-0.0.6 → protobin-0.0.8}/tests/tests.py

@@ -12,7 +12,7 @@ DATA = {
                 'lng': -11.485014,
                 'lat': -77.621845,
                 'speed': 20,
-                'mark': 0,
+                'mark': None,
                 'busstop': 16
             },
             {
@@ -20,7 +20,7 @@ DATA = {
                 'lng': -11.485414,
                 'lat': -77.622245,
                 'speed': 25,
-                'mark': 0,
+                'mark': None,
                 'busstop': 16
             },
             {
@@ -28,7 +28,7 @@ DATA = {
                 'lng': -11.485514,
                 'lat': -77.621945,
                 'speed': 18,
-                'mark': 0,
+                'mark': None,
                 'busstop': 16
             },
             {
@@ -62,73 +62,69 @@ DATA = {
     }
 
 
-class FormatTest(unittest.TestCase):
-
-    def test_format_array(self):
-        parser = Protocol(js={
-            'array': [{'key': 'test', 'bytes': 0, 'type': 'array', 'array': [
-                {'key': 'test', 'bytes': 0, 'type': 'string'}
-            ]}]
-        })
-
-    def test_format_bits(self):
-        parser = Protocol(js={
-            'bits': [{'key': 'test', 'bytes': 2, 'type': 'bits'}],
-        })
-
-    def test_format_date(self):
-
-        self.parser = Protocol(js={
-            'date': [{'key': 'test', 'bytes': 1, 'type': 'date'}],
-        })
-
-    def test_format_flags(self):
-
-        self.parser = Protocol(js={
-            'flags': [{'keys': ['f1', 'f2', 'f3', 'f4'], 'bytes': 1, 'type': 'flags'}],
-        })
-
-    def test_format(self):
-
-        self.parser = Protocol(js={
-            'array': [{'key': 'test', 'bytes': 0, 'type': 'array', 'array': [
-                {'key': 'test', 'bytes': 0, 'type': 'string'}
-            ]}],
-            'bits': [{'key': 'test', 'bytes': 2, 'type': 'bits'}],
-            'bool': [{'key': 'test', 'bytes': 1, 'type': 'bool'}],
-            'char': [{'key': 'test', 'bytes': 1, 'type': 'char'}],
-            'date': [{'key': 'test', 'bytes': 3, 'type': 'date'}],
-            'datetime': [{'key': 'test', 'bytes': 6, 'type': 'datetime'}],
-            'flags': [{'keys': ['f1', 'f2', 'f3', 'f4'], 'bytes': 1, 'type': 'flags'}],
-            'float': [{'key': 'test', 'bytes': 4, 'decimals': 6, 'type': 'float'}],
-            'signed': [{'key': 'test', 'bytes': 2, 'type': 'signed'}],
-            'string': [{'key': 'test', 'bytes': 0, 'type': 'string'}],
-            'time': [{'key': 'test', 'bytes': 1, 'type': 'time'}],
-            'timestamp': [{'key': 'test', 'bytes': 8, 'type': 'string'}],
-            'unsigned': [{'key': 'test', 'bytes': 3, 'type': 'unsigned'}]
-        })
-
-
 class BasicTest(unittest.TestCase):
 
     def setUp(self):
         self.protocol = Protocol(js={
-            'array': [{'key': 'test', 'bytes': 0, 'type': 'array', 'array': [
-                {'key': 'test', 'bytes': 0, 'type': 'string'}
-            ]}],
-            'bits': [{'key': 'test', 'type': 'bits'}],
-            'bits_fixed': [{'key': 'test', 'type': 'bits', 'length': 7}],
-            'bool': [{'key': 'test', 'bytes': 1, 'type': 'bool'}],
-            'char': [{'key': 'test', 'bytes': 1, 'type': 'char'}],
-            'date': [{'key': 'test', 'bytes': 1, 'type': 'date'}],
-            'datetime': [{'key': 'test', 'bytes': 1, 'type': 'datetime'}],
-            'flags': [{'keys': ['f1', 'f2', 'f3', 'f4'], 'type': 'flags'}],
-            'float': [{'key': 'test', 'bytes': 4, 'decimals': 6, 'type': 'float'}],
-            'signed': [{'key': 'test', 'bytes': 2, 'type': 'signed'}],
-            'string': [{'key': 'test', 'bytes': 0, 'type': 'string'}],
-            'time': [{'key': 'test', 'bytes': 2, 'type': 'time'}],
-            'timestamp': [{'key': 'test', 'bytes': 8, 'type': 'timestamp'}],
-            'unsigned': [{'key': 'test', 'bytes': 3, 'type': 'unsigned'}]
+            'array': {
+                "header": "A",
+                "fields": {
+                    'test': {'bytes': 0, 'type': 'array', 'array': {
+                        'test': {'bytes': 0, 'type': 'string'}
+                    }}}
+            },
+            'bits': {
+                "header": "B",
+                "fields": {'test': {'type': 'bits'}}
+            },
+            'bits_fixed': {
+                "header": "b",
+                "fields": {'test': {'type': 'bits', 'length': 7}}
+            },
+            'bool': {
+                "header": "BO",
+                "fields": {'test': {'bytes': 1, 'type': 'bool'}}
+            },
+            'char': {
+                "header": "C",
+                "fields": {'test': {'bytes': 1, 'type': 'char'}}
+            },
+            'date': {
+                "header": "D",
+                "fields": {'test': {'bytes': 1, 'type': 'date'}}
+            },
+            'datetime': {
+                "header": "d",
+                "fields": {'test': {'bytes': 1, 'type': 'datetime'}}
+            },
+            'flags': {
+                "header": "F",
+                "fields": {'f1,f2,f3,f4': {'type': 'flags'}}
+            },
+            'float': {
+                "header": "f",
+                "fields": {'test': {'bytes': 4, 'decimals': 6, 'type': 'float'}}
+            },
+            'signed': {
+                "header": "+",
+                "fields": {'test': {'bytes': 2, 'type': 'signed'}}
+            },
+            'string': {
+                "header": "S",
+                "fields": {'test': {'bytes': 0, 'type': 'string'}}
+            },
+            'time': {
+                "header": "T",
+                "fields": {'test': {'bytes': 2, 'type': 'time'}}
+            },
+            'timestamp': {
+                "header": "TS",
+                "fields": {'test': {'bytes': 8, 'type': 'timestamp'}}
+            },
+            'unsigned': {
+                "header": "u",
+                "fields": {'test': {'bytes': 3, 'type': 'unsigned'}}
+            }
         })
 
     def test_array(self):
@@ -138,7 +134,7 @@ class BasicTest(unittest.TestCase):
             {'test': 'otra más'}]
         }
         binary = self.protocol.encode(data, 'array')
-        recv = self.protocol.decode(binary, 'array')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
         data = {'test': [
             {'test': 'texto2 de prueba'},
@@ -147,123 +143,155 @@ class BasicTest(unittest.TestCase):
             {'test': 'y una última'}]
         }
         binary = self.protocol.encode(data, 'array')
-        recv = self.protocol.decode(binary, 'array')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_bits(self):
         data = {'test': [True, False, True, False, False] * 3}
         binary = self.protocol.encode(data, 'bits')
-        recv = self.protocol.decode(binary, 'bits')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
         data = {'test': [True, False, True, False, False] * 5}
         binary = self.protocol.encode(data, 'bits')
-        recv = self.protocol.decode(binary, 'bits')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_bits_fixed(self):
         data = {'test': [True, False, True, False, False, True, True]}
         binary = self.protocol.encode(data, 'bits_fixed')
-        recv = self.protocol.decode(binary, 'bits_fixed')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_bool(self):
         data = {'test': False}
         binary = self.protocol.encode(data, 'bool')
-        recv = self.protocol.decode(binary, 'bool')
+        h, recv = self.protocol.decode(binary)
+        self.assertEqual(data, recv)
+
+    def test_bool_none(self):
+        data = {'test': None}
+        binary = self.protocol.encode(data, 'bool')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_char(self):
         data = {'test': 'F'}
         binary = self.protocol.encode(data, 'char')
-        recv = self.protocol.decode(binary, 'char')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_date(self):
         data = {'test': datetime.date(2024, 9, 13)}
         binary = self.protocol.encode(data, 'date')
-        recv = self.protocol.decode(binary, 'date')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_datetime(self):
         data = {'test': datetime.datetime(2024, 9, 13, 15, 23, 51)}
         binary = self.protocol.encode(data, 'datetime')
-        recv = self.protocol.decode(binary, 'datetime')
+        print('binary', binary)
+        h, recv = self.protocol.decode(binary)
+        print('recv', recv)
         self.assertEqual(data, recv)
 
+    def test_datetime_error_type(self):
+        data = {'test': []}
+        with self.assertRaises(ValueError) as er:
+            self.protocol.encode(data, 'datetime')
+
+    def test_datetime_none(self):
+        data = {'test': None}
+        binary = self.protocol.encode(data, 'datetime')
+        print('binary', binary)
+        h, recv = self.protocol.decode(binary)
+        print('recv', recv)
+        self.assertEqual(datetime.datetime(2000, 1, 1), recv['test'])
+
     def test_time(self):
         data = {'test': datetime.time(15, 23)}
         binary = self.protocol.encode(data, 'time')
-        recv = self.protocol.decode(binary, 'time')
+        h, recv = self.protocol.decode(binary)
+        self.assertEqual(data, recv)
+
+    def test_time_none(self):
+        data = {'test': None}
+        binary = self.protocol.encode(data, 'time')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_flags(self):
         data = {'f1': True, 'f2': False, 'f3': False, 'f4': True}
         binary = self.protocol.encode(data, 'flags')
-        recv = self.protocol.decode(binary, 'flags')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_float(self):
         data = {'test': -11.659812}
         binary = self.protocol.encode(data, 'float')
-        recv = self.protocol.decode(binary, 'float')
+        print(binary)
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_signed(self):
         data = {'test': -11812}
         binary = self.protocol.encode(data, 'signed')
-        recv = self.protocol.decode(binary, 'signed')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_unsigned(self):
         data = {'test': 9811812}
         binary = self.protocol.encode(data, 'unsigned')
-        recv = self.protocol.decode(binary, 'unsigned')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_string(self):
         data = {'test': 'texto de prueba'}
         binary = self.protocol.encode(data, 'string')
-        recv = self.protocol.decode(binary, 'string')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
         data = {'test': 'otro texto de prueba más largo'}
         binary = self.protocol.encode(data, 'string')
-        recv = self.protocol.decode(binary, 'string')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_timestamp(self):
         data = {'test': datetime.datetime(2024, 9, 13, 15, 23, 51, 265981)}
         binary = self.protocol.encode(data, 'timestamp')
-        recv = self.protocol.decode(binary, 'timestamp')
+        h, recv = self.protocol.decode(binary)
         self.assertEqual(data, recv)
 
 
 class AdvancedTest(unittest.TestCase):
 
     def test_file_json(self):
-        protocol = Protocol(file='demo.json')
-        binary = protocol.encode(DATA, 'report')
-        recv = protocol.decode(binary, 'report')
+        device = Protocol(file='demo.json', server=False)
+        binary = device.encode(DATA, 'report')
+        server = Protocol(file='demo.json', server=True)
+        name, recv = server.decode(binary)
         self.assertEqual(DATA, recv)
+        self.assertEqual(name, 'report')
 
-    def test_file_yaml(self):
-        protocol = Protocol(file='demo.yaml')
-        binary = protocol.encode(DATA, 'report')
-        recv = protocol.decode(binary, 'report')
-        self.assertEqual(DATA, recv)
+    # def test_file_yaml(self):
+    #     protocol = Protocol(file='demo.yaml')
+    #     binary = protocol.encode(DATA, 'report')
+    #     h, recv = protocol.decode(binary)
+    #     self.assertEqual(h, 'P')
 
     def test_json(self):
-        protocol = Protocol(js={'medida': [
-                {'key': 'id', 'bytes': 1, 'type': 'unsigned'},
-                {'key': 'nombre', 'type': 'string'},
-                {'key': 'valor', 'bytes': 2, 'type': 'signed'}
-            ]})
+        protocol = Protocol(js={'medida':
+            {'header': 'M',
+             'fields': {
+                'id': {'bytes': 1, 'type': 'unsigned'},
+                'nombre': {'type': 'string'},
+                'valor': {'bytes': 2, 'type': 'signed'}
+             }}})
         data = {'id': 2, 'nombre': 'Voltaje', 'valor': -20}
         binary = protocol.encode(data, 'medida')
-        recv = protocol.decode(binary, 'medida')
+        h, recv = protocol.decode(binary)
         self.assertEqual(data, recv)
         data = {'id': 4, 'nombre': 'Corriente', 'valor': 240}
         binary = protocol.encode(data, 'medida')
-        recv = protocol.decode(binary, 'medida')
+        h, recv = protocol.decode(binary)
         self.assertEqual(data, recv)
 
     def test_new_yaml(self):
@@ -319,8 +347,29 @@ class AdvancedTest(unittest.TestCase):
         type: unsigned
 """)
         js = json.dumps(ym, indent=2)
-        print(js)
 
     def test_convert_json_to_yaml(self):
-        protocol = Protocol(file='demo.json')
-
+        protocol = Protocol(file='demo.json', server=True)
+
+    def test_login(self):
+        device = Protocol(file='demo.json', server=False)
+        server = Protocol(file='demo.json', server=True)
+        data = {'serial': '15984316545'}
+        binary = device.encode(data, 'login')
+        header, recv = server.decode(binary)
+        self.assertEqual(header, 'login')
+        self.assertEqual(data, recv)
+        data = {
+            'id': 43,
+            'bus_number': 18,
+            'route': 2,
+            'direction': True,
+            'geofence': None,
+            'state': 'R',
+            'trip': 5681121,
+            'driver': 1432
+        }
+        binary = server.encode(data, 'login')
+        header, recv = device.decode(binary)
+        self.assertEqual(header, 'login')
+        self.assertEqual(data, recv)

protobin-0.0.6/protobin/protocol.py

@@ -1,62 +0,0 @@
-import json
-
-import yaml
-
-from protobin.fields import FieldBase, FIELD_MAP
-
-
-class Format:
-
-    fields: [FieldBase]
-
-    def __init__(self, fields: [object]):
-        self.fields = []
-        for f in fields:
-            self.fields.append(FIELD_MAP[f['type']](f))
-
-    def encode(self, data):
-        binary = b''
-        for f in self.fields:
-            binary += f.encode(data)
-        return binary
-
-    def decode(self, binary):
-        data = {}
-        for f in self.fields:
-            val, binary = f.decode(binary)
-            if f.key:
-                data[f.key] = val
-            else:
-                for k in f.keys:
-                    data[k] = val[k]
-        return data
-
-    def to_dict(self):
-        return [f.to_dict() for f in self.fields]
-
-
-class Protocol:
-
-    def __init__(self, file=None, js=None):
-        if file:
-            with open(file, 'r') as f:
-                if 'json' in file:
-                    js = json.loads(f.read())
-                    self.formats = {}
-                    for k in js.keys():
-                        self.formats[k] = Format(js[k])
-                elif 'yaml' in file:
-                    js = yaml.full_load(f.read())
-                    self.formats = {}
-                    for k in js.keys():
-                        self.formats[k] = Format(js[k])
-
-
-    def temp_format(self, k):
-        return self.formats[k].to_dict()
-
-    def encode(self, data, format):
-        return self.formats[format].encode(data)
-
-    def decode(self, binary, format):
-        return self.formats[format].decode(binary)

protobin-0.0.6/tests/demo.json

@@ -1,291 +0,0 @@
-{
-    "ask_schedule1": {
-        "id": [{"bytes": 4, "type": "unsigned"}],
-        "inicio": [{"bytes": 6, "type": "datetime"}]},
-
-    "fare": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "color", "bytes": 7, "type": "string"},
-        {"key": "orden", "bytes": 1, "type": "unsigned"},
-        {"key": "nombre", "bytes": 13, "type": "string"},
-        {"keys": ["activo", "reintegro"], "bytes": 1, "type": "flags"},
-        {"keys": ["lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo", "feriado"], "bytes": 1, "type": "flags"},
-        {"key": "ruta", "bytes": 2, "type": "unsigned"},
-        {"key": "tarifa", "bytes": 2, "type": "float", "decimals": 2},
-        {"key": "timestamp", "bytes": 6, "type": "datetime"}
-    ],
-    "command": [
-        {"key": "comando", "bytes": 1, "type": "char"},
-        {"key": "id", "bytes": 0, "type": "string"},
-        {"key": "value", "bytes": 0, "type": "string"}
-    ],
-    "route_settings": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "nombre", "bytes": 0, "type": "string"},
-        {"key": "ruta", "bytes": 1, "type": "unsigned"},
-        {"key": "tipo", "bytes": 0, "type": "string"},
-        {"key": "data", "bytes": 0, "type": "string"},
-        {"key": "timestamp", "bytes": 6, "type": "datetime"}
-    ],
-    "forward_datero": [
-        {"key": "geocerca", "bytes": 2, "type": "unsigned"},
-        {"key": "salida", "bytes": 4, "type": "unsigned"},
-        {"key": "hora", "bytes": 6, "type": "datetime"},
-        {"key": "dateros", "bytes": 0, "type": "array", "array": [
-            {"key": "padron", "bytes": 2, "type": "unsigned"},
-            {"key": "delta", "bytes": 1, "type": "unsigned"}
-        ]}
-    ],
-    "backward_datero": [
-        {"key": "geocerca", "bytes": 2, "type": "unsigned"},
-        {"key": "i", "bytes": 1, "type": "unsigned"},
-        {"key": "delta", "bytes": 1, "type": "unsigned"},
-        {"key": "padron", "bytes": 2, "type": "unsigned"},
-        {"key": "id", "bytes": 0, "type": "string"}
-    ],
-    "error": [
-        {"key": "error", "bytes": 0, "type": "string"}
-    ],
-    "geocerca": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "orden", "bytes": 1, "type": "unsigned"},
-        {"key": "longitud", "bytes": 4, "type": "float", "decimals": 6},
-        {"key": "latitud", "bytes": 4, "type": "float", "decimals": 6},
-        {"key": "radio", "bytes": 2, "type": "unsigned"},
-        {"key": "ruta", "bytes": 1, "type": "unsigned"},
-        {"keys": ["lado", "control", "datear", "activo"], "bytes": 1, "type": "flags"},
-        {"key": "nombre", "bytes": 15, "type": "string"},
-        {"key": "timestamp", "bytes": 6, "type": "datetime"}
-    ],
-    "ask_trip": [
-        {"key": "salida", "bytes": 4, "type": "unsigned"}
-    ],
-    "schedule": [
-        {"key": "salida", "bytes": 4, "type": "unsigned"},
-        {"key": "controles", "bytes": 0, "type": "array", "array": [
-            {"key": "geocerca", "bytes": 2, "type": "unsigned"}
-        ]}
-    ],
-    "ask_schedule": [
-        {"key": "id", "bytes": 4, "type": "unsigned"},
-        {"key": "inicio", "bytes": 6, "type": "datetime"},
-        {"key": "controles", "bytes": 0, "type": "array", "array": [
-            {"key": "geocerca", "bytes": 2, "type": "unsigned"},
-            {"key": "tiempo", "bytes": 1, "type": "signed"},
-            {"key": "volada", "bytes": 1, "type": "signed"}
-        ]}
-    ],
-    "login": [
-        {"key": "serial", "bytes": 0, "type": "string"}
-    ],
-    "new_ip": [
-        {"key": "ip", "bytes": 0, "type": "string"}
-    ],
-    "login_device": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "padron", "bytes": 2, "type": "unsigned"},
-        {"key": "ruta", "bytes": 1, "type": "unsigned"},
-        {"key": "lado", "bytes": 1, "type": "bool"},
-        {"key": "geocerca", "bytes": 2, "type": "unsigned"},
-        {"key": "estado", "bytes": 1, "type": "char"},
-        {"key": "salida", "bytes": 4, "type": "unsigned"},
-        {"key": "conductor", "bytes": 4, "type": "unsigned"},
-        {"key": "orden", "bytes": 1, "type": "unsigned"},
-        {"key": "logueado", "bytes": 1, "type": "bool"},
-        {"key": "data", "bytes": 6, "type": "datetime"},
-        {"key": "programada", "bytes": 2, "type": "time"}
-    ],
-    "start_sales": [
-        {"key": "clave", "bytes": 0, "type": "string"},
-        {"key": "dni", "bytes": 0, "type": "string"},
-        {"key": "lado", "bytes": 1, "type": "bool"},
-        {"key": "ruta", "bytes": 1, "type": "unsigned"},
-        {"key": "unidad", "bytes": 2, "type": "unsigned"}
-    ],
-    "start_sales_response": [
-        {"key": "error", "bytes": 1, "type": "bool"},
-        {"key": "title", "bytes": 0, "type": "string"},
-        {"key": "mensaje", "bytes": 0, "type": "string"},
-        {"key": "sesiones", "bytes": 0, "type": "array", "array": [
-            {"key": "id", "bytes": 4, "type": "unsigned"},
-            {"key": "conductor_id", "bytes": 2, "type": "unsigned"},
-            {"key": "conductor_codigo", "bytes": 0, "type": "string"},
-            {"keys": ["activo", "castigado", "conductor", "vencido"], "bytes": 1, "type": "flags"},
-            {"key": "ruta", "bytes": 1, "type": "unsigned"},
-            {"key": "lado", "bytes": 1, "type": "bool"},
-            {"key": "inicio", "bytes": 6, "type": "datetime"}
-        ]}
-    ],
-    "finalize_sales": [
-        {"key": "sesion", "bytes": 4, "type": "unsigned"},
-        {"key": "unidad", "bytes": 2, "type": "unsigned"},
-        {"key": "fin", "bytes": 6, "type": "datetime"},
-        {"key": "produccion", "bytes": 4, "type": "unsigned"},
-        {"key": "primero", "bytes": 4, "type": "unsigned"},
-        {"key": "ultimo", "bytes": 4, "type": "unsigned"}
-    ],
-    "finalize_sales_response": [
-        {"key": "error", "bytes": 1, "type": "bool"},
-        {"key": "title", "bytes": 0, "type": "string"},
-        {"key": "mensaje", "bytes": 0, "type": "string"},
-        {"key": "id", "bytes": 4, "type": "unsigned"}
-    ],
-    "message": [
-        {"key": "id", "bytes": 4, "type": "unsigned"},
-        {"key": "texto", "bytes": 0, "type": "string"}
-    ],
-    "message_response": [
-        {"key": "id", "bytes": 4, "type": "unsigned"},
-        {"key": "read", "bytes": 1, "type": "bool"}
-    ],
-    "operation": [
-        {"key": "id", "bytes": 0, "type": "string"},
-        {"key": "section", "bytes": 0, "type": "string"},
-        {"key": "key", "bytes": 0, "type": "string"},
-        {"key": "value", "bytes": 0, "type": "string"}
-    ],
-    "operation_response": [
-        {"key": "id", "bytes": 0, "type": "string"}
-    ],
-    "busstop": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "orden", "bytes": 1, "type": "unsigned"},
-        {"key": "longitud", "bytes": 4, "type": "float", "decimals": 6},
-        {"key": "latitud", "bytes": 4, "type": "float", "decimals": 6},
-        {"key": "radio", "bytes": 2, "type": "unsigned"},
-        {"key": "ruta", "bytes": 1, "type": "unsigned"},
-        {"keys": ["liquidar", "lado", "terminal", "activo"], "bytes": 1, "type": "flags"},
-        {"key": "nombre", "bytes": 14, "type": "string"},
-        {"key": "velocidad", "bytes": 1, "type": "unsigned"},
-        {"key": "tarifas", "bytes": 0, "type": "array", "array": [
-            {"key": "boleto", "bytes": 2, "type": "unsigned"},
-            {"key": "fin", "bytes": 2, "type": "unsigned"}
-        ]},
-        {"key": "timestamp", "bytes": 6, "type": "datetime"}
-    ],
-    "parameter": [
-        {"key": "id", "bytes": 0, "type": "string"},
-        {"key": "nombre", "bytes": 0, "type": "string"},
-        {"key": "valor", "bytes": 0, "type": "string"}
-    ],
-    "report": [
-        {"key": "positions", "bytes": 19, "type": "array", "array": [
-            {"key": "time", "bytes": 6, "type": "datetime"},
-            {"key": "lng", "bytes": 4, "type": "float", "decimals": 6},
-            {"key": "lat", "bytes": 4, "type": "float", "decimals": 6},
-            {"key": "speed", "bytes": 1, "type": "unsigned"},
-            {"key": "mark", "bytes": 2, "type": "unsigned"},
-            {"key": "busstop", "bytes": 2, "type": "unsigned"}
-        ]},
-        {"key": "trip", "bytes": 4, "type": "unsigned"},
-        {"key": "route", "bytes": 1, "type": "unsigned"},
-        {"key": "direction", "bytes": 1, "type": "bool"},
-        {"key": "state", "bytes": 1, "type": "char"},
-        {"key": "sales", "bytes": 3, "type": "unsigned"},
-        {"key": "events", "bytes": 3, "type": "array", "array": [
-            {"key": "id", "bytes": 2, "type": "unsigned"},
-            {"key": "value", "bytes": 1, "type": "unsigned"}
-        ]}
-    ],
-    "report": {
-        "positions": {"bytes": 19,"type": "array",
-          "array": {
-            "time": {"bytes": 6,"type": "datetime"},
-            "lng": {"bytes": 4,"decimals": 6,"type": "float"},
-            "lat": {"bytes": 4,"decimals": 6,"type": "float"},
-            "speed": {"bytes": 1,"type": "unsigned"},
-            "mark": {"bytes": 2,"type": "unsigned"},
-            "busstop": {"bytes": 2,"type": "unsigned"}
-          }
-        },
-        "trip": {"bytes": 4,"type": "unsigned"},
-        "route": {"bytes": 1,"type": "unsigned"},
-        "direction": {"bytes": 1,"type": "bool"},
-        "state": {"bytes": 1,"type": "char"},
-        "sales": {"bytes": 3,"type": "unsigned"},
-        "events": {"bytes": 3,"type": "array",
-            "array": {
-                "id": {"bytes": 2,"type": "unsigned"},
-                "value": {"bytes": 1,"type": "unsigned"}
-          }
-        }
-    },
-    "position_response": [
-        {"key": "reportes", "bytes": 1, "type": "unsigned"},
-        {"key": "ids", "bytes": 0, "type": "array", "array": [
-            {"key": "id", "bytes": 2, "type": "unsigned"}
-        ]}
-    ],
-    "route": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "codigo", "bytes": 0, "type": "string"},
-        {"key": "timestamp", "bytes": 6, "type": "datetime"}
-    ],
-    "trip": [
-        {"key": "id", "bytes": 4, "type": "unsigned"},
-        {"key": "ruta", "bytes": 1, "type": "unsigned"},
-        {"key": "lado", "bytes": 1, "type": "bool"},
-        {"key": "inicio", "bytes": 6, "type": "datetime"},
-        {"key": "estado", "bytes": 1, "type": "char"},
-        {"key": "frecuencia", "bytes": 1, "type": "unsigned"},
-        {"key": "conductor", "bytes": 4, "type": "unsigned"},
-        {"key": "geocerca", "bytes": 2, "type": "unsigned"},
-        {"key": "controles", "bytes": 0, "type": "array", "array": [
-            {"key": "geocerca", "bytes": 2, "type": "unsigned"},
-            {"key": "tiempo", "bytes": 1, "type": "signed"},
-            {"key": "volada", "bytes": 1, "type": "signed"}
-        ]},
-        {"key": "marcados", "bytes": 0, "type": "bits"}
-    ],
-    "settings": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "nombre", "bytes": 0, "type": "string"},
-        {"key": "tipo", "bytes": 0, "type": "string"},
-        {"key": "data", "bytes": 0, "type": "string"},
-        {"key": "timestamp", "bytes": 6, "type": "datetime"}
-    ],
-    "tickets": [
-        {"key": "tickets", "bytes": 0, "type": "array", "array": [
-            {"key": "boleto", "bytes": 2, "type": "unsigned"},
-            {"key": "conductor", "bytes": 2, "type": "unsigned"},
-            {"key": "correlativo", "bytes": 4, "type": "unsigned"},
-            {"key": "dia", "bytes": 3, "type": "date"},
-            {"key": "fin", "bytes": 2, "type": "unsigned"},
-            {"key": "hora", "bytes": 6, "type": "datetime"},
-            {"key": "inicio", "bytes": 4, "type": "unsigned"},
-            {"key": "inspector", "bytes": 2, "type": "unsigned"},
-            {"key": "medio_pago", "bytes": 1, "type": "unsigned"},
-            {"key": "numero", "bytes": 4, "type": "unsigned"},
-            {"key": "precio", "bytes": 2, "type": "unsigned"},
-            {"key": "ruta", "bytes": 1, "type": "unsigned"},
-            {"key": "sesion", "bytes": 4, "type": "unsigned"},
-            {"key": "unidad", "bytes": 2, "type": "unsigned"},
-            {"key": "tarjeta", "bytes": 0, "type": "string"}
-        ]}
-    ],
-    "tickets_response": [
-        {"key": "tickets", "bytes": 0, "type": "array", "array": [
-            {"key": "correlativo", "bytes": 4, "type": "unsigned"},
-            {"key": "id", "bytes": 0, "type": "string"}
-        ]}
-    ],
-    "timestamp": [
-        {"key": "timestamp", "bytes": 6, "type": "timestamp"}
-    ],
-    "timestamp_us": [
-        {"key": "timestamp", "bytes": 8, "type": "timestamp"}
-    ],
-    "remaining_data": [
-        {"key": "faltantes", "bytes": 4, "type": "unsigned"},
-        {"key": "tabla", "bytes": 1, "type": "char"}
-    ],
-    "user_route": [
-        {"key": "id", "bytes": 2, "type": "unsigned"},
-        {"key": "celular", "bytes": 9, "type": "string"},
-        {"key": "nombre", "bytes": 14, "type": "string"},
-        {"key": "rutas", "bytes": 1, "type": "array", "array": [
-            {"key": "ruta", "bytes": 1, "type": "unsigned"}
-        ]},
-        {"key": "timestamp", "bytes": 6, "type": "datetime"}
-    ]
-}