protobin 0.0.5__tar.gz → 0.0.7__tar.gz

{protobin-0.0.5 → protobin-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: protobin
-Version: 0.0.5
+Version: 0.0.7
 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

{protobin-0.0.5 → protobin-0.0.7}/protobin/fields.py

@@ -27,9 +27,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):
@@ -88,8 +88,8 @@ class FieldBase:
 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):
@@ -108,7 +108,7 @@ class FieldArray(FieldBase):
         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 +117,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 +128,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 +177,21 @@ class FieldBool(FieldBase):
     bytes = 1
 
     def to_binary(self, val):
+        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 +208,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 +230,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 +261,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 +278,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):
@@ -327,8 +341,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 +356,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):

protobin-0.0.7/protobin/protocol.py

@@ -0,0 +1,69 @@
+import json
+
+import yaml
+
+from protobin.fields import FieldBase, FIELD_MAP
+
+
+class Format:
+
+    fields: [FieldBase]
+
+    def __init__(self, format: [object]):
+        self.fields = []
+        self.header = format['header']
+        for k, f in format['fields'].items():
+            self.fields.append(FIELD_MAP[f['type']](k, f))
+
+    def encode(self, data):
+        binary = self.header.encode('utf') + 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 isinstance(f.key, list):
+                for k in f.key:
+                    data[k] = val[k]
+            else:
+                data[f.key] = val
+        return data
+
+    def to_dict(self):
+        return [f.to_dict() for f in self.fields]
+
+
+class Protocol:
+
+    def __init__(self, file=None, js=None):
+        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(js[k])
+            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 h.decode('utf'), format.decode(binary)

{protobin-0.0.5 → protobin-0.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "protobin"
-version = "0.0.5"
+version = "0.0.7"
 authors = [
     { name="Daniel Robles", email="drm.electronic@gmail.com" },
 ]

protobin-0.0.7/tests/demo.json

@@ -0,0 +1,30 @@
+{
+    "login": {
+        "header": "T",
+        "fields": {
+            "serial": {"bytes": 0, "type": "string"}
+        }
+    },
+    "report": {
+        "header": "P",
+        "fields": {
+            "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": "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"}}
+            }
+        }
+    }
+}