pam-python 0.2.10__tar.gz → 0.2.12__tar.gz

{pam_python-0.2.10/pam_python.egg-info → pam_python-0.2.12}/PKG-INFO

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

{pam_python-0.2.10 → pam_python-0.2.12}/pam/__init__.py

@@ -1,3 +1,3 @@
 """PAM Data Plugin framework."""
 
-__version__ = "0.2.10"
+__version__ = "0.2.12"

{pam_python-0.2.10 → pam_python-0.2.12}/pam/interface_task_manager.py

@@ -79,5 +79,6 @@ class ITaskManager(ABC):
         service: Service,
         report_key: str,
         pointer: dict,
+        tracker_name: str,
     ):
         pass

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/__init__.py

@@ -31,6 +31,7 @@ from pam.reports.range_bar import RangeBarChartReport
 from pam.reports.scatter import ScatterChartReport
 from pam.reports.store import ReportStore
 from pam.reports.table import TableReport
+from pam.reports.temporal import TemporalMode
 from pam.reports.treemap import TreemapReport
 
 __all__ = [
@@ -68,6 +69,7 @@ __all__ = [
     "ScatterChartReport",
     "Sum",
     "TableReport",
+    "TemporalMode",
     "TimeRangeTransform",
     "TreemapReport",
 ]

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/area.py

@@ -8,6 +8,7 @@ from pam.reports.definition import ReportDefinition
 from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Dimension, Measure
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 AREA_RENDERER = "area"
@@ -50,6 +51,7 @@ class AreaChartReport(TypedCollectionReport):
         series: Optional[Dimension] = None,
         stacked: bool = False,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         if not isinstance(stacked, bool):
             raise ReportStoreValidationError("Area stacked must be boolean")
@@ -61,6 +63,13 @@ class AreaChartReport(TypedCollectionReport):
         normalized_range_transform = normalize_range_transform(
             range_transform, granularity, normalized_values, "Area Chart"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode,
+            granularity,
+            normalized_values,
+            "Area Chart",
+            range_transform,
+        )
         definition = ReportDefinition.create(
             report_type="area",
             contract_version=AREA_CONTRACT_VERSION,
@@ -72,6 +81,7 @@ class AreaChartReport(TypedCollectionReport):
             },
             options={"stacked": stacked},
             range_transform=normalized_range_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key=key,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/bar.py

@@ -8,6 +8,7 @@ from pam.reports.definition import ReportDefinition
 from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Dimension, Measure
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 BAR_RENDERER = "bar"
@@ -56,6 +57,7 @@ class BarChartReport(TypedCollectionReport):
         orientation: str = "vertical",
         stacked: bool = False,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         if not isinstance(category, Dimension):
             raise ReportStoreValidationError(
@@ -110,6 +112,13 @@ class BarChartReport(TypedCollectionReport):
         normalized_range_transform = normalize_range_transform(
             range_transform, granularity, normalized_values, "Bar Chart"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode,
+            granularity,
+            normalized_values,
+            "Bar Chart",
+            range_transform,
+        )
         definition = ReportDefinition.create(
             report_type="bar",
             contract_version=BAR_CONTRACT_VERSION,
@@ -121,6 +130,7 @@ class BarChartReport(TypedCollectionReport):
             },
             options={"orientation": orientation, "stacked": stacked},
             range_transform=normalized_range_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key=key,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/definition.py

@@ -18,6 +18,7 @@ class ReportDefinition:
     binding: Dict[str, Any]
     options: Dict[str, Any] = field(default_factory=dict)
     range_transform: Optional[Dict[str, Any]] = None
+    temporal_mode: Optional[str] = None
 
     def __post_init__(self) -> None:
         if not isinstance(self.report_type, str) or not self.report_type:
@@ -41,6 +42,17 @@ class ReportDefinition:
             raise ReportStoreValidationError(
                 "range_transform must be a dictionary or None"
             )
+        if self.temporal_mode is not None and self.temporal_mode not in {
+            "AGGREGATE",
+            "SNAPSHOT",
+        }:
+            raise ReportStoreValidationError(
+                "temporal_mode must be AGGREGATE, SNAPSHOT, or None"
+            )
+        if self.temporal_mode is not None and self.range_transform is not None:
+            raise ReportStoreValidationError(
+                "temporal_mode and range_transform cannot be declared together"
+            )
 
         # Validate serializability while the declaration is still close to its caller.
         canonical_json(self.to_dict())
@@ -54,6 +66,7 @@ class ReportDefinition:
         binding: Dict[str, Any],
         options: Dict[str, Any] = None,
         range_transform: Dict[str, Any] = None,
+        temporal_mode: str = None,
     ):
         return cls(
             report_type=report_type,
@@ -64,6 +77,7 @@ class ReportDefinition:
             range_transform=(
                 dict(range_transform) if range_transform is not None else None
             ),
+            temporal_mode=temporal_mode,
         )
 
     def to_dict(self) -> Dict[str, Any]:
@@ -76,6 +90,8 @@ class ReportDefinition:
         }
         if self.range_transform is not None:
             definition["range_transform"] = self.range_transform
