rara-tools 0.7.13__py3-none-any.whl → 0.7.14__py3-none-any.whl

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/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/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/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.13.dist-info → rara_tools-0.7.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rara-tools
-Version: 0.7.13
+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.13.dist-info → rara_tools-0.7.14.dist-info}/RECORD

@@ -12,7 +12,7 @@ rara_tools/constants/general.py,sha256=dLomRopLiHv_J_liSIGzK1A3XByydsKGIyVN8KuuN
 rara_tools/constants/language_evaluator.py,sha256=3sCSaoS-zXQRY0vJ7UUMuZqbtYQD_quVVbdpgvJjE7I,124
 rara_tools/constants/linker.py,sha256=WnOmJFTkoBMZUbBaW1uY45NTQB7FGG-dc9a_6qYTtwk,3381
 rara_tools/constants/meta_extractor.py,sha256=iVyxycKScbrjFWLv50dRmdeHfTLOKbdyEhgUF3DyBrY,1053
-rara_tools/constants/normalizers.py,sha256=Qyi6eSCp4Gnz45xF-vOPExGXasyAoVimOAAlLj1t74s,1383
+rara_tools/constants/normalizers.py,sha256=6s0CQNGiE0T6v8FUdfSRebkCJeGEBcEDo_9wmco-o8w,1410
 rara_tools/constants/parsers.py,sha256=L6nh1Itget9_9DMsliDkh6T25z78eMFPWVkbaU08DwU,5561
 rara_tools/constants/subject_indexer.py,sha256=0snyyB8IMCWXOYPXR_c0Kavq4nBiww559rdNOKjawx8,2133
 rara_tools/core_formatters/core_formatter.py,sha256=u_Cdgv9qBcyF-XddjaRGUqAFik9OMAdSzAulXpYR7vE,4997
@@ -20,9 +20,9 @@ rara_tools/core_formatters/formatted_keyword.py,sha256=hhi6wh4ErFionjBqYsEeKGbf1
 rara_tools/core_formatters/formatted_meta.py,sha256=WEnMs8K0YeTLGjXn_mxQTpshxcz5_9YjvqcbRFa3M1g,5605
 rara_tools/core_formatters/formatted_object.py,sha256=7a499ZmcZXOqtlwxDi6FWHWF5a6HdCsduS22wV3uHIE,5656
 rara_tools/normalizers/__init__.py,sha256=_NqpS5w710DhaURytHq9JpEt8HgYpSPfRDcOtOymJgE,193
-rara_tools/normalizers/authorities.py,sha256=w7r2KIFSnmo57Pt9YGsxYYCH8AkdNkiBBFHhpf1GLJA,4794
-rara_tools/normalizers/base.py,sha256=LzWdjzG_5zFGbzOCpUSOdmzrJJ7p23iODEtar8wDrrY,15942
-rara_tools/normalizers/bibs.py,sha256=7H-spiqj6x8Xk4JQkBY5GK7q5pKjYUmXTRFf0RgzC-w,4040
+rara_tools/normalizers/authorities.py,sha256=U3IjQW3XaxAiIJ30Jlq6ON8fdXgrtgNwrvX8oy_iKL0,5304
+rara_tools/normalizers/base.py,sha256=SkbzmAOX5C6PbEFC9i_mpzK1u6LMAh7PavG52ULeO2Y,19744
+rara_tools/normalizers/bibs.py,sha256=DMjJj1mCVVWRpL2NuR6b7W1RWqkx50xix34X_tyxJig,3931
 rara_tools/normalizers/reader.py,sha256=GYCkAtnsNx135w5lD-_MqCZzdHQHHPDF-pDxYj839Vo,1595
 rara_tools/normalizers/viaf.py,sha256=C-NfbvL83ZcHVB9ICMw43wAMYKTqDTHU3ZT2mXKec00,24288
 rara_tools/parsers/marc_parsers/base_parser.py,sha256=Kdw4aivJf2FkWgIK7pJtHtVXF_G1pjHVQ7IcFItSqy8,1649
@@ -39,8 +39,8 @@ rara_tools/parsers/marc_records/title_record.py,sha256=XrtJ4gj7wzSaGxNaPtPuawmqq
 rara_tools/parsers/tools/entity_normalizers.py,sha256=VyCy_NowCLpOsL0luQ55IW-Qi-J5oBH0Ofzr7HRFBhM,8949
 rara_tools/parsers/tools/marc_converter.py,sha256=LgSHe-7n7aiDrw2bnsB53r3fXTRFjZXTwBYfTpL0pfs,415
 rara_tools/parsers/tools/russian_transliterator.py,sha256=5ZU66iTqAhr7pmfVqXPAI_cidF43VqqmuN4d7H4_JuA,9770
-rara_tools-0.7.13.dist-info/licenses/LICENSE.md,sha256=hkZVnIZll7e_KNEQzeY94Y9tlzVL8iVZBTMBvDykksU,35142
-rara_tools-0.7.13.dist-info/METADATA,sha256=WOwPPJ8wE9B-0Mpf9BCWQalBzTaRg9L4GvpAhFK0PnI,4080
-rara_tools-0.7.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rara_tools-0.7.13.dist-info/top_level.txt,sha256=JwfB5b8BAtW5OFKRln2AQ_WElTRyIBM4nO0FKN1cupY,11
-rara_tools-0.7.13.dist-info/RECORD,,
+rara_tools-0.7.14.dist-info/licenses/LICENSE.md,sha256=hkZVnIZll7e_KNEQzeY94Y9tlzVL8iVZBTMBvDykksU,35142
+rara_tools-0.7.14.dist-info/METADATA,sha256=GIybax1V5ZqALB6SH-oN-e0Cu9-0dbt7rRph7lsEY-Q,4080
+rara_tools-0.7.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rara_tools-0.7.14.dist-info/top_level.txt,sha256=JwfB5b8BAtW5OFKRln2AQ_WElTRyIBM4nO0FKN1cupY,11
+rara_tools-0.7.14.dist-info/RECORD,,