pam-python 0.2.15__tar.gz → 0.2.17__tar.gz

{pam_python-0.2.15/pam_python.egg-info → pam_python-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pam-python
-Version: 0.2.15
+Version: 0.2.17
 Summary: Pam Python Library
 Author-email: Narongrit Kanhanoi <narongrit@pams.ai>
 Project-URL: Homepage, https://github.com/heart/pam-python

{pam_python-0.2.15 → pam_python-0.2.17}/pam/__init__.py

@@ -1,3 +1,3 @@
 """PAM Data Plugin framework."""
 
-__version__ = "0.2.15"
+__version__ = "0.2.17"

{pam_python-0.2.15 → pam_python-0.2.17}/pam/models/data_input_v2.py

@@ -71,21 +71,34 @@ class DataInputV2Dataset:
         for part in self.parts:
             yield from part.iter_csv_rows()
 
-    def scan_polars(self) -> Any:
-        """Return one lazy frame across all ordered CSV or Parquet parts."""
+    def scan_polars(self, empty_schema: dict[str, Any] | None = None) -> Any:
+        """Return one lazy frame across all ordered CSV or Parquet parts.
+
+        PAM represents a valid dataset with no rows as ``row_count=0`` and no
+        physical parts. In that case the plugin may provide its domain schema
+        so downstream computation can handle the empty input normally.
+        """
         pl = _import_polars()
         if not self.parts:
-            return pl.LazyFrame(schema={"id": pl.String})
+            schema = {"id": pl.String} if empty_schema is None else empty_schema
+            return pl.LazyFrame(schema=schema)
         scans = [part.scan_polars() for part in self.parts]
         if len(scans) == 1:
             return scans[0]
         return pl.concat(scans, how="diagonal_relaxed")
 
-    def read_pandas(self) -> Any:
-        """Materialize and concatenate all verified parts using their metadata."""
+    def read_pandas(self, empty_dtypes: dict[str, Any] | None = None) -> Any:
+        """Materialize and concatenate all verified parts using their metadata.
+
+        ``empty_dtypes`` is used only for a declared empty dataset, allowing
+        the plugin to retain its domain columns without fabricating data rows.
+        """
         pd = _import_pandas()
         if not self.parts:
-            return pd.DataFrame({"id": pd.Series(dtype="string")})
+            dtypes = {"id": "string"} if empty_dtypes is None else empty_dtypes
+            return pd.DataFrame(
+                {name: pd.Series(dtype=dtype) for name, dtype in dtypes.items()}
+            )
         frames = [part.read_pandas() for part in self.parts]
         if len(frames) == 1:
             return frames[0]

{pam_python-0.2.15 → pam_python-0.2.17}/pam/task_manager.py

@@ -258,8 +258,16 @@ class TaskManager(ITaskManager):
         """
         log(f"Start Service: {service_name}, Token: {req.token}")
         service_instance = service_class(self, req)
-        service_instance.on_start()
         self._add_service(req.token, service_instance)
+        try:
+            # Register the service before on_start. A service commonly requests
+            # its first page from on_start, and PAM can deliver that page before
+            # on_start returns. Registering afterwards loses that callback and
+            # also lets on_dataset_input cancel the V2 wait timer permanently.
+            service_instance.on_start()
+        except BaseException:
+            self._remove_service(req.token)
+            raise
 
     def terminate_service(self, token):
         """
@@ -419,9 +427,8 @@ class TaskManager(ITaskManager):
         from its worker, so failures must propagate for retry handling.
         """
         endpoint = service.request.response_api
-        payload = None
+        payload = {"token": service.request.token}
         if options is not None:
-            payload = {}
             if "is_realtime" in options:
                 is_realtime = options.get("is_realtime")
                 payload["is_realtime"] = str(is_realtime).lower() if isinstance(is_realtime, bool) else is_realtime
@@ -464,7 +471,11 @@ class TaskManager(ITaskManager):
 
         def upload_wrapper():
             """Wrapper for the report upload to handle response logging."""
-            response = self.api.http_upload(endpoint, file_path)
+            response = self.api.http_upload(
+                endpoint,
+                file_path,
+                {"token": service.request.token},
+            )
             handle_report_response(response)
 
         log(f"Uploading Report to: {endpoint}")
@@ -501,7 +512,11 @@ class TaskManager(ITaskManager):
                     column_name: json.dumps(pointer, ensure_ascii=False, sort_keys=True),
                 })
 
-            response = self.api.http_upload(service.request.response_api, csv_path)
+            response = self.api.http_upload(
+                service.request.response_api,
+                csv_path,
+                {"token": service.request.token},
+            )
             if response is None:
                 return False
             success = response.ok

{pam_python-0.2.15 → pam_python-0.2.17}/pam/templates/init/AGENT.md

@@ -234,6 +234,11 @@ result = calculate(population, profile_frame, purchase_frame).collect()
 
 `scan_polars()` returns one lazy frame across ordered CSV or Parquet parts and
 uses verified manifest format metadata. CSV-only code may use `iter_rows()`.
+`row_count=0` with `parts=[]` is a valid empty dataset. The plugin decides the
+business result for the page population; it must not treat the absence of event
+rows as a transport error. If computation requires domain columns on an empty
+frame, call `scan_polars(empty_schema=...)` or
+`read_pandas(empty_dtypes=...)` with the plugin-owned schema.
 The external customer key is `id`. The population file is authoritative: in
 `contacts` mode, contacts with no event rows remain visible there. Use the
 opaque `data.next` cursor for the next `_request_data_v2(...)` call and stop when

{pam_python-0.2.15 → pam_python-0.2.17/pam_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pam-python
-Version: 0.2.15
+Version: 0.2.17
 Summary: Pam Python Library
 Author-email: Narongrit Kanhanoi <narongrit@pams.ai>
 Project-URL: Homepage, https://github.com/heart/pam-python

{pam_python-0.2.15 → pam_python-0.2.17}/pam_python.egg-info/SOURCES.txt

@@ -94,6 +94,7 @@ tests/test_request_data_v2.py
 tests/test_result_batch_uploader.py
 tests/test_service_dataframe_output.py
 tests/test_sqlite_download_v2.py
+tests/test_task_manager_upload_token.py
 tests/test_temp_file_utils.py
 tests/test_temporal_mode.py
 tests/test_typed_area_report.py

{pam_python-0.2.15 → pam_python-0.2.17}/tests/test_data_error_v2.py

@@ -11,6 +11,50 @@ from pam.task_manager import TaskManager
 
 
 class DataErrorV2Test(unittest.TestCase):
+    def test_start_service_registers_before_immediate_data_callback(self):
+        manager = TaskManager.__new__(TaskManager)
+        manager.thread_lock = threading.Lock()
+        manager.services = {}
+        manager.data_wait_timers = {}
+        request = Mock(token="run-1")
+
+        class ImmediateCallbackService:
+            def __init__(self, task_manager, req):
+                self.task_manager = task_manager
+                self.request = req
+                self.received = []
+
+            def on_start(self):
+                self.task_manager.on_dataset_input(self.request)
+
+            def on_data_input(self, req):
+                self.received.append(req)
+
+        manager.start_service(ImmediateCallbackService, request, "test-service")
+
+        service = manager.services[request.token].service
+        self.assertEqual([request], service.received)
+
+    def test_start_service_removes_registration_when_on_start_fails(self):
+        manager = TaskManager.__new__(TaskManager)
+        manager.thread_lock = threading.Lock()
+        manager.services = {}
+        manager.data_wait_timers = {}
+
+        service = Mock()
+        service.on_start.side_effect = RuntimeError("start failed")
+        service.request = Mock(service_name="test-service", token="run-1")
+        service.reports = Mock()
+        service_class = Mock(return_value=service)
+        request = Mock(token="run-1")
+
+        with self.assertRaisesRegex(RuntimeError, "start failed"):
+            manager.start_service(service_class, request, "test-service")
+
+        self.assertNotIn(request.token, manager.services)
+        service.on_destroy.assert_called_once_with()
+        service.reports.close.assert_called_once_with()
+
     def test_request_command_parses_dataset_error_without_zip(self):
         app = Flask(__name__)
         with app.test_request_context(

{pam_python-0.2.15 → pam_python-0.2.17}/tests/test_data_input_v2.py

@@ -78,6 +78,30 @@ class DataInputV2Test(unittest.TestCase):
         self.assertEqual(0, data_input.datasets[0].row_count)
         self.assertEqual((), data_input.datasets[0].parts)
 
+    def test_empty_dataset_readers_use_plugin_owned_schema(self):
+        import polars as pl
+
+        manifest = self._valid_manifest()
+        manifest["datasets"][0]["row_count"] = 0
+        manifest["datasets"][0]["parts"] = []
+        self.dataset_path.unlink()
+        manifest_path = self._write_manifest(manifest)
+        dataset = parse_data_input_v2(
+            [str(manifest_path), str(self.population_path)]
+        ).datasets[0]
+
+        polars_frame = dataset.scan_polars(
+            empty_schema={"id": pl.String, "netamount": pl.Float64}
+        ).collect()
+        self.assertEqual(0, polars_frame.height)
+        self.assertEqual(["id", "netamount"], polars_frame.columns)
+
+        pandas_frame = dataset.read_pandas(
+            empty_dtypes={"id": "string", "netamount": "float64"}
+        )
+        self.assertTrue(pandas_frame.empty)
+        self.assertEqual(["id", "netamount"], pandas_frame.columns.tolist())
+
     def test_streams_population_and_ordered_dataset_parts(self):
         second_part_path = self._write_file(
             "dataset_001_demographic_part_0002.csv",

{pam_python-0.2.15 → pam_python-0.2.17}/tests/test_report_store.py

@@ -496,8 +496,9 @@ class ReportStoreTransportTest(unittest.TestCase):
             captured = {}
             response = Mock(ok=True)
 
-            def capture_upload(endpoint, file_path):
+            def capture_upload(endpoint, file_path, payload):
                 captured["endpoint"] = endpoint
+                captured["payload"] = payload
                 with open(file_path, encoding="utf-8", newline="") as input_file:
                     captured["row"] = next(csv.DictReader(input_file))
                 return response
@@ -535,6 +536,7 @@ class ReportStoreTransportTest(unittest.TestCase):
 
         self.assertTrue(published)
         self.assertEqual(request.response_api, captured["endpoint"])
+        self.assertEqual({"token": "token-1"}, captured["payload"])
         self.assertEqual("adapter-1", captured["row"]["customer"])
         self.assertEqual("Customer Report Group", captured["row"]["_tracker_name"])
         self.assertEqual(

pam_python-0.2.17/tests/test_task_manager_upload_token.py

@@ -0,0 +1,61 @@
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+from pam.task_manager import TaskManager
+
+
+class TaskManagerUploadTokenTest(unittest.TestCase):
+    def setUp(self):
+        self.manager = TaskManager(SimpleNamespace())
+        self.manager.api = Mock()
+        self.service = SimpleNamespace(
+            request=SimpleNamespace(
+                response_api="http://pam/api/dataadapter/adapter-1/response",
+                token="token-1",
+                service_name="service-1",
+            ),
+        )
+        self.response = Mock(ok=True)
+        self.response.json.return_value = {"code": "SUCCESS"}
+        self.manager.api.http_upload.return_value = self.response
+
+    def test_result_upload_always_sends_token_with_options(self):
+        with tempfile.TemporaryDirectory() as directory:
+            file_path = Path(directory) / "result.csv"
+            file_path.write_text("id\n1\n", encoding="utf-8")
+
+            self.manager.service_upload_result(
+                self.service,
+                str(file_path),
+                {"is_realtime": True, "is_priority": False},
+            )
+
+        self.manager.api.http_upload.assert_called_once_with(
+            self.service.request.response_api,
+            str(file_path),
+            {
+                "token": "token-1",
+                "is_realtime": "true",
+                "is_priority": "false",
+            },
+        )
+
+    def test_result_upload_sends_token_without_options(self):
+        with tempfile.TemporaryDirectory() as directory:
+            file_path = Path(directory) / "result.csv"
+            file_path.write_text("id\n1\n", encoding="utf-8")
+
+            self.manager.service_upload_result(self.service, str(file_path))
+
+        self.manager.api.http_upload.assert_called_once_with(
+            self.service.request.response_api,
+            str(file_path),
+            {"token": "token-1"},
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()