+        if self.temporal_mode is not None:
+            definition["temporal_mode"] = self.temporal_mode
         return definition
 
     def to_json(self) -> str:

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/donut.py

@@ -8,6 +8,7 @@ from pam.reports.definition import ReportDefinition
 from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Dimension, Measure
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 DONUT_RENDERER = "donut"
@@ -51,6 +52,7 @@ class DonutChartReport(TypedCollectionReport):
         category: Dimension,
         value: Measure,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         if not isinstance(category, Dimension):
             raise ReportStoreValidationError(
@@ -80,12 +82,16 @@ class DonutChartReport(TypedCollectionReport):
         normalized_range_transform = normalize_range_transform(
             range_transform, granularity, (value,), "Donut"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode, granularity, (value,), "Donut", range_transform
+        )
         definition = ReportDefinition.create(
             report_type="donut",
             contract_version=DONUT_CONTRACT_VERSION,
             fields=(category, value),
             binding={"category": category.name, "value": value.name},
             range_transform=normalized_range_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key=key,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/line.py

@@ -8,6 +8,7 @@ from pam.reports.definition import ReportDefinition
 from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Dimension, Measure
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 LINE_RENDERER = "line"
@@ -46,6 +47,7 @@ class LineChartReport(TypedCollectionReport):
         values: Iterable[Measure],
         series: Optional[Dimension] = None,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         if granularity == "NONE":
             raise ReportStoreValidationError("Line granularity must be DAY or MONTH")
@@ -55,6 +57,13 @@ class LineChartReport(TypedCollectionReport):
         normalized_range_transform = normalize_range_transform(
             range_transform, granularity, normalized_values, "Line"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode,
+            granularity,
+            normalized_values,
+            "Line",
+            range_transform,
+        )
         definition = ReportDefinition.create(
             report_type="line",
             contract_version=LINE_CONTRACT_VERSION,
@@ -65,6 +74,7 @@ class LineChartReport(TypedCollectionReport):
                 "values": [value.name for value in normalized_values],
             },
             range_transform=normalized_range_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key=key,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/manager.py

@@ -31,9 +31,15 @@ class ReportStoreManager:
         self._sleep = sleep_fn
         self._stores = {}
 
-    def create(self, file_name: str, shared: bool = False) -> ReportStore:
+    def create(
+        self,
+        file_name: str,
+        shared: bool = False,
+        tracker_name: str | None = None,
+    ) -> ReportStore:
         """Start a fresh local file without performing a download."""
         self._validate_file_name(file_name)
+        tracker_name = self._resolve_tracker_name(tracker_name)
         session_key = (file_name, shared)
         self._assert_not_open(session_key)
         path = self._new_local_path(file_name)
@@ -41,18 +47,29 @@ class ReportStoreManager:
             path,
             file_name,
             shared,
+            tracker_name=tracker_name,
             transport=self._transport,
             cleanup_on_close=True,
         )
         self._stores[session_key] = store
         return store
 
-    def open(self, file_name: str, shared: bool = False) -> ReportStore:
+    def open(
+        self,
+        file_name: str,
+        shared: bool = False,
+        tracker_name: str | None = None,
+    ) -> ReportStore:
         """Resume remote state, or create only after an authoritative 404."""
         self._validate_file_name(file_name)
+        tracker_name = self._resolve_tracker_name(tracker_name)
         session_key = (file_name, shared)
         existing = self._stores.get(session_key)
         if existing is not None:
+            if existing.tracker_name != tracker_name:
+                raise ReportStoreLocalIOError(
+                    "This report store is already open with a different tracker_name"
+                )
             return existing
 
         path = self._new_local_path(file_name)
@@ -64,6 +81,7 @@ class ReportStoreManager:
                     downloaded_path,
                     file_name,
                     shared,
+                    tracker_name=tracker_name,
                     transport=self._transport,
                     cleanup_on_close=True,
                 )
