logs-py 2.9.5__py3-none-any.whl → 3.0.0__py3-none-any.whl

LOGS/Parameters/Color.py

@@ -0,0 +1,92 @@
+from typing import List, Optional
+
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+
+class SingleColor(SerializeableContent):
+    _color: str
+    _offset: Optional[float]
+    _value: Optional[float]
+
+    @classmethod
+    def bgrIntSigned32bit_to_hexcolor(cls, bgrInt: int):
+        b = bgrInt & 2**8 - 1
+        g = (bgrInt >> 8) & 2**8 - 1
+        r = (bgrInt >> 16) & 2**8 - 1
+        return "#%02x%02x%02x" % (r, g, b)
+
+    @property
+    def color(self) -> str:
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        self._color = value
+
+    @property
+    def offset(self) -> Optional[float]:
+        return self._offset
+
+    @offset.setter
+    def offset(self, value):
+        value = self.checkAndConvert(
+            value, fieldName="offset", fieldType=float, allowNone=True
+        )
+        if value < 0:
+            raise Exception("Color offset value must be >= 0. (Got %f)" % value)
+        if value > 1:
+            raise Exception("Color offset value must be <= 1. (Got %f)" % value)
+        self._offset = value
+
+    @property
+    def value(self) -> Optional[float]:
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+
+
+class Color(SerializeableContent):
+    _colors: List[SingleColor]
+    _discrete: Optional[bool]
+    _reverse: Optional[bool]
+
+    def __init__(self, ref=None):
+        if ref != None:
+            if isinstance(ref, str):
+                ref = {"colors": [ref]}
+            elif isinstance(ref, list):
+                ref = {"colors": ref}
+
+        super().__init__(ref)
+
+    @classmethod
+    def bgrIntSigned32bit_to_hexcolor(cls, bgrInt: int):
+        return SingleColor.bgrIntSigned32bit_to_hexcolor(bgrInt=bgrInt)
+
+    @property
+    def colors(self) -> List[SingleColor]:
+        return self._colors
+
+    @colors.setter
+    def colors(self, value):
+        self._colors = self.checkListAndConvert(
+            value, fieldType=SingleColor, fieldName="colors"
+        )
+
+    @property
+    def discrete(self) -> Optional[bool]:
+        return self._discrete
+
+    @discrete.setter
+    def discrete(self, value):
+        self._discrete = bool(value)
+
+    @property
+    def reverse(self) -> Optional[bool]:
+        return self._reverse
+
+    @reverse.setter
+    def reverse(self, value):
+        self._reverse = bool(value)

LOGS/Parameters/ParameterBase.py

@@ -0,0 +1,55 @@
+from typing import List, Optional
+
+from LOGS.Entity.SerializeableContent import SerializeableContent
+from LOGS.Parameters.Color import Color
+
+
+class ParameterBase(SerializeableContent):
+    _name: str = ""
+    _tracks: Optional[List[str]] = None
+    _colors: List[Color] = []
+    _active: bool = True
+    _type: str = "None"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvert(value, fieldType=str, fieldName="name")
+
+    @property
+    def tracks(self) -> Optional[List[str]]:
+        return self._tracks
+
+    @tracks.setter
+    def tracks(self, value):
+        self._tracks = self.checkListAndConvert(
+            value, fieldType=str, fieldName="tracks"
+        )
+
+    @property
+    def active(self) -> bool:
+        return self._active
+
+    @active.setter
+    def active(self, value):
+        self._active = bool(value)
+
+    @property
+    def colors(self) -> Optional[List[Color]]:
+        if len(self._colors) < 1:
+            return None
+
+        return self._colors
+
+    @colors.setter
+    def colors(self, value):
+        self._colors = self.checkListAndConvert(
+            value, fieldType=Color, fieldName="colors"
+        )
+
+    @property
+    def type(self) -> str:
+        return self._type

LOGS/Parameters/ParameterConverter.py

@@ -0,0 +1,24 @@
+from typing import cast
+
+from LOGS.Parameters.ParameterBase import ParameterBase
+from LOGS.Parameters.ParameterElement import ParameterElement
+from LOGS.Parameters.ParameterList import ParameterList
+from LOGS.Parameters.ParameterTable import ParameterTable
+
+
+class ParameterConverter:
+    @classmethod
+    def convert(cls, parameter):
+        if not isinstance(parameter, dict) or "type" not in parameter:
+            return cast(ParameterBase, None)
+
+        if parameter["type"] == "parameter":
+            return ParameterElement(parameter)
+
+        if parameter["type"] == "list":
+            return ParameterList(parameter)
+
+        if parameter["type"] == "table":
+            return ParameterTable(parameter)
+
+        return cast(ParameterBase, None)

LOGS/Parameters/ParameterElement.py

@@ -0,0 +1,99 @@
+from typing import List, Literal, Optional, Union
+
+from LOGS.Parameters.ParameterBase import ParameterBase
+
+VTypeType = Literal["int", "float", "int[]", "float[]", "str"]
+ValueType = Union[str, int, float, List[int], List[float], None]
+FormatterType = Literal[
+    "duration",
+    "length",
+    "voltage",
+    "current",
+    "pressure",
+    "frequency",
+    "magnetic",
+    "epower",
+]
+
+
+class ParameterElement(ParameterBase):
+    _type = "parameter"
+
+    _vtype: VTypeType = "str"
+    _value: ValueType = None
+    _formatter: Optional[FormatterType] = None
+    _unit: Optional[str] = None
+    _delimiter: Optional[str] = None
+    _decimalPlaces: Optional[int] = None
+    _multiline: Optional[bool] = None
+
+    @property
+    def vtype(self) -> VTypeType:
+        return self._vtype
+
+    @vtype.setter
+    def vtype(self, value):
+        self._vtype = value
+
+    @property
+    def value(self) -> ValueType:
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+
+    @property
+    def formattedValue(self) -> str:
+        if self._unit:
+            return str(self._value) + " " + self._unit
+
+        return str(self._value)
+
+    @property
+    def formatter(self) -> Optional[FormatterType]:
+        return self._formatter
+
+    @formatter.setter
+    def formatter(self, value):
+        self._formatter = value
+
+    @property
+    def unit(self) -> Optional[str]:
+        return self._unit
+
+    @unit.setter
+    def unit(self, value):
+        self._unit = value
+
+    @property
+    def multiline(self) -> Optional[bool]:
+        return self._multiline
+
+    @multiline.setter
+    def multiline(self, value):
+        self._multiline = value
+
+    @property
+    def delimiter(self) -> Optional[str]:
+        return self._delimiter
+
+    @delimiter.setter
+    def delimiter(self, value):
+        self._delimiter = value
+
+    @property
+    def decimalPlaces(self) -> Optional[int]:
+        return self._decimalPlaces
+
+    @decimalPlaces.setter
+    def decimalPlaces(self, value):
+        value = self.checkAndConvert(
+            value, fieldName="decimalPlaces", fieldType=int, allowNone=True
+        )
+        if value < 0:
+            raise Exception(
+                "Decimal places must be zero or a positive integer number. (Got %a)"
+                % value
+            )
+        self._decimalPlaces = value

LOGS/Parameters/ParameterList.py

@@ -0,0 +1,52 @@
+from typing import Any, List, cast
+
+from LOGS.Parameters.ParameterBase import ParameterBase
+
+
+class ParameterList(ParameterBase):
+    _type = "list"
+    _content: List[ParameterBase] = []
+
+    def __init__(self, ref=None):
+        if isinstance(ref, list):
+            ref = {"name": "<root>", "content": ref}
+
+        super().__init__(ref)
+
+    def __iter__(self):
+        for c in self._content:
+            yield c
+
+    def findItems(self, name: str) -> list[ParameterBase]:
+        return [c for c in self._content if c.name == name]
+
+    def findItemsRecursively(self, name: str) -> list[ParameterBase]:
+        result = self.findItems(name)
+        # print([c.name for c in self._content])
+        # print("->", [c.name for c in result])
+
+        for c in self._content:
+            if isinstance(c, ParameterList):
+                result.extend(c.findItemsRecursively(name))
+
+        return result
+
+    @property
+    def content(self) -> List[ParameterBase]:
+        return self._content
+
+    @content.setter
+    def content(self, value: List[ParameterBase]):
+        from LOGS.Parameters.ParameterConverter import ParameterConverter
+
+        # for e in value:
+        #     p = ParameterConverter.convert(e)
+        #     p.printJson()
+        #     print("-------------------")
+
+        self._content = self.checkListAndConvert(
+            value,
+            ParameterBase,
+            "content",
+            converter=cast(Any, ParameterConverter.convert),
+        )

LOGS/Parameters/ParameterTable.py

@@ -0,0 +1,64 @@
+from typing import List, Literal, Optional, Union
+
+from LOGS.Parameters.ParameterBase import ParameterBase
+
+ColumnTypesType = Literal["int", "float", "str", "bool"]
+TableType = Union[str, int, float, None]
+
+
+class ParameterTable(ParameterBase):
+    _type = "table"
+
+    _columnNumber: int = 0
+    _columnTypes: List[ColumnTypesType] = []
+    _columnDecimals: List[Optional[int]] = []
+    _columnNames: List[str] = []
+    _table: List[List[TableType]] = []
+
+    @property
+    def columnNumber(self) -> int:
+        return self._columnNumber
+
+    @columnNumber.setter
+    def columnNumber(self, value):
+        if not isinstance(value, int) or value < 0:
+            value = 0
+        self._columnNumber = value
+
+    @property
+    def columnTypes(self) -> List[ColumnTypesType]:
+        return self._columnTypes
+
+    @columnTypes.setter
+    def columnTypes(self, value):
+        self._columnTypes = self.checkListAndConvert(
+            value, str, fieldName="columnTypes"  # type: ignore
+        )
+
+    @property
+    def columnDecimals(self) -> List[Optional[int]]:
+        return self._columnDecimals
+
+    @columnDecimals.setter
+    def columnDecimals(self, value):
+        self._columnDecimals = self.checkListAndConvert(
+            value, fieldType=int, fieldName="columnDecimals", allowNone=True
+        )
+
+    @property
+    def columnNames(self) -> List[str]:
+        return self._columnNames
+
+    @columnNames.setter
+    def columnNames(self, value):
+        self._columnNames = self.checkListAndConvert(
+            value, fieldType=str, fieldName="columnNames", allowNone=True
+        )
+
+    @property
+    def table(self) -> List[List[TableType]]:
+        return self._table
+
+    @table.setter
+    def table(self, value):
+        self._table = value

LOGS/Parameters/__init__.py

@@ -0,0 +1,13 @@
+"""
+    This package is written for the LOGS Repository.
+    
+    It's objects can be used to write your own dataset parser.
+    
+    License:
+    Permission to use this libraray and all of its contents is 
+    strictly permitted to the Signals Company.
+"""
+
+from .Color import *
+from .ParameterBase import *
+from .ParameterElement import *

LOGS/__init__.py

@@ -8,4 +8,5 @@
 
 from .LOGS import *
 from .LOGSConnection import *
+from .LOGSOptions import *
 from .ServerMetaData import *

{logs_py-2.9.5.dist-info → logs_py-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logs-py
-Version: 2.9.5
+Version: 3.0.0
 Summary: A python interface for the LOGS public API
 Home-page: https://docs.logs-python.com
 Author: Sina Kazemi
@@ -15,9 +15,10 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: numpy
 Requires-Dist: requests
-Requires-Dist: regex >=2019.12.9
+Requires-Dist: regex>=2019.12.9
 Requires-Dist: Pillow
 Requires-Dist: deprecation
+Requires-Dist: pytz
 
 # LOGS-Py