ltcodecs 0.2.0__tar.gz → 1.0.0__tar.gz

{ltcodecs-0.2.0 → ltcodecs-1.0.0}/PKG-INFO

@@ -1,18 +1,18 @@
-Metadata-Version: 2.1
-Name: ltcodecs
-Version: 0.2.0
-Summary: LT Codecs
-Home-page: https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
-Author: whoi
-Author-email: egallimore@whoi.edu
-Project-URL: Bug Tracker, https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# LT Codecs
-
-The package was original part of ros_acomms under the field_codecs directory. 
+Metadata-Version: 2.1
+Name: ltcodecs
+Version: 1.0.0
+Summary: LT Codecs
+Home-page: https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
+Author: whoi
+Author-email: egallimore@whoi.edu
+Project-URL: Bug Tracker, https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# LT Codecs
+
+The package was original part of ros_acomms under the field_codecs directory. 

{ltcodecs-0.2.0 → ltcodecs-1.0.0}/setup.cfg

@@ -1,30 +1,30 @@
-[metadata]
-name = ltcodecs
-version = 0.2.0
-author = whoi
-author_email = egallimore@whoi.edu
-description = LT Codecs
-long_description = file: README.md
-long_description_content_type = text/markdown
-url = https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
-project_urls = 
-	Bug Tracker = https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
-classifiers = 
-	Programming Language :: Python :: 3
-	License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
-	Operating System :: OS Independent
-
-[options]
-package_dir = 
-	= src
-packages = find:
-python_requires = >=3.6
-include_package_data = True
-
-[options.packages.find]
-where = src
-
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[metadata]
+name = ltcodecs
+version = 1.0.0
+author = whoi
+author_email = egallimore@whoi.edu
+description = LT Codecs
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
+project_urls = 
+	Bug Tracker = https://git.whoi.edu/acomms/ros_acomms/tree/master/src/acomms_codecs
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+	Operating System :: OS Independent
+
+[options]
+package_dir = 
+	= src
+packages = find:
+python_requires = >=3.6
+include_package_data = True
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

ltcodecs-1.0.0/src/ltcodecs/__init__.py

@@ -0,0 +1,67 @@
+from .varint_codec import VarintCodec
+from .fixedint_codec import FixedIntCodec
+from .fixedint_codec import Int8Codec, Int16Codec, Int32Codec, Int64Codec
+from .fixedint_codec import UInt8Codec, UInt16Codec, UInt32Codec, UInt64Codec
+from .float_codec import FloatCodec
+from .linspace_float_codec import LinspaceFloatCodec
+from .ieee_float_codec import IeeeFloat32Codec, IeeeFloat64Codec
+from .bool_codec import BoolCodec
+from .string_codecs import AsciiStringCodec
+from .string_enum_codec import StringEnumCodec
+from .bytes_codec import BytesCodec
+from .variable_len_array_codec import VariableLenArrayCodec
+from .fixed_len_array_codec import FixedLenArrayCodec
+from .ros_msg_field_codec import RosMsgFieldCodec
+from .ccl_latlon_codec import CclLatLonCodec
+from .ccl_latlon_bcd_codec import CclLatLonBcdCodec
+from .padding_codec import PaddingCodec
+from .rostime_codec import RosTimeCodec
+from .ros_message_codec import RosMessageCodec
+from .lzma_codec import LzmaCodec
+from .exceptions import EncodingFailed
+
+field_codec_classes = {
+    "integer": VarintCodec,
+    "fixedint": FixedIntCodec,
+    "varint": VarintCodec,
+    "float": FloatCodec,
+    "linspace_float": LinspaceFloatCodec,
+    "linspace": LinspaceFloatCodec,
+    "uint8": UInt8Codec,
+    "uint16": UInt16Codec,
+    "uint32": UInt32Codec,
+    "uint64": UInt64Codec,
+    "int8": Int8Codec,
+    "int16": Int16Codec,
+    "int32": Int32Codec,
+    "int64": Int64Codec,
+    "float32": IeeeFloat32Codec,
+    "float64": IeeeFloat64Codec,
+    "bool": BoolCodec,
+    "string": AsciiStringCodec,
+    "ascii": AsciiStringCodec,
+    "bytes": BytesCodec,
+    "msg": RosMsgFieldCodec,
+    "ros_msg": RosMsgFieldCodec,
+    "variable_len_array": VariableLenArrayCodec,
+    "fixed_len_array": FixedLenArrayCodec,
+    "ccl_latlon": CclLatLonCodec,
+    "ccl_latlon_bcd": CclLatLonBcdCodec,
+    "pad": PaddingCodec,
+    "padding": PaddingCodec,
+    "time": RosTimeCodec,
+    "rostime": RosTimeCodec,
+    "string_enum": StringEnumCodec,
+    "lzma": LzmaCodec,
+}
+
+metadata_decoders = {
+    "src": "packet.src",
+    "dest": "packet.dest",
+    "dest_decoder": "packet.dest",
+    "toa": "cst.toa",
+    "snr_in": "cst.snr_in",
+}
+
+
+metadata_encoders = {"dest": "packet.dest"}

