API: removed unneeded pragma: no cover comments

Author: AlexanderWatzinger

openatlas/api/endpoints/endpoint.py

@@ -264,8 +264,7 @@ def get_entities_formatted(self) -> None:
                 self.formated_entities = [
                     self.get_linked_places_entity(_id)
                     for _id in self.entities_with_links]
-            case _ if self.parser.format \
-                      in app.config['RDF_FORMATS']:  # pragma: no cover
+            case _ if self.parser.format in app.config['RDF_FORMATS']:
                 license_links = get_license_ids_with_links()
                 parsed_context = parse_loud_context()
                 self.generator_entities = (

openatlas/api/endpoints/file.py

@@ -15,8 +15,8 @@
 from openatlas.api.resources.parser import files, image
 from openatlas.api.resources.resolve_endpoints import download
 from openatlas.api.resources.templates import licensed_file_template
-from openatlas.api.resources.util import get_iiif_manifest_and_path, \
-    get_license_name
+from openatlas.api.resources.util import (
+    get_iiif_manifest_and_path, get_license_name)
 from openatlas.database.overlay import get_by_object
 from openatlas.display.util import (
     check_iiif_activation, check_iiif_file_exist, get_file_path)
@@ -118,10 +118,11 @@ def get() -> Response:
     def get_file_dict(
             entity: Entity,
             overlay: Optional[Overlay] = None) -> dict[str, Any]:
-        path = get_file_path(entity.id)
+        url = 'N/A'
         mime_type = None
-        if path:
-            mime_type, _ = mimetypes.guess_type(path)  # pragma: no cover
+        if path := get_file_path(entity.id):
+            url = url_for('api.display', filename=path.stem, _external=True)
+            mime_type, _ = mimetypes.guess_type(path)
         data = {
             'id': entity.id,
             'title': entity.name,
@@ -130,10 +131,7 @@ def get_file_dict(
             'licenseHolder': entity.license_holder,
             'publicShareable': entity.public,
             'mimetype': mime_type,
-            'url': url_for(
-                'api.display',
-                filename=path.stem,
-                _external=True) if path else 'N/A'}
+            'url': url}
         data.update(get_iiif_manifest_and_path(entity.id))
         if overlay:
             data.update({'overlay': overlay.bounding_box})

openatlas/api/external/arche.py

@@ -27,7 +27,7 @@ def is_arche_likeable_uri(uri: str) -> bool:
     for rule in g.arche_uri_rules:
         if search(rule['match'], uri):
             return True
-    return False  # pragma: no cover
+    return False
 
 
 def is_valid_url(url: str) -> bool:
@@ -56,12 +56,9 @@ def create_uri(value: str | list[str]) -> list[URIRef]:
     return [create_single_uri(value)]
 
 
-def ensure_person_exist(
-        graph: Graph,
-        names: str | list[str]) -> None:
+def ensure_person_exist(graph: Graph, names: str | list[str]) -> None:
     names = names if isinstance(names, list) else [names]
     for name in names:
-
         if not name or is_valid_url(name):
             continue  # pragma: no cover
         uri = create_single_uri(name)
@@ -117,13 +114,11 @@ def ensure_entity_exist(
 
 def transliterate_url(url: str) -> str:
     parsed = urlparse(url)
-    path = parsed.path
-    ascii_path = unidecode(path)
-    ascii_path = ascii_path.replace(' ', '_')
+    ascii_path = unidecode(parsed.path)
     return urlunparse((
         parsed.scheme,
         parsed.netloc,
-        ascii_path,
+        ascii_path.replace(' ', '_'),
         parsed.params,
         parsed.query,
         parsed.fragment))

openatlas/api/formats/linked_places.py

@@ -1,20 +1,18 @@
 from __future__ import annotations
 
 import mimetypes
-from typing import Any, Optional, TYPE_CHECKING
+from typing import Any, Optional
 
 from flask import g, url_for
 
+from openatlas.api.endpoints.parser import Parser
 from openatlas.api.resources.util import (
     date_to_str, get_crm_relation, get_crm_relation_label_x,
     get_crm_relation_x, get_iiif_manifest_and_path, get_license_name,
     to_camel_case)
 from openatlas.display.util import get_file_path
 from openatlas.models.entity import Entity, Link
 
-if TYPE_CHECKING:  # pragma: no cover
-    from openatlas.api.endpoints.parser import Parser
-
 
 def link_dict(link_: Link, inverse: bool = False) -> dict[str, Any]:
     return {
@@ -81,10 +79,9 @@ def get_lp_time(entity: Entity | Link) -> Optional[dict[str, Any]]:
 
 
 def get_lp_file(file: Entity) -> dict[str, Any]:
-    path = get_file_path(file.id)
-    url = "N/A"
+    url = 'N/A'
     mime_type = None
-    if path:
+    if path := get_file_path(file.id):
         url = url_for('api.display', filename=path.stem, _external=True)
         mime_type, _ = mimetypes.guess_type(path)
     data = {

openatlas/api/formats/presentation_view.py

@@ -52,10 +52,9 @@ def get_file_dict(
         link: Link,
         overlay: Optional[Overlay] = None,
         root: Optional[bool] = False) -> dict[str, Any]:
-    path = get_file_path(link.domain.id)
     url = 'N/A'
     mime_type = None
-    if path:
+    if path := get_file_path(link.domain.id):
         url_for('api.display', filename=path.stem, _external=True)
         mime_type, _ = mimetypes.guess_type(path)
     data = {

openatlas/api/formats/rdf.py

@@ -30,20 +30,20 @@ def _add_namespaces(graph: Graph, context: dict[str, Any]) -> None:
     graph.bind("rdf", Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#"))
 
 
-def _expand_curie(curie: str) -> str:  # pragma: no cover
+def _expand_curie(curie: str) -> str:
     if ":" not in curie:
-        return curie
+        return curie  # pragma: no cover
     ctx = _linked_art_context.get("@context", {})
     prefix, local = curie.split(":", 1)
     base = ctx.get(prefix)
     if isinstance(base, str):
         return base + local
-    return curie
+    return curie  # pragma: no cover
 
 
 def _resolve_predicate(
         key: str,
-        data_type: str | None = None) -> URIRef | None:  # pragma: no cover
+        data_type: str | None = None) -> URIRef | None:
     ctx = _linked_art_context.get("@context", {})
 
     if data_type and data_type in ctx:
@@ -54,16 +54,15 @@ def _resolve_predicate(
                 entry = tctx[key]
                 if isinstance(entry, dict) and "@id" in entry:
                     return URIRef(_expand_curie(entry["@id"]))
-                if isinstance(entry, str):
+                if isinstance(entry, str):  # pragma: no cover
                     return URIRef(_expand_curie(entry))
 
     entry = ctx.get(key)
     if isinstance(entry, dict) and "@id" in entry:
         return URIRef(_expand_curie(entry["@id"]))
-    if isinstance(entry, str):
+    if isinstance(entry, str):  # pragma: no cover
         return URIRef(_expand_curie(entry))
-
-    return None
+    return None  # pragma: no cover
 
 
 def _get_subject(
@@ -106,41 +105,36 @@ def _add_triples_from_linked_art(
         graph: Graph,
         data: list[dict[str, Any]] | dict[str, Any],
         parent_subject: URIRef | BNode | None = None,
-        parent_predicate: URIRef | None = None) -> None:  # pragma: no cover
-    if not isinstance(data, dict):  # pragma: no cover - mypy
-        return
+        parent_predicate: URIRef | None = None) -> None:
+    if not isinstance(data, dict):
+        return  # pragma: no cover
 
     subject = _get_subject(data, graph, parent_subject, parent_predicate)
-
-    data_type = data.get("type")
-    if data_type:
+    if data_type := data.get("type"):
         ctx = _linked_art_context.get("@context", {})
         type_uri: str | None = None
 
         if ":" in data_type:
-            type_uri = _expand_curie(data_type)
-
+            type_uri = _expand_curie(data_type)  # pragma: no cover
         elif isinstance(ctx.get(data_type), dict):
             entry = ctx[data_type]
             if "@id" in entry:
                 type_uri = _expand_curie(entry["@id"])
 
-        if not type_uri:
+        if not type_uri:  # pragma: no cover
             la_base = ctx.get("la") or "https://linked.art/ns/terms/"
             type_uri = la_base + data_type
 
-        if not type_uri:  # pragma: no cover - mypy
-            return
+        if not type_uri:
+            return  # pragma: no cover
 
         graph.add((subject, RDF.type, URIRef(type_uri)))
 
     for key, value in data.items():
         if key in {"id", "type", "@context"}:
             continue
-
-        predicate = _resolve_predicate(key, data_type)
-        if not predicate:  # pragma: no cover - mypy
-            continue
+        if not (predicate := _resolve_predicate(key, data_type)):
+            continue  # pragma: no cover
 
         _handle_value(graph, subject, predicate, value)
 

openatlas/api/formats/subunits.py

@@ -4,9 +4,8 @@
 from flask import g
 
 from openatlas.api.resources.util import (
-    geometry_to_geojson, get_license_name,
-    get_reference_systems, remove_duplicate_entities,
-    replace_empty_list_values_in_dict_with_none)
+    geometry_to_geojson, get_license_name, get_reference_systems,
+    remove_duplicate_entities, replace_empty_list_values_in_dict_with_none)
 from openatlas.display.util import get_file_path
 from openatlas.models.entity import Entity, Link
 from openatlas.models.gis import Gis

openatlas/api/import_scripts/util.py

@@ -53,19 +53,19 @@ def vocabs_requests(
         parameter: Optional[dict[str, str]] = None) -> dict[str, Any]:
     base = g.settings['vocabs_base_url']
     url = f'{base}{g.settings['vocabs_endpoint']}{id_}/{endpoint}'
-    sleep(0.1)  # fix connection abort
+    sleep(0.1)  # Fix connection abort
     try:
         resp = requests.get(
             url,
             params=parameter or "",
             timeout=60,
             auth=(g.settings['vocabs_user'], app.config['VOCABS_PASS']))
         resp.raise_for_status()
-    except requests.exceptions.RequestException as e:  # pragma: no cover
+    except requests.exceptions.RequestException as e:
         abort(400, f'Request failed for {url}: {e}')
 
     try:
         result = resp.json()
-    except ValueError:  # pragma: no cover
+    except ValueError:
         abort(400, f'Invalid JSON from {url}')
     return result

openatlas/api/import_scripts/vocabs.py

@@ -118,7 +118,7 @@ def import_children(
     children = []
     child = None
     for entry in req['narrower']:
-        if not entry['prefLabel']:  # pragma: no cover
+        if not entry['prefLabel']:
             g.logger.log(
                 'warn',
                 'import',

openatlas/api/resources/templates.py

@@ -310,8 +310,7 @@ def subunit_template(id_: str) -> dict[str, List]:
         'description': fields.String,
         'standardType': fields.Nested(standard_type),
         'timespan': fields.Nested(timespan),
-        'externalReferences': fields.List(
-            fields.Nested(external_references)),
+        'externalReferences': fields.List(fields.Nested(external_references)),
         'references': fields.List(fields.Nested(references)),
         'files': fields.List(fields.Nested(files)),
         'types': fields.List(fields.Nested(types))}