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

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/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

@@ -10,8 +10,10 @@ class TrackXY(Track):
     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):
@@ -33,4 +35,6 @@ class TrackXY(Track):
 
     @datatracks.setter
     def datatracks(self, value):
-        self._datatracks = self.checkAndConvertNullable(value, TrackXYData, "data")
+        self._datatracks = self.checkAndConvertNullable(
+            value, TrackXYData, "datatracks"
+        )

LOGS/Entities/TrackXYComplex.py

@@ -47,5 +47,5 @@ class TrackXYComplex(Track):
     @datatracks.setter
     def datatracks(self, value):
         self._datatracks = self.checkAndConvertNullable(
-            value, TrackXYComplexData, "data"
+            value, TrackXYComplexData, "datatracks"
         )

LOGS/Entities/__init__.py

@@ -15,10 +15,14 @@ from .BridgeMinimal import *
 from .BridgeRequestParameter import *
 from .BridgeType import *
 from .CustomField import *
-from .CustomFieldEnums import *
+from .CustomFieldModels import *
 from .CustomFieldRequestParameter import *
+from .CustomFieldValue import *
 from .CustomSchema import *
 from .CustomSchemaSection import *
+from .CustomType import *
+from .CustomTypeMinimal import *
+from .CustomTypeRequestParameter import *
 from .Dataset import *
 from .DatasetCreator import *
 from .DatasetInfo import *
@@ -28,14 +32,15 @@ from .DatasetMinimal import *
 from .DatasetRelations import *
 from .DatasetRequestParameter import *
 from .Datasets import *
-from .DatasetType import *
-from .DatasetTypeMinimal import *
 from .DatasetUploadParameter import *
 from .DataSource import *
 from .DataSourceMinimal import *
 from .DataSourceRequestParameter import *
 from .Datatrack import *
+from .DatatrackFormattedTable import *
+from .DatatrackImage import *
 from .DatatrackNumericArray import *
+from .DatatrackNumericMatrix import *
 from .Document import *
 from .DocumentRelations import *
 from .DocumentRequestParameter import *
@@ -63,10 +68,23 @@ from .Instrument import *
 from .InstrumentMinimal import *
 from .InstrumentRequestParameter import *
 from .Instruments import *
+from .Inventory import *
+from .InventoryMinimal import *
+from .InventoryRequestParameter import *
+from .LabNotebook import *
 from .LabNotebookEntries import *
-from .LabNotebookEntry import *
+from .LabNotebookEntryContent import *
 from .LabNotebookEntryMinimal import *
+from .LabNotebookEntryRelations import *
 from .LabNotebookEntryRequestParameter import *
+from .LabNotebookExperiment import *
+from .LabNotebookExperimentMinimal import *
+from .LabNotebookExperimentRequestParameter import *
+from .LabNotebookExperiments import *
+from .LabNotebookMinimal import *
+from .LabNotebookModels import *
+from .LabNotebookRequestParameter import *
+from .LabNotebooks import *
 from .Method import *
 from .MethodMinimal import *
 from .MethodRequestParameter import *
@@ -94,11 +112,12 @@ from .SampleMinimal import *
 from .SampleRelations import *
 from .SampleRequestParameter import *
 from .Samples import *
-from .SampleType import *
-from .SampleTypeMinimal import *
-from .SampleTypeRequestParameter import *
 from .Track import *
 from .TrackData import *
+from .TrackImage import *
+from .TrackImageData import *
+from .TrackMatrix import *
+from .TrackMatrixData import *
 from .TrackSettings import *
 from .TrackXY import *
 from .TrackXYComplex import *

LOGS/Entity/ConnectedEntity.py

@@ -9,7 +9,9 @@ class ConnectedEntity(SerializeableContent):
     _connection: Optional[LOGSConnection]
     _endpoint: Optional[List[str]] = None
     _uiEndpoint: Optional[List[str]] = None
-    _noSerialize = ["connection"]
+    _noSerialize = ["connection", "cachePath", "cacheId", "cacheDir"]
+    _cacheDir: Optional[str] = None
+    _cacheId: str = cast(str, None)
 
     def __init__(self, ref=None, connection: Optional[LOGSConnection] = None):
         self._connection = connection
