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

LOGS/Entities/DatasetInfo.py

@@ -2,10 +2,17 @@ from typing import List, Optional, TypeVar, Union, cast
 
 from LOGS.Entities.DatasetRequestParameter import ParsingStates
 from LOGS.Entities.Datatrack import Datatrack
+from LOGS.Entities.DatatrackFormattedTable import DatatrackFormattedTable
+from LOGS.Entities.DatatrackGeneric import DatatrackGeneric
+from LOGS.Entities.DatatrackImage import DatatrackImage
 from LOGS.Entities.DatatrackNumericArray import DatatrackNumericArray
+from LOGS.Entities.DatatrackNumericMatrix import DatatrackNumericMatrix
 from LOGS.Entities.HierarchyNode import HierarchyNode
 from LOGS.Entities.ParserLog import ParserLog
 from LOGS.Entities.Track import Track
+from LOGS.Entities.TrackImage import TrackImage
+from LOGS.Entities.TrackMatrix import TrackMatrix
+from LOGS.Entities.TrackTable import TrackTable
 from LOGS.Entities.TrackXY import TrackXY
 from LOGS.Entities.TrackXYComplex import TrackXYComplex
 from LOGS.Entity.SerializeableContent import SerializeableContent
@@ -72,10 +79,17 @@ class DatasetInfo(SerializeableContent):
     @classmethod
     def _trackConverter(cls, value: dict) -> TRACKS:
         if isinstance(value, dict) and "type" in value:
+            # print("_trackConverter", value["type"])
             if value["type"] == "XY_real":
                 return TrackXY(value)
             elif value["type"] == "XY_complex":
                 return TrackXYComplex(value)
+            elif value["type"] == "matrix_real":
+                return TrackMatrix(value)
+            elif value["type"] == "image":
+                return TrackImage(value)
+            elif value["type"] == "table":
+                return TrackTable(value)
             else:
                 return Track(value)
         else:
@@ -84,12 +98,19 @@ class DatasetInfo(SerializeableContent):
     @classmethod
     def _datatrackConverter(cls, value: dict) -> DATATRACKS:
         if isinstance(value, dict) and "type" in value:
+            # print("_datatrackConverter", value["type"])
             if value["type"] == "numeric_array":
                 return DatatrackNumericArray(value)
+            elif value["type"] == "numeric_matrix":
+                return DatatrackNumericMatrix(value)
+            elif value["type"] == "image":
+                return DatatrackImage(value)
+            elif value["type"] == "formatted_table":
+                return DatatrackFormattedTable(value)
             else:
-                return Datatrack(value)
+                return DatatrackGeneric(value)
         else:
-            return Datatrack(value)
+            return DatatrackGeneric(value)
 
     @property
     def tracks(self) -> Optional[List[Track]]:

LOGS/Entities/DatasetModels.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional
+
+from LOGS.Entity.SerializeableContent import SerializeableClass, SerializeableContent
+
+
+class DatasetSourceType(Enum):
+    ManualUpload = 0
+    SFTPAutoload = 1
+    ClientAutoload = 2
+    APIUpload = 3
+
+
+class ParsedMetadata(SerializeableContent):
+    Parameters: bool = False
+    Tracks: bool = False
+    TrackCount: int = False
+    TrackViewerTypes: List[str] = []
+
+
+@dataclass
+class DatasetSource(SerializeableClass):
+    id: Optional[int] = None
+    type: Optional[DatasetSourceType] = None
+    name: Optional[str] = None
+
+
+class ViewableEntityTypes(Enum):
+    ELN = "ELN"
+    CustomField = "CustomField"

LOGS/Entities/DatasetRequestParameter.py

@@ -4,12 +4,16 @@ from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Sequence
 
 from LOGS.Auxiliary.Constants import Constants
+from LOGS.Entities.DatasetModels import ViewableEntityTypes
 from LOGS.Entities.ICustomSchemaRequest import ICustomSchemaRequest
 from LOGS.Entities.IRelatedEntityRequest import IRelatedEntityRequest
 from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Interfaces.ICreationRecord import ICreationRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
 from LOGS.Interfaces.INamedEntity import INamedEntityRequest
 from LOGS.Interfaces.IOwnedEntity import IOwnedEntityRequest
 from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.IProjectBased import IProjectBasedRequest
 from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
 from LOGS.Interfaces.ITypedEntity import ITypedEntityRequest
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
@@ -30,22 +34,24 @@ class DatasetOrder(Enum):
     METHOD_DESC = "METHOD_DESC"
     EXPERIMENT_ASC = "EXPERIMENT_ASC"
     EXPERIMENT_DESC = "EXPERIMENT_DESC"
-    DATE_ADDED_ASC = "DATE_ADDED_ASC"
-    DATE_ADDED_DESC = "DATE_ADDED_DESC"
+    CREATED_ON_ASC = "CREATED_ON_ASC"
+    CREATED_ON_DESC = "CREATED_ON_DESC"
+    CREATED_BY_ASC = "CREATED_BY_ASC"
+    CREATED_BY_DESC = "CREATED_BY_DESC"
+    MODIFIED_ON_ASC = "MODIFIED_ON_ASC"
+    MODIFIED_ON_DESC = "MODIFIED_ON_DESC"
+    MODIFIED_BY_ASC = "MODIFIED_BY_ASC"
+    MODIFIED_BY_DESC = "MODIFIED_BY_DESC"
     INSTRUMENT_ASC = "INSTRUMENT_ASC"
     INSTRUMENT_DESC = "INSTRUMENT_DESC"
     SAMPLE_ASC = "SAMPLE_ASC"
     SAMPLE_DESC = "SAMPLE_DESC"
-    FACILITY_ASC = "FACILITY_ASC"
-    FACILITY_DESC = "FACILITY_DESC"
     PARSING_STATE_ASC = "PARSING_STATE_ASC"
     PARSING_STATE_DESC = "PARSING_STATE_DESC"
-    PARSERID_ASC = "PARSERID_ASC"
-    PARSERID_DESC = "PARSERID_DESC"
     FORMAT_ID_ASC = "FORMAT_ID_ASC"
     FORMAT_ID_DESC = "FORMAT_ID_DESC"
     TYPE_ASC = "TYPE_ASC"
-    TYPE_DESC = "YPE_DESC"
+    TYPE_DESC = "TYPE_DESC"
 
 
 @dataclass
@@ -55,42 +61,49 @@ class DatasetRequestParameter(
     ITypedEntityRequest,
     ISoftDeletableRequest,
     ICustomSchemaRequest,
+    IProjectBasedRequest,
     IOwnedEntityRequest,
     INamedEntityRequest,
     IUniqueEntityRequest,
+    ICreationRecordRequest,
+    IModificationRecordRequest,
     IPermissionedEntityRequest,
 ):
-    includeParameters: Optional[bool] = None
-    methodIds: Optional[List[int]] = None
-    formatIds: Optional[List[str]] = None
-    experimentIds: Optional[List[int]] = None
-    sampleIds: Optional[List[int]] = None
+
     acquisitionDateFrom: Optional[datetime] = None
     acquisitionDateTo: Optional[datetime] = None
-    dateAddedFrom: Optional[datetime] = None
-    dateAddedTo: Optional[datetime] = None
-    operatorIds: Optional[List[int]] = None
-    instrumentIds: Optional[List[int]] = None
-    hasExperiment: Optional[bool] = None
-    hasOperator: Optional[bool] = None
-    documentIds: Optional[List[int]] = None
-    equipmentIds: Optional[List[int]] = None
-    projectIds: Optional[List[int]] = None
-    organizationIds: Optional[List[int]] = None
     autoloadServerIds: Optional[List[int]] = None
-    participatedPersonIds: Optional[List[int]] = None
-    pathContains: Optional[str] = None
-    parsingState: Optional[List[ParsingStates]] = None
     bridgeIds: Optional[List[int]] = None
     dataSourceIds: Optional[List[int]] = None
-    orderBy: Optional[DatasetOrder] = None
-    typeIds: Optional[List[str]] = None
+    documentIds: Optional[List[int]] = None
+    equipmentIds: Optional[List[int]] = None
+    excludeUndeleted: Optional[bool] = None
+    experimentIds: Optional[List[int]] = None
+    files: Optional[Sequence[Constants.FILE_TYPE]] = None
+    formatIds: Optional[List[str]] = None
+    hasExperiment: Optional[bool] = None
     hashes: Optional[List[str]] = None
-    includeSoftDeleted: Optional[Optional[bool]] = None
-    isSoftDeleted: Optional[Optional[bool]] = None
+    hasOperator: Optional[bool] = None
+    includeParameters: Optional[bool] = None
     includeParsingInfo: Optional[bool] = None
-    isClaimed: Optional[Optional[bool]] = None
+    includeSoftDeleted: Optional[Optional[bool]] = None
     includeUnclaimed: Optional[Optional[bool]] = None
-    files: Optional[Sequence[Constants.FILE_TYPE]] = None
-    parameters: Optional[Dict[str, Any]] = None
+    instrumentIds: Optional[List[int]] = None
+    isClaimed: Optional[Optional[bool]] = None
     isReferencedByLabNotebook: Optional[Optional[bool]] = None
+    isViewableEntity: Optional[bool] = None
+    methodIds: Optional[List[int]] = None
+    names: Optional[List[str]] = None
+    operatorIds: Optional[List[int]] = None
+    orderBy: Optional[DatasetOrder] = None
+    organizationIds: Optional[List[int]] = None
+    originIds: Optional[List[int]] = None
+    parameters: Optional[Dict[str, Any]] = None
+    parsingState: Optional[List[ParsingStates]] = None
+    participatedPersonIds: Optional[List[int]] = None
+    pathContains: Optional[str] = None
+    sampleIds: Optional[List[int]] = None
+    searchTermIncludeNotes: Optional[bool] = None
+    searchTermIncludeParameters: Optional[bool] = None
+    searchTermIncludePaths: Optional[bool] = None
+    viewableEntityTypes: Optional[List[ViewableEntityTypes]] = None

LOGS/Entities/Datatrack.py

@@ -1,34 +1,37 @@
+import os
 from typing import Any, List, Literal, Optional, cast
 
-import numpy as np
-
 from LOGS.Auxiliary.Exceptions import (
     EntityIncompleteException,
     LOGSException,
     formatErrorMessage,
 )
 from LOGS.Entity.ConnectedEntity import ConnectedEntity
-from LOGS.LOGSConnection import ResponseTypes
+from LOGS.LOGSConnection import LOGSConnection, ResponseTypes
 
-NumberTypeType = Literal["int", "float", "double"]
-DatatrackType = Literal[
+_NumberTypeType = Literal["int", "float", "double"]
+_DatatrackType = Literal[
     "binary", "char", "formatted_table", "image", "numeric_array", "numeric_matrix"
 ]
-CodecType = Literal["char", "jpeg", "points", "generator"]
+_CodecType = Literal["char", "jpeg", "points", "generator"]
 
 
 class Datatrack(ConnectedEntity):
-    _type: Optional[DatatrackType] = None
-    _codec: Optional[CodecType] = None
+    _type: Optional[_DatatrackType] = None
+    _codec: Optional[_CodecType] = None
     _id: Optional[str] = None
     _count: Optional[int] = None
     _size: Optional[List[int]] = None
     _min: Optional[List[float]] = None
     _max: Optional[List[float]] = None
-    _numberType: Optional[NumberTypeType] = None
+    _numberType: Optional[_NumberTypeType] = None
     _data: Optional[Any] = None
     _incomplete = True
 
+    def __init__(self, ref=None, connection: Optional[LOGSConnection] = None):
+        self._noSerialize += ["data"]
+        super().__init__(ref=ref, connection=connection)
+
     def _getConnectionData(self):
         if not self._endpoint:
             raise NotImplementedError(
@@ -40,22 +43,60 @@ class Datatrack(ConnectedEntity):
 
         return self._getConnection(), self._endpoint, self.id
 
+    def _fetchDataFromCache(self):
+        cacheFile = self._getCacheFile()
+        if cacheFile is None:
+            raise LOGSException("Cache directory not defined.")
+
+        if not os.path.exists(cacheFile):
+            return None
+
+        with open(cacheFile, "rb") as f:
+            return f.read()
+
+    def _getCacheFile(self):
+        if self.cacheDir is None:
+            return None
+
+        return os.path.join(self.cacheDir, self.cacheId + ".cache")
+
+    def _storeDataInCache(self, data):
+        cacheFile = self._getCacheFile()
+        if cacheFile is None:
+            raise LOGSException("Cache directory not defined.")
+        with open(cacheFile, "wb") as f:
+            f.write(data)
+
+    def clearCache(self):
+        cacheFile = self._getCacheFile()
+        if cacheFile is not None:
+            if os.path.exists(cacheFile):
+                os.remove(cacheFile)
+
     def _fetchData(self):
-        connection, endpoint, id = self._getConnectionData()
+        data = None
+        if self.cacheDir:
+            data = self._fetchDataFromCache()
 
-        data, responseError = connection.getEndpoint(
-            endpoint + [id], responseType=ResponseTypes.RAW
-        )
-        if responseError:
-            raise LOGSException(
-                "Could not fetch %s: %s"
-                % (type(self).__name__, formatErrorMessage(responseError.errors)),
-                responseError=responseError,
+        if data is None:
+            connection, endpoint, id = self._getConnectionData()
+
+            data, responseError = connection.getEndpoint(
+                endpoint + [id], responseType=ResponseTypes.RAW
             )
+            if responseError:
+                raise LOGSException(
+                    "Could not fetch %s: %s"
+                    % (type(self).__name__, formatErrorMessage(responseError.errors)),
+                    responseError=responseError,
+                )
+
+            if self.cacheDir:
+                self._storeDataInCache(data)
 
         self._data = data
 
-    def fetchFull(self):
+    def fetchFull(self, cacheDir: Optional[str] = None):
         self._fetchData()
         self._incomplete = False
 
@@ -67,15 +108,11 @@ class Datatrack(ConnectedEntity):
                 yield x
 
     @property
-    def type(self) -> Optional[DatatrackType]:
+    def type(self) -> Optional[_DatatrackType]:
         return self._type
 
-    @type.setter
-    def type(self, value):
-        self._type = cast(Any, self.checkAndConvertNullable(value, str, "type"))
-
     @property
-    def codec(self) -> Optional[CodecType]:
+    def codec(self) -> Optional[_CodecType]:
         return self._codec
 
     @codec.setter
@@ -123,7 +160,7 @@ class Datatrack(ConnectedEntity):
         self._max = self.checkListAndConvertNullable(value, float, "max")
 
     @property
-    def numberType(self) -> Optional[NumberTypeType]:
+    def numberType(self) -> Optional[_NumberTypeType]:
         return self._numberType
 
     @numberType.setter
@@ -133,7 +170,14 @@ class Datatrack(ConnectedEntity):
         )
 
     @property
-    def data(self) -> Optional[np.ndarray]:
-        if self._incomplete:
-            raise EntityIncompleteException(self)
-        return self._data
+    def data(self) -> Optional[Any]:
+        raise NotImplementedError(
+            "Field 'data' of %a class not implemented." % type(self).__name__
+        )
+
+    @property
+    def cacheId(self) -> str:
+        if self._cacheId is None:
+            return f"{self.type}_{self.id}"
+        else:
+            return self._cacheId

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

@@ -1,51 +1,15 @@
-from typing import Literal, Optional, cast
+from typing import Optional, cast
 
 import numpy as np
 
-from LOGS.Auxiliary.Exceptions import (
-    EntityIncompleteException,
-    LOGSException,
-    formatErrorMessage,
-)
+from LOGS.Auxiliary.Exceptions import EntityIncompleteException
 from LOGS.Entities.Datatrack import Datatrack
-from LOGS.LOGSConnection import ResponseTypes
-
-NumberTypeType = Literal["int", "float", "double"]
-DatatrackType = Literal[
-    "binary", "char", "formatted_table", "image", "numeric_array", "numeric_matrix"
-]
-CodecType = Literal["char", "jpeg", "points", "generator"]
 
 
 class DatatrackNumericArray(Datatrack):
+    _type = "numeric_array"
     _data: Optional[np.ndarray] = None
 
-    def _getConnectionData(self):
-        if not self._endpoint:
-            raise NotImplementedError(
-                "Endpoint missing for of entity type %a." % (type(self).__name__)
-            )
-
-        if not self.id:
-            raise LOGSException("%s id is not defined." % type(self).__name__)
-
-        return self._getConnection(), self._endpoint, self.id
-
-    def _fetchData(self):
-        connection, endpoint, id = self._getConnectionData()
-
-        data, responseError = connection.getEndpoint(
-            endpoint + [id], responseType=ResponseTypes.RAW
-        )
-        if responseError:
-            raise LOGSException(
-                "Could not fetch %s: %s"
-                % (type(self).__name__, formatErrorMessage(responseError.errors)),
-                responseError=responseError,
-            )
-
-        self._data = np.frombuffer(cast(bytes, data), dtype=np.double)
-
     def __iter__(self):
         if self._incomplete:
             raise EntityIncompleteException(self)
@@ -53,6 +17,12 @@ class DatatrackNumericArray(Datatrack):
             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:

LOGS/Entities/DatatrackNumericMatrix.py

@@ -0,0 +1,86 @@
+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]):
+        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.")
+
+        return (
+            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])),
+        )
+
+    def getValueFromCoordinate(self, coord: Tuple[float, float]):
+        if self._incomplete:
+            raise EntityIncompleteException(self)
+        if self._data is None:
+            return None
+
+        return self.getValueFromIndex(self.getIndex(coord))
+
+    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/DocumentRequestParameter.py

@@ -3,16 +3,16 @@ from datetime import datetime
 from typing import List, Optional
 
 from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Interfaces.IProjectBased import IProjectBasedRequest
 
 
 @dataclass
-class DocumentRequestParameter(EntityRequestParameter):
+class DocumentRequestParameter(EntityRequestParameter, IProjectBasedRequest):
     name: Optional[str] = None
     creationDate: Optional[datetime] = None
     publicationTypes: Optional[List[int]] = None
     doi: Optional[str] = None
     authorIds: Optional[List[int]] = None
-    projectIds: Optional[List[int]] = None
     datasetIds: Optional[List[int]] = None
     documentIds: Optional[List[int]] = None
     sampleIds: Optional[List[int]] = None

LOGS/Entities/EntitiesRequestParameter.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, Optional, Union
+from typing import List, Optional, Sequence, Union
 from uuid import UUID
 
 from LOGS.Entity.SerializeableContent import SerializeableClass
@@ -8,5 +8,5 @@ from LOGS.Entity.SerializeableContent import SerializeableClass
 @dataclass
 class EntitiesRequestParameter(SerializeableClass):
     _noSerialize = ["asString"]
-    uids: Optional[List[Union[str, UUID]]] = None
+    uids: Optional[Sequence[Union[str, UUID]]] = None
     names: Optional[List[str]] = None

LOGS/Entities/Experiment.py

@@ -9,7 +9,7 @@ from LOGS.Interfaces.ICreationRecord import ICreationRecord
 from LOGS.Interfaces.IModificationRecord import IModificationRecord
 from LOGS.Interfaces.INamedEntity import INamedEntity
 from LOGS.Interfaces.IOwnedEntity import IOwnedEntity
-from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntity
+from LOGS.Interfaces.IPermissionedEntity import GenericPermissionEntity
 from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
 from LOGS.LOGSConnection import LOGSConnection
@@ -24,9 +24,9 @@ class Experiment(
     IModificationRecord,
     IOwnedEntity,
     IRelatedEntity[ExperimentRelations],
-    IPermissionedEntity,
+    GenericPermissionEntity,
 ):
-    _relationType = type(ExperimentRelations)
+    _relationType = ExperimentRelations
 
     _method: Optional[MethodMinimal]
     _notes: Optional[str]

LOGS/Entities/FileExcludePattern.py

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