logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/Signature.py

@@ -0,0 +1,60 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entities.PersonMinimal import PersonMinimal
+from LOGS.Entity.Entity import Entity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+
+from enum import Enum
+
+
+class SignatureType(Enum):
+    Unknown = "Unknown"
+    Contributor = "Contributor"
+    Reviewer = "Reviewer"
+
+
+class Signature(Entity):
+    _signedBy: Optional["PersonMinimal"] = None
+    _timestamp: Optional[datetime] = None
+    _signatureType: Optional[SignatureType] = None
+    _comment: Optional[str] = None
+
+    @property
+    def signedBy(self) -> Optional["PersonMinimal"]:
+        return self._signedBy
+
+    @signedBy.setter
+    def signedBy(self, value):
+        self._signedBy = MinimalModelGenerator.MinimalFromSingle(
+            value, "PersonMinimal", "signedBy", self._getConnection()
+        )
+
+    @property
+    def timestamp(self) -> Optional[datetime]:
+        return self._timestamp
+
+    @timestamp.setter
+    def timestamp(self, value: Optional[datetime]):
+        self._timestamp = self.checkAndConvertNullable(value, datetime, "timestamp")
+
+    @property
+    def signatureType(self) -> Optional[SignatureType]:
+        return self._signatureType
+
+    @signatureType.setter
+    def signatureType(self, value: Optional[SignatureType]):
+        self._signatureType = self.checkAndConvertNullable(
+            value, SignatureType, "signatureType"
+        )
+
+    @property
+    def comment(self) -> Optional[str]:
+        return self._comment
+
+    @comment.setter
+    def comment(self, value: Optional[str]):
+        self._comment = self.checkAndConvertNullable(value, str, "comment")

LOGS/Entities/Track.py

@@ -0,0 +1,93 @@
+from typing import Any, Dict, Generic, List, Literal, Optional, TypeVar, Union, cast
+
+from LOGS.Entities.Datatrack import Datatrack
+from LOGS.Entities.TrackData import TrackData
+from LOGS.Entities.TrackSettings import TrackSettings
+from LOGS.Entity.EntityWithStrId import EntityWithStrId
+
+TrackTypes = Literal[
+    "nucleotide_sequence",
+    "image",
+    "matrix_real",
+    "pdf",
+    "table",
+    "XY_complex",
+    "XY_real",
+]
+
+_T = TypeVar("_T", bound=Union[Datatrack, Dict[str, Datatrack]])
+
+
+class Track(Generic[_T], EntityWithStrId):
+    _name: Optional[str] = None
+    _type: Optional[TrackTypes] = None
+    _tags: Optional[List[str]] = None
+    _settings: TrackSettings = TrackSettings()
+    _dataIds: Optional[dict] = None
+    _datatracks: Optional[_T] = None
+
+    def fromDict(self, ref) -> None:
+        if isinstance(ref, dict):
+            if "data" in ref:
+                self._dataIds = self.checkAndConvertNullable(ref["data"], dict)
+                ref["data"] = None
+
+        super().fromDict(ref)
+
+    def toDict(self) -> Dict[str, Any]:
+        d = super().toDict()
+        if isinstance(self.datatracks, TrackData):
+            d["data"] = self.datatracks.toData()
+        return d
+
+    def __str__(self):
+        s = (" name:'%s'" % getattr(self, "name")) if hasattr(self, "name") else ""
+        return "<%s id:%s%s>" % (type(self).__name__, str(self.id), s)
+
+    def _fetchData(self):
+        if isinstance(self.datatracks, dict):
+            for t in self.datatracks.values():
+                t.fetchFull()
+
+    def fetchFull(self):
+        self._fetchData()
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvertNullable(value, str, "name")
+
+    @property
+    def type(self) -> Optional[TrackTypes]:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = cast(TrackTypes, self.checkAndConvertNullable(value, str, "type"))
+
+    @property
+    def tags(self) -> Optional[List[str]]:
+        return self._tags
+
+    @tags.setter
+    def tags(self, value):
+        self._tags = self.checkListAndConvertNullable(value, str, "tags")
+
+    @property
+    def settings(self) -> TrackSettings:
+        return self._settings
+
+    @settings.setter
+    def settings(self, value):
+        self._settings = self.checkAndConvert(value, TrackSettings, "settings")
+
+    @property
+    def datatracks(self) -> Optional[_T]:
+        return self._datatracks
+
+    @datatracks.setter
+    def datatracks(self, value):
+        self._datatracks = cast(Any, self.checkAndConvertNullable(value, dict, "data"))

LOGS/Entities/TrackData.py

@@ -0,0 +1,20 @@
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class TrackData(SerializableContent):
+    def fetchFull(self):
+        raise NotImplementedError(
+            "Specific %a class for this track type is not implemented yet."
+            % type(self).__name__
+        )
+
+    def toData(self):
+        from LOGS.Entities.Datatrack import Datatrack
+
+        d = {}
+        for key in self.__dict__:
+            if key.startswith("_"):
+                a = getattr(self, key)
+                if isinstance(a, Datatrack):
+                    d[key[1:]] = a.id
+        return d

LOGS/Entities/TrackImage.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from LOGS.Entities.Track import Track
+from LOGS.Entities.TrackImageData import TrackImageData
+
+
+class TrackImage(Track):
+    _datatracks: Optional[TrackImageData] = None
+
+    def _fetchData(self):
+        if self.datatracks:
+            if self.datatracks.image:
+                self.datatracks.image.fetchFull()
+
+    @property
+    def datatracks(self) -> Optional[TrackImageData]:
+        return self._datatracks
+
+    @datatracks.setter
+    def datatracks(self, value):
+        self._datatracks = self.checkAndConvertNullable(value, TrackImageData, "data")

LOGS/Entities/TrackImageData.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from LOGS.Entities.DatatrackImage import DatatrackImage
+from LOGS.Entities.TrackData import TrackData
+
+
+class TrackImageData(TrackData):
+    _image: Optional[DatatrackImage] = None
+
+    def fetchFull(self):
+        if self.image:
+            self.image.fetchFull()
+
+    @property
+    def image(self) -> Optional[DatatrackImage]:
+        return self._image
+
+    @image.setter
+    def image(self, value):
+        self._image = self.checkAndConvertNullable(value, DatatrackImage, "image")

LOGS/Entities/TrackMatrix.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from LOGS.Entities.Track import Track
+from LOGS.Entities.TrackMatrixData import TrackMatrixData
+
+
+class TrackMatrix(Track):
+    _datatracks: Optional[TrackMatrixData] = None
+
+    def _fetchData(self):
+        if self.datatracks:
+            if self.datatracks.matrix:
+                self.datatracks.matrix.fetchFull()
+
+    def __iter__(self):
+        if self.datatracks is not None and self.datatracks.matrix is not None:
+            for i in self.datatracks.matrix:
+                yield i[0], i[1], self.datatracks.matrix.getValueFromIndex(i)
+
+    @property
+    def datatracks(self) -> Optional[TrackMatrixData]:
+        return self._datatracks
+
+    @datatracks.setter
+    def datatracks(self, value):
+        self._datatracks = self.checkAndConvertNullable(
+            value, TrackMatrixData, "datatracks"
+        )

LOGS/Entities/TrackMatrixData.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from LOGS.Entities.DatatrackNumericMatrix import DatatrackNumericMatrix
+from LOGS.Entities.TrackData import TrackData
+
+
+class TrackMatrixData(TrackData):
+    _matrix: Optional[DatatrackNumericMatrix] = None
+
+    def fetchFull(self):
+        if self.matrix:
+            self.matrix.fetchFull()
+
+    @property
+    def matrix(self) -> Optional[DatatrackNumericMatrix]:
+        return self._matrix
+
+    @matrix.setter
+    def matrix(self, value):
+        self._matrix = self.checkAndConvertNullable(
+            value, DatatrackNumericMatrix, "matrix"
+        )

LOGS/Entities/TrackSettings.py

@@ -0,0 +1,55 @@
+from typing import Optional
+
+from LOGS.Entities.AxisNaming import AxisNaming
+from LOGS.Entities.AxisZoom import AxisZoom
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class TrackSettings(SerializableContent):
+    """LOGS general Track settings"""
+
+    _color: Optional[str] = None
+    _axisUnits: Optional[AxisNaming] = None
+    _axisLabels: Optional[AxisNaming] = None
+    _visible: Optional[bool] = None
+    _zoom: Optional[AxisZoom] = None
+
+    @property
+    def color(self) -> Optional[str]:
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        self._color = self.checkAndConvertNullable(value, str, "color")
+
+    @property
+    def axisUnits(self) -> Optional[AxisNaming]:
+        return self._axisUnits
+
+    @axisUnits.setter
+    def axisUnits(self, value):
+        self._axisUnits = self.checkAndConvertNullable(value, AxisNaming, "axisUnits")
+
+    @property
+    def axisLabels(self) -> Optional[AxisNaming]:
+        return self._axisLabels
+
+    @axisLabels.setter
+    def axisLabels(self, value):
+        self._axisLabels = self.checkAndConvertNullable(value, AxisNaming, "axisLabels")
+
+    @property
+    def visible(self) -> Optional[bool]:
+        return self._visible
+
+    @visible.setter
+    def visible(self, value):
+        self._visible = self.checkAndConvertNullable(value, bool, "visible")
+
+    @property
+    def zoom(self) -> Optional[AxisZoom]:
+        return self._zoom
+
+    @zoom.setter
+    def zoom(self, value):
+        self._zoom = self.checkAndConvertNullable(value, AxisZoom, "zoom")

LOGS/Entities/TrackTable.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from LOGS.Entities.Track import Track
+from LOGS.Entities.TrackTableData import TrackTableData
+
+
+class TrackTable(Track):
+    _datatracks: Optional[TrackTableData] = None
+
+    def _fetchData(self):
+        if self.datatracks:
+            if self.datatracks.table:
+                self.datatracks.table.fetchFull()
+
+    @property
+    def datatracks(self) -> Optional[TrackTableData]:
+        return self._datatracks
+
+    @datatracks.setter
+    def datatracks(self, value):
+        self._datatracks = self.checkAndConvertNullable(value, TrackTableData, "data")

LOGS/Entities/TrackTableData.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from LOGS.Entities.DatatrackFormattedTable import DatatrackFormattedTable
+from LOGS.Entities.TrackData import TrackData
+
+
+class TrackTableData(TrackData):
+    _table: Optional[DatatrackFormattedTable] = None
+
+    def fetchFull(self):
+        if self.table:
+            self.table.fetchFull()
+
+    @property
+    def table(self) -> Optional[DatatrackFormattedTable]:
+        return self._table
+
+    @table.setter
+    def table(self, value):
+        self._table = self.checkAndConvertNullable(
+            value, DatatrackFormattedTable, "matrix"
+        )

LOGS/Entities/TrackXY.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+from LOGS.Entities.Track import Track
+from LOGS.Entities.TrackXYData import TrackXYData
+
+
+class TrackXY(Track):
+    _datatracks: Optional[TrackXYData] = None
+
+    def _fetchData(self):
+        if self.datatracks:
+            if self.datatracks.x:
+                self.datatracks.x.cacheDir = self.cacheDir
+                self.datatracks.x.fetchFull()
+            if self.datatracks.y:
+                self.datatracks.y.cacheDir = self.cacheDir
+                self.datatracks.y.fetchFull()
+
+    def __iter__(self):
+        if (
+            self.datatracks is not None
+            and self.datatracks.x is not None
+            and self.datatracks.x.count is not None
+            and self.datatracks.x.data is not None
+            and self.datatracks.y is not None
+            and self.datatracks.y.count is not None
+            and self.datatracks.y.data is not None
+        ):
+            for i in range(min(self.datatracks.x.count, self.datatracks.y.count)):
+                yield self.datatracks.x.data[i], self.datatracks.y.data[i]
+
+    @property
+    def datatracks(self) -> Optional[TrackXYData]:
+        return self._datatracks
+
+    @datatracks.setter
+    def datatracks(self, value):
+        self._datatracks = self.checkAndConvertNullable(
+            value, TrackXYData, "datatracks"
+        )

LOGS/Entities/TrackXYComplex.py

@@ -0,0 +1,51 @@
+from typing import Optional
+
+from LOGS.Entities.Track import Track
+from LOGS.Entities.TrackXYComplexData import TrackXYComplexData
+
+
+class TrackXYComplex(Track):
+    _datatracks: Optional[TrackXYComplexData] = None
+
+    def _fetchData(self):
+        if self.datatracks:
+            if self.datatracks.x:
+                self.datatracks.x.fetchFull()
+            if self.datatracks.re:
+                self.datatracks.re.fetchFull()
+            if self.datatracks.im:
+                self.datatracks.im.fetchFull()
+
+    def __iter__(self):
+        if (
+            self.datatracks is not None
+            and self.datatracks.x is not None
+            and self.datatracks.x.count is not None
+            and self.datatracks.x.data is not None
+            and self.datatracks.re is not None
+            and self.datatracks.re.count is not None
+            and self.datatracks.re.data is not None
+            and self.datatracks.im is not None
+            and self.datatracks.im.count is not None
+            and self.datatracks.im.data is not None
+        ):
+            for i in range(
+                min(
+                    self.datatracks.x.count,
+                    self.datatracks.re.count,
+                    self.datatracks.im.count,
+                )
+            ):
+                yield self.datatracks.x.data[i], self.datatracks.re.data[
+                    i
+                ], self.datatracks.im.data[i]
+
+    @property
+    def datatracks(self) -> Optional[TrackXYComplexData]:
+        return self._datatracks
+
+    @datatracks.setter
+    def datatracks(self, value):
+        self._datatracks = self.checkAndConvertNullable(
+            value, TrackXYComplexData, "datatracks"
+        )

LOGS/Entities/TrackXYComplexData.py

@@ -0,0 +1,50 @@
+from typing import Optional
+
+from numpy import ndarray, vectorize
+
+from LOGS.Entities.DatatrackNumericArray import DatatrackNumericArray
+from LOGS.Entities.TrackData import TrackData
+
+
+class TrackXYComplexData(TrackData):
+    _x: Optional[DatatrackNumericArray] = None
+    _re: Optional[DatatrackNumericArray] = None
+    _im: Optional[DatatrackNumericArray] = None
+
+    def fetchFull(self):
+        if self.x:
+            self.x.fetchFull()
+        if self.re:
+            self.re.fetchFull()
+        if self.im:
+            self.im.fetchFull()
+
+    @property
+    def x(self) -> Optional[DatatrackNumericArray]:
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        self._x = self.checkAndConvertNullable(value, DatatrackNumericArray, "x")
+
+    @property
+    def re(self) -> Optional[DatatrackNumericArray]:
+        return self._re
+
+    @re.setter
+    def re(self, value):
+        self._re = self.checkAndConvertNullable(value, DatatrackNumericArray, "re")
+
+    @property
+    def im(self) -> Optional[DatatrackNumericArray]:
+        return self._im
+
+    @im.setter
+    def im(self, value):
+        self._im = self.checkAndConvertNullable(value, DatatrackNumericArray, "im")
+
+    @property
+    def y(self) -> Optional[ndarray]:
+        if not self.re or not self.im:
+            return None
+        return vectorize(complex)(self.re.data, self.im.data)

LOGS/Entities/TrackXYData.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from LOGS.Entities.DatatrackNumericArray import DatatrackNumericArray
+from LOGS.Entities.TrackData import TrackData
+
+
+class TrackXYData(TrackData):
+    _x: Optional[DatatrackNumericArray] = None
+    _y: Optional[DatatrackNumericArray] = None
+
+    def fetchFull(self):
+        if self.x:
+            self.x.fetchFull()
+        if self.y:
+            self.y.fetchFull()
+
+    @property
+    def x(self) -> Optional[DatatrackNumericArray]:
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        self._x = self.checkAndConvertNullable(value, DatatrackNumericArray, "x")
+
+    @property
+    def y(self) -> Optional[DatatrackNumericArray]:
+        return self._y
+
+    @y.setter
+    def y(self, value):
+        self._y = self.checkAndConvertNullable(value, DatatrackNumericArray, "y")

LOGS/Entities/Vendor.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entity.EntityWithStrId import EntityWithStrId
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.LOGSConnection import LOGSConnection
+
+
+@Endpoint("vendors")
+class Vendor(EntityWithStrId, INamedEntity):
+    _description: Optional[str]
+    _icon: Optional[str]
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[str] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+
+        self._description = None
+        self._icon = None
+        super().__init__(ref=ref, id=id, connection=connection)
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def icon(self) -> Optional[str]:
+        return self._icon
+
+    @icon.setter
+    def icon(self, value):
+        self._icon = self.checkAndConvertNullable(value, str, "icon")

LOGS/Entities/VendorMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.Vendor import Vendor
+from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
+
+
+@FullModel(Vendor)
+class VendorMinimal(EntityMinimalWithStrId[Vendor]):
+    pass

LOGS/Entities/VendorRequestParameter.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Optional, Type
+
+from LOGS.Entity.EntityRequestParameter import (
+    DefaultSortingOptions,
+    EntityRequestParameter,
+)
+
+
+@dataclass
+class VendorRequestParameter(EntityRequestParameter[DefaultSortingOptions]):
+    _orderByType: Type[DefaultSortingOptions] = field(
+        default=DefaultSortingOptions, init=False
+    )
+
+    name: Optional[str] = None
+    includeIcon: Optional[bool] = None

LOGS/Entities/Vendors.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Vendor import Vendor
+from LOGS.Entities.VendorRequestParameter import VendorRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("vendors")
+class Vendors(EntityIterator[Vendor, VendorRequestParameter]):
+    """LOGS connected class Vendors iterator"""
+
+    _generatorType = Vendor
+    _parameterType = VendorRequestParameter