@@ -24,6 +26,24 @@ class ConnectedEntity(SerializeableContent):
             raise EntityNotConnectedException(self)
         return self._connection
 
+    def _getConnectionData(self):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Endpoint missing for of entity type %a."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != ConnectedEntity.__name__
+                    else "unknown"
+                )
+            )
+
+        return self._getConnection(), self._endpoint
+
+    def clearCache(self):
+        raise NotImplementedError(
+            "Clearing cache of %a class is not implemented." % type(self).__name__
+        )
+
     @property
     def connection(self) -> Optional[LOGSConnection]:
         return self._connection
@@ -43,3 +63,21 @@ class ConnectedEntity(SerializeableContent):
     @property
     def identifier(self):
         return "%s" % (type(self).__name__)
+
+    @property
+    def cacheDir(self) -> Optional[str]:
+        return self._cacheDir
+
+    @cacheDir.setter
+    def cacheDir(self, value):
+        self._cacheDir = self.checkAndConvertNullable(value, str, "cacheDir")
+
+    @property
+    def cacheId(self) -> str:
+        if self._cacheId is None:
+            if not hasattr(self, "id"):
+                setattr(self, "id", self.generateID())
+
+            return f"{type(self).__name__}_{str(getattr(self, 'id'))}"
+        else:
+            return self._cacheId

LOGS/Entity/Entity.py

@@ -1,6 +1,6 @@
 from typing import Any, Optional, cast
 
-from LOGS.Auxiliary import MinimalModelGenerator
+from LOGS.Auxiliary import MinimalModelGenerator, Tools
 from LOGS.Auxiliary.Constants import Constants
 from LOGS.Auxiliary.Exceptions import (
     EntityDeletingException,
@@ -32,24 +32,15 @@ class Entity(ConnectedEntity):
         super().__init__(ref=ref, connection=connection)
 
     def _getConnectionData(self):
-        if not self._endpoint:
-            raise NotImplementedError(
-                "Endpoint missing for of entity type %a."
-                % (
-                    type(self).__name__
-                    if type(self).__name__ != Entity.__name__
-                    else "unknown"
-                )
-            )
+        (connection, endpoint) = super()._getConnectionData()
 
         if not self.id:
             raise EntityNotFoundException(self)
 
-        return self._getConnection(), self._endpoint, self.id
+        return connection, endpoint, self.id
 
     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)
+        return Tools.ObjectToString(self)
 
     def getUIUrl(self) -> str:
         if not self._uiEndpoint:
@@ -188,7 +179,11 @@ class Entity(ConnectedEntity):
 
     @property
     def identifier(self):
-        name = f"'{getattr(self, 'name')}'" if hasattr(self, "name") else None
+        name = (
+            f" '{getattr(self, 'name')}'"
+            if hasattr(self, "name") and getattr(self, "name")
+            else ""
+        )
         return "%s(id:%s)%s" % (
             type(self).__name__,
             str(self.id),

LOGS/Entity/SerializeableContent.py

@@ -2,7 +2,6 @@ import inspect
 import json
 import math
 import random
-from copy import deepcopy
 from datetime import datetime
 from enum import Enum
 from typing import (
@@ -32,7 +31,12 @@ _T = TypeVar("_T")
 class SerializeableContent:
     _noSerialize: List[str] = []
     _typeMapper: Optional[Dict[str, Any]] = None
-    _planeClass = False
+    _slack: Dict[str, Any] = {}
+
+    _planeClass: bool = False
+    _includeNone: bool = False
+    _debugPrintRef: bool = False
+    _includeSlack: bool = False
 
     def __init__(self, ref=None):
         if ref != None:
@@ -45,23 +49,25 @@ class SerializeableContent:
         self,
         ref,
         selfClass,
-        fromInstance=None,
-        fromDict=None,
-        formatDict=None,
         convertOtherType: Optional[Tuple[type, Callable[[Any], Any]]] = None,
     ):
-        # print("FromRef", selfClass.__name__, self._json_schema)
+        if self._debugPrintRef:
+            print("FromRef", selfClass.__name__, "\n", self._dictToJson(ref))
 
-        # if not isinstance(ref, (selfClass, dict)) and convertOtherType:
-        #     ref = convertOtherType(ref)
         if convertOtherType and isinstance(ref, convertOtherType[0]):
             ref = convertOtherType[1](ref)
 
-        if isinstance(ref, selfClass):
-            if fromInstance:
-                fromInstance(ref)
-            else:
-                self.fromInstance(ref)
+        serializableAncestors = tuple(
+            [
+                c
+                for c in inspect.getmro(selfClass)
+                if issubclass(c, SerializeableContent)
+            ]
+        )
+
+        # if isinstance(ref, selfClass):
+        if isinstance(ref, serializableAncestors):
+            self.fromInstance(ref)
         elif isinstance(ref, dict):
             if hasattr(self, "_typeMapper") and self._typeMapper:
                 for k, t in self._typeMapper.items():
@@ -75,10 +81,7 @@ class SerializeableContent:
                                 elements=ref, fieldName=k, fieldType=t, allowNone=True
                             )
 
-            if fromDict:
-                fromDict(ref)
-            else:
-                self.fromDict(ref, formatDict=formatDict)
+            self.fromDict(ref)
         else:
             types: List[type] = [dict, type(self)]
             if convertOtherType:
@@ -99,21 +102,73 @@ class SerializeableContent:
         attrList = self._getAttrList()
         for k in attrList:
             if hasattr(ref, k):
-                setattr(self, k, getattr(ref, k))
+                try:
+                    setattr(self, k, getattr(ref, k))
+                except AttributeError:
+                    pass
 
-    def fromDict(self, ref, formatDict=None) -> None:
-        if formatDict:
-            ref = deepcopy(ref)
-            ref = formatDict(ref)
-            if ref == None:
-                ref = {}
+    def _getSlack(self, ignoreClasses: Optional[List[Type]] = None):
+        slack = {"class": type(self).__name__, "slack": {}}
+        if self._slack:
+            slack["slack"]["self"] = self._slack
+        attrList = self._getAttrList()
+        for k in attrList:
+            try:
+                if hasattr(self, k):
+                    item = getattr(self, k)
+                    if isinstance(item, list):
+                        slacks = {}
+                        for i, e in enumerate(item):
+                            if ignoreClasses and any(
+                                type(e) == c for c in ignoreClasses
+                            ):
+                                continue
+                            if isinstance(e, SerializeableContent):
+                                s = e._getSlack(ignoreClasses=ignoreClasses)
+                                if s["slack"]:
+                                    slacks[f"{k}[{i}]"] = s
+                        if slacks:
+                            slack["slack"].update(slacks)
+
+                    if isinstance(item, SerializeableContent):
+                        if ignoreClasses and any(
+                            type(item) == c for c in ignoreClasses
+                        ):
+                            continue
+                        s = item._getSlack(ignoreClasses=ignoreClasses)
+                        if s["slack"]:
+                            slack["slack"][k] = s
+            except AttributeError:
+                pass
+
+        return slack
+
+    def _printSlackDict(self, slack: dict, prefix=""):
+        if not slack or "slack" not in slack or not slack["slack"]:
+            return
+
+        prefix += slack["class"] if prefix == "" else f"({slack['class']})"
+        if "self" in slack["slack"]:
+            print(f"{prefix}: '{slack['slack']['self']}'")
+        for k, v in slack["slack"].items():
+            if k == "self":
+                continue
+            self._printSlackDict(v, prefix + f".{k}")
 
-        # if "type" in ref:
-        #     self.type = ref["type"]
+    def _printSlack(self, prefix="", ignoreClasses: Optional[List[Type]] = None):
+        self._printSlackDict(self._getSlack(ignoreClasses=ignoreClasses))
 
-        # self.validateDict(ref)
+    def fromDict(self, ref) -> None:
         # print("ref", ref)
         # print("ref", type(self).__name__)
+        if not hasattr(self, "_noSerialize"):
+            self._noSerialize = []
+
+        mappedKey = {
+            k: False
+            for k, v in ref.items()
+            if v is not None and k not in self._noSerialize
+        }
 
         for k in dir(self):
             # print(
@@ -123,19 +178,27 @@ class SerializeableContent:
             #     "->",
             #     ref[k] if k in ref else "NULL",
             # )
-            if k in ref and hasattr(self, k) and not callable(getattr(self, k)):
+
+            try:
+                hasAttr = hasattr(self, k)
+            except (
+                EntityIncompleteException
+            ):  # while deserializing we want to ignore incomplete fields
+                hasAttr = False
+
+            if k in ref and hasAttr and not callable(getattr(self, k)):
                 try:
                     # print("  ", k, "->", ref[k])
                     setattr(self, k, ref[k])
+                    mappedKey[k] = True
                 except AttributeError as e:
                     # print(f"[{type(self).__name__}] ERROR:", k, "->", ref[k], e)
                     pass
 
-        # This is the old way to check if settable: checks if a private attr exists and sets this
-        # setattr(self, k, [])
-        # if hasattr(self, _k) and not callable(getattr(self, _k)) and k in ref:
-        #     print(k, "->", ref[k])
-        #     setattr(self, _k, ref[k])
+        self._slack = {k: ref[k] for k, v in mappedKey.items() if not v}
+
+        # if self._slack:
+        #     print(type(self).__name__, "->", ", ".join(self._slack.keys()))
 
     @classmethod
     def toBaseclassString(cls, obj):
@@ -148,11 +211,13 @@ class SerializeableContent:
     def toString(self):
         return str(self)
 
-    @classmethod
-    def _serializeItem(cls, item):
+    def _serializeItem(self, item):
         # print("serialize", item, hasattr(item, "__dict__"))
         if hasattr(item, "toDict"):
-            return item.toDict()
+            if self._includeSlack and hasattr(item, "_toDictWithSlack"):
+                return item._toDictWithSlack()
+            else:
+                return item.toDict()
         if isinstance(item, cast(Any, np.float32)):
             return item.item()
         elif hasattr(
@@ -199,6 +264,13 @@ class SerializeableContent:
 
         return result
 
+    def _toDictWithSlack(self):
+        tmp = self._includeSlack
+        self._includeSlack = True
+        result = self.toDict()
+        self._includeSlack = tmp
+        return result
+
     def toDict(self) -> Dict[str, Any]:
         # print("toDict", type(self).__name__)
         if not hasattr(self, "_noSerialize"):
@@ -233,9 +305,12 @@ class SerializeableContent:
                 # d[k] = "2021-12-01T00:00:00.000Z"
             elif isinstance(a, Enum):
                 d[k] = a.value
-            elif a != None:
+            elif a != None or self._includeNone:
                 d[k] = self._serializeItem(a)
 
+        if self._includeSlack:
+            d.update({k: v for k, v in self._slack.items() if k not in d})
+
         return d
 
     @classmethod
@@ -274,12 +349,16 @@ class SerializeableContent:
             self.toDict(), indent=indent, sort_keys=sort_keys, compact=compact
         )
 
-    def printJson(self, validate=False):
-        print(self.toJson(validate=validate))
+    def printJson(self, indent=2, sort_keys=True, compact=False, validate=False):
+        print(
+            self.toJson(
+                validate=validate, indent=indent, sort_keys=sort_keys, compact=compact
+            )
+        )
 
     @classmethod
     def truncString(cls, text: str, length: int = 30) -> str:
-        return Tools.truncString(text=text, length=length)
+        return Tools.truncString(text=str(text), length=length)
 
     @staticmethod
     def delEntryFromDict(d: dict, entry: str):
@@ -515,11 +594,14 @@ class SerializeableContent:
                 excludeCharacters.append("line feed")
             for k in text.keys():
                 if k not in excludeKeys:
-                    text[k], messages = cls.replaceControlCharacters(
-                        text[k],
-                        excludeKeys=excludeKeys,
-                        excludeCharacters=excludeCharacters,
-                        mergeMessages=mergeMessages,
+                    text[k], messages = cast(
+                        Any,
+                        cls.replaceControlCharacters(
+                            text[k],
+                            excludeKeys=excludeKeys,
+                            excludeCharacters=excludeCharacters,
+                            mergeMessages=mergeMessages,
+                        ),
                     )
                     if messages:
                         for m in messages:

LOGS/Interfaces/IHierarchyType.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary import Tools
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class IHierarchyTypeRequest:
+    childrenOfParentIds: Optional[List[int]] = None
+    descendantsOfIds: Optional[List[int]] = None
+    isRoot: Optional[List[bool]] = None
+
+
+class IHierarchyType(IEntityInterface):
+    _inventoryName: Optional[str]
+    _isHierarchyRoot: Optional[bool]
+    _rootHierarchy: Optional[EntityMinimalWithIntId]
+    _parentTypes: Optional[List[EntityMinimalWithIntId]]
+
+    @property
+    def inventoryName(self) -> Optional[str]:
+        return self._inventoryName
+
+    @inventoryName.setter
+    def inventoryName(self, value):
+        self._inventoryName = Tools.checkAndConvert(
+            value, str, "inventoryName", allowNone=True
+        )
+
+    @property
+    def isHierarchyRoot(self) -> Optional[bool]:
+        return self._isHierarchyRoot
+
+    @isHierarchyRoot.setter
+    def isHierarchyRoot(self, value):
+        self._isHierarchyRoot = Tools.checkAndConvert(
+            value, bool, "isHierarchyRoot", allowNone=True
+        )
+
+    @property
+    def rootHierarchy(self) -> Optional[EntityMinimalWithIntId]:
+        return self._rootHierarchy
+
+    @rootHierarchy.setter
+    def rootHierarchy(self, value):
+        self._rootHierarchy = Tools.checkAndConvert(
+            value, EntityMinimalWithIntId, "rootHierarchy", allowNone=True
+        )
+
+    @property
+    def parentTypes(self) -> Optional[List[EntityMinimalWithIntId]]:
+        return self._parentTypes
+
+    @parentTypes.setter
+    def parentTypes(self, value):
+        self._parentTypes = Tools.checkListAndConvert(
+            value, EntityMinimalWithIntId, "parentTypes", allowNone=True
+        )

LOGS/Interfaces/IPermissionedEntity.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Generic, Optional, Type, TypeVar, cast
 
 from LOGS.Auxiliary import Tools
+from LOGS.Entity.SerializeableContent import SerializeableClass
 from LOGS.Interfaces.IEntityInterface import IEntityInterface
 
 if TYPE_CHECKING:
@@ -13,15 +14,38 @@ class IPermissionedEntityRequest:
     includePermissions: Optional[bool] = None
 
 
-class IPermissionedEntity(IEntityInterface):
-    _permissions: Optional[dict[str, bool]] = None
+class IPermissionModel:
+    edit: Optional[bool] = None
+
+
+class GenericPermission(IPermissionModel, SerializeableClass):
+    edit: Optional[bool] = False
+
+
+_PERMISSION = TypeVar("_PERMISSION", bound=IPermissionModel)
+
+
+class IPermissionedEntity(Generic[_PERMISSION], IEntityInterface):
+    _permissionType: Optional[Type[_PERMISSION]] = None
+
+    _permissions: Optional[_PERMISSION] = None
 
     @property
-    def permissions(self) -> Optional[dict[str, bool]]:
+    def permissions(self) -> Optional[_PERMISSION]:
         return self._permissions
 
     @permissions.setter
     def permissions(self, value):
+        if not self._permissionType:
+            raise NotImplementedError("Permission type must be set")
+
         self._permissions = Tools.checkAndConvert(
-            value, dict, "permissions", allowNone=True
+            value,
+            cast(Type[_PERMISSION], self._permissionType),
+            "permissions",
+            allowNone=True,
         )
+
+
+class GenericPermissionEntity(IPermissionedEntity[GenericPermission]):
+    _permissionType: Type[GenericPermission] = GenericPermission

LOGS/Interfaces/IProjectBased.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
 
 @dataclass
 class IProjectBasedRequest:
-    projects: Optional[List[str]] = None
+    projectIds: Optional[List[int]] = None
 
 
 class IProjectBased(IEntityInterface):