logs-py 2.9.5__py3-none-any.whl → 3.0.0__py3-none-any.whl

LOGS/Entities/LabNotebookEntry.py

@@ -2,16 +2,22 @@ from datetime import datetime
 from typing import Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
+from LOGS.Auxiliary.Exceptions import EntityFetchingException, EntityIncompleteException
+from LOGS.Entities.LabNotebookEntryContent.EntryContentConverter import (
+    EntryContentConverter,
+)
+from LOGS.Entities.LabNotebookEntryContent.EntryContentDocument import (
+    EntryContentDocument,
+)
 from LOGS.Entities.LabNotebookEntryRelations import LabNotebookEntryRelations
 from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
 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.Interfaces.ISoftDeletable import ISoftDeletable
-from LOGS.LOGSConnection import LOGSConnection
 
 
 @Endpoint("lab_notebook_entries")
@@ -22,35 +28,33 @@ class LabNotebookEntry(
     ICreationRecord,
     IModificationRecord,
     ISoftDeletable,
-    IPermissionedEntity,
+    GenericPermissionEntity,
 ):
-    _relationType = type(LabNotebookEntryRelations)
-
-    _version: Optional[int]
-    _labNotebook: Optional[EntityMinimalWithIntId]
-    _labNotebookExperiment: Optional[EntityMinimalWithIntId]
-    _entryDate: Optional[datetime]
-
-    def __init__(
-        self,
-        ref=None,
-        id: Optional[int] = None,
-        connection: Optional[LOGSConnection] = None,
-    ):
-        """Represents a connected LOGS entity type"""
-        self._version = None
-        self._labNotebook = None
-        self._labNotebookExperiment = None
-        self._entryDate = None
-
-        super().__init__(ref=ref, id=id, connection=connection)
-
-    def fromDict(self, ref, formatDict=None) -> None:
+    _relationType = LabNotebookEntryRelations
+    _noContent: bool = True
+
+    _version: Optional[int] = None
+    _labNotebook: Optional[EntityMinimalWithIntId] = None
+    _labNotebookExperiment: Optional[EntityMinimalWithIntId] = None
+    _entryDate: Optional[datetime] = None
+    _content: Optional[EntryContentDocument] = None
+
+    def fromDict(self, ref) -> None:
         if isinstance(ref, dict):
-            if "name" in ref:
+            if "name" in ref and ref["name"]:
                 ref["name"] = ref["name"].replace(" > ", "_")
 
-        super().fromDict(ref, formatDict)
+        super().fromDict(ref)
+
+    def fetchContent(self):
+        connection, endpoint, id = self._getConnectionData()
+
+        content, responseError = connection.getEndpoint(endpoint + [id, "content"])
+        if responseError:
+            raise EntityFetchingException(entity=self, responseError=responseError)
+
+        self.content = content
+        self._noContent = False
 
     @property
     def version(self) -> Optional[int]:
@@ -87,3 +91,22 @@ class LabNotebookEntry(
     @entryDate.setter
     def entryDate(self, value):
         self._entryDate = self.checkAndConvertNullable(value, datetime, "entryDate")
+
+    @property
+    def content(self) -> Optional[EntryContentDocument]:
+        if self._noContent:
+            raise EntityIncompleteException(
+                self,
+                parameterName="content",
+                functionName=f"{self.fetchContent.__name__}()",
+                hasFetchFull=False,
+            )
+        return self._content
+
+    @content.setter
+    def content(self, value):
+        if value:
+            self._noContent = False
+        self._content = EntryContentConverter[EntryContentDocument].convert(
+            value, fieldName="content"
+        )

LOGS/Entities/LabNotebookEntryContent/BasicAttribute.py

@@ -0,0 +1,15 @@
+from typing import Optional
+
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+
+class BasicAttribute(SerializeableContent):
+    _id: Optional[str] = None
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = self.checkAndConvertNullable(value, str, "id")

LOGS/Entities/LabNotebookEntryContent/EntityAttribute.py

@@ -0,0 +1,85 @@
+from typing import Optional
+
+from LOGS.Entities.LabNotebookEntryContent.BasicAttribute import BasicAttribute
+from LOGS.Entity.SerializeableContent import SerializeableClass
+
+
+class EntityAttributeSettings(SerializeableClass):
+    showHeader: Optional[bool] = None
+    collapsible: Optional[bool] = None
+    defaultCollapsed: Optional[bool] = None
+
+
+class EntityAttributeAdditionalSettings(SerializeableClass):
+    height: Optional[int] = None
+    showViewer: Optional[bool] = None
+
+
+class EntityAttribute(BasicAttribute):
+    _version: Optional[int] = None
+    _entityId: Optional[int] = None
+    _settings: Optional[EntityAttributeSettings] = None
+    _additionalSettings: Optional[EntityAttributeAdditionalSettings] = None
+    _entityUuid: Optional[str] = None
+    _entityTypeId: Optional[str] = None
+    _style: 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 entityTypeId(self) -> Optional[str]:
+        return self._entityTypeId
+
+    @entityTypeId.setter
+    def entityTypeId(self, value):
+        self._entityTypeId = self.checkAndConvertNullable(value, str, "entityTypeId")
+
+    @property
+    def entityUuid(self) -> Optional[str]:
+        return self._entityUuid
+
+    @entityUuid.setter
+    def entityUuid(self, value):
+        self._entityUuid = self.checkAndConvertNullable(value, str, "entityUuid")
+
+    @property
+    def version(self) -> Optional[int]:
+        return self._version
+
+    @version.setter
+    def version(self, value):
+        self._version = self.checkAndConvertNullable(value, int, "version")
+
+    @property
+    def entityId(self) -> Optional[int]:
+        return self._entityId
+
+    @entityId.setter
+    def entityId(self, value):
+        self._entityId = self.checkAndConvertNullable(value, int, "entityId")
+
+    @property
+    def settings(self) -> Optional[EntityAttributeSettings]:
+        return self._settings
+
+    @settings.setter
+    def settings(self, value):
+        self._settings = self.checkAndConvertNullable(
+            value, EntityAttributeSettings, "settings"
+        )
+
+    @property
+    def additionalSettings(self) -> Optional[EntityAttributeAdditionalSettings]:
+        return self._additionalSettings
+
+    @additionalSettings.setter
+    def additionalSettings(self, value):
+        self._additionalSettings = self.checkAndConvertNullable(
+            value, EntityAttributeAdditionalSettings, "additionalSettings"
+        )

LOGS/Entities/LabNotebookEntryContent/EntryContentBlockquote.py

@@ -0,0 +1,13 @@
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithContent import (
+    IEntryContentWithContent,
+)
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithTextAttribute import (
+    IEntryContentWithTextAttribute,
+)
+
+
+class EntryContentBlockquote(
+    EntryContentItem, IEntryContentWithContent, IEntryContentWithTextAttribute
+):
+    _type = "blockquote"

LOGS/Entities/LabNotebookEntryContent/EntryContentBulletList.py

@@ -0,0 +1,17 @@
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithAttribute import (
+    IEntryContentWithAttribute,
+)
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithContent import (
+    IEntryContentWithContent,
+)
+from LOGS.Entities.LabNotebookEntryContent.TextMarkAtributes import BasicAttribute
+
+
+class EntryContentBulletList(
+    EntryContentItem,
+    IEntryContentWithContent,
+    IEntryContentWithAttribute[BasicAttribute],
+):
+    _attrType = BasicAttribute
+    _type = "bulletList"

LOGS/Entities/LabNotebookEntryContent/EntryContentCallout.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+from LOGS.Entities.LabNotebookEntryContent.BasicAttribute import BasicAttribute
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithAttribute import (
+    IEntryContentWithAttribute,
+)
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithContent import (
+    IEntryContentWithContent,
+)
+
+
+class CalloutAttribute(BasicAttribute):
+    _type: Optional[str] = None
+    _emoji: Optional[str] = None
+
+    @property
+    def type(self) -> Optional[str]:
+        return self._type
+
+    @type.setter
+    def type(self, value):
+        self._type = self.checkAndConvertNullable(value, str, "type")
+
+    @property
+    def emoji(self) -> Optional[str]:
+        return self._emoji
+
+    @emoji.setter
+    def emoji(self, value):
+        self._emoji = self.checkAndConvertNullable(value, str, "emoji")
+
+
+class EntryContentCallout(
+    EntryContentItem,
+    IEntryContentWithContent,
+    IEntryContentWithAttribute[CalloutAttribute],
+):
+    _attrType = CalloutAttribute
+    _type = "callout"

LOGS/Entities/LabNotebookEntryContent/EntryContentContentPlaceholderNode.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithAttribute import (
+    IEntryContentWithAttribute,
+)
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithContent import (
+    IEntryContentWithContent,
+)
+from LOGS.Entities.LabNotebookEntryContent.TextAttribute import TextAttribute
+
+
+class PlaceholderNodeAttribute(TextAttribute):
+    _label: Optional[str] = None
+
+    @property
+    def label(self) -> Optional[str]:
+        return self._label
+
+    @label.setter
+    def label(self, value):
+        self._label = self.checkAndConvertNullable(value, str, "label")
+
+
+class EntryContentContentPlaceholderNode(
+    EntryContentItem,
+    IEntryContentWithContent,
+    IEntryContentWithAttribute[PlaceholderNodeAttribute],
+):
+    _attrType = PlaceholderNodeAttribute
+    _type = "contentPlaceholderNode"

LOGS/Entities/LabNotebookEntryContent/EntryContentConverter.py

@@ -0,0 +1,207 @@
+from typing import Generic, Optional, TypeVar, cast
+
+from LOGS.Auxiliary.Tools import Tools
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+
+_T = TypeVar("_T", bound=EntryContentItem)
+
+
+class EntryContentConverter(Generic[_T]):
+
+    @classmethod
+    def _convertEntryContentDocument(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentDocument import (
+            EntryContentDocument,
+        )
+
+        return EntryContentDocument(item)
+
+    @classmethod
+    def _convertEntryContentHeading(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentHeading import (
+            EntryContentHeading,
+        )
+
+        return EntryContentHeading(item)
+
+    @classmethod
+    def _convertEntryContentText(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentText import (
+            EntryContentText,
+        )
+
+        return EntryContentText(item)
+
+    @classmethod
+    def _convertEntryContentParagraph(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentParagraph import (
+            EntryContentParagraph,
+        )
+
+        return EntryContentParagraph(item)
+
+    @classmethod
+    def _convertEntryContentBlockquote(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentBlockquote import (
+            EntryContentBlockquote,
+        )
+
+        return EntryContentBlockquote(item)
+
+    @classmethod
+    def _convertEntryContentBulletList(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentBulletList import (
+            EntryContentBulletList,
+        )
+
+        return EntryContentBulletList(item)
+
+    @classmethod
+    def _convertEntryContentOrderedList(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentOrderedList import (
+            EntryContentOrderedList,
+        )
+
+        return EntryContentOrderedList(item)
+
+    @classmethod
+    def _convertEntryContentCallout(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentCallout import (
+            EntryContentCallout,
+        )
+
+        return EntryContentCallout(item)
+
+    @classmethod
+    def _convertEntryContentContentPlaceholderNode(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentContentPlaceholderNode import (
+            EntryContentContentPlaceholderNode,
+        )
+
+        return EntryContentContentPlaceholderNode(item)
+
+    @classmethod
+    def _convertEntryContentEntity(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentEntity import (
+            EntryContentEntity,
+        )
+
+        return EntryContentEntity(item)
+
+    @classmethod
+    def _convertEntryContentEntityMention(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentEntityMention import (
+            EntryContentEntityMention,
+        )
+
+        return EntryContentEntityMention(item)
+
+    @classmethod
+    def _convertEntryContentHorizontalRule(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentHorizontalRule import (
+            EntryContentHorizontalRule,
+        )
+
+        return EntryContentHorizontalRule(item)
+
+    @classmethod
+    def _convertEntryContentListItem(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentListItem import (
+            EntryContentListItem,
+        )
+
+        return EntryContentListItem(item)
+
+    @classmethod
+    def _convertEntryContentTaskList(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentTaskList import (
+            EntryContentTaskList,
+        )
+
+        return EntryContentTaskList(item)
+
+    @classmethod
+    def _convertEntryContentTaskListItem(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentTaskListItem import (
+            EntryContentTaskListItem,
+        )
+
+        return EntryContentTaskListItem(item)
+
+    @classmethod
+    def _convertEntryContentTable(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentTable import (
+            EntryContentTable,
+        )
+
+        return EntryContentTable(item)
+
+    @classmethod
+    def _convertEntryContentTableCell(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentTableCell import (
+            EntryContentTableCell,
+        )
+
+        return EntryContentTableCell(item)
+
+    @classmethod
+    def _convertEntryContentTableRow(cls, item: dict):
+        from LOGS.Entities.LabNotebookEntryContent.EntryContentTableRow import (
+            EntryContentTableRow,
+        )
+
+        return EntryContentTableRow(item)
+
+    @classmethod
+    def convert(cls, item: dict, fieldName: Optional[str] = None) -> _T:
+        field = f"in field {fieldName}" if fieldName else ""
+
+        if isinstance(item, EntryContentItem):
+            return cast(_T, item)
+
+        if not isinstance(item, dict):
+            raise ValueError(
+                f"EntryContentItem {field} must be of type 'dict'. (Got type '{type(item).__name__}')"
+            )
+
+        if "type" not in item:
+            raise ValueError(
+                f"EntryContentItem {field} must contain a 'type' field. (Got '{Tools.truncString(str(item))}')"
+            )
+
+        _typeMapper = {
+            "blockquote": cls._convertEntryContentBlockquote,
+            "bulletList": cls._convertEntryContentBulletList,
+            "callout": cls._convertEntryContentCallout,
+            "contentPlaceholderNode": cls._convertEntryContentContentPlaceholderNode,
+            "doc": cls._convertEntryContentDocument,
+            "entity": cls._convertEntryContentEntity,
+            "entityMention": cls._convertEntryContentEntityMention,
+            "heading": cls._convertEntryContentHeading,
+            "horizontalRule": cls._convertEntryContentHorizontalRule,
+            "listItem": cls._convertEntryContentListItem,
+            "orderedList": cls._convertEntryContentOrderedList,
+            "paragraph": cls._convertEntryContentParagraph,
+            "table": cls._convertEntryContentTable,
+            "tableCell": cls._convertEntryContentTableCell,
+            "tableRow": cls._convertEntryContentTableRow,
+            "taskList": cls._convertEntryContentTaskList,
+            "taskListItem": cls._convertEntryContentTaskListItem,
+            "text": cls._convertEntryContentText,
+        }
+
+        mapper = _typeMapper.get(item["type"], None)
+        if mapper:
+            return cast(_T, mapper(item))
+
+        return cast(_T, EntryContentItem(item))
+
+    @classmethod
+    def convertList(cls, items, fieldName: Optional[str] = None) -> list[_T]:
+        if not isinstance(items, list):
+            items = [items]
+
+        return [
+            cls.convert(item, fieldName=f"{fieldName}[{i}]" if fieldName else None)
+            for i, item in enumerate(items)
+        ]

LOGS/Entities/LabNotebookEntryContent/EntryContentDocument.py

@@ -0,0 +1,8 @@
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithContent import (
+    IEntryContentWithContent,
+)
+
+
+class EntryContentDocument(EntryContentItem, IEntryContentWithContent):
+    _type = "doc"

LOGS/Entities/LabNotebookEntryContent/EntryContentEntity.py

@@ -0,0 +1,13 @@
+from LOGS.Entities.LabNotebookEntryContent.EntityAttribute import EntityAttribute
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithAttribute import (
+    IEntryContentWithAttribute,
+)
+
+
+class EntryContentEntity(
+    EntryContentItem,
+    IEntryContentWithAttribute[EntityAttribute],
+):
+    _attrType = EntityAttribute
+    _type = "entity"

LOGS/Entities/LabNotebookEntryContent/EntryContentEntityMention.py

@@ -0,0 +1,31 @@
+from typing import List, Optional
+
+from LOGS.Entities.LabNotebookEntryContent.EntityAttribute import EntityAttribute
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithAttribute import (
+    IEntryContentWithAttribute,
+)
+from LOGS.Entities.LabNotebookEntryContent.TextMarkConverter import TextMarkConverter
+
+
+class EntryContentEntityMention(
+    EntryContentItem,
+    IEntryContentWithAttribute[EntityAttribute],
+):
+    _attrType = EntityAttribute
+    _type = "entityMention"
+
+    _marks: Optional[List[IEntryContentWithAttribute]] = None
+
+    @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/EntryContentHeading.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithContent import (
+    IEntryContentWithContent,
+)
+from LOGS.Entities.LabNotebookEntryContent.TextAttribute import TextAttribute
+
+
+class HeadingAttribute(TextAttribute):
+    _level: Optional[int] = None
+
+    @property
+    def level(self) -> Optional[int]:
+        return self._level
+
+    @level.setter
+    def level(self, value):
+        self._level = self.checkAndConvertNullable(value, int, "level")
+
+
+class EntryContentHeading(EntryContentItem, IEntryContentWithContent):
+    _type = "heading"
+
+    _attrs: Optional[HeadingAttribute] = None
+
+    @property
+    def attrs(self) -> Optional[HeadingAttribute]:
+        return self._attrs
+
+    @attrs.setter
+    def attrs(self, value):
+        self._attrs = self.checkAndConvertNullable(value, HeadingAttribute, "attrs")

LOGS/Entities/LabNotebookEntryContent/EntryContentHorizontalRule.py

@@ -0,0 +1,12 @@
+from LOGS.Entities.LabNotebookEntryContent.BasicAttribute import BasicAttribute
+from LOGS.Entities.LabNotebookEntryContent.EntryContentItem import EntryContentItem
+from LOGS.Entities.LabNotebookEntryContent.IEntryContentWithAttribute import (
+    IEntryContentWithAttribute,
+)
+
+
+class EntryContentHorizontalRule(
+    EntryContentItem, IEntryContentWithAttribute[BasicAttribute]
+):
+    _attrType = BasicAttribute
+    _type = "horizontalRule"

LOGS/Entities/LabNotebookEntryContent/EntryContentItem.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+from LOGS.Entity.SerializeableContent import SerializeableContent
+
+
+class EntryContentItem(SerializeableContent):
+    __type: str = "Unknown"
+    _type: Optional[str] = None
+
+    def fromDict(self, ref) -> None:
+        if isinstance(ref, dict):
+            if "type" not in ref or not ref["type"]:
+                raise ValueError(
+                    f"EntryContentItem must contain a 'type' field. (Got '{self.truncString(str(ref))}')"
+                )
+
+        super().fromDict(ref)
+
+    @property
+    def type(self) -> str:
+        if type(self) == EntryContentItem:
+            return self.__type
+
+        if self._type:
+            return self._type
+        else:
+            raise ValueError(f"Field 'type' in class {type(self).__name__} is not set.")
+
+    @type.setter
+    def type(self, value):
+        if type(self) != EntryContentItem:
+            if self._type != value:
+                raise ValueError(
+                    f"Field 'type' in class {type(self).__name__} is not mutable. (Got '{self.truncString(str(value))}' expected '{self._type}')"
+                )
+            return
+        self.__type = self.checkAndConvertNullable(value, str, "type")