logs-py 4.0.7__py3-none-any.whl

LOGS/Entities/LabNotebookEntryContent/EntryContentText.py

@@ -0,0 +1,33 @@
+from typing import List, Optional
+
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.TextMarkConverter import TextMarkConverter
+from LOGS.Entities.LabNotebookEntryContent.TextMarks import IEntryContentWithAttribute
+
+
+class EntryContentText(EntryContentItem):
+    _type = "text"
+
+    _text: Optional[str] = None
+    _marks: Optional[List[IEntryContentWithAttribute]] = None
+
+    @property
+    def text(self) -> Optional[str]:
+        return self._text
+
+    @text.setter
+    def text(self, value):
+        self._text = self.checkAndConvertNullable(value, str, "text")
+
+    @property
+    def marks(self) -> Optional[List[IEntryContentWithAttribute]]:
+        return self._marks
+
+    @marks.setter
+    def marks(self, value):
+        self._marks = self.checkListAndConvertNullable(
+            value,
+            IEntryContentWithAttribute,
+            "marks",
+            converter=TextMarkConverter.convert,
+        )

LOGS/Entities/LabNotebookEntryContent/IEntryContentWithAttribute.py

@@ -0,0 +1,23 @@
+from typing import Generic, Optional, Type, TypeVar
+
+from LOGS.Entities.LabNotebookEntryContent.BasicAttribute import BasicAttribute
+from LOGS.Entity.SerializableContent import SerializableContent
+
+_T = TypeVar("_T", bound=BasicAttribute)
+
+
+class IEntryContentWithAttribute(Generic[_T], SerializableContent):
+    _attrType: Optional[Type] = None
+    _attrs: Optional[_T] = None
+
+    @property
+    def attrs(self) -> Optional[_T]:
+        return self._attrs
+
+    @attrs.setter
+    def attrs(self, value):
+        if not self._attrType:
+            raise Exception(
+                f"Field attrType must be defined for class '{type(self).__name__}'"
+            )
+        self._attrs = self.checkAndConvertNullable(value, self._attrType, "attrs")

LOGS/Entities/LabNotebookEntryContent/IEntryContentWithContent.py

@@ -0,0 +1,38 @@
+from typing import List, Optional, Tuple, Type, TypeVar, Union, cast
+
+from LOGS.Entities.LabNotebookEntryContent.EntryContentConverter import (
+    EntryContentConverter,
+)
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entity.SerializableContent import SerializableContent
+
+_T = TypeVar("_T", bound=EntryContentItem)
+
+
+class IEntryContentWithContent(SerializableContent):
+    _content: List[EntryContentItem] = cast(List[EntryContentItem], None)
+
+    def listContentItems(
+        self, types: Optional[Union[Type[_T], Tuple[Type[_T], ...]]] = None
+    ) -> List[_T]:
+        items = []
+        for item in self.content:
+            if not types or isinstance(item, types):
+                items.append(item)
+            if isinstance(item, IEntryContentWithContent):
+                items.extend(item.listContentItems(types))
+
+        return items
+
+    def append(self, item: _T) -> _T:
+        raise NotImplementedError()
+
+    @property
+    def content(self) -> List[EntryContentItem]:
+        if self._content is None:
+            self._content = []
+        return self._content
+
+    @content.setter
+    def content(self, value):
+        self._content = EntryContentConverter.convertList(value, fieldName="content")

LOGS/Entities/LabNotebookEntryContent/IEntryContentWithTextAttribute.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+from LOGS.Entities.LabNotebookEntryContent.TextAttribute import TextAttribute
+from LOGS.Entity.SerializableContent import SerializableContent
+
+
+class IEntryContentWithTextAttribute(SerializableContent):
+    _attrs: Optional[TextAttribute] = None
+
+    @property
+    def attrs(self) -> Optional[TextAttribute]:
+        return self._attrs
+
+    @attrs.setter
+    def attrs(self, value):
+        self._attrs = self.checkAndConvertNullable(value, TextAttribute, "attrs")

LOGS/Entities/LabNotebookEntryContent/TextAttribute.py

@@ -0,0 +1,46 @@
+from typing import Optional
+
+from LOGS.Entities.LabNotebookEntryContent.BasicAttribute import BasicAttribute
+
+
+class TextAttribute(BasicAttribute):
+    _style: Optional[str] = None
+    _nodeIndent: Optional[int] = None
+    _nodeLineHeight: Optional[int] = None
+    _nodeTextAlignment: Optional[str] = None
+
+    @property
+    def style(self) -> Optional[str]:
+        return self._style
+
+    @style.setter
+    def style(self, value):
+        self._style = self.checkAndConvertNullable(value, str, "style")
+
+    @property
+    def nodeIndent(self) -> Optional[int]:
+        return self._nodeIndent
+
+    @nodeIndent.setter
+    def nodeIndent(self, value):
+        self._nodeIndent = self.checkAndConvertNullable(value, int, "nodeIndent")
+
+    @property
+    def nodeLineHeight(self) -> Optional[int]:
+        return self._nodeLineHeight
+
+    @nodeLineHeight.setter
+    def nodeLineHeight(self, value):
+        self._nodeLineHeight = self.checkAndConvertNullable(
+            value, int, "nodeLineHeight"
+        )
+
+    @property
+    def nodeTextAlignment(self) -> Optional[str]:
+        return self._nodeTextAlignment
+
+    @nodeTextAlignment.setter
+    def nodeTextAlignment(self, value):
+        self._nodeTextAlignment = self.checkAndConvertNullable(
+            value, str, "nodeTextAlignment"
+        )

LOGS/Entities/LabNotebookEntryContent/TextMarkAtributes.py

@@ -0,0 +1,64 @@
+from typing import Optional, TypeVar
+
+from LOGS.Entities.LabNotebookEntryContent.BasicAttribute import BasicAttribute
+
+
+class TextMarkAttributeDefault(BasicAttribute):
+    pass
+
+
+_T = TypeVar("_T", bound=BasicAttribute)
+
+
+class TextMarkAttributeTextColor(BasicAttribute):
+    _color: Optional[str] = None
+
+    @property
+    def color(self) -> Optional[str]:
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        self._color = self.checkAndConvertNullable(value, str, "color")
+
+
+class TextMarkAttributeTextHighlight(BasicAttribute):
+    _highlight: Optional[str] = None
+
+    @property
+    def highlight(self) -> Optional[str]:
+        return self._highlight
+
+    @highlight.setter
+    def highlight(self, value):
+        self._highlight = self.checkAndConvertNullable(value, str, "highlight")
+
+
+class TextMarkAttributeLink(BasicAttribute):
+    _auto: Optional[bool] = None
+    _href: Optional[str] = None
+    _target: Optional[str] = None
+
+    @property
+    def auto(self) -> Optional[bool]:
+        return self._auto
+
+    @auto.setter
+    def auto(self, value):
+        self._auto = self.checkAndConvertNullable(value, bool, "auto")
+
+    @property
+    def href(self) -> Optional[str]:
+        return self._href
+
+    @href.setter
+    def href(self, value):
+        self._href = self.checkAndConvertNullable(value, str, "href")
+
+    @property
+    def target(self) -> Optional[str]:
+        return self._target
+
+    @target.setter
+    def target(self, value):
+        self._target = self.checkAndConvertNullable(value, str, "target")

LOGS/Entities/LabNotebookEntryContent/TextMarkConverter.py

@@ -0,0 +1,45 @@
+from LOGS.Entities.LabNotebookEntryContent.TextMarks import (
+    TextMarkBold,
+    TextMarkCode,
+    TextMarkContentPlaceholder,
+    TextMarkItalic,
+    TextMarkLink,
+    TextMarkStrike,
+    TextMarkSub,
+    TextMarkSup,
+    TextMarkTextColor,
+    TextMarkTextHighlight,
+    TextMarkUnderline,
+)
+
+
+class TextMarkConverter:
+    @staticmethod
+    def convert(mark: dict):
+        if "type" not in mark:
+            raise ValueError(f"TextMark must contain a 'type' field. (Got '{mark}')")
+        _type = mark["type"]
+        if _type == "bold":
+            return TextMarkBold(mark)
+        if _type == "italic":
+            return TextMarkItalic(mark)
+        elif _type == "underline":
+            return TextMarkUnderline(mark)
+        elif _type == "strike":
+            return TextMarkStrike(mark)
+        elif _type == "sup":
+            return TextMarkSup(mark)
+        elif _type == "sub":
+            return TextMarkSub(mark)
+        elif _type == "code":
+            return TextMarkCode(mark)
+        elif _type == "textColor":
+            return TextMarkTextColor(mark)
+        elif _type == "textHighlight":
+            return TextMarkTextHighlight(mark)
+        elif _type == "link":
+            return TextMarkLink(mark)
+        elif _type == "contentPlaceholder":
+            return TextMarkContentPlaceholder(mark)
+        else:
+            raise ValueError(f"TextMark type '{_type}' is not supported.")

LOGS/Entities/LabNotebookEntryContent/TextMarks.py

@@ -0,0 +1,71 @@
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithAttribute import (
+    IEntryContentWithAttribute,
+)
+from LOGS.Entities.LabNotebookEntryContent.TextMarkAtributes import (
+    TextMarkAttributeDefault,
+    TextMarkAttributeLink,
+    TextMarkAttributeTextColor,
+    TextMarkAttributeTextHighlight,
+)
+
+
+class TextMarkBold(EntryContentItem, IEntryContentWithAttribute):
+    _type = "bold"
+    _attrType = TextMarkAttributeDefault
+
+
+class TextMarkItalic(EntryContentItem, IEntryContentWithAttribute):
+    _type = "italic"
+    _attrType = TextMarkAttributeDefault
+
+
+class TextMarkUnderline(EntryContentItem, IEntryContentWithAttribute):
+    _type = "underline"
+    _attrType = TextMarkAttributeDefault
+
+
+class TextMarkStrike(EntryContentItem, IEntryContentWithAttribute):
+    _type = "strike"
+    _attrType = TextMarkAttributeDefault
+
+
+class TextMarkSup(EntryContentItem, IEntryContentWithAttribute):
+    _type = "sup"
+    _attrType = TextMarkAttributeDefault
+
+
+class TextMarkSub(EntryContentItem, IEntryContentWithAttribute):
+    _type = "sub"
+    _attrType = TextMarkAttributeDefault
+
+
+class TextMarkCode(EntryContentItem, IEntryContentWithAttribute):
+    _type = "code"
+    _attrType = TextMarkAttributeDefault
+
+
+class TextMarkTextColor(
+    EntryContentItem, IEntryContentWithAttribute[TextMarkAttributeTextColor]
+):
+    _type = "textColor"
+    _attrType = TextMarkAttributeTextColor
+
+
+class TextMarkTextHighlight(
+    EntryContentItem, IEntryContentWithAttribute[TextMarkAttributeTextHighlight]
+):
+    _type = "textHighlight"
+    _attrType = TextMarkAttributeTextHighlight
+
+
+class TextMarkLink(EntryContentItem, IEntryContentWithAttribute[TextMarkAttributeLink]):
+    _type = "link"
+    _attrType = TextMarkAttributeLink
+
+
+class TextMarkContentPlaceholder(
+    EntryContentItem, IEntryContentWithAttribute[TextMarkAttributeLink]
+):
+    _type = "contentPlaceholder"
+    _attrType = TextMarkAttributeLink

LOGS/Entities/LabNotebookEntryContent/__init__.py

