Changes for path resolver (#23)

* Changes for path resolver

* Moved the path resolver to Util and updated the test case

* Added Abstraction for file provider and refactored the code accordingly

* updated file provider test cases

* renamed file provider and updated its reference

* File Provider changes

* Fixed the Stage Object file function and formatted the files

* Changes to reflect the locref as relative path

* Removed unused reference

* Added fileprovider dependency to test_store_resource

* Update poetry.lock

* Update poetry.lock

* removed commented resolve

Author: jayamala17

Diff for: dor/providers/file_provider.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class FileProvider(ABC):
+    @abstractmethod
+    def apply_relative_path(self, base_path: Path, path_to_apply: str) -> Path:
+        pass
+
+    @abstractmethod
+    def get_descriptor_dir(self, file_path: Path) -> Path:
+        pass
+
+    @abstractmethod
+    def get_norm_path(self, base_path: Path, path_to_apply: str) -> Path:
+        pass

Diff for: dor/providers/file_system_file_provider.py

@@ -0,0 +1,19 @@
+import os
+from pathlib import Path
+from dor.providers.file_provider import FileProvider
+
+
+class FilesystemFileProvider(FileProvider):
+
+    def apply_relative_path(self, base_path: Path, path_to_apply: str) -> Path:
+        resolved_combined_path = self.get_norm_path(base_path, path_to_apply)
+        final_path = resolved_combined_path.relative_to(base_path.parent)
+        return final_path
+
+    def get_descriptor_dir(self, file_path: Path) -> Path:
+        return file_path.parent
+
+    def get_norm_path(self, base_path: Path, path_to_apply: str) -> Path:
+        combined_path = os.path.join(base_path, path_to_apply)
+        resolved_combined_path = Path(os.path.normpath(combined_path))
+        return resolved_combined_path

Diff for: dor/providers/models.py

@@ -33,17 +33,17 @@ class PreservationEvent:
 @dataclass
 class FileReference:
     locref: str
-    mdtype: Optional[str] = None
-    mimetype: Optional[str] = None
+    mdtype: str | None = None
+    mimetype: str | None = None
 
 
 @dataclass
 class FileMetadata:
     id: str
     use: str
-    mdid: Optional[str] = None
-    groupid: Optional[str] = None
-    ref: FileReference = None
+    ref: FileReference
+    mdid: str | None = None
+    groupid: str | None = None
 
 
 class StructMapType(Enum):
@@ -56,7 +56,7 @@ class StructMapItem:
     order: int
     label: str
     asset_id: str
-    type: Optional[str] = None
+    type: str | None = None
 
 
 @dataclass
@@ -77,7 +77,7 @@ class PackageResource:
     struct_maps: list[StructMap] = field(default_factory=list)
 
     def get_entries(self) -> list[Path]:
-        entries = []
+        entries: list[Path] = []
         for file_metadata in self.metadata_files:
             if not file_metadata.ref.locref.startswith("https://"):
                 entries.append(Path(file_metadata.ref.locref))

Diff for: dor/providers/package_resource_provider.py

@@ -1,12 +1,14 @@
 from pathlib import Path
 
-from .parsers import DescriptorFileParser
+from dor.providers.file_provider import FileProvider
 
+from .parsers import DescriptorFileParser
 
 class PackageResourceProvider:
 
-    def __init__(self, data_path: Path):
+    def __init__(self, data_path: Path, file_provider: FileProvider):
         self.data_path = data_path
+        self.file_provider = file_provider
 
     @property
     def descriptor_files(self):
@@ -15,5 +17,6 @@ def descriptor_files(self):
 
     def get_resources(self):
         return [
-            DescriptorFileParser(file).get_resource() for file in self.descriptor_files
+            DescriptorFileParser(file, self.file_provider).get_resource() for file in self.descriptor_files
         ]
+        

Diff for: dor/providers/parsers.py

@@ -1,8 +1,20 @@
 from datetime import datetime
 import uuid
+from pathlib import Path
 
+from dor.providers.file_provider import FileProvider
 from utils.element_adapter import ElementAdapter
-from .models import *
+from .models import (
+    Agent,
+    AlternateIdentifier,
+    FileMetadata,
+    FileReference,
+    PackageResource,
+    PreservationEvent,
+    StructMap,
+    StructMapItem,
+    StructMapType,
+)
 
 
 class DescriptorFileParser:
@@ -11,9 +23,13 @@ class DescriptorFileParser:
         "PREMIS": "http://www.loc.gov/premis/v3",
     }
 
-    def __init__(self, descriptor_path):
-        text = descriptor_path.read_text()
+    def __init__(self, descriptor_file_path: Path, file_provider: FileProvider):
+        text = descriptor_file_path.read_text()
         self.tree: ElementAdapter = ElementAdapter.from_string(text, self.namespaces)
+        self.file_provider = file_provider
+        self.descriptor_path: Path = file_provider.get_descriptor_dir(
+            descriptor_file_path
+        )
 
     def get_id(self):
         return uuid.UUID(self.tree.get("OBJID"))
@@ -22,17 +38,16 @@ def get_type(self):
         hdr = self.tree.find("METS:metsHdr")
         return hdr.get("TYPE")
 
-    def get_alternate_identifier(self):
+    def get_alternate_identifier(self) -> AlternateIdentifier:
         alt_record_id = self.tree.find("METS:metsHdr/METS:altRecordID")
-        if alt_record_id:
-            return AlternateIdentifier(
-                type=alt_record_id.get("TYPE"), id=alt_record_id.text
-            )
+        return AlternateIdentifier(
+            type=alt_record_id.get("TYPE"), id=alt_record_id.text
+        )
 
     def get_preservation_events(self) -> list[PreservationEvent]:
         return [self.get_event(elem) for elem in self.tree.findall(".//PREMIS:event")]
 
-    def get_event(self, elem) -> PreservationEvent:
+    def get_event(self, elem: ElementAdapter) -> PreservationEvent:
         event_identifier = elem.find(".//PREMIS:eventIdentifierValue").text
         event_type = elem.find(".//PREMIS:eventType").text
         event_datetime = elem.find(".//PREMIS:eventDateTime").text
@@ -59,56 +74,68 @@ def get_data_files(self) -> list[FileMetadata]:
             for elem in self.tree.findall(".//METS:file")
         ]
 
-    def get_md_file_metadatum(self, elem):
+    def get_md_file_metadatum(self, elem: ElementAdapter):
         id_ = elem.get("ID")
         use = elem.get("USE")
-        locref = elem.find("METS:mdRef").get_optional("LOCREF")
-        mdtype = elem.find("METS:mdRef").get_optional("MDTYPE")
-        mimetype = elem.find("METS:mdRef").get_optional("MIMETYPE")
+        md_ref_element = elem.find("METS:mdRef")
+        locref = md_ref_element.get("LOCREF")
+        if not locref.startswith("https"):
+            locref = self.file_provider.apply_relative_path(
+                self.descriptor_path, locref
+            )
+        mdtype = md_ref_element.get_optional("MDTYPE")
+        mimetype = md_ref_element.get_optional("MIMETYPE")
 
         return FileMetadata(
             id=id_,
             use=use,
-            ref=FileReference(locref=locref, mdtype=mdtype, mimetype=mimetype),
+            ref=FileReference(locref=str(locref), mdtype=mdtype, mimetype=mimetype),
         )
 
-    def get_filesec_file_metadatum(self, elem):
+    def get_filesec_file_metadatum(self, elem: ElementAdapter):
         id_ = elem.get("ID")
         use = elem.get("USE")
-        mdid = elem.get_optional("MDID", None)
-        groupid = elem.get_optional("GROUPID", None)
-        mimetype = elem.get('MIMETYPE')
+        mdid = elem.get_optional("MDID")
+        groupid = elem.get_optional("GROUPID")
+        mimetype = elem.get_optional("MIMETYPE")
         mdtype = None
-        locref = elem.find("METS:FLocat").get_optional("LOCREF")
+        flocat_element = elem.find("METS:FLocat")
+        locref = flocat_element.get("LOCREF")
+        if not locref.startswith("https"):
+            locref = self.file_provider.apply_relative_path(
+                self.descriptor_path, locref
+            )
 
         return FileMetadata(
             id=id_,
             use=use,
             mdid=mdid,
             groupid=groupid,
-            ref=FileReference(locref=locref, mdtype=mdtype, mimetype=mimetype),
+            ref=FileReference(locref=str(locref), mdtype=mdtype, mimetype=mimetype),
         )
 
-    def get_struct_maps(self):
-        struct_maps = []
+    def get_struct_maps(self) -> list[StructMap]:
+        struct_maps: list[StructMap] = []
         for struct_map_elem in self.tree.findall(".//METS:structMap"):
             struct_map_id = struct_map_elem.get("ID")
             struct_map_type = struct_map_elem.get("TYPE")
 
             order_elems = struct_map_elem.findall(".//METS:div[@ORDER]")
 
-            struct_map_items = []
+            struct_map_items: list[StructMapItem] = []
             for order_elem in order_elems:
                 order_number = int(order_elem.get("ORDER"))
                 label = order_elem.get("LABEL")
                 asset_id = order_elem.get("ID")
-                order_elem_type = order_elem.get_optional("TYPE", None)
-                struct_map_items.append(StructMapItem(
-                    order=order_number,
-                    label=label,
-                    asset_id=asset_id,
-                    type=order_elem_type,
-                ))
+                order_elem_type = order_elem.get_optional("TYPE")
+                struct_map_items.append(
+                    StructMapItem(
+                        order=order_number,
+                        label=label,
+                        asset_id=asset_id,
+                        type=order_elem_type,
+                    )
+                )
 
             struct_maps.append(
                 StructMap(

Diff for: dor/providers/translocator.py

@@ -37,20 +37,11 @@ def object_data_directory(self) -> Path:
         if self.root_identifier is None:
             raise Exception()
         return self.package_directory() / "data" / self.root_identifier
-    
-    def _apply_relative_path(self, path: Path, path_to_apply: Path) -> Path:
-        return (path / path_to_apply).resolve().relative_to(self.object_data_directory().resolve())
 
     def get_bundle(self, entries: list[Path]) -> Bundle:
-        resolved_entries = []
-        for entry in entries:
-            resolved_entries.append(
-                self._apply_relative_path(self.object_data_directory() / "descriptor", entry)
-            )
-
         return Bundle(
             root_path=self.object_data_directory(),
-            entries=resolved_entries
+            entries=entries
         )
 
 

Diff for: dor/service_layer/handlers/store_files.py

@@ -1,11 +1,12 @@
+from pathlib import Path
 from dor.domain.events import PackageStored, PackageUnpacked
 from dor.service_layer.unit_of_work import UnitOfWork
 
 
 def store_files(event: PackageUnpacked, uow: UnitOfWork, workspace_class: type) -> None:
     workspace = workspace_class(event.workspace_identifier, event.identifier)
 
-    entries = []
+    entries: list[Path] = []
     for resource in event.resources:
         entries.extend(resource.get_entries())
 
@@ -19,11 +20,10 @@ def store_files(event: PackageUnpacked, uow: UnitOfWork, workspace_class: type)
     uow.gateway.commit_object_changes(
         id=event.identifier,
         coordinator=event.version_info.coordinator,
-        message=event.version_info.message
+        message=event.version_info.message,
     )
 
     stored_event = PackageStored(
-        identifier=event.identifier,
-        tracking_identifier=event.tracking_identifier
+        identifier=event.identifier, tracking_identifier=event.tracking_identifier
     )
-    uow.add_event(stored_event)
+    uow.add_event(stored_event)

Diff for: dor/service_layer/handlers/unpack_package.py

@@ -1,34 +1,41 @@
 from dor.domain.events import PackageUnpacked, PackageVerified
 from dor.domain.models import VersionInfo
+from dor.providers.file_provider import FileProvider
 from dor.service_layer.unit_of_work import UnitOfWork
 from gateway.coordinator import Coordinator
 
+
 def unpack_package(
     event: PackageVerified,
     uow: UnitOfWork,
     bag_adapter_class: type,
     package_resource_provider_class: type,
-    workspace_class: type
+    workspace_class: type,
+    file_provider: FileProvider,
 ) -> None:
     workspace = workspace_class(event.workspace_identifier)
     bag_adapter = bag_adapter_class(workspace.package_directory())
 
     info = bag_adapter.dor_info
     workspace.root_identifier = info["Root-Identifier"]
-    resources = package_resource_provider_class(workspace.object_data_directory()).get_resources()
+    resources = package_resource_provider_class(
+        workspace.object_data_directory(), file_provider
+    ).get_resources()
 
-    root_resource = [ r for r in resources if str(r.id) == info['Root-Identifier'] ][0]
-    preservation_event = [e for e in root_resource.events if e.type == 'ingest'][0]
+    root_resource = [r for r in resources if str(r.id) == info["Root-Identifier"]][0]
+    preservation_event = [e for e in root_resource.events if e.type == "ingest"][0]
 
     unpacked_event = PackageUnpacked(
-        identifier=info['Root-Identifier'],
+        identifier=info["Root-Identifier"],
         tracking_identifier=event.tracking_identifier,
         package_identifier=event.package_identifier,
         workspace_identifier=event.workspace_identifier,
         resources=resources,
         version_info=VersionInfo(
-            coordinator=Coordinator(preservation_event.agent.address, preservation_event.agent.address),
-            message=preservation_event.detail
-        )
+            coordinator=Coordinator(
+                preservation_event.agent.address, preservation_event.agent.address
+            ),
+            message=preservation_event.detail,
+        ),
     )
-    uow.add_event(unpacked_event)
+    uow.add_event(unpacked_event)