sibi-dst 2025.9.9__py3-none-any.whl → 2025.9.10__py3-none-any.whl

sibi_dst/utils/data_wrapper.py

@@ -37,7 +37,6 @@ class DataWrapper(ManagedResource):
         dataclass: Type,
         date_field: str,
         data_path: str,
-        parquet_filename: str,
         class_params: Optional[Dict] = None,
         load_params: Optional[Dict] = None,
         show_progress: bool = False,
@@ -50,7 +49,7 @@ class DataWrapper(ManagedResource):
         self.dataclass: Type = dataclass
         self.date_field: str = date_field
         self.data_path: str = self._ensure_forward_slash(data_path)
-        self.parquet_filename: str = parquet_filename
+        self.partition_on_date: bool = True # Assume Hive-style date partitioning by default
 
         if self.fs is None:
             raise ValueError("DataWrapper requires a File system (fs) to be provided.")
@@ -282,16 +281,23 @@ class DataWrapper(ManagedResource):
     def _process_single_date(self, date: datetime.date):
         """Process a single date: load, save to Parquet."""
         # --- 1. Setup paths and logging ---
-        path = f"{self.data_path}{date.year}/{date.month:02d}/{date.day:02d}/"
-        log_extra = self._log_extra(date_context=date.isoformat())
-        self.logger.debug(f"Processing date {date.isoformat()} for {path}", extra=log_extra)
-
+        path = self.data_path.rstrip("/")+"/"
+        if not self.partition_on_date:
+            # not a Hive-style partitioned path
+            path = f"{self.data_path}{date.year}/{date.month:02d}/{date.day:02d}/"
+            log_extra = self._log_extra(date_context=date.isoformat())
+            self.logger.debug(f"Processing date {date.isoformat()} for legacy {path}", extra=log_extra)
+        else :
+            # Hive-style partitioned path
+            log_extra = self._log_extra(date_context=date.isoformat(), partition_on=self.date_field)
+            self.logger.debug(f"Processing date {date.isoformat()} for partitioned {self.data_path} with hive-style partitions", extra=log_extra)
         # --- 2. Check if date/path should be skipped ---
         if (self.update_planner and path in self.update_planner.skipped and
                 getattr(self.update_planner, 'ignore_missing', False)):
             self.logger.debug(f"Skipping {date} as it exists in the skipped list", extra=log_extra)
             return
-        full_path = f"{path}{self.parquet_filename}"
+
+        self.logger.debug(f"Processing date {date.isoformat()} for {path}", extra=log_extra)
 
         # --- 3. Timing ---
         overall_start = time.perf_counter()
@@ -326,39 +332,44 @@ class DataWrapper(ManagedResource):
                                 self.mmanifest.record(full_path=path)
                             except Exception as e:
                                 self.logger.error(f"Failed to record missing path {path}: {e}", extra=log_extra)
-                        self.logger.info(f"No data found for {full_path}. Logged to missing manifest.", extra=log_extra)
+                        self.logger.info(f"No data found for {path}. Logged to missing manifest.", extra=log_extra)
                         return # Done for this date
 
                     if total_records < 0:
-                        self.logger.warning(f"Negative record count ({total_records}) for {full_path}. Proceeding.", extra=log_extra)
+                        self.logger.warning(f"Negative record count ({total_records}) for {path}. Proceeding.", extra=log_extra)
                         # Continue processing even with negative count
 
-                # --- 6. Save to Parquet ---
-                save_start = time.perf_counter()
-                parquet_params = {
-                    "df_result": df,
-                    "parquet_storage_path": path,
-                    "fs": self.fs,
-                    "logger": self.logger,
-                    "debug": self.debug,
-                    "verbose": self.verbose,
-                }
-                self.logger.debug(f"{self.dataclass.__name__} saving to parquet started...", extra=log_extra)
-                with ParquetSaver(**parquet_params) as ps:
-                    ps.save_to_parquet(self.parquet_filename, overwrite=True)
-                save_time = time.perf_counter() - save_start
-                self.logger.debug(f"Parquet saving for {date} completed in {save_time:.2f}s", extra=log_extra)
-
-                # --- 7. Benchmarking ---
-                total_time = time.perf_counter() - overall_start
-                self.benchmarks[date] = {
-                    "load_duration": load_time,
-                    "save_duration": save_time,
-                    "total_duration": total_time,
-                }
-
-                # --- 8. Log Success ---
-                self._log_success(date, total_time, full_path)
+                    # --- 6. Save to Parquet ---
+                    save_start = time.perf_counter()
+
+
+                    parquet_params = {
+                        "df_result": df,
+                        "parquet_storage_path": path,
+                        "fs": self.fs,
+                        "logger": self.logger,
+                        "debug": self.debug,
+                        "verbose": self.verbose,
+                    }
+                    if self.partition_on_date:
+                        df["partition_date"] = df[self.date_field].dt.date.astype(str)
+                        parquet_params["partition_on"] = ["partition_date"]
+                    self.logger.debug(f"{self.dataclass.__name__} saving to parquet started...", extra=log_extra)
+                    with ParquetSaver(**parquet_params) as ps:
+                        ps.save_to_parquet()
+                    save_time = time.perf_counter() - save_start
+                    self.logger.debug(f"Parquet saving for {date} completed in {save_time:.2f}s", extra=log_extra)
+
+                    # --- 7. Benchmarking ---
+                    total_time = time.perf_counter() - overall_start
+                    self.benchmarks[date] = {
+                        "load_duration": load_time,
+                        "save_duration": save_time,
+                        "total_duration": total_time,
+                    }
+
+                    # --- 8. Log Success ---
+                    self._log_success(date, total_time, path)
 
         except Exception as e:
             # --- 9. Handle Errors ---
@@ -397,280 +408,3 @@ class DataWrapper(ManagedResource):
         except Exception as e:
             self.logger.error(f"Error generating benchmark summary: {e}", extra=self.logger_extra)
 