@@ -0,0 +1,34 @@
+"""
+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 .EntityAttribute import *
+from .EntryContentBlockquote import *
+from .EntryContentBulletList import *
+from .EntryContentCallout import *
+from .EntryContentContentPlaceholderNode import *
+from .EntryContentConverter import *
+from .EntryContentDocument import *
+from .EntryContentEntity import *
+from .EntryContentEntityMention import *
+from .EntryContentHeading import *
+from .EntryContentHorizontalRule import *
+from .EntryContentItem import *
+from .EntryContentListItem import *
+from .EntryContentOrderedList import *
+from .EntryContentParagraph import *
+from .EntryContentTable import *
+from .EntryContentTableCell import *
+from .EntryContentTableRow import *
+from .EntryContentTaskList import *
+from .EntryContentTaskListItem import *
+from .EntryContentText import *
+from .TextAttribute import *
+from .TextMarkAtributes import *
+from .TextMarks import *

LOGS/Entities/LabNotebookEntryMinimal.py

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

LOGS/Entities/LabNotebookEntryRequestParameter.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass, field
+from datetime import date
+from typing import List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entity.EntityRequestParameter import EntityRequestParameter
+from LOGS.Entity.IGenericEntityOrderBy import (
+    IGenericEntitySortingOptions,
+    IModificationRecordSortingOptions,
+)
+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.ISignableEntity import ISignableEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntityRequest
+
+
+class LabNotebookEntrySortingOptions(
+    IGenericEntitySortingOptions, IModificationRecordSortingOptions
+):
+    NAME: Self = cast(Self, "NAME")
+    ENTRY_DATE: Self = cast(Self, "ENTRY_DATE")
+    VERSION: Self = cast(Self, "VERSION")
+    LAB_NOTEBOOK_ID: Self = cast(Self, "LAB_NOTEBOOK_ID")
+    LAB_NOTEBOOK_NAME: Self = cast(Self, "LAB_NOTEBOOK_NAME")
+    LAB_NOTEBOOK_EXPERIMENT_ID: Self = cast(Self, "LAB_NOTEBOOK_EXPERIMENT_ID")
+    LAB_NOTEBOOK_EXPERIMENT_NAME: Self = cast(Self, "LAB_NOTEBOOK_EXPERIMENT_NAME")
+
+
+@dataclass
+class LabNotebookEntryRequestParameter(
+    EntityRequestParameter[LabNotebookEntrySortingOptions],
+    IPermissionedEntityRequest,
+    IUniqueEntityRequest,
+    INamedEntityRequest,
+    IProjectBasedRequest,
+    ILockableEntityRequest,
+    ISignableEntityRequest,
+    IVersionedEntityRequest,
+):
+    _orderByType: Type[LabNotebookEntrySortingOptions] = field(
+        default=LabNotebookEntrySortingOptions, init=False
+    )
+
+    entryDateFrom: Optional[date] = None
+    entryDateTo: Optional[date] = None
+    labNotebookExperimentReferenceIds: Optional[List[int]] = None
+    datasetReferenceIds: Optional[List[int]] = None
+    attachmentReferenceIds: Optional[List[int]] = None
+    personReferenceIds: Optional[List[int]] = None
+    projectReferenceIds: Optional[List[int]] = None
+    sampleReferenceIds: Optional[List[int]] = None
+    inventoryItemReferenceIds: Optional[List[int]] = None
+    labNotebookReferenceIds: Optional[List[int]] = None
+    useFullTextSearch: Optional[bool] = None
+    includeContent: Optional[bool] = None

LOGS/Entities/LabNotebookExperiment.py

@@ -0,0 +1,58 @@
+from typing import TYPE_CHECKING, Optional
+
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.MinimalModelGenerator import MinimalModelGenerator
+from LOGS.Entities.LabNotebookModels import LabNotebookExperimentStatus
+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.ISignableEntity import ISignableEntity
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntity
+
+if TYPE_CHECKING:
+    from LOGS.Entities import LabNotebookMinimal
+
+
+@Endpoint("lab_notebook_experiments")
+class LabNotebookExperiment(
+    IEntityWithIntId,
+    IUniqueEntity,
+    INamedEntity,
+    IVersionedEntity,
+    IGenericPermissionEntity,
+    ILockableEntity,
+    ISignableEntity,
+):
+    _labNotebook: Optional["LabNotebookMinimal"] = None
+    _status: Optional[LabNotebookExperimentStatus] = None
+    _description: Optional[str] = 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 status(self) -> Optional[LabNotebookExperimentStatus]:
+        return self._status
+
+    @status.setter
+    def status(self, value: str):
+        self._status = self.checkAndConvertNullable(
+            value, LabNotebookExperimentStatus, "status"
+        )
+
+    @property
+    def labNotebook(self) -> Optional["LabNotebookMinimal"]:
+        return self._labNotebook
+
+    @labNotebook.setter
+    def labNotebook(self, value: str):
+        self._labNotebook = MinimalModelGenerator.MinimalFromSingle(
+            value, "LabNotebookMinimal", "labNotebook", self._getConnection()
+        )

LOGS/Entities/LabNotebookExperimentMinimal.py

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

LOGS/Entities/LabNotebookExperimentRequestParameter.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Type, cast
+
+from typing_extensions import Self
+
+from LOGS.Entities.LabNotebookModels import LabNotebookExperimentStatus
+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.ISignableEntity import ISignableEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntityRequest
+
+
+class LabNotebookExperimentSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IModificationRecordSortingOptions,
+):
+    STATUS: Self = cast(Self, "STATUS")
+    VERSION: Self = cast(Self, "VERSION")
+    LAB_NOTEBOOK_ID: Self = cast(Self, "LAB_NOTEBOOK_ID")
+    LAB_NOTEBOOK_NAME: Self = cast(Self, "LAB_NOTEBOOK_NAME")
+    LAB_NOTEBOOK_EXPERIMENT_ID: Self = cast(Self, "LAB_NOTEBOOK_EXPERIMENT_ID")
+    LAB_NOTEBOOK_EXPERIMENT_NAME: Self = cast(Self, "LAB_NOTEBOOK_EXPERIMENT_NAME")
+
+
+@dataclass
+class LabNotebookExperimentRequestParameter(
+    EntityRequestParameter[LabNotebookExperimentSortingOptions],
+    IPermissionedEntityRequest,
+    IUniqueEntityRequest,
+    INamedEntityRequest,
+    IProjectBasedRequest,
+    ILockableEntityRequest,
+    ISignableEntityRequest,
+    IVersionedEntityRequest[int],
+):
+    _orderByType: Type[LabNotebookExperimentSortingOptions] = field(
+        default=LabNotebookExperimentSortingOptions, init=False
+    )
+
+    status: Optional[List[LabNotebookExperimentStatus]] = None
+    labNotebookIds: Optional[List[int]] = None
+    labNotebookProjectIds: Optional[List[int]] = None

LOGS/Entities/LabNotebookExperiments.py

@@ -0,0 +1,16 @@
+from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Entities.LabNotebookExperiment import LabNotebookExperiment
+from LOGS.Entities.LabNotebookExperimentRequestParameter import (
+    LabNotebookExperimentRequestParameter,
+)
+from LOGS.Entity.EntityIterator import EntityIterator
+
+
+@Endpoint("lab_notebook_experiments")
+class LabNotebookExperiments(
+    EntityIterator[LabNotebookExperiment, LabNotebookExperimentRequestParameter]
+):
+    """LOGS connected LabNotebookExperiment iterator"""
+
+    _generatorType = LabNotebookExperiment
+    _parameterType = LabNotebookExperimentRequestParameter

LOGS/Entities/LabNotebookMinimal.py

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

LOGS/Entities/LabNotebookModels.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class LabNotebookStatus(Enum):
+    CLOSED = "CLOSED"
+    ACTIVE = "ACTIVE"
+
+
+class LabNotebookExperimentStatus(Enum):
+    RUNNING = "RUNNING"
+    PAUSED = "PAUSED"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    ABORTED = "ABORTED"

LOGS/Entities/LabNotebookRequestParameter.py

@@ -0,0 +1,42 @@
+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 (
+    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.ISignableEntity import ISignableEntityRequest
+from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
+from LOGS.Interfaces.IVersionedEntity import IVersionedEntityRequest
+
+
+class LabNotebookSortingOptions(
+    IGenericEntitySortingOptions,
+    INamedEntitySortingOptions,
+    IModificationRecordSortingOptions,
+):
+    VERSION: Self = cast(Self, "VERSION")
+
+
+@dataclass
+class LabNotebookRequestParameter(
+    EntityRequestParameter[LabNotebookSortingOptions],
+    IPermissionedEntityRequest,
+    IUniqueEntityRequest,
+    INamedEntityRequest,
+    IProjectBasedRequest,
+    IVersionedEntityRequest[int],
+    ILockableEntityRequest,
+    ISignableEntityRequest,
+):
+    _orderByType: Type[LabNotebookSortingOptions] = field(
+        default=LabNotebookSortingOptions, init=False
+    )