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 _register_one(self, resource: Resource, schema_id: str) -> None:
context = self.model_context or self.context
data = as_jsonld(resource,
"compacted",
False,
model_context=context,
metadata_context=None,
context_resolver=self.service.resolve_context,
na=nan)
try:
schema = quote_plus(schema_id) if schema_id else "_"
url_base = f"{self.service.url_resources}/{schema}"
url = f"{url_base}/{quote_plus(data['@id'])}" if hasattr(
data, "@id") else url_base
params_register = copy.deepcopy(
self.service.params.get("register", None))
response = requests.post(url,
headers=self.service.headers,
data=json.dumps(data, ensure_ascii=True),
params=params_register)
response.raise_for_status()
except nexus.HTTPError as e:
raise RegistrationError(_error_message(e))
else:
response_json = response.json()
resource.id = response_json['@id']
# If resource had no context, update it with the one provided by the store.
if not hasattr(resource, "context"):
resource.context = data["@context"]
self.service.sync_metadata(resource, response_json)
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 _freeze_one(self, resource: Resource) -> None:
# Notify of failures with exception FreezingError including a message.
# Use self.versioned_id_template.format(x=resource) to freeze IDs.
for _, v in resource.__dict__.items():
if isinstance(v, List):
for x in v:
if isinstance(x, Resource):
self._freeze_one(x)
elif isinstance(v, Resource):
self._freeze_one(v)
if hasattr(resource, "id"):
resource.id = self.versioned_id_template.format(x=resource)
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 _register_one(self, resource: Resource, schema_id: str) -> None:
context = self.model_context or self.context
data = as_jsonld(resource,
"compacted",
False,
model_context=context,
metadata_context=None,
context_resolver=self.service.resolve_context)
try:
response = nexus.resources.create(org_label=self.organisation,
project_label=self.project,
data=data,
schema_id=schema_id)
except nexus.HTTPError as e:
raise RegistrationError(_error_message(e))
else:
resource.id = response['@id']
# If resource had no context, update it with the one provided by the store.
if not hasattr(resource, "context"):
resource.context = data["@context"]
self.service.sync_metadata(resource, response)
def valid_activity_resource(self, activity_json):
resource = Resource(**activity_json)
resource.id = "http://testing/123"
return resource