refactor get_info() functions of external reference systems

openatlas/api/external/cadaster.py

@@ -12,7 +12,6 @@ class Cadaster(ExternalApi):  # pylint: disable=too-few-public-methods
     @staticmethod
     def get_info(id_: str, system: Entity) -> dict[str, object]:
         endpoint = 'gst/' if '/' in id_ else 'kgnr/'
-        info = {}
         try:
             data = requests.get(
                 f'https://kataster.bev.gv.at/api/{endpoint}{id_}',
@@ -21,42 +20,44 @@ def get_info(id_: str, system: Entity) -> dict[str, object]:
                 timeout=10).json()
         except Exception:  # pragma: no cover
             return {}
-        try:
-            info['katestralgemeinde'] = data['properties']['kg']
-        except KeyError:  # pragma: no cover
-            pass
-        try:
-            info['bundesland'] = data['properties']['bl']
-        except KeyError:  # pragma: no cover
-            pass
-        try:
-            info['grundstücksnummer'] = data['properties']['gnr']
-        except KeyError:  # pragma: no cover
-            pass
-        try:
-            info['einlagezahl'] = data['properties']['ez']
-        except KeyError:  # pragma: no cover
-            pass
-        try:
-            info['rstatus'] = data['properties']['rstatus']
-        except KeyError:  # pragma: no cover
-            pass
-        try:
+
+        info: dict[str, object] = {}
+
+        if error_msg := data.get('message'):
+            info['Error'] = error_msg
+            return info
+
+        properties = data.get('properties', {})
+
+        if kg := properties.get('kg'):
+            info['katestralgemeinde'] = kg
+
+        if bl := properties.get('bl'):
+            info['bundesland'] = bl  # pragma: no cover
+
+        if gnr := properties.get('gnr'):
+            info['grundstücksnummer'] = gnr
+
+        if ez := properties.get('ez'):
+            info['einlagezahl'] = ez
+
+        if rstatus := properties.get('rstatus'):
+            info['rstatus'] = rstatus
+
+        if nutzungen := properties.get('nutzungen'):
             info['nutzungen'] = [
-                f'Allocation: {usage['nutzung']}, Area: {usage['fl']}m²'
-                for usage in data['properties']['nutzungen']]
-        except KeyError:  # pragma: no cover
-            pass
-        try:
-            geometry = shape(data['geometry']).centroid
-            zoom = '18.1' if '/' in id_ else '12.9'
-            url = f'https://kataster.bev.gv.at/#/center/' \
-                  f'{geometry.x},{geometry.y}/zoom/{zoom}/vermv/0.6'
-            info['geometry'] = link(url, url, external=True)
-        except KeyError:  # pragma: no cover
-            pass
-        try:
-            info['Error'] = data['message']
-        except KeyError:  # pragma: no cover
-            pass
+                f'Allocation: {usage.get("nutzung", "")}, ' \
+                f'Area: {usage.get("fl", "")}m²'
+                for usage in nutzungen]
+
+        if geometry_data := data.get('geometry'):
+            try:
+                geom = shape(geometry_data).centroid
+                zoom = '18.1' if '/' in id_ else '12.9'
+                url = f'https://kataster.bev.gv.at/#/center/' \
+                      f'{geom.x},{geom.y}/zoom/{zoom}/vermv/0.6'
+                info['geometry'] = link(url, url, external=True)
+            except Exception:  # pragma: no cover
+                pass
+
         return info

openatlas/api/external/chronontology.py

@@ -14,8 +14,6 @@ class ChronOntology(ExternalApi):  # pylint: disable=too-few-public-methods
 
     @staticmethod
     def get_info(id_: str, system: Entity) -> dict[str, object]:
-        info: dict[str, object] = {}
-
         try:
             response = requests.get(
                 f'https://chronontology.dainst.org/data/period/{id_}',
@@ -27,28 +25,30 @@ def get_info(id_: str, system: Entity) -> dict[str, object]:
             response.raise_for_status()
             data = response.json()
         except Exception:  # pragma: no cover
-            return info
+            return {}
 
+        info: dict[str, object] = {}
         resource = data.get('resource', {})
 
         names = resource.get('names', {})
-        title = None
-        if 'en' in names and names['en']:
-            title = names['en'][0]
-        elif 'de' in names and names['de']:  # pragma: no cover
-            title = names['de'][0]
+        if en_names := names.get('en'):
+            info['title'] = en_names[0]
+        elif de_names := names.get('de'):  # pragma: no cover
+            info['title'] = de_names[0]
+        else:
+            info['title'] = f"ChronOntology Period {id_}"  # pragma: no cover
 
-        info['title'] = title or f"ChronOntology Period {id_}"
+        if definition := resource.get('definition'):
+            info['definition'] = definition
 
-        info['definition'] = resource.get('definition')
+        if (timespans := resource.get('hasTimespan')) \
+                and isinstance(timespans, list):
+            if time_orig := timespans[0].get('timeOriginal'):
+                info['timespan'] = time_orig
 
-        timespans = resource.get('hasTimespan', [])
-        if timespans and isinstance(timespans, list):
-            info['timespan'] = timespans[0]['timeOriginal']
-
-        types = resource.get('types', [])
-        if types:
-            info['period types'] = ', '.join(types)
+        if types := resource.get('types'):
+            info['period types'] = ', '.join(types) \
+                if isinstance(types,list) else str(types)
 
         if gazetteer := ChronOntology.get_gazetteer_links(data.get('related')):
             info['gazetteer'] = gazetteer
@@ -57,40 +57,39 @@ def get_info(id_: str, system: Entity) -> dict[str, object]:
 
     @staticmethod
     def get_gazetteer_links(related: Any) -> list[str]:
-        links: list[str] = []
         if not isinstance(related, dict):
-            return links  # pragma: no cover
+            return []  # pragma: no cover
 
+        links: list[str] = []
         for key, place in related.items():
-            if 'gazetteer.dainst.org/place/' not in str(key):
-                continue  # pragma: no cover
-            if not isinstance(place, dict):
+            if 'gazetteer.dainst.org/place/' not in str(key) \
+                    or not isinstance(place, dict):
                 continue  # pragma: no cover
 
             english_name = ''
+
             for name in place.get('names', []):
-                if not isinstance(name, dict):
-                    continue  # pragma: no cover
-                if name.get('language') == 'eng' and name.get('title'):
-                    english_name = str(name['title'])
+                if isinstance(name, dict) \
+                        and name.get('language') == 'eng' \
+                        and (title := name.get('title')):
+                    english_name = str(title)
                     break
 
-            if not english_name \
-                    and isinstance(place.get('prefName'), dict) \
-                    and place['prefName'].get('language') == 'eng' \
-                    and place['prefName'].get('title'):
-                english_name = str(place['prefName']['title'])
+            if not english_name:
+                pref = place.get('prefName', {})
+                if isinstance(pref, dict) \
+                        and pref.get('language') == 'eng' \
+                        and (title := pref.get('title')):
+                    english_name = str(title)
 
             if not english_name:
                 continue  # pragma: no cover
 
             place_id = str(key).rstrip('/').rsplit('/', maxsplit=1)[-1]
-            if not place_id:
-                continue  # pragma: no cover
-
-            links.append(link(
-                english_name,
-                f'https://gazetteer.dainst.org/place/{place_id}',
-                external=True))
+            if place_id:
+                links.append(link(
+                    english_name,
+                    f'https://gazetteer.dainst.org/place/{place_id}',
+                    external=True))
 
-        return links
+        return links

openatlas/api/external/doi.py

@@ -12,7 +12,6 @@ class DOI(ExternalApi):  # pylint: disable=too-few-public-methods
 
     @staticmethod
     def get_info(id_: str, system: Entity) -> dict[str, object]:
-        info: dict[str, object] = {}
         try:
             data = requests.get(
                 f'https://doi.org/{id_}',
@@ -22,59 +21,56 @@ def get_info(id_: str, system: Entity) -> dict[str, object]:
                 proxies=app.config['PROXIES'],
                 timeout=10).json()
         except Exception:  # pragma: no cover
-            return info
+            return {}
+
+        info: dict[str, object] = {}
 
-        if 'title' in data and data['title']:
-            info['title'] = data['title']
+        if title := data.get('title'):
+            info['title'] = title
 
-        if 'author' in data:
+        if raw_authors := data.get('author', []):
             authors = []
-            for author in data['author']:
+            for author in raw_authors:
                 name = []
-                if 'family' in author:
-                    name.append(author['family'])
-                if 'given' in author:
-                    name.append(author['given'])
-                elif 'literal' in author:  # pragma: no cover
-                    name.append(author['literal'])
-                authors.append(', '.join(name))
-            info['authors'] = '; '.join(authors)
-
-        if 'container-title' in data and data['container-title']:
-            info['container'] = data['container-title']
-
-        if 'publisher' in data:
-            info['publisher'] = data['publisher']
-
-        year = None
+                if family := author.get('family'):
+                    name.append(family)
+                if given := author.get('given'):
+                    name.append(given)
+                elif literal := author.get('literal'):  # pragma: no cover
+                    name.append(literal)
+                if name:
+                    authors.append(', '.join(name))
+            if authors:
+                info['authors'] = '; '.join(authors)
+
+        if container := data.get('container-title'):
+            info['container'] = container
+
+        if publisher := data.get('publisher'):
+            info['publisher'] = publisher
+
         for date_field in [
-            'issued', 'published-print', 'published-online', 'published']:
-            if date_field in data and 'date-parts' in data[date_field]:
-                try:
-                    year = data[date_field]['date-parts'][0][0]
-                    if year:
+                'issued', 'published-print', 'published-online', 'published']:
+            if date_obj := data.get(date_field):
+                parts = date_obj.get('date-parts', [])
+                if parts and isinstance(parts[0], list) and parts[0]:
+                    if year := parts[0][0]:
+                        info['year'] = year
                         break
-                except (IndexError, TypeError):  # pragma: no cover
-                    continue
-        if year:
-            info['year'] = year
 
-        if 'DOI' in data:
-            info['DOI'] = link(
-                data['DOI'],
-                f'https://doi.org/{data["DOI"]}',
-                external=True)
+        if doi := data.get('DOI'):
+            info['DOI'] = link(doi, f'https://doi.org/{doi}', external=True)
 
-        if 'type' in data:
-            info['type'] = data['type'].replace('-', ' ').title()
+        if doc_type := data.get('type'):
+            info['type'] = doc_type.replace('-', ' ').title()
 
-        if 'page' in data:
-            info['page'] = data['page']
+        if page := data.get('page'):
+            info['page'] = page
 
-        if 'volume' in data:
-            info['volume'] = data['volume']
+        if volume := data.get('volume'):
+            info['volume'] = volume
 
-        if 'issue' in data:
-            info['issue'] = data['issue']
+        if issue := data.get('issue'):
+            info['issue'] = issue
 
         return info

openatlas/api/external/gnd.py

@@ -12,31 +12,40 @@ class GND(ExternalApi):  # pylint: disable=too-few-public-methods
 
     @staticmethod
     def get_info(id_: str, system: Entity) -> dict[str, object]:
-        info: dict[str, object] = {}
         try:
             data = requests.get(
                 f'{system.resolver_url}{id_}.json',
                 proxies=app.config['PROXIES'],
                 timeout=10).json()
         except Exception:  # pragma: no cover
-            return info
+            return {}
 
         def print_values(values: list[dict[str, str]]) -> str:
             return '<br>'.join(
                 [link(i['label'], i['id'], external=True) for i in values])
 
-        if 'preferredName' in data:
-            info['preferred name'] = data['preferredName']
-        if 'gender' in data:
-            info['gender'] = print_values(data['gender'])
-        if 'dateOfBirth' in data:
-            info['date of birth'] = data['dateOfBirth']
-        if 'placeOfBirth' in data:
-            info['place of birth'] = print_values(data['placeOfBirth'])
-        if 'dateOfDeath' in data:
-            info['date of death'] = data['dateOfDeath']
-        if 'placeOfDeath' in data:
-            info['place of death'] = print_values(data['placeOfDeath'])
-        if 'type' in data:
-            info['type'] = '<br>'.join(data['type'])
+        info: dict[str, object] = {}
+
+        if pref_name := data.get('preferredName'):
+            info['preferred name'] = pref_name
+
+        if gender := data.get('gender'):
+            info['gender'] = print_values(gender)
+
+        if dob := data.get('dateOfBirth'):
+            info['date of birth'] = dob
+
+        if pob := data.get('placeOfBirth'):
+            info['place of birth'] = print_values(pob)
+
+        if dod := data.get('dateOfDeath'):
+            info['date of death'] = dod
+
+        if pod := data.get('placeOfDeath'):
+            info['place of death'] = print_values(pod)
+
+        if types := data.get('type'):
+            info['type'] = '<br>'.join(types) \
+                if isinstance(types, list) else str(types)
+
         return info