logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/Project.py

@@ -0,0 +1,52 @@
+from typing import List, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.ProjectPersonPermission import ProjectPersonPermission
+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.IOwnedEntity import IOwnedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.ITypedEntity import ITypedEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+from LOGS.LOGSConnection import LOGSConnection
+
+
+@Endpoint("projects")
+class Project(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    ITypedEntity,
+    IOwnedEntity,
+    IEntryRecord,
+    IModificationRecord,
+    ILockableEntity,
+    IGenericPermissionEntity,
+):
+
+    _projectPersonPermissions: Optional[List[ProjectPersonPermission]] = None
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = None,
+        connection: Optional[LOGSConnection] = None,
+        name: Optional[str] = None,
+    ):
+        """Represents a connected LOGS entity type"""
+
+        self._name = name
+        super().__init__(ref=ref, id=id, connection=connection)
+
+    @property
+    def projectPersonPermissions(self) -> Optional[List[ProjectPersonPermission]]:
+        return self._projectPersonPermissions
+
+    @projectPersonPermissions.setter
+    def projectPersonPermissions(self, value):
+        self._projectPersonPermissions = self.checkListAndConvertNullable(
+            value, ProjectPersonPermission, "projectPersonPermissions"
+        )

LOGS/Entities/ProjectMinimal.py

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

LOGS/Entities/ProjectPersonPermission.py

@@ -0,0 +1,102 @@
+from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Union
+
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entity.ConnectedEntity import ConnectedEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+    from LOGS.Entities.ProjectMinimal import ProjectMinimal
+
+
+class ProjectPersonPermission(ConnectedEntity):
+    _person: Optional["PersonMinimal"] = None
+    _project: Optional["ProjectMinimal"] = None
+    _administer: Optional[bool] = None
+    _edit: Optional[bool] = None
+    _add: Optional[bool] = None
+    _read: Optional[bool] = None
+
+    def _fromRef(
+        self,
+        ref,
+        selfClass,
+        convertOtherType: Union[Tuple[type, Callable[[Any], Any]], None] = None,
+    ):
+        if isinstance(ref, dict) and "read" in ref:
+            self._read = ref["read"]
+            del ref["read"]
+        return super()._fromRef(ref, selfClass, convertOtherType)
+
+    def __str__(self):
+        attrList = self._getAttrList()
+
+        s1 = f"'{self.person.name}'" if self.person else ""
+        s2 = ",".join(k for k in attrList if getattr(self, k, None) is True)
+        return f"<{type(self).__name__} {s1} access:{s2}>"
+
+    def contentToString(self, indentation: int = 1, hideNone: bool = False) -> str:
+        return str(self)
+
+    @property
+    def person(self) -> Optional["PersonMinimal"]:
+        return self._person
+
+    @person.setter
+    def person(self, value):
+        self._person = MinimalModelGenerator.MinimalFromSingle(
+            value, "PersonMinimal", "person", self._getConnection()
+        )
+
+    @property
+    def project(self) -> Optional["ProjectMinimal"]:
+        return self._project
+
+    @project.setter
+    def project(self, value):
+        self._project = MinimalModelGenerator.MinimalFromSingle(
+            value, "ProjectMinimal", "project", self._getConnection()
+        )
+
+    @property
+    def administer(self) -> Optional[bool]:
+        return self._administer
+
+    @administer.setter
+    def administer(self, value):
+        self._administer = self.checkAndConvertNullable(value, bool, "administer")
+        if self._administer:
+            self._edit = True
+            self._add = True
+
+    @property
+    def edit(self) -> Optional[bool]:
+        return self._edit
+
+    @edit.setter
+    def edit(self, value):
+        self._edit = self.checkAndConvertNullable(value, bool, "edit")
+        if self._edit:
+            self._add = True
+        else:
+            self._administer = False
+
+    @property
+    def add(self) -> Optional[bool]:
+        return self._add
+
+    @add.setter
+    def add(self, value):
+        self._add = self.checkAndConvertNullable(value, bool, "add")
+        if not self._add:
+            self._edit = False
+            self._administer = False
+
+    @property
+    def read(self) -> Optional[bool]:
+        return self._read
+
+    @read.setter
+    def read(self, _):
+        raise Exception(
+            "Every person added to a project has automatically read permissions."
+        )

