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

LOGS/Entities/Dataset.py

@@ -2,6 +2,8 @@ import os
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union, cast
 
+from numpy import deprecate
+
 from LOGS.Auxiliary.Constants import Constants
 from LOGS.Auxiliary.Decorators import Endpoint, UiEndpoint
 from LOGS.Auxiliary.Exceptions import (
@@ -10,7 +12,7 @@ from LOGS.Auxiliary.Exceptions import (
     LOGSException,
 )
 from LOGS.Auxiliary.MinimalModelGenerator import (
-    AutoloadSourceMinimalFromDict,
+    BridgeMinimalFromDict,
     DatasetTypeMinimalFromDict,
     ExperimentMinimalFromDict,
     FormatMinimalFromDict,
@@ -30,15 +32,19 @@ from LOGS.Entities.FileEntry import FileEntry
 from LOGS.Entities.HierarchyNode import HierarchyNode
 from LOGS.Entities.ParserLog import ParserLog
 from LOGS.Entities.Track import Track
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
 from LOGS.Entity.SerializeableContent import SerializeableContent
 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, ResponseTypes
 
 if TYPE_CHECKING:
-    from LOGS.Entities.AutoloadSourceMinimal import AutoloadSourceMinimal
+    from LOGS.Entities.BridgeMinimal import BridgeMinimal
     from LOGS.Entities.EquipmentMinimal import EquipmentMinimal
     from LOGS.Entities.ExperimentMinimal import ExperimentMinimal
     from LOGS.Entities.FormatMinimal import FormatMinimal
@@ -60,33 +66,39 @@ class ParsedMetadata(SerializeableContent):
 @UiEndpoint("#data")
 class Dataset(
     INamedEntity,
-    IUniqueEntity,
+    IProjectBased,
     IOwnedEntity,
-    EntityWithIntId,
+    IEntityWithIntId,
+    IRelatedEntity[DatasetRelations],
+    ITypedEntity,
+    ISoftDeletable,
+    IUniqueEntity,
 ):
     _noInfo = True
     _noParameters = True
+    _relationType = type(DatasetRelations)
 
-    _datasetType: Optional[DatasetTypeMinimal]
+    _legacyId: Optional[str]
+    _type: Optional[DatasetTypeMinimal]
     _format: Optional["FormatMinimal"]
     _acquisitionDate: Optional[datetime]
     _path: Optional[str]
+    _sourceBaseDirectory: Optional[str]
+    _sourceRelativeDirectory: Optional[str]
     _method: Optional["MethodMinimal"]
     _experiment: Optional["ExperimentMinimal"]
     _claimed: Optional[bool]
     _notes: Optional[str]
     _dateAdded: Optional[datetime]
-    _isDeleted: Optional[bool]
+    _isViewableEntity: Optional[bool]
     _other: Optional[str]
     _instrument: Optional["InstrumentMinimal"]
     _sample: Optional["SampleMinimal"]
-    _autoloadSource: Optional["AutoloadSourceMinimal"]
+    _bridge: Optional["BridgeMinimal"]
     _operators: Optional[List["PersonMinimal"]]
     _equipments: Optional[List["EquipmentMinimal"]]
     _projects: Optional[List["ProjectMinimal"]]
-    _customFields: Optional[Dict[str, Any]]
     _parsingState: Optional[ParsingStates]
-    _relations: Optional[DatasetRelations]
     _parsedMetadata: Optional[ParsedMetadata]
     _parameters: Optional[Dict[str, Any]]
     _formatVersion: Optional[int]
@@ -95,7 +107,6 @@ class Dataset(
     _datatracks: Optional[List[Datatrack]]
     _tracksHierarchy: Optional[HierarchyNode]
     _files: Optional[List[FileEntry]]
-    _formatId: Optional[str]
     _parameterHelper: Optional[ParameterHelper]
 
     def __init__(
@@ -106,7 +117,8 @@ class Dataset(
         files: Optional[Sequence[Constants.FILE_TYPE]] = None,
         format: Optional[Union[str, "FormatMinimal"]] = None,
     ):
-        self._datasetType = None
+        self._legacyId = None
+        self._type = None
         self._format = None
         self._acquisitionDate = None
         self._path = None
@@ -115,17 +127,16 @@ class Dataset(
         self._claimed = None
         self._notes = None
         self._dateAdded = None
+        self._isViewableEntity = None
         self._isDeleted = None
         self._other = None
         self._instrument = None
         self._sample = None
-        self._autoloadSource = None
+        self._bridge = None
         self._operators = None
         self._equipments = None
         self._projects = None
-        self._customFields = None
         self._parsingState = None
-        self._relations = None
         self._parsedMetadata = None
         self._parameters = None
         self._formatVersion = None
@@ -197,22 +208,6 @@ class Dataset(
 
         super().fromDict(ref=ref, formatDict=formatDict)
 
-    # def _getConnectionData(self):
-    #     if not self._endpoint:
-    #         raise NotImplementedError(
-    #             "Endpoint missing for of entity type %a."
-    #             % (
-    #                 type(self).__name__
-    #                 if type(self).__name__ != Entity.__name__
-    #                 else "unknown"
-    #             )
-    #         )
-
-    #     if not self.id:
-    #         raise EntityNotFoundException(self)
-
-    #     return self._getConnection(), self._endpoint, self.id
-
     def fetchParameters(self):
         connection, endpoint, id = self._getConnectionData()
 
@@ -310,12 +305,12 @@ class Dataset(
         return self._parameterHelper.get(key, removeUnit)
 
     @property
-    def datasetType(self) -> Optional[DatasetTypeMinimal]:
-        return self._datasetType
+    def type(self) -> Optional[DatasetTypeMinimal]:
+        return self._type
 
-    @datasetType.setter
-    def datasetType(self, value):
-        self._datasetType = DatasetTypeMinimalFromDict(
+    @type.setter
+    def type(self, value):
+        self._type = DatasetTypeMinimalFromDict(
             value, "datasetType", connection=self.connection
         )
 
@@ -387,14 +382,6 @@ class Dataset(
     def other(self, value):
         self._other = self.checkAndConvertNullable(value, str, "other")
 
-    @property
-    def customFields(self) -> Optional[Dict[str, Any]]:
-        return self._customFields
-
-    @customFields.setter
-    def customFields(self, value):
-        self._customFields = self.checkAndConvertNullable(value, dict, "customFields")
-
     @property
     def parsingState(self) -> Optional[ParsingStates]:
         return self._parsingState
@@ -405,15 +392,6 @@ class Dataset(
             ParsingStates, self.checkAndConvertNullable(value, str, "parsingState")
         )
 
-    @property
-    def relations(self) -> Optional[DatasetRelations]:
-        return self._relations
-
-    @relations.setter
-    def relations(self, value):
-        if value:
-            self._relations = self.checkAndConvert(value, DatasetRelations, "relations")
-
     @property
     def parsedMetadata(self) -> Optional[ParsedMetadata]:
         return self._parsedMetadata
@@ -461,23 +439,23 @@ class Dataset(
         return self._tracksHierarchy
 
     @property
-    def autoloadSource(self) -> Optional["AutoloadSourceMinimal"]:
-        return self._autoloadSource
+    def bridge(self) -> Optional["BridgeMinimal"]:
+        return self._bridge
 
-    @autoloadSource.setter
-    def autoloadSource(self, value):
-        self._autoloadSource = AutoloadSourceMinimalFromDict(
-            value, "autoloadSource", connection=self.connection
+    @bridge.setter
+    def bridge(self, value):
+        self._bridge = BridgeMinimalFromDict(
+            value, "bridge", connection=self.connection
         )
 
     @property
-    def autoloadSourceId(self) -> Optional[int]:
-        return self._autoloadSource.id if self._autoloadSource else None
+    def bridgeId(self) -> Optional[int]:
+        return self._bridge.id if self._bridge else None
 
-    @autoloadSourceId.setter
-    def autoloadSourceId(self, value):
-        self._autoloadSource = AutoloadSourceMinimalFromDict(
-            value, "autoloadSource", connection=self.connection
+    @bridgeId.setter
+    def bridgeId(self, value):
+        self._bridge = BridgeMinimalFromDict(
+            value, "bridge", connection=self.connection
         )
 
     @property
@@ -516,12 +494,6 @@ class Dataset(
     def methodId(self) -> Optional[int]:
         return self._method.id if self._method else None
 
-    @methodId.setter
-    def methodId(self, value):
-        self._method = MethodMinimalFromDict(
-            value, "method", connection=self.connection
-        )
-
     @property
     def experiment(self) -> Optional["ExperimentMinimal"]:
         return self._experiment
@@ -615,3 +587,43 @@ class Dataset(
         self._instrument = InstrumentMinimalFromDict(
             value, "instrument", connection=self.connection
         )
+
+    @property
+    def legacyId(self) -> Optional[str]:
+        return self._legacyId
+
+    @legacyId.setter
+    def legacyId(self, value):
+        self._legacyId = self.checkAndConvertNullable(value, str, "legacyId")
+
+    @property
+    def sourceBaseDirectory(self) -> Optional[str]:
+        return self._sourceBaseDirectory
+
+    @sourceBaseDirectory.setter
+    def sourceBaseDirectory(self, value):
+        self._sourceBaseDirectory = self.checkAndConvertNullable(
+            value, str, "sourceBaseDirectory"
+        )
+
+    @property
+    def sourceRelativeDirectory(self) -> Optional[str]:
+        return self._sourceRelativeDirectory
+
+    @sourceRelativeDirectory.setter
+    def sourceRelativeDirectory(self, value):
+        self._sourceRelativeDirectory = self.checkAndConvertNullable(
+            value, str, "sourceRelativeDirectory"
+        )
+
+    @property
+    @deprecate(new_name="attachment")
+    def isViewableEntity(self) -> Optional[bool]:
+        return self._isViewableEntity
+
+    @isViewableEntity.setter
+    @deprecate(new_name="attachment")
+    def isViewableEntity(self, value):
+        self._isViewableEntity = self.checkAndConvertNullable(
+            value, bool, "isViewableEntity"
+        )

LOGS/Entities/DatasetCreator.py

@@ -1,6 +1,8 @@
 from enum import Enum
 from typing import TYPE_CHECKING, Any, List, Optional
 
+from numpy import deprecate
+
 from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Auxiliary.Exceptions import EntityCreatingException, LOGSException
 from LOGS.Auxiliary.Tools import Tools
@@ -25,50 +27,68 @@ class DatasetUploadRequest(SerializeableClass):
     _typeMapper = {"files": FileEntry}
 
     def __init__(self, ref: Any = None):
-        self.parserId: str = ""
-        self.files: List[FileEntry] = []
-        self.autoloadBaseDir: str = ""
-        self.relativeDir: str = ""
-        self.sourceType: DatasetSourceType = DatasetSourceType.APIUpload
-        self.datasetType: Optional[str] = None
         self.name: Optional[str] = None
-        self.ownerId: Optional[int] = None
+        self.formatId: str = ""
         self.methodId: Optional[int] = None
         self.instrumentId: Optional[int] = None
         self.experimentId: Optional[int] = None
         self.sampleId: Optional[int] = None
+        self.ownerId: Optional[int] = None
         self.projectIds: Optional[List[int]] = None
         self.organizationIds: Optional[List[int]] = None
         self.operatorIds: Optional[List[int]] = None
         self.equipmentIds: Optional[List[int]] = None
-        self.autoloadConfigurationId: Optional[int] = None
+        self.autoloadBaseDir: str = ""
+        self.relativeDir: str = ""
+        self.dataSourceId: Optional[str] = None
         self.isViewableEntity: Optional[bool] = None
+        self.files: List[FileEntry] = []
+
         if isinstance(ref, Dataset) and ref.format:
             self.name = ref.name
-            if ref.format.id:
-                self.parserId = ref.format.id
+
+            if ref.name:
+                self.name = ref.name
+            if ref.format:
+                self.formatId = ref.format.id
             if ref.owner:
                 self.ownerId = ref.owner.id
             if ref._files:
                 self.files = ref._files
             if ref.method:
-                self.methodId = ref.methodId
+                self.methodId = ref.method.id
             if ref.instrument:
-                self.instrumentId = ref.instrumentId
+                self.instrumentId = ref.instrument.id
             if ref.experiment:
-                self.experiment = ref.experiment
-            if ref.sample:
-                self.sampleId = ref.sample.id
+                self.experimentId = ref.experiment.id
+            if ref.sampleId:
+                self.sampleId = ref.sampleId
+            if ref.owner:
+                self.ownerId = ref.owner.id
             if ref.projects:
-                self.projectIds = ref.projectIds
+                self.projectIds = [p.id for p in ref.projects]
             if ref.operators:
-                self.operatorIds = ref.operatorIds
+                self.operatorIds = [o.id for o in ref.operators]
             if ref.equipments:
-                self.equipmentIds = ref.equipmentIds
+                self.equipmentIds = [e.id for e in ref.equipments]
+            if ref.isViewableEntity:
+                self.isViewableEntity = ref.isViewableEntity
+            if ref._files:
+                self.files = ref._files
             ref = None
 
         super().__init__(ref)
 
+    @property
+    @deprecate(new_name="formatId")
+    def parserId(self):
+        return self.formatId
+
+    @parserId.setter
+    @deprecate(new_name="formatId")
+    def paserId(self, value):
+        self.formatId = value
+
 
 @Endpoint("datasets")
 class DatasetCreator(EntityConnector):

LOGS/Entities/DatasetMatchTypes.py

@@ -1,6 +1,8 @@
 import uuid
 from typing import Any, List, Optional
 
+from numpy import deprecate
+
 from LOGS.Auxiliary.Tools import Tools
 from LOGS.Entities.FileEntry import FileEntry, FileFragment
 from LOGS.Entity.SerializeableContent import SerializeableClass
@@ -20,12 +22,22 @@ class DatasetForSearch(SerializeableClass):
 
     def __init__(self, ref: Any = None):
         self.id: str = ""
-        self.parserId: str = ""
+        self.formatId: str = ""
         self.checkUpdatable: bool = True
         self.files: List[FileEntry] = []
         super().__init__(ref)
         self.id = uuid.uuid4().hex
 
+    @property
+    @deprecate(new_name="formatId")
+    def parserId(self):
+        return self.formatId
+
+    @parserId.setter
+    @deprecate(new_name="formatId")
+    def paserId(self, value):
+        self.formatId = value
+
 
 class DatasetsUpdatableFiles(SerializeableClass):
     _typeMapper = {"files": FileEntry}
@@ -70,7 +82,7 @@ class MatchedDataset(SerializeableClass):
 
     def __init__(self, ref: Any = None):
         self.id: str = ""
-        self.parserId: str = ""
+        self.formatId: str = ""
         self.name: str = ""
         self.parentMissing: bool = False
         self.parentPath: str = ""
@@ -85,18 +97,28 @@ class MatchedDataset(SerializeableClass):
         if len(self.files):
             return "<%s %a %s>" % (
                 type(self).__name__,
-                self.parserId,
+                self.formatId,
                 Tools.numberPlural("file", len(self.files)),
             )
         else:
             return "<%s>" % (type(self).__name__)
 
+    @property
+    @deprecate(new_name="formatId")
+    def parserId(self):
+        return self.formatId
+
+    @parserId.setter
+    @deprecate(new_name="formatId")
+    def paserId(self, value):
+        self.formatId = value
+
 
 class DatasetMatch(SerializeableClass):
     _typeMapper = {"datasets": MatchedDataset}
 
     def __init__(self, ref: Any = None):
-        self.parserId: str = ""
+        self.fromatId: str = ""
         self.parserName: str = ""
         self.datasets: List[MatchedDataset] = []
         super().__init__(ref)
@@ -106,15 +128,25 @@ class DatasetMatch(SerializeableClass):
             yield dataset
 
     def __str__(self):
-        if self.parserId and len(self.datasets):
+        if self.fromatId and len(self.datasets):
             return "<%s %a(%d)>" % (
                 type(self).__name__,
-                self.parserId,
+                self.fromatId,
                 len(self.datasets),
             )
         else:
             return "<%s>" % (type(self).__name__)
 
+    @property
+    @deprecate(new_name="formatId")
+    def parserId(self):
+        return self.formatId
+
+    @parserId.setter
+    @deprecate(new_name="formatId")
+    def paserId(self, value):
+        self.formatId = value
+
 
 class MatchResult(SerializeableClass):
     _typeMapper = {"matches": DatasetMatch, "missingFragments": FileFragment}

LOGS/Entities/DatasetRelations.py

@@ -1,18 +1,21 @@
 from typing import TYPE_CHECKING, Optional
 
-from LOGS.Entities.Documents import Documents
 from LOGS.Entity.EntityRelation import EntityRelation
 from LOGS.Entity.EntityRelations import EntityRelations
 
 if TYPE_CHECKING:
     from LOGS.Entities.Document import Document
+    from LOGS.Entities.Documents import Documents
+    from LOGS.Entities.LabNotebookEntry import LabNotebookEntry
+    from LOGS.Entities.Project import Project
 
 
 class DatasetRelations(EntityRelations):
     """Relations of a Dataset with other entities"""
 
     _documents: Optional[EntityRelation["Document"]] = None
-    _labNotebookEntries: Optional[EntityRelation] = None
+    _labNotebookEntries: Optional[EntityRelation["LabNotebookEntry"]] = None
+    _projects: Optional[EntityRelation["Project"]] = None
 
     @property
     def documents(self) -> Optional[EntityRelation["Document"]]:
@@ -31,3 +34,11 @@ class DatasetRelations(EntityRelations):
         self._labNotebookEntries = self.checkAndConvertNullable(
             value, EntityRelation, "labNotebookEntries"
         )
+
+    @property
+    def projects(self) -> Optional[EntityRelation]:
+        return self._projects
+
+    @projects.setter
+    def projects(self, value):
+        self._projects = self.checkAndConvertNullable(value, EntityRelation, "projects")

LOGS/Entities/DatasetRequestParameter.py

@@ -4,9 +4,13 @@ from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Sequence
 
 from LOGS.Auxiliary.Constants import Constants
+from LOGS.Entities.ICustomSchemaRequest import ICustomSchemaRequest
+from LOGS.Entities.IRelatedEntityRequest import IRelatedEntityRequest
 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.ISoftDeletable import ISoftDeletableRequest
+from LOGS.Interfaces.ITypedEntity import ITypedEntityRequest
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntityRequest
 
 ParsingStates = Literal[
@@ -37,16 +41,22 @@ class DatasetOrder(Enum):
     PARSING_STATE_DESC = "PARSING_STATE_DESC"
     PARSERID_ASC = "PARSERID_ASC"
     PARSERID_DESC = "PARSERID_DESC"
-    DATASET_TYPE_ASC = "DATASET_TYPE_ASC"
-    DATASET_TYPE_DESC = "DATASET_TYPE_DESC"
+    FORMAT_ID_ASC = "FORMAT_ID_ASC"
+    FORMAT_ID_DESC = "FORMAT_ID_DESC"
+    TYPE_ASC = "TYPE_ASC"
+    TYPE_DESC = "YPE_DESC"
 
 
 @dataclass
 class DatasetRequestParameter(
-    EntityRequestParameter,
-    IUniqueEntityRequest,
+    EntityRequestParameter[DatasetOrder],
+    IRelatedEntityRequest,
+    ITypedEntityRequest,
+    ISoftDeletableRequest,
+    ICustomSchemaRequest,
     IOwnedEntityRequest,
-    ICustomFieldsRequest,
+    INamedEntityRequest,
+    IUniqueEntityRequest,
 ):
     includeParameters: Optional[bool] = None
     methodIds: Optional[List[int]] = None
@@ -69,7 +79,8 @@ class DatasetRequestParameter(
     participatedPersonIds: Optional[List[int]] = None
     pathContains: Optional[str] = None
     parsingState: Optional[List[ParsingStates]] = None
-    autoloadSourceId: Optional[int] = None
+    bridgeIds: Optional[List[int]] = None
+    dataSourceIds: Optional[List[int]] = None
     orderBy: Optional[DatasetOrder] = None
     typeIds: Optional[List[str]] = None
     hashes: Optional[List[str]] = None
@@ -80,3 +91,4 @@ class DatasetRequestParameter(
     includeUnclaimed: Optional[Optional[bool]] = None
     files: Optional[Sequence[Constants.FILE_TYPE]] = None
     parameters: Optional[Dict[str, Any]] = None
+    isReferencedByLabNotebook: Optional[Optional[bool]] = None

LOGS/Entities/Datasets.py

@@ -77,7 +77,7 @@ class Datasets(EntityIterator[Dataset, DatasetRequestParameter]):
         for formatId in formatIds:
             dataset = DatasetForSearch()
             dataset.checkUpdatable = checkUpdatable
-            dataset.parserId = formatId
+            dataset.formatId = formatId
             dataset.files.extend(fileList)
             request.datasets.append(dataset)
         return request

LOGS/Entities/Document.py

@@ -5,7 +5,7 @@ from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Auxiliary.MinimalModelGenerator import MinimalFromList
 from LOGS.Entities.DocumentRelations import DocumentRelations
 from LOGS.Entity.EntityMinimalWithIntId import EntityMinimalWithIntId
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+from LOGS.Entity.EntityWithIntId import IEntityWithIntId
 from LOGS.Entity.SerializeableContent import SerializeableContent
 from LOGS.Interfaces.IOwnedEntity import IOwnedEntity
 from LOGS.LOGSConnection import LOGSConnection
@@ -57,7 +57,7 @@ class DocumentFile(SerializeableContent):
 
 
 @Endpoint("documents")
-class Document(EntityWithIntId, IOwnedEntity):
+class Document(IEntityWithIntId, IOwnedEntity):
     _name: Optional[str]
     _creationDate: Optional[datetime]
     _modificationDate: Optional[datetime]

LOGS/Entities/Experiment.py

@@ -2,25 +2,30 @@ from typing import Optional
 
 from LOGS.Auxiliary.Decorators import Endpoint
 from LOGS.Auxiliary.MinimalModelGenerator import MethodMinimalFromDict
+from LOGS.Entities.ExperimentRelations import ExperimentRelations
 from LOGS.Entities.MethodMinimal import MethodMinimal
-from LOGS.Entity.EntityWithIntId import EntityWithIntId
+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.IOwnedEntity import IOwnedEntity
+from LOGS.Interfaces.IRelatedEntity import IRelatedEntity
 from LOGS.Interfaces.IUniqueEntity import IUniqueEntity
 from LOGS.LOGSConnection import LOGSConnection
 
 
 @Endpoint("experiments")
 class Experiment(
+    IEntityWithIntId,
     INamedEntity,
-    EntityWithIntId,
     IUniqueEntity,
-    IOwnedEntity,
-    IModificationRecord,
     ICreationRecord,
+    IModificationRecord,
+    IOwnedEntity,
+    IRelatedEntity[ExperimentRelations],
 ):
+    _relationType = type(ExperimentRelations)
+
     _method: Optional[MethodMinimal]
     _notes: Optional[str]
 
@@ -34,8 +39,6 @@ class Experiment(
 
         self._method = None
         self._notes = None
-        self._date_added = None
-        self._date_last_modified = None
 
         super().__init__(ref=ref, id=id, connection=connection)
 
@@ -64,21 +67,3 @@ class Experiment(
     @notes.setter
     def notes(self, value):
         self._notes = self.checkAndConvertNullable(value, str, "notes")
-
-    @property
-    def date_added(self) -> Optional[str]:
-        return self._date_added
-
-    @date_added.setter
-    def date_added(self, value):
-        self._date_added = self.checkAndConvertNullable(value, str, "date_added")
-
-    @property
-    def date_last_modified(self) -> Optional[str]:
-        return self._date_last_modified
-
-    @date_last_modified.setter
-    def date_last_modified(self, value):
-        self._date_last_modified = self.checkAndConvertNullable(
-            value, str, "date_last_modified"
-        )