logs-py 1.13__py3-none-any.whl → 2.1__py3-none-any.whl

LOGS/Entities/Role.py

@@ -1,19 +1,50 @@
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
-from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+from LOGS.Entities.RoleRelations import RoleRelations
+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.IUniqueEntity import IUniqueEntity
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
+from LOGS.LOGSConnection import LOGSConnection
 
 if TYPE_CHECKING:
-    from LOGS.Entities.PersonMinimal import PersonMinimal
+    pass
 
 
 @Endpoint("roles")
-class Role(INamedEntity, EntityWithIntId, IUniqueEntity):
+class Role(
+    IEntityWithIntId,
+    INamedEntity,
+    ICreationRecord,
+    IModificationRecord,
+    IRelatedEntity[RoleRelations],
+):
+    _relationType = type(RoleRelations)
+
+    _roleId: Optional[str] = None
     _description: Optional[str] = None
-    _users: Optional[List["PersonMinimal"]]
+    _isDefault: Optional[bool]
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = None,
+        connection: Optional[LOGSConnection] = None,
+    ):
+        if isinstance(ref, str):
+            ref = {"roleId": ref}
+
+        super().__init__(ref=ref, id=id, connection=connection)
+
+    @property
+    def roleId(self) -> Optional[str]:
+        return self._roleId
+
+    @roleId.setter
+    def roleId(self, value):
+        self._roleId = self.checkAndConvertNullable(value, str, "roleId")
 
     @property
     def description(self) -> Optional[str]:
@@ -21,14 +52,12 @@ class Role(INamedEntity, EntityWithIntId, IUniqueEntity):
 
     @description.setter
     def description(self, value):
-        self._description = self.checkAndConvertNullable(value, str, "fullName")
+        self._description = self.checkAndConvertNullable(value, str, "description")
 
     @property
-    def users(self) -> Optional[List["PersonMinimal"]]:
-        return self._users
-
-    @users.setter
-    def users(self, value):
-        self._users = MinimalFromList(
-            value, "PersonMinimal", "users", connection=self.connection
-        )
+    def isDefault(self) -> Optional[bool]:
+        return self._isDefault
+
+    @isDefault.setter
+    def isDefault(self, value):
+        self._isDefault = self.checkAndConvertNullable(value, bool, "isDefault")

LOGS/Entities/RoleRelations.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Entity.EntityRelation import EntityRelation
+from LOGS.Entity.EntityRelations import EntityRelations
+
+if TYPE_CHECKING:
+    from LOGS.Entities.Person import Person
+
+
+class RoleRelations(EntityRelations):
+    """Relations of a Role with other entities"""
+
+    _persons: Optional[EntityRelation["Person"]] = 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)

LOGS/Entities/RoleRequestParameter.py

@@ -1,9 +1,36 @@
 from dataclasses import dataclass
+from enum import Enum
 from typing import Optional
 
+from LOGS.Entities.IRelatedEntityRequest import IRelatedEntityRequest
 from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Interfaces.ICreationRecord import ICreationRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+
+
+class RoleOrder(Enum):
+    ID_ASC = "ID_ASC"
+    ID_DESC = "ID_DESC"
+    NAME_ASC = "NAME_ASC"
+    NAME_DESC = "NAME_DESC"
+    IS_INTERNAL_ASC = "IS_INTERNAL_ASC"
+    IS_INTERNAL_DESC = "IS_INTERNAL_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"
 
 
 @dataclass
-class RoleRequestParameter(EntityRequestParameter):
+class RoleRequestParameter(
+    EntityRequestParameter[RoleOrder],
+    IRelatedEntityRequest,
+    ICreationRecordRequest,
+    IModificationRecordRequest,
+):
     name: Optional[str] = None
+    roleId: Optional[str] = None

LOGS/Entities/Sample.py

@@ -8,11 +8,13 @@ from LOGS.Auxiliary.MinimalModelGenerator import (
 )
 from LOGS.Entities.SampleRelations import SampleRelations
 from LOGS.Entities.SampleTypeMinimal import SampleTypeMinimal
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
-from LOGS.Interfaces.ICustomFields import ICustomFields
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
 from LOGS.Interfaces.INamedEntity import INamedEntity
 from LOGS.Interfaces.IOwnedEntity import IOwnedEntity