ltcodecs-1.0.0/src/ltcodecs/bool_codec.py

@@ -0,0 +1,47 @@
+"""
+ltcodecs.bool_codec
+---------------------
+
+This module contains the BoolCodec class, which is used to encode and decode bools.
+"""
+
+from __future__ import annotations
+from bitstring import BitArray, ConstBitStream, Bits
+from .field_codec import FieldCodec
+
+
+class BoolCodec(FieldCodec):
+    """
+    codec for bools
+    """
+
+    def __init__(self, **kwargs) -> None:
+        pass
+
+    def encode(self, value: bool) -> tuple[Bits, bool]:
+        """
+        encode a bool
+
+        :param value: the bool to encode
+        """
+        value = bool(value)
+        value_bits = BitArray(bool=value)
+        return value_bits, value
+
+    def decode(self, bits_to_decode: ConstBitStream) -> bool:
+        """
+        decode a bool
+
+        :param bits_to_decode: the bits to decode
+        """
+
+        value = bits_to_decode.read("bool")
+        return value
+
+    @property
+    def min_length_bits(self) -> int:
+        return 1
+
+    @property
+    def max_length_bits(self) -> int:
+        return 1

ltcodecs-1.0.0/src/ltcodecs/bytes_codec.py

@@ -0,0 +1,57 @@
+"""
+ltcodecs.bytes_codec
+---------------------
+
+This module contains the BytesCodec class, which is used to encode and decode bytes.
+"""
+
+from __future__ import annotations
+from bitstring import BitArray, ConstBitStream, Bits
+from .field_codec import FieldCodec
+from .varint_codec import VarintCodec
+from .exceptions import EncodingFailed
+
+
+class BytesCodec(FieldCodec):
+    """
+    codec for bytes
+    """
+
+    def __init__(self, max_length: int, fail_on_overflow=False, **kwargs) -> None:
+        self.max_length = max_length
+        self.length_codec = VarintCodec(min_value=0, max_value=self.max_length)
+        self.fail_on_overflow = fail_on_overflow
+
+    def encode(self, value: bytes) -> tuple[Bits, bytes]:
+        """
+        encode bytes
+
+        :param value: the bytes to encode
+        """
+        if self.fail_on_overflow and len(value) > self.max_length:
+            raise EncodingFailed(
+                f"BytesCodec: value with length {len(value)} is too long to encode (codec max_length={self.max_length}"
+            )
+        value = value[0 : self.max_length]
+        length_bits, _ = self.length_codec.encode(len(value))
+        value_bits = BitArray(bytes=value)
+        value_bits.prepend(length_bits)
+        return value_bits, value
+
+    def decode(self, bits_to_decode: ConstBitStream) -> bytes:
+        """
+        decode bytes
+
+        :param bits_to_decode: the bits to decode
+        """
+        num_bytes = self.length_codec.decode(bits_to_decode)
+        value = bits_to_decode.read("bytes:" + str(num_bytes))
+        return value
+
+    @property
+    def min_length_bits(self) -> int:
+        return self.length_codec.max_length_bits
+
+    @property
+    def max_length_bits(self) -> int:
+        return self.length_codec.max_length_bits + (8 * self.max_length)

ltcodecs-1.0.0/src/ltcodecs/ccl_latlon_bcd_codec.py

@@ -0,0 +1,56 @@
+"""
+ltcodecs.ccl_latlon_bcd_codec
+-----------------------------
+
+This module contains the the ccl latlon bcd codec
+"""
+
+from __future__ import annotations
+from bitstring import ConstBitStream, Bits
+from .field_codec import FieldCodec
+from math import modf, copysign
+
+
+class CclLatLonBcdCodec(FieldCodec):
+    """This codec is horrifically inefficient, but included for compatibility with messages like MDAT_RANGER"""
+
+    def __init__(self, lat_not_lon=True, **kwargs):
+        self.lat_not_lon = lat_not_lon
+
+    def encode(self, value: float) -> tuple[Bits, float]:
+        sign = copysign(1, value)
+        abs_value = abs(value)
+        frac, degrees = modf(abs_value)
+        degrees = int(degrees)
+        minutes = frac * 60
+        dec_min = int(minutes * 10000)
+
+        if self.lat_not_lon:
+            sign_char = "a" if sign > 0 else "c"
+        else:
+            sign_char = "b" if sign > 0 else "d"
+
+        hex_string = f"{degrees:03d}{sign_char}{dec_min:06d}"
+        encoded_value = sign * (degrees + (dec_min / 10000) / 60)
+        encoded_bits = Bits(hex=hex_string)
+
+        return encoded_bits, encoded_value
+
+    def decode(self, bits_to_decode: ConstBitStream) -> float:
+        string_bytes = bits_to_decode.read("bytes:5")
+        hex_string = "".join(f"{x:02x}" for x in string_bytes)
+
+        degrees = int(hex_string[0:3])
+        direction = 1 if hex_string[3] in ("a", "b") else -1
+        minutes = float(hex_string[4:10]) / 10000.0
+
+        value = direction * (degrees + (minutes / 60))
+        return value
+
+    @property
+    def max_length_bits(self) -> int:
+        return 40
+
+    @property
+    def min_length_bits(self) -> int:
+        return 40

ltcodecs-1.0.0/src/ltcodecs/ccl_latlon_codec.py

@@ -0,0 +1,51 @@
+"""
+ltcodecs.ccl_latlon_codec
+-------------------------
+
+ccl_latlon_codec encodes and decodes CCL latitude and longitude values
+"""
+
+from __future__ import annotations
+from bitstring import ConstBitStream, Bits
+from .field_codec import FieldCodec
+from math import ceil, log2
+
+
+class CclLatLonCodec(FieldCodec):
+    """
+    codec for CCL latitude and longitude values
+    """
+
+    def __init__(self, **kwargs) -> None:
+        pass
+
+    def encode(self, value: float) -> tuple[Bits, float]:
+        """
+        encode value
+
+        :param value: the value to encode
+        """
+
+        encoded_value = int(value * ((2**23 - 1) / 180.0))
+        encoded_bits = Bits(intle=encoded_value, length=24)
+
+        return encoded_bits, encoded_value
+
+    def decode(self, bits_to_decode: ConstBitStream) -> float:
+        """
+        decode value
+
+        :param bits_to_decode: the bitstream to decode
+        """
+
+        scale = bits_to_decode.read("intle:24")
+        value = scale * (180.0 / (2**23 - 1))
+        return value
+
+    @property
+    def max_length_bits(self) -> int:
+        return 24
+
+    @property
+    def min_length_bits(self) -> int:
+        return 24

ltcodecs-1.0.0/src/ltcodecs/exceptions.py

@@ -0,0 +1,16 @@
+"""
+ltcodecs.exceptions
+-------------------
+
+This module contains custom exceptions for ltcodecs
+"""
+
+
+class EncodingFailed(Exception):
+    """
+    Raised when encoding fails
+    """
+
+    def __init__(self, message: str = "Encoding failed") -> None:
+        self.message = message
+        super().__init__(self.message)

ltcodecs-1.0.0/src/ltcodecs/field_codec.py

