python-jack-knife 0.7.1__tar.gz → 0.7.4__tar.gz

{python_jack_knife-0.7.1/src/python_jack_knife.egg-info → python_jack_knife-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jack-knife
-Version: 0.7.1
+Version: 0.7.4
 Summary: Python Jack Knife – a command line data processor
 Author-email: Mike Schultz <mike.schultz@gmail.com>
 License: 

python_jack_knife-0.7.4/src/pjk/integrations/postgres_pipe.py

@@ -0,0 +1,268 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 Mike Schultz
+#
+# djk/pipes/postgres_pipe.py
+
+import base64
+import datetime as _dt
+import uuid
+import time
+from decimal import Decimal
+from typing import Any, Dict, Optional
+
+from pjk.usage import ParsedToken, Usage
+from pjk.common import Integration
+from pjk.pipes.query_pipe import QueryPipe
+
+MAX_RETRIES = 3
+BASE_DELAY = 0.1  # seconds
+
+class DBClient:
+    """Per-instance pg8000 connection wrapper. No shared state."""
+
+    def __init__(
+        self,
+        host: str,
+        username: str,
+        password: Optional[str],
+        db_name: str,
+        port: int = 5432,
+        ssl: bool = False,
+    ):
+        import pg8000  # lazy import
+
+        kwargs = dict(
+            user=username,
+            password=password,
+            host=host,
+            database=db_name,
+            port=port,
+        )
+        if ssl:
+            import ssl as _ssl
+
+            kwargs["ssl_context"] = _ssl.create_default_context()
+
+        try:
+            self.conn = pg8000.connect(**kwargs)
+            self.conn.autocommit = True
+        except Exception as e:
+            print("Failed to connect to DB")
+            raise e
+
+    def close(self):
+        if getattr(self, "conn", None) is None:
+            return
+
+        import pg8000  # lazy
+
+        try:
+            self.conn.close()
+        except pg8000.exceptions.InterfaceError:
+            # Already closed / broken; ignore.
+            pass
+        finally:
+            self.conn = None
+
+
+def _iso_dt(x: _dt.datetime) -> str:
+    """ISO 8601; normalize UTC offset to 'Z'."""
+    s = x.isoformat()
+    return s.replace("+00:00", "Z")
+
+
+def normalize(obj: Any) -> Any:
+    """
+    Make values JSON/YAML-safe and portable (schema-agnostic):
+      - Decimal -> exact string (no sci-notation)
+      - date/datetime/time -> ISO-8601 string (datetime keeps offset; UTC -> 'Z')
+      - UUID -> string
+      - bytes -> base64 string
+      - lists/tuples/sets, dicts -> normalized recursively
+      - leaves int/float/str/bool/None as-is
+    """
+    if obj is None:
+        return None
+
+    if isinstance(obj, Decimal):
+        return format(obj, "f")  # exact value as string
+
+    if isinstance(obj, _dt.datetime):
+        return _iso_dt(obj)
+
+    if isinstance(obj, (_dt.date, _dt.time)):
+        return obj.isoformat()
+
+    if isinstance(obj, uuid.UUID):
+        return str(obj)
+
+    if isinstance(obj, (bytes, bytearray, memoryview)):
+        return base64.b64encode(bytes(obj)).decode("ascii")
+
+    if isinstance(obj, dict):
+        return {k: normalize(v) for k, v in obj.items()}
+
+    if isinstance(obj, (list, tuple, set)):
+        return [normalize(v) for v in obj]
+
+    return obj
+
+
+def _row_to_dict(cursor, row) -> Dict[str, Any]:
+    cols = [d[0] for d in cursor.description]
+    return {col: normalize(val) for col, val in zip(cols, row)}
+
+
+class PostgresPipe(QueryPipe, Integration):
+    name = "postgres"
+    desc = "Postgres query pipe; executes SQL over input record['query']."
+    arg0 = ("instance", "instance of database.")
+    examples = [
+        ["myquery.sql", "postgres:mydb", "-"],
+        ["{'query': 'SELECT * from MY_TABLE;'}", "postgres:mydb", "-"],
+        ["{'query': 'SELECT * FROM pg_catalog.pg_tables;'}", "postgres:mydb"],
+        ["{'query': 'SELECT procedure_batch(%s, ...), batch_params:{...}"],
+        ["{'query': 'SELECT procedure_jsonb(%s, ...), json_params:json_string"],
+    ]
+
+    # name, type, default
+    config_tuples = [
+        ("db_name", str, None),
+        ("host", str, None),
+        ("user", str, None),
+        ("password", str, None),
+        ("port", int, 5432),
+        ("ssl", bool, False),
+    ]
+
+    def __init__(self, ptok: ParsedToken, u: Usage, root=None):
+        super().__init__(ptok, u, root=root)
+
+        self.db_name = u.get_config("db_name")
+        self.db_host = u.get_config("host")
+        self.db_user = u.get_config("user")
+        self.db_pass = u.get_config("password")
+        self.db_port = u.get_config("port")
+        self.db_ssl = u.get_config("ssl")
+
+        # Standard params field: single-exec params (list/tuple/dict/single value)
+        self.params_field = "params"
+
+        # Legacy batch path: list[tuple|list|dict] → executemany
+        self.batch_field = "batch_params"
+
+        # Explicit JSON payload field (no query sniffing).
+        # If present, this value is passed to cur.execute(query, json_params).
+        self.json_params_field = "json_params"
+
+        # One DB client (and thus one connection) per PostgresPipe instance.
+        # Under your invariant (one thread per pipe), this is thread-safe.
+        self.client = DBClient(
+            host=self.db_host,
+            username=self.db_user,
+            password=self.db_pass,
+            db_name=self.db_name,
+            port=self.db_port,
+            ssl=self.db_ssl,
+        )
+
+    def reset(self):
+        # stateless across reset
+        pass
+
+    def close(self):
+        if self.client is not None:
+            self.client.close()
+
+    def _make_header(self, cur, query: str, params=None) -> Dict[str, Any]:
+        """
+        Inspect the cursor and build a full header record.
+        Figures out result, rowcount, function automatically.
+        """
+        h = {
+            "db": self.db_name,
+            "dbhost": self.db_host,
+        }
+        if params is not None:
+            h["params"] = params
+
+        if cur.description:
+            cols = [d[0] for d in cur.description]
+            if len(cols) == 1 and cols[0] == "ingest_event":
+                _ = cur.fetchone()  # consume void row
+                h["result"] = "ok"
+                h["function"] = "ingest_event"
+            else:
+                h["result"] = "ok"
+                h["rowcount"] = cur.rowcount if cur.rowcount != -1 else None
+        else:
+            h["result"] = "ok"
+            h["rowcount"] = cur.rowcount
+
+        return h
+
+    def execute_query_returning_S_xO_iterable(self, record):
+        query = record.get(self.query_field)
+        if not query:
+            record["_error"] = "missing query"
+            yield record
+            return
+
+        # Priority: json_params > batch_params > params
+        json_params = record.get(self.json_params_field, None)
+        batch = record.get(self.batch_field, None)
+        params = record.get(self.params_field, None)
+
+        cur = self.client.conn.cursor()
+        try:
+            did_executemany = False
+            header_params = None
+
+            # ---------- execute ----------
+            if json_params is not None:
+                # Explicit JSON payload; caller controls shape.
+                # We don't inspect query or payload.
+                if isinstance(json_params, (list, tuple, dict)):
+                    cur.execute(query, json_params)
+                else:
+                    cur.execute(query, (json_params,))
+                header_params = {self.json_params_field: json_params}
+
+            elif batch is not None:
+                # Legacy executemany path; no magic.
+                if len(batch) == 0:
+                    cur.execute("SELECT 1")
+                    header_params = {"batch_size": 0}
+                elif len(batch) == 1:
+                    cur.execute(query, batch[0])
+                    header_params = {"batch_size": 1, "params": batch[0]}
+                else:
+                    cur.executemany(query, batch)
+                    did_executemany = True
+                    header_params = {"batch_size": len(batch)}
+
+            else:
+                # Single-statement path.
+                if params is None:
+                    cur.execute(query)
+                    header_params = None
+                else:
+                    if isinstance(params, (list, tuple, dict)):
+                        cur.execute(query, params)
+                    else:
+                        cur.execute(query, (params,))
+                    header_params = params
+
+            # ---------- header ----------
+            yield self._make_header(cur, query, header_params)
+
+            # ---------- stream rows (only meaningful for single execute that returns rows) ----------
+            if not did_executemany and cur.description:
+                cols = [d[0] for d in cur.description]
+                if not (len(cols) == 1 and cols[0] == "ingest_event"):
+                    for row in cur:
+                        yield _row_to_dict(cur, row)
+
+        finally:
+            cur.close()
+            # connection stays open for this pipe; closed in .close()

{python_jack_knife-0.7.1 → python_jack_knife-0.7.4}/src/pjk/pipes/query_pipe.py

@@ -35,8 +35,8 @@ class QueryPipe(Pipe):
         return u
 
 
-    def __init__(self, ptok: ParsedToken, usage: Usage):
-        super().__init__(ptok, usage)
+    def __init__(self, ptok: ParsedToken, usage: Usage, root = None):
+        super().__init__(ptok, usage, root=root)
         self.output_shape = usage.get_param('shape')
         self.count = usage.get_param('count')
         self.query_field = 'query' # for all subclasses

{python_jack_knife-0.7.1 → python_jack_knife-0.7.4}/src/pjk/sinks/graph_bar_line.py

@@ -92,6 +92,7 @@ class MultiYAdapter:
     @staticmethod
     def to_df(records: Iterable[Dict[str, Any]], x_field: str, y_fields: Sequence[str]) -> pd.DataFrame:
         import pandas as pd # lazy
+        import numpy as np # lazy
         rows: List[Dict[str, Any]] = []
         for r in records:
             if x_field not in r:
@@ -120,7 +121,8 @@ class MultiYAdapter:
 class SingleYWithSetsAdapter:
     """Legacy: single y_field + optional per-row set_name to create series."""
     @staticmethod
-    def to_df(records: Iterable[Dict[str, Any]], x_field: str, y_field: str) -> pd.DataFrame:
+    def to_df(records: Iterable[Dict[str, Any]], x_field: str, y_field: str):
+        import pandas as pd # lazy
         triplets = []  # (x, y, set_name)
         for r in records:
             if x_field in r and y_field in r:
@@ -137,7 +139,6 @@ class SingleYWithSetsAdapter:
 # ----------------------------- Plotter -----------------------------
 class GraphPlotter:
     def __init__(self, params: GraphParams):
-        import numpy as np
         self.pms = params
         self.y_fields = list(dict.fromkeys(self.pms.y_fields))  # dedupe, preserve order
 
@@ -145,6 +146,7 @@ class GraphPlotter:
         import matplotlib.pyplot as plt # lazy
         import matplotlib.dates as mdates # lazy
         import pandas as pd # lazy
+        import numpy as np # lazy
 
         fig = plt.figure()
         ax = plt.gca()
@@ -291,6 +293,7 @@ class GraphPlotter:
 
     def _bars_time(self, ax, df: pd.DataFrame, y_cols: Sequence[str]) -> None:
         # Grouped bars at each timestamp using index positions
+        import numpy as np # lazy
         x_vals = df["ts"].to_numpy(); idx = np.arange(len(x_vals))
         n = len(y_cols); width = 0.8 / max(n, 1)
         for i, y in enumerate(y_cols):
@@ -300,6 +303,7 @@ class GraphPlotter:
         ax.set_xticks(idx, [pd.to_datetime(t).strftime("%Y-%m-%d %H:%M") for t in x_vals], rotation=45)
 
     def _bars_categorical(self, ax, df: pd.DataFrame, y_cols: Sequence[str]) -> None:
+        import numpy as np # lazy
         seen = set(); ordered_x: List[Any] = []
         for x in df["x"].tolist():
             if x not in seen:
@@ -312,6 +316,7 @@ class GraphPlotter:
         ax.set_xticks(idx, ordered_x, rotation=45)
 
     def _lines_categorical(self, ax, df: pd.DataFrame, y_cols: Sequence[str]) -> None:
+        import numpy as np # lazy
         seen = set(); ordered_x: List[Any] = []
         for x in df["x"].tolist():
             if x not in seen:

{python_jack_knife-0.7.1 → python_jack_knife-0.7.4}/src/pjk/sources/factory.py

@@ -13,9 +13,11 @@ from pjk.sources.inline_source import InlineSource
 from pjk.sources.user_source_factory import UserSourceFactory
 from pjk.sources.parquet_source import ParquetSource
 from pjk.sources.format_source import FormatSource
+from pjk.sources.s3_select_source import S3SelectSource
 
 COMPONENTS = {
         'inline': InlineSource,
+        's3s': S3SelectSource,
         'json': JsonSource,
         'jsonl': JsonSource,
         'csv': CSVSource,
@@ -35,6 +37,11 @@ class SourceFactory(ComponentFactory):
     def create(self, token: str) -> Source:
         token = token.strip()
 
+        # s3s is a pseudo source only in the above list to provide easy man page
+        # it's instantiated by the parser when <file>.s3s, so disallow standard search for it.
+        if token == 's3s':
+            return None
+
         if InlineSource.is_inline(token):
             return InlineSource(token)
         
@@ -44,6 +51,12 @@ class SourceFactory(ComponentFactory):
             source = UserSourceFactory.create(ptok)
             if source:
                 return source
+            
+        # s3 select file
+        if ptok.pre_colon.endswith('.s3s'):
+            source = S3SelectSource(ptok, None)
+            if source:
+                return source
 
         source_cls = self.get_component_class(ptok.pre_colon)
         if source_cls and not issubclass(source_cls, FormatSource):