-# import datetime
-# import random
-# import threading
-# import time
-# from concurrent.futures import ThreadPoolExecutor, as_completed
-# from typing import Type, Any, Dict, Optional, Union, List, ClassVar
-#
-# import pandas as pd
-# from tqdm import tqdm
-#
-# from . import ManagedResource
-# from .parquet_saver import ParquetSaver
-#
-#
-# class DataWrapper(ManagedResource):
-#     DEFAULT_PRIORITY_MAP: ClassVar[Dict[str, int]] = {
-#         "overwrite": 1,
-#         "missing_in_history": 2,
-#         "existing_but_stale": 3,
-#         "missing_outside_history": 4,
-#         "file_is_recent": 0,
-#     }
-#     DEFAULT_MAX_AGE_MINUTES: int = 1440
-#     DEFAULT_HISTORY_DAYS_THRESHOLD: int = 30
-#
-#     logger_extra = {"sibi_dst_component": __name__}
-#
-#     def __init__(
-#         self,
-#         dataclass: Type,
-#         date_field: str,
-#         data_path: str,
-#         parquet_filename: str,
-#         class_params: Optional[Dict] = None,
-#         load_params: Optional[Dict] = None,
-#         show_progress: bool = False,
-#         timeout: float = 30,
-#         max_threads: int = 3,
-#         **kwargs: Any,
-#     ):
-#         super().__init__(**kwargs)
-#         self.dataclass = dataclass
-#         self.date_field = date_field
-#         self.data_path = self._ensure_forward_slash(data_path)
-#         self.parquet_filename = parquet_filename
-#         if self.fs is None:
-#             raise ValueError("DataWrapper requires a File system (fs) to be provided.")
-#         self.show_progress = show_progress
-#         self.timeout = timeout
-#         self.max_threads = max_threads
-#         self.class_params = class_params or {
-#             "debug": self.debug,
-#             "logger": self.logger,
-#             "fs": self.fs,
-#             "verbose": self.verbose,
-#         }
-#         self.load_params = load_params or {}
-#
-#         self._lock = threading.Lock()
-#         self.processed_dates: List[datetime.date] = []
-#         self.benchmarks: Dict[datetime.date, Dict[str, float]] = {}
-#         self.mmanifest = kwargs.get("mmanifest", None)
-#         self.update_planner = kwargs.get("update_planner", None)
-#
-#         # --- NEW: stop gate tripped during cleanup/interrupt to block further scheduling/retries
-#         self._stop_event = threading.Event()
-#         self.logger_extra.update({"action_module_name": "data_wrapper", "dataclass": self.dataclass.__name__})
-#
-#     # ensure manifest is saved on context exit
-#     def __exit__(self, exc_type, exc_val, exc_tb):
-#         if self.mmanifest:
-#             self.mmanifest.save()
-#         super().__exit__(exc_type, exc_val, exc_tb)
-#         return False
-#
-#     # --- NEW: trip stop gate during class-specific cleanup (close/aclose/finalizer path)
-#     def _cleanup(self) -> None:
-#         self._stop_event.set()
-#
-#     @staticmethod
-#     def _convert_to_date(date: Union[datetime.date, str]) -> datetime.date:
-#         if isinstance(date, datetime.date):
-#             return date
-#         try:
-#             return pd.to_datetime(date).date()
-#         except ValueError as e:
-#             raise ValueError(f"Error converting {date} to datetime: {e}")
-#
-#     @staticmethod
-#     def _ensure_forward_slash(path: str) -> str:
-#         return path.rstrip("/") + "/"
-#
-#     def process(
-#         self,
-#         max_retries: int = 3,
-#         backoff_base: float = 2.0,
-#         backoff_jitter: float = 0.1,
-#         backoff_max: float = 60.0,
-#     ):
-#         """
-#         Execute the update plan with concurrency, retries and exponential backoff.
-#         Stops scheduling immediately if closed or interrupted (Ctrl-C).
-#         """
-#         overall_start = time.perf_counter()
-#         tasks = list(self.update_planner.get_tasks_by_priority())
-#         if not tasks:
-#             self.logger.info("No updates required based on the current plan.")
-#             return
-#
-#         if self.update_planner.show_progress:
-#             self.update_planner.show_update_plan()
-#
-#         try:
-#             for priority, dates in tasks:
-#                 if self._stop_event.is_set():
-#                     break
-#                 self._execute_task_batch(priority, dates, max_retries, backoff_base, backoff_jitter, backoff_max)
-#         except KeyboardInterrupt:
-#             self.logger.warning("KeyboardInterrupt received — stopping scheduling and shutting down.", extra=self.logger_extra)
-#             self._stop_event.set()
-#             raise
-#         finally:
-#             total_time = time.perf_counter() - overall_start
-#             if self.processed_dates:
-#                 count = len(self.processed_dates)
-#                 self.logger.info(f"Processed {count} dates in {total_time:.1f}s (avg {total_time / count:.1f}s/date)", extra=self.logger_extra)
-#                 if self.update_planner.show_progress:
-#                     self.show_benchmark_summary()
-#
-#     def _execute_task_batch(
-#         self,
-#         priority: int,
-#         dates: List[datetime.date],
-#         max_retries: int,
-#         backoff_base: float,
-#         backoff_jitter: float,
-#         backoff_max: float,
-#     ):
-#         desc = f"Processing {self.dataclass.__name__}, priority: {priority}"
-#         max_thr = min(len(dates), self.max_threads)
-#         self.logger.info(f"Executing {len(dates)} tasks with priority {priority} using {max_thr} threads.", extra=self.logger_extra)
-#
-#         # Use explicit try/finally so we can request cancel of queued tasks on teardown
-#         executor = ThreadPoolExecutor(max_workers=max_thr, thread_name_prefix="datawrapper")
-#         try:
-#             futures = {}
-#             for date in dates:
-#                 if self._stop_event.is_set():
-#                     break
-#                 try:
-#                     fut = executor.submit(
-#                         self._process_date_with_retry, date, max_retries, backoff_base, backoff_jitter, backoff_max
-#                     )
-#                     futures[fut] = date
-#                 except RuntimeError as e:
-#                     # tolerate race: executor shutting down
-#                     if "cannot schedule new futures after shutdown" in str(e).lower():
-#                         self.logger.warning("Executor is shutting down; halting new submissions for this batch.", extra=self.logger_extra)
-#                         break
-#                     raise
-#
-#             iterator = as_completed(futures)
-#             if self.show_progress:
-#                 iterator = tqdm(iterator, total=len(futures), desc=desc)
-#
-#             for future in iterator:
-#                 try:
-#                     future.result(timeout=self.timeout)
-#                 except Exception as e:
-#                     self.logger.error(f"Permanent failure for {futures[future]}: {e}", extra=self.logger_extra)
-#         finally:
-#             # Python 3.9+: cancel_futures prevents queued tasks from starting
-#             executor.shutdown(wait=True, cancel_futures=True)
-#
-#     def _process_date_with_retry(
-#         self,
-#         date: datetime.date,
-#         max_retries: int,
-#         backoff_base: float,
-#         backoff_jitter: float,
-#         backoff_max: float,
-#     ):
-#         for attempt in range(max_retries):
-#             # --- NEW: bail out quickly if shutdown/interrupt began
-#             if self._stop_event.is_set():
-#                 raise RuntimeError("shutting_down")
-#
-#             try:
-#                 self._process_single_date(date)
-#                 return
-#             except Exception as e:
-#                 if attempt < max_retries - 1 and not self._stop_event.is_set():
-#                     base_delay = min(backoff_base ** attempt, backoff_max)
-#                     delay = base_delay * (1 + random.uniform(0.0, max(0.0, backoff_jitter)))
-#                     self.logger.warning(
-#                         f"Retry {attempt + 1}/{max_retries} for {date}: {e} (sleep {delay:.2f}s)",
-#                         extra=self.logger_extra
-#                     )
-#                     time.sleep(delay)
-#                 else:
-#                     self.logger.error(f"Failed processing {date} after {max_retries} attempts.", extra=self.logger_extra)
-#                     raise
-#
-#     def _process_single_date(self, date: datetime.date):
-#         path = f"{self.data_path}{date.year}/{date.month:02d}/{date.day:02d}/"
-#         self.logger.debug(f"Processing date {date.isoformat()} for {path}", extra=self.logger_extra)
-#         if path in self.update_planner.skipped and self.update_planner.ignore_missing:
-#             self.logger.debug(f"Skipping {date} as it exists in the skipped list", extra=self.logger_extra)
-#             return
-#         full_path = f"{path}{self.parquet_filename}"
-#
-#         overall_start = time.perf_counter()
-#         try:
-#             load_start = time.perf_counter()
-#             date_filter = {f"{self.date_field}__date": {date.isoformat()}}
-#             self.logger.debug(f"{self.dataclass.__name__} is loading data for {date} with filter: {date_filter}", extra=self.logger_extra)
-#
-#             local_load_params = self.load_params.copy()
-#             local_load_params.update(date_filter)
-#
-#             with self.dataclass(**self.class_params) as local_class_instance:
-#                 df = local_class_instance.load(**local_load_params)  # expected to be Dask
-#                 load_time = time.perf_counter() - load_start
-#
-#                 if hasattr(local_class_instance, "total_records"):
-#                     total_records = int(local_class_instance.total_records)
-#                     self.logger.debug(f"Total records loaded: {total_records}", extra=self.logger_extra)
-#
-#                     if total_records == 0:
-#                         if self.mmanifest:
-#                             self.mmanifest.record(full_path=path)
-#                         self.logger.info(f"No data found for {full_path}. Logged to missing manifest.", extra=self.logger_extra)
-#                         return
-#
-#                     if total_records < 0:
-#                         self.logger.warning(f"Negative record count ({total_records}) for {full_path}.", extra=self.logger_extra)
-#                         return
-#
-#                 save_start = time.perf_counter()
-#                 parquet_params = {
-#                     "df_result": df,
-#                     "parquet_storage_path": path,
-#                     "fs": self.fs,
-#                     "logger": self.logger,
-#                     "debug": self.debug,
-#                 }
-#                 with ParquetSaver(**parquet_params) as ps:
-#                     ps.save_to_parquet(self.parquet_filename, overwrite=True)
-#                 save_time = time.perf_counter() - save_start
-#
-#                 total_time = time.perf_counter() - overall_start
-#                 self.benchmarks[date] = {
-#                     "load_duration": load_time,
-#                     "save_duration": save_time,
-#                     "total_duration": total_time,
-#                 }
-#                 self._log_success(date, total_time, full_path)
-#
-#         except Exception as e:
-#             self._log_failure(date, e)
-#             raise
-#
-#     def _log_success(self, date: datetime.date, duration: float, path: str):
-#         self.logger.info(f"Completed {date} in {duration:.1f}s | Saved to {path}", extra=self.logger_extra)
-#         self.processed_dates.append(date)
-#
-#     def _log_failure(self, date: datetime.date, error: Exception):
-#         self.logger.error(f"Failed processing {date}: {error}", extra=self.logger_extra)
-#
-#     def show_benchmark_summary(self):
-#         if not self.benchmarks:
-#             self.logger.info("No benchmarking data to show", extra=self.logger_extra)
-#             return
-#         df_bench = pd.DataFrame.from_records([{"date": d, **m} for d, m in self.benchmarks.items()])
-#         df_bench = df_bench.set_index("date").sort_index(ascending=not self.update_planner.reverse_order)
-#         self.logger.info(f"Benchmark Summary:\n {self.dataclass.__name__}\n" + df_bench.to_string(), extra=self.logger_extra)
-#