@@ -0,0 +1,45 @@
+"""
+abstract base class for field codecs
+"""
+
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from bitstring import ConstBitStream, Bits
+from typing import Any
+
+
+class FieldCodec(ABC):
+    """
+    abstract base class for field codecs
+    """
+
+    def __init__(self, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    def encode(self, value: Any) -> tuple[Bits, Any]:
+        """
+        encodes value
+
+        :param value: value to encode
+        """
+        pass
+
+    @abstractmethod
+    def decode(self, bits_to_decode: ConstBitStream) -> Any:
+        """
+        decodes value
+
+        :param bits_to_decode: ConstBitStream to decode
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def max_length_bits(self) -> int:
+        pass
+
+    @property
+    @abstractmethod
+    def min_length_bits(self) -> int:
+        pass

ltcodecs-1.0.0/src/ltcodecs/fixed_len_array_codec.py

@@ -0,0 +1,70 @@
+"""
+ltcodecs.fixed_len_array_codec
+------------------------------
+
+This module contains the FixedLenArrayCodec class, which is used to encode and decode fixed length arrays.
+"""
+
+from __future__ import annotations
+from bitstring import BitArray, ConstBitStream, Bits
+from .field_codec import FieldCodec
+import ltcodecs as ltcodecs
+from typing import List
+from .exceptions import EncodingFailed
+
+
+class FixedLenArrayCodec(FieldCodec):
+    """
+    codec for fixed length arrays
+    """
+
+    def __init__(
+        self, element_type: str, length: int, element_params=None, **kwargs
+    ) -> None:
+        self.length = length
+        if element_params:
+            self.element_field_codec = ltcodecs.field_codec_classes[element_type](
+                **element_params
+            )
+        else:
+            self.element_field_codec = ltcodecs.field_codec_classes[element_type]()
+
+    def encode(self, value: List) -> tuple[Bits, List]:
+        """
+        encode a fixed length array
+
+        :param value: the fixed length array to encode
+        """
+        value = value[0 : self.length]
+        value_bits = BitArray()
+        encoded_value_list = []
+        for element in value:
+            (
+                element_bits,
+                element_value,
+            ) = self.element_field_codec.encode(element)
+
+            value_bits.append(element_bits)
+            encoded_value_list.append(element_value)
+        return value_bits, encoded_value_list
+
+    def decode(self, bits_to_decode: ConstBitStream) -> List:
+        """
+        decode a fixed length array
+
+        :param bits_to_decode: the bits to decode
+        """
+
+        decoded_list = []
+        for i in range(self.length):
+            element = self.element_field_codec.decode(bits_to_decode)
+            decoded_list.append(element)
+        return decoded_list
+
+    @property
+    def min_length_bits(self) -> int:
+        return self.length * self.element_field_codec.max_length_bits
+
+    @property
+    def max_length_bits(self) -> int:
+        return self.length * self.element_field_codec.max_length_bits

{ltcodecs-0.2.0 → ltcodecs-1.0.0}/src/ltcodecs/fixedint_codec.py

@@ -1,18 +1,33 @@
-from bitstring import ConstBitStream, Bits
-from .field_codec import FieldCodec
+"""
+ltcodecs.fixedint_codec
+-----------------------
+
+This module contains classes for fixed width integer codecs
+"""
+
 from .varint_codec import VarintCodec
-from math import ceil, log2
 
 
 class FixedIntCodec(VarintCodec):
-    def __init__(self, num_bits: int, signed: bool = False, min_value: int = None, resolution: int = 1,
-                 little_endian: bool = False, **kwargs):
+    """
+    FixedIntCodec base class
+    """
+
+    def __init__(
+        self,
+        num_bits: int,
+        signed: bool = False,
+        min_value: int = None,
+        resolution: int = 1,
+        little_endian: bool = False,
+        **kwargs
+    ):
         self.num_bits = num_bits
         if min_value:
             self.min_value = int(min_value)
         else:
             if signed:
-                self.min_value = -1 * resolution * 2**(self.num_bits - 1)
+                self.min_value = -1 * resolution * 2 ** (self.num_bits - 1)
             else:
                 self.min_value = 0
         self.max_value = self.min_value + (2**self.num_bits * resolution)
@@ -21,43 +36,73 @@ class FixedIntCodec(VarintCodec):
         self.little_endian = little_endian
 
 
-
-
 class Int8Codec(FixedIntCodec):
+    """
+    metaclass for int8 codec
+    """
+
     def __init__(self, **kwargs):
         super(Int8Codec, self).__init__(num_bits=8, signed=True)
 
 
 class Int16Codec(FixedIntCodec):
+    """
+    metaclass for int16 codec
+    """
+
     def __init__(self, **kwargs):
         super(Int16Codec, self).__init__(num_bits=16, signed=True)
 
 
 class Int32Codec(FixedIntCodec):
+    """
+    metaclass for int32 codec
+    """
+
     def __init__(self, **kwargs):
         super(Int32Codec, self).__init__(num_bits=32, signed=True)
 
 
 class Int64Codec(FixedIntCodec):
+    """
+    metaclass for int64 codec
+    """
+
     def __init__(self, **kwargs):
         super(Int64Codec, self).__init__(num_bits=64, signed=True)
 
 
 class UInt8Codec(FixedIntCodec):
+    """
+    metaclass for uint8 codec
+    """
+
     def __init__(self, **kwargs):
         super(UInt8Codec, self).__init__(num_bits=8, signed=False)
 
 
 class UInt16Codec(FixedIntCodec):
+    """
+    metaclass for uint16 codec
+    """
+
     def __init__(self, **kwargs):
         super(UInt16Codec, self).__init__(num_bits=16, signed=False)
 
 
 class UInt32Codec(FixedIntCodec):
+    """
+    metaclass for uint32 codec
+    """
+
     def __init__(self, **kwargs):
         super(UInt32Codec, self).__init__(num_bits=32, signed=False)
 
 
 class UInt64Codec(FixedIntCodec):
+    """
+    metaclass for uint64 codec
+    """
+
     def __init__(self, **kwargs):
-        super(UInt32Codec, self).__init__(num_bits=64, signed=False)
+        super(UInt32Codec, self).__init__(num_bits=64, signed=False)