ose-plugin-hbcp 0.2.5__py3-none-any.whl

ose_plugin_hbcp/__init__.py

@@ -0,0 +1,11 @@
+from ose.model.Plugin import Plugin
+
+
+HBCPPlugin = Plugin(
+    id="org.bssofoundry.hbcp",
+    name="HBCP Plugin",
+    version="0.1.0",
+    description="Plugin for HBCP services and workflows. Provides common functionality for derived plugins.",
+    contents=[],
+    components=[],
+)

ose_plugin_hbcp/search_api/APIClient.py

@@ -0,0 +1,351 @@
+import abc
+import asyncio
+import json
+import logging
+import re
+import urllib
+from abc import ABCMeta
+from itertools import groupby
+from typing import Union, List, Literal, Optional, Dict, Tuple, Any, TypeVar
+
+import aiohttp
+import async_lru
+from attr import dataclass
+
+from ose.model.Result import Result
+from ose.model.Term import Term
+from ose.model.TermIdentifier import TermIdentifier
+from .HttpError import HttpError
+
+T = TypeVar('T')
+
+
+@dataclass
+class APIPage:
+    items: List[T]
+    page: int
+    total_items: int
+    next_page: int
+    first_page: int
+    last_page: int
+
+
+class APIClient(abc.ABC, metaclass=ABCMeta):
+    _logger = logging.getLogger(__name__)
+
+    _term_link_to_relation_mapping: Dict[str, Tuple[TermIdentifier, Literal["single", "multiple", "multiple-per-line"]]]
+
+    def __init__(self, api_url: str, session: aiohttp.ClientSession, auth_token: Optional[str] = None, debug=False):
+        self._auth_token = auth_token
+        self._base = api_url
+        self._session = session
+        self._default_params = {"test": "1"} if debug else {}
+
+    def _request(self,
+                 sub_url: Union[str, List[str]],
+                 method: Literal["get", "post", "put", "patch", "delete"],
+                 data: Optional[Dict] = None,
+                 headers: Optional[Dict] = None,
+                 query_params: Optional[Dict[str, str]] = None) -> aiohttp.client._RequestContextManager:
+        if data is None:
+            data = {}
+        if headers is None:
+            headers = {}
+        if query_params is None:
+            query_params = {} if method == "get" else self._default_params
+
+        default_headers = {
+            "accept": "application/ld+json",
+            "Content-Type": "application/ld+json"
+        }
+
+        if self._auth_token is not None:
+            default_headers["X-AUTH-TOKEN"] = self._auth_token
+
+        url = self._base
+        if isinstance(sub_url, list):
+            url = urllib.parse.urljoin(url, "/".join(sub_url))
+        else:
+            url = urllib.parse.urljoin(url, sub_url)
+
+        query_string = urllib.parse.urlencode(query_params)
+        if query_string != "":
+            url += "?" + query_string
+
+        headers = {**default_headers, **headers}
+        if method != "get":
+            self._logger.info(f"{method} {json.dumps(data)}")
+
+            # return self._session.request("get", "https://example.com/")
+        # else:
+        return self._session.request(method, url, headers=headers, json=data)
+
+    def convert_to_api_term(self, term: Term, with_references=True) -> Dict:
+        data = {
+            "id": term.id.strip(),
+            "uri": f"/terms/{term.id.strip()}",
+            "label": term.label.strip(),
+            **dict([(k,
+                     (((lambda x: x) if multiplicity == "multiple" else "\n".join)(term.get_relation_values(i)))
+                     if multiplicity.startswith("multiple") else term.get_relation_value(i))
+                    for k, (i, multiplicity) in self._term_link_to_relation_mapping.items()]),
+        }
+
+        if data['curationStatus'] in ['To Be Discussed', 'In Discussion', None]:
+            data['curationStatus'] = 'Proposed'
+
+        definition_source = self._merge_definition_source_and_id(term)
+        if definition_source:
+            data["definitionSource"] = definition_source
+
+        data['eCigO'] = data.get('eCigO', 'false') in ["True", "true", "TRUE", "1"]
+        data['fuzzySet'] = data.get('fuzzySet', 'false') in ["True", "true", "TRUE", "1"]
+
+        if data.get('curationStatus', None) is None:
+            data['curationStatus'] = "Proposed"
+        data['curationStatus'] = data['curationStatus'].lower()
+
+        if with_references:
+            def key_fn(r: Union[Tuple[TermIdentifier, Any], TermIdentifier]) -> str:
+                return (r[0] if isinstance(r, tuple) else r).label
+
+            relations: List[Tuple[TermIdentifier, TermIdentifier]] = [(r, v) for r, v in term.relations if
+                                                                      isinstance(v, TermIdentifier) and v.is_resolved()]
+            relations.sort(key=key_fn)
+
+            data = {
+                **data,
+                "parentTerm": f"/terms/{term.sub_class_of[0].id}",
+                "logicalDefinition": next(iter(term.equivalent_to), None),
+                "termLinks": [{
+                    "type": r,
+                    "linkedTerms": [f"/terms/{e[1].id}" for e in g]
+                } for r, g in groupby(relations, key_fn)]
+            }
+
+        return data
+
+    async def convert_from_api_term(self, data: Dict, with_references=True) -> Term:
+        rev = data["termRevisions"][0]
+
+        i: str = data["id"]
+        label: str = rev["label"]
+
+        parent_term = rev.get("parentTerm", None)
+        parents: List[TermIdentifier] = [TermIdentifier(id=parent_term.split("/")[-1])] if parent_term else []
+
+        logical_definition = rev.get("logicalDefinition", None)
+        equivalent_to: List[str] = [logical_definition] if logical_definition else []
+
+        disjoint_with = []
+
+        relations: List[Tuple[TermIdentifier, Any]] = []
+        if with_references:
+            async with self._request([rev["@id"], "term_links"], "get") as response:
+                term_links = (await response.json())["hydra:member"]
+                relations = [
+                    (TermIdentifier(label=link["type"]),
+                     TermIdentifier(linked["id"], linked["termRevisions"][0]["label"]))
+                    for link in term_links
+                    for linked in link["linkedTerms"]
+                ]
+
+        relations += [(identifier, v)
+                      for key, (identifier, multiplicity) in self._term_link_to_relation_mapping.items() if key in rev
+                      for v in (
+                          ((lambda x: x) if multiplicity == "multiple" else str.splitlines)(rev[key])
+                          if multiplicity.startswith("multiple") else [rev[key]])
+                      ]
+
+        relations += [(identifier, v)
+                      for key, (identifier, multiplicity) in self._term_link_to_relation_mapping.items() if
+                      key in data and key not in rev
+                      for v in (
+                          ((lambda x: x) if multiplicity == "multiple" else str.splitlines)(data[key])
+                          if multiplicity.startswith("multiple") else [data[key]])
+                      ]
+        definition_source = rev.get("definitionSource", None)
+        if definition_source is not None:
+            parts = definition_source.split("\n")
+            if len(parts) == 1:
+                relations.append((TermIdentifier(id="IAO:0000119", label="definition source"), parts[0]))
+            elif len(parts) == 2:
+                relations += [
+                    (TermIdentifier(id="rdfs:isDefinedBy", label="rdfs:isDefinedBy"), parts[0]),
+                    (TermIdentifier(id="IAO:0000119", label="definition source"), parts[1])
+                ]
+
+        return Term(i, label, ("web", -1), relations, parents, equivalent_to, disjoint_with)
+
+    @async_lru.alru_cache(maxsize=None)
+    async def _get_term(self, term: str) -> Optional[Dict]:
+        async with self._request(["terms", term], "get") as r:
+            if r.status == 404:
+                return None
+
+            if not r.ok:
+                raise HttpError(r.status,
+                                f"{r.status}, message={r.reason!r}, url={r.request_info.real_url!r}",
+                                await r.json())
+
+            return await r.json()
+
+    async def get_term(self, term: Union[Term, str, TermIdentifier], with_references=True) -> Optional[Term]:
+        term_id = term.id if isinstance(term, Term) or isinstance(term, TermIdentifier) else term
+
+        data = await self._get_term(term_id)
+
+        if data is None:
+            return None
+
+        return await self.convert_from_api_term(data, with_references)
+
+    async def create_term(self, term: Term):
+        data = self.convert_to_api_term(term)
+
+        async with self._request("terms", "post", data) as r:
+            if not r.ok:
+                raise HttpError(r.status,
+                                f"{r.status}, message={r.reason!r}, url={r.request_info.real_url!r}",
+                                await r.json())
+
+    async def declare_term(self, term: Union[Term, TermIdentifier]) -> Result[Union[bool]]:
+        exists = (await self.get_term(term, with_references=False)) is not None
+        if exists:
+            return Result(False)
+
+        data = self.convert_to_api_term(term, False)
+
+        async with self._request("terms", "post", data) as r:
+
+            if not r.ok:
+                result = Result()
+                error = await r.text()
+                result.error(status_code=r.status, body=error)
+                self._logger.error(f"Failed to declare term '{term.label} ({term.id})': {error}")
+                return result
+
+            return Result(True)
+
+    async def update_term(self, term: Term, msg: str, with_references=True):
+        existing = await self.get_term(term, with_references)
+        if existing is not None:
+            if not self.terms_equal(existing, term):
+                api_term = self.convert_to_api_term(term)
+                api_term['revisionMessage'] = msg
+
+                async with self._request(["terms", term.id], "put", api_term, headers={
+                    "Content-Type": "application/json"
+                }) as r:
+                    if not r.ok:
+                        raise HttpError(r.status,
+                                        f"{r.status}, message={r.reason!r}, url={r.request_info.real_url!r}",
+                                        await r.json())
+
+    def delete_term(self, term: Union[Term, str, TermIdentifier]):
+        pass
+
+    def _merge_definition_source_and_id(self, term: Term) -> Optional[str]:
+        defined_by = term.get_relation_value(TermIdentifier(id="rdfs:isDefinedBy", label="rdfs:isDefinedBy"))
+        definition_source = term.get_relation_value(TermIdentifier(id="IAO:0000119", label="definition source"))
+        return "\n".join(d for d in [defined_by, definition_source] if d is not None)
+
+    def _terms_equal(self, ignore_if_not_exists: List[str], new: Term, old: Term):
+        def value_eq(v1, v2) -> bool:
+            if isinstance(v1, bool):
+                return (str(v2).lower().strip() in ['true', '1']) == v1
+            if isinstance(v2, bool):
+                return (str(v1).lower().strip() in ['true', '1']) == v2
+            if isinstance(v1, str) and isinstance(v2, str):
+                return v1.lower().strip() == v2.lower().strip()
+            if v1 is None and v2 == 'None' or v2 is None and v1 == 'None':
+                return True
+
+            if isinstance(v1, TermIdentifier) and isinstance(v2, TermIdentifier):
+                if v1.id is None or v2.id is None:
+                    return v1.label == v2.label
+                else:
+                    return v1.id == v2.id
+            if isinstance(v1, list) and isinstance(v2, list):
+                return len(v1) == len(v2) and all(any(value_eq(x1, x2) for x2 in v2) for x1 in v1)
+
+            return v1 == v2
+
+        result = True
+        relations_old = dict(
+            [(k, [e[1] for e in g]) for k, g in groupby(sorted(old.relations), key=lambda x: x[0].label)])
+        relations_new = dict(
+            [(k, [e[1] for e in g]) for k, g in groupby(sorted(new.relations), key=lambda x: x[0].label)])
+        for r, v in relations_old.items():
+            if r in ["rdfs:isDefinedBy", "definition source", "example of usage"]:
+                continue
+
+            if r in relations_new:
+                if not value_eq(relations_new[r], v):
+                    self._logger.debug(f"DIFF <{r}>:\n  {v}\n  {relations_new[r]}")
+                    result = False
+            else:
+                if r not in ignore_if_not_exists:
+                    self._logger.debug(f"DELETED <{r}>: {v}")
+                    result = False
+        for r, v in relations_new.items():
+            if r in ["rdfs:isDefinedBy", "definition source"]:
+                continue
+
+            if r not in relations_old:
+                if r not in ignore_if_not_exists:
+                    self._logger.debug(f"CREATED <{r}>: {v}")
+                    result = False
+        old_definition_source = self._merge_definition_source_and_id(old)
+        new_definition_source = self._merge_definition_source_and_id(new)
+        if not (value_eq(old_definition_source, new_definition_source)):
+            self._logger.debug(f"DIFF <definitionSource>\n  {[old_definition_source]}\n  {[new_definition_source]}")
+            result = False
+        old_examples = old.get_relation_values(TermIdentifier(label="example of usage"))
+        new_examples = new.get_relation_values(TermIdentifier(label="example of usage"))
+        if isinstance(old_examples, list):
+            old_examples = "\n".join(old_examples)
+        if isinstance(new_examples, list):
+            new_examples = "\n".join(new_examples)
+        if not (value_eq(old_examples, new_examples)):
+            self._logger.debug(f"DIFF <examples>\n  {[old_examples]}\n  {[new_examples]}")
+            result = False
+        if not (old.id == new.id):
+            self._logger.debug(f"DIFF <id>\n  {old.id}\n  {new.id}")
+            result = False
+        if not (value_eq(old.label, new.label)):
+            self._logger.debug(f"DIFF <label>\n  {old.label}\n  {new.label}")
+            result = False
+        if not (value_eq(old.sub_class_of, new.sub_class_of)):
+            self._logger.debug(f"DIFF <sub_class_of>\n  {old.sub_class_of}\n  {new.sub_class_of}")
+            result = False
+        if not (value_eq(old.equivalent_to, new.equivalent_to)):
+            self._logger.debug(f"DIFF <equivalent_to>\n  {old.equivalent_to}\n  {new.equivalent_to}")
+            result = False
+        # # Apparently this is not used by BCIOSearch
+        # if not (value_eq(old.disjoint_with, new.disjoint_with)):
+        #     self._logger.debug(f"DIFF <disjoint_with>\n  {old.disjoint_with}\n  {new.disjoint_with}")
+        #     result = False
+        return result
+
+    async def get_terms(self, page: int, items_per_page: int = 50) -> APIPage:
+        r = await self._request(f"/terms?page={page}&itemsPerPage={items_per_page}", "get")
+
+        r.raise_for_status()
+
+        data = await r.json()
+
+        view = data.get("hydra:view", dict())
+        next_page_m = re.search(r"page=(\d+)", view.get("hydra:next", ""))
+        next_page = int(next_page_m.group(1)) if next_page_m is not None else None
+        first_page_m = re.search(r"page=(\d+)", view.get("hydra:first", ""))
+        first_page = int(first_page_m.group(1)) if first_page_m is not None else None
+        last_page_m = re.search(r"page=(\d+)", view.get("hydra:last", ""))
+        last_page = int(last_page_m.group(1)) if last_page_m is not None else None
+
+        total_items = data.get("hydra:totalItems", -1)
+
+        items = await asyncio.gather(
+            *(self.convert_from_api_term(term, False) for term in data.get("hydra:member", [])))
+
+        return APIPage(items, page, total_items, next_page, first_page, last_page)

ose_plugin_hbcp/search_api/APIService.py

@@ -0,0 +1,191 @@
+import abc
+import asyncio
+import logging
+from typing import List, Callable, Optional, Tuple
+
+import pyhornedowl
+
+from ose.services.ConfigurationService import ConfigurationService
+from .APIClient import APIClient
+from .HttpError import HttpError
+from ose.model.ExcelOntology import ExcelOntology
+from ose.model.Result import Result
+from ose.model.Term import Term
+from ose.model.TermIdentifier import TermIdentifier
+from ose.utils import lower
+
+
+class APIService[T: APIClient](abc.ABC):
+    _config: ConfigurationService
+    _logger: logging.Logger
+    _api_client: T
+
+    def __init__(self, config: ConfigurationService, api_client: T):
+        self._config = config
+        self._api_client = api_client
+
+    @property
+    @abc.abstractmethod
+    def repository_name(self) -> str: ...
+
+    async def update_api(
+        self,
+        ontology: ExcelOntology,
+        external_ontologies: List[str],
+        revision_message: str,
+        update_fn: Optional[Callable[[int, int, str], None]] = None,
+    ) -> Result[Tuple]:
+        self._logger.info("Starting update")
+        result = Result()
+
+        config = self._config.get(self.repository_name)
+
+        if config is None:
+            self._logger.error(f"No config for repository '{self.repository_name}'!")
+
+        external_ontologies_loaded = []
+        for external in external_ontologies:
+            ext_ontology = pyhornedowl.open_ontology(external)
+
+            if config is not None:
+                for prefix, iri in config.prefixes.items():
+                    ext_ontology.prefix_mapping.add_prefix(prefix, iri)
+
+            external_ontologies_loaded.append(ext_ontology)
+
+        external_classes = [(o, o.get_classes()) for o in external_ontologies_loaded]
+        total = sum(len(classes) for o, classes in external_classes) + len(ontology.terms())
+        step = 0
+
+        queue: List[Term] = []
+
+        # edit lock for modifying the queue or counters
+        lock = asyncio.Lock()
+
+        # Only allow 5 concurrent calls to the API
+        sem = asyncio.Semaphore(5)
+
+        async def handle_external(o: pyhornedowl.PyIndexedOntology, term_iri: str):
+            nonlocal step, total
+            async with sem:
+                async with lock:
+                    step += 1
+
+                    if update_fn:
+                        update_fn(step, total, f"External - {term_iri}")
+
+                term_id = o.get_id_for_iri(term_iri)
+                if term_id is None:
+                    self._logger.warning(f"Term has no id {term_iri}")
+                    return
+
+                term = ontology.term_by_id(term_id)
+                if term is None:
+                    ext_label = o.get_annotation(term_iri, "http://www.w3.org/2000/01/rdf-schema#label")
+                    ext_definition = o.get_annotation(term_iri, "http://purl.obolibrary.org/obo/IAO_0000115")
+                    if ext_definition is None:
+                        ext_definition = o.get_annotation(term_iri, "http://purl.obolibrary.org/obo/IAO_0000600")
+                    if ext_definition is None:
+                        ext_definition = "no definition provided for external entity"
+                        result.warning(
+                            type="external-no-definition",
+                            msg="No definition was provided for the external "
+                            + f"entity '{ext_label}' ({term_id}). Using default instead.",
+                        )
+
+                    if ext_label is None:
+                        result.warning(
+                            type="external-no-label", msg=f'The external term "{term_id}" has no label. Skipping it'
+                        )
+                        return
+
+                    ext_parents = o.get_superclasses(term_iri)
+                    # If multiple parents check if they are (immediate) subclasses of each other and only take the most
+                    # specific parent.
+                    ext_parents -= set().union(*[o.get_ancestors(i) for i in ext_parents])
+                    ext_parents = [TermIdentifier(id=o.get_id_for_iri(cls)) for cls in ext_parents]
+                    ext_parents = [p for p in ext_parents if p.id is not None]
+
+                    if len(ext_parents) == 0:
+                        self._logger.warning(f"External term has no parents: {term_id}")
+                        return
+                    if len(ext_parents) > 1:
+                        self._logger.warning(
+                            f"Multiple parents defined for external term: {term_id}."
+                            "Using only the lexicographical first entry."
+                        )
+                        ext_parents = [sorted(ext_parents)[0]]
+
+                    ext_relations = [
+                        (TermIdentifier("IAO:0000115", "definition"), ext_definition),
+                        (TermIdentifier("IAO:0000114", "has curation status"), "External"),
+                    ]
+                    ext_term = Term(term_id, ext_label, ("<external>", -1), ext_relations, ext_parents, [], [])
+
+                    await self._api_client.declare_term(ext_term)
+
+                    async with lock:
+                        queue.append(ext_term)
+                        total += 1
+                else:
+                    await self._api_client.declare_term(term)
+
+                    async with lock:
+                        queue.append(term)
+                        total += 1
+
+        tasks = [handle_external(o, term_iri) for o, classes in external_classes for term_iri in classes]
+        await asyncio.gather(*tasks)
+
+        async def declare_term(term: Term):
+            nonlocal step, total
+            async with sem:
+                async with lock:
+                    step += 1
+
+                    if update_fn:
+                        update_fn(step, total, f"declaring '{term.label}' ({term.id})")
+
+                if lower(term.curation_status()) in ["obsolete", "pre-proposed"]:
+                    self._logger.info(f"Skipping {term.curation_status()} term '{term.label}'")
+                else:
+                    await self._api_client.declare_term(term)
+
+                    async with lock:
+                        queue.append(term)
+                        total += 1
+
+        tasks = [declare_term(term) for term in ontology.terms()]
+        await asyncio.gather(*tasks)
+
+        async def work_queue(term: Term):
+            nonlocal step
+            async with sem:
+                async with lock:
+                    step += 1
+
+                    if update_fn:
+                        update_fn(step, total, f"updating '{term.label}' ({term.id})")
+
+                try:
+                    await self._api_client.update_term(term, revision_message)
+                except HttpError as e:
+                    result.error(type="http-error", details=e.message, response=e.response)
+
+        tasks = [work_queue(term) for term in queue]
+        await asyncio.gather(*tasks)
+
+        result.value = ()
+        return result
+
+    async def get_all_terms(self) -> List[Term]:
+        next_page = 1
+        items = []
+
+        while next_page is not None:
+            page = await self._api_client.get_terms(next_page)
+
+            items.extend(page.items)
+            next_page = page.next_page
+
+        return items

ose_plugin_hbcp/search_api/HttpError.py

@@ -0,0 +1,9 @@
+import dataclasses
+from typing import Any
+
+
+@dataclasses.dataclass
+class HttpError(Exception):
+    status_code: int
+    message: str
+    response: Any

ose_plugin_hbcp-0.2.5.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: ose-plugin-hbcp
+Version: 0.2.5
+Summary: OntoSpreadEd plugin for HBCP common services
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: ose-core==0.2.5
+
+# OSE Plugin: HBCP
+
+OntoSpreadEd plugin for HBCP (Human Behaviour Change Project) services.
+
+## Description
+
+This plugin provides common functionality for HBCP-related ontology projects. It serves as a base plugin with shared services used by derived plugins like AddictO and BCIO.
+
+Features:
+- Search API client for external vocabulary services
+- HTTP error handling utilities
+- Common service infrastructure
+
+## Installation
+
+```bash
+pip install ose-plugin-hbcp
+```
+
+## Requirements
+
+- Python 3.12+
+- ose-core
+
+## License
+
+LGPL-3.0-or-later

ose_plugin_hbcp-0.2.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+ose_plugin_hbcp/__init__.py,sha256=z4YuujZ0zcVLHuMlgXkJOtKJNusl-57jPiMom_712JM,283
+ose_plugin_hbcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ose_plugin_hbcp/search_api/APIClient.py,sha256=Kl1Xck06FCbQ2V8vlSZAQi7QYfHlwnymAXmW4C-iQyE,15239
+ose_plugin_hbcp/search_api/APIService.py,sha256=2zYhciN5oM4Bng-wmsOmVij6OoWKdzDUgMWbMCpAh54,7303
+ose_plugin_hbcp/search_api/HttpError.py,sha256=UhSsF47PX7XEuHCFaGwUi4IFSlWJ3YJRndJTlhnc_ww,151
+ose_plugin_hbcp/search_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ose_plugin_hbcp-0.2.5.dist-info/METADATA,sha256=hhPJcV8WTHBaKzPDVj9cslyW5GuEh2ZgK4YGrjHNwbo,752
+ose_plugin_hbcp-0.2.5.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+ose_plugin_hbcp-0.2.5.dist-info/top_level.txt,sha256=7QS5dsHVKSRq0_1ibGbZbFS292DMDHDCyY_pSd34fkg,16
+ose_plugin_hbcp-0.2.5.dist-info/RECORD,,

ose_plugin_hbcp-0.2.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ose_plugin_hbcp-0.2.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+ose_plugin_hbcp