sibi_dst/utils/parquet_saver.py

@@ -71,6 +71,7 @@ class ParquetSaver(ManagedResource):
             max_delete_workers: int = 8,
             write_gate_max: int = 2,
             write_gate_key: Optional[str] = None,
+            partition_on: Optional[list[str]] = None,
             **kwargs: Any,
     ):
         super().__init__(**kwargs)
@@ -93,6 +94,7 @@ class ParquetSaver(ManagedResource):
         self.max_delete_workers = max(1, int(max_delete_workers))
         self.write_gate_max = max(1, int(write_gate_max))
         self.write_gate_key = (write_gate_key or self.parquet_storage_path).rstrip("/")
+        self.partition_on = partition_on
 
         # Fix: Remove deprecated coerce_timestamps parameter
         self.pyarrow_args.setdefault("compression", "zstd")
@@ -103,7 +105,18 @@ class ParquetSaver(ManagedResource):
 
     # ---------- public API ----------
     def save_to_parquet(self, output_directory_name: str = "default_output", overwrite: bool = True) -> str:
-        target_path = f"{self.parquet_storage_path}/{output_directory_name}".rstrip("/")
+        """
+        Save the Dask DataFrame to Parquet. If partition_on is provided, write as a
+        partitioned dataset without overwriting earlier partitions.
+        """
+        # Always treat as a directory target
+        if self.partition_on:
+            overwrite = False
+            # we override the output_directory_name and overwrite setting to avoid confusion since dask will (re) create subdirs
+            # Partitioned dataset → write directly to root directory
+            target_path = self.parquet_storage_path.rstrip("/")
+        else:
+            target_path = f"{self.parquet_storage_path}/{output_directory_name}".rstrip("/")
 
         sem = get_write_sem(self.write_gate_key, self.write_gate_max)
         with sem:
