def get(self):
client = NanopubClient()
type_of_search = self.get_argument('type_of_search')
if type_of_search == 'text':
search_str = self.get_argument('search_str')
print('Searching for', search_str)
results = client.find_nanopubs_with_text(search_str)
elif type_of_search == 'pattern':
subj = self.get_argument('subj')
pred = self.get_argument('pred')
obj = self.get_argument('obj')
print('Searching for pattern', subj, pred, obj)
results = client.find_nanopubs_with_pattern(subj=subj,
pred=pred,
obj=obj)
elif type_of_search == 'things':
thing_type = self.get_argument('thing_type')
searchterm = self.get_argument('searchterm')
print('Searching for "thing"', thing_type, searchterm)
if not searchterm:
searchterm = ' '
results = client.find_things(thing_type=thing_type,
searchterm=searchterm)
else:
raise ValueError(f'Unrecognized type_of_search, {type_of_search}')
ret = json.dumps(list(results))
self.finish(ret)
def main(orcid_id, publish, name, keypair: Union[Tuple[Path, Path], None]):
"""
Interactive CLI to create a user profile.
Args:
orcid_id: the users ORCID iD or other form of universal identifier. Example:
`https://orcid.org/0000-0000-0000-0000`
publish: if True, profile will be published to nanopub servers
name: the name of the user
keypair: a tuple containing the paths to the public and private RSA key to be used to sign
nanopubs. If empty, new keys will be generated.
"""
click.echo('Setting up nanopub profile...')
if not USER_CONFIG_DIR.exists():
USER_CONFIG_DIR.mkdir()
if not keypair:
if _rsa_keys_exist():
if _check_erase_existing_keys():
_delete_keys()
JavaWrapper.make_keys(path_name=DEFAULT_KEYS_PATH_PREFIX)
click.echo(f'Your RSA keys are stored in {USER_CONFIG_DIR}')
else:
JavaWrapper.make_keys(path_name=DEFAULT_KEYS_PATH_PREFIX)
click.echo(f'Your RSA keys are stored in {USER_CONFIG_DIR}')
else:
public_key_path, private_key = keypair
# Copy the keypair to the default location
shutil.copy(public_key_path, USER_CONFIG_DIR / PUBLIC_KEY_FILE)
shutil.copy(private_key, USER_CONFIG_DIR / PRIVATE_KEY_FILE)
click.echo(f'Your RSA keys have been copied to {USER_CONFIG_DIR}')
# Public key can always be found at DEFAULT_PUBLIC_KEY_PATH.
# Either new keys have been generated there or
# existing keys have been copy to that location.
public_key = DEFAULT_PUBLIC_KEY_PATH.read_text()
profile = Profile(orcid_id, name, DEFAULT_PUBLIC_KEY_PATH,
DEFAULT_PRIVATE_KEY_PATH)
store_profile(profile)
# Declare the user to nanopub
if publish:
assertion, concept = _create_this_is_me_rdf(orcid_id, public_key, name)
np = Publication.from_assertion(assertion,
introduces_concept=concept,
assertion_attributed_to=orcid_id)
client = NanopubClient()
result = client.publish(np)
profile.nanopub_uri = result['concept_uri']
# Store profile nanopub uri
store_profile(profile)
def test_find_nanopubs_with_text_prod(self):
"""
Check that Nanopub text search is returning results for a few common search terms on the
production nanopub server
"""
prod_client = NanopubClient()
searches = ['test', 'US']
for search in searches:
results = prod_client.find_nanopubs_with_text(search)
assert len(results) > 0
def __init__(
self,
db_nano_pub: Nanopublication,
settings: dict = None,
np_client: NanopubClient = None,
from_db_rdf: bool = False,
):
self.dbnanopub = db_nano_pub
# fetch Publication for published nanopub
nanopub = None
if np_client != None and self.dbnanopub.publication_info != None:
nanopub = np_client.fetch(uri=db_nano_pub.publication_info.nanopub_uri)
elif from_db_rdf and self.dbnanopub.rdf_raw != None:
nanopub_rdf = rdflib.ConjunctiveGraph()
nanopub_rdf.parse(data=self.dbnanopub.rdf_raw, format="trig")
nanopub = Publication(rdf=nanopub_rdf)
if nanopub != None and self.dbnanopub.publication_info != None:
nanopub.rdf.bind(
"", rdflib.Namespace(self.dbnanopub.publication_info.nanopub_uri + "#")
)
super().__init__(
url=self.dbnanopub.protocol.uri,
author=self.dbnanopub.author,
derived_from=self.derived_from,
settings=settings,
nanopub=nanopub,
)
def __init__(
self,
workflow: Workflow,
settings: dict = None,
np_client: NanopubClient = None,
):
self.workflow = workflow
worflow_nanopub = None
if self.workflow.rdf != None:
workflow_nanopub_rdf = rdflib.ConjunctiveGraph()
workflow_nanopub_rdf.parse(data=self.workflow.rdf, format="trig")
worflow_nanopub = Publication(rdf=workflow_nanopub_rdf)
elif np_client != None:
worflow_nanopub = np_client.fetch(
uri=self.workflow.publication_info["nanopub_uri"])
else:
raise "Can't build rdf from workflow passed"
worflow_nanopub.rdf.bind(
"",
rdflib.Namespace(self.workflow.publication_info["nanopub_uri"] +
"#"))
super().__init__(author=self.workflow.author,
derived_from=[],
nanopub=worflow_nanopub)
def test_nanopub_publish(self):
test_concept = rdflib.term.BNode('test')
test_published_uri = 'http://www.example.com/my-nanopub'
expected_concept_uri = 'http://www.example.com/my-nanopub#test'
client = NanopubClient()
client.java_wrapper.publish = mock.MagicMock(
return_value=test_published_uri)
assertion_rdf = rdflib.Graph()
assertion_rdf.add((test_concept, namespaces.HYCL.claims,
rdflib.Literal('This is a test')))
nanopub = Publication.from_assertion(
assertion_rdf=assertion_rdf,
introduces_concept=test_concept,
)
pubinfo = client.publish(nanopub)
assert pubinfo['nanopub_uri'] == test_published_uri
assert pubinfo['concept_uri'] == expected_concept_uri
def get(self):
client = NanopubClient()
np_uri = self.get_argument('np_uri')
print('Fetching nanopub from', np_uri)
# Fetch the nanopub at the given URI
np = client.fetch(np_uri)
print(np)
# Look for first step (if exists)
first_step_URI = self.get_first_step(np.rdf)
if first_step_URI is not None:
step_URIs = [first_step_URI]
step_URIs += self.get_subsequent_steps(np.rdf)
steps = []
for step_uri in step_URIs:
print(step_uri, type(step_uri))
step_np = client.fetch(step_uri)
steps.append({
'nanopubURI':
step_uri,
'description':
self.get_step_from_nanopub(step_np.rdf, step_uri)
})
else:
# If not a workflow, return the step description in this NP
print('No first step found - assuming this np describes a step')
steps = [{
'nanopubURI': np_uri,
'description': self.get_step_from_nanopub(np.rdf, np_uri)
}]
ret = json.dumps(steps)
self.finish(ret)
def test_retract_without_force(self, mock_get_public_key):
test_uri = 'http://www.example.com/my-nanopub'
test_public_key = 'test key'
client = NanopubClient()
client.java_wrapper.publish = mock.MagicMock()
# Return a mocked to-be-retracted publication object that is signed with public key
mock_publication = mock.MagicMock()
mock_publication.pubinfo = rdflib.Graph()
mock_publication.pubinfo.add(
(rdflib.URIRef(test_uri + '#sig'), namespaces.NPX.hasPublicKey,
rdflib.Literal(test_public_key)))
client.fetch = mock.MagicMock(return_value=mock_publication)
# Retract should be successful when public keys match
mock_get_public_key.return_value = test_public_key
client.retract(test_uri)
# And fail if they don't match
mock_get_public_key.return_value = 'Different public key'
with pytest.raises(AssertionError):
client.retract(test_uri)
def test_retract_with_force(self):
client = NanopubClient()
client.java_wrapper.publish = mock.MagicMock()
client.retract('http://www.example.com/my-nanopub', force=True)
def test_nanopub_claim(self):
client = NanopubClient()
client.java_wrapper.publish = mock.MagicMock()
client.claim(statement_text='Some controversial statement')
from unittest import mock
import pytest
import rdflib
from conftest import skip_if_nanopub_server_unavailable
from nanopub import NanopubClient, namespaces, Publication
client = NanopubClient(use_test_server=True)
TEST_ASSERTION = (namespaces.AUTHOR.DrBob, namespaces.HYCL.claims,
rdflib.Literal('This is a test'))
class TestNanopubClient:
@pytest.mark.flaky(max_runs=10)
@skip_if_nanopub_server_unavailable
def test_find_nanopubs_with_text(self):
"""
Check that Nanopub text search is returning results for a few common search terms
"""
searches = ['test', 'US']
for search in searches:
results = client.find_nanopubs_with_text(search)
assert len(results) > 0
assert len(client.find_nanopubs_with_text('')) == 0
@pytest.mark.flaky(max_runs=10)
def test_find_nanopubs_with_text_prod(self):