def to_resource(self, payload: Dict) -> Resource:
data_context = deepcopy(payload["@context"])
if not isinstance(data_context, list):
data_context = [data_context]
if self.store_context in data_context:
data_context.remove(self.store_context)
if self.store_local_context in data_context:
data_context.remove(self.store_local_context)
data_context = data_context[0] if len(data_context) == 1 else data_context
metadata = dict()
data = dict()
for k, v in payload.items():
if k in self.metadata_context.terms.keys():
metadata[k] = v
else:
data[k] = v
if self.model_context and data_context == self.model_context.iri:
resolved_ctx = self.model_context.document["@context"]
else:
resolved_ctx = recursive_resolve(data_context, self.resolve_context)
data["@context"] = resolved_ctx
resource = _from_jsonld_one(data)
resource.context = data_context
if len(metadata) > 0:
self.sync_metadata(resource, metadata)
return resource
def __init__(self, endpoint: str, org: str, prj: str, token: str, model_context: Context,
max_connection: int, searchendpoints: Dict, store_context: str, store_local_context: str, namespace: str, project_property: str,
deprecated_property: bool, content_type: str, accept: str, files_upload_config: Dict,
files_download_config: Dict, **params):
nexus.config.set_environment(endpoint)
self.endpoint = endpoint
self.organisation = org
self.project = prj
self.model_context = model_context
self.context_cache: Dict = dict()
self.max_connection = max_connection
self.params = copy.deepcopy(params)
self.store_context = store_context
self.store_local_context = store_local_context
self.namespace = namespace
self.project_property = project_property
self.deprecated_property = deprecated_property
self.default_sparql_index = f"{self.namespace}defaultSparqlIndex"
self.default_es_index = f"{self.namespace}defaultElasticSearchIndex"
self.headers = {
"Content-Type": content_type,
"Accept": accept
}
sparql_config = searchendpoints['sparql'] if searchendpoints and "sparql" in searchendpoints else None
elastic_config = searchendpoints['elastic'] if searchendpoints and "elastic" in searchendpoints else None
self.headers_sparql = {
"Content-Type": sparql_config['Content-Type'] if sparql_config and 'Content-Type' in sparql_config
else "text/plain",
"Accept": sparql_config['Accept'] if sparql_config and 'Accept' in sparql_config
else "application/sparql-results+json"
}
self.headers_elastic = {
"Content-Type": elastic_config['Content-Type'] if elastic_config and 'Content-Type' in elastic_config
else "application/json",
"Accept": elastic_config['Accept'] if elastic_config and 'Accept' in elastic_config
else "application/json"
}
self.headers_upload = {
"Accept": files_upload_config.pop("Accept"),
}
self.headers_download = {
"Accept": files_download_config.pop("Accept")
}
if token is not None:
nexus.config.set_token(token)
self.headers["Authorization"] = "Bearer " + token
self.headers_sparql["Authorization"] = "Bearer " + token
self.headers_elastic["Authorization"] = "Bearer " + token
self.headers_upload["Authorization"] = "Bearer " + token
self.headers_download["Authorization"] = "Bearer " + token
self.context = Context(self.get_project_context())
self.url_base_files = "/".join((self.endpoint, "files"))
self.url_files = "/".join((self.url_base_files, quote_plus(org), quote_plus(prj)))
self.url_resources = "/".join((self.endpoint, "resources", quote_plus(org), quote_plus(prj)))
self.url_resolver = "/".join((self.endpoint,"resolvers", quote_plus(org), quote_plus(prj)))
self.metadata_context = Context(recursive_resolve(self.store_context, self.resolve_context), store_context)
sparql_view = sparql_config['endpoint'] if sparql_config and "endpoint" in sparql_config else self.default_sparql_index
elastic_view = elastic_config['endpoint'] if elastic_config and "endpoint" in elastic_config else self.default_es_index
self.sparql_endpoint = dict()
self.elastic_endpoint = dict()
self.sparql_endpoint["endpoint"] = "/".join((self.endpoint, "views", quote_plus(org), quote_plus(prj), quote_plus(sparql_view), "sparql"))
self.sparql_endpoint["type"] = "sparql"
self.elastic_endpoint["endpoint"] = "/".join((self.endpoint, "views", quote_plus(org), quote_plus(prj), quote_plus(elastic_view), "_search"))
self.elastic_endpoint["type"] = "elastic"
# The following code is for async to work on jupyter notebooks
try:
asyncio.get_event_loop()
nest_asyncio.apply()
except RuntimeError:
pass