logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/LabNotebookTemplate.py

@@ -0,0 +1,42 @@
+from typing import Any, Dict, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.ILockableEntity import ILockableEntity
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IProjectBased import IProjectBased
+from LOGS.Interfaces.ISessionedEntity import ISessionedEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntity
+
+
+@Endpoint("lab_notebook_templates")
+class LabNotebookTemplate(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    IVersionedEntity,
+    IProjectBased,
+    IGenericPermissionEntity,
+    ISessionedEntity,
+    ILockableEntity,
+):
+    _description: Optional[str] = None
+    _content: Optional[Dict[str, Any]] = None
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value: str):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def content(self) -> Optional[Dict[str, Any]]:
+        return self._content
+
+    @content.setter
+    def content(self, value: Dict[str, Any]):
+        self._content = self.checkAndConvertNullable(value, dict, "content")

LOGS/Entities/LabNotebookTemplateMinimal.py

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

LOGS/Entities/LabNotebookTemplateRequestParameter.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass, field
+from typing import Type
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Interfaces.ILockableEntity import ILockableEntityRequest
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.IProjectBased import IProjectBasedRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntityRequest
+
+
+class LabNotebookTemplateSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IModificationRecordSortingOptions,
+):
+    pass
+
+
+@dataclass
+class LabNotebookTemplateRequestParameter(
+    EntityRequestParameter[LabNotebookTemplateSortingOptions],
+    IPermissionedEntityRequest,
+    IUniqueEntityRequest,
+    INamedEntityRequest,
+    IProjectBasedRequest,
+    IVersionedEntityRequest[int],
+    ILockableEntityRequest,
+):
+    _orderByType: Type[LabNotebookTemplateSortingOptions] = field(
+        default=LabNotebookTemplateSortingOptions, init=False
+    )

LOGS/Entities/LabNotebookTemplates.py

@@ -0,0 +1,16 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.LabNotebookTemplate import LabNotebookTemplate
+from LOGS.Entities.LabNotebookTemplateRequestParameter import (
+    LabNotebookTemplateRequestParameter,
+)
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("lab_notebook_templates")
+class LabNotebookTemplates(
+    EntityIterator[LabNotebookTemplate, LabNotebookTemplateRequestParameter]
+):
+    """LOGS connected LabNotebookTemplate iterator"""
+
+    _generatorType = LabNotebookTemplate
+    _parameterType = LabNotebookTemplateRequestParameter

LOGS/Entities/LabNotebooks.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.LabNotebook import LabNotebook
+from LOGS.Entities.LabNotebookRequestParameter import LabNotebookRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("lab_notebooks")
+class LabNotebooks(EntityIterator[LabNotebook, LabNotebookRequestParameter]):
+    """LOGS connected LabNotebook iterator"""
+
+    _generatorType = LabNotebook
+    _parameterType = LabNotebookRequestParameter

LOGS/Entities/Method.py

@@ -0,0 +1,66 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entity.EntityWithStrId import EntityWithStrId
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.DataFormatMinimal import DataFormatMinimal
+    from LOGS.Entities.MethodMinimal import MethodMinimal
+
+
+@Endpoint("methods")
+class Method(EntityWithStrId, INamedEntity, IGenericPermissionEntity):
+    _fullName: Optional[str] = None
+    _description: Optional[str] = None
+    _dataFormats: Optional[List["DataFormatMinimal"]] = None
+    _childMethods: Optional[List["MethodMinimal"]] = None
+    _parentMethod: Optional["MethodMinimal"] = None
+
+    @property
+    def fullName(self) -> Optional[str]:
+        return self._fullName
+
+    @fullName.setter
+    def fullName(self, value):
+        self._fullName = self.checkAndConvertNullable(value, str, "fullName")
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def dataFormats(self) -> Optional[List["DataFormatMinimal"]]:
+        return self._dataFormats
+
+    @dataFormats.setter
+    def dataFormats(self, value):
+        self._dataFormats = MinimalModelGenerator.MinimalFromList(
+            value, "DataFormatMinimal", "dataFormats", connection=self._getConnection()
+        )
+
+    @property
+    def childMethods(self) -> Optional[List["MethodMinimal"]]:
+        return self._childMethods
+
+    @childMethods.setter
+    def childMethods(self, value):
+        self._childMethods = MinimalModelGenerator.MinimalFromList(
+            value, "MethodMinimal", "childMethods", self._getConnection()
+        )
+
+    @property
+    def parentMethod(self) -> Optional["MethodMinimal"]:
+        return self._parentMethod
+
+    @parentMethod.setter
+    def parentMethod(self, value):
+        self._parentMethod = MinimalModelGenerator.MinimalFromSingle(
+            value, "MethodMinimal", "parentMethod", self._getConnection()
+        )

LOGS/Entities/MethodMinimal.py

@@ -0,0 +1,8 @@
+from LOGS.Auxiliary.Decorators import FullModel
+from LOGS.Entities.Method import Method
+from LOGS.Entity.EntityMinimalWithStrId import EntityMinimalWithStrId
+
+
+@FullModel(Method)
+class MethodMinimal(EntityMinimalWithStrId[Method]):
+    pass

LOGS/Entities/MethodRequestParameter.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass, field
+from typing import Optional, Type
+
+from LOGS.Entity.EntityRequestParameter import (
+    DefaultSortingOptions,
+    EntityRequestParameter,
+)
+
+
+@dataclass
+class MethodRequestParameter(EntityRequestParameter[DefaultSortingOptions]):
+    _orderByType: Type[DefaultSortingOptions] = field(
+        default=DefaultSortingOptions, init=False
+    )
+
+    name: Optional[str] = None

LOGS/Entities/Methods.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Method import Method
+from LOGS.Entities.MethodRequestParameter import MethodRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("methods")
+class Methods(EntityIterator[Method, MethodRequestParameter]):
+    """LOGS connected class FormatMethod iterator"""
+
+    _generatorType = Method
+    _parameterType = MethodRequestParameter

LOGS/Entities/Origin.py

@@ -0,0 +1,53 @@
+from typing import Optional
+from uuid import UUID
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.IEntryRecord import IEntryRecord
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.LOGSConnection import LOGSConnection
+
+
+@Endpoint("origins")
+class Origin(
+    IEntityWithIntId,
+    INamedEntity,
+    IModificationRecord,
+    IEntryRecord,
+    IGenericPermissionEntity,
+):
+    _url: Optional[str] = None
+    _uid: Optional[UUID] = None
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = None,
+        connection: Optional[LOGSConnection] = None,
+        name: Optional[str] = None,
+        url: Optional[str] = None,
+        uid: Optional[UUID] = None,
+    ):
+        self._name = name
+        self._url = url
+        self._uid = uid
+
+        super().__init__(ref=ref, id=id, connection=connection)
+
+    @property
+    def url(self) -> Optional[str]:
+        return self._url
+
+    @url.setter
+    def url(self, value):
+        self._url = self.checkAndConvertNullable(value, str, "url")
+
+    @property
+    def uid(self) -> Optional[UUID]:
+        return self._uid
+
+    @uid.setter
+    def uid(self, value):
+        self._uid = self.checkAndConvertNullable(value, UUID, "uid")

LOGS/Entities/OriginMinimal.py

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

LOGS/Entities/OriginRequestParameter.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Sequence, Type, Union
+from uuid import UUID
+
+from LOGS.Entity.EntityRequestParameter import (
+    DefaultSortingOptions,
+    EntityRequestParameter,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.INamedEntity import INamedEntityRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+
+
+@dataclass
+class OriginRequestParameter(
+    EntityRequestParameter[DefaultSortingOptions],
+    INamedEntityRequest,
+    IModificationRecordRequest,
+    IEntryRecordRequest,
+    IPermissionedEntityRequest,
+):
+    _orderByType: Type[DefaultSortingOptions] = field(
+        default=DefaultSortingOptions, init=False
+    )
+
+    urls: Optional[List[str]] = None
+    uids: Optional[Sequence[Union[UUID, str]]] = None

LOGS/Entities/Origins.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Origin import Origin
+from LOGS.Entities.OriginRequestParameter import OriginRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("origins")
+class Origins(EntityIterator[Origin, OriginRequestParameter]):
+    """LOGS connected Person iterator"""
+
+    _generatorType = Origin
+    _parameterType = OriginRequestParameter

LOGS/Entities/ParserLog.py

@@ -0,0 +1,49 @@
+from typing import List, Optional
+
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class ParserLog(SerializableContent):
+    _type: Optional[str] = None
+    _message: Optional[str] = None
+    _description: Optional[List[str]] = None
+    _code: Optional[int] = None
+
+    def __init__(self, ref=None):
+        super().__init__(ref=ref)
+
+    def __str__(self):
+        error = f" ({self.code})" if self.code else ""
+        return f"{type(self).__name__}.{self.type}{error}: {self.message}"
+
+    @property
+    def type(self) -> Optional[str]:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = self.checkAndConvertNullable(value, str, "type")
+
+    @property
+    def message(self) -> Optional[str]:
+        return self._message
+
+    @message.setter
+    def message(self, value):
+        self._message = self.checkAndConvertNullable(value, str, "message")
+
+    @property
+    def description(self) -> Optional[List[str]]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkListAndConvertNullable(value, str, "description")
+
+    @property
+    def code(self) -> Optional[int]:
+        return self._code
+
+    @code.setter
+    def code(self, value):
+        self._code = self.checkAndConvertNullable(value, int, "code")

LOGS/Entities/Permission.py

@@ -0,0 +1,9 @@
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class Permission(SerializableClass):
+    name: Optional[str] = None
+    shortDescription: Optional[str] = None
+    longDescription: Optional[str] = None

LOGS/Entities/Person.py

@@ -0,0 +1,145 @@
+from enum import Enum
+from typing import List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.ProjectPersonPermission import ProjectPersonPermission
+from LOGS.Entities.Role import Role
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
+from LOGS.Interfaces.IEntryRecord import IEntryRecord
+from LOGS.Interfaces.ILockableEntity import ILockableEntity
+from LOGS.Interfaces.IModificationRecord import IModificationRecord
+from LOGS.Interfaces.INamedEntity import INamedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.Interfaces.ITypedEntity import ITypedEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+
+class PersonAccountState(Enum):
+    NoAccount = "NoAccount"
+    Enabled = "Enabled"
+    Disabled = "Disabled"
+
+
+@Endpoint("persons")
+class Person(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    ITypedEntity,
+    IEntryRecord,
+    IModificationRecord,
+    ISoftDeletable,
+    ILockableEntity,
+    IGenericPermissionEntity,
+):
+
+    _personProjectPermissions: Optional[List[ProjectPersonPermission]] = None
+
+    _isSystemUser: Optional[bool] = None
+    _has2FA: Optional[bool] = None
+    _isLocalUser: Optional[bool] = None
+
+    _firstName: Optional[str] = None
+    _lastName: Optional[str] = None
+    _login: Optional[str] = None
+    _accountState: Optional[PersonAccountState] = None
+
+    _email: Optional[str] = None
+    _roles: Optional[List[Role]] = None
+    _password: Optional[str] = None
+
+    @property
+    def personProjectPermissions(self) -> Optional[List[ProjectPersonPermission]]:
+        return self._personProjectPermissions
+
+    @personProjectPermissions.setter
+    def personProjectPermissions(self, value):
+        self._personProjectPermissions = self.checkListAndConvertNullable(
+            value, ProjectPersonPermission, "personProjectPermissions"
+        )
+
+    @property
+    def isSystemUser(self) -> Optional[bool]:
+        return self._isSystemUser
+
+    @isSystemUser.setter
+    def isSystemUser(self, value):
+        self._isSystemUser = self.checkAndConvertNullable(value, bool, "isSystemUser")
+
+    @property
+    def has2FA(self) -> Optional[bool]:
+        return self._has2FA
+
+    @has2FA.setter
+    def has2FA(self, value):
+        self._has2FA = self.checkAndConvertNullable(value, bool, "has2FA")
+
+    @property
+    def isLocalUser(self) -> Optional[bool]:
+        return self._isLocalUser
+
+    @isLocalUser.setter
+    def isLocalUser(self, value):
+        self._isLocalUser = self.checkAndConvertNullable(value, bool, "isLocalUser")
+
+    @property
+    def login(self) -> Optional[str]:
+        return self._login
+
+    @login.setter
+    def login(self, value):
+        self._login = self.checkAndConvertNullable(value, str, "login")
+
+    @property
+    def accountState(self) -> Optional[PersonAccountState]:
+        return self._accountState
+
+    @accountState.setter
+    def accountState(self, value):
+        self._accountState = self.checkAndConvertNullable(
+            value, PersonAccountState, "accountState"
+        )
+
+    @property
+    def firstName(self) -> Optional[str]:
+        return self._firstName
+
+    @firstName.setter
+    def firstName(self, value):
+        self._firstName = self.checkAndConvertNullable(value, str, "firstName")
+
+    @property
+    def lastName(self) -> Optional[str]:
+        return self._lastName
+
+    @lastName.setter
+    def lastName(self, value):
+        self._lastName = self.checkAndConvertNullable(value, str, "lastName")
+
+    @property
+    def email(self) -> Optional[str]:
+        return self._email
+
+    @email.setter
+    def email(self, value):
+        self._email = self.checkAndConvertNullable(value, str, "email")
+
+    @property
+    def roles(self) -> Optional[List[Role]]:
+        return self._roles
+
+    @roles.setter
+    def roles(self, value):
+        if value is None:
+            self._roles = None
+        else:
+            self._roles = self.checkListAndConvertNullable(value, Role, "roles")
+
+    @property
+    def password(self) -> Optional[str]:
+        return self._password
+
+    @password.setter
+    def password(self, value):
+        self._password = self.checkAndConvertNullable(value, str, "password")

LOGS/Entities/PersonCategory.py

@@ -0,0 +1,12 @@
+from typing import Optional
+
+from LOGS.Entity.SerializableContent import SerializableClass
+
+
+class PersonCategory(SerializableClass):
+    id: Optional[int] = None
+    name: Optional[str] = None
+
+    def __str__(self):
+        s = (" name:'%s'" % self.name) if self.name else ""
+        return "<%s id:%s%s>" % (type(self).__name__, str(self.id), s)

LOGS/Entities/PersonMinimal.py

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

LOGS/Entities/PersonRequestParameter.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    ITypedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.ILockableEntity import ILockableEntityRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+from LOGS.Interfaces.ITypedEntity import ITypedEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+
+
+class PersonSortingOptions(
+    IGenericEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+    ITypedEntitySortingOptions,
+):
+    NAME: Self = cast(Self, "NAME")
+    LOGIN: Self = cast(Self, "LOGIN")
+    IS_SYSTEM_USER: Self = cast(Self, "IS_SYSTEM_USER")
+    LAST_NAME: Self = cast(Self, "LAST_NAME")
+    FIRST_NAME: Self = cast(Self, "FIRST_NAME")
+
+
+@dataclass
+class PersonRequestParameter(
+    EntityRequestParameter[PersonSortingOptions],
+    IPermissionedEntityRequest,
+    IUniqueEntityRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+    ILockableEntityRequest,
+    ITypedEntityRequest,
+):
+    _orderByType: Type[PersonSortingOptions] = field(
+        default=PersonSortingOptions, init=False
+    )
+
+    isLocalUser: Optional[List[bool]] = None
+    roleIds: Optional[List[int]] = None
+    hasAccount: Optional[bool] = None
+    isAccountEnabled: Optional[bool] = None
+    includeSystemUsers: Optional[bool] = None
+    logins: Optional[List[str]] = None
+    emails: Optional[List[str]] = None
+    firstNames: Optional[List[str]] = None
+    lastNames: Optional[List[str]] = None

LOGS/Entities/Persons.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Person import Person
+from LOGS.Entities.PersonRequestParameter import PersonRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("persons")
+class Persons(EntityIterator[Person, PersonRequestParameter]):
+    """LOGS connected Person iterator"""
+
+    _generatorType = Person
+    _parameterType = PersonRequestParameter