diff --git a/src/caosdb/common/models.py b/src/caosdb/common/models.py
index 547a83f06d1af90223b621bc341b39c52f156758..5bc1983c56b4c1bdb7b8c7a0fcc194c9d64c9296 100644
--- a/src/caosdb/common/models.py
+++ b/src/caosdb/common/models.py
@@ -54,14 +54,14 @@ from ..configuration import get_config
from ..connection.connection import get_connection
from ..connection.encode import MultipartParam, multipart_encode
from ..exceptions import (AmbiguousEntityError, AuthorizationError,
- CaosDBConnectionError, CaosDBException,
- ConsistencyError, EmptyUniqueQueryError,
- EntityDoesNotExistError, EntityError,
- EntityHasNoDatatypeError, HTTPURITooLongError,
- MismatchingEntitiesError, QueryNotUniqueError,
- TransactionError, UniqueNamesError,
- UnqualifiedParentsError, PagingConsistencyError,
- UnqualifiedPropertiesError)
+ CaosDBConnectionError, CaosDBException,
+ ConsistencyError, EmptyUniqueQueryError,
+ EntityDoesNotExistError, EntityError,
+ EntityHasNoDatatypeError, HTTPURITooLongError,
+ MismatchingEntitiesError, QueryNotUniqueError,
+ TransactionError, UniqueNamesError,
+ UnqualifiedParentsError, PagingConsistencyError,
+ UnqualifiedPropertiesError)
from .datatype import BOOLEAN, DATETIME, DOUBLE, INTEGER, TEXT, is_reference, is_list_datatype
from .state import State
from .timezone import TimeZone
diff --git a/src/caosdb/high_level_api.py b/src/caosdb/high_level_api.py
index 96fc09af3b59ef4a1061908ec1ac241a256acaa4..70f1be36283b706f8d38d450d937ab13a9b9e699 100644
--- a/src/caosdb/high_level_api.py
+++ b/src/caosdb/high_level_api.py
@@ -39,42 +39,40 @@ import yaml
from dateutil import parser
import linkahead as db
-from linkahead.common.datatype import (BOOLEAN, DATETIME, DOUBLE, FILE,
- INTEGER, REFERENCE, TEXT,
- get_list_datatype, is_list_datatype,
- is_reference)
-
from .apiutils import create_flat_list, get_type_of_entity_with
+from .common.datatype import (BOOLEAN, DATETIME, DOUBLE, FILE, INTEGER,
+ REFERENCE, TEXT, get_list_datatype,
+ is_list_datatype, is_reference)
warnings.warn("""EXPERIMENTAL! The high_level_api module is experimental and may be changed or
removed in the future. Its purpose is to give an impression on how the Python client user interface
might be changed.""")
-def standard_type_for_high_level_type(high_level_record: "LinkAheadPythonEntity",
+def standard_type_for_high_level_type(high_level_record: "CaosDBPythonEntity",
return_string: bool = False):
"""
- For a given LinkAheadPythonEntity either return the corresponding
- class in the standard LinkAhead API or - if return_string is True - return
+ For a given CaosDBPythonEntity either return the corresponding
+ class in the standard CaosDB API or - if return_string is True - return
the role as a string.
"""
- if type(high_level_record) == LinkAheadPythonRecord:
+ if type(high_level_record) == CaosDBPythonRecord:
if not return_string:
return db.Record
return "Record"
- elif type(high_level_record) == LinkAheadPythonFile:
+ elif type(high_level_record) == CaosDBPythonFile:
if not return_string:
return db.File
return "File"
- elif type(high_level_record) == LinkAheadPythonProperty:
+ elif type(high_level_record) == CaosDBPythonProperty:
if not return_string:
return db.Property
return "Property"
- elif type(high_level_record) == LinkAheadPythonRecordType:
+ elif type(high_level_record) == CaosDBPythonRecordType:
if not return_string:
return db.RecordType
return "RecordType"
- elif type(high_level_record) == LinkAheadPythonEntity:
+ elif type(high_level_record) == CaosDBPythonEntity:
if not return_string:
return db.Entity
return "Entity"
@@ -83,15 +81,15 @@ def standard_type_for_high_level_type(high_level_record: "LinkAheadPythonEntity"
def high_level_type_for_role(role: str):
if role == "Record":
- return LinkAheadPythonRecord
+ return CaosDBPythonRecord
if role == "File":
- return LinkAheadPythonFile
+ return CaosDBPythonFile
if role == "Property":
- return LinkAheadPythonProperty
+ return CaosDBPythonProperty
if role == "RecordType":
- return LinkAheadPythonRecordType
+ return CaosDBPythonRecordType
if role == "Entity":
- return LinkAheadPythonEntity
+ return CaosDBPythonEntity
raise RuntimeError("Unknown role.")
@@ -100,20 +98,20 @@ def high_level_type_for_standard_type(standard_record: db.Entity):
raise ValueError()
role = standard_record.role
if role == "Record" or type(standard_record) == db.Record:
- return LinkAheadPythonRecord
+ return CaosDBPythonRecord
elif role == "File" or type(standard_record) == db.File:
- return LinkAheadPythonFile
+ return CaosDBPythonFile
elif role == "Property" or type(standard_record) == db.Property:
- return LinkAheadPythonProperty
+ return CaosDBPythonProperty
elif role == "RecordType" or type(standard_record) == db.RecordType:
- return LinkAheadPythonRecordType
+ return CaosDBPythonRecordType
elif role == "Entity" or type(standard_record) == db.Entity:
- return LinkAheadPythonEntity
+ return CaosDBPythonEntity
raise RuntimeError("Incompatible type.")
@dataclass
-class LinkAheadPropertyMetaData:
+class CaosDBPropertyMetaData:
# name is already the name of the attribute
unit: Optional[str] = None
datatype: Optional[str] = None
@@ -122,12 +120,12 @@ class LinkAheadPropertyMetaData:
importance: Optional[str] = None
-class LinkAheadPythonUnresolved:
+class CaosDBPythonUnresolved:
pass
@dataclass
-class LinkAheadPythonUnresolvedParent(LinkAheadPythonUnresolved):
+class CaosDBPythonUnresolvedParent(CaosDBPythonUnresolved):
"""
Parents can be either given by name or by ID.
@@ -139,32 +137,32 @@ class LinkAheadPythonUnresolvedParent(LinkAheadPythonUnresolved):
@dataclass
-class LinkAheadPythonUnresolvedReference(LinkAheadPythonUnresolved):
+class CaosDBPythonUnresolvedReference(CaosDBPythonUnresolved):
def __init__(self, id=None):
self.id = id
-class LinkAheadPythonEntity(object):
+class CaosDBPythonEntity(object):
def __init__(self):
"""
- Initialize a new LinkAheadPythonEntity for the high level python api.
+ Initialize a new CaosDBPythonEntity for the high level python api.
- Parents are either unresolved references or LinkAhead RecordTypes.
+ Parents are either unresolved references or CaosDB RecordTypes.
Properties are stored directly as attributes for the object.
Property metadata is maintained in a dctionary _properties_metadata that should
never be accessed directly, but only using the get_property_metadata function.
If property values are references to other objects, they will be stored as
- LinkAheadPythonUnresolvedReference objects that can be resolved later into
- LinkAheadPythonRecords.
+ CaosDBPythonUnresolvedReference objects that can be resolved later into
+ CaosDBPythonRecords.
"""
- # Parents are either unresolved references or LinkAhead RecordTypes
+ # Parents are either unresolved references or CaosDB RecordTypes
self._parents: List[Union[
- LinkAheadPythonUnresolvedParent, LinkAheadPythonRecordType]] = []
- # self._id: int = LinkAheadPythonEntity._get_new_id()
+ CaosDBPythonUnresolvedParent, CaosDBPythonRecordType]] = []
+ # self._id: int = CaosDBPythonEntity._get_new_id()
self._id: Optional[int] = None
self._name: Optional[str] = None
self._description: Optional[str] = None
@@ -174,7 +172,7 @@ class LinkAheadPythonEntity(object):
self._path: Optional[str] = None
# name: name of property, value: property metadata
- self._properties_metadata: Dict[LinkAheadPropertyMetaData] = dict()
+ self._properties_metadata: Dict[CaosDBPropertyMetaData] = dict()
# Store all current attributes as forbidden attributes
# which must not be changed by the set_property function.
@@ -211,14 +209,14 @@ class LinkAheadPythonEntity(object):
"""
Getter for the file.
"""
- if type(self) != LinkAheadPythonFile:
+ if type(self) != CaosDBPythonFile:
raise RuntimeError("Please don't use the file attribute for entities"
" that are no files.")
return self._file
@file.setter
def file(self, val: str):
- if val is not None and type(self) != LinkAheadPythonFile:
+ if val is not None and type(self) != CaosDBPythonFile:
raise RuntimeError("Please don't use the file attribute for entities"
" that are no files.")
self._file = val
@@ -228,14 +226,14 @@ class LinkAheadPythonEntity(object):
"""
Getter for the path.
"""
- if type(self) != LinkAheadPythonFile:
+ if type(self) != CaosDBPythonFile:
raise RuntimeError("Please don't use the path attribute for entities"
" that are no files.")
return self._path
@path.setter
def path(self, val: str):
- if val is not None and type(self) != LinkAheadPythonFile:
+ if val is not None and type(self) != CaosDBPythonFile:
raise RuntimeError("Please don't use the path attribute for entities"
" that are no files.")
self._path = val
@@ -264,7 +262,7 @@ class LinkAheadPythonEntity(object):
def _set_property_from_entity(self, ent: db.Entity, importance: str,
references: Optional[db.Container],
- visited: Dict[int, "LinkAheadPythonEntity"]):
+ visited: Dict[int, "CaosDBPythonEntity"]):
"""
Set a new property using an entity from the normal python API.
@@ -293,7 +291,7 @@ class LinkAheadPythonEntity(object):
else:
metadata.__setattr__(k, ent.__getattribute__(k))
- def get_property_metadata(self, prop_name: str) -> LinkAheadPropertyMetaData:
+ def get_property_metadata(self, prop_name: str) -> CaosDBPropertyMetaData:
"""
Retrieve the property metadata for the property with name prop_name.
@@ -311,7 +309,7 @@ class LinkAheadPythonEntity(object):
raise RuntimeError("The property with name {} does not exist.".format(prop_name))
if prop_name not in self._properties_metadata:
- self._properties_metadata[prop_name] = LinkAheadPropertyMetaData()
+ self._properties_metadata[prop_name] = CaosDBPropertyMetaData()
return self._properties_metadata[prop_name]
@@ -382,7 +380,7 @@ class LinkAheadPythonEntity(object):
val: List,
pr: str,
references: Optional[db.Container],
- visited: Dict[int, "LinkAheadPythonEntity"]):
+ visited: Dict[int, "CaosDBPythonEntity"]):
"""
Convert a list to a python list of the correct type.
@@ -403,12 +401,12 @@ class LinkAheadPythonEntity(object):
val: Any,
pr: str,
references: Optional[db.Container],
- visited: Dict[int, "LinkAheadPythonEntity"]):
+ visited: Dict[int, "CaosDBPythonEntity"]):
"""
Convert val to the correct type which is indicated by the database
type string in pr.
- References with ids will be turned into LinkAheadPythonUnresolvedReference.
+ References with ids will be turned into CaosDBPythonUnresolvedReference.
"""
if val is None:
@@ -431,16 +429,16 @@ class LinkAheadPythonEntity(object):
elif pr == TEXT:
return str(val)
elif pr == FILE:
- return LinkAheadPythonUnresolvedReference(val)
+ return CaosDBPythonUnresolvedReference(val)
elif pr == REFERENCE:
- return LinkAheadPythonUnresolvedReference(val)
+ return CaosDBPythonUnresolvedReference(val)
elif pr == DATETIME:
return self._parse_datetime(val)
elif is_list_datatype(pr):
return self._type_converted_list(val, pr, references, visited)
else:
# Generic references to entities:
- return LinkAheadPythonUnresolvedReference(val)
+ return CaosDBPythonUnresolvedReference(val)
def _parse_datetime(self, val: Union[str, datetime]):
"""
@@ -477,7 +475,7 @@ class LinkAheadPythonEntity(object):
return [att]
def add_parent(self, parent: Union[
- LinkAheadPythonUnresolvedParent, "LinkAheadPythonRecordType", str]):
+ CaosDBPythonUnresolvedParent, "CaosDBPythonRecordType", str]):
"""
Add a parent to this entity. Either using an unresolved parent or
using a real record type.
@@ -488,10 +486,10 @@ class LinkAheadPythonEntity(object):
"""
if isinstance(parent, str):
- parent = LinkAheadPythonUnresolvedParent(name=parent)
+ parent = CaosDBPythonUnresolvedParent(name=parent)
if isinstance(parent, int):
- parent = LinkAheadPythonUnresolvedParent(id=parent)
+ parent = CaosDBPythonUnresolvedParent(id=parent)
if self.has_parent(parent):
raise RuntimeError("Duplicate parent.")
@@ -507,7 +505,7 @@ class LinkAheadPythonEntity(object):
return self._parents
def has_parent(self, parent: Union[
- LinkAheadPythonUnresolvedParent, "LinkAheadPythonRecordType"]):
+ CaosDBPythonUnresolvedParent, "CaosDBPythonRecordType"]):
"""
Check whether this parent already exists for this entity.
@@ -517,10 +515,10 @@ class LinkAheadPythonEntity(object):
"""
if isinstance(parent, str):
- parent = LinkAheadPythonUnresolvedParent(name=parent)
+ parent = CaosDBPythonUnresolvedParent(name=parent)
if isinstance(parent, int):
- parent = LinkAheadPythonUnresolvedParent(id=parent)
+ parent = CaosDBPythonUnresolvedParent(id=parent)
for p in self._parents:
if p.id is not None and p.id == parent.id:
@@ -529,8 +527,8 @@ class LinkAheadPythonEntity(object):
return True
return False
- def _resolve_linkahead_python_unresolved_reference(self, propval, deep,
- references, visited):
+ def _resolve_caosdb_python_unresolved_reference(self, propval, deep,
+ references, visited):
# This does not make sense for unset ids:
if propval.id is None:
raise RuntimeError("Unresolved property reference without an ID.")
@@ -563,7 +561,7 @@ class LinkAheadPythonEntity(object):
def resolve_references(self, deep: bool, references: db.Container,
visited: Optional[Dict[Union[str, int],
- "LinkAheadPythonEntity"]] = None):
+ "CaosDBPythonEntity"]] = None):
"""
Resolve this entity's references. This affects unresolved properties as well
as unresolved parents.
@@ -574,7 +572,7 @@ class LinkAheadPythonEntity(object):
references: Optional[db.Container]
A container with references that might be resolved.
If None is passed as the container, this function tries to resolve entities from a running
- LinkAhead instance directly.
+ CaosDB instance directly.
"""
# This parameter is used in the recursion to keep track of already visited
@@ -584,31 +582,31 @@ class LinkAheadPythonEntity(object):
for parent in self.get_parents():
# TODO
- if isinstance(parent, LinkAheadPythonUnresolvedParent):
+ if isinstance(parent, CaosDBPythonUnresolvedParent):
pass
for prop in self.get_properties():
propval = self.__getattribute__(prop)
# Resolve all previously unresolved attributes that are entities:
- if deep and isinstance(propval, LinkAheadPythonEntity):
+ if deep and isinstance(propval, CaosDBPythonEntity):
propval.resolve_references(deep, references)
elif isinstance(propval, list):
resolvedelements = []
for element in propval:
- if deep and isinstance(element, LinkAheadPythonEntity):
+ if deep and isinstance(element, CaosDBPythonEntity):
element.resolve_references(deep, references)
resolvedelements.append(element)
- if isinstance(element, LinkAheadPythonUnresolvedReference):
+ if isinstance(element, CaosDBPythonUnresolvedReference):
resolvedelements.append(
- self._resolve_linkahead_python_unresolved_reference(element, deep,
- references, visited))
+ self._resolve_caosdb_python_unresolved_reference(element, deep,
+ references, visited))
else:
resolvedelements.append(element)
self.__setattr__(prop, resolvedelements)
- elif isinstance(propval, LinkAheadPythonUnresolvedReference):
- val = self._resolve_linkahead_python_unresolved_reference(propval, deep,
- references, visited)
+ elif isinstance(propval, CaosDBPythonUnresolvedReference):
+ val = self._resolve_caosdb_python_unresolved_reference(propval, deep,
+ references, visited)
self.__setattr__(prop, val)
def get_properties(self):
@@ -628,7 +626,7 @@ class LinkAheadPythonEntity(object):
if "role" in serialization:
entity = high_level_type_for_role(serialization["role"])()
else:
- entity = LinkAheadPythonRecord()
+ entity = CaosDBPythonRecord()
if "parents" in serialization:
for parent in serialization["parents"]:
@@ -639,7 +637,7 @@ class LinkAheadPythonEntity(object):
id = parent["id"]
if "name" in parent:
name = parent["name"]
- entity.add_parent(LinkAheadPythonUnresolvedParent(
+ entity.add_parent(CaosDBPythonUnresolvedParent(
id=id, name=name))
else:
raise NotImplementedError(
@@ -649,7 +647,7 @@ class LinkAheadPythonEntity(object):
if baseprop in serialization:
entity.__setattr__(baseprop, serialization[baseprop])
- if type(entity) == LinkAheadPythonFile:
+ if type(entity) == CaosDBPythonFile:
entity.file = serialization["file"]
entity.path = serialization["path"]
@@ -659,7 +657,7 @@ class LinkAheadPythonEntity(object):
prop = serialization["properties"][p]
if isinstance(prop, dict):
if "unresolved" in prop:
- entity.__setattr__(p, LinkAheadPythonUnresolvedReference(
+ entity.__setattr__(p, CaosDBPythonUnresolvedReference(
id=prop["id"]))
else:
entity.__setattr__(p,
@@ -704,13 +702,13 @@ class LinkAheadPythonEntity(object):
fulldict = dict()
visited[self] = fulldict
- # Add LinkAhead role:
+ # Add CaosDB role:
fulldict["role"] = standard_type_for_high_level_type(self, True)
for parent in self._parents:
- if isinstance(parent, LinkAheadPythonEntity):
+ if isinstance(parent, CaosDBPythonEntity):
parents.append(parent.serialize(without_metadata, visited))
- elif isinstance(parent, LinkAheadPythonUnresolvedParent):
+ elif isinstance(parent, CaosDBPythonUnresolvedParent):
parents.append({"name": parent.name, "id": parent.id,
"unresolved": True})
else:
@@ -721,7 +719,7 @@ class LinkAheadPythonEntity(object):
if val is not None:
fulldict[baseprop] = val
- if type(self) == LinkAheadPythonFile:
+ if type(self) == CaosDBPythonFile:
fulldict["file"] = self.file
fulldict["path"] = self.path
@@ -734,19 +732,19 @@ class LinkAheadPythonEntity(object):
metadata[p][f.name] = val
val = self.get_property(p)
- if isinstance(val, LinkAheadPythonUnresolvedReference):
+ if isinstance(val, CaosDBPythonUnresolvedReference):
properties[p] = {"id": val.id, "unresolved": True}
- elif isinstance(val, LinkAheadPythonEntity):
+ elif isinstance(val, CaosDBPythonEntity):
properties[p] = val.serialize(without_metadata, visited)
elif isinstance(val, list):
serializedelements = []
for element in val:
- if isinstance(element, LinkAheadPythonUnresolvedReference):
+ if isinstance(element, CaosDBPythonUnresolvedReference):
elm = dict()
elm["id"] = element.id
elm["unresolved"] = True
serializedelements.append(elm)
- elif isinstance(element, LinkAheadPythonEntity):
+ elif isinstance(element, CaosDBPythonEntity):
serializedelements.append(
element.serialize(without_metadata,
visited))
@@ -773,19 +771,19 @@ class LinkAheadPythonEntity(object):
# return yaml.dump(self.serialize(True))
-class LinkAheadPythonRecord(LinkAheadPythonEntity):
+class CaosDBPythonRecord(CaosDBPythonEntity):
pass
-class LinkAheadPythonRecordType(LinkAheadPythonEntity):
+class CaosDBPythonRecordType(CaosDBPythonEntity):
pass
-class LinkAheadPythonProperty(LinkAheadPythonEntity):
+class CaosDBPythonProperty(CaosDBPythonEntity):
pass
-class LinkAheadMultiProperty:
+class CaosDBMultiProperty:
"""
This implements a multi property using a python list.
"""
@@ -794,7 +792,7 @@ class LinkAheadMultiProperty:
raise NotImplementedError()
-class LinkAheadPythonFile(LinkAheadPythonEntity):
+class CaosDBPythonFile(CaosDBPythonEntity):
def download(self, target=None):
if self.id is None:
raise RuntimeError("Cannot download file when id is missing.")
@@ -806,14 +804,14 @@ BASE_ATTRIBUTES = (
"id", "name", "description", "version", "path", "file")
-def _single_convert_to_python_object(robj: LinkAheadPythonEntity,
+def _single_convert_to_python_object(robj: CaosDBPythonEntity,
entity: db.Entity,
references: Optional[db.Container] = None,
visited: Optional[Dict[int,
- "LinkAheadPythonEntity"]] = None):
+ "CaosDBPythonEntity"]] = None):
"""
Convert a db.Entity from the standard API to a (previously created)
- LinkAheadPythonEntity from the high level API.
+ CaosDBPythonEntity from the high level API.
This method will not resolve any unresolved references, so reference properties
as well as parents will become unresolved references in the first place.
@@ -821,7 +819,7 @@ def _single_convert_to_python_object(robj: LinkAheadPythonEntity,
The optional third parameter can be used
to resolve references that occur in the converted entities and resolve them
to their correct representations. (Entities that are not found remain as
- LinkAheadPythonUnresolvedReferences.)
+ CaosDBPythonUnresolvedReferences.)
Returns the input object robj.
"""
@@ -848,16 +846,16 @@ def _single_convert_to_python_object(robj: LinkAheadPythonEntity,
visited)
for parent in entity.parents:
- robj.add_parent(LinkAheadPythonUnresolvedParent(id=parent.id,
- name=parent.name))
+ robj.add_parent(CaosDBPythonUnresolvedParent(id=parent.id,
+ name=parent.name))
return robj
def _convert_property_value(propval):
- if isinstance(propval, LinkAheadPythonUnresolvedReference):
+ if isinstance(propval, CaosDBPythonUnresolvedReference):
propval = propval.id
- elif isinstance(propval, LinkAheadPythonEntity):
+ elif isinstance(propval, CaosDBPythonEntity):
propval = _single_convert_to_entity(
standard_type_for_high_level_type(propval)(), propval)
elif isinstance(propval, list):
@@ -869,19 +867,19 @@ def _convert_property_value(propval):
def _single_convert_to_entity(entity: db.Entity,
- robj: LinkAheadPythonEntity):
+ robj: CaosDBPythonEntity):
"""
- Convert a LinkAheadPythonEntity to an entity in standard pylib format.
+ Convert a CaosDBPythonEntity to an entity in standard pylib format.
entity: db.Entity
An empty entity.
- robj: LinkAheadPythonEntity
- The LinkAheadPythonEntity that is supposed to be converted to the entity.
+ robj: CaosDBPythonEntity
+ The CaosDBPythonEntity that is supposed to be converted to the entity.
"""
for base_attribute in BASE_ATTRIBUTES:
- if base_attribute in ("file", "path") and not isinstance(robj, LinkAheadPythonFile):
+ if base_attribute in ("file", "path") and not isinstance(robj, CaosDBPythonFile):
continue
# Skip version:
@@ -894,9 +892,9 @@ def _single_convert_to_entity(entity: db.Entity,
entity.__setattr__(base_attribute, val)
for parent in robj.get_parents():
- if isinstance(parent, LinkAheadPythonUnresolvedParent):
+ if isinstance(parent, CaosDBPythonUnresolvedParent):
entity.add_parent(name=parent.name, id=parent.id)
- elif isinstance(parent, LinkAheadPythonRecordType):
+ elif isinstance(parent, CaosDBPythonRecordType):
raise NotImplementedError()
else:
raise RuntimeError("Incompatible class used as parent.")
@@ -924,15 +922,15 @@ def convert_to_entity(python_object):
# Create a list of objects:
return [convert_to_entity(i) for i in python_object]
- elif isinstance(python_object, LinkAheadPythonRecord):
+ elif isinstance(python_object, CaosDBPythonRecord):
return _single_convert_to_entity(db.Record(), python_object)
- elif isinstance(python_object, LinkAheadPythonFile):
+ elif isinstance(python_object, CaosDBPythonFile):
return _single_convert_to_entity(db.File(), python_object)
- elif isinstance(python_object, LinkAheadPythonRecordType):
+ elif isinstance(python_object, CaosDBPythonRecordType):
return _single_convert_to_entity(db.RecordType(), python_object)
- elif isinstance(python_object, LinkAheadPythonProperty):
+ elif isinstance(python_object, CaosDBPythonProperty):
return _single_convert_to_entity(db.Property(), python_object)
- elif isinstance(python_object, LinkAheadPythonEntity):
+ elif isinstance(python_object, CaosDBPythonEntity):
return _single_convert_to_entity(db.Entity(), python_object)
else:
raise ValueError("Cannot convert an object of this type.")
@@ -941,15 +939,15 @@ def convert_to_entity(python_object):
def convert_to_python_object(entity: Union[db.Container, db.Entity],
references: Optional[db.Container] = None,
visited: Optional[Dict[int,
- "LinkAheadPythonEntity"]] = None):
+ "CaosDBPythonEntity"]] = None):
"""
- Convert either a container of LinkAhead entities or a single LinkAhead entity
+ Convert either a container of CaosDB entities or a single CaosDB entity
into the high level representation.
The optional second parameter can be used
to resolve references that occur in the converted entities and resolve them
to their correct representations. (Entities that are not found remain as
- LinkAheadPythonUnresolvedReferences.)
+ CaosDBPythonUnresolvedReferences.)
"""
if isinstance(entity, db.Container):
# Create a list of objects:
@@ -1026,10 +1024,10 @@ def load_external_record(record_name: str):
return convert_to_python_object(db.Record(name=record_name).retrieve())
-def create_entity_container(record: LinkAheadPythonEntity):
+def create_entity_container(record: CaosDBPythonEntity):
"""
Convert this record into an entity container in standard format that can be used
- to insert or update entities in a running LinkAhead instance.
+ to insert or update entities in a running CaosDB instance.
"""
ent = convert_to_entity(record)
lse: List[db.Entity] = [ent]
diff --git a/src/doc/high_level_api.org b/src/doc/high_level_api.org
index fee4735684ada26b3551be987724d41d0a79d97a..516df1b41d500fab000a72517fd2d12ba61753b7 100644
--- a/src/doc/high_level_api.org
+++ b/src/doc/high_level_api.org
@@ -1,14 +1,14 @@
* High Level API
In addition to the old standard pylib API, new versions of pylib ship with a high level API
-that facilitates usage of LinkAhead entities within data analysis scripts. In a nutshell that
-API exposes all properties of LinkAhead Records as standard python attributes making their
+that facilitates usage of CaosDB entities within data analysis scripts. In a nutshell that
+API exposes all properties of CaosDB Records as standard python attributes making their
access easier.
Or to spell it out directly in Python:
#+BEGIN_SRC python
- import linkahead as db
+ import caosdb as db
# Old API:
r = db.Record()
r.add_parent("Experiment")
@@ -16,7 +16,7 @@ Or to spell it out directly in Python:
r.get_property("alpha").value = 25 # setting properties (old api)
print(r.get_property("alpha").value + 25) # getting properties (old api)
- from linkahead.high_level_api import convert_to_python_entity
+ from caosdb.high_level_api import convert_to_python_entity
obj = convert_to_python_object(r) # create a high level entity
obj.r = 25 # setting properties (new api)
print(obj.r + 25) # getting properties (new api)
@@ -27,7 +27,7 @@ Or to spell it out directly in Python:
** Quickstart
The module, needed for the high level API is called:
-~linkahead.high_level_api~
+~caosdb.high_level_api~
There are two functions converting entities between the two representation (old API and new API):
- ~convert_to_python_object~: Convert entities from **old** into **new** representation.
@@ -38,11 +38,11 @@ Furthermore there are a few utility functions which expose very practical shorth
- ~create_record~: Create a new high level entity using the name of a record type and a list of key value pairs as properties.
- ~load_external_record~: Retrieve a record with a specific name and return it as high level entity.
- ~create_entity_container~: Convert a high level entity into a standard entity including all sub entities.
-- ~query~: Do a LinkAhead query and return the result as a container of high level objects.
+- ~query~: Do a CaosDB query and return the result as a container of high level objects.
-So as a first example, you could retrieve any record from LinkAhead and use it using its high level representation:
+So as a first example, you could retrieve any record from CaosDB and use it using its high level representation:
#+BEGIN_SRC python
- from linkahead.high_level_api import query
+ from caosdb.high_level_api import query
res = query("FIND Record Experiment")
experiment = res[0]
@@ -60,7 +60,7 @@ like the list of output files "output", become immediately available.
**Note** that for the old API you were supposed to run the following series of commands
to achieve the same result:
#+BEGIN_SRC python
- import linkahead as db
+ import caosdb as db
res = db.execute_query("FIND Record Experiment")
output = res.get_property("output")
@@ -69,9 +69,9 @@ to achieve the same result:
#+END_SRC
Resolving subproperties makes use of the "resolve_reference" function provided by the high level
-entity class (~LinkAheadPythonEntity~), with the following parameters:
+entity class (~CaosDBPythonEntity~), with the following parameters:
- ~deep~: Whether to use recursive retrieval
-- ~references~: Whether to use the supplied db.Container to resolve references. This allows offline usage. Set it to None if you want to automatically retrieve entities from the current LinkAhead connection.
+- ~references~: Whether to use the supplied db.Container to resolve references. This allows offline usage. Set it to None if you want to automatically retrieve entities from the current CaosDB connection.
- ~visited~: Needed for recursion, set this to None.
Objects in the high level representation can be serialized to a simple yaml form using the function
@@ -94,26 +94,26 @@ print(str(obj))
As described in the section [[Quickstart]] the two functions ~convert_to_python_object~ and ~convert_to_entity~ convert
entities beetween the high level and the standard representation.
-The high level entities are represented using the following classes from the module ~linkahead.high_level_api~:
-- ~LinkAheadPythonEntity~: Base class of the following entity classes.
-- ~LinkAheadPythonRecord~
-- ~LinkAheadPythonRecordType~
-- ~LinkAheadPythonProperty~
-- ~LinkAheadPythonMultiProperty~: **WARNING** Not implemented yet.
-- ~LinkAheadPythonFile~: Used for file entities and provides an additional ~download~ function for being able to directly retrieve files from LinkAhead.
+The high level entities are represented using the following classes from the module ~caosdb.high_level_api~:
+- ~CaosDBPythonEntity~: Base class of the following entity classes.
+- ~CaosDBPythonRecord~
+- ~CaosDBPythonRecordType~
+- ~CaosDBPythonProperty~
+- ~CaosDBPythonMultiProperty~: **WARNING** Not implemented yet.
+- ~CaosDBPythonFile~: Used for file entities and provides an additional ~download~ function for being able to directly retrieve files from CaosDB.
In addition, there are the following helper structures which are realized as Python data classes:
-- ~LinkAheadPropertyMetaData~: For storing meta data about properties.
-- ~LinkAheadPythonUnresolved~: The base class of unresolved "things".
-- ~LinkAheadPythonUnresolvedParent~: Parents of entities are stored as unresolved parents by default, storing an id or a name of a parent (or both).
-- ~LinkAheadPythonUnresolvedReference~: An unresolved reference is a reference property with an id which has not (yet) been resolved to an Entity.
+- ~CaosDBPropertyMetaData~: For storing meta data about properties.
+- ~CaosDBPythonUnresolved~: The base class of unresolved "things".
+- ~CaosDBPythonUnresolvedParent~: Parents of entities are stored as unresolved parents by default, storing an id or a name of a parent (or both).
+- ~CaosDBPythonUnresolvedReference~: An unresolved reference is a reference property with an id which has not (yet) been resolved to an Entity.
-The function "resolve_references" can be used to recursively replace ~LinkAheadPythonUnresolvedReferences~ into members of type ~LinkAheadPythonRecords~
-or ~LinkAheadPythonFile~.
+The function "resolve_references" can be used to recursively replace ~CaosDBPythonUnresolvedReferences~ into members of type ~CaosDBPythonRecords~
+or ~CaosDBPythonFile~.
-Each property stored in a LinkAhead record corresponds to:
-- a member attribute of ~LinkAheadPythonRecord~ **and**
-- an entry in a dict called "metadata" storing a LinkAheadPropertyMetadata object with the following information about proeprties:
+Each property stored in a CaosDB record corresponds to:
+- a member attribute of ~CaosDBPythonRecord~ **and**
+- an entry in a dict called "metadata" storing a CaosDBPropertyMetadata object with the following information about proeprties:
- ~unit~
- ~datatype~
- ~description~
@@ -141,7 +141,7 @@ First, the data model will be filled with the parameter values for this specific
Records are created by the `create_record` function. Parameter values can be set at record creation and also after creation as python properties of the corresponding record instance. The following example shows how to create a record, how to set the parameter at creation and how to set them as python properties
#+BEGIN_SRC python
- from linkahead.high_level_api import create_record
+ from caosdb.high_level_api import create_record
MonodomainRecord = create_record("MonodomainTissueSimulation")
MonodomainRecord.LocalModel = create_record("MitchellSchaefferModel")
@@ -166,6 +166,6 @@ Records are created by the `create_record` function. Parameter values can be set
#+END_SRC
At any position in the algorithm you are free to:
-- Convert this model to the standard python API and insert or update the records in a running instance of LinkAhead.
-- Serialize this model in the high level API yaml format. This enables the LinkAhead crawler to pickup the file and synchronize it with a running instance
-of LinkAhead.
+- Convert this model to the standard python API and insert or update the records in a running instance of CaosDB.
+- Serialize this model in the high level API yaml format. This enables the CaosDB crawler to pickup the file and synchronize it with a running instance
+of CaosDB.
diff --git a/unittests/test_high_level_api.py b/unittests/test_high_level_api.py
index 7820ed78157c2003f0dca2df0ac0ad6d3954ba2f..ea5e635eadaa849480de5f3ece10b813a538a1b0 100644
--- a/unittests/test_high_level_api.py
+++ b/unittests/test_high_level_api.py
@@ -1,4 +1,4 @@
-# This file is a part of the LinkAhead Project.
+# This file is a part of the CaosDB Project.
#
# Copyright (C) 2018 Research Group Biomedical Physics,
# Max-Planck-Institute for Dynamics and Self-Organization Göttingen
@@ -23,30 +23,31 @@
# A. Schlemmer, 02/2022
+import caosdb as db
+from caosdb.high_level_api import (convert_to_entity, convert_to_python_object,
+ new_high_level_entity)
+from caosdb.high_level_api import (CaosDBPythonUnresolvedParent,
+ CaosDBPythonUnresolvedReference,
+ CaosDBPythonRecord, CaosDBPythonFile,
+ high_level_type_for_standard_type,
+ standard_type_for_high_level_type,
+ high_level_type_for_role,
+ CaosDBPythonEntity)
+from caosdb.apiutils import compare_entities
+
+from caosdb.common.datatype import (is_list_datatype,
+ get_list_datatype,
+ is_reference)
+
+import pytest
+from lxml import etree
import os
-import pdb
+import tempfile
import pickle
+
import sys
-import tempfile
import traceback
-
-import linkahead as db
-import pytest
-from linkahead.apiutils import compare_entities
-from linkahead.common.datatype import (get_list_datatype, is_list_datatype,
- is_reference)
-from linkahead.high_level_api import (LinkAheadPythonEntity,
- LinkAheadPythonFile,
- LinkAheadPythonRecord,
- LinkAheadPythonUnresolvedParent,
- LinkAheadPythonUnresolvedReference,
- convert_to_entity,
- convert_to_python_object,
- high_level_type_for_role,
- high_level_type_for_standard_type,
- new_high_level_entity,
- standard_type_for_high_level_type)
-from lxml import etree
+import pdb
@pytest.fixture
@@ -91,25 +92,25 @@ def test_convert_record():
assert obj.c == 18
assert obj.has_parent("bla") is True
- assert obj.has_parent(LinkAheadPythonUnresolvedParent(name="bla")) is True
+ assert obj.has_parent(CaosDBPythonUnresolvedParent(name="bla")) is True
# Check the has_parent function:
assert obj.has_parent("test") is False
- assert obj.has_parent(LinkAheadPythonUnresolvedParent(name="test")) is False
+ assert obj.has_parent(CaosDBPythonUnresolvedParent(name="test")) is False
# duplicate parent
with pytest.raises(RuntimeError):
obj.add_parent("bla")
# add parent with just an id:
- obj.add_parent(LinkAheadPythonUnresolvedParent(id=225))
+ obj.add_parent(CaosDBPythonUnresolvedParent(id=225))
assert obj.has_parent(225) is True
- assert obj.has_parent(LinkAheadPythonUnresolvedParent(id=225)) is True
+ assert obj.has_parent(CaosDBPythonUnresolvedParent(id=225)) is True
assert obj.has_parent(226) is False
- assert obj.has_parent(LinkAheadPythonUnresolvedParent(id=228)) is False
+ assert obj.has_parent(CaosDBPythonUnresolvedParent(id=228)) is False
# same with just a name:
- obj.add_parent(LinkAheadPythonUnresolvedParent(name="another"))
+ obj.add_parent(CaosDBPythonUnresolvedParent(name="another"))
assert obj.has_parent("another") is True
@@ -163,7 +164,7 @@ def test_convert_with_references():
obj = convert_to_python_object(r)
# Parent does not automatically lead to a datatype:
assert obj.get_property_metadata("ref").datatype == "bla"
- assert isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
+ assert isinstance(obj.ref, CaosDBPythonUnresolvedReference)
assert obj.ref.id == 27
@@ -185,19 +186,19 @@ def test_resolve_references():
# Nothing is going to be resolved:
obj.resolve_references(False, db.Container())
- assert isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
+ assert isinstance(obj.ref, CaosDBPythonUnresolvedReference)
assert obj.ref.id == 27
assert obj.ref_false == 27
# deep == True does not help:
obj.resolve_references(True, db.Container())
- assert isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
+ assert isinstance(obj.ref, CaosDBPythonUnresolvedReference)
assert obj.ref.id == 27
# But adding the reference container will do:
obj.resolve_references(False, references)
- assert not isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
- assert isinstance(obj.ref, LinkAheadPythonRecord)
+ assert not isinstance(obj.ref, CaosDBPythonUnresolvedReference)
+ assert isinstance(obj.ref, CaosDBPythonRecord)
assert obj.ref.id == 27
assert obj.ref.a == 57
# Datatypes will not automatically be set:
@@ -209,27 +210,27 @@ def test_resolve_references():
ref.add_property(name="ref", value=225, datatype="bla")
obj = convert_to_python_object(r)
- assert isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
+ assert isinstance(obj.ref, CaosDBPythonUnresolvedReference)
obj.resolve_references(False, references)
- assert not isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
- assert isinstance(obj.ref.ref, LinkAheadPythonUnresolvedReference)
+ assert not isinstance(obj.ref, CaosDBPythonUnresolvedReference)
+ assert isinstance(obj.ref.ref, CaosDBPythonUnresolvedReference)
assert obj.ref.ref.id == 225
# Will not help, because ref2 is missing in container:
obj.resolve_references(True, references)
- assert not isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
- assert isinstance(obj.ref.ref, LinkAheadPythonUnresolvedReference)
+ assert not isinstance(obj.ref, CaosDBPythonUnresolvedReference)
+ assert isinstance(obj.ref.ref, CaosDBPythonUnresolvedReference)
assert obj.ref.ref.id == 225
references.append(ref2)
obj.resolve_references(False, references)
- assert not isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
- assert isinstance(obj.ref.ref, LinkAheadPythonUnresolvedReference)
+ assert not isinstance(obj.ref, CaosDBPythonUnresolvedReference)
+ assert isinstance(obj.ref.ref, CaosDBPythonUnresolvedReference)
assert obj.ref.ref.id == 225
obj.resolve_references(True, references)
- assert not isinstance(obj.ref, LinkAheadPythonUnresolvedReference)
- assert not isinstance(obj.ref.ref, LinkAheadPythonUnresolvedReference)
+ assert not isinstance(obj.ref, CaosDBPythonUnresolvedReference)
+ assert not isinstance(obj.ref.ref, CaosDBPythonUnresolvedReference)
assert obj.ref.ref.c == "test"
# Test circular dependencies:
@@ -302,7 +303,7 @@ def test_base_properties():
def test_empty():
r = db.Record()
obj = convert_to_python_object(r)
- assert isinstance(obj, LinkAheadPythonRecord)
+ assert isinstance(obj, CaosDBPythonRecord)
assert len(obj.get_properties()) == 0
assert len(obj.get_parents()) == 0
@@ -346,7 +347,7 @@ def test_files():
r = db.File()
obj = convert_to_python_object(r)
print(type(obj))
- assert isinstance(obj, LinkAheadPythonFile)
+ assert isinstance(obj, CaosDBPythonFile)
assert len(obj.get_properties()) == 0
assert len(obj.get_parents()) == 0
@@ -358,7 +359,7 @@ def test_files():
obj = convert_to_python_object(r)
assert r.path == "test.dat"
assert r.file == "/local/path/test.dat"
- assert isinstance(obj, LinkAheadPythonFile)
+ assert isinstance(obj, CaosDBPythonFile)
assert obj.path == "test.dat"
assert obj.file == "/local/path/test.dat"
@@ -384,7 +385,7 @@ def test_files():
rec = db.Record()
rec.add_property(name="testfile", value=2, datatype=db.FILE)
obj = convert_to_python_object(rec)
- assert type(obj.testfile) == LinkAheadPythonUnresolvedReference
+ assert type(obj.testfile) == CaosDBPythonUnresolvedReference
assert obj.testfile.id == 2
assert obj.get_property_metadata("testfile").datatype == db.FILE
@@ -466,8 +467,8 @@ def test_list_types():
assert len(obj.a) == 3
assert obj.get_property_metadata("a").datatype == "LIST<TestReference>"
for i in range(3):
- assert type(obj.a[i]) == LinkAheadPythonUnresolvedReference
- assert obj.a == [LinkAheadPythonUnresolvedReference(id=i) for i in [1, 2, 4]]
+ assert type(obj.a[i]) == CaosDBPythonUnresolvedReference
+ assert obj.a == [CaosDBPythonUnresolvedReference(id=i) for i in [1, 2, 4]]
# Try resolving:
@@ -477,8 +478,8 @@ def test_list_types():
assert len(obj.a) == 3
assert obj.get_property_metadata("a").datatype == "LIST<TestReference>"
for i in range(3):
- assert type(obj.a[i]) == LinkAheadPythonUnresolvedReference
- assert obj.a == [LinkAheadPythonUnresolvedReference(id=i) for i in [1, 2, 4]]
+ assert type(obj.a[i]) == CaosDBPythonUnresolvedReference
+ assert obj.a == [CaosDBPythonUnresolvedReference(id=i) for i in [1, 2, 4]]
references = db.Container()
for i in [1, 2, 4]:
@@ -491,7 +492,7 @@ def test_list_types():
assert len(obj.a) == 3
assert obj.get_property_metadata("a").datatype == "LIST<TestReference>"
for i in range(3):
- assert type(obj.a[i]) == LinkAheadPythonRecord
+ assert type(obj.a[i]) == CaosDBPythonRecord
assert obj.a[0].val == "1 bla"
@@ -522,15 +523,15 @@ def test_list_types():
# Test utility functions:
def test_type_conversion():
- assert high_level_type_for_standard_type(db.Record()) == LinkAheadPythonRecord
- assert high_level_type_for_standard_type(db.Entity()) == LinkAheadPythonEntity
- assert standard_type_for_high_level_type(LinkAheadPythonRecord()) == db.Record
- assert standard_type_for_high_level_type(LinkAheadPythonEntity()) == db.Entity
- assert standard_type_for_high_level_type(LinkAheadPythonFile(), True) == "File"
- assert standard_type_for_high_level_type(LinkAheadPythonRecord(), True) == "Record"
- assert high_level_type_for_role("Record") == LinkAheadPythonRecord
- assert high_level_type_for_role("Entity") == LinkAheadPythonEntity
- assert high_level_type_for_role("File") == LinkAheadPythonFile
+ assert high_level_type_for_standard_type(db.Record()) == CaosDBPythonRecord
+ assert high_level_type_for_standard_type(db.Entity()) == CaosDBPythonEntity
+ assert standard_type_for_high_level_type(CaosDBPythonRecord()) == db.Record
+ assert standard_type_for_high_level_type(CaosDBPythonEntity()) == db.Entity
+ assert standard_type_for_high_level_type(CaosDBPythonFile(), True) == "File"
+ assert standard_type_for_high_level_type(CaosDBPythonRecord(), True) == "Record"
+ assert high_level_type_for_role("Record") == CaosDBPythonRecord
+ assert high_level_type_for_role("Entity") == CaosDBPythonEntity
+ assert high_level_type_for_role("File") == CaosDBPythonFile
with pytest.raises(RuntimeError, match="Unknown role."):
high_level_type_for_role("jkaldjfkaldsjf")
@@ -555,11 +556,11 @@ def test_deserialization():
obj = convert_to_python_object(r)
serial = obj.serialize()
- obj_des = LinkAheadPythonEntity.deserialize(serial)
+ obj_des = CaosDBPythonEntity.deserialize(serial)
assert obj_des.name == "test"
assert obj_des.id == 17
- assert obj_des.has_parent(LinkAheadPythonUnresolvedParent(name="bla"))
+ assert obj_des.has_parent(CaosDBPythonUnresolvedParent(name="bla"))
print(obj)
print(obj_des)
@@ -573,7 +574,7 @@ def test_deserialization():
obj = convert_to_python_object(f)
serial = obj.serialize()
- obj_des = LinkAheadPythonEntity.deserialize(serial)
+ obj_des = CaosDBPythonEntity.deserialize(serial)
assert obj_des.file == "bla.test"
assert obj_des.path == "/test/n/bla.test"
@@ -592,7 +593,7 @@ def test_deserialization():
obj = convert_to_python_object(r)
serial = obj.serialize()
- obj_des = LinkAheadPythonEntity.deserialize(serial)
+ obj_des = CaosDBPythonEntity.deserialize(serial)
assert obj.serialize() == obj_des.serialize()