dsp-tools 0.9.13__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/xmlupload/CLAUDE.md

@@ -0,0 +1,292 @@
+# CLAUDE.md - xmlupload command
+
+This file provides guidance to Claude Code when working with the `xmlupload` command in DSP-TOOLS.
+
+## Module Overview
+
+The `xmlupload` package implements the core functionality for uploading XML data files to a DSP server. 
+It handles the complete workflow from XML parsing and validation to resource creation on the DSP server, including:
+
+- XML file parsing and validation
+- Resource processing and transformation
+- Circular reference resolution via stashing
+- Upload of multimedia files referenced in the XML file, and ingest management
+- RDF graph generation for DSP-API
+- Error handling and recovery mechanisms
+
+## Architecture
+
+### Core Entry Point
+
+- **xmlupload.py**: Main entry point containing the `xmlupload()` function and workflow orchestration
+- **upload_config.py**: Configuration management for upload operations
+
+### Key Workflow Stages
+
+1. **XML Input Processing** (`prepare_xml_input/`)
+   - Parse and validate XML files
+   - Transform input values to processed format
+   - Resolve ARKs to IRIs
+   - Validate IIIF URIs and check if bitstreams (i.e. referenced multimedia files) exist
+
+2. **Resource Processing** (`models/processed/`)
+   - Transform parsed resources to processed format
+   - Handle permissions and metadata
+   - Manage file values and IIIF URIs
+
+3. **Circular Reference Handling** (`stash/`)
+   - Detect circular references between resources
+   - Create stash for problematic references
+   - Generate upload order to resolve dependencies
+
+4. **RDF Graph Generation** (`make_rdf_graph/`)
+   - Convert processed resources to RDF graphs
+   - Handle file values and metadata
+   - Generate JSON-LD for DSP API consumption
+
+5. **Resource Creation**
+   - Upload resources to DSP server via API calls
+   - Handle file ingestion process
+   - Manage upload state and recovery
+
+### Key Components
+
+#### prepare_xml_input/
+
+- **prepare_xml_input.py**: Main orchestration for XML processing pipeline
+- **read_validate_xml_file.py**: XML file reading and validation logic
+- **get_processed_resources.py**: Transform parsed resources to processed format
+- **transform_input_values.py**: Value transformation utilities
+- **ark2iri.py**: ARK to IRI resolution
+- **iiif_uri_validator.py**: IIIF URI validation
+- **list_client.py**: Client for list node lookups
+
+#### models/
+
+- **processed/**: Data models for processed resources and values
+    - **res.py**: `ProcessedResource` and `MigrationMetadata` models
+    - **values.py**: Various processed value types
+    - **file_values.py**: Value models for Files
+- **lookup_models.py**: Lookup tables for IRIs and XML references
+- **upload_state.py**: State management for upload operations
+- **upload_clients.py**: Client collection for various services
+- **ingest.py**: File ingest process models
+- **permission.py**: Permission handling models
+- **bitstream_info.py**: Bitstream metadata models
+- **input_problems.py**: Input validation problem tracking
+
+#### stash/
+
+- **stash_models.py**: Data models for stashing circular references
+    - `StandoffStash`: Manages stashed RichtextValue with standoff markup
+    - `StandoffStashItem`: Individual stashed RichtextValue
+    - `LinkObjStash`: Manages stashed LinkValue references
+- **stash_circular_references.py**: Logic for detecting and stashing circular references
+- **analyse_circular_reference_graph.py**: Graph analysis for upload ordering
+- **create_info_for_graph.py**: Graph information extraction
+- **upload_stashed_resptr_props.py**: Upload stashed resource pointer properties
+- **upload_stashed_xml_texts.py**: Upload stashed XML text values
+
+#### make_rdf_graph/
+
+- **make_resource_and_values.py**: Main RDF graph creation logic, creates resources and calls other functionalities
+- **make_values.py**: RDF generation for various value types
+- **make_file_value.py**: File value RDF generation
+- **jsonld_utils.py**: JSON-LD serialization utilities
+- **constants.py**: RDF-related constants and mappings
+
+#### Client Classes
+
+- **resource_create_client.py**: `ResourceCreateClient` for creating resources via DSP API
+- **project_client.py**: `ProjectClient` for project-related operations
+- **iri_resolver.py**: IRI resolution utilities
+
+#### Utilities
+
+- **write_diagnostic_info.py**: Generates JSON files mapping XML resource IDs to DSP server IRIs 
+  for troubleshooting and post-upload reference
+
+## Key Data Models
+
+### ProcessedResource
+
+The central data model representing a fully processed resource ready for upload:
+The class `ProcessedResource` in `models/processed/res.py`
+
+The `ProcessedResource` is created from the `ParsedResources`
+
+### Stash Models
+
+For handling circular references:
+
+- **StandoffStash**: Manages stashed Richtext values with standoff markup
+- **LinkObjStash**: Manages stashed resource pointer properties
+
+### Upload Configuration
+
+- **UploadConfig**: Central configuration management
+- **UploadState**: Tracks upload progress and enables resumption
+
+## Workflow
+
+### Standard XMLUpload Flow
+
+1. **Initialization**: Load configuration, authenticate, set up clients
+2. **XML Processing**: Parse XML, validate structure, transform to processed resources
+3. **Dependency Analysis**: Detect circular references, create stashes
+4. **Upload Order Generation**: Determine optimal upload sequence
+5. **Resource Creation**: Upload resources individually, handle file ingestion
+6. **Stash Resolution**: Upload previously stashed references
+7. **Cleanup**: Write diagnostic info, clean up temporary files
+
+### File Handling
+
+- Supports both local file uploads and IIIF URI references
+- Integrates with DSP ingest service for file processing
+- Handles various media types (images, audio, video, documents, archives)
+
+### Error Handling
+
+- Comprehensive error tracking and reporting
+- Support for resuming interrupted uploads
+- Validation at multiple stages (XML, values, permissions)
+- Comprehensive diagnostic output including ID-to-IRI mappings and upload state persistence
+
+## Diagnostic Output and Troubleshooting
+
+### ID-to-IRI Mapping Files
+
+The xmlupload process automatically generates diagnostic files containing mappings of internal XML IDs to DSP IRIs:
+
+#### File Generation (`write_diagnostic_info.py`)
+
+- **Function**: `write_id2iri_mapping(id2iri_mapping, shortcode, diagnostics)`
+- **Purpose**: Creates JSON files mapping XML resource IDs to their corresponding DSP server IRIs
+- **Timing**: Generated at the end of successful uploads (called in `xmlupload.py`)
+
+#### State Management
+
+- **Save Location**: Configurable via `DiagnosticsConfig.save_location`
+- **Default Path**: `~/.dsp-tools/xmluploads/`
+- **Cleanup**: State files are automatically removed after successful completion
+- **Persistence**: Used for resuming interrupted uploads with `resume-xmlupload`
+
+#### Upload State Contents
+
+The saved state includes:
+
+- Progress tracking for resource uploads
+- Failed upload information
+- Pending stash items (circular references)
+- IRI resolver lookup table
+- Upload configuration parameters
+
+### Troubleshooting Workflow
+
+#### 1. Upload Interruption Handling
+
+When an upload fails or is interrupted:
+
+- Upload state is preserved in `~/.dsp-tools/xmluploads/`
+- ID-to-IRI mappings are written for successfully uploaded resources
+- Use `dsp-tools resume-xmlupload` to continue from the last checkpoint
+
+#### 2. Diagnostic File Analysis
+
+- **Check ID mappings**: Verify which resources were successfully created
+- **Cross-reference with XML**: Compare XML IDs with generated IRIs
+- **State inspection**: Examine saved upload state for failure points
+
+#### 3. Error Recovery
+
+- Failed uploads are tracked in the upload state
+- Stash failures prevent completion but preserve progress
+- State cleanup occurs only after full success confirmation
+
+## Important Design Patterns
+
+### Client Abstraction
+
+
+- Separate client classes for different DSP-API endpoints
+- Live implementations for actual server communication
+- Interface-based design for testing and mocking
+
+### Pipeline Processing
+
+
+- Multi-stage transformation pipeline from XML to RDF
+- Clear separation between parsing, processing, and uploading
+- Intermediate data models at each stage
+
+### Stashing Strategy
+
+
+- Sophisticated circular reference detection and resolution
+- Two-phase upload process (resources first, then stashed references)
+- Graph analysis for optimal upload ordering
+
+
+## Testing Considerations
+
+- Unit tests should focus on individual transformation functions
+- Integration tests should verify the full pipeline with sample data
+- Mock clients for testing without server dependencies
+- Test circular reference scenarios thoroughly
+- Validate error handling and recovery mechanisms
+
+## Common Issues and Solutions
+
+### Circular References
+
+- Handled automatically via stashing mechanism
+- Resources uploaded first, then cross-references added
+- Graph analysis determines optimal upload order
+
+### File Upload
+
+- Separate file upload from data upload
+
+### Performance Optimization
+
+- Batch processing for large datasets
+- Progress tracking with tqdm
+- Memory-efficient streaming for large files
+
+## Development Guidelines
+
+- Follow existing patterns for client implementations
+- Use dataclasses for model definitions
+- Implement comprehensive error handling
+- Add type hints for all new code
+- Write descriptive docstrings for public functions and classes
+- Use dependency injection for testability
+
+## Key Files to Reference
+
+When working on xmlupload functionality, these are the most important files to understand:
+
+- `xmlupload.py` - Main upload workflow orchestration
+- `prepare_xml_input/prepare_xml_input.py` - XML processing pipeline
+- `models/processed/res.py` - Core ProcessedResource model
+- `stash/stash_circular_references.py` - Circular reference handling
+- `make_rdf_graph/make_resource_and_values.py` - RDF generation
+- `resource_create_client.py` - DSP-API resource creation
+
+## Module Dependencies
+
+The xmlupload package depends on:
+
+- Core DSP-TOOLS utilities (`utils/xml_parsing/`, `utils/data_formats/`)
+- Client libraries (`clients/`)
+- Legacy models (`legacy_models/`)
+- Configuration and CLI args (`cli/args.py`)
+- External libraries: `lxml`, `rdflib`, `tqdm`, `loguru`
+
+## Integration Points
+
+- **CLI Integration**: Called from `dsp-tools xmlupload` command
+- **Validation Integration**: Uses `validate_data` module for SHACL validation
+- **File Services**: Integrates with DSP ingest service for file processing
+- **Authentication**: Uses authentication clients for server access
+- **Logging**: Comprehensive logging throughout the pipeline

dsp_tools/commands/xmlupload/iri_resolver.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from dataclasses import field
+
+
+@dataclass
+class IriResolver:
+    """Service for resolving internal IDs to IRIs."""
+
+    lookup: dict[str, str] = field(default_factory=dict)
+
+    def update(self, internal_id: str, iri: str) -> None:
+        """Adds or updates an internal ID to IRI mapping"""
+        self.lookup[internal_id] = iri
+
+    def get(self, internal_id: str) -> str | None:
+        """Resolves an internal ID to an IRI."""
+        return self.lookup.get(internal_id)
+
+    def non_empty(self) -> bool:
+        """Checks if the resolver is empty."""
+        return bool(self.lookup)

dsp_tools/commands/xmlupload/make_rdf_graph/constants.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from rdflib import XSD
+
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedBoolean
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedColor
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedDecimal
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedGeometry
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedGeoname
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedInt
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedSimpleText
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedTime
+from dsp_tools.commands.xmlupload.models.processed.values import ProcessedUri
+from dsp_tools.commands.xmlupload.models.rdf_models import RDFPropTypeInfo
+from dsp_tools.utils.rdf_constants import KNORA_API
+from dsp_tools.utils.xml_parsing.models.parsed_resource import KnoraValueType
+
+# values that need special considerations during the graph construction
+LIST_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.ListValue, KNORA_API.listValueAsListNode)
+LINK_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.LinkValue, KNORA_API.linkValueHasTargetIri)
+RICHTEXT_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.TextValue, KNORA_API.textValueAsXml, XSD.string)
+
+# values suitable for the generic lookup
+BOOLEAN_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.BooleanValue, KNORA_API.booleanValueAsBoolean, XSD.boolean)
+COLOR_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.ColorValue, KNORA_API.colorValueAsColor, XSD.string)
+DECIMAL_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.DecimalValue, KNORA_API.decimalValueAsDecimal, XSD.decimal)
+GEOMETRY_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.GeomValue, KNORA_API.geometryValueAsGeometry, XSD.string)
+GEONAME_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.GeonameValue, KNORA_API.geonameValueAsGeonameCode, XSD.string)
+INT_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.IntValue, KNORA_API.intValueAsInt, XSD.int)
+SIMPLE_TEXT_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.TextValue, KNORA_API.valueAsString, XSD.string)
+TIME_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.TimeValue, KNORA_API.timeValueAsTimeStamp, XSD.dateTimeStamp)
+URI_PROP_TYPE_INFO = RDFPropTypeInfo(KNORA_API.UriValue, KNORA_API.uriValueAsUri, XSD.anyURI)
+
+RDF_LITERAL_PROP_TYPE_MAPPER = {
+    ProcessedBoolean: BOOLEAN_PROP_TYPE_INFO,
+    ProcessedColor: COLOR_PROP_TYPE_INFO,
+    ProcessedDecimal: DECIMAL_PROP_TYPE_INFO,
+    ProcessedGeometry: GEOMETRY_PROP_TYPE_INFO,
+    ProcessedGeoname: GEONAME_PROP_TYPE_INFO,
+    ProcessedInt: INT_PROP_TYPE_INFO,
+    ProcessedSimpleText: SIMPLE_TEXT_PROP_TYPE_INFO,
+    ProcessedTime: TIME_PROP_TYPE_INFO,
+    ProcessedUri: URI_PROP_TYPE_INFO,
+}
+
+# file values
+ARCHIVE_FILE_VALUE = RDFPropTypeInfo(KNORA_API.ArchiveFileValue, KNORA_API.hasArchiveFileValue, XSD.string)
+AUDIO_FILE_VALUE = RDFPropTypeInfo(KNORA_API.AudioFileValue, KNORA_API.hasAudioFileValue, XSD.string)
+DOCUMENT_FILE_VALUE = RDFPropTypeInfo(KNORA_API.DocumentFileValue, KNORA_API.hasDocumentFileValue, XSD.string)
+MOVING_IMAGE_FILE_VALUE = RDFPropTypeInfo(KNORA_API.MovingImageFileValue, KNORA_API.hasMovingImageFileValue, XSD.string)
+STILL_IMAGE_FILE_VALUE = RDFPropTypeInfo(KNORA_API.StillImageFileValue, KNORA_API.hasStillImageFileValue, XSD.string)
+TEXT_FILE_VALUE = RDFPropTypeInfo(KNORA_API.TextFileValue, KNORA_API.hasTextFileValue, XSD.string)
+IIIF_URI_VALUE = RDFPropTypeInfo(KNORA_API.StillImageExternalFileValue, KNORA_API.hasStillImageFileValue, XSD.anyURI)
+
+
+FILE_TYPE_TO_RDF_MAPPER = {
+    KnoraValueType.ARCHIVE_FILE: ARCHIVE_FILE_VALUE,
+    KnoraValueType.AUDIO_FILE: AUDIO_FILE_VALUE,
+    KnoraValueType.DOCUMENT_FILE: DOCUMENT_FILE_VALUE,
+    KnoraValueType.MOVING_IMAGE_FILE: MOVING_IMAGE_FILE_VALUE,
+    KnoraValueType.STILL_IMAGE_FILE: STILL_IMAGE_FILE_VALUE,
+    KnoraValueType.TEXT_FILE: TEXT_FILE_VALUE,
+}

dsp_tools/commands/xmlupload/make_rdf_graph/jsonld_utils.py

@@ -0,0 +1,44 @@
+import json
+from typing import Any
+
+from pyld import jsonld
+from rdflib import Graph
+
+
+def serialise_jsonld_for_resource(rdf_graph: Graph) -> dict[str, Any]:
+    json_graph = _serialise_json(rdf_graph)
+    return _frame_graph_for_resource(json_graph)
+
+
+def _frame_graph_for_resource(serialised_json: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    The result of the serialisation is a list.
+    Although the API would accept that, our connection has the payload typed as `dict[str, Any]`.
+    If the typing of the connection was changed or a different class was used, this step can be removed.
+
+    Args:
+        serialised_json: graph serialised as json-ld
+
+    Returns:
+        graph in a specific json-ld format
+    """
+    json_frame: dict[str, Any] = {"http://api.knora.org/ontology/knora-api/v2#attachedToProject": {}}
+    framed: dict[str, Any] = jsonld.frame(serialised_json, json_frame)
+    return framed
+
+
+def serialise_jsonld_for_value(rdf_graph: Graph, resource_iri_str: str) -> dict[str, Any]:
+    json_graph = _serialise_json(rdf_graph)
+    return _frame_graph_for_value(json_graph, resource_iri_str)
+
+
+def _frame_graph_for_value(serialised_json: list[dict[str, Any]], resource_iri_str: str) -> dict[str, Any]:
+    json_frame = {"@id": resource_iri_str}
+    framed: dict[str, Any] = jsonld.frame(serialised_json, json_frame)
+    return framed
+
+
+def _serialise_json(rdf_graph: Graph) -> list[dict[str, Any]]:
+    graph_bytes = rdf_graph.serialize(format="json-ld", encoding="utf-8")
+    json_graph: list[dict[str, Any]] = json.loads(graph_bytes)
+    return json_graph

dsp_tools/commands/xmlupload/make_rdf_graph/make_file_value.py

@@ -0,0 +1,77 @@
+from rdflib import RDF
+from rdflib import XSD
+from rdflib import BNode
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.commands.xmlupload.make_rdf_graph.constants import IIIF_URI_VALUE
+from dsp_tools.commands.xmlupload.models.bitstream_info import BitstreamInfo
+from dsp_tools.commands.xmlupload.models.rdf_models import AbstractFileValue
+from dsp_tools.commands.xmlupload.models.rdf_models import FileValueMetadata
+from dsp_tools.commands.xmlupload.models.rdf_models import RDFPropTypeInfo
+from dsp_tools.utils.rdf_constants import KNORA_API
+
+
+def make_iiif_uri_value_graph(iiif_uri: AbstractFileValue, res_node: BNode | URIRef) -> Graph:
+    """
+    Creates a graph with the IIIF-URI Link
+
+    Args:
+        iiif_uri: Information about the IIIF URI
+        res_node: Node of the resource
+
+    Returns:
+        Graph with the IIIF-URI Value
+    """
+    return _make_abstract_file_value_graph(
+        iiif_uri, IIIF_URI_VALUE, res_node, KNORA_API.stillImageFileValueHasExternalUrl
+    )
+
+
+def make_file_value_graph(
+    bitstream_info: BitstreamInfo,
+    rdf_prop_type_info: RDFPropTypeInfo,
+    file_value_metadata: FileValueMetadata,
+    res_node: BNode | URIRef,
+) -> Graph:
+    """
+    Creates a graph with the File Value information.
+
+    Args:
+        bitstream_info: Information about the previously uploaded file
+        rdf_prop_type_info: the type of value based on the extension
+        file_value_metadata: Metadata of the file value
+        res_node: Node of the resource
+
+    Returns:
+        Graph with the File Value
+    """
+    internal_filename = bitstream_info.internal_file_name
+    file_value = AbstractFileValue(internal_filename, file_value_metadata)
+    return _make_abstract_file_value_graph(file_value, rdf_prop_type_info, res_node)
+
+
+def _make_abstract_file_value_graph(
+    file_value: AbstractFileValue,
+    type_info: RDFPropTypeInfo,
+    res_node: BNode | URIRef,
+    has_file_name_prop: URIRef = KNORA_API.fileValueHasFilename,
+) -> Graph:
+    file_bn = BNode()
+    g = _add_metadata(file_bn, file_value.metadata)
+    g.add((res_node, type_info.knora_prop, file_bn))
+    g.add((file_bn, RDF.type, type_info.knora_type))
+    g.add((file_bn, has_file_name_prop, Literal(file_value.value, datatype=XSD.string)))
+    return g
+
+
+def _add_metadata(file_bn: BNode, metadata: FileValueMetadata) -> Graph:
+    g = Graph()
+    g.add((file_bn, KNORA_API.hasLicense, URIRef(metadata.license_iri)))
+    g.add((file_bn, KNORA_API.hasCopyrightHolder, Literal(metadata.copyright_holder, datatype=XSD.string)))
+    for auth in metadata.authorships:
+        g.add((file_bn, KNORA_API.hasAuthorship, Literal(auth, datatype=XSD.string)))
+    if metadata.permissions:
+        g.add((file_bn, KNORA_API.hasPermissions, Literal(metadata.permissions, datatype=XSD.string)))
+    return g

dsp_tools/commands/xmlupload/make_rdf_graph/make_resource_and_values.py

@@ -0,0 +1,114 @@
+from typing import cast
+
+from rdflib import RDF
+from rdflib import RDFS
+from rdflib import XSD
+from rdflib import BNode
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.commands.xmlupload.make_rdf_graph.constants import FILE_TYPE_TO_RDF_MAPPER
+from dsp_tools.commands.xmlupload.make_rdf_graph.make_file_value import make_file_value_graph
+from dsp_tools.commands.xmlupload.make_rdf_graph.make_file_value import make_iiif_uri_value_graph
+from dsp_tools.commands.xmlupload.make_rdf_graph.make_values import make_values
+from dsp_tools.commands.xmlupload.models.bitstream_info import BitstreamInfo
+from dsp_tools.commands.xmlupload.models.lookup_models import IRILookups
+from dsp_tools.commands.xmlupload.models.processed.file_values import ProcessedFileMetadata
+from dsp_tools.commands.xmlupload.models.processed.file_values import ProcessedFileValue
+from dsp_tools.commands.xmlupload.models.processed.res import MigrationMetadata
+from dsp_tools.commands.xmlupload.models.processed.res import ProcessedResource
+from dsp_tools.commands.xmlupload.models.rdf_models import AbstractFileValue
+from dsp_tools.commands.xmlupload.models.rdf_models import FileValueMetadata
+from dsp_tools.utils.rdf_constants import KNORA_API
+
+
+def create_resource_with_values(
+    resource: ProcessedResource,
+    bitstream_information: BitstreamInfo | None,
+    lookups: IRILookups,
+) -> Graph:
+    """
+    This function takes an XMLResource and serialises it into a json-ld type dict that can be sent to the API.
+
+    Args:
+        resource: XMLResource
+        bitstream_information: if the resource has a FileValue
+        lookups: Lookups to resolve IRIs, etc.
+
+    Returns:
+        A resource as a graph
+    """
+
+    graph = Graph()
+
+    res_node: BNode | URIRef = BNode()
+    if migration := resource.migration_metadata:
+        if migration.iri_str:
+            res_node = URIRef(migration.iri_str)
+        graph += _make_migration_metadata(migration, res_node)
+
+    graph += _make_resource(resource=resource, res_node=res_node, project_iri=lookups.project_iri)
+
+    graph += _make_values_graph_from_resource(
+        resource=resource, res_node=res_node, bitstream_information=bitstream_information, lookups=lookups
+    )
+
+    return graph
+
+
+def _make_values_graph_from_resource(
+    resource: ProcessedResource,
+    res_node: BNode | URIRef,
+    bitstream_information: BitstreamInfo | None,
+    lookups: IRILookups,
+) -> Graph:
+    properties_graph = make_values(resource.values, res_node, lookups)
+
+    if resource.iiif_uri:
+        metadata = _make_file_value_metadata(resource.iiif_uri.metadata)
+        iiif_g = make_iiif_uri_value_graph(AbstractFileValue(resource.iiif_uri.value, metadata), res_node)
+        properties_graph += iiif_g
+
+    elif bitstream_information:
+        file_val = cast(ProcessedFileValue, resource.file_value)
+        metadata = _make_file_value_metadata(file_val.metadata)
+        prop_type_info = FILE_TYPE_TO_RDF_MAPPER[file_val.file_type]
+        file_g = make_file_value_graph(
+            bitstream_info=bitstream_information,
+            rdf_prop_type_info=prop_type_info,
+            file_value_metadata=metadata,
+            res_node=res_node,
+        )
+        properties_graph += file_g
+
+    return properties_graph
+
+
+def _make_file_value_metadata(processed_metadata: ProcessedFileMetadata) -> FileValueMetadata:
+    permissions = None
+    if found := processed_metadata.permissions:
+        permissions = str(found)
+    return FileValueMetadata(
+        processed_metadata.license_iri,
+        processed_metadata.copyright_holder,
+        processed_metadata.authorships,
+        permissions,
+    )
+
+
+def _make_resource(resource: ProcessedResource, res_node: BNode | URIRef, project_iri: URIRef) -> Graph:
+    g = Graph()
+    g.add((res_node, RDF.type, URIRef(resource.type_iri)))
+    g.add((res_node, RDFS.label, Literal(resource.label, datatype=XSD.string)))
+    g.add((res_node, KNORA_API.attachedToProject, project_iri))
+    if resource.permissions:
+        g.add((res_node, KNORA_API.hasPermissions, Literal(str(resource.permissions), datatype=XSD.string)))
+    return g
+
+
+def _make_migration_metadata(migration_metadata: MigrationMetadata, res_node: BNode | URIRef) -> Graph:
+    g = Graph()
+    if date := migration_metadata.creation_date:
+        g.add((res_node, KNORA_API.creationDate, Literal(str(date), datatype=XSD.dateTimeStamp)))
+    return g