logs-py 2.9.6__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

@@ -53,14 +53,20 @@ class SerializeableContent:
     ):
         if self._debugPrintRef:
             print("FromRef", selfClass.__name__, "\n", self._dictToJson(ref))
-        # print("FromRef", selfClass.__name__, self._json_schema)
 
-        # 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):
+        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:
@@ -101,6 +107,57 @@ class SerializeableContent:
                 except AttributeError:
                     pass
 
+    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}")
+
+    def _printSlack(self, prefix="", ignoreClasses: Optional[List[Type]] = None):
+        self._printSlackDict(self._getSlack(ignoreClasses=ignoreClasses))
+
     def fromDict(self, ref) -> None:
         # print("ref", ref)
         # print("ref", type(self).__name__)
@@ -301,7 +358,7 @@ class SerializeableContent:
 
     @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):

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, Dict, 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):

LOGS/Interfaces/ITypedEntity.py

@@ -1,28 +1,85 @@
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, List, Optional, Sequence, Union
 
 from LOGS.Auxiliary import Tools
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromSingle
+from LOGS.Entities.CustomFieldValue import (
+    CustomFieldValue,
+    CustomSectionValue,
+    ICustomValue,
+)
+from LOGS.Entities.CustomFieldValueConverter import CustomFieldValueConverter
 from LOGS.Interfaces.IEntityInterface import IEntityInterface
 
 if TYPE_CHECKING:
-    pass
+    from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
 
 
 @dataclass
 class ITypedEntityRequest:
-    includeCustomFields: Optional[bool] = None
-    customFields: Optional[Dict[str, Any]] = None
+    includeCustomFields: Optional[List[bool]] = None
 
 
 class ITypedEntity(IEntityInterface):
-    _customFields: Optional[Dict[str, Any]] = None
+    _customType: Optional["CustomTypeMinimal"] = None
+    _customValues: Optional[
+        Sequence[Union["CustomFieldValue", "CustomSectionValue"]]
+    ] = None
+
+    def _customValueConverter(self, value):
+        return Tools.checkListAndConvert(
+            value, ICustomValue, "customValues", allowNone=True
+        )
 
     @property
-    def customFields(self) -> Optional[Dict[str, Any]]:
-        return self._customFields
+    def customType(self) -> Optional["CustomTypeMinimal"]:
+        return self._customType
 
-    @customFields.setter
-    def customFields(self, value):
-        self._customFields = Tools.checkAndConvert(
-            value, dict, "customFields", allowNone=True
-        )
+    @customType.setter
+    def customType(self, value):
+        self._customType = MinimalFromSingle(value, "CustomTypeMinimal", "customType")
+
+    @property
+    def customValues(
+        self,
+    ) -> Optional[
+        Union[
+            Sequence[Union["CustomFieldValue", "CustomSectionValue"]],
+            Union["CustomFieldValue", "CustomSectionValue"],
+        ]
+    ]:
+        return self._customValues
+
+    @customValues.setter
+    def customValues(self, value):
+        self._customValues = CustomFieldValueConverter.convert(value, "customValues")
+
+    def _extractCustomFieldValue(
+        self,
+        value: Union[
+            CustomFieldValue,
+            CustomSectionValue,
+            Sequence[Union[CustomFieldValue, CustomSectionValue]],
+        ],
+    ) -> List[CustomFieldValue]:
+        if isinstance(value, list):
+            result: List[CustomFieldValue] = []
+            for v in value:
+                result += self._extractCustomFieldValue(v)
+            return result
+        if isinstance(value, CustomFieldValue):
+            return [value]
+        if isinstance(value, CustomSectionValue):
+            if value.content:
+                return self._extractCustomFieldValue(value.content)
+
+        return []
+
+    @property
+    def customFieldValues(
+        self,
+    ) -> Optional[List["CustomFieldValue"]]:
+        if self.customValues == None:
+            return None
+
+        return self._extractCustomFieldValue(self.customValues)

LOGS/Interfaces/IVersionedEntity.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, List, Optional, TypeVar, Union
+
+from LOGS.Auxiliary import Tools
+from LOGS.Interfaces.ICreationRecord import ICreationRecord, ICreationRecordRequest
+from LOGS.Interfaces.IModificationRecord import (
+    IModificationRecord,
+    IModificationRecordRequest,
+)
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable, ISoftDeletableRequest
+
+if TYPE_CHECKING:
+    pass
+
+_idType = TypeVar("_idType", bound=Union[int, str])
+
+
+@dataclass
+class IVersionedEntityRequest(
+    Generic[_idType],
+    ICreationRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+):
+    originalIds: Optional[List[_idType]] = None
+    versionIds: Optional[List[int]] = None
+    versions: Optional[List[int]] = None
+
+
+class IVersionedEntity(ICreationRecord, IModificationRecord, ISoftDeletable):
+    _version: Optional[int] = None
+
+    @property
+    def version(self) -> Optional[int]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = Tools.checkAndConvert(value, int, "version", allowNone=True)