@@ -111,7 +124,7 @@ class ParquetSaver(ManagedResource):
                 self._clear_directory_safely(target_path)
             self.fs.mkdirs(target_path, exist_ok=True)
 
-            # Define a pyarrow schema and coerce the Dask frame to match it.
+            # Enforce schema before write
             schema = self._define_schema()
             ddf = self._coerce_ddf_to_schema(self.df_result, schema)
 
@@ -128,25 +141,25 @@ class ParquetSaver(ManagedResource):
                 pa.set_cpu_count(self.arrow_cpu)
 
             try:
+                params = {
+                    "path": target_path,
+                    "engine": "pyarrow",
+                    "filesystem": self.fs,
+                    "write_index": self.write_index,
+                    "write_metadata_file": self.write_metadata_file,
+                    **self.pyarrow_args,
+                }
+                self.partition_on = self.partition_on if isinstance(self.partition_on, list) else None
+                if self.partition_on:
+                    params["partition_on"] = self.partition_on
+
                 with self._local_dask_pool():
-                    ddf.to_parquet(
-                        path=target_path,
-                        engine="pyarrow",
-                        schema=schema,
-                        overwrite=False,
-                        filesystem=self.fs,
-                        write_index=self.write_index,
-                        write_metadata_file=self.write_metadata_file,
-                        **self.pyarrow_args,
-                    )
+                    ddf.to_parquet(**params)
             finally:
                 if old_arrow_cpu is not None:
                     pa.set_cpu_count(old_arrow_cpu)
 
-        self.logger.info(
-            f"Parquet dataset written: {target_path}",
-            extra=self.logger_extra,
-        )
+        self.logger.info(f"Parquet dataset written: {target_path}", extra=self.logger_extra)
         return target_path
 
     @contextmanager

