def _load_one(data: Union[Path, Dict]) -> DictWrapper:
if isinstance(data, Path):
with data.open() as f:
record = json.load(f)
return wrap_dict(record)
else:
return wrap_dict(data)
def test_freeze(config, store_metadata_value):
forge = KnowledgeGraphForge(config, debug=True)
derivation1 = Dataset(forge, type="Dataset", name="A derivation dataset")
derivation1.id = "http://derivation1"
derivation1._store_metadata = wrap_dict(store_metadata_value)
generation1 = Dataset(forge, type="Dataset", name="A generation dataset")
generation1.id = "http://generation1"
generation1._store_metadata = wrap_dict(store_metadata_value)
invalidation1 = Dataset(forge, type="Activity", name="An invalidation activity")
invalidation1.id = "http://invalidation1"
invalidation1._store_metadata = wrap_dict(store_metadata_value)
contribution1 = Resource(type="Person", name="A contributor")
contribution1.id = "http://contribution1"
contribution1._store_metadata = wrap_dict(store_metadata_value)
dataset = Dataset(forge, type="Dataset", name="A dataset")
dataset._store_metadata = wrap_dict(store_metadata_value)
dataset.add_derivation(derivation1, versioned=False)
dataset.add_generation(generation1, versioned=False)
dataset.add_invalidation(invalidation1, versioned=False)
dataset.add_contribution(contribution1, versioned=False)
expected_derivation = json.loads(json.dumps({"type":"Derivation", "entity":{"id": "http://derivation1",
"type":"Dataset", "name":"A derivation dataset"}}))
assert forge.as_json(dataset.derivation) == expected_derivation
expected_generation = json.loads(json.dumps({"type": "Generation",
"activity": {"id": "http://generation1", "type": "Dataset"}}))
assert forge.as_json(dataset.generation) == expected_generation
expected_contribution = json.loads(json.dumps({"type": "Contribution",
"agent": {"id": "http://contribution1", "type": "Person"}}))
assert forge.as_json(dataset.contribution) == expected_contribution
expected_invalidation = json.loads(json.dumps({"type": "Invalidation",
"activity": {"id": "http://invalidation1", "type": "Activity"}}))
assert forge.as_json(dataset.invalidation) == expected_invalidation
dataset.id = "http://dataset"
dataset._synchronized = True
forge._store.freeze(dataset)
assert dataset.id == "http://dataset?_version=1"
assert dataset.derivation.entity.id == "http://derivation1?_version=1"
assert dataset.generation.activity.id == "http://generation1?_version=1"
assert dataset.contribution.agent.id == "http://contribution1?_version=1"
assert dataset.invalidation.activity.id == "http://invalidation1?_version=1"
def sync_metadata(self, resource: Resource, result: Dict) -> None:
metadata = {"id": resource.id}
keys = sorted(self.metadata_context.terms.keys())
only_meta = {k: v for k, v in result.items() if k in keys}
metadata.update(
_remove_ld_keys(only_meta, self.metadata_context, False))
resource._store_metadata = wrap_dict(metadata)
def registered_person(person, store_metadata_value):
custom_context = person.context
if custom_context.base:
person.id = f"{person.base}{str(uuid4())}"
else:
person.id = f"{urljoin('file:', pathname2url(os.getcwd()))}/{str(uuid4())}"
store_metadata_value["id"] = person.id
person._store_metadata = wrap_dict(store_metadata_value)
return person
def _make_registered(r: Resource, metadata, base=None):
if base:
r.id = f"{urljoin('file:', pathname2url(os.getcwd()))}/{str(uuid4())}"
else:
r.id = str(uuid4())
if metadata:
metadata["id"] = r.id
r._store_metadata = wrap_dict(metadata)
return r
def _deprecate_one(self, resource: Resource) -> None:
rid = resource.id
try:
record = self.service.deprecate(rid)
except StoreLibrary.RecordMissing:
raise DeprecationError("resource not found")
except StoreLibrary.RecordDeprecated:
raise DeprecationError("resource already deprecated")
else:
resource._store_metadata = wrap_dict(record["metadata"])
def _register_one(self, resource: Resource, schema_id: str) -> None:
data = as_json(resource, expanded=False, store_metadata=False, model_context=None,
metadata_context=None, context_resolver=None)
try:
record = self.service.create(data)
except StoreLibrary.RecordExists:
raise RegistrationError("resource already exists")
else:
resource.id = record["data"]["id"]
resource._store_metadata = wrap_dict(record["metadata"])
def registered_building(building, model_context, store_metadata_value):
building.context = model_context.iri if model_context.is_http_iri(
) else model_context.document["@context"]
if model_context.base:
building.id = f"{model_context.base}{str(uuid4())}"
else:
building.id = f"{urljoin('file:', pathname2url(os.getcwd()))}/{str(uuid4())}"
store_metadata_value["id"] = building.id
building._store_metadata = wrap_dict(store_metadata_value)
return building
def _update_one(self, resource: Resource) -> None:
data = as_json(resource, expanded=False, store_metadata=False, model_context=None,
metadata_context=None, context_resolver=None)
try:
record = self.service.update(data)
except StoreLibrary.RecordMissing:
raise UpdatingError("resource not found")
except StoreLibrary.RecordDeprecated:
raise UpdatingError("resource is deprecated")
else:
resource._store_metadata = wrap_dict(record["metadata"])
def add_metadata(resource: Resource):
metadata = {
"_self": resource.id,
"_constrainedBy": "https://bluebrain.github.io/nexus/schemas/unconstrained.json",
"_project": "https://nexus/org/prj",
"_rev": 1,
"_deprecated": False,
"_createdAt": "2019-03-28T13:40:38.934Z",
"_createdBy": "https://nexus/u1",
"_updatedAt": "2019-03-28T13:40:38.934Z",
"_updatedBy": "https://nexus/u1",
"_incoming": "https:/nexus/incoming",
"_outgoing": "https://nexux/outgoing"
}
resource._synchronized = True
resource._validated = True
resource._store_metadata = wrap_dict(metadata)
def find(self, conditions: List[str]) -> List[Dict]:
return [r for r in self.records.values()
if all(eval(c, {}, {"x": wrap_dict(r["data"])}) for c in conditions)]
def _to_resource(record: Dict) -> Resource:
# TODO This operation might be abstracted in core when other stores will be implemented.
resource = from_json(record["data"], None)
resource._store_metadata = wrap_dict(record["metadata"])
resource._synchronized = True
return resource
def registered_person_custom_context(person, custom_context, store_metadata_value):
person.id = "c51f4e4e-2b30-41f4-8f7c-aced85632b03"
store_metadata_value["id"] = person.id
person._store_metadata = wrap_dict(store_metadata_value)
return person
def registered_person_custom_context(person, custom_context,
store_metadata_value):
person.id = str(uuid4())
store_metadata_value["id"] = person.id
person._store_metadata = wrap_dict(store_metadata_value)
return person
