rara-tools 0.7.12__tar.gz → 0.7.14__tar.gz

{rara_tools-0.7.12/rara_tools.egg-info → rara_tools-0.7.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rara-tools
-Version: 0.7.12
+Version: 0.7.14
 Summary: Tools to support Kata's work.
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10

rara_tools-0.7.14/VERSION

@@ -0,0 +1 @@
+0.7.14

{rara_tools-0.7.12 → rara_tools-0.7.14}/rara_tools/constants/normalizers.py

@@ -1,6 +1,7 @@
 from pymarc import Indicators
 
 YYMMDD_FORMAT = "%y%m%d"
+YYYYMMDD_FORMAT = "%Y%m%d"
 YY_DD_FORMAT = "%Y-%m"
 
 class EntityType:

{rara_tools-0.7.12 → rara_tools-0.7.14}/rara_tools/core_formatters/formatted_meta.py

@@ -56,7 +56,17 @@ class FormattedAuthor(FormattedObject):
 
     @property
     def name(self) -> str:
-        return self.entity
+        """ Force all names into format <last_name>, <first_name>.
+        """
+        if "," in self.entity:
+            name = self.entity 
+        else:
+            name_tokens = self.entity.rsplit(" ", 1)
+            if len(name_tokens) == 2:
+                name = f"{name_tokens[1]}, {name_tokens[0]}"
+            else:
+                name = self.entity 
+        return name
 
     @property
     def name_order(self) -> str:

{rara_tools-0.7.12 → rara_tools-0.7.14}/rara_tools/normalizers/authorities.py

@@ -11,45 +11,54 @@ class AuthoritiesRecordNormalizer(RecordNormalizer):
     """ Normalize authorities records """
 
     def __init__(self, linking_results: List[dict] = [], sierra_data: List[dict] = [],
+                 classified_fields: List[str] = [],
                  ALLOW_EDIT_FIELDS: List[str] = ["008", "925"],
-                 REPEATABLE_FIELDS: List[str] = ["024", "035", "400", "670", "667"]):
+                 REPEATABLE_FIELDS: List[str] = ["024", "035", "400", "667"]):
 
-        super().__init__(linking_results, sierra_data)
+        super().__init__(linking_results, sierra_data, classified_fields)
         self.ALLOW_EDIT_FIELDS = ALLOW_EDIT_FIELDS
         self.REPEATABLE_FIELDS = REPEATABLE_FIELDS
         self.records_extra_data = []
         self.sierra_data = sierra_data
-        self.records = self._setup_records(linking_results, sierra_data)
+        self.records = self._setup_records(linking_results, sierra_data, classified_fields)
 
-    def _normalize_sierra(self, record: Record, sierraID: str) -> None:
+    def _normalize_sierra(self, record: Record, sierraID: str, is_editing_existing_record: bool) -> Record:
+        """008 updated only for new records, unless editing where prefix is preserved."""
 
         suffix_008 = "|n|adnnnaabn          || |a|      "
 
+        if is_editing_existing_record:
+            # Try to reuse prefix from existing 008 field if present
+            existing_008 = next((f for f in record.fields if f.tag == "008" and hasattr(f, "data")), None)
+            if existing_008 and len(existing_008.data) >= 6:
+                prefix = existing_008.data[:6]
+            else:
+                prefix = self.current_timestamp()  # fallback if missing
+        else:
+            prefix = self.current_timestamp()
+
         fields = [
             Field(
                 tag="008",
-                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")),
-                ]
-            ),
+                data=f"{prefix}{suffix_008}"
+            )
         ]
 
-        self._add_fields_to_record(record, fields)
+        field_040 = Field(
+            tag="040",
+            indicators=EMPTY_INDICATORS,
+            subfields=[
+                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")),
+            ]
+        )
+        fields.append(field_040)
 
+        self._add_fields_to_record(record, fields)
+        
         return record
-
+    
     def _add_birth_and_death_dates(self, record: Record, viaf_record: VIAFRecord) -> None:
         
         formatted_birth_date = self._format_date(viaf_record.birth_date)
@@ -72,7 +81,7 @@ class AuthoritiesRecordNormalizer(RecordNormalizer):
             record, [Field(tag="046", indicators=EMPTY_INDICATORS, subfields=subfields_046)])
 
     def _add_viaf_url_or_isni(self, record: Record, viaf_record: VIAFRecord) -> None:
-        viaf_url = f"https://viaf.org/viaf/{viaf_record.viaf_id}"
+        viaf_url = viaf_record.viaf_url
 
         subfields = [Subfield("0", self.get_subfield(
             record, "024", "0", viaf_url))]
@@ -102,7 +111,7 @@ class AuthoritiesRecordNormalizer(RecordNormalizer):
             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
@@ -124,7 +133,7 @@ class AuthoritiesRecordNormalizer(RecordNormalizer):
                           is_editing_existing_record: bool,
                           original_entity: str) -> Record:
         
-        self._normalize_sierra(record, sierraID)
+        self._normalize_sierra(record, sierraID, is_editing_existing_record)
         self._normalize_viaf(record, viaf_record)
 
         return record

{rara_tools-0.7.12 → rara_tools-0.7.14}/rara_tools/normalizers/base.py

@@ -7,7 +7,7 @@ from rara_tools.normalizers.viaf import VIAFRecord, VIAFClient
 from rara_tools.constants.normalizers import (
     DEFAULT_VIAF_FIELD, ALLOWED_VIAF_FIELDS, ALLOWED_VIAF_WIKILINK_LANGS,
     VIAF_SIMILARITY_THRESHOLD, VERIFY_VIAF_RECORD, MAX_VIAF_RECORDS_TO_VERIFY,
-    EMPTY_INDICATORS, YYMMDD_FORMAT, YY_DD_FORMAT
+    EMPTY_INDICATORS, YYMMDD_FORMAT, YY_DD_FORMAT, YYYYMMDD_FORMAT
 )
 from glom import glom
 from dateutil import parser
@@ -29,10 +29,12 @@ class RecordNormalizer:
     Args:
         sierra_data: Optionally, can normalize records from SIERRA. Must be in specific format,
         e.g converted with SierraResponseConverter. examples at: tests/sierra/output
+        classified_fields: Optionally can include marc fields, will follow the rules of the tag number.
+        Useful to send classified data from core.
         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] = [],
+    def __init__(self, linking_results: List[dict] = [], sierra_data: List[dict] = [], classified_fields: List[str] = [],
                  ALLOW_EDIT_FIELDS: List[str] = ["925"], REPEATABLE_FIELDS: List[str] = ["667"]):
 
         # Include, if will replace existing field
@@ -41,17 +43,16 @@ class RecordNormalizer:
         self.REPEATABLE_FIELDS = REPEATABLE_FIELDS
         # leader applied to new records
         self.DEFAULT_LEADER = "01682nz  a2200349n  4500" # must be 24 digits
-        
-    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?).
+    def _setup_records(self, linking_results: List[dict], sierra_data: List[dict], classified_fields: List[str] = []) -> JSONReader:
+        """Setup initial MARC records and data.
+        
+        If no linked entities or more than one linked entity found, we create a new record.
+        If one linked entity found, we create an updated record from the linked entity data.
         """
+        
         linked_records = []
-
+        
         for linked in linking_results or []:
             if not isinstance(linked, dict):
                 continue
@@ -69,6 +70,7 @@ class RecordNormalizer:
                 })
                 self.records_extra_data.append({
                     "entity": entity,
+                    "classified_fields": classified_fields,
                     "edited": False
                 })
                 continue
@@ -83,6 +85,7 @@ class RecordNormalizer:
                 })
                 self.records_extra_data.append({
                     "entity": entity,
+                    "classified_fields": classified_fields,
                     "edited": False
                 })
                 continue   
@@ -91,11 +94,13 @@ class RecordNormalizer:
                 linked_item = linked_info[0]
                 if not isinstance(linked_item, dict):
                     continue
-
+                
                 linked_records.append(linked_item.get("json", {}))
+                
                 self.records_extra_data.append({
                     "entity": entity,
                     "viaf": linked_item.get("viaf", {}),
+                    "classified_fields": classified_fields,
                     "type": "linked",
                     "edited": True
                 })
@@ -128,6 +133,20 @@ class RecordNormalizer:
     @staticmethod
     def _is_person_est_nationality(viaf_record: VIAFRecord) -> bool:
         return hasattr(viaf_record, 'nationality') and viaf_record.nationality == "ee"
+    
+    def get_formatted_dates(self, viaf_record: VIAFRecord) -> str | None:
+        """ Get birth and death date in the form 1878-1940. If only birth date is present, return 1878-.
+            If no dates, return empty string.
+        """
+        birth_date = self._extract_year(viaf_record.birth_date)
+        death_date = self._extract_year(viaf_record.death_date) if viaf_record.death_date != 0 else ""
+        
+        if birth_date and death_date:
+            return f"{birth_date}-{death_date}"
+        elif birth_date:
+            return f"{birth_date}-"
+        else:
+            return None
         
     def _is_nxx(self, field: Field, n: str):
         """ Check if fields tag is in nxx range. """
@@ -146,13 +165,29 @@ class RecordNormalizer:
         """ 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 _extract_year(self, value: str) -> str:
+        if value is None:
+            return ""
+
+        if isinstance(value, (datetime, date)):
+            return str(value.year)
+
+        try:
+            dt = parser.parse(str(value), fuzzy=True)
+            parsed_year = str(dt.year)
+            logger.info(f"Extracted year '{parsed_year}' from value '{value}'")
+            return parsed_year
+        except Exception as e:
+            logger.info(f"Failed to extract year string '{value}': {e}")
+            return ""
+    
     def _format_date(self, value: str) -> str:
         
         if not value:
             return ""
 
         if isinstance(value, (datetime, date)):
-            return value.strftime("%Y%m%d")
+            return value.strftime(YYYYMMDD_FORMAT)
 
         val = str(value).strip()
 
@@ -165,7 +200,7 @@ class RecordNormalizer:
             return dt.strftime("%Y")  # YYYY
         if len(val) in (6, 7):  # YYYYMM or YYYY-MM
             return dt.strftime("%Y%m")  # YYYYMM
-        return dt.strftime("%Y%m%d")  # YYYYMMDD
+        return dt.strftime(YYYYMMDD_FORMAT)  # YYYYMMDD
 
     def get_subfield(self, record: Record, tag: str, subfield: str, default: str) -> str:
         """ get record existing subfield value or assign a fallback value. """
@@ -179,7 +214,7 @@ class RecordNormalizer:
         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 """
+        """ Default behavior - 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)
@@ -213,6 +248,7 @@ class RecordNormalizer:
         )
 
     def _add_fields_to_record(self, record: Record, fields: List[Field]) -> Record:
+        
         cleaned_fields = []
         
         for field in fields:
@@ -242,7 +278,7 @@ class RecordNormalizer:
         return record
 
     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:
@@ -266,9 +302,42 @@ class RecordNormalizer:
                 ]
             )
         ]
+        
+        if viaf_record:
+            author_dates = self.get_formatted_dates(viaf_record)
+            if author_dates:
+                fields[0].add_subfield("d", author_dates)
 
         self._add_fields_to_record(record, fields)
         
+        if viaf_record:
+            self._include_name_variations(record, viaf_record)
+            
+    def _include_name_variations(self, record: Record, viaf_record: VIAFRecord) -> None:
+        """ Include name variations from VIAF record as 400|t fields """
+        
+        if not viaf_record or not viaf_record.name_variations:
+            return
+        
+        existing_name_variations = record.get_fields("400")
+        existing_variations = [sf.value for field in existing_name_variations for sf in field.get_subfields("t")]
+        
+        fields = []
+        
+        for variation in viaf_record.name_variations:
+            if variation not in existing_variations:
+                fields.append(
+                    Field(
+                        tag="400",
+                        indicators=EMPTY_INDICATORS,
+                        subfields=[
+                            Subfield("t", variation)
+                        ]
+                    )
+                )
+        
+        self._add_fields_to_record(record, fields)
+        
     def _move680_fields_to_667(self, record: Record) -> None:
         """ Move existing 680 fields to 667, if any. """
         fields_680 = record.get_fields("680")
@@ -285,13 +354,36 @@ class RecordNormalizer:
 
         record.remove_fields("680")
         self._add_fields_to_record(record, fields_667)
+        
+    
+    def _include_classified_fields(self, record: Record, classified_fields: list[dict]) -> None:
+        """Include classified fields from core, if any.
+        e.g. classified_fields=[{'670': {'ind1': ' ', 'ind2': '0', 'subfields': [{'a': 'Päikesekiri, 2021'}]}}]
+        """
+        if not classified_fields:
+            return
 
-    def _normalize_common(self, record: Record, is_editing_existing_record: bool) -> None:
+        fields = [
+            Field(
+                tag=str(tag),
+                indicators=v.get("indicators", [v.get("ind1", " "), v.get("ind2", " ")]),
+                subfields=[Subfield(code, value) for sub in v.get("subfields", []) for code, value in sub.items()]
+            )
+            for field_dict in classified_fields
+            for tag, v in field_dict.items()
+        ]
+
+        logger.info(f"Adding classified fields: {[f.tag for f in fields]}")
+        self._add_fields_to_record(record, fields)
+
+    def _normalize_common(self, record: Record, is_editing_existing_record: bool, classified_fields: List[dict]) -> None:
         """Common logic for all normalizations. 
         - Includes note about record being created/edited.  
         - include date note with a different subfield, depending on if record is new or edited.
         - move existing 680 fields to 667
         """
+        self._include_classified_fields(record, classified_fields)
+        
         # before adding new notes
         self._move680_fields_to_667(record)
         
@@ -404,15 +496,16 @@ class RecordNormalizer:
         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)
-
+            classified_fields = extra_data.get("classified_fields", [])
+            
             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)
+            record = self._normalize_common(record, is_editing_existing_record, classified_fields)
 
             normalized_record = self._normalize_record(
                 record, sierra_id, viaf_record, is_editing_existing_record, original_entity=entity)

{rara_tools-0.7.12 → rara_tools-0.7.14}/rara_tools/normalizers/bibs.py

@@ -12,55 +12,40 @@ class BibRecordNormalizer(RecordNormalizer):
     """ Normalize bib records. """
 
     def __init__(self, linking_results: List[dict] = [], sierra_data: List[dict] = [],
+                 classified_fields: List[str] = [],
                  ALLOW_EDIT_FIELDS: List[str] = ["008", "925"],
                  REPEATABLE_FIELDS: List[str] = ["667"]):
-        super().__init__(linking_results, sierra_data)
+        super().__init__(linking_results, sierra_data, classified_fields)
         self.DEFAULT_LEADER = "00399nz  a2200145n  4500" # must be 24 digits
         self.ALLOW_EDIT_FIELDS = ALLOW_EDIT_FIELDS
         self.REPEATABLE_FIELDS = REPEATABLE_FIELDS
         
         self.records_extra_data = []
         self.sierra_data = sierra_data
-        self.records = self._setup_records(linking_results, sierra_data)
+        self.records = self._setup_records(linking_results, sierra_data, classified_fields)
 
-    def _normalize_sierra(self, record: Record) -> Record:
-        
+    def _normalize_sierra(self, record: Record, is_editing_existing_record: bool) -> Record:
         suffix_008 = "|||aznnnaabn          || |||      "
-        
+
+        if is_editing_existing_record:
+            # Try to reuse prefix from existing 008 field if present
+            existing_008 = next((f for f in record.fields if f.tag == "008" and hasattr(f, "data")), None)
+            if existing_008 and len(existing_008.data) >= 6:
+                prefix = existing_008.data[:6]  # keep existing timestamp
+            else:
+                prefix = self.current_timestamp()  # fallback if no valid existing data
+        else:
+            prefix = self.current_timestamp()
+
         fields = [
             Field(
                 tag="008",
-                data=f"{self.current_timestamp()}{suffix_008}"
+                data=f"{prefix}{suffix_008}"
             ),
         ]
 
         self._add_fields_to_record(record, fields)
-        
-    def _include_name_variations(self, record: Record, viaf_record: VIAFRecord) -> None:
-        """ Include name variations from VIAF record as 400|t fields """
-        
-        if not viaf_record or not viaf_record.name_variations:
-            return
-        
-        existing_name_variations = record.get_fields("400")
-        existing_variations = [sf.value for field in existing_name_variations for sf in field.get_subfields("t")]
-        
-        fields = []
-        
-        for variation in viaf_record.name_variations:
-            if variation not in existing_variations:
-                fields.append(
-                    Field(
-                        tag="400",
-                        indicators=EMPTY_INDICATORS,
-                        subfields=[
-                            Subfield("t", variation)
-                        ]
-                    )
-                )
-        
-        self._add_fields_to_record(record, fields)
-        
+                
     def _add_author(self, record: Record, viaf_record: Optional[VIAFRecord], original_entity: str) -> Optional[Field]:
         if record.get("100") or record.get("110") or record.get("111"):
             return record
@@ -76,11 +61,17 @@ class BibRecordNormalizer(RecordNormalizer):
 
         fields = [Field(tag=tag, indicators=EMPTY_INDICATORS, subfields=[Subfield("t", title)])]
         
+        if viaf_record:
+            author_dates = self.get_formatted_dates(viaf_record)
+            if author_dates:
+                fields[0].add_subfield("d", author_dates)
+
         self._add_fields_to_record(record, fields)
         
         if viaf_record:
             self._include_name_variations(record, viaf_record)
-
+            
+          
     def _normalize_viaf(self, record: Record, viaf_record: VIAFRecord, original_entity: str) -> None:
         
         if not viaf_record:
@@ -105,7 +96,7 @@ class BibRecordNormalizer(RecordNormalizer):
     def _normalize_record(self, record: Record, sierraID: str,
                           viaf_record: VIAFRecord, is_editing_existing_record: bool, original_entity: str) -> Record:
 
-        self._normalize_sierra(record)
+        self._normalize_sierra(record, is_editing_existing_record)
         self._normalize_viaf(record, viaf_record, original_entity=original_entity)
 
         return record

{rara_tools-0.7.12 → rara_tools-0.7.14/rara_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rara-tools
-Version: 0.7.12
+Version: 0.7.14
 Summary: Tools to support Kata's work.
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10

{rara_tools-0.7.12 → rara_tools-0.7.14}/tests/test_normalization.py

@@ -1,10 +1,9 @@
 import os
 import json
 
-
-from rara_tools.constants import YYMMDD_FORMAT, YY_DD_FORMAT
+from rara_tools.constants import YYMMDD_FORMAT
 from rara_tools.normalizers import (BibRecordNormalizer, AuthoritiesRecordNormalizer)
-from tests.test_utils import (get_linker_res_example, get_formatted_sierra_response, search_viaf_record,
+from tests.test_utils import (get_linker_res_example, get_formatted_sierra_response,
                         check_record_tags_sorted, check_no_dupe_tag_values, check_record_tags_have_values)
 
 from rara_tools.constants.linker import EntityType
@@ -302,8 +301,7 @@ def test_normalized_fields_sorted():
 
 def test_authority_normrecord_found_in_es_and_normalized():
     """ KATA elastic normkirjete seast leitakse 1 vaste & normaliseerija täiendab leitud normkirjet VIAF infoga.
-        - valideeri normaliseerimise mapping, mis autori tabelis. Täiendatud väljad ja VIAFist info
-        - Valideeri märge lisatud (TODO) """
+        - valideeri normaliseerimise mapping, mis autori tabelis. Täiendatud väljad ja VIAFist info """
     # Presume, author name identified and sent to linker
     linker_res = get_linker_res_example(
         "oneFound.json")  # single result
@@ -573,6 +571,20 @@ def test_create_new_normrecord():
     assert len(data) == 1
     record = normalizer.first
     
+    # Test 100|d gets date
+    linking_results = [{
+        "original_entity": "Libe, Katariina",
+        "entity_type": EntityType.PER,
+        "linked_info": []
+    }]
+    normalizer = AuthoritiesRecordNormalizer(linking_results=linking_results)
+    record = normalizer.first
+    # Check that 100|d has date added from VIAF
+    field_100 = record.get_fields("100")[0]
+    assert field_100.get_subfields("d")[0] == "1986-"
+    field_046 = record.get_fields("046")[0]
+    assert field_046.get_subfields("f")[0] == "19861126"
+    
 def test_680_field_on_existing_record_moved_to_667():
     """ 680 Should not be added for new, if exists on existing record, should be moved to 667 """
     linker_res = get_linker_res_example(
@@ -666,3 +678,102 @@ def test_new_bibrecord_title_included():
     fields_100 = record.get_fields("100")
     assert len(fields_100) == 1
     assert fields_100[0].get_subfields("t")[0] == "Roolijoodiku katastroofiline jõulusõit"
+    
+def _validate_new_record_008_field(record: Record):
+    """ Validate 008 field in new record """
+    field_008 = record.get_fields("008")[0].data
+    assert len(field_008) == 40
+    # pos 00-05 is current date in YYMMDD format
+    timestamp = field_008[0:6]
+    try:
+        datetime.strptime(timestamp, YYMMDD_FORMAT)
+    except ValueError:
+        raise AssertionError(f"008 field timestamp {timestamp} is not in format {YYMMDD_FORMAT}")
+    
+def test_008_field_formatting():
+    """ 00-04 position will be changed for new record, not edited on existing record """
+    
+    # Case 1 - new record created, should have current date in 008 field
+    
+    linking_results = [{
+        "original_entity": "Eesti Ekspress",
+        "entity_type": EntityType.TITLE,
+        "linked_info": []
+    }]
+    
+    normalizer = BibRecordNormalizer(
+        linking_results=linking_results,
+    )
+    new_record = normalizer.first
+    _validate_new_record_008_field(new_record)
+
+    # Case 2 - existing record updated, 008 field should not be changed
+    linker_res = get_linker_res_example(
+        "oneFound.json")
+    linking_results = [linker_res]
+    original_record = JSONReader(
+            json.dumps([linker_res["linked_info"][0]["json"]], ensure_ascii=False)
+        )
+    record = next(iter(original_record))
+    original_008 = record.get_fields("008")[0].data
+    
+    # for authorities   
+    normalizer = AuthoritiesRecordNormalizer(
+        linking_results=linking_results
+    )
+    authorities_record = normalizer.first
+    field_008 = authorities_record.get_fields("008")[0].data
+    assert len(field_008) == 40
+    
+    assert field_008 == original_008
+    
+    # for bibs  
+    normalizer = BibRecordNormalizer(
+        linking_results=linking_results
+    )
+    expected_008 = "990107|||aznnnaabn          || |||" + 6 * " "
+    bibrecord = normalizer.first
+    field_008 = bibrecord.get_fields("008")[0].data
+    assert len(field_008) == 40
+    assert field_008 == expected_008
+    
+def test_classified_fields_added_to_linked_record():
+    """ Test that classified fields Can be passed to normalizer & added to linked record """
+    
+    classified_fields = [
+        {
+            "670": {
+                "ind1": " ",
+                "ind2": "0",
+                "subfields": [
+                    {
+                        "a": "Päikesekiri, 2021"
+                    }
+                ]
+            }
+        }
+    ]
+    # Case 1 - no 670 exists, should be added to linked record
+    for normalizer in (AuthoritiesRecordNormalizer, BibRecordNormalizer):
+        linking_results = [MOCK_LINKER_NOT_FOUND]
+        normalizer = normalizer(linking_results=linking_results, classified_fields=classified_fields)
+        
+        record = normalizer.first
+        fields_670 = record.get_fields("670")
+        assert len(fields_670) == 1
+        assert fields_670[0].get_subfields("a")[0] == "Päikesekiri, 2021"
+    
+    # Case 1 - existing record with 670 should not update (same behavior for both normalizers)
+    linker_res = get_linker_res_example(
+        "oneFound.json")
+    linking_results = [linker_res]
+    
+    for normalizer in (AuthoritiesRecordNormalizer, BibRecordNormalizer):
+        normalizer = normalizer(
+            linking_results=linking_results,
+            classified_fields=classified_fields
+        )
+        record = normalizer.first
+        fields_670 = record.get_fields("670")
+        assert len(fields_670) == 1
+        assert fields_670[0].get_subfields("a")[0] == "Eesti kirjarahva leksikon, 1995."

rara_tools-0.7.12/VERSION

@@ -1 +0,0 @@
-0.7.12