rdetoolkit 1.5.2__tar.gz → 1.5.3__tar.gz

{rdetoolkit-1.5.2 → rdetoolkit-1.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdetoolkit
-Version: 1.5.2
+Version: 1.5.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{rdetoolkit-1.5.2 → rdetoolkit-1.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rdetoolkit"
-version = "1.5.2"
+version = "1.5.3"
 description = "A module that supports the workflow of the RDE dataset construction program"
 authors = [{ name = "NIMS MDPF", email = "rde@nims.go" }]
 keywords = ["rdetoolkit", "RDE", "toolkit", "structure", "dataset"]

{rdetoolkit-1.5.2 → rdetoolkit-1.5.3}/src/rdetoolkit/__init__.py

@@ -15,7 +15,7 @@ if sys.version_info < (3, 10):
 from importlib import import_module
 from typing import Any
 
-__version__ = "1.5.2"
+__version__ = "1.5.3"
 
 _LAZY_ATTRS: dict[str, tuple[str, str]] = {
     "DirectoryOps": ("rdetoolkit.core", "DirectoryOps"),

{rdetoolkit-1.5.2 → rdetoolkit-1.5.3}/src/rdetoolkit/invoicefile.py

@@ -160,16 +160,18 @@ def check_exist_rawfiles(dfexcelinvoice: pd.DataFrame, excel_rawfiles: list[Path
         excel_rawfiles (list[Path]): A list of Path objects representing file paths.
 
     Raises:
-        tructuredError: If any file name in dfexcelinvoice is not found in excel_rawfiles.
+        StructuredError: If any file name in dfexcelinvoice is not found in excel_rawfiles.
 
     Returns:
         list[Path]: A list of Path objects corresponding to the file names in dfexcelinvoice, ordered as they appear in the DataFrame.
     """
-    file_set_group = {f.name for f in excel_rawfiles}
-    file_set_invoice = set(dfexcelinvoice["data_file_names/name"])
-    if file_set_invoice - file_set_group:
-        emsg = f"ERROR: raw file not found: {(file_set_invoice-file_set_group).pop()}"
-        raise StructuredError(emsg)
+    file_set_group = {f.name for f in excel_rawfiles}
+    file_set_invoice = set(dfexcelinvoice["data_file_names/name"])
+    if file_set_invoice - file_set_group:
+        missing = sorted(file_set_invoice - file_set_group)
+        missing_display = (str(name) for name in missing)
+        emsg = f"ERROR: raw file not found: {', '.join(missing_display)}"
+        raise StructuredError(emsg)
     # Sort excel_rawfiles in the order they appear in the invoice
     _tmp = {f.name: f for f in excel_rawfiles}
     try:
@@ -1152,7 +1154,8 @@ class RuleBasedReplacer:
         Args:
             replacements (Mapping[str, Any]): The object containing mapping rules (read-only).
             source_json_obj (MutableMapping[str, Any] | None): Objects of key and value to which you want to apply the rule (performs nested assignments).
-            mapping_rules (Mapping[str, str] | None, optional): Rules for mapping key and value (read-only). Defaults to None.
+            mapping_rules (Mapping[str, str] | None, optional): Rules for mapping key and value (read-only).
+                If None, uses self.rules. Defaults to None.
 
         Returns:
             dict[str, Any]: dictionary type data after conversion
@@ -1173,13 +1176,12 @@ class RuleBasedReplacer:
             result = replacer.apply_rules(replacement_rule, save_file_path, mapping_rules = rule)
             print(result)
         """
-        # [TODO] Correction of type definitions in version 0.1.6
         if mapping_rules is None:
             mapping_rules = self.rules
         if source_json_obj is None:
             source_json_obj = {}
 
-        for key, value in self.rules.items():
+        for key, value in mapping_rules.items():
             keys = key.split(".")
             replace_value = replacements.get(value, "")
             current_obj: MutableMapping[str, Any] = source_json_obj

{rdetoolkit-1.5.2 → rdetoolkit-1.5.3}/src/rdetoolkit/processing/processors/invoice.py

@@ -411,6 +411,7 @@ class SmartTableInvoiceInitializer(Processor):
         """Apply SmartTable row data to invoice and collect metadata updates."""
         metadata_updates: dict[str, dict[str, Any]] = {}
         metadata_def: dict[str, Any] | None = None
+        csv_has_sample_owner_id = False
 
         # Handle empty CSV (no data rows)
         if len(csv_data) == 0:
@@ -435,10 +436,50 @@ class SmartTableInvoiceInitializer(Processor):
                 meta_key, meta_entry = self._process_meta_mapping(col, value, metadata_def)
                 metadata_updates[meta_key] = meta_entry
                 continue
+            # Track if sample/ownerId is explicitly specified in CSV
+            if col == "sample/ownerId":
+                csv_has_sample_owner_id = True
             self._process_mapping_key(col, value, invoice_data, invoice_schema_json_data)
 
+        # Set sample.ownerId to basic.dataOwnerId only if not specified in CSV
+        if not csv_has_sample_owner_id:
+            self._set_sample_owner_id(invoice_data)
+
         return metadata_updates
 
+    def _set_sample_owner_id(self, invoice_data: dict[str, Any]) -> None:
+        """Set sample.ownerId to basic.dataOwnerId for SmartTable processing.
+
+        This ensures that newly registered samples have the correct owner ID,
+        which should always be the data owner (registrant) rather than
+        any temporary sample owner selected in the invoice screen.
+
+        Args:
+            invoice_data: Invoice data dictionary to update.
+
+        Note:
+            - For new sample registration: Sets the correct owner ID
+            - For sample linking: The value is set but not used (safe to set)
+            - If basic.dataOwnerId is missing: Logs warning and preserves existing value
+        """
+        basic_section = invoice_data.get("basic", {})
+        data_owner_id = basic_section.get("dataOwnerId")
+
+        if data_owner_id is None or data_owner_id == "":
+            logger.warning(
+                "basic.dataOwnerId is missing or empty; sample.ownerId will not be updated. "
+                "This may cause incorrect sample owner assignment.",
+            )
+            return
+
+        sample_section = invoice_data.setdefault("sample", {})
+        sample_section["ownerId"] = data_owner_id
+
+        logger.debug(
+            "Set sample.ownerId to basic.dataOwnerId: %s",
+            data_owner_id,
+        )
+
     def _load_metadata_definition(self, metadata_def_path: Path) -> dict[str, Any]:
         """Load metadata definitions for SmartTable meta column processing.
 

{rdetoolkit-1.5.2 → rdetoolkit-1.5.3}/tests/test_invoicefile.py

@@ -777,6 +777,34 @@ def test_error_check_exist_rawfiles(inputfile_multi_excelinvoice):
     assert str(e.value) == "ERROR: raw file not found: test_child2.txt"
 
 
+def test_error_check_exist_rawfiles_multiple_missing(inputfile_multi_excelinvoice):
+    """Test that check_exist_rawfiles reports ALL missing files when multiple files are absent.
+
+    This test verifies that all missing files are reported in a single error message,
+    listed in alphabetical order, and separated by ", " for clarity.
+    """
+    # Preprocess test Excel invoice
+    df_excelinvoice = pd.read_excel(inputfile_multi_excelinvoice, sheet_name="invoice_form", dtype=str, header=None, index_col=None)
+    df = df_excelinvoice.dropna(axis=0, how="all").dropna(axis=1, how="all")
+    hd1 = list(df.iloc[1, :].fillna(""))
+    hd2 = list(df.iloc[2, :].fillna(""))
+    df.columns = [f"{s1}/{s2}" if s1 else s2 for s1, s2 in zip(hd1, hd2)]
+    df_excelinvoice = df.iloc[4:, :].reset_index(drop=True).copy()
+
+    # Test raw files - missing both test_child1.txt and test_child2.txt
+    test_excel_raw_files = [
+        Path("test_child3.txt"),
+        Path("test_child9.txt"),
+        Path("test_child10.txt"),
+    ]
+
+    with pytest.raises(StructuredError) as e:
+        _ = check_exist_rawfiles(df_excelinvoice, test_excel_raw_files)
+
+    # Expected: Both missing files listed in alphabetical order, separated by ", "
+    assert str(e.value) == "ERROR: raw file not found: test_child1.txt, test_child2.txt"
+
+
 def test_apply_magic_variable_inputfile_check(ivnoice_json_magic_filename_variable):
     """${filename}が置換できるかテスト
 

{rdetoolkit-1.5.2 → rdetoolkit-1.5.3}/tests/test_smarttable_invoice_initializer.py

@@ -1,15 +1,19 @@
-"""
-Equivalence Partitioning
+"""Test SmartTableInvoiceInitializer behavior with equivalence partitioning and boundary values.
+
+Equivalence Partitioning:
 | API                                   | Input/State Partition                                     | Rationale                                                     | Expected Outcome                                      | Test ID       |
 | ------------------------------------- | --------------------------------------------------------- | ------------------------------------------------------------- | ----------------------------------------------------- | ------------- |
-| `SmartTableInvoiceInitializer.process` | Multiple SmartTable rows with fresh processors per row    | Pipelines re-instantiate processors for each row              | Later invoices retain `sample.ownerId` after mutation | `TC-EP-001`   |
+| `SmartTableInvoiceInitializer.process` | Multiple SmartTable rows with fresh processors per row    | Pipelines re-instantiate processors for each row              | sample.ownerId is set to basic.dataOwnerId            | `TC-EP-001`   |
 | `SmartTableInvoiceInitializer.process` | Missing SmartTable row CSV in SmartTable mode              | Invalid SmartTable input should be rejected                    | Raises `StructuredError`                              | `TC-EP-002`   |
+| `SmartTableInvoiceInitializer.process` | basic.dataOwnerId is missing in original invoice           | Defensive handling when required field is absent              | Logs warning, preserves original sample.ownerId       | `TC-EP-003`   |
+| `SmartTableInvoiceInitializer.process` | SmartTable CSV contains sample/ownerId column              | CSV value should take precedence when explicitly specified    | sample.ownerId uses CSV value, not basic.dataOwnerId  | `TC-EP-004`   |
 
-Boundary Value
+Boundary Value:
 | API                                   | Boundary                                      | Rationale                                                    | Expected Outcome                                      | Test ID       |
 | ------------------------------------- | --------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------- | ------------- |
-| `SmartTableInvoiceInitializer.process` | First vs. subsequent invocation per invoice   | Cache must survive across pipeline instances and mutations   | Later invoices retain `sample.ownerId` after mutation | `TC-BV-001`   |
+| `SmartTableInvoiceInitializer.process` | First invocation with SmartTable row          | Automatic ownerId assignment from basic.dataOwnerId          | sample.ownerId is set to basic.dataOwnerId            | `TC-BV-001`   |
 | `SmartTableInvoiceInitializer.process` | `smarttable_file` is `None`                    | SmartTable mode should be enforced                           | Raises `ValueError`                                   | `TC-BV-002`   |
+| `SmartTableInvoiceInitializer.process` | basic.dataOwnerId is empty string              | Defensive handling when field is empty                       | Logs warning, preserves original sample.ownerId       | `TC-BV-003`   |
 """
 
 from __future__ import annotations
@@ -17,6 +21,7 @@ from __future__ import annotations
 import csv
 import json
 import shutil
+from collections.abc import Generator
 from pathlib import Path
 
 import pytest
@@ -32,7 +37,7 @@ from rdetoolkit.processing.processors.invoice import SmartTableInvoiceInitialize
 
 
 @pytest.fixture(autouse=True)
-def reset_initializer_cache() -> None:
+def reset_initializer_cache() -> Generator[None, None, None]:
     """Ensure SmartTable initializer cache isolation per test."""
     SmartTableInvoiceInitializer._BASE_INVOICE_CACHE.clear()
     yield
@@ -93,9 +98,12 @@ def _build_resource_paths(
 
 
 def test_smarttable_invoice_initializer_preserves_owner_id_after_source_mutation__tc_ep_001(tmp_path: Path) -> None:
+    """TC-EP-001: Multiple SmartTable rows with fresh processors per row preserve basic.dataOwnerId."""
     # Given: two SmartTable rows and an original invoice containing ownerId
     invoice_org, schema_path = _copy_sample_invoice_files(tmp_path)
-    expected_owner_id = json.loads(invoice_org.read_text())["sample"]["ownerId"]
+    original_invoice = json.loads(invoice_org.read_text())
+    # ownerId should be set from basic.dataOwnerId, not sample.ownerId
+    expected_owner_id = original_invoice["basic"]["dataOwnerId"]
     smarttable_file = tmp_path / "inputdata" / "smarttable_sample.xlsx"
     smarttable_file.parent.mkdir(parents=True, exist_ok=True)
     smarttable_file.touch()
@@ -149,14 +157,17 @@ def test_smarttable_invoice_initializer_preserves_owner_id_after_source_mutation
 
     output_invoice = json.loads((divided_invoice_dir / "invoice.json").read_text())
 
-    # Then: the later invoice still includes the original ownerId
+    # Then: sample.ownerId is set to basic.dataOwnerId
     assert output_invoice["sample"]["ownerId"] == expected_owner_id
 
 
-def test_smarttable_invoice_initializer_uses_base_owner_on_first_invocation__tc_bv_001(tmp_path: Path) -> None:
+def test_smarttable_invoice_initializer_sets_owner_id_from_data_owner__tc_bv_001(tmp_path: Path) -> None:
+    """TC-BV-001: First invocation with SmartTable row sets sample.ownerId from basic.dataOwnerId."""
     # Given: a SmartTable row without ownerId override
     invoice_org, schema_path = _copy_sample_invoice_files(tmp_path)
-    expected_owner_id = json.loads(invoice_org.read_text())["sample"]["ownerId"]
+    original_invoice = json.loads(invoice_org.read_text())
+    # ownerId should be set from basic.dataOwnerId
+    expected_owner_id = original_invoice["basic"]["dataOwnerId"]
     smarttable_file = tmp_path / "inputdata" / "smarttable_sample.xlsx"
     smarttable_file.parent.mkdir(parents=True, exist_ok=True)
     smarttable_file.touch()
@@ -188,11 +199,12 @@ def test_smarttable_invoice_initializer_uses_base_owner_on_first_invocation__tc_
     initializer.process(context)
     output_invoice = json.loads((invoice_org.parent / "invoice.json").read_text())
 
-    # Then: ownerId remains from the original invoice template
+    # Then: ownerId is set to basic.dataOwnerId
     assert output_invoice["sample"]["ownerId"] == expected_owner_id
 
 
 def test_smarttable_invoice_initializer_requires_row_csv__tc_ep_002(tmp_path: Path) -> None:
+    """TC-EP-002: Missing SmartTable row CSV in SmartTable mode raises StructuredError."""
     # Given: SmartTable mode without a generated row CSV
     invoice_org, schema_path = _copy_sample_invoice_files(tmp_path)
     smarttable_file = tmp_path / "inputdata" / "smarttable_sample.xlsx"
@@ -225,6 +237,7 @@ def test_smarttable_invoice_initializer_requires_row_csv__tc_ep_002(tmp_path: Pa
 
 
 def test_smarttable_invoice_initializer_requires_smarttable_mode__tc_bv_002(tmp_path: Path) -> None:
+    """TC-BV-002: smarttable_file is None raises ValueError."""
     # Given: SmartTable initializer invoked without smarttable mode enabled
     invoice_org, schema_path = _copy_sample_invoice_files(tmp_path)
     row0 = tmp_path / "temp" / "fsmarttable_case_0000.csv"
@@ -253,3 +266,149 @@ def test_smarttable_invoice_initializer_requires_smarttable_mode__tc_bv_002(tmp_
     # When/Then: SmartTable processing rejects contexts without smarttable_file
     with pytest.raises(ValueError, match="SmartTable file not provided"):
         initializer.process(context)
+
+
+def test_smarttable_invoice_initializer_warns_when_data_owner_id_missing__tc_ep_003(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """TC-EP-003: basic.dataOwnerId missing logs warning and preserves original sample.ownerId."""
+    # Given: an original invoice without basic.dataOwnerId
+    invoice_org, schema_path = _copy_sample_invoice_files(tmp_path)
+    original_invoice = json.loads(invoice_org.read_text())
+    original_sample_owner_id = original_invoice["sample"]["ownerId"]
+
+    # Remove dataOwnerId to simulate missing value
+    del original_invoice["basic"]["dataOwnerId"]
+    invoice_org.write_text(json.dumps(original_invoice))
+
+    smarttable_file = tmp_path / "inputdata" / "smarttable_sample.xlsx"
+    smarttable_file.parent.mkdir(parents=True, exist_ok=True)
+    smarttable_file.touch()
+
+    row0 = tmp_path / "temp" / "fsmarttable_case_0000.csv"
+    _write_smarttable_row(row0, {"sample/names": "sample-one"})
+
+    srcpaths = RdeInputDirPaths(
+        inputdata=smarttable_file.parent,
+        invoice=invoice_org.parent,
+        tasksupport=schema_path.parent,
+        config=create_default_config(),
+    )
+    initializer = SmartTableInvoiceInitializer()
+
+    resource_paths = _build_resource_paths(
+        tmp_path, invoice_org.parent, invoice_org, schema_path, row0,
+    )
+    context = ProcessingContext(
+        index="0",
+        srcpaths=srcpaths,
+        resource_paths=resource_paths,
+        datasets_function=None,
+        mode_name="smarttable",
+        smarttable_file=smarttable_file,
+    )
+
+    # When: processing with missing basic.dataOwnerId
+    with caplog.at_level("WARNING"):
+        initializer.process(context)
+
+    output_invoice = json.loads((invoice_org.parent / "invoice.json").read_text())
+
+    # Then: warning is logged and sample.ownerId is preserved from original
+    assert "basic.dataOwnerId is missing or empty" in caplog.text
+    assert output_invoice["sample"]["ownerId"] == original_sample_owner_id
+
+
+def test_smarttable_invoice_initializer_warns_when_data_owner_id_empty__tc_bv_003(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """TC-BV-003: basic.dataOwnerId empty string logs warning and preserves original sample.ownerId."""
+    # Given: an original invoice with empty basic.dataOwnerId
+    invoice_org, schema_path = _copy_sample_invoice_files(tmp_path)
+    original_invoice = json.loads(invoice_org.read_text())
+    original_sample_owner_id = original_invoice["sample"]["ownerId"]
+
+    # Set dataOwnerId to empty string
+    original_invoice["basic"]["dataOwnerId"] = ""
+    invoice_org.write_text(json.dumps(original_invoice))
+
+    smarttable_file = tmp_path / "inputdata" / "smarttable_sample.xlsx"
+    smarttable_file.parent.mkdir(parents=True, exist_ok=True)
+    smarttable_file.touch()
+
+    row0 = tmp_path / "temp" / "fsmarttable_case_0000.csv"
+    _write_smarttable_row(row0, {"sample/names": "sample-one"})
+
+    srcpaths = RdeInputDirPaths(
+        inputdata=smarttable_file.parent,
+        invoice=invoice_org.parent,
+        tasksupport=schema_path.parent,
+        config=create_default_config(),
+    )
+    initializer = SmartTableInvoiceInitializer()
+
+    resource_paths = _build_resource_paths(
+        tmp_path, invoice_org.parent, invoice_org, schema_path, row0,
+    )
+    context = ProcessingContext(
+        index="0",
+        srcpaths=srcpaths,
+        resource_paths=resource_paths,
+        datasets_function=None,
+        mode_name="smarttable",
+        smarttable_file=smarttable_file,
+    )
+
+    # When: processing with empty basic.dataOwnerId
+    with caplog.at_level("WARNING"):
+        initializer.process(context)
+
+    output_invoice = json.loads((invoice_org.parent / "invoice.json").read_text())
+
+    # Then: warning is logged and sample.ownerId is preserved from original
+    assert "basic.dataOwnerId is missing or empty" in caplog.text
+    assert output_invoice["sample"]["ownerId"] == original_sample_owner_id
+
+
+def test_smarttable_invoice_initializer_uses_csv_owner_id_when_specified__tc_ep_004(tmp_path: Path) -> None:
+    """TC-EP-004: SmartTable CSV sample/ownerId takes precedence over basic.dataOwnerId."""
+    # Given: SmartTable row with sample/ownerId column explicitly specified
+    invoice_org, schema_path = _copy_sample_invoice_files(tmp_path)
+    original_invoice = json.loads(invoice_org.read_text())
+    data_owner_id = original_invoice["basic"]["dataOwnerId"]
+
+    smarttable_file = tmp_path / "inputdata" / "smarttable_sample.xlsx"
+    smarttable_file.parent.mkdir(parents=True, exist_ok=True)
+    smarttable_file.touch()
+
+    # SmartTable CSV includes sample/ownerId column with different value
+    csv_owner_id = "DifferentOwnerIdFromCSVaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    row0 = tmp_path / "temp" / "fsmarttable_case_0000.csv"
+    _write_smarttable_row(row0, {
+        "sample/names": "sample-one",
+        "sample/ownerId": csv_owner_id,
+    })
+
+    srcpaths = RdeInputDirPaths(
+        inputdata=smarttable_file.parent,
+        invoice=invoice_org.parent,
+        tasksupport=schema_path.parent,
+        config=create_default_config(),
+    )
+    initializer = SmartTableInvoiceInitializer()
+
+    resource_paths = _build_resource_paths(
+        tmp_path, invoice_org.parent, invoice_org, schema_path, row0,
+    )
+    context = ProcessingContext(
+        index="0",
+        srcpaths=srcpaths,
+        resource_paths=resource_paths,
+        datasets_function=None,
+        mode_name="smarttable",
+        smarttable_file=smarttable_file,
+    )
+
+    # When: processing with both CSV ownerId and basic.dataOwnerId
+    initializer.process(context)
+    output_invoice = json.loads((invoice_org.parent / "invoice.json").read_text())
+
+    # Then: CSV value takes precedence over basic.dataOwnerId
+    assert output_invoice["sample"]["ownerId"] == csv_owner_id
+    assert output_invoice["sample"]["ownerId"] != data_owner_id