LOGS/Entities/ProjectRequestParameter.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,
+    INamedEntitySortingOptions,
+    ITypedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.ILockableEntity import ILockableEntityRequest
+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.ITypedEntity import ITypedEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+
+
+class ProjectSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+    ITypedEntitySortingOptions,
+):
+    DATASET_COUNT: Self = cast(Self, "DATASET_COUNT")
+    INVENTORY_ITEM_COUNT: Self = cast(Self, "INVENTORY_ITEM_COUNT")
+    LAB_NOTEBOOK_COUNT: Self = cast(Self, "LAB_NOTEBOOK_COUNT")
+    SAMPLE_COUNT: Self = cast(Self, "SAMPLE_COUNT")
+
+
+@dataclass
+class ProjectRequestParameter(
+    EntityRequestParameter[ProjectSortingOptions],
+    IPermissionedEntityRequest,
+    IUniqueEntityRequest,
+    INamedEntityRequest,
+    IOwnedEntityRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    ILockableEntityRequest,
+    ITypedEntityRequest,
+):
+    _orderByType: Type[ProjectSortingOptions] = field(
+        default=ProjectSortingOptions, init=False
+    )
+
+    inventoryItemIds: Optional[List[int]] = None
+    labNotebookIds: Optional[List[int]] = None
+    personIds: Optional[List[int]] = None
+    datasetIds: Optional[List[int]] = None
+    sampleIds: Optional[List[int]] = None
+    currentUserHasAddPermission: Optional[bool] = None

LOGS/Entities/Projects.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Project import Project
+from LOGS.Entities.ProjectRequestParameter import ProjectRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("projects")
+class Projects(EntityIterator[Project, ProjectRequestParameter]):
+    """LOGS connected Projects iterator"""
+
+    _generatorType = Project
+    _parameterType = ProjectRequestParameter

LOGS/Entities/Role.py

@@ -0,0 +1,94 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from LOGS.Auxiliary import MinimalModelGenerator
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Permission import Permission
+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
+
+if TYPE_CHECKING:
+    from LOGS.Entities.PersonMinimal import PersonMinimal
+
+
+@Endpoint("roles")
+class Role(
+    IEntityWithIntId,
+    INamedEntity,
+    IGenericPermissionEntity,
+    IEntryRecord,
+    IModificationRecord,
+):
+
+    _rolePermissions: Optional[List["Permission"]] = None
+    _users: Optional[List["PersonMinimal"]] = None
+    _isInternal: Optional[bool] = None
+    _roleId: Optional[str] = None
+    _description: Optional[str] = None
+    _isDefault: Optional[bool] = None
+
+    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 rolePermissions(self) -> Optional[List["Permission"]]:
+        return self._rolePermissions
+
+    @rolePermissions.setter
+    def rolePermissions(self, value):
+        self._rolePermissions = self.checkListAndConvertNullable(
+            value, Permission, "rolePermissions"
+        )
+
+    @property
+    def users(self) -> Optional[List["PersonMinimal"]]:
+        return self._users
+
+    @users.setter
+    def users(self, value):
+        self._users = MinimalModelGenerator.MinimalFromList(
+            value, "PersonMinimal", "users", self._getConnection()
+        )
+
+    @property
+    def isInternal(self) -> Optional[bool]:
+        return self._isInternal
+
+    @isInternal.setter
+    def isInternal(self, value):
+        self._isInternal = self.checkAndConvertNullable(value, bool, "isInternal")
+
+    @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]:
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        self._description = self.checkAndConvertNullable(value, str, "description")
+
+    @property
+    def isDefault(self) -> Optional[bool]:
+        return self._isDefault
+
+    @isDefault.setter
+    def isDefault(self, value):
+        self._isDefault = self.checkAndConvertNullable(value, bool, "isDefault")

LOGS/Entities/RoleMinimal.py

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

LOGS/Entities/RoleRequestParameter.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass, field
+from typing import Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+
+
+class RoleSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+):
+    IS_INTERNAL: Self = cast(Self, "IS_INTERNAL")
+
+
+@dataclass
+class RoleRequestParameter(
+    EntityRequestParameter[RoleSortingOptions],
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    IPermissionedEntityRequest,
+):
+    _orderByType: Type[RoleSortingOptions] = field(
+        default=RoleSortingOptions, init=False
+    )
+
+    name: Optional[str] = None
+    roleId: Optional[str] = None
+    includeInternals: Optional[bool] = None

LOGS/Entities/Roles.py

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

LOGS/Entities/RunState.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RunState(Enum):
+    Running = "Running"
+    Failed = "Failed"
+    Finished = "Finished"
+    Waiting = "Waiting"
+    Aborted = "Aborted"

LOGS/Entities/Sample.py

@@ -0,0 +1,53 @@
+from typing import TYPE_CHECKING, List, Optional, Union, cast
+
+from LOGS.Auxiliary.Decorators import Endpoint
+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.IOwnedEntity import IOwnedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IProjectBased import IProjectBased
+from LOGS.Interfaces.ISignableEntity import ISignableEntity
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletable
+from LOGS.Interfaces.ITypedEntity import ITypedEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+from LOGS.LOGSConnection import LOGSConnection
+
+if TYPE_CHECKING:
+    from LOGS.Entities.Project import Project
+    from LOGS.Entities.ProjectMinimal import ProjectMinimal
+
+
+@Endpoint("samples")
+class Sample(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    ITypedEntity,
+    IOwnedEntity,
+    IProjectBased,
+    IEntryRecord,
+    IModificationRecord,
+    ISoftDeletable,
+    ILockableEntity,
+    ISignableEntity,
+    IGenericPermissionEntity,
+):
+
+    def __init__(
+        self,
+        ref=None,
+        id: Optional[int] = None,
+        connection: Optional[LOGSConnection] = None,
+        name: str = "",
+        projects: Optional[List[Union["ProjectMinimal", "Project"]]] = None,
+    ):
+        self._name = name
+        self._projects = cast(Optional[List["ProjectMinimal"]], projects)
+
+        if ref != None and isinstance(ref, (str, int, float)):
+            ref = {"text": str(ref)}
+
+        super().__init__(ref=ref, id=id, connection=connection)

LOGS/Entities/SampleMinimal.py

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

LOGS/Entities/SampleRequestParameter.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass, field
+from typing import Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+    ITypedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.ILockableEntity import ILockableEntityRequest
+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.ISignableEntity import ISignableEntityRequest
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+from LOGS.Interfaces.ITypedEntity import ITypedEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+
+
+class SampleSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    IEntryRecordSortingOptions,
+    ITypedEntitySortingOptions,
+):
+    OWNER: Self = cast(Self, "OWNER")
+
+
+@dataclass
+class SampleRequestParameter(
+    EntityRequestParameter[SampleSortingOptions],
+    IPermissionedEntityRequest,
+    IUniqueEntityRequest,
+    INamedEntityRequest,
+    IOwnedEntityRequest,
+    IProjectBasedRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    ISoftDeletableRequest,
+    ILockableEntityRequest,
+    ISignableEntityRequest,
+    ITypedEntityRequest,
+):
+    _orderByType: Type[SampleSortingOptions] = field(
+        default=SampleSortingOptions, init=False
+    )

LOGS/Entities/Samples.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.Sample import Sample
+from LOGS.Entities.SampleRequestParameter import SampleRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("samples")
+class Samples(EntityIterator[Sample, SampleRequestParameter]):
+    """LOGS connected Samples iterator"""
+
+    _generatorType = Sample
+    _parameterType = SampleRequestParameter

LOGS/Entities/SharedContent.py

@@ -0,0 +1,87 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from deprecation import deprecated  # type: ignore
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+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.IOwnedEntity import IOwnedEntity
+from LOGS.Interfaces.IPermissionedEntity import IGenericPermissionEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities.DatasetMinimal import DatasetMinimal
+
+
+@Endpoint("shared_content")
+class SharedContent(
+    IEntityWithIntId,
+    IGenericPermissionEntity,
+    IUniqueEntity,
+    INamedEntity,
+    IOwnedEntity,
+    IEntryRecord,
+    IModificationRecord,
+):
+
+    _shareId: Optional[str] = None
+    _allowContentDownload: Optional[bool] = None
+    _publicNotes: Optional[str] = None
+    _privateNotes: Optional[str] = None
+    _password: Optional[str] = None
+    _datasets: Optional[List["DatasetMinimal"]] = None
+
+    @property
+    def shareId(self) -> Optional[str]:
+        return self._shareId
+
+    @shareId.setter
+    def shareId(self, value):
+        self._shareId = self.checkAndConvertNullable(value, str, "shareId")
+
+    @property
+    def allowContentDownload(self) -> Optional[bool]:
+        return self._allowContentDownload
+
+    @allowContentDownload.setter
+    def allowContentDownload(self, value):
+        self._allowContentDownload = self.checkAndConvertNullable(
+            value, bool, "allowContentDownload"
+        )
+
+    @property
+    def publicNotes(self) -> Optional[str]:
+        return self._publicNotes
+
+    @publicNotes.setter
+    def publicNotes(self, value):
+        self._publicNotes = self.checkAndConvertNullable(value, str, "publicNotes")
+
+    @property
+    def privateNotes(self) -> Optional[str]:
+        return self._privateNotes
+
+    @privateNotes.setter
+    def privateNotes(self, value):
+        self._privateNotes = self.checkAndConvertNullable(value, str, "privateNotes")
+
+    @property
+    def password(self) -> Optional[str]:
+        return self._password
+
+    @password.setter
+    def password(self, value):
+        self._password = self.checkAndConvertNullable(value, str, "password")
+
+    @property
+    def datasets(self) -> Optional[List["DatasetMinimal"]]:
+        return self._datasets
+
+    @datasets.setter
+    def datasets(self, value):
+        self._datasets = MinimalModelGenerator.MinimalFromList(
+            value, "DatasetMinimal", "datasets", connection=self._getConnection()
+        )

LOGS/Entities/SharedContentMinimal.py

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

LOGS/Entities/SharedContentRequestParameter.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IEntryRecordSortingOptions,
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+    INamedEntitySortingOptions,
+)
+from LOGS.Interfaces.IEntryRecord import IEntryRecordRequest
+from LOGS.Interfaces.IModificationRecord import IModificationRecordRequest
+from LOGS.Interfaces.IPermissionedEntity import IPermissionedEntityRequest
+from LOGS.Interfaces.ISoftDeletable import ISoftDeletableRequest
+
+
+class SharedContentSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IEntryRecordSortingOptions,
+    IModificationRecordSortingOptions,
+):
+    pass
+
+
+@dataclass
+class SharedContentRequestParameter(
+    EntityRequestParameter[SharedContentSortingOptions],
+    ISoftDeletableRequest,
+    IEntryRecordRequest,
+    IModificationRecordRequest,
+    IPermissionedEntityRequest,
+):
+    _orderByType: Type[SharedContentSortingOptions] = field(
+        default=SharedContentSortingOptions, init=False
+    )
+
+    datasetIds: Optional[List[int]] = None

LOGS/Entities/SharedContents.py

@@ -0,0 +1,12 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.SharedContent import SharedContent
+from LOGS.Entities.SharedContentRequestParameter import SharedContentRequestParameter
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("shared_content")
+class SharedContents(EntityIterator[SharedContent, SharedContentRequestParameter]):
+    """LOGS connected SharedContents iterator"""
+
+    _generatorType = SharedContent
+    _parameterType = SharedContentRequestParameter