rara-tools 0.2.0__tar.gz → 0.4.0__tar.gz

{rara_tools-0.2.0/rara_tools.egg-info → rara_tools-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rara-tools
-Version: 0.2.0
+Version: 0.4.0
 Summary: Tools to support Kata's work.
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -13,10 +13,13 @@ License-File: LICENSE.md
 Requires-Dist: elasticsearch==8.*
 Requires-Dist: elasticsearch_dsl==8.*
 Requires-Dist: minio==7.*
-Requires-Dist: rara-norm-linker==1.*
+Requires-Dist: estnltk==1.7.3
+Requires-Dist: nltk
+Requires-Dist: jsonlines
 Requires-Dist: requests
 Requires-Dist: iso639-lang
 Requires-Dist: pymarc
+Requires-Dist: regex
 Requires-Dist: glom
 Provides-Extra: testing
 Requires-Dist: pytest>=8.0; extra == "testing"

rara_tools-0.4.0/VERSION

@@ -0,0 +1 @@
+0.4.0

{rara_tools-0.2.0 → rara_tools-0.4.0}/pyproject.toml

@@ -9,7 +9,12 @@ dependencies = { file = ["requirements.txt"] }
 [tool.setuptools.packages.find]
 include = [
     "rara_tools",
-    "rara_tools.constants"
+    "rara_tools.constants",
+    "rara_tools.normalizers",
+    "rara_tools.parsers",
+    "rara_tools.parsers.marc_parsers",
+    "rara_tools.parsers.marc_records",
+    "rara_tools.parsers.tools"
 ]
 
 [project]

rara_tools-0.4.0/rara_tools/constants/normalizers.py

@@ -0,0 +1,6 @@
+from pymarc import Indicators
+import os
+
+EMPTY_INDICATORS = Indicators(" ", " ")
+VIAF_ALLOWED_SOURCES = ["LC", "DNB", "LNB", "NLL",
+                        "ERRR", "J9U"]

rara_tools-0.4.0/rara_tools/constants/parsers.py

@@ -0,0 +1,152 @@
+import logging
+
+LOGGER = logging.getLogger("rara-tools-marc-parser")
+
+
+class EMSMarcIDs:
+    SYNONYMS = ["448", "450", "451", "455"]
+    RELATED = ["548", "550", "551", "555"]
+    CATEGORY = ["072"]
+    NOTES = ["680"]
+    URL = ["024"]
+    TIME_KEYWORD = "148"
+    TOPIC_KEYWORD = "150"
+    LOC_KEYWORD = "151"
+    GENRE_KEYWORD = "155"
+
+
+class GeneralMarcIDs:
+    ID = ["001"]
+    ID_SOURCE = ["003"]
+
+
+class OrganizationMarcIDs:
+    NAME = ["110", "111"]
+    NAME_VARIATIONS = ["410", "411"]
+    RELATED_NAMES = ["510", "511"]
+    SOURCE = ["667"]
+    DESCRIPTION = ["680"]
+    AREA_CODE = ["043"]
+
+
+class PersonMarcIDs:
+    NAME = ["100"]
+    NAME_VARIATIONS = ["400"]
+    SOURCE = ["670"]
+    DESCRIPTION = ["680"]
+
+class KeywordType:
+    LOC = "Kohamärksõnad"
+    TIME = "Ajamärksõnad"
+    TOPIC = "Teemamärksõnad"
+    GENRE = "Vormimärksõnad"
+
+class EntityType:
+    PER = "PER"
+    ORG = "ORG"
+    KEYWORD = "EMS_KEYWORD"
+    LOC = "LOC"
+    UNK = "UNKNOWN"
+
+
+EN_SUBJECT_FIELDS = {
+    "00": "GENERAL CONCEPTS",
+    "01": "PHILOSOPHY. ETHICS. SEMIOTICS",
+    "02": "RELIGION. THEOLOGY. ESOTERICISM",
+    "03": "SCIENCE AND TECHNOLOGY",
+    "04": "EDUCATION. PEDAGOGY",
+    "06": "PSYCHOLOGY",
+    "07": "SOCIOLOGY. SOCIAL PSYCHOLOGY",
+    "08": "EMPLOYMENT. WORKING CONDITIONS. OCCUPATIONS",
+    "10": "POLITOLOGY. POLITICS",
+    "11": "GOVERNMENT. ADMINISTRATION. CIVIL DEFENCE. SECURITY SERVICE",
+    "12": "SOCIAL POLICY",
+    "13": "LAW. LEGISLATION",
+    "15": "MILITARY AFFAIRS. ARMAMENT. MILITARY EQUIPMENT",
+    "17": "DEMOGRAPHY. STATISTICS",
+    "18": "JOURNALISM. COMMUNICATION. MEDIA. ADVERTISING",
+    "19": "NATURE PROTECTION. ENVIRONMENT PROTECTION. ENVIRONMENT TECHY",
+    "20": "GEOLOGY. HYDROLOGY. CLIMATOLOGY",
+    "21": "MATHEMATICS",
+    "22": "ASTRONOMY. ASTROPHYSICS. SPACE EXPLORATION",
+    "23": "PHYSICS",
+    "24": "CHEMISTRY. CHEMICAL INDUSTRY",
+    "25": "BIOLOGY. MICROBIOLOGY. GENETICS. ANTHROPOLOGY",
+    "26": "BOTANY",
+    "27": "ZOOLOGY",
+    "28": "MEDICINE. BIOCHEMISTRY. ANATOMY. PHYSIOLOGY. COSMETICS",
+    "29": "ECONOMY. ECONOMICS. FINANCE. TRADE",
+    "30": "AGRICULTURE. HORTICULTURE. ANIMAL BREEDING. VETERINARY",
+    "31": "FORESTRY. HUNTING. FISHERY. FOREST AND WOODWORK INDUSTRY. PULP AND PAPER INDUSTRY",
+    "34": "CATERING. DOMESTIC ECONOMY",
+    "35": "ELECTRICAL TECHNOLOGY. ELECTRONICS. ENERGETICS",
+    "36": "INFORMATICS. INFORMATION TECHNOLOGY. AUTOMATICS",
+    "39": "MECHANICAL ENGINEERING. METAL INDUSTRY. METALLURGY. MINING",
+    "43": "LIGHT INDUSTRY. TEXTILE INDUSTRY. LEATHER INDUSTRY",
+    "44": "BUILDING. CONSTRUCTION. SANITARY ENGINEERING",
+    "45": "TRAFFIC. TRANSPORT. COMMUNICATION",
+    "47": "ART. ARCHITECTURE",
+    "48": "PHOTOGRAPHY. CINEMA",
+    "49": "MUSIC",
+    "50": "THEATRE. DANCE",
+    "51": "SPORTS. PHYSICAL CULTURE",
+    "52": "HOBBIES. LEISURE ACTIVITIES",
+    "53": "INFORMATION SCIENCE. LIBRARIANSHIP. MEMORY INSTITUTIONS. PUBLISHING. TYPOGRAPHY",
+    "54": "LINGUISTICS. LANGUAGES",
+    "55": "LITERARY SCIENCE. LITERATURE. FOLKLORE",
+    "56": "HISTORY. ARCHAEOLOGY",
+    "58": "ETHNOLOGY. CULTURAL ANTHROPOLOGY",
+    "59": "GEOGRAPHY. GEODESY. CARTOGRAPHY",
+    "60": "GEOGRAPHICAL NAMES"
+}
+
+ET_SUBJECT_FIELDS = {
+    "00": "ÜLDMÕISTED",
+    "01": "FILOSOOFIA. EETIKA. SEMIOOTIKA",
+    "02": "RELIGIOON. TEOLOOGIA. ESOTEERIKA",
+    "03": "TEADUS JA TEHNIKA. TEADUSKORRALDUS. TEADUSMETODOLOOGIA. KULTUUR",
+    "04": "HARIDUS. PEDAGOOGIKA",
+    "06": "PSÜHHOLOOGIA",
+    "07": "SOTSIOLOOGIA. SOTSIAALPSÜHHOLOOGIA",
+    "08": "TÖÖHÕIVE. TÖÖTINGIMUSED. AMETID",
+    "10": "RIIGIÕPETUS. POLIITIKA",
+    "11": "VALITSUS. HALDUS. KODANIKUKAITSE. TURVATEENISTUS",
+    "12": "SOTSIAALPOLIITIKA",
+    "13": "ÕIGUS",
+    "15": "SÕJANDUS. RELVAJÕUD. SÕJATEHNIKA",
+    "17": "DEMOGRAAFIA. STATISTIKA",
+    "18": "AJAKIRJANDUS. KOMMUNIKATSIOON. MEEDIA. REKLAAM",
+    "19": "LOODUSKAITSE. KESKKONNAKAITSE. KESKKONNATEHNIKA",
+    "20": "GEOLOOGIA. HÜDROLOOGIA. KLIMATOLOOGIA",
+    "21": "MATEMAATIKA",
+    "22": "ASTRONOOMIA. ASTROFÜÜSIKA. KOSMOSEUURIMINE",
+    "23": "FÜÜSIKA",
+    "24": "KEEMIA. KEEMIATÖÖSTUS",
+    "25": "BIOLOOGIA. MIKROBIOLOOGIA. GENEETIKA. ANTROPOLOOGIA",
+    "26": "BOTAANIKA",
+    "27": "ZOOLOOGIA",
+    "28": "MEDITSIIN. BIOKEEMIA. ANATOOMIA. FÜSIOLOOGIA. FARMAKOLOOGIA. KOSMEETIKA",
+    "29": "MAJANDUS. MAJANDUSTEADUS. RAHANDUS. KAUBANDUS",
+    "30": "PÕLLUMAJANDUS. AIANDUS. LOOMAKASVATUS. VETERINAARIA",
+    "31": "METSANDUS. JAHINDUS. KALANDUS. METSA- JA PUIDUTÖÖSTUS. TSELLULOOSI- JA PABERITÖÖSTUS",
+    "34": "KODUMAJANDUS. TOIDUAINETETÖÖSTUS. TOITLUSTUS. OLME",
+    "35": "ELEKTROTEHNIKA. ELEKTROONIKA. ENERGEETIKA",
+    "36": "INFORMAATIKA. INFOTEHNOLOOGIA. AUTOMAATIKA",
+    "39": "MASINAEHITUS. METALLITÖÖSTUS. METALLURGIA. MÄENDUS",
+    "43": "KERGETÖÖSTUS. TEKSTIILITÖÖSTUS. NAHA- JA JALATSITÖÖSTUS",
+    "44": "EHITUS. SANITAARTEHNIKA",
+    "45": "LIIKLUS. TRANSPORT. SIDE",
+    "47": "KUNST. ARHITEKTUUR",
+    "48": "FOTOGRAAFIA. FILM. KINO",
+    "49": "MUUSIKA",
+    "50": "TEATER. TANTS",
+    "51": "SPORT. KEHAKULTUUR",
+    "52": "HARRASTUSED. VABA AEG",
+    "53": "INFOTEADUS. RAAMATUKOGUNDUS. MÄLUASUTUSED. KIRJASTAMINE. TRÜKINDUS",
+    "54": "KEELETEADUS. KEELED",
+    "55": "KIRJANDUSTEADUS. ILUKIRJANDUS. RAHVALUULE",
+    "56": "AJALUGU. ARHEOLOOGIA",
+    "58": "ETNOLOOGIA. KULTUURIANTROPOLOOGIA",
+    "59": "GEOGRAAFIA. GEODEESIA. KARTOGRAAFIA",
+    "60": "KOHANIMED"
+}

rara_tools-0.4.0/rara_tools/normalizers/__init__.py

@@ -0,0 +1,4 @@
+
+from rara_tools.normalizers.base import RecordNormalizer
+from rara_tools.normalizers.authorities import AuthoritiesRecordNormalizer
+from rara_tools.normalizers.bibs import BibRecordNormalizer

rara_tools-0.4.0/rara_tools/normalizers/authorities.py

@@ -0,0 +1,120 @@
+from rara_tools.constants import EMPTY_INDICATORS
+from rara_tools.normalizers.viaf import VIAFRecord
+
+from rara_tools.normalizers import RecordNormalizer
+
+from pymarc import Field, Subfield, Record
+from typing import List
+
+
+class AuthoritiesRecordNormalizer(RecordNormalizer):
+    """ Normalize authorities records """
+
+    def __init__(self, linking_results: List[dict] = [], sierra_data: List[dict] = [],
+                 ALLOW_EDIT_FIELDS: List[str] = [
+                     "667", "925", "043"],
+                 REPEATABLE_FIELDS: List[str] = ["024", "035", "400", "670"]):
+
+        super().__init__(linking_results, sierra_data)
+        self.ALLOW_EDIT_FIELDS = ALLOW_EDIT_FIELDS
+        self.REPEATABLE_FIELDS = REPEATABLE_FIELDS
+
+    def _normalize_sierra(self, record: Record, sierraID: str) -> None:
+
+        suffix_008 = "|n|adnnnaabn          || |a|      "
+
+        fields = [
+            Field(
+                tag="008",
+                indicators=EMPTY_INDICATORS,
+                data=f"{self.current_timestamp()}{suffix_008}"
+            ),
+
+            Field(
+                tag="040",
+                indicators=EMPTY_INDICATORS,
+                subfields=[
+                    # if record subfield exists already, use that value. if not, use hardcoded value
+                    Subfield("a", self.get_subfield(
+                        record, "040", "a", "ErESTER")),
+                    Subfield("b", self.get_subfield(
+                        record, "040", "b", "est")),
+                    Subfield("c", self.get_subfield(
+                        record, "040", "c", "ErEster")),
+                ]
+            ),
+        ]
+
+        self._add_fields_to_record(record, fields)
+
+        return record
+
+    def _add_birth_and_death_dates(self, record: Record, viaf_record: VIAFRecord) -> None:
+        subfields_046 = [
+            Subfield("f", self.get_subfield(
+                record, "046", "f", viaf_record.birth_date)),
+            Subfield("g", self.get_subfield(
+                record, "046", "g", viaf_record.death_date)),
+            Subfield("s", self.get_subfield(
+                record, "046", "s", viaf_record.activity_start)),
+            Subfield("t", self.get_subfield(
+                record, "046", "t", viaf_record.activity_end)),
+        ]
+
+        self._add_fields_to_record(
+            record, [Field(tag="046", indicators=EMPTY_INDICATORS, subfields=subfields_046)])
+
+    def _add_viaf_url_and_isni(self, record: Record, viaf_record: VIAFRecord) -> None:
+        # TODO 024. will be used to store KRATT KATA ID. Just generate one?
+        viaf_url = f"https://viaf.org/viaf/{viaf_record.viaf_id}"
+
+        subfields = [Subfield("0", self.get_subfield(
+            record, "024", "0", viaf_url))]
+
+        if viaf_record.has_isni:
+            subfields.append(Subfield("2", "isni"))
+
+        field = Field(tag="024", indicators=EMPTY_INDICATORS,
+                      subfields=subfields)
+
+        self._add_fields_to_record(record, [field])
+
+    def _add_nationality(self, record: Record, viaf_record: VIAFRecord) -> None:
+
+        fields = [
+            Field(
+                tag="043",
+                indicators=EMPTY_INDICATORS,
+                subfields=[
+                    Subfield("c", "ee")
+                ] if self._is_person_est_nationality(viaf_record) else []
+            )]
+
+        self._add_fields_to_record(record, fields)
+
+    def _normalize_viaf(self, record: Record, viaf_record: VIAFRecord) -> None:
+        """"
+        Attempts to enrich the record with VIAF data.
+
+        024 - repeatable field, add VIAF URL to subfield 0. If ISNI found, add to subfield 2
+        043 - repeatable field. Add "ee" if found to be estonian nationality
+        046 - non-repeatable field, add birth and death dates
+        100, 110, 111 - non-repeatable field, attempts to add author type, if missing.
+
+        """
+        # TODO: include KRATT KATA ID to 024 and remove on delete. Increment last elastic ID?
+        if not viaf_record:
+            return
+
+        self._add_nationality(record, viaf_record)
+        self._add_viaf_url_and_isni(record, viaf_record)
+        self._add_birth_and_death_dates(record, viaf_record)
+        self._add_author(record, viaf_record)
+
+    def _normalize_record(self, record: Record, sierraID: str,
+                          viaf_record: VIAFRecord, is_editing_existing_record: bool) -> Record:
+
+        self._normalize_sierra(record, sierraID)
+        self._normalize_viaf(record, viaf_record)
+
+        return record

rara_tools-0.4.0/rara_tools/normalizers/base.py

@@ -0,0 +1,290 @@
+from datetime import datetime
+from pymarc import (Field, Subfield, JSONReader, Record)
+from typing import List, Optional, Iterator
+
+from rara_tools.constants import EMPTY_INDICATORS
+from rara_tools.normalizers.viaf import VIAFRecord, VIAFClient
+
+from glom import glom
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class RecordNormalizer:
+    """
+    Base class. For normalizing different record types corresponding classes have been created.
+    By default existing record fields will not be changed, unless included in ALLOW_EDIT_FIELDS. If a field
+    included in the normalization is not present, it will be added to the record. If under REPEATABLE_FIELDS.
+    a new record field is added.
+
+    Args:
+        sierra_data: Optionally, can normalize records from SIERRA. Must be in specific format,
+        e.g converted with SierraResponseConverter. examples at: tests/sierra/output
+        entities: List of Full names (str). If included, will use NormLinker to match with normalized records on KATA elastic.
+    """
+
+    def __init__(self, linking_results: List[dict] = [], sierra_data: List[dict] = [],
+                 ALLOW_EDIT_FIELDS: List[str] = ["667", "925"], REPEATABLE_FIELDS: List[str] = []):
+
+        # Include, if will replace existing field
+        self.ALLOW_EDIT_FIELDS = ALLOW_EDIT_FIELDS
+        # include, if should be added alongside existing fields
+        self.REPEATABLE_FIELDS = REPEATABLE_FIELDS
+
+        self.records_extra_data = []
+        self.records = self._setup_records(linking_results, sierra_data)
+        self.sierra_data = sierra_data
+
+    def _setup_records(self, linking_results: List[dict], sierra_data: List[dict]) -> JSONReader:
+        """Setup initial MARC records and data.
+
+        For linked entities:
+            1. Try to get single linked normalized record from KATA elastic. If more than one found, skip.
+            2. If 0 matches, search from VIAF and if 1 result found, create a new authority record from the data.
+            3. If none or more than one responses found, use only Classificator data (coming from Linker?).
+
+        for SIERRA records: normalize.
+        """
+        linked_records = []
+
+        for linked in linking_results:
+            entity = linked.get("original_entity")
+            try:
+                linked_info = linked.get("linked_info", [])
+                linked_num = len(linked_info)
+
+                if not linked_info:
+                    # new record will be created
+                    logger.info(
+                        f"No linked entities found for {entity}")
+                    continue
+
+                if linked_num == 1:
+                    linked = linked_info[0]
+                    linked_records.append(linked.get("json", {}))
+                    self.records_extra_data.append({
+                        "entity": entity,
+                        "viaf": linked.get("viaf", {}),
+                        "type": "linked",
+                        "edited": True
+                    })
+                else:
+                    # new record will be created
+                    logger.info(
+                        f"Multiple linked entities found for {entity}")
+
+            except Exception as e:
+                logger.error(f"Error processing entity {entity}: {e}")
+
+        self.records_extra_data.extend(
+            {
+                "sierraID": obj.get("sierraID"),
+                "type": "sierra",
+                "edited": True
+            }
+            for obj in (sierra_data or [])
+        )
+
+        all_records = linked_records + (sierra_data or [])
+
+        return JSONReader(json.dumps(all_records,
+                                     ensure_ascii=False), stream=False)
+
+    @staticmethod
+    def current_timestamp():
+        """6 digit timestamp."""
+        return datetime.now().strftime("%H%M%S")
+
+    @staticmethod
+    def current_yyyy_dd():
+        """format of 2025-03"""
+        return datetime.now().strftime("%Y-%m")
+
+    @staticmethod
+    def _is_person_est_nationality(viaf_record: VIAFRecord) -> bool:
+        return viaf_record.nationality == "ee"
+
+    def _is_nxx(self, field: Field, n: str):
+        """ Check if fields tag is in nxx range. """
+        return field.tag.startswith(n)
+
+    def get_record_field_or_none(self, record: Record, tag: str) -> Optional[Field]:
+        return record.get_fields(tag)[0] if record.get_fields(tag) else None
+
+    def _field_in_record(self, field: Field, record: Record) -> bool:
+        """ Check if field exists in record. """
+        existing_fields = record.get_fields(field.tag)
+        return any(
+            field.data == existing_field.data for existing_field in existing_fields)
+
+    def _filter_equivalent_field_not_in_record(self, record: Record, fields: List[Field]) -> bool:
+        """ filter out fields, that do not have an equivalent in the record. """
+        return filter(lambda field: not self._field_in_record(field, record), fields)
+
+    def get_subfield(self, record: Record, tag: str, subfield: str, default: str) -> str:
+        """ get record existing subfield value or assign a fallback value. """
+
+        field = self.get_record_field_or_none(record, tag)
+
+        if field is None:
+            return default
+
+        subfields = field.get_subfields(subfield)
+        return subfields[0] if subfields else default
+
+    def _handle_default_fields(self, record: Record, *fields: List[Field]) -> Record:
+        """ add field to record iff not present already """
+        record.add_field(
+            *filter(lambda field: field.tag not in [
+                f.tag for f in record.get_fields()], fields)
+        )
+
+    def _handle_editable_fields(self, record: Record, *fields: List[Field]) -> Record:
+        """ replace existing field with a new field. """
+
+        editable_fields = filter(
+            lambda field: field.tag in self.ALLOW_EDIT_FIELDS, fields)
+
+        tags = [f.tag for f in editable_fields]
+
+        record.remove_fields(
+            *tags
+        )
+        record.add_field(
+            *editable_fields
+        )
+
+    def _handle_repeatable_fields(self, record: Record, *fields: List[Field]) -> Record:
+        """ add field to the record & don't replace existing field."""
+
+        repeatable_fields = [
+            field for field in fields if field.tag in self.REPEATABLE_FIELDS]
+
+        record.add_field(
+            *repeatable_fields
+            # *self._filter_equivalent_field_not_in_record(
+            #     record, repeatable_fields)
+        )
+
+    def _add_fields_to_record(self, record: Record, fields: List[Field]) -> Record:
+
+        self._handle_repeatable_fields(record, *fields)
+        self._handle_editable_fields(record, *fields)
+        self._handle_default_fields(record, *fields)
+
+    def _add_author(self, record: Record, viaf_record: VIAFRecord) -> Optional[Field]:
+
+        existing_author: Optional[Field] = record.get(
+            "100") or record.get("110") or record.get("111")
+        if existing_author:
+            return record
+
+        type_map = {
+            "Personal": "100",
+            "Corporate": "110",
+            "Collective": "111"
+        }
+
+        author_type = viaf_record.author_type
+        tag = type_map.get(author_type, "100")
+
+        fields = [
+            Field(
+                tag=tag,
+                indicators=EMPTY_INDICATORS,
+                subfields=[
+                    Subfield("a", viaf_record.author),
+                    Subfield("b", viaf_record.author_type),
+                    Subfield("c", viaf_record.author_type)
+                ]
+            )
+        ]
+
+        self._add_fields_to_record(record, fields)
+
+    def _normalize_common(self, record: Record, is_editing_existing_record: bool) -> None:
+        """Common logic for all normalizations. """
+
+        note = "Muudetud AI poolt" if is_editing_existing_record else "Loodud AI poolt"
+        date_note = f"KRATT {self.current_yyyy_dd()}"
+
+        fields = [
+            Field(tag="667",
+                  indicators=EMPTY_INDICATORS,
+                  subfields=[Subfield("a", note)]),
+            Field(tag="925",
+                  indicators=EMPTY_INDICATORS,
+                  subfields=[Subfield("t", self.get_subfield(record, "925", "t", date_note))
+                             ] + ([Subfield("p", self.get_subfield(record, "925", "p", date_note))]
+                                  if is_editing_existing_record else []))
+        ]
+
+        self._add_fields_to_record(record, fields)
+
+        return record
+
+    def _get_viaf_search_term(self, record: Record, entity: Optional[str]) -> Optional[str]:
+        """ prioritize entity name, if not available, use author name. """
+
+        if entity:
+            return entity
+        else:
+            return record.author
+
+    def _get_viaf_record(self, record: Record, viaf_id: Optional[int] = None, entity: Optional[str] = None) -> Optional[VIAFRecord]:
+        try:
+            viaf_client = VIAFClient()
+
+            if viaf_id:
+                viaf_info = viaf_client.get_records_by_viaf_id(viaf_id).json()
+                return VIAFRecord(viaf_info)
+
+            search_term = self._get_viaf_search_term(record, entity)
+
+            results = viaf_client.get_records_by_search_term(
+                search_term).json()
+
+            num_records = glom(
+                results, "queryResult.numberOfRecords.value", default=0)
+
+            if num_records == 1:
+                return VIAFRecord(results)
+
+            logger.warning(
+                f"Multiple VIAF records found for {search_term}: {num_records}. Skipping.")
+
+        except Exception as e:
+            logger.error(f"Error fetching VIAF record: {e}")
+
+    def _normalize_record(self, record: Record, sierraID: str,
+                          viaf_record: VIAFRecord, is_editing_existing_record: bool) -> Record:
+        return record
+
+    @property
+    def data(self) -> List[dict]:
+        """ Shorthand to get all normalized records as dict. """
+        return [record.as_dict() for record in self]
+
+    def __iter__(self) -> Iterator:
+        viaf_id_path = "viaf.queryResult.records.record.0.recordData.VIAFCluster.viafID"
+        sierra_id_path = "sierraID"
+
+        for record, extra_data in zip(self.records, self.records_extra_data):
+
+            sierra_id = glom(extra_data, sierra_id_path, default="")
+            viaf_id = glom(extra_data, viaf_id_path, default=None)
+
+            entity = extra_data.get("entity")
+            is_editing_existing_record = extra_data.get("edited") == True
+
+            viaf_record = self._get_viaf_record(record, viaf_id, entity)
+            record = self._normalize_common(record, is_editing_existing_record)
+
+            normalized_record = self._normalize_record(
+                record, sierra_id, viaf_record, is_editing_existing_record)
+
+            normalized_record.fields.sort(key=lambda field: field.tag)
+
+            yield normalized_record