@@ -75,6 +93,7 @@ class ReportStoreManager:
                     path,
                     file_name,
                     shared,
+                    tracker_name=tracker_name,
                     transport=self._transport,
                     cleanup_on_close=True,
                 )
@@ -138,6 +157,15 @@ class ReportStoreManager:
                 "This report store is already open for the current service run"
             )
 
+    def _resolve_tracker_name(self, tracker_name: str | None) -> str:
+        if tracker_name is None:
+            tracker_name = self._service.request.service_name
+        if not isinstance(tracker_name, str) or not tracker_name.strip():
+            raise ReportStoreLocalIOError(
+                "tracker_name must be a non-empty string"
+            )
+        return tracker_name.strip()
+
     @staticmethod
     def _validate_file_name(file_name: str) -> None:
         if not isinstance(file_name, str) or not file_name.strip():

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/metric.py

@@ -7,6 +7,7 @@ from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Measure
 from pam.reports.record import ReportRecord, build_record_key, validate_partition_key
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 METRIC_RENDERER = "metric"
@@ -31,6 +32,7 @@ class MetricReport:
         granularity: str,
         metrics: Iterable[Measure],
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         if isinstance(metrics, (str, bytes)):
             raise ReportStoreValidationError("metrics must contain Measure declarations")
@@ -50,6 +52,13 @@ class MetricReport:
         normalized_range_transform = normalize_range_transform(
             range_transform, granularity, normalized_metrics, "Metric"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode,
+            granularity,
+            normalized_metrics,
+            "Metric",
+            range_transform,
+        )
 
         definition = ReportDefinition.create(
             report_type="metric",
@@ -57,6 +66,7 @@ class MetricReport:
             fields=normalized_metrics,
             binding={"metrics": [metric.name for metric in normalized_metrics]},
             range_transform=normalized_range_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key=key,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/pie.py

@@ -8,6 +8,7 @@ from pam.reports.definition import ReportDefinition
 from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Dimension, Measure
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 PIE_RENDERER = "pie"
@@ -51,6 +52,7 @@ class PieChartReport(TypedCollectionReport):
         category: Dimension,
         value: Measure,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         if not isinstance(category, Dimension):
             raise ReportStoreValidationError(
@@ -80,12 +82,16 @@ class PieChartReport(TypedCollectionReport):
         normalized_range_transform = normalize_range_transform(
             range_transform, granularity, (value,), "Pie"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode, granularity, (value,), "Pie", range_transform
+        )
         definition = ReportDefinition.create(
             report_type="pie",
             contract_version=PIE_CONTRACT_VERSION,
             fields=(category, value),
             binding={"category": category.name, "value": value.name},
             range_transform=normalized_range_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key=key,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/polar_area.py

@@ -8,6 +8,7 @@ from pam.reports.definition import ReportDefinition
 from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Dimension, Measure
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 POLAR_AREA_RENDERER = "polar_area"
@@ -52,6 +53,7 @@ class PolarAreaChartReport(TypedCollectionReport):
         category: Dimension,
         value: Measure,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         if not isinstance(category, Dimension):
             raise ReportStoreValidationError(
@@ -81,12 +83,16 @@ class PolarAreaChartReport(TypedCollectionReport):
         normalized_range_transform = normalize_range_transform(
             range_transform, granularity, (value,), "Polar Area"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode, granularity, (value,), "Polar Area", range_transform
+        )
         definition = ReportDefinition.create(
             report_type="polar_area",
             contract_version=POLAR_AREA_CONTRACT_VERSION,
             fields=(category, value),
             binding={"category": category.name, "value": value.name},
             range_transform=normalized_range_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key=key,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/radial_bar.py

@@ -9,6 +9,7 @@ from pam.reports.errors import ReportStoreValidationError
 from pam.reports.fields import Measure
 from pam.reports.record import ReportRecord, build_record_key, validate_partition_key
 from pam.reports.range_transform import TimeRangeTransform, normalize_range_transform
+from pam.reports.temporal import TemporalMode, normalize_temporal_mode
 
 
 RADIAL_BAR_RENDERER = "radial_bar"
@@ -32,6 +33,7 @@ class RadialBarChartReport:
         cls, store, key: str, granularity: str, metrics: Iterable[Measure],
         min_value: float, max_value: float,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ):
         try:
             normalized_metrics = tuple(metrics)
@@ -66,6 +68,13 @@ class RadialBarChartReport:
         normalized_transform = normalize_range_transform(
             range_transform, granularity, normalized_metrics, "Radial Bar"
         )
+        normalized_temporal_mode = normalize_temporal_mode(
+            temporal_mode,
+            granularity,
+            normalized_metrics,
+            "Radial Bar",
+            range_transform,
+        )
         definition = ReportDefinition.create(
             report_type="radial_bar",
             contract_version=RADIAL_BAR_CONTRACT_VERSION,
@@ -73,6 +82,7 @@ class RadialBarChartReport:
             binding={"metrics": [metric.name for metric in normalized_metrics]},
             options={"min_value": min_value, "max_value": max_value},
             range_transform=normalized_transform,
+            temporal_mode=normalized_temporal_mode,
         )
         report = store._declare_typed_report(
             key, RADIAL_BAR_RENDERER, RADIAL_BAR_SCHEMA, granularity,

{pam_python-0.2.10 → pam_python-0.2.12}/pam/reports/store.py

@@ -45,6 +45,7 @@ from pam.reports.schema import (
     STORE_VERSION,
 )
 from pam.reports.table import TableReport
+from pam.reports.temporal import TemporalMode
 from pam.reports.treemap import TreemapReport
 
 
@@ -60,12 +61,14 @@ class ReportStore:
         path: Path,
         file_name: str,
         shared: bool,
+        tracker_name: str = "",
         transport=None,
         cleanup_on_close: bool = False,
     ):
         self.path = Path(path)
         self.file_name = file_name
         self.shared = shared
+        self.tracker_name = tracker_name
         self._transport = transport
         self._cleanup_on_close = cleanup_on_close
         self._lock = threading.RLock()
@@ -87,6 +90,7 @@ class ReportStore:
         path: Path,
         file_name: str,
         shared: bool,
+        tracker_name: str = "",
         transport=None,
         cleanup_on_close: bool = False,
     ):
@@ -97,7 +101,14 @@ class ReportStore:
         except OSError as exc:
             raise ReportStoreLocalIOError(str(exc)) from exc
 
-        store = cls(path, file_name, shared, transport, cleanup_on_close)
+        store = cls(
+            path,
+            file_name,
+            shared,
+            tracker_name=tracker_name,
+            transport=transport,
+            cleanup_on_close=cleanup_on_close,
+        )
         try:
             with store._connection:
                 store._connection.executescript(CREATE_SCHEMA_SQL)
@@ -116,10 +127,18 @@ class ReportStore:
         path: Path,
         file_name: str,
         shared: bool,
+        tracker_name: str = "",
         transport=None,
         cleanup_on_close: bool = False,
     ):
-        store = cls(path, file_name, shared, transport, cleanup_on_close)
+        store = cls(
+            path,
+            file_name,
+            shared,
+            tracker_name=tracker_name,
+            transport=transport,
+            cleanup_on_close=cleanup_on_close,
+        )
         try:
             store._migrate_compatible_schema()
             store.validate()
@@ -137,9 +156,10 @@ class ReportStore:
         key: str,
         granularity: str,
         columns: Iterable[Field],
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> TableReport:
         """Declare a typed Table report."""
-        return TableReport.declare(self, key, granularity, columns)
+        return TableReport.declare(self, key, granularity, columns, temporal_mode)
 
     def metric(
         self,
@@ -147,10 +167,11 @@ class ReportStore:
         granularity: str,
         metrics: Iterable[Measure],
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> MetricReport:
         """Declare a typed Metric report."""
         return MetricReport.declare(
-            self, key, granularity, metrics, range_transform
+            self, key, granularity, metrics, range_transform, temporal_mode
         )
 
     def line_chart(
@@ -160,10 +181,11 @@ class ReportStore:
         values: Iterable[Measure],
         series: Optional[Dimension] = None,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> LineChartReport:
         """Declare a typed Line Chart report."""
         return LineChartReport.declare(
-            self, key, granularity, values, series, range_transform
+            self, key, granularity, values, series, range_transform, temporal_mode
         )
 
     def area_chart(
@@ -174,10 +196,18 @@ class ReportStore:
         series: Optional[Dimension] = None,
         stacked: bool = False,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> AreaChartReport:
         """Declare a typed Area Chart report."""
         return AreaChartReport.declare(
-            self, key, granularity, values, series, stacked, range_transform
+            self,
+            key,
+            granularity,
+            values,
+            series,
+            stacked,
+            range_transform,
+            temporal_mode,
         )
 
     def bar_chart(
@@ -190,6 +220,7 @@ class ReportStore:
         orientation: str = "vertical",
         stacked: bool = False,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> BarChartReport:
         """Declare a typed Bar/Column Chart report."""
         return BarChartReport.declare(
@@ -202,6 +233,7 @@ class ReportStore:
             orientation,
             stacked,
             range_transform,
+            temporal_mode,
         )
 
     def pie_chart(
@@ -211,10 +243,11 @@ class ReportStore:
         category: Dimension,
         value: Measure,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> PieChartReport:
         """Declare a typed Pie Chart report."""
         return PieChartReport.declare(
-            self, key, granularity, category, value, range_transform
+            self, key, granularity, category, value, range_transform, temporal_mode
         )
 
     def donut_chart(
@@ -224,10 +257,11 @@ class ReportStore:
         category: Dimension,
         value: Measure,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> DonutChartReport:
         """Declare a typed Donut Chart report."""
         return DonutChartReport.declare(
-            self, key, granularity, category, value, range_transform
+            self, key, granularity, category, value, range_transform, temporal_mode
         )
 
     def radial_bar_chart(
@@ -238,10 +272,18 @@ class ReportStore:
         min_value: float,
         max_value: float,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> RadialBarChartReport:
         """Declare a typed Radial Bar Chart report."""
         return RadialBarChartReport.declare(
-            self, key, granularity, metrics, min_value, max_value, range_transform
+            self,
+            key,
+            granularity,
+            metrics,
+            min_value,
+            max_value,
+            range_transform,
+            temporal_mode,
         )
 
     def polar_area_chart(
@@ -251,10 +293,11 @@ class ReportStore:
         category: Dimension,
         value: Measure,
         range_transform: Optional[TimeRangeTransform] = None,
+        temporal_mode: Optional[TemporalMode] = None,
     ) -> PolarAreaChartReport:
         """Declare a typed Polar Area Chart report."""
         return PolarAreaChartReport.declare(
-            self, key, granularity, category, value, range_transform
+            self, key, granularity, category, value, range_transform, temporal_mode
         )
 
     def scatter_chart(