+from LOGS.Interfaces.IProjectBased import IProjectBased
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.Interfaces.ITypedEntity import ITypedEntity
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
 from LOGS.LOGSConnection import LOGSConnection
 
@@ -24,24 +26,26 @@ if TYPE_CHECKING:
 
 @Endpoint("samples")
 class Sample(
-    INamedEntity,
-    EntityWithIntId,
+    IProjectBased,
+    IEntityWithIntId,
+    IRelatedEntity[SampleRelations],
+    ITypedEntity,
     IUniqueEntity,
     IOwnedEntity,
-    ICustomFields,
     ISoftDeletable,
+    INamedEntity,
 ):
+    _relationType = type(SampleRelations)
+
     _type: Optional[SampleTypeMinimal]
     _fullName: Optional[str] = None
     _createdAt: Optional[datetime]
     _preparedAt: Optional[datetime]
     _discardedAt: Optional[datetime]
-    _projects: Optional[List["ProjectMinimal"]]
     _preparedBy: Optional[List["PersonMinimal"]]
     _discardedBy: Optional[List["PersonMinimal"]]
     _other: Optional[str]
     _notes: Optional[str]
-    _relations: Optional[SampleRelations]
     _tags: Optional[Dict[str, Union[str, int, float]]]
 
     def __init__(
@@ -148,15 +152,15 @@ class Sample(
     # def discarders(self, value):
     #     self._discarders = self.checkAndConvertNullable(value, List, "discarders")
 
-    @property
-    def projects(self) -> Optional[List["ProjectMinimal"]]:
-        return self._projects
+    # @property
+    # def projects(self) -> Optional[List["ProjectMinimal"]]:
+    #     return self._projects
 
-    @projects.setter
-    def projects(self, value):
-        self._projects = MinimalFromList(
-            value, "ProjectMinimal", "projects", connection=self.connection
-        )
+    # @projects.setter
+    # def projects(self, value):
+    #     self._projects = MinimalFromList(
+    #         value, "ProjectMinimal", "projects", connection=self.connection
+    #     )
 
     # @property
     # def documents(self) -> List[Document]:
@@ -194,16 +198,6 @@ class Sample(
     def notes(self, value):
         self._notes = self.checkAndConvertNullable(value, str, "notes")
 
-    @property
-    def relations(self) -> Optional[SampleRelations]:
-        return self._relations
-
-    @relations.setter
-    def relations(self, value):
-        self._relations = self.checkAndConvertNullable(
-            value, SampleRelations, "relations"
-        )
-
     @property
     def tags(self) -> Optional[Dict[str, Union[str, int, float]]]:
         return self._tags
@@ -211,11 +205,11 @@ class Sample(
     @tags.setter
     def tags(self, value):
         self._tags = self.checkAndConvertNullable(value, dict, "tags")
-        self._tags = {
-            str(k): v
-            for k, v in self._tags.items()
-            if v is not None and k != "Name" and isinstance(v, (str, int, float))
-        }
-
-        if not self._tags:
+        if self._tags:
+            self._tags = {
+                str(k): v
+                for k, v in self._tags.items()
+                if v is not None and k != "Name" and isinstance(v, (str, int, float))
+            }
+        else:
             self._tags = None

LOGS/Entities/SampleRelations.py

@@ -1,7 +1,5 @@
 from typing import TYPE_CHECKING, Optional
 
-from LOGS.Entities.Datasets import Datasets
-from LOGS.Entities.Documents import Documents
 from LOGS.Entity.EntityRelation import EntityRelation
 from LOGS.Entity.EntityRelations import EntityRelations
 
@@ -23,6 +21,8 @@ class SampleRelations(EntityRelations):
 
     @documents.setter
     def documents(self, value):
+        from LOGS.Entities.Documents import Documents
+
         self._documents = self._entityConverter(value, Documents)
 
     @property
@@ -31,6 +31,8 @@ class SampleRelations(EntityRelations):
 
     @datasets.setter
     def datasets(self, value):
+        from LOGS.Entities.Datasets import Datasets
+
         self._datasets = self._entityConverter(value, Datasets)
 
     @property

LOGS/Entities/SampleRequestParameter.py

@@ -4,11 +4,11 @@ from enum import Enum
 from typing import List, Optional
 
 from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
-from LOGS.Interfaces.ICustomFields import ICustomFieldsRequest
 from LOGS.Interfaces.INamedEntity import INamedEntityRequest
 from LOGS.Interfaces.IOwnedEntity import IOwnedEntityRequest
 from LOGS.Interfaces.IPaginationRequest import IPaginationRequest
 from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+from LOGS.Interfaces.ITypedEntity import ITypedEntityRequest
 
 
 class SampleOrder(Enum):
@@ -20,23 +20,19 @@ class SampleOrder(Enum):
     PREPARATION_DATE_DESC = "PREPARATION_DATE_DESC"
     NAME_ASC = "NAME_ASC"
     NAME_DESC = "NAME_DESC"
-    SAMPLE_TYPE_ASC = "SAMPLE_TYPE_ASC"
-    SAMPLE_TYPE_DESC = "SAMPLE_TYPE_DESC"
+    TYPE_ASC = "TYPE_ASC"
+    TYPE_DESC = "TYPE_DESC"
 
 
 @dataclass
 class SampleRequestParameter(
-    EntityRequestParameter,
+    EntityRequestParameter[SampleOrder],
     IPaginationRequest,
     IOwnedEntityRequest,
-    ICustomFieldsRequest,
+    ITypedEntityRequest,
     INamedEntityRequest,
     ISoftDeletableRequest,
 ):
-    includePermissions: Optional[bool] = None
-    includeRelationLink: Optional[bool] = None
-    includeRelationCount: Optional[bool] = None
-
     projectIds: Optional[List[int]] = None
     organizationIds: Optional[List[int]] = None
     preparedByIds: Optional[List[int]] = None
@@ -48,4 +44,3 @@ class SampleRequestParameter(
     preparedAtFrom: Optional[datetime] = None
     preparedAtTo: Optional[datetime] = None
     includeTags: Optional[bool] = None
-    orderBy: Optional[SampleOrder] = None

LOGS/Entities/__init__.py

@@ -7,15 +7,13 @@
     Permission to use this libraray and all of its contents is 
     strictly permitted to the Signals Company.
 """
+
 from .AutoloadClientInfo import *
-from .AutoloadConfiguration import *
-from .AutoloadConfigurationMinimal import *
-from .AutoloadConfigurationRequestParameter import *
-from .AutoloadSource import *
-from .AutoloadSourceMinimal import *
-from .AutoloadSourceRequestParameter import *
-from .AutoloadSourceType import *
 from .AxisNaming import *
+from .Bridge import *
+from .BridgeMinimal import *
+from .BridgeRequestParameter import *
+from .BridgeType import *
 from .CustomSchema import *
 from .Dataset import *
 from .DatasetCreator import *
@@ -29,6 +27,9 @@ 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 .DatatrackNumericArray import *
 from .Document import *

LOGS/Entity/Entity.py

@@ -91,6 +91,28 @@ class Entity(ConnectedEntity):
     def fetch(self):
         self._fetchEntity(self._getConnection())
 
+    def _restoreEntity(self, connection: LOGSConnection):
+        if not self._endpoint:
+            raise NotImplementedError(
+                "Updating of entity type %a is not implemented."
+                % (
+                    type(self).__name__
+                    if type(self).__name__ != Entity.__name__
+                    else "unknown"
+                )
+            )
+
+        if not self.id:
+            raise EntityNotFoundException(self)
+
+        data, errors = connection.postEndpoint(
+            self._endpoint + ["restore", self.id], data=self.toDict()
+        )
+        if errors:
+            raise EntityUpdatingException(entity=self, errors=errors)
+
+        self.override(data)
+
     def _updateEntity(self, connection: LOGSConnection):
         if not self._endpoint:
             raise NotImplementedError(
@@ -130,6 +152,9 @@ class Entity(ConnectedEntity):
         _, error = connection.deleteEndpoint(
             self._endpoint + [self.id], parameters={"deletePermanently": permanently}
         )
+        if hasattr(self, "isDeleted"):
+            self.isDeleted = True
+
         if permanently:
             self.connection = None
 
@@ -148,6 +173,9 @@ class Entity(ConnectedEntity):
     def update(self):
         self._updateEntity(self._getConnection())
 
+    def restore(self):
+        self._restoreEntity(self._getConnection())
+
     def delete(self, permanently: bool = False):
         self._deleteEntity(self._getConnection(), permanently=permanently)
 
@@ -158,17 +186,13 @@ class Entity(ConnectedEntity):
 
     @property
     def identifier(self):
-        name = self.name
+        name = f"'{getattr(self, 'name')}'" if hasattr(self, "name") else None
         return "%s(id:%s)%s" % (
             type(self).__name__,
             str(self.id),
-            "'" + name + "'" if name else "",
+            name,
         )
 
-    @property
-    def name(self):
-        return getattr(self, "_name") if hasattr(self, "_name") else None
-
     @property
     def id(self):
         return self._id

LOGS/Entity/EntityRelations.py

@@ -3,15 +3,16 @@ from typing import Any, Optional, Type, cast
 from LOGS.Entity.ConnectedEntity import ConnectedEntity
 from LOGS.Entity.EntityConnector import EntityConnector
 from LOGS.Entity.EntityRelation import EntityRelation
+from LOGS.Interfaces.IRelationModel import IRelationModel
 from LOGS.LOGSConnection import LOGSConnection
 
 
-class EntityRelations(ConnectedEntity):
+class EntityRelations(ConnectedEntity, IRelationModel):
     def _entityConverter(self, ref: Any, entityConnector: Type[EntityConnector]):
         result = self.checkAndConvertNullable(
             ref, EntityRelation, fieldName=type(entityConnector).__name__.lower()
         )
-        result._entities = entityConnector(connection=self._connection)
+        result._entities = cast(Any, entityConnector(connection=self._connection))
         result._entities._firstUrl = result.link
         return result
 

LOGS/Entity/EntityRequestParameter.py

@@ -1,22 +1,27 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, List, Optional, Union
+from typing import Generic, List, Optional, TypeVar, Union
 
 from LOGS.Entity.SerializeableContent import SerializeableClass
 from LOGS.Interfaces.IPaginationRequest import IPaginationRequest
 
 
 class DefaultOrder(Enum):
-    id: Any = "id"
-    name: Any = "name"
+    ID_ASC = "ID_ASC"
+    ID_DESC = "ID_DESC"
+    NAME_ASC = "NAME_ASC"
+    NAME_DESC = "NAME_DESC"
+
+
+_Sorting = TypeVar("_Sorting", bound=Enum)
 
 
 @dataclass
-class EntityRequestParameter(SerializeableClass, IPaginationRequest):
+class EntityRequestParameter(Generic[_Sorting], SerializeableClass, IPaginationRequest):
     _noSerialize = ["asString"]
     excludeIds: Optional[Union[List[int], List[str]]] = None
     searchTerm: Optional[str] = None
     ids: Optional[Union[List[int], List[str]]] = None
     includeCount: Optional[bool] = None
     includeRelations: Optional[bool] = True
-    orderby: Any = None
+    orderby: Optional[_Sorting] = None

LOGS/Entity/EntityWithIntId.py

@@ -5,7 +5,7 @@ from LOGS.Entity.Entity import Entity
 from LOGS.LOGSConnection import LOGSConnection
 
 
-class EntityWithIntId(Entity):
+class IEntityWithIntId(Entity):
     _id: int = 0
 
     def __init__(

LOGS/Entity/SerializeableContent.py

@@ -72,7 +72,7 @@ class SerializeableContent:
                             )
                         else:
                             self.checkFieldAndConvert(
-                                ref, fieldName=k, fieldType=t, allowNone=True
+                                elements=ref, fieldName=k, fieldType=t, allowNone=True
                             )
 
             if fromDict:
@@ -116,13 +116,19 @@ class SerializeableContent:
         # print("ref", type(self).__name__)
 
         for k in dir(self):
-            # _k = "_" + k
+            # print(
+            #     f"[{type(self).__name__}] Attribute",
+            #     k,
+            #     k in ref and hasattr(self, k) and not callable(getattr(self, k)),
+            #     "->",
+            #     ref[k] if k in ref else "NULL",
+            # )
             if k in ref and hasattr(self, k) and not callable(getattr(self, k)):
                 try:
                     # print("  ", k, "->", ref[k])
                     setattr(self, k, ref[k])
-                except AttributeError:
-                    # print("ERROR:", k, "->", ref[k])
+                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

LOGS/Interfaces/ICreationRecord.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from LOGS.Auxiliary import Tools
 from LOGS.Auxiliary.MinimalModelGenerator import PersonMinimalFromDict
@@ -10,8 +10,17 @@ if TYPE_CHECKING:
     from LOGS.Entities.PersonMinimal import PersonMinimal
 
 
+class ICreatedOnRequest:
+    createdFrom: Optional[datetime] = None
+    createdTo: Optional[datetime] = None
+
+
+class ICreatedByRequest:
+    createdByIds: Optional[List[int]]
+
+
 @dataclass
-class ICreationRecordRequest:
+class ICreationRecordRequest(ICreatedOnRequest, ICreatedByRequest):
     pass
 
 
@@ -39,7 +48,7 @@ class ICreatedBy(IEntityInterface):
     @createdBy.setter
     def createdBy(self, value):
         self._createdBy = PersonMinimalFromDict(
-            value, "_createdBy", self._getEntityConnection()
+            value, "createdBy", self._getEntityConnection()
         )
 
 

LOGS/Interfaces/IModificationRecord.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 from LOGS.Auxiliary import Tools
 from LOGS.Auxiliary.MinimalModelGenerator import PersonMinimalFromDict
@@ -15,6 +15,15 @@ class IModificationRecordRequest:
     pass
 
 
+class IModifiedOnRequest:
+    modifiedFrom: Optional[datetime] = None
+    modifiedTo: Optional[datetime] = None
+
+
+class IModifiedByRequest:
+    modifiedByIds: Optional[List[int]]
+
+
 class IModifiedOn(IEntityInterface):
     _modifiedOn: Optional[datetime] = None
 

LOGS/Interfaces/IProjectBased.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+
+if TYPE_CHECKING:
+    from LOGS.Entities.ProjectMinimal import ProjectMinimal
+
+
+@dataclass
+class IProjectBasedRequest:
+    projects: Optional[List[str]] = None
+
+
+class IProjectBased(IEntityInterface):
+    _projects: Optional[List["ProjectMinimal"]] = None
+
+    @property
+    def projects(self) -> Optional[List["ProjectMinimal"]]:
+        return self._projects
+
+    @projects.setter
+    def projects(self, value):
+        connection = (
+            getattr(self, "connection") if hasattr(self, "connection") else None
+        )
+        self._projects = MinimalFromList(
+            value, "ProjectMinimal", "projects", connection=connection
+        )

LOGS/Interfaces/IRelatedEntity.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, Optional, Type, TypeVar
+
+from LOGS.Auxiliary import Tools
+from LOGS.Interfaces.IEntityInterface import IEntityInterface
+from LOGS.Interfaces.IRelationModel import IRelationModel
+
+if TYPE_CHECKING:
+    pass
+
+
+_Relations = TypeVar("_Relations", bound=IRelationModel)
+
+
+@dataclass
+class IRelatedEntity(Generic[_Relations], IEntityInterface):
+    _relationType: Optional[Type[_Relations]] = None
+    _relations: Optional[_Relations] = None
+
+    @property
+    def relations(self) -> Optional[_Relations]:
+        return self._relations
+
+    @relations.setter
+    def relations(self, value):
+        if not self._relationType:
+            raise NotImplementedError(
+                "Relation class definition (_relationType) for of entity type %a is missing."
+                % (type(self).__name__)
+            )
+
+        self._createdOn = Tools.checkAndConvert(
+            value, self._relationType, "relations", allowNone=True
+        )

LOGS/Interfaces/IRelationModel.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class IRelationModel:
+    pass

LOGS/Interfaces/IRelationRequest.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class IRelationRequest:
+    includePermissions: Optional[bool] = None
+    includeRelationLink: Optional[bool] = None
+    includeRelationCount: Optional[bool] = None