rara-tools 0.4.3__tar.gz → 0.5.0__tar.gz

{rara_tools-0.4.3/rara_tools.egg-info → rara_tools-0.5.0}/PKG-INFO

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

rara_tools-0.5.0/VERSION

@@ -0,0 +1 @@
+0.5.0

{rara_tools-0.4.3 → rara_tools-0.5.0}/rara_tools/constants/parsers.py

@@ -35,6 +35,12 @@ class PersonMarcIDs:
     SOURCE = ["670"]
     DESCRIPTION = ["680"]
 
+class TitleMarcIDs:
+    NAME = ["100"]
+    NAME_VARIATIONS = ["400"]
+    YEAR = ["046"]
+    TYPE = ["075"]
+
 class KeywordType:
     LOC = "Kohamärksõnad"
     TIME = "Ajamärksõnad"

{rara_tools-0.4.3 → rara_tools-0.5.0}/rara_tools/converters.py

@@ -14,9 +14,46 @@ class SierraResponseConverter:
     def _map_control_fields(field: dict) -> dict:
         # for tags < 010, no subfields, instead one str value in "value"
         return {field["tag"]: field["value"]}
+    
+    def _map_data_field_subfields(self, subfields: list) -> list:
+        """ Maps data field subfields to the standardised format, if necessary.
 
-    @staticmethod
-    def _map_data_fields(field: dict) -> dict:
+        Args:
+            subfields (list): List of subfields in format e.g
+              "subfields": [
+                        {
+                            "code": "a",
+                            "data": "foo"
+                        }, 
+                        {
+                            "code": "c",
+                            "data": "by me."
+                        }
+                    ]
+
+        Returns:
+            list: standardised marc-in-json format. e.g 
+             "subfields": [
+                            { "a": "foo /" },
+                            { "c": "by me." }
+                                ]
+        """
+        result = []
+        for subfield in subfields:
+            
+            code = subfield.get("code")
+            data = subfield.get("data")
+
+            if not code or not data:
+                # assume that the subfield is already in the correct format
+                return subfields
+            else:
+                result.append({code: data})
+                
+        return result
+
+
+    def _map_data_fields(self, field: dict) -> dict:
         """ Maps marc fields > 010. 
 
         Args:
@@ -27,12 +64,13 @@ class SierraResponseConverter:
         """
 
         data = field["data"]
+        subfields = data.get("subfields", [])
 
         # Order matters ind1, in2, subfields
         field_data = {
             "ind1": data.get("ind1", " "),
             "ind2": data.get("ind2", " "),
-            "subfields": data.get("subfields", [])
+            "subfields": self._map_data_field_subfields(subfields)
         }
 
         return {field["tag"]: field_data}
@@ -41,7 +79,7 @@ class SierraResponseConverter:
     def _is_marc21structured(field: dict) -> bool:
         """Checks if the field is already structured according to MARC21 in JSON"""
         return any(key.isdigit() for key in field.keys())
-
+    
     def _handle_field_type(self, field: dict) -> dict:
 
         if self._is_marc21structured(field):

rara_tools-0.5.0/rara_tools/parsers/marc_parsers/title_parser.py

@@ -0,0 +1,44 @@
+from typing import NoReturn
+from collections.abc import Iterator
+from rara_tools.parsers.marc_parsers.base_parser import BaseMARCParser
+from rara_tools.parsers.marc_records.title_record import TitleRecord
+from rara_tools.constants.parsers import LOGGER
+
+
+class TitlesMARCParser(BaseMARCParser):
+    """ MARC parser for titles' .mrc files.
+    """
+    def __init__(self,
+            marc_file_path: str,
+            add_variations: bool = True
+        ) -> NoReturn:
+        """ Initializes OrganizationsMARCParser object.
+
+        Parameters
+        -----------
+        marc_file_path: str
+            Full path to .mrc file containing titles' data.
+        add_variations: bool
+            If enabled, constructs an additional variations field, which
+            combines the content of multiple fields + adds some generated
+            variations. If the output is uploaded into Elastic and used
+            via rara-norm-linker, it is necessary to enable this.
+        """
+        super().__init__(
+            marc_file_path=marc_file_path,
+            add_variations=add_variations
+        )
+
+    def record_generator(self) -> Iterator[TitleRecord]:
+        """ Generates TitleRecord objects.
+        """
+        LOGGER.info(
+            f"Generating title records from " \
+            f"MARC dump '{self.marc_file_path}'."
+        )
+        for record in self.marc_record_generator():
+            title_record = TitleRecord(
+                record=record,
+                add_variations=self.add_variations
+            )
+            yield title_record.full_record

{rara_tools-0.4.3 → rara_tools-0.5.0}/rara_tools/parsers/marc_records/base_record.py

@@ -61,7 +61,7 @@ class BaseRecord:
                             if isinstance(subfield_id, str):
                                 if _subfield_id == subfield_id:
                                     value = subfield[_subfield_id]
-                                    values.append(value)
+                                    values.append(value.strip())
                             elif isinstance(subfield_id, list):
                                 if _subfield_id in subfield_id:
                                     value = subfield[_subfield_id]

rara_tools-0.5.0/rara_tools/parsers/marc_records/title_record.py

@@ -0,0 +1,196 @@
+from typing import List, NoReturn
+from pymarc.record import Record
+from rara_tools.parsers.marc_records.base_record import BaseRecord
+from rara_tools.constants.parsers import TitleMarcIDs, LOGGER
+import regex as re
+import json
+import logging
+
+
+class TitleRecord(BaseRecord):
+    """ Generates a simplified title JSON record
+    from a pymarc MARC record.
+    """
+    def __init__(self, record: Record, add_variations: bool = False) -> NoReturn:
+        """ Initializes TitleRecord object.
+
+        Parameters
+        -----------
+        record: Record
+            pymarc.record.Record object.
+        add_variations: bool
+            If enabled, constructs an additional variations field, which
+            combines the content of multiple fields + adds some generated
+            variations. If the output is uploaded into Elastic and used
+            via rara-norm-linker, it is necessary to enable this.
+        """
+        super().__init__(record=record, add_variations=add_variations)
+
+        self.__name_field_id: List[str] = TitleMarcIDs.NAME
+        self.__name_variations_field_id: List[str]= TitleMarcIDs.NAME_VARIATIONS
+        self.__year_field_id: List[str] = TitleMarcIDs.YEAR
+        self.__type_field_id: List[str] = TitleMarcIDs.TYPE
+
+        self.__default_year: int | None = None
+
+        self.__name: str = ""
+        self.__author_original_name: dict = {}
+        self.__author_name: str = ""
+        self.__year: int = -1
+        self.__type: str = ""
+
+        self.__author_life_years: str = ""
+        self.__author_birth_year: int = -1
+        self.__author_death_year: int = -1
+        self.__name_variations: List[str] = []
+        self.__full_record: dict = {}
+
+
+    def _parse_year(self, year: str) -> int:
+        year = year.strip()
+        _year = self.__default_year
+        if len(year) >= 4:
+            if year[:4].isnumeric():
+                _year = int(year[:4])
+        elif len(year) == 3 and year.isnumeric():
+            _year = int(year)
+        return _year
+
+    @property
+    def name(self) -> str:
+        if not self.__name:
+            values = self.get_values(
+                marc_ids=self.__name_field_id,
+                subfield_id="t"
+            )
+            if values:
+                self.__name = self._clean_value(values[0])
+            else:
+                pass
+        return self.__name
+
+
+    @property
+    def year(self) -> str:
+        if self.__year == -1:
+            values = self.get_values(
+                marc_ids=self.__year_field_id,
+                subfield_id="k"
+            )
+            self.__year = self._clean_value(values[0]) if values else None
+        return self.__year
+
+    @property
+    def type(self) -> str:
+        if not self.__type:
+            values = self.get_values(
+                marc_ids = self.__type_field_id,
+                subfield_id="a"
+            )
+            self.__type = self._clean_value(values[0]) if values else ""
+        return self.__type
+
+    @property
+    def author_original_name(self) -> str:
+        if not self.__author_original_name:
+            values = self.get_values(
+                marc_ids=self.__name_field_id,
+                subfield_id=["a", "b"]
+            )
+            if values:
+                self.__author_original_name = {
+                    "a": self._clean_value(values[0].get("a", "")),
+                    "b": self._clean_value(values[0].get("b", ""))
+                }
+            else:
+                pass
+        return self.__author_original_name
+
+    @property
+    def author_name(self) -> str:
+        if not self.__author_name:
+            self.__author_name = self._merge_and_clean(self.author_original_name, ["a", "b"])
+        return self.__author_name
+
+    @property
+    def author_life_years(self) -> str:
+        if not self.__author_life_years:
+            values = self.get_values(
+                marc_ids = self.__name_field_id,
+                subfield_id="d"
+            )
+            self.__author_life_years = self._clean_value(values[0]) if values else ""
+        return self.__author_life_years
+
+
+    @property
+    def author_birth_year(self) -> int:
+        if self.__author_birth_year == -1:
+            try:
+                birth_year, death_year = self.author_life_years.split("-")
+                self.__author_birth_year = self._parse_year(birth_year)
+                self.__author_death_year = self._parse_year(death_year)
+            except Exception as e:
+                LOGGER.error(
+                    f"Failed extracting birth and/or death year " \
+                    f"from '{self.author_life_years}' with the following " \
+                    f"exception: '{e}'."
+                )
+        return self.__author_birth_year
+
+
+    @property
+    def author_death_year(self) -> int:
+        if self.__author_death_year == -1:
+            try:
+                birth_year, death_year = self.author_life_years.split("-")
+                self.__author_birth_year = self._parse_year(birth_year)
+                self.__author_death_year = self._parse_year(death_year)
+            except Exception as e:
+                LOGGER.error(
+                    f"Failed extracting birth and/or death year " \
+                    f"from '{self.author_life_years}' with the following " \
+                    f"exception: '{e}'."
+                )
+        return self.__author_death_year
+
+    @property
+    def name_variations(self) -> List[str]:
+        if not self.__name_variations:
+            values = self.get_values(
+                marc_ids=self.__name_variations_field_id,
+                subfield_id="t"
+            )
+            variations = [self.name]
+            if values:
+                _variations = [
+                    self._clean_value(value)
+                    for value in values
+                ]
+                variations.extend(_variations)
+            variations = [v.lower() for v in variations]
+            self.__name_variations = list(set(variations))
+        return self.__name_variations
+
+
+    @property
+    def full_record(self) -> dict:
+        if not self.__full_record:
+            self.__full_record = {
+                "name": self.name,
+                "author_name": self.author_name,
+                "year": self.year,
+                "type": self.type,
+                "author_life_years": self.author_life_years,
+                "author_birth_year": self.author_birth_year,
+                "auhtor_death_year": self.author_death_year,
+                "name_variations": self.name_variations,
+                "full_record_marc": str(self.marc_record),
+                "full_record_json": json.dumps(self.marc_json_record)
+            }
+            if self.add_variations:
+                self.__full_record.update(
+                    {"link_variations": self.name_variations}
+                )
+
+        return self.__full_record

{rara_tools-0.4.3 → rara_tools-0.5.0/rara_tools.egg-info}/PKG-INFO

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

{rara_tools-0.4.3 → rara_tools-0.5.0}/tests/test_marc_parsers.py

@@ -4,12 +4,14 @@ from rara_tools.parsers.marc_parsers.ems_parser import EMSMARCParser
 from rara_tools.parsers.marc_parsers.person_parser import PersonsMARCParser
 from rara_tools.parsers.marc_parsers.organization_parser import OrganizationsMARCParser
 from rara_tools.parsers.marc_parsers.location_parser import LocationMARCParser
+from rara_tools.parsers.marc_parsers.title_parser import TitlesMARCParser
 
 
 MARC_ROOT_DIR = os.path.join("tests", "test_data", "marc_records")
 EMS_TEST_FILE = os.path.join(MARC_ROOT_DIR, "ems_test_subset.mrc")
 PER_TEST_FILE = os.path.join(MARC_ROOT_DIR, "per_test_subset.mrc")
 ORG_TEST_FILE = os.path.join(MARC_ROOT_DIR, "org_test_subset.mrc")
+TITLE_TEST_FILE = os.path.join(MARC_ROOT_DIR, "title_test_subset.mrc")
 
 def test_ems_parser_without_variations():
     ems_marc_parser = EMSMARCParser(EMS_TEST_FILE, add_variations=False)
@@ -47,3 +49,10 @@ def test_organizations_parser_without_variations():
     for record in org_marc_parser.record_generator():
         assert "name" in record
         assert "link_variations" not in record
+
+def test_title_parser_with_variations():
+    title_marc_parser = TitlesMARCParser(TITLE_TEST_FILE, add_variations=True)
+    for record in title_marc_parser.record_generator():
+        assert "name" in record
+        assert "link_variations" in record
+        assert len(record["link_variations"]) > 0

{rara_tools-0.4.3 → rara_tools-0.5.0}/tests/test_sierra_converters.py

@@ -44,25 +44,16 @@ example_res = {
 def test_convert_bibs_response():
 
     data = get_formatted_sierra_response("bibs.json")
-
+    
     expected = read_json_file(os.path.join(SIERRA_OUTPUT_DIR, "bibs.json"))
 
     assert compare_results(expected, data)
 
 
-def test_convert_keywords_response():
-
-    data = get_formatted_sierra_response("keywords.json")
-
-    expected = read_json_file(os.path.join(SIERRA_OUTPUT_DIR, "keywords.json"))
-
-    assert compare_results(expected, data)
-
-
 def test_convert_authorities_response():
 
     data = get_formatted_sierra_response("authorities.json")
-
+    
     expected = read_json_file(os.path.join(
         SIERRA_OUTPUT_DIR, "authorities.json"))
 

rara_tools-0.4.3/VERSION

@@ -1 +0,0 @@
-0.4.3

rara_tools-0.4.3/rara_tools/parsers/marc_parsers/title_parser.py

@@ -1 +0,0 @@
-# Coming soon

rara_tools-0.4.3/rara_tools/parsers/marc_records/title_record.py

@@ -1 +0,0 @@
-# Coming soon