logs-py 4.0.7__py3-none-any.whl

LOGS/Parameters/Color.py

@@ -0,0 +1,92 @@
+from typing import List, Optional
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class SingleColor(SerializableContent):
+    _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(SerializableContent):
+    _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.SerializableContent import SerializableContent
+from LOGS.Parameters.Color import Color
+
+
+class ParameterBase(SerializableContent):
+    _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/ServerMetaData.py

@@ -0,0 +1,120 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class ServerMetaData(SerializableContent):
+    _application: Optional[str] = None
+    _vendor: Optional[str] = None
+    _version: Optional[str] = None
+    _uid: Optional[UUID] = None
+    _apiVersion: Optional[str] = None
+    _edition: Optional[str] = None
+    _groups: Optional[int] = None
+    _licensedTo: Optional[str] = None
+    _daysUntilExpiration: Optional[int] = None
+    _expirationDate: Optional[datetime] = None
+    _homepage: Optional[str] = None
+    _email: Optional[str] = None
+
+    @property
+    def application(self) -> Optional[str]:
+        return self._application
+
+    @application.setter
+    def application(self, value):
+        self._application = self.checkAndConvertNullable(value, str, "application")
+
+    @property
+    def vendor(self) -> Optional[str]:
+        return self._vendor
+
+    @vendor.setter
+    def vendor(self, value):
+        self._vendor = self.checkAndConvertNullable(value, str, "vendor")
+
+    @property
+    def version(self) -> Optional[str]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = self.checkAndConvertNullable(value, str, "version")
+
+    @property
+    def uid(self) -> Optional[UUID]:
+        return self._uid
+
+    @uid.setter
+    def uid(self, value):
+        self._uid = self.checkAndConvertNullable(value, UUID, "uid")
+
+    @property
+    def apiVersion(self) -> Optional[str]:
+        return self._apiVersion
+
+    @apiVersion.setter
+    def apiVersion(self, value):
+        self._apiVersion = self.checkAndConvertNullable(value, str, "apiVersion")
+
+    @property
+    def edition(self) -> Optional[str]:
+        return self._edition
+
+    @edition.setter
+    def edition(self, value):
+        self._edition = self.checkAndConvertNullable(value, str, "edition")
+
+    @property
+    def groups(self) -> Optional[int]:
+        return self._groups
+
+    @groups.setter
+    def groups(self, value):
+        self._groups = self.checkAndConvertNullable(value, int, "groups")
+
+    @property
+    def licensedTo(self) -> Optional[str]:
+        return self._licensedTo
+
+    @licensedTo.setter
+    def licensedTo(self, value):
+        self._licensedTo = self.checkAndConvertNullable(value, str, "licensedTo")
+
+    @property
+    def daysUntilExpiration(self) -> Optional[int]:
+        return self._daysUntilExpiration
+
+    @daysUntilExpiration.setter
+    def daysUntilExpiration(self, value):
+        self._daysUntilExpiration = self.checkAndConvertNullable(
+            value, int, "daysUntilExpiration"
+        )
+
+    @property
+    def expirationDate(self) -> Optional[datetime]:
+        return self._expirationDate
+
+    @expirationDate.setter
+    def expirationDate(self, value):
+        self._expirationDate = self.checkAndConvertNullable(
+            value, datetime, "expirationDate"
+        )
+
+    @property
+    def homepage(self) -> Optional[str]:
+        return self._homepage
+
+    @homepage.setter
+    def homepage(self, value):
+        self._homepage = self.checkAndConvertNullable(value, str, "homepage")
+
+    @property
+    def email(self) -> Optional[str]:
+        return self._email
+
+    @email.setter
+    def email(self, value):
+        self._email = self.checkAndConvertNullable(value, str, "email")

LOGS/__init__.py

@@ -0,0 +1,12 @@
+"""
+This Module is written for the LOGS Repository.
+
+It's objects can be used to access the LOGS public API
+programmatically via python scripts.
+...
+"""
+
+from .LOGS import *
+from .LOGSConnection import *
+from .LOGSOptions import *
+from .ServerMetaData import *

logs_py-4.0.7.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: logs-py
+Version: 4.0.7
+Summary: A python interface for the LOGS public API
+Home-page: https://docs.logs-python.com
+Author: Sina Kazemi
+Author-email: support@logs-repository.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: requests
+Requires-Dist: regex>=2019.12.9
+Requires-Dist: Pillow
+Requires-Dist: deprecation
+Requires-Dist: pytz
+Requires-Dist: tzlocal; platform_system == "Windows"
+Requires-Dist: typing_extensions
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# LOGS-Py
+
+LOGS is a scientific data management system (SDMS) software allowing for automated data collection, visualization, and organization. Within its internal organizational concepts it allows you to enrich you experimental data with metadata. LOGS allows you to adapt many of its organization structures which enables your data management to follow your internal workflows.
+
+**LOGS-Py is a Python package** interacting with the LOGS web API to enable you to extract and push data to LOGS and generally operateinteract with the LOGS backend in a programatic way. The main motivation behind in the desing of library is to keep this interaction as pythonic as possible. The communication with the API remains mainly in the background while the user of the library handles native Python objects whereby theuser is still able to interact with nearly are LOGS functionalities and entities.
+
+Thus _this library_ firstly _targets lab and data scientist_ allowing them to freely interact with experimental data and its meta-data without any pre-knowledge of Web technologies and communication. Secondly, it _facilitates power-users_ to implement highly specific workflows automations and 3rd-party software intergrations with LOGS and other lab software.
+
+## Installation
+
+The **LOGS-Py** package can be easily installed by using `pip`.
+
+For this open the `terminal` and do:
+
+```bash
+pip install logs-py
+```