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

LOGS/Entities/CustomFieldValueConverter.py

@@ -0,0 +1,66 @@
+from typing import TYPE_CHECKING, Any, Optional, Sequence, Union, cast
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entities.CustomFieldModels import CustomFieldValueType
+
+if TYPE_CHECKING:
+    from LOGS.Entities.CustomFieldValue import CustomFieldValue, CustomSectionValue
+
+
+class CustomFieldValueConverter:
+    @classmethod
+    def convert(
+        cls,
+        value: Any,
+        fieldName: Optional[str] = None,
+    ) -> Optional[Sequence[Union["CustomFieldValue", "CustomSectionValue"]]]:
+        from LOGS.Entities.CustomFieldValue import CustomFieldValue, CustomSectionValue
+
+        if value is None:
+            return None
+
+        if isinstance(value, list):
+            g = [cls.convert(v, f"{fieldName}[{i}]") for i, v in enumerate(value)]
+            return cast(Any, g)
+
+        if isinstance(value, CustomFieldValue):
+            return cast(Any, value)
+
+        if isinstance(value, dict):
+            if "type" not in value:
+                raise Exception(
+                    "Field %a cannot be converted because field 'type' is missing."
+                    % (fieldName)
+                )
+
+            t = Tools.checkAndConvert(
+                value["type"],
+                CustomFieldValueType,
+                fieldName,
+            )
+            if t == CustomFieldValueType.CustomField:
+                return cast(
+                    Any, Tools.checkAndConvert(value, CustomFieldValue, fieldName)
+                )
+            elif t == CustomFieldValueType.CustomTypeSection:
+                return cast(
+                    Any, Tools.checkAndConvert(value, CustomSectionValue, fieldName)
+                )
+
+            if isinstance(value, CustomFieldValue):
+                return cast(Any, value)
+
+            if isinstance(value, CustomSectionValue):
+                if value.content:
+                    value.content = [
+                        cls.convert(v, f"{fieldName}.content[{i}]")
+                        for i, v in enumerate(value.content)
+                    ]
+                return cast(Any, value)
+
+            raise Exception(
+                "Field %a cannot contain element of type %a."
+                % (fieldName, type(value).__name__)
+            )
+
+        return None

LOGS/Entities/CustomType.py

@@ -0,0 +1,187 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList, MinimalFromSingle
+from LOGS.Entities.CustomField import CustomField
+from LOGS.Entities.CustomTypeEntityType import CustomTypeEntityType
+from LOGS.Entities.CustomTypeRelations import CustomTypeRelations
+from LOGS.Entities.CustomTypeSection import CustomTypeSection
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.ICreationRecord import ICreationRecord
+from LOGS.Interfaces.IHierarchyType import IHierarchyType
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import GenericPermissionEntity
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.CustomTypeMinimal import CustomTypeMinimal
+
+
+@Endpoint("types")
+class CustomType(
+    IEntityWithIntId,
+    GenericPermissionEntity,
+    INamedEntity,
+    IUniqueEntity,
+    ICreationRecord,
+    IModificationRecord,
+    ISoftDeletable,
+    IRelatedEntity[CustomTypeRelations],
+    IHierarchyType,
+):
+    _relationType = CustomTypeRelations
+    _noSerialize = ["customFields"]
+
+    _description: Optional[str] = None
+    _entityType: Optional[CustomTypeEntityType] = None
+    _hasRestrictedAddPermission: Optional[bool] = None
+    _hasRestrictedEditPermission: Optional[bool] = None
+    _hasRestrictedReadPermission: Optional[bool] = None
+    _sections: Optional[List[CustomTypeSection]] = None
+    _isEnabled: Optional[bool] = None
+    _relations: Optional[CustomTypeRelations] = None
+    _inventoryName: Optional[str] = None
+    _inventoryDescription: Optional[str] = None
+    _isHierarchyRoot: Optional[bool] = None
+    _rootHierarchy: Optional["CustomTypeMinimal"] = None
+    _parentTypes: Optional[List["CustomTypeMinimal"]] = None
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def entityType(self) -> Optional[CustomTypeEntityType]:
+        return self._entityType
+
+    @entityType.setter
+    def entityType(self, value):
+        self._entityType = self.checkAndConvertNullable(
+            value, CustomTypeEntityType, "entityType"
+        )
+
+    @property
+    def hasRestrictedAddPermission(self) -> Optional[bool]:
+        return self._hasRestrictedAddPermission
+
+    @hasRestrictedAddPermission.setter
+    def hasRestrictedAddPermission(self, value):
+        self._hasRestrictedAddPermission = self.checkAndConvertNullable(
+            value, bool, "hasRestrictedAddPermission"
+        )
+
+    @property
+    def hasRestrictedEditPermission(self) -> Optional[bool]:
+        return self._hasRestrictedEditPermission
+
+    @hasRestrictedEditPermission.setter
+    def hasRestrictedEditPermission(self, value):
+        self._hasRestrictedEditPermission = self.checkAndConvertNullable(
+            value, bool, "hasRestrictedEditPermission"
+        )
+
+    @property
+    def hasRestrictedReadPermission(self) -> Optional[bool]:
+        return self._hasRestrictedReadPermission
+
+    @hasRestrictedReadPermission.setter
+    def hasRestrictedReadPermission(self, value):
+        self._hasRestrictedReadPermission = self.checkAndConvertNullable(
+            value, bool, "hasRestrictedReadPermission"
+        )
+
+    @property
+    def sections(self) -> Optional[List[CustomTypeSection]]:
+        return self._sections
+
+    @sections.setter
+    def sections(self, value):
+        self._sections = self.checkListAndConvertNullable(
+            value, CustomTypeSection, "sections"
+        )
+
+    @property
+    def isEnabled(self) -> Optional[bool]:
+        return self._isEnabled
+
+    @isEnabled.setter
+    def isEnabled(self, value):
+        self._isEnabled = self.checkAndConvertNullable(value, bool, "isEnabled")
+
+    @property
+    def relations(self) -> Optional[CustomTypeRelations]:
+        return self._relations
+
+    @relations.setter
+    def relations(self, value):
+        self._relations = self.checkAndConvertNullable(
+            value, CustomTypeRelations, "relations"
+        )
+
+    @property
+    def inventoryName(self) -> Optional[str]:
+        return self._inventoryName
+
+    @inventoryName.setter
+    def inventoryName(self, value):
+        self._inventoryName = self.checkAndConvertNullable(value, str, "inventoryName")
+
+    @property
+    def inventoryDescription(self) -> Optional[str]:
+        return self._inventoryDescription
+
+    @inventoryDescription.setter
+    def inventoryDescription(self, value):
+        self._inventoryDescription = self.checkAndConvertNullable(
+            value, str, "inventoryDescription"
+        )
+
+    @property
+    def isHierarchyRoot(self) -> Optional[bool]:
+        return self._isHierarchyRoot
+
+    @isHierarchyRoot.setter
+    def isHierarchyRoot(self, value):
+        self._isHierarchyRoot = self.checkAndConvertNullable(
+            value, bool, "isHierarchyRoot"
+        )
+
+    @property
+    def rootHierarchy(self) -> Optional["CustomTypeMinimal"]:
+        return self._rootHierarchy
+
+    @rootHierarchy.setter
+    def rootHierarchy(self, value):
+        self._rootHierarchy = MinimalFromSingle(
+            value, "CustomTypeMinimal", "rootHierarchy", self.connection
+        )
+
+    @property
+    def parentTypes(self) -> Optional[List["CustomTypeMinimal"]]:
+        return self._parentTypes
+
+    @parentTypes.setter
+    def parentTypes(self, value):
+        self._parentTypes = MinimalFromList(
+            value, "CustomTypeMinimal", "parentTypes", self.connection
+        )
+
+    @property
+    def customFields(self) -> List[CustomField]:
+        if self.sections is None:
+            return []
+
+        return [
+            field
+            for section in self.sections
+            if section.customFields is not None
+            for field in section.customFields
+            if field is not None
+        ]

LOGS/Entities/CustomTypeEntityType.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class CustomTypeEntityType(Enum):
+    Sample = "Sample"
+    Dataset = "Dataset"
+    Inventory = "Inventory"
+    Project = "Project"
+    Person = "Person"
+    Method = "Method"
+    Facility = "Facility"

LOGS/Entities/CustomTypeMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.CustomType import CustomType
+from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
+
+
+@FullModel(CustomType)
+class CustomTypeMinimal(EntityMinimalWithIntId[CustomType]):
+    pass

LOGS/Entities/CustomTypeRelations.py

@@ -0,0 +1,59 @@
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Entity.EntityRelation import EntityRelation
+from LOGS.Entity.EntityRelations import EntityRelations
+
+if TYPE_CHECKING:
+    from LOGS.Entities.Dataset import Dataset
+    from LOGS.Entities.Person import Person
+    from LOGS.Entities.Project import Project
+    from LOGS.Entities.Sample import Sample
+
+
+class CustomTypeRelations(EntityRelations):
+    """Relations of a CustomType with other entities"""
+
+    _persons: Optional[EntityRelation["Person"]] = None
+    _datasets: Optional[EntityRelation["Dataset"]] = None
+    _samples: Optional[EntityRelation["Sample"]] = None
+    _projects: Optional[EntityRelation["Project"]] = None
+
+    @property
+    def persons(self) -> Optional[EntityRelation["Person"]]:
+        return self._persons
+
+    @persons.setter
+    def persons(self, value):
+        from LOGS.Entities.Persons import Persons
+
+        self._persons = self._entityConverter(value, Persons)
+
+    @property
+    def datasets(self) -> Optional[EntityRelation["Dataset"]]:
+        return self._datasets
+
+    @datasets.setter
+    def datasets(self, value):
+        from LOGS.Entities.Datasets import Datasets
+
+        self._datasets = self._entityConverter(value, Datasets)
+
+    @property
+    def samples(self) -> Optional[EntityRelation["Sample"]]:
+        return self._samples
+
+    @samples.setter
+    def samples(self, value):
+        from LOGS.Entities.Samples import Samples
+
+        self._samples = self._entityConverter(value, Samples)
+
+    @property
+    def projects(self) -> Optional[EntityRelation["Project"]]:
+        return self._projects
+
+    @projects.setter
+    def projects(self, value):
+        from LOGS.Entities.Projects import Projects
+
+        self._projects = self._entityConverter(value, Projects)

LOGS/Entities/CustomTypeRequestParameter.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional
+
+from LOGS.Entities.CustomTypeEntityType import CustomTypeEntityType
+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.IPaginationRequest import IPaginationRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.IRelationRequest import IRelationRequest
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+
+
+class CustomTypeOrder(Enum):
+    ID_ASC = "ID_ASC"
+    ID_DESC = "ID_DESC"
+    NAME_ASC = "NAME_ASC"
+    NAME_DESC = "NAME_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"
+    NUMBER_OF_ITEMS_ASC = "NUMBER_OF_ITEMS_ASC"
+    NUMBER_OF_ITEMS_DESC = "NUMBER_OF_ITEMS_DESC"
+    INVENTORY_NAME_ASC = "INVENTORY_NAME_ASC"
+    INVENTORY_NAME_DESC = "INVENTORY_NAME_DESC"
+    LAYOUT_ASC = "LAYOUT_ASC"
+    LAYOUT_DESC = "LAYOUT_DESC"
+
+
+@dataclass
+class CustomTypeRequestParameter(
+    EntityRequestParameter[CustomTypeOrder],
+    IRelationRequest,
+    IPaginationRequest,
+    IPermissionedEntityRequest,
+    ICreationRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+    INamedEntityRequest,
+):
+    excludeDisabled: Optional[bool] = None
+    isEnabled: Optional[bool] = None
+    customFieldIds: Optional[List[int]] = None
+    entityTypes: Optional[List[CustomTypeEntityType]] = None
+    extendSearchToInventoryItems: Optional[bool] = None
+    parentTypeIds: Optional[List[int]] = None
+    hasRestrictedAddPermission: Optional[bool] = None
+    hasRestrictedEditPermission: Optional[bool] = None
+    hasRestrictedReadPermission: Optional[bool] = None
+    rootHierarchyIds: Optional[List[int]] = None
+    isInventory: Optional[bool] = None
+    isHierarchyRoot: Optional[bool] = None
+    inventoryNames: Optional[List[str]] = None
+    excludeNonInventories: Optional[bool] = None

LOGS/Entities/CustomTypeSection.py

@@ -0,0 +1,39 @@
+from typing import List, Optional
+
+from LOGS.Entities.CustomField import CustomField
+from LOGS.Entities.ILiterarTypedEntity import ILiterarTypedEntity
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+
+class CustomTypeSection(SerializeableContent, ILiterarTypedEntity):
+    _name: Optional[str] = None
+    _isFolded: Optional[bool] = None
+    _customFields: Optional[List[CustomField]] = None
+
+    _type = "CustomTypeSection"
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        self._name = self.checkAndConvertNullable(value, str, "name")
+
+    @property
+    def isFolded(self) -> Optional[bool]:
+        return self._isFolded
+
+    @isFolded.setter
+    def isFolded(self, value):
+        self._isFolded = self.checkAndConvertNullable(value, bool, "isFolded")
+
+    @property
+    def customFields(self) -> Optional[List[CustomField]]:
+        return self._customFields
+
+    @customFields.setter
+    def customFields(self, value):
+        self._customFields = self.checkListAndConvertNullable(
+            value, CustomField, "customFields"
+        )

LOGS/Entities/CustomTypes.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.CustomType import CustomType
+from LOGS.Entities.CustomTypeRequestParameter import CustomTypeRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("types")
+class CustomTypes(EntityIterator[CustomType, CustomTypeRequestParameter]):
+    """LOGS connected CustomTypes iterator"""
+
+    _generatorType = CustomType
+    _parameterType = CustomTypeRequestParameter

LOGS/Entities/DataSource.py

@@ -6,6 +6,7 @@ from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Auxiliary.Exceptions import EntityAPIException
 from LOGS.Auxiliary.MinimalModelGenerator import (
     BridgeMinimalFromDict,
+    FormatMinimalFromDict,
     InstrumentMinimalFromDict,
     MethodMinimalFromDict,
     MinimalFromList,
@@ -13,6 +14,7 @@ from LOGS.Auxiliary.MinimalModelGenerator import (
 from LOGS.Entities.BridgeMinimal import BridgeMinimal
 from LOGS.Entities.DataSourceRelations import DataSourceRelations
 from LOGS.Entities.DataSourceStatus import DataSourceStatus
+from LOGS.Entities.FileExcludePattern import FileExcludePattern
 from LOGS.Entities.Format import Format
 from LOGS.Entities.FormatMinimal import FormatMinimal
 from LOGS.Entities.InstrumentMinimal import InstrumentMinimal
@@ -22,13 +24,13 @@ 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.IPermissionedEntity import IPermissionedEntity
+from LOGS.Interfaces.IPermissionedEntity import GenericPermissionEntity
 from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.LOGSConnection import LOGSConnection
 
 
 class DataSourceType(Enum):
-    Crawling = "Crawling"
+    Crawler = "Crawler"
     IconNMR = "IconNMR"
 
 
@@ -39,13 +41,15 @@ class DataSource(
     ICreationRecord,
     IModificationRecord,
     IRelatedEntity[DataSourceRelations],
-    IPermissionedEntity,
+    GenericPermissionEntity,
 ):
-    _relationType = type(DataSourceRelations)
+    _relationType = DataSourceRelations
+
+    _relations: DataSourceRelations
 
     _type: Optional[DataSourceType]
     _bridge: Optional[BridgeMinimal]
-    _formatIds: Optional[List[int]]
+    _format: Optional[FormatMinimal]
     _customImport: Optional[EntityMinimalWithStrId]
     _enabled: Optional[bool]
     _bridgeId: Optional[int]
@@ -55,8 +59,8 @@ class DataSource(
     _method: Optional[MethodMinimal]
     _instrument: Optional[InstrumentMinimal]
     _cutoffDate: Optional[datetime]
-    _customImportId: Optional[str]
-    _parserDefinitions: Optional[Dict[str, Format]]
+    _fileExcludePatterns: Optional[List[FileExcludePattern]]
+    _formatDefinitions: Optional[Dict[str, Format]]
     _status: Optional[DataSourceStatus]
 
     def __init__(
@@ -69,7 +73,7 @@ class DataSource(
 
         self._type = None
         self._bridge = None
-        self._formatIds = None
+        self._format = None
         self._customImport = None
         self._enabled = None
         self._bridgeId = None
@@ -80,7 +84,6 @@ class DataSource(
         self._instrument = None
         self._cutoffDate = None
         self._customImportId = None
-        self._parserDefinitions = None
         self._status = None
 
         super().__init__(ref=ref, id=id, connection=connection)
@@ -154,12 +157,23 @@ class DataSource(
     def cutoffDate(self, value):
         self._cutoffDate = self.checkAndConvertNullable(value, datetime, "cutoffDate")
 
+    @property
+    def fileExcludePatterns(self) -> Optional[List[FileExcludePattern]]:
+        return self._fileExcludePatterns
+
+    @fileExcludePatterns.setter
+    def fileExcludePatterns(self, value):
+        self._fileExcludePatterns = self.checkListAndConvertNullable(
+            value, FileExcludePattern, "fileExcludePatterns"
+        )
+
     @property
     def customImportId(self) -> Optional[str]:
         return self._customImportId
 
     @customImportId.setter
     def customImportId(self, value):
+        print("customImportId", value)
         self._customImportId = self.checkAndConvertNullable(
             value, str, "customImportId"
         )
@@ -189,12 +203,12 @@ class DataSource(
         self._bridge = BridgeMinimalFromDict(value, "bridge", self.connection)
 
     @property
-    def formatIds(self) -> Optional[List[int]]:
-        return self._formatIds
+    def format(self) -> Optional[FormatMinimal]:
+        return self._format
 
-    @formatIds.setter
-    def formatIds(self, value):
-        self._formatIds = self.checkListAndConvertNullable(value, int, "formatIds")
+    @format.setter
+    def format(self, value):
+        self._format = FormatMinimalFromDict(value, "format", self.connection)
 
     @property
     def customImport(self) -> Optional[EntityMinimalWithStrId]: