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

LOGS/Converter/ConverterParameter.py

@@ -0,0 +1,88 @@
+from enum import Enum
+from typing import Optional, Union
+
+from LOGS.Entity.SerializeableContent import SerializeableClass
+
+
+class ParameterType(Enum):
+    Integer = "Integer"
+    String = "String"
+    Boolean = "Boolean"
+    Float = "Float"
+
+
+class IConverterParameter(SerializeableClass):
+    name: Optional[str] = None
+    id: Optional[str] = None
+    description: Optional[str] = None
+    required: Optional[bool] = None
+    hasDefault: Optional[bool] = None
+    identifier: Optional[str] = None
+
+    @classmethod
+    def TypeMapper(cls, t: Union[ParameterType, str]):
+        if t == ParameterType.Integer:
+            return int
+        if t == ParameterType.String:
+            return str
+        if t == ParameterType.Boolean:
+            return bool
+        if t == ParameterType.Float:
+            return float
+        raise Exception("Unknown parameter type '%s'" % t)
+
+    @classmethod
+    def GetParameterFromDict(cls, data: dict):
+        if not isinstance(data, dict) or "type" not in data:
+            raise Exception(f"Export parameter type not specified.")
+
+        type = data["type"]
+        if type not in ParameterType.__members__:
+            raise Exception(
+                f"Unknown export parameter type '{type}' not found in parameter data"
+            )
+
+        type = ParameterType.__members__[type]
+
+        if type == ParameterType.Integer:
+            return ConverterIntegerParameter(data)
+        if type == ParameterType.String:
+            return ConverterStringParameter(data)
+        if type == ParameterType.Boolean:
+            return ConverterBooleanParameter(data)
+        if type == ParameterType.Float:
+            return ConverterFloatParameter(data)
+
+        raise Exception(
+            f"Unknown export parameter type '{type}' not found in parameter data"
+        )
+
+    @property
+    def type(self) -> ParameterType:
+        raise NotImplementedError(
+            f"{type(self).__name__} is an abstract class. Please implement the 'type' property."
+        )
+
+
+class ConverterIntegerParameter(IConverterParameter):
+    @property
+    def type(self) -> ParameterType:
+        return ParameterType.Integer
+
+
+class ConverterStringParameter(IConverterParameter):
+    @property
+    def type(self) -> ParameterType:
+        return ParameterType.String
+
+
+class ConverterBooleanParameter(IConverterParameter):
+    @property
+    def type(self) -> ParameterType:
+        return ParameterType.Boolean
+
+
+class ConverterFloatParameter(IConverterParameter):
+    @property
+    def type(self) -> ParameterType:
+        return ParameterType.Float

LOGS/Converter/ExportParamters.py

@@ -0,0 +1,89 @@
+from typing import Any, Dict, Optional
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entity.SerializeableContent import SerializeableClass
+
+
+class ExportParamters(SerializeableClass):
+
+    def __init__(
+        self,
+        ref=None,
+        types: Optional[Dict[str, type]] = None,
+    ):
+        self._lock = False
+        if types is not None:
+            if not isinstance(types, dict):
+                raise Exception("type must be a dictionary")
+            for k, v in types.items():
+                if not isinstance(v, type):
+                    raise Exception(
+                        f"Invalid type for key '{k}'. (Expected '{type.__name__}' got '{type(v).__name__}')"
+                    )
+        else:
+            types = {}
+
+        self._typeMapping: Dict[str, type] = {}
+        if isinstance(ref, dict):
+            if "_parentId" in ref:
+                self._parentId: Optional[str] = str(ref["_parentId"])
+                del ref["_parentId"]
+            else:
+                self._parentId = None
+
+            self._includeNone = True
+            for k in ref.keys():
+                setattr(self, k, ref[k])
+                if k in types:
+                    self._typeMapping[k] = types[k]
+        super().__init__(ref)
+        self._lock = True
+
+    def fromDict(self, ref) -> None:
+        if getattr(self, "_lock", False):
+            if isinstance(ref, dict):
+                if "parameters" in ref and isinstance(ref["parameters"], list):
+                    for p in ref["parameters"]:
+                        if "id" in p and "value" in p:
+                            setattr(self, p["id"], p["value"])
+                for k, v in ref.items():
+                    setattr(self, k, v)
+        return super().fromDict(ref)
+
+    def toDict(self) -> Dict[str, Any]:
+        l = [
+            {"id": k, "value": getattr(self, k)}
+            for k in self.__dict__
+            if k[0] != "_" and getattr(self, k) is not None
+        ]
+        if l:
+            return {"parameters": l}
+        return {}
+
+    def __repr__(self):
+        fields = [
+            f"{k}{':' + self._typeMapping[k].__name__ if k in self._typeMapping else ''}={v}"
+            for k, v in self.toDict().items()
+        ]
+        return f'{self.identifier}({", ".join(fields)})'
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if getattr(self, "_lock", False):
+            if name not in self._typeMapping:
+                raise Exception(f"Unknown field '{self.identifier}.{name}'")
+
+            if name in self._typeMapping:
+                value = Tools.checkAndConvert(
+                    value,
+                    self._typeMapping[name],
+                    f"{self.identifier}.{name}",
+                    allowNone=True,
+                )
+        return super().__setattr__(name, value)
+
+    @property
+    def identifier(self):
+        return f"{self.__class__.__name__}{'<' + self._parentId + '>' if self._parentId else ''}"
+
+    def __str__(self):
+        return self.__repr__()

LOGS/Converter/__init__.py

@@ -0,0 +1,13 @@
+"""
+    This package is written for the LOGS Repository.
+    
+    It's objects can be used to write your own dataset parser.
+    
+    License:
+    Permission to use this libraray and all of its contents is 
+    strictly permitted to the Signals Company.
+"""
+
+from .Conversion import *
+from .Converter import *
+from .ConverterParameter import *

LOGS/Entities/Bridge.py

@@ -8,16 +8,19 @@ from LOGS.Entities.BridgeRelations import BridgeRelations
 from LOGS.Entities.BridgeType import BridgeType
 from LOGS.Entity.EntityWithIntId import IEntityWithIntId
 from LOGS.Interfaces.INamedEntity import INamedEntity
-from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntity
+from LOGS.Interfaces.IPermissionedEntity import GenericPermissionEntity
 from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.LOGSConnection import LOGSConnection
 
 
 @Endpoint("bridges")
 class Bridge(
-    IEntityWithIntId, INamedEntity, IRelatedEntity[BridgeRelations], IPermissionedEntity
+    IEntityWithIntId,
+    INamedEntity,
+    IRelatedEntity[BridgeRelations],
+    GenericPermissionEntity,
 ):
-    _relationType = type(BridgeRelations)
+    _relationType = BridgeRelations
 
     _type: Optional[BridgeType]
     _hostname: Optional[str]

LOGS/Entities/CustomField.py

@@ -1,58 +1,58 @@
-from datetime import datetime
-from typing import List, Optional
-
-from regex import Regex
+from typing import TYPE_CHECKING, List, Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
-from LOGS.Entities.CustomFieldEnums import CustomFieldDataTypes, CustomFieldTypes
-from LOGS.Entity.EntityWithStrId import EntityWithStrId
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList
+from LOGS.Entities.CustomFieldModels import CustomFieldDataType
+from LOGS.Entities.CustomFieldRelations import CustomFieldRelations
+from LOGS.Entities.ILiterarTypedEntity import ILiterarTypedEntity
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+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 GenericPermissionEntity
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
 from LOGS.LOGSConnection import LOGSConnection
 
+if TYPE_CHECKING:
+    from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
+
 
 @Endpoint("custom_fields")
 class CustomField(
-    EntityWithStrId,
+    IEntityWithIntId,
     IOwnedEntity,
     INamedEntity,
+    IUniqueEntity,
+    ICreationRecord,
+    IModificationRecord,
+    IRelatedEntity[CustomFieldRelations],
+    ILiterarTypedEntity,
+    GenericPermissionEntity,
 ):
-    _createdAt: Optional[datetime]
-    _widget: Optional[CustomFieldTypes] = CustomFieldTypes.Text
-    _type: Optional[CustomFieldDataTypes] = CustomFieldDataTypes.String
-    _description: Optional[str]
-    _defaultValue: Optional[str]
-    _isReadOnly: Optional[bool]
-    _isRequired: Optional[bool]
-    _isMulti: Optional[bool]
-    _validationRegexp: Optional[str]
-    _validationMessage: Optional[str]
-    _enumOptions: Optional[List[str]]
-
-    _alphanumeric = Regex(r"[^a-zA-Z0-9_]")
+    _relationType = CustomFieldRelations
+    _type = "CustomField"
+
+    _customTypeConstraint: Optional[List["CustomTypeMinimal"]] = None
+    _dataType: Optional[CustomFieldDataType] = None
+    _defaultValue: Optional[str] = None
+    _description: Optional[str] = None
+    _enumOptions: Optional[List[str]] = None
+    _enumOptionsFromValues: Optional[bool] = None
+    _placeholder: Optional[str] = None
+    _readOnly: Optional[bool] = None
+    _required: Optional[bool] = None
+    _showAsTextArea: Optional[bool] = None
+    _validationMessage: Optional[str] = None
+    _validationRegexp: Optional[str] = None
 
     def __init__(
         self,
         ref=None,
-        id: Optional[str] = None,
+        id: Optional[int] = None,
         connection: Optional[LOGSConnection] = None,
-        name: str = "",
     ):
-        self._name = name
-        if id is None:
-            id = self._idFromName(name)
-        self._createdAt = None
-        self._widget = None
-        self._type = None
-        self._description = None
-        self._defaultValue = None
-        self._isReadOnly = None
-        self._isRequired = None
-        self._isMulti = None
-        self._validationRegexp = None
-        self._validationMessage = None
-        self._enumOptions = None
-
         if ref != None and isinstance(ref, (str, int, float)):
             ref = {"text": str(ref)}
 
@@ -66,34 +66,6 @@ class CustomField(
 
         super().fromDict(ref=ref)
 
-    @classmethod
-    def _idFromName(cls, name):
-        return cls._alphanumeric.sub("_", name).lower()
-
-    @property
-    def createdAt(self) -> Optional[datetime]:
-        return self._createdAt
-
-    @createdAt.setter
-    def createdAt(self, value):
-        self._createdAt = self.checkAndConvertNullable(value, datetime, "createdAt")
-
-    @property
-    def widget(self) -> Optional[CustomFieldTypes]:
-        return self._widget
-
-    @widget.setter
-    def widget(self, value):
-        self._widget = self.checkAndConvertNullable(value, CustomFieldTypes, "widget")
-
-    @property
-    def type(self) -> Optional[CustomFieldDataTypes]:
-        return self._type
-
-    @type.setter
-    def type(self, value):
-        self._type = self.checkAndConvertNullable(value, CustomFieldDataTypes, "type")
-
     @property
     def description(self) -> Optional[str]:
         return self._description
@@ -111,28 +83,20 @@ class CustomField(
         self._defaultValue = self.checkAndConvertNullable(value, str, "defaultValue")
 
     @property
-    def isReadOnly(self) -> Optional[bool]:
-        return self._isReadOnly
+    def readOnly(self) -> Optional[bool]:
+        return self._readOnly
 
-    @isReadOnly.setter
-    def isReadOnly(self, value):
-        self._isReadOnly = self.checkAndConvertNullable(value, bool, "isReadOnly")
+    @readOnly.setter
+    def readOnly(self, value):
+        self._readOnly = self.checkAndConvertNullable(value, bool, "readOnly")
 
     @property
-    def isRequired(self) -> Optional[bool]:
-        return self._isRequired
+    def required(self) -> Optional[bool]:
+        return self._required
 
-    @isRequired.setter
-    def isRequired(self, value):
-        self._isRequired = self.checkAndConvertNullable(value, bool, "isRequired")
-
-    @property
-    def isMulti(self) -> Optional[bool]:
-        return self._isMulti
-
-    @isMulti.setter
-    def isMulti(self, value):
-        self._isMulti = self.checkAndConvertNullable(value, bool, "isMulti")
+    @required.setter
+    def required(self, value):
+        self._required = self.checkAndConvertNullable(value, bool, "required")
 
     @property
     def validationRegexp(self) -> Optional[str]:
@@ -160,14 +124,55 @@ class CustomField(
 
     @enumOptions.setter
     def enumOptions(self, value):
+        if value == None:
+            self._enumOptions = None
+            return
         self._enumOptions = self.checkListAndConvertNullable(value, str, "enumOptions")
 
     @property
-    def name(self) -> Optional[str]:
-        return self._name
-
-    @name.setter
-    def name(self, value):
-        self._name = self.checkAndConvert(value, str, "name", allowNone=True)
-        if self.id is None or self.id == "":
-            self.id = self._idFromName(self._name)
+    def customTypeConstraint(self) -> Optional[List["CustomTypeMinimal"]]:
+        return self._customTypeConstraint
+
+    @customTypeConstraint.setter
+    def customTypeConstraint(self, value):
+        self._customTypeConstraint = MinimalFromList(
+            value, "CustomTypeMinimal", "customTypeConstraint"
+        )
+
+    @property
+    def dataType(self) -> Optional[CustomFieldDataType]:
+        return self._dataType
+
+    @dataType.setter
+    def dataType(self, value):
+        self._dataType = self.checkAndConvertNullable(
+            value, CustomFieldDataType, "dataType"
+        )
+
+    @property
+    def enumOptionsFromValues(self) -> Optional[bool]:
+        return self._enumOptionsFromValues
+
+    @enumOptionsFromValues.setter
+    def enumOptionsFromValues(self, value):
+        self._enumOptionsFromValues = self.checkAndConvertNullable(
+            value, bool, "enumOptionsFromValues"
+        )
+
+    @property
+    def placeholder(self) -> Optional[str]:
+        return self._placeholder
+
+    @placeholder.setter
+    def placeholder(self, value):
+        self._placeholder = self.checkAndConvertNullable(value, str, "placeholder")
+
+    @property
+    def showAsTextArea(self) -> Optional[bool]:
+        return self._showAsTextArea
+
+    @showAsTextArea.setter
+    def showAsTextArea(self, value):
+        self._showAsTextArea = self.checkAndConvertNullable(
+            value, bool, "showAsTextArea"
+        )

LOGS/Entities/CustomFieldModels.py

@@ -0,0 +1,57 @@
+from enum import Enum
+
+
+class CustomFieldDataType(Enum):
+    String = "String"
+    StringArray = "StringArray"
+    Integer = "Integer"
+    IntegerArray = "IntegerArray"
+    Float = "Float"
+    FloatArray = "FloatArray"
+    Boolean = "Boolean"
+    Date = "Date"
+    DateArray = "DateArray"
+    DateTime = "DateTime"
+    DateTimeArray = "DateTimeArray"
+    Time = "Time"
+    TimeArray = "TimeArray"
+    DateTimeRange = "DateTimeRange"
+    TimeRange = "TimeRange"
+    Dataset = "Dataset"
+    DatasetArray = "DatasetArray"
+    Sample = "Sample"
+    SampleArray = "SampleArray"
+    Project = "Project"
+    ProjectArray = "ProjectArray"
+    Organization = "Organization"
+    OrganizationArray = "OrganizationArray"
+    Person = "Person"
+    PersonArray = "PersonArray"
+    Method = "Method"
+    MethodArray = "MethodArray"
+    Instrument = "Instrument"
+    InstrumentArray = "InstrumentArray"
+    SharedContent = "SharedContent"
+    SharedContentArray = "SharedContentArray"
+    LabNotebook = "LabNotebook"
+    LabNotebookArray = "LabNotebookArray"
+    LabNotebookExperiment = "LabNotebookExperiment"
+    LabNotebookExperimentArray = "LabNotebookExperimentArray"
+    LabNotebookEntry = "LabNotebookEntry"
+    LabNotebookEntryArray = "LabNotebookEntryArray"
+    ViewableEntity = "ViewableEntity"
+    Inventory = "Inventory"
+    InventoryArray = "InventoryArray"
+    EntityBarCode = "EntityBarCode"
+    Url = "Url"
+    UrlArray = "UrlArray"
+
+
+class CustomFieldValuesSearchPredicate(Enum):
+    AND = "AND"
+    OR = "OR"
+
+
+class CustomFieldValueType(Enum):
+    CustomField = "CustomField"
+    CustomTypeSection = "CustomTypeSection"

LOGS/Entities/CustomFieldRelations.py

@@ -0,0 +1,10 @@
+from typing import TYPE_CHECKING
+
+from LOGS.Entity.EntityRelations import EntityRelations
+
+if TYPE_CHECKING:
+    pass
+
+
+class CustomFieldRelations(EntityRelations):
+    """Relations of a CustomType with other entities"""

LOGS/Entities/CustomFieldRequestParameter.py

@@ -1,13 +1,19 @@
 from dataclasses import dataclass
-from datetime import datetime
 from enum import Enum
-from typing import List, Optional
+from typing import Any, List, Optional
 
-from LOGS.Entities.CustomFieldEnums import CustomFieldPropertyFilters, CustomFieldTypes
+from LOGS.Entities.CustomFieldModels import (
+    CustomFieldDataType,
+    CustomFieldValuesSearchPredicate,
+)
 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.IPaginationRequest import IPaginationRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.IRelationRequest import IRelationRequest
 
 
 class CustomFieldOrder(Enum):
@@ -15,26 +21,48 @@ class CustomFieldOrder(Enum):
     ID_DESC = "ID_DESC"
     NAME_ASC = "NAME_ASC"
     NAME_DESC = "NAME_DESC"
-    TYPE_ASC = "TYPE_ASC"
-    TYPE_DESC = "TYPE_DESC"
-    WIDGET_ASC = "WIDGET_ASC"
-    WIDGET_DESC = "WIDGET_DESC"
-    OWNER_ASC = "OWNER_ASC"
-    OWNER_DESC = "OWNER_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"
+    DATATYPE_ASC = "DATATYPE_ASC"
+    DATATYPE_DESC = "DATATYPE_DESC"
+
+
+@dataclass
+class CustomFieldValuesSearchParameters:
+    values: Optional[List[Any]] = None
+    dataType: Optional[CustomFieldDataType] = None
+    customFieldIds: Optional[List[int]] = None
+    sampleIds: Optional[List[int]] = None
+    datasetIds: Optional[List[int]] = None
+    projectIds: Optional[List[int]] = None
+    personIds: Optional[List[int]] = None
+    inventoryIds: Optional[List[int]] = None
+    facilityIds: Optional[List[int]] = None
+    predicate: Optional[CustomFieldValuesSearchPredicate] = None
+
+
+@dataclass
+class ICustomFieldValuesSearchRequest:
+    customFieldValues: Optional[List[CustomFieldValuesSearchParameters]] = None
 
 
 @dataclass
 class CustomFieldRequestParameter(
     EntityRequestParameter[CustomFieldOrder],
     IPaginationRequest,
+    IRelationRequest,
+    IPermissionedEntityRequest,
+    ICreationRecordRequest,
+    IModificationRecordRequest,
+    ICustomFieldValuesSearchRequest,
     IOwnedEntityRequest,
     INamedEntityRequest,
 ):
-    name: Optional[str] = None
-    ownerIds: Optional[List[int]] = None
-    creationDateFrom: Optional[datetime] = None
-    creationDateTo: Optional[datetime] = None
-    widgets: Optional[List[CustomFieldTypes]] = None
-    properties: Optional[List[CustomFieldPropertyFilters]] = None
+    dataTypes: Optional[List[CustomFieldDataType]] = None
+    customFieldValues: Optional[List[CustomFieldValuesSearchParameters]] = None

LOGS/Entities/CustomFieldValue.py

@@ -0,0 +1,88 @@
+from typing import TYPE_CHECKING, Any, Optional, Sequence, Union, cast
+
+from LOGS.Auxiliary.Exceptions import IllegalFieldValueException
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entities.CustomFieldModels import CustomFieldDataType, CustomFieldValueType
+from LOGS.Entities.CustomFieldValueConverter import CustomFieldValueConverter
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+if TYPE_CHECKING:
+    pass
+
+
+class ICustomValue(SerializeableContent):
+    _name: Optional[str] = None
+    _type: CustomFieldValueType = cast(CustomFieldValueType, None)
+
+    @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) -> CustomFieldValueType:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        value = self.checkAndConvert(value, CustomFieldValueType, "type")
+        if value != self._type:
+            raise IllegalFieldValueException(
+                self, "type", value, f"Only value '{self._type}' allowed."
+            )
+
+
+class CustomFieldValue(ICustomValue):
+    _type: CustomFieldValueType = CustomFieldValueType.CustomField
+
+    _id: Optional[int] = None
+    _dataType: Optional[CustomFieldDataType] = None
+    _value: Optional[Any] = None
+
+    @property
+    def id(self) -> Optional[int]:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = self.checkAndConvertNullable(value, int, "id")
+
+    @property
+    def dataType(self) -> Optional[CustomFieldDataType]:
+        return self._dataType
+
+    @dataType.setter
+    def dataType(self, value):
+        self._dataType = self.checkAndConvertNullable(
+            value, CustomFieldDataType, "dataType"
+        )
+
+    @property
+    def value(self) -> Optional[Any]:
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+
+    def __str__(self):
+        return Tools.ObjectToString(self)
+
+
+class CustomSectionValue(ICustomValue):
+    _type: CustomFieldValueType = CustomFieldValueType.CustomTypeSection
+
+    _content: Optional[Sequence[Union[CustomFieldValue, "CustomSectionValue"]]] = None
+
+    @property
+    def content(
+        self,
+    ) -> Optional[Sequence[Union[CustomFieldValue, "CustomSectionValue"]]]:
+        return self._content
+
+    @content.setter
+    def content(self, value):
+        self._content = CustomFieldValueConverter.convert(value)