sibi_dst/utils/progress/sse_runner.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import asyncio, contextlib, inspect, json
-from typing import Any, Awaitable, Callable, Dict, Optional, Union
+from typing import Any, Awaitable, Callable, Dict, Optional, Union, Mapping, MutableMapping
 from fastapi import Request
 from sse_starlette.sse import EventSourceResponse
 from sibi_dst.utils import Logger
@@ -13,6 +13,16 @@ TaskFn = Union[Task2, Task3]
 def _as_sse_msg(event: str, data: Any) -> dict:
     return {"event": event, "data": json.dumps(data) if not isinstance(data, (str, bytes)) else data}
 
+def _merge_ctx(*parts: Optional[Mapping[str, Any]]) -> Dict[str, Any]:
+    """Right-most precedence; shallow merge is sufficient for our keys."""
+    out: Dict[str, Any] = {}
+    for p in parts:
+        if not p:
+            continue
+        for k, v in p.items():
+            out[k] = v
+    return out
+
 class SSERunner:
     def __init__(self, *, task: TaskFn, logger: Logger, ping: int = 15,
                  headers: Optional[dict] = None, auto_complete: bool = True) -> None:
@@ -31,39 +41,57 @@ class SSERunner:
     async def _worker(self, queue: asyncio.Queue, task_id: str, ctx: Dict[str, Any]) -> None:
         self.logger.info(f"SSE {task_id}: start")
         try:
-            await queue.put(_as_sse_msg("progress", {"message": "Task started"}))
+            await queue.put(_as_sse_msg("progress", {"message": "Task started", "task_id": task_id}))
             payload = await self._call_task(queue, task_id, ctx)
             if self.auto_complete:
                 final = payload if payload is not None else {"status": "complete"}
+                if isinstance(final, dict) and "task_id" not in final:
+                    final["task_id"] = task_id
                 await queue.put(_as_sse_msg("complete", final))
             self.logger.info(f"SSE {task_id}: complete")
         except asyncio.CancelledError:
             raise
         except Exception as e:
             self.logger.error(f"SSE {task_id} failed: {e}", exc_info=True)
-            await queue.put(_as_sse_msg("error", {"detail": str(e)}))
+            await queue.put(_as_sse_msg("error", {"detail": str(e), "task_id": task_id}))
         finally:
             await queue.put(None)
 
-    def endpoint(self):
-        async def handler(request: Request):  # <-- only Request
+    def endpoint(self, *, ctx: Optional[Dict[str, Any]] = None):
+        """
+        Create an SSE endpoint.
+        - ctx: optional explicit context dict provided by the caller.
+               This overrides request-derived context and request.state.ctx.
+        Precedence when merging: request-derived < request.state.ctx < ctx (explicit).
+        """
+        async def handler(request: Request):
             queue: asyncio.Queue = asyncio.Queue()
             task_id = str(asyncio.get_running_loop().time()).replace(".", "")
             self.logger.debug(
-                f"SSE {task_id}: new request client={request.client} path={request.url.path} q={dict(request.query_params)}")
+                f"SSE {task_id}: new request client={request.client} path={request.url.path} q={dict(request.query_params)}"
+            )
 
-            ctx: Dict[str, Any] = {
-                "path": dict(request.path_params),          # <-- pull path params here
+            # Base ctx from the HTTP request
+            base_ctx: Dict[str, Any] = {
+                "path": dict(request.path_params),
                 "query": dict(request.query_params),
                 "method": request.method,
+                "headers": dict(request.headers) if hasattr(request, "headers") else None,
             }
             if request.headers.get("content-type", "").startswith("application/json"):
                 try:
-                    ctx["body"] = await request.json()
+                    base_ctx["body"] = await request.json()
                 except Exception:
-                    ctx["body"] = None
+                    base_ctx["body"] = None
+
+            # Pull any pre-attached ctx from request.state
+            state_ctx: Optional[Dict[str, Any]] = getattr(request.state, "ctx", None)
+
+            # Merge with precedence: base_ctx < state_ctx < explicit ctx
+            merged_ctx = _merge_ctx(base_ctx, state_ctx, ctx)
 
-            worker = asyncio.create_task(self._worker(queue, task_id, ctx))
+            # Run worker
+            worker = asyncio.create_task(self._worker(queue, task_id, merged_ctx))
 
             async def gen():
                 try: