logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/DatatrackFormattedTable.py

@@ -0,0 +1,25 @@
+import json
+from typing import Optional, cast
+
+from LOGS.Auxiliary.Exceptions import EntityIncompleteException
+from LOGS.Entities.Datatrack import Datatrack
+from LOGS.Entities.FormattedTable.DatatypeFormattedTable import DatatypeFormattedTable
+
+
+class DatatrackFormattedTable(Datatrack):
+    _type = "formatted_table"
+    _data: Optional[DatatypeFormattedTable] = None
+
+    def _fetchData(self):
+        super()._fetchData()
+
+        if self._data is not None:
+            # s = cast(bytes, self._data).decode("utf-8")
+            b = cast(bytes, self._data).split(b"\x00")[0]
+            self._data = DatatypeFormattedTable(json.loads(b.decode("utf-8")))
+
+    @property
+    def data(self) -> Optional[DatatypeFormattedTable]:
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        return self._data

LOGS/Entities/DatatrackGeneric.py

@@ -0,0 +1,34 @@
+from typing import Optional, cast
+
+from LOGS.Auxiliary.Exceptions import EntityIncompleteException
+from LOGS.Entities.Datatrack import Datatrack
+
+
+class DatatrackGeneric(Datatrack):
+    _type = "formatted_table"
+    _data: Optional[str] = None
+
+    def _fetchData(self):
+        super()._fetchData()
+
+        if self._data is not None:
+            s = cast(bytes, self._data)
+            try:
+                self._data = s.decode()
+                return
+            except:
+                pass
+
+            try:
+                self._data = s.decode("latin-1")
+                return
+            except:
+                pass
+
+            self._data = None
+
+    @property
+    def data(self) -> Optional[str]:
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        return self._data

LOGS/Entities/DatatrackImage.py

@@ -0,0 +1,25 @@
+from io import BytesIO
+from typing import Optional, cast
+
+import PIL.Image
+from PIL.Image import Image
+
+from LOGS.Auxiliary.Exceptions import EntityIncompleteException
+from LOGS.Entities.Datatrack import Datatrack
+
+
+class DatatrackImage(Datatrack):
+    _type = "image"
+    _data: Optional[Image] = None
+
+    def _fetchData(self):
+        super()._fetchData()
+
+        if self._data:
+            self._data = PIL.Image.open(BytesIO(cast(bytes, self._data)))
+
+    @property
+    def data(self) -> Optional[Image]:
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        return self._data

LOGS/Entities/DatatrackNumericArray.py

@@ -0,0 +1,30 @@
+from typing import Optional, cast
+
+import numpy as np
+
+from LOGS.Auxiliary.Exceptions import EntityIncompleteException
+from LOGS.Entities.Datatrack import Datatrack
+
+
+class DatatrackNumericArray(Datatrack):
+    _type = "numeric_array"
+    _data: Optional[np.ndarray] = None
+
+    def __iter__(self):
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        if self._data is not None:
+            for x in self._data:
+                yield x
+
+    def _fetchData(self):
+        super()._fetchData()
+
+        if self._data:
+            self._data = np.frombuffer(cast(bytes, self._data), dtype=np.double)
+
+    @property
+    def data(self) -> Optional[np.ndarray]:
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        return self._data

LOGS/Entities/DatatrackNumericMatrix.py

@@ -0,0 +1,98 @@
+from typing import Optional, Tuple, cast
+
+import numpy as np
+
+from LOGS.Auxiliary.Exceptions import EntityIncompleteException
+from LOGS.Entities.Datatrack import Datatrack
+
+
+class DatatrackNumericMatrix(Datatrack):
+    _type = "numeric_matrix"
+    _data: Optional[np.ndarray] = None
+
+    def __iter__(self):
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+
+        if self.size is None:
+            raise ValueError("Datatrack has no size defined.")
+
+        if self._data is not None:
+            for x in range(self.size[0]):
+                for y in range(self.size[1]):
+                    yield x, y
+
+    def _fetchData(self):
+        super()._fetchData()
+
+        if self._data and self.size and len(self.size) > 1:
+            self._data = np.frombuffer(cast(bytes, self._data), dtype=np.double)
+            self._data = self._data.reshape((self.size[1], self.size[0]))
+            self._data = self._data.T
+
+    def getCoordinate(self, index: Tuple[int, int]):
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        if self.min is None or self.max is None or self.size is None:
+            return None
+
+        return (
+            self.min[0] + index[0] * (self.max[0] - self.min[0]) / self.size[0],
+            self.min[1] + index[1] * (self.max[1] - self.min[1]) / self.size[1],
+        )
+
+    def getIndex(
+        self, coord: Tuple[float, float], keepInBounds: bool = False
+    ) -> Tuple[int, int]:
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        if self.min is None or self.max is None or self.size is None:
+            raise ValueError("Datatrack has no min, max or size defined.")
+
+        index = (
+            int((coord[0] - self.min[0]) * self.size[0] / (self.max[0] - self.min[0])),
+            int((coord[1] - self.min[1]) * self.size[1] / (self.max[1] - self.min[1])),
+        )
+
+        if keepInBounds:
+            index = (
+                max(0, min(index[0], self.size[0] - 1)),
+                max(0, min(index[1], self.size[1] - 1)),
+            )
+
+        return index
+
+    def getValueFromCoordinate(
+        self, coord: Tuple[float, float], keepInBounds: bool = True
+    ):
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        if self._data is None:
+            return None
+
+        return self.getValueFromIndex(self.getIndex(coord, keepInBounds=keepInBounds))
+
+    def getValueFromIndex(self, index: Tuple[int, int]):
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        if self._data is None:
+            return None
+
+        if self.size is None:
+            raise ValueError("Datatrack has no size defined.")
+
+        if (
+            index[0] < 0
+            or index[0] >= self.size[0]
+            or index[1] < 0
+            or index[1] >= self.size[1]
+        ):
+            raise ValueError("Index out of bounds.")
+
+        return self._data[index]
+
+    @property
+    def data(self) -> Optional[np.ndarray]:
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        return self._data

LOGS/Entities/Entities.py

@@ -0,0 +1,71 @@
+from typing import Any, Optional, cast
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.Exceptions import LOGSException
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entities.EntitiesRequestParameter import EntitiesRequestParameter
+from LOGS.Entity.Entity import Entity
+from LOGS.Entity.EntityIterator import EntityIterator
+from LOGS.Entity.EntityMinimalWithType import EntityMinimalWithType
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.LOGSConnection import LOGSConnection
+
+
+@Endpoint("entities")
+class Entities(EntityIterator[Entity, EntityRequestParameter]):
+    """LOGS connected multi Entity iterator"""
+
+    _generatorType = EntityMinimalWithType  # type: ignore
+    _parameterType = EntitiesRequestParameter  # type: ignore
+
+    def __init__(
+        self,
+        connection: Optional[LOGSConnection],
+        parameters: Optional[EntitiesRequestParameter] = None,
+    ):
+        super().__init__(connection=connection, parameters=cast(Any, parameters))
+
+    def _convertToEntity(self, entity: EntityMinimalWithType):
+        return MinimalModelGenerator.MinimalFromSingle(
+            entity.toDict(), entity.type, None, connection=self._getConnection()
+        )
+
+    def __next__(self) -> EntityMinimalWithType:
+        entity = cast(EntityMinimalWithType, super().__next__())
+        result = self._convertToEntity(entity)
+        if not result:
+            raise LOGSException(
+                "Unknown entity %a of type %a." % (str(entity), entity.type)
+            )
+
+        return result
+
+    def fetch(self, uid: str):
+        self._entityIterator = 0
+
+        if not self._connection:
+            raise LOGSException(
+                "Entity connector %a is not connected" % type(self).__name__
+            )
+
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Endpoint missing for of entity type %a."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != Entity.__name__
+                    else "unknown"
+                )
+            )
+
+        ref, responseError = self._connection.getEndpoint(self._endpoint + [str(uid)])
+        if responseError:
+            raise LOGSException(
+                message="Could not fetch entity with uid %a: %s"
+                % (uid, responseError.errorString()),
+                responseError=responseError,
+            )
+
+        entity = Tools.checkAndConvert(ref, EntityMinimalWithType)
+        return self._convertToEntity(entity)

LOGS/Entities/EntitiesRequestParameter.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Sequence, Type, Union
+from uuid import UUID
+
+from LOGS.Entity.EntityRequestParameter import (
+    DefaultSortingOptions,
+    EntityRequestParameter,
+)
+
+
+@dataclass
+class EntitiesRequestParameter(EntityRequestParameter[DefaultSortingOptions]):
+    _orderByType: Type[DefaultSortingOptions] = field(
+        default=DefaultSortingOptions, init=False
+    )
+
+    uids: Optional[Sequence[Union[str, UUID]]] = None
+    names: Optional[List[str]] = None

LOGS/Entities/EntityOriginWriteModelWithId.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+from uuid import UUID
+
+from LOGS.Auxiliary.Constants import Constants
+from LOGS.Entities.OriginMinimal import OriginMinimal
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+@dataclass
+class EntityOriginWriteModelWithId(SerializableClass):
+    _noSerialize: List[str] = field(default_factory=lambda: ["asString"])
+    id: Optional[Constants.ID_TYPE] = None
+    uid: Optional[UUID] = None
+    origin: Optional[OriginMinimal] = None

LOGS/Entities/FileEntry.py

@@ -0,0 +1,138 @@
+import base64
+import os
+import uuid
+from datetime import datetime
+from hashlib import sha256
+from typing import Any, List, Literal, Optional, Sequence, Union, cast
+
+from LOGS.Auxiliary.Constants import Constants
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class FingerprintFragment(SerializableClass):
+    offset: int = 0
+    length: int = 0
+    bytes: str = ""
+
+
+class FileFragment(SerializableClass):
+    _typeMapper = {"fragments": FingerprintFragment}
+    id: str = ""
+    fragments: List[FingerprintFragment] = []
+
+
+FormatFileState = Literal["NEW", "UNCHANGED", "NEEDSUPDATE", "DELETE"]
+
+
+class FileEntry(SerializableClass):
+    _typeMapper = {"fragments": FingerprintFragment}
+    _noSerialize = ["isDir", "name"]
+    id: Optional[str] = None
+    # The naming here is confusing. FullPath is part of the LOGS API but it refers
+    # to the full path in LOGS and not the actual file path.
+    fullPath: str = ""
+    path: str = ""
+    isDir: bool = False
+    name: str = ""
+    fragments: Optional[List[FingerprintFragment]] = None
+    hash: Optional[str] = None
+    state: Optional[FormatFileState] = None
+    mtime: Optional[datetime] = None
+
+    def __init__(
+        self,
+        ref: Any = None,
+        fullPath: Optional[str] = None,
+        state: Optional[FormatFileState] = None,
+    ):
+        if isinstance(ref, FileEntry):
+            super().__init__(self._fieldsFromPath(ref.path))
+            self.fullPath = ref.fullPath
+            self.state = ref.state
+        elif isinstance(ref, os.DirEntry) and ref.path:
+            super().__init__(self._fieldsFromPath(ref.path))
+        elif isinstance(ref, str) or fullPath is not None:
+            super().__init__(
+                self._fieldsFromPath(str(ref if fullPath is None else fullPath))
+            )
+        else:
+            super().__init__(ref)
+
+        if fullPath is not None:
+            self.fullPath = fullPath
+        if state is not None:
+            self.state = state
+
+    @classmethod
+    def _fieldsFromPath(cls, path: str):
+        _path = os.path.realpath(path)
+        return {
+            "id": uuid.uuid4().hex,
+            "fullPath": _path,
+            "path": _path,
+            "isDir": os.path.isdir(_path),
+            "name": os.path.basename(_path),
+        }
+
+    def __str__(self):
+        return "<%s %s%a>" % (
+            type(self).__name__,
+            ("<dir> " if self.isDir else ""),
+            self.path,
+        )
+
+    def addFragment(self, fragments: List[FingerprintFragment]):
+        with open(self.path, "rb") as read:
+            if self.fragments is None:
+                self.fragments = []
+            for fragment in fragments:
+                read.seek(fragment.offset)
+                fragment.bytes = base64.b64encode(read.read(fragment.length)).decode(
+                    "utf-8"
+                )
+                self.fragments.append(fragment)
+
+    def addHash(self):
+        with open(self.path, "rb") as read:
+            self.hash = sha256(read.read()).hexdigest()
+
+    def addMtime(self):
+        self.mtime = datetime.fromtimestamp(os.path.getmtime(self.path))
+
+    @classmethod
+    def entriesFromFiles(
+        cls,
+        files: Union[Constants.FILE_TYPE, Sequence[Constants.FILE_TYPE]],
+        ignoreReadErrors=False,
+    ):
+        if files == None:
+            raise FileNotFoundError("Could not read file or directory from 'None' path")
+        if not isinstance(files, list):
+            files = [cast(Constants.FILE_TYPE, files)]
+
+        result: List[FileEntry] = []
+
+        while len(files) > 0:
+            file = files.pop(0)
+            if isinstance(file, (str, os.DirEntry, FileEntry)):
+                f = FileEntry(file)
+                if f.isDir:
+                    with os.scandir(f.path) as entries:
+                        files.extend(entries)
+                else:
+                    if not os.path.isfile(f.path) or not os.access(f.path, os.R_OK):
+                        if not ignoreReadErrors:
+                            raise PermissionError("Could not read file %a" % f.path)
+                    else:
+                        f.id = uuid.uuid4().hex
+                        result.append(f)
+
+        return result
+
+    def modifyPathPrefix(
+        self, prefixToStrip: Optional[str] = None, prefixToAdd: Optional[str] = None
+    ):
+        if prefixToStrip and self.fullPath.startswith(prefixToStrip):
+            self.fullPath = self.fullPath[len(prefixToStrip) :]
+        if prefixToAdd and not self.fullPath.startswith(prefixToAdd):
+            self.fullPath = os.path.join(prefixToAdd, self.fullPath)

LOGS/Entities/FileExcludePattern.py

@@ -0,0 +1,8 @@
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class FileExcludePattern(SerializableClass):
+    name: Optional[str] = None
+    regex: Optional[str] = None

LOGS/Entities/FormatMetaData.py

@@ -0,0 +1,56 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entity.ConnectedEntity import ConnectedEntity
+from LOGS.LOGSConnection import LOGSConnection
+
+if TYPE_CHECKING:
+    from LOGS.Entities.DataFormatInstrumentMinimal import DataFormatInstrumentMinimal
+    from LOGS.Entities.MethodMinimal import MethodMinimal
+    from LOGS.Entities.VendorMinimal import VendorMinimal
+
+
+class FormatMetaData(ConnectedEntity):
+    _vendor: List["VendorMinimal"]
+    _method: List["MethodMinimal"]
+    _instrument: List["DataFormatInstrumentMinimal"]
+
+    def __init__(self, ref=None, connection: Optional[LOGSConnection] = None):
+        self._vendor = []
+        self._method = []
+        self._format = []
+        self._instrument = []
+        super().__init__(ref=ref, connection=connection)
+
+    @property
+    def vendor(self) -> List["VendorMinimal"]:
+        return self._vendor
+
+    @vendor.setter
+    def vendor(self, value):
+        self._vendor = MinimalModelGenerator.MinimalFromList(
+            value, "VendorMinimal", "vendor", connection=self._getConnection()
+        )
+
+    @property
+    def method(self) -> List["MethodMinimal"]:
+        return self._method
+
+    @method.setter
+    def method(self, value):
+        self._method = MinimalModelGenerator.MinimalFromList(
+            value, "MethodMinimal", "method", connection=self._getConnection()
+        )
+
+    @property
+    def instrument(self) -> List["DataFormatInstrumentMinimal"]:
+        return self._instrument
+
+    @instrument.setter
+    def instrument(self, value):
+        self._instrument = MinimalModelGenerator.MinimalFromList(
+            value,
+            "DataFormatInstrumentMinimal",
+            "instrument",
+            connection=self._getConnection(),
+        )

LOGS/Entities/FormattedTable/DatatypeFormattedTable.py

@@ -0,0 +1,135 @@
+import sys
+from typing import Dict, List, Literal, Optional, Union
+
+from LOGS.Entities.FormattedTable.DatatypeFormattedTableCell import (
+    DatatypeFormattedTableCell,
+)
+from LOGS.Entity.SerializableContent import SerializableContent
+
+_VTypeType = Literal["int", "float", "str", "bool"]
+
+
+class DatatypeFormattedTable(SerializableContent):
+    _type: str = "formatted_table"
+    _name: Optional[str] = None
+    _id = ""
+
+    _cells: List[DatatypeFormattedTableCell] = []
+
+    _rowRange: List[int] = [sys.maxsize, -1]
+    _columnRange: List[int] = [sys.maxsize, -1]
+
+    _cellIds: Dict[str, int] = {}
+
+    _fixedRow: Optional[int] = None
+    _fixedColumn: Optional[int] = None
+
+    def appendCell(
+        self,
+        cell: Union[_VTypeType, DatatypeFormattedTableCell],
+        row: int = -1,
+        column: int = -1,
+    ) -> DatatypeFormattedTableCell:
+        c = self.checkAndConvert(
+            cell, fieldName="cell", fieldType=DatatypeFormattedTableCell
+        )
+        if row >= 0:
+            c.row = row
+        if column >= 0:
+            c.column = column
+
+        id = c.id
+        index = self.getCell(id)
+        if index >= 0:
+            self.cells[index] = c
+        else:
+            self._cellIds[id] = len(self.cells)
+            self.cells.append(c)
+
+        # self.reorganizeCells()
+
+        return c
+
+    def getCell(self, id: str) -> int:
+        if id in self._cellIds:
+            return self._cellIds[id]
+        return -1
+
+    # def addCellId(self, cell: DatatypeFormattedTableCell):
+    #     self.cells.sort(key=lambda c: (c.row, c.column))
+    #     self._cellIds = {c.id: i for i, c in enumerate(self.cells)}
+    #     self._cellIds[cell.id] = cell
+
+    def reorganizeCells(self):
+        self.cells.sort(key=lambda c: c.column)
+        self._columnRange = [self.cells[0].column, self.cells[-1].column]
+        self.cells.sort(key=lambda c: (c.row, c.column))
+        self._rowRange = [self.cells[0].row, self.cells[-1].row]
+        self._cellIds = {c.id: i for i, c in enumerate(self.cells)}
+
+    def toDict(self, validate=False):
+        self.reorganizeCells()
+        return super().toDict()
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = value
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = value
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @property
+    def cells(self) -> List[DatatypeFormattedTableCell]:
+        return self._cells
+
+    @cells.setter
+    def cells(self, value):
+        self._cells = self.checkListAndConvert(
+            value, fieldName="cells", fieldType=DatatypeFormattedTableCell
+        )
+        self.reorganizeCells()
+
+    @property
+    def rowRange(self) -> List[int]:
+        return self._rowRange
+
+    @property
+    def columnRange(self) -> List[int]:
+        return self._columnRange
+
+    @property
+    def fixedRow(self) -> Optional[int]:
+        return self._fixedRow
+
+    @fixedRow.setter
+    def fixedRow(self, value):
+        self._fixedRow = self.checkAndConvert(
+            value, fieldName="fixedRow", fieldType=int, allowNone=True
+        )
+
+    @property
+    def fixedColumn(self) -> Optional[int]:
+        return self._fixedColumn
+
+    @fixedColumn.setter
+    def fixedColumn(self, value):
+        self._fixedColumn = self.checkAndConvert(
+            value, fieldName="fixedColumn", fieldType=int, allowNone=True
+        )