python-jack-knife 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

pjk/common.py

@@ -5,7 +5,7 @@ import sys, shutil, subprocess, contextlib, signal
 import os
 import re
 import yaml
-from pjk.base import TokenError, Integration
+from pjk.base import TokenError, Integration, Source, Pipe
 
 class SafeNamespace:
     def __init__(self, obj):
@@ -74,50 +74,32 @@ def highlight(text: str, color: str = 'bold', value: str = None) -> str:
     style = COLOR_CODES.get(color.lower(), COLOR_CODES['bold'])
     return text.replace(value, f"{style}{value}{RESET}")
 
-class Lookups:
-    def __init__(self, component_class):
-        self.lookups_yaml = os.path.expanduser('~/.pjk/lookups.yaml')
+class Config:
+    def __init__(self, instance_type: str, component_class: Source|Pipe, instance: str):
+        # instance = name of the instance, e.g. 'myindexcollection', instance_type = 'index'
+        # instance_type only used by automatic config template maker MUST BE STRING LITERAL!
+        self.configs_yaml = os.path.expanduser('~/.pjk/component_configs.yaml')
         self.class_name = type(component_class).__name__
+        self.instance = instance
         self._data = {}
         self._load()
         
     def _load(self):
-        """Load lookups from YAML file if it exists."""
-        if os.path.exists(self.lookups_yaml):
-            with open(self.lookups_yaml, 'r') as f:
+        if os.path.exists(self.configs_yaml):
+            with open(self.configs_yaml, 'r') as f:
                 self._data = yaml.safe_load(f) or {}
         else:
             self._data = {}
 
-    def save(self):
-        """Save current lookups back to YAML file."""
-        os.makedirs(os.path.dirname(self.lookups_yaml), exist_ok=True)
-        with open(self.lookups_yaml, 'w') as f:
-            yaml.safe_dump(self._data, f)
-
-    def get(self, key, default=None):
-        lookup_key = f'{self.class_name}-{key}'
-        entry = self._data.get(lookup_key, default)
+    def lookup(self, param: str, default=None):
+        instance_key = f'{self.class_name}-{self.instance}'
+        entry = self._data.get(instance_key, None)
         if not entry:
             raise TokenError(
-                f"~/.pjk/lookups.yaml does not contain entry for '{lookup_key}' with required params."
+                f"~/.pjk/component_configs.yaml does not contain entry for '{instance_key}' with required params."
             )
-        return entry
-
-    def set(self, key, value):
-        """Set a lookup value and persist it."""
-        self._data[key] = value
-        self.save()
-
-    def delete(self, key):
-        """Remove a key if it exists and save."""
-        if key in self._data:
-            del self._data[key]
-            self.save()
-
-    def all(self):
-        """Return the full lookup dictionary."""
-        return dict(self._data)
+        
+        return entry.get(param, default)
 
 class ComponentFactory:
     def __init__(self, core_components: dict):

pjk/integrations/opensearch_client.py

@@ -0,0 +1,78 @@
+from pjk.common import Config
+
+class OpenSearchClient:
+
+    @classmethod
+    def get_client(cls, config: Config):
+        aws_auth = config.lookup("os_auth_use_aws", "true") == 'true'
+        scheme = config.lookup("os_scheme", "https")
+        verify_certs = config.lookup("os_verify_certs", "true") == 'true'
+        ca_certs = config.lookup("os_ca_certs", None)
+        region = config.lookup("os_region", None)
+        service = config.lookup("os_service", "es")
+        username = config.lookup("os_username", None)
+        password = config.lookup("os_password", None)
+        timeout = float(config.lookup("os_timeout", 30))
+        ssl_assert_hostname = config.lookup("os_ssl_assert_hostname", "true") == 'true'
+        ssl_show_warn = config.lookup("os_ssl_show_warn", "false") == 'true'
+        host = config.lookup("os_host", None)
+        port = config.lookup("os_port", None)
+
+        # Reasonable port defaults
+        if port is None:
+            port = 443 if scheme == "https" else 9200
+        else:
+            port = int(port)
+
+        if host is None:
+            raise ValueError("Config os_host is required (set os_host + os_port/os_scheme, or a connection profile).")
+
+        # Lazy import so this module can still be imported if deps aren't installed.
+        try:
+            from opensearchpy import OpenSearch, RequestsHttpConnection, Urllib3HttpConnection
+        except Exception as e:
+            raise RuntimeError("opensearch-py must be installed to use OpenSearchQueryPipe") from e
+
+        http_auth = None
+        connection_class = Urllib3HttpConnection  # default
+        use_ssl = (scheme == "https")
+
+        if aws_auth:
+            # AWS SigV4 (works for OpenSearch Service / legacy ES domains)
+            try:
+                import boto3
+                from requests_aws4auth import AWS4Auth
+            except Exception as e:
+                raise RuntimeError("boto3 and requests-aws4auth are required for os_auth_method='aws'") from e
+
+            if not region:
+                raise ValueError("Config os_region is required for os_auth_method='aws'.")
+
+            session = boto3.Session()
+            credentials = session.get_credentials()
+            if credentials is None:
+                raise RuntimeError("No AWS credentials found (boto3 session.get_credentials() returned None).")
+
+            creds = credentials.get_frozen_credentials()
+            http_auth = AWS4Auth(creds.access_key, creds.secret_key, region, service, session_token=creds.token)
+            connection_class = RequestsHttpConnection  # SigV4 signing via requests path
+
+        else:
+            if not (username and password):
+                raise ValueError("os_username and os_password are required for os_auth_method='basic'.")
+            http_auth = (username, password)
+
+        # Build client
+        client = OpenSearch(
+            hosts=[{"host": host, "port": port}],
+            http_auth=http_auth,
+            use_ssl=use_ssl,
+            verify_certs=verify_certs,
+            ssl_assert_hostname=ssl_assert_hostname,
+            ssl_show_warn=ssl_show_warn,
+            ca_certs=ca_certs,
+            timeout=timeout,
+            connection_class=connection_class,
+        )
+
+        return client

pjk/integrations/opensearch_query_pipe.py

@@ -0,0 +1,104 @@
+import os
+import sys
+import traceback
+from copy import deepcopy
+from typing import Optional, Iterator, Dict, Any, Iterable
+
+from pjk.base import Pipe, ParsedToken, Usage, Integration
+from pjk.pipes.query_pipe import QueryPipe
+from pjk.common import Config
+from pjk.integrations.opensearch_client import OpenSearchClient
+
+def build_body_from_string(query_string: str) -> dict:
+    if query_string == "*":
+        return {"query": {"match_all": {}}}
+    else:
+        return {
+            "query": {
+                "simple_query_string": {
+                    "query": query_string
+                }
+            }
+        }
+
+class OpenSearchQueryPipe(QueryPipe, Integration):
+    name = "os_query"
+    desc = "Opensearch query pipe. Uses record['query_string'] or record['query_object'] for os query"
+    arg0 = ("index", "index to query over")
+    examples = [
+        ["{'query_string': '*'}", 'os_query:myindex', '-'],
+        ["{'query_string': 'dog'}", 'os_query:myindex', '-'],
+        ["{'query_string': 'dog AND cat'}", 'os_query:myindex', '-'],
+        ["{'query_object': {query: {...}}", 'os_query:myindex', '-'],
+    ]
+
+    def __init__(self, ptok: ParsedToken, usage: Usage):
+        super().__init__(ptok, usage)
+
+        # index from arg0 or config
+        self.index = ptok.get_arg(0)
+
+        # Build the OpenSearch client (handles AWS/basic/none)
+        config = Config('index', self, self.index)
+        self.client = OpenSearchClient.get_client(config)
+
+        # Iteration state
+        self.cur_record: Optional[Dict[str, Any]] = None
+        self.hits_iter: Optional[Iterator[Dict[str, Any]]] = None
+
+    def reset(self):
+        # keep the index open between drains
+        pass
+
+    def close(self):
+        pass
+
+    def execute_query_returning_Q_xR_iterable(self, query_record: dict) -> Iterator[Dict[str, Any]]:
+        query_string = query_record.get('query_string', None)
+        query_body = None
+
+        if query_string:
+            query_body = build_body_from_string(query_string)
+        else:
+            query_body = query_record.get('query_object')
+
+        try:
+            # Build final request body
+            req_body = deepcopy(query_body)
+            req_body["size"] = self.count
+
+            res = self.client.search(index=self.index, body=req_body)
+
+            total_hits = 0
+            took = res.get("took")
+            hits = res.get("hits", {}).get("hits", [])
+            total_obj = res.get("hits", {}).get("total", {})
+            if isinstance(total_obj, dict):
+                total_hits = total_obj.get("value", 0)
+            elif isinstance(total_obj, int):
+                total_hits = total_obj
+
+            # Emit a metadata record first
+            yield {
+                "took_ms": took,
+                "total_hits": total_hits,
+                "index": self.index,
+                "os_query_body": req_body
+            }
+
+            # Emit each hit
+            for hit in hits:
+                if "_source" in hit and isinstance(hit["_source"], dict):
+                    yield hit["_source"]
+                else:
+                    # Some queries (e.g., stored fields only) might not include _source
+                    yield {"_type": "os_query_hit", "_hit": hit}
+
+        except Exception as e:
+            print("OpenSearch query error:", e, file=sys.stderr)
+            traceback.print_exc()
+            yield {
+                "_type": "os_query_error",
+                "error": str(e),
+                "query_record": query_record,
+            }

pjk/integrations/postgres_pipe.py

@@ -10,7 +10,7 @@ from decimal import Decimal
 from typing import Any, Dict, Optional
 
 from pjk.base import Integration, ParsedToken, Usage
-from pjk.common import Lookups
+from pjk.common import Config
 from pjk.pipes.query_pipe import QueryPipe
 
 
@@ -91,26 +91,25 @@ def _row_to_dict(cursor, row) -> Dict[str, Any]:
 
 
 class PostgresPipe(QueryPipe,Integration):
-    name = 'pgres'
+    name = 'postgres'
     desc = "Postgres query pipe; executes SQL from input."
     arg0 = ("dbname", 'database name.')
     examples = [
-        ['myquery.sql', 'pgres:mydb', '-'],
-        ["{'query': 'SELECT * from MY_TABLE;'}", 'pgres:mydb', '-'],
-        ["{'query': 'SELECT * FROM pg_catalog.pg_tables;'}", 'pgres:mydb']
+        ['myquery.sql', 'postgres:mydb', '-'],
+        ["{'query': 'SELECT * from MY_TABLE;'}", 'postgres:mydb', '-'],
+        ["{'query': 'SELECT * FROM pg_catalog.pg_tables;'}", 'postgres:mydb']
     ]
 
     def __init__(self, ptok: ParsedToken, usage: Usage):
         super().__init__(ptok, usage)
 
-        lookups = Lookups(self)
         self.dbname = usage.get_arg("dbname")
-
-        self.db_host = self.lookup_params.get("host")
-        self.db_user = self.lookup_params.get("user")
-        self.db_pass = self.lookup_params.get("password")
-        self.db_port = int(self.lookup_params.get("port", 5432))
-        self.db_ssl  = bool(self.lookup_params.get("ssl", False))
+        config = Config('dbname', self, self.dbname)
+        self.db_host = config.lookup("host")
+        self.db_user = config.lookup("user")
+        self.db_pass = config.lookup("password")
+        self.db_port = int(config.lookup("port", 5432))
+        self.db_ssl  = bool(config.lookup("ssl", False))
 
         self.query_field  = usage.get_param('query_field')
         self.params_field = "params"  # optional: list/tuple (positional) or dict (named)

pjk/integrations/snowflake_pipe.py

@@ -9,8 +9,9 @@ import uuid
 from decimal import Decimal
 from typing import Any, Dict, Optional
 
-from pjk.base import ParsedToken, Usage, TokenError, Integration
+from pjk.base import ParsedToken, TokenError, Usage, Integration
 from pjk.pipes.query_pipe import QueryPipe
+from pjk.common import Config
 
 
 # ---------- utilities ----------
@@ -55,23 +56,6 @@ def _row_to_dict(cursor, row) -> Dict[str, Any]:
     return {col: normalize(val) for col, val in zip(cols, row)}
 
 
-def _get_any(params: Dict[str, Any], *keys: str) -> Optional[Any]:
-    """
-    Fetch a value from params using any of the provided keys,
-    trying case variants and optional SNOWFLAKE_ prefix.
-    """
-    variants = []
-    for k in keys:
-        variants.extend([
-            k, k.lower(), k.upper(),
-            f"snowflake_{k}".lower(), f"SNOWFLAKE_{k}".upper()
-        ])
-    for v in variants:
-        if v in params:
-            return params[v]
-    return None
-
-
 # ---------- client ----------
 
 class SnowflakeClient:
@@ -141,29 +125,28 @@ class SnowflakeClient:
 class SnowflakePipe(QueryPipe, Integration):
     """
     Snowflake query pipe; executes SQL found in input record['query'] and streams rows.
-    Connection/session settings are pulled from ~/.pjk/lookups.yaml under the arg name.
+    Connection/session settings are pulled from ~/.pjk/component_configs.yaml under the arg name.
     """
     name = 'snowflake'
     desc = "Snowflake query pipe; executes an SQL query for each input record."
     arg0 = ('dbname', 'database name.')
     examples = [
-        ["{'query': 'SELECT CURRENT_ROLE();'}", "snow:EDLDB", "-"],
-        ["myquery.sql", "snow:EDLDB", "-"]
+        ["{'query': 'SELECT CURRENT_ROLE();'}", "snowflake:EDLDB", "-"],
+        ["myquery.sql", "snowflake:EDLDB", "-"]
     ]
 
     def __init__(self, ptok: ParsedToken, usage: Usage):
         super().__init__(ptok, usage)
 
-        self.dbname = usage.get_arg(type(self).arg0[0])
-
-        # Accept both bare keys and SNOWFLAKE_* variants in lookups.yaml
-        self.sf_account  = _get_any(self.lookup_params, "account")
-        self.sf_user     = _get_any(self.lookup_params, "user")
-        self.sf_auth     = _get_any(self.lookup_params, "authenticator")
-        self.sf_role     = _get_any(self.lookup_params, "role")
-        self.sf_wh       = _get_any(self.lookup_params, "warehouse")
+        self.dbname = usage.get_arg('dbname')
+        config = Config('dbname', self, self.dbname)
+        self.sf_account  = config.lookup("account")
+        self.sf_user     = config.lookup("user")
+        self.sf_auth     = config.lookup("authenticator")
+        self.sf_role     = config.lookup("role")
+        self.sf_wh       = config.lookup("warehouse")
+        self.sf_schema   = config.lookup("schema")
         self.sf_db       = self.dbname
-        self.sf_schema   = _get_any(self.lookup_params, "schema")
 
         # Basic validation
         missing = [k for k, v in [
@@ -176,7 +159,7 @@ class SnowflakePipe(QueryPipe, Integration):
         ] if not v]
         if missing:
             raise TokenError(
-                f"lookups entry '{self.dbname}' missing: {', '.join(missing)}"
+                f"config entry '{self.dbname}' missing: {', '.join(missing)}"
             )
 
         self.query_field = usage.get_param('query_field')

pjk/main.py

@@ -11,6 +11,8 @@ from pjk.parser import ExpressionParser
 from pjk.base import UsageError
 from pjk.log import init as init_logging
 from datetime import datetime
+from pathlib import Path
+import shutil
 import traceback
 import concurrent.futures
 from pjk.registry import ComponentRegistry
@@ -65,13 +67,22 @@ def execute_threaded(sinks, stop_progress=None):
     else:
         executor.shutdown(wait=True)
 
+def initialize():
+    init_logging()
+
+    '''
+    src = Path("src/pjk/resources/component_configs.tmpl")
+    dst_dir = Path.home() / ".pjk"
+    dst_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copy(src, dst_dir / src.name)
+    '''
+
 def execute(command: str):
     tokens = shlex.split(command, comments=True, posix=True)
     execute_tokens(tokens)
 
 def execute_tokens(tokens: List[str]):
-    init_logging()
-    # (remove the sys.exit SIGINT handler here)
+    initialize()
 
     if '--version' in tokens:
         print(f"pjk version {__version__}")

pjk/pipes/factory.py

@@ -20,6 +20,7 @@ from pjk.pipes.select import SelectFields
 from pjk.pipes.denorm import DenormPipe
 from pjk.integrations.postgres_pipe import PostgresPipe
 from pjk.integrations.snowflake_pipe import SnowflakePipe
+from pjk.integrations.opensearch_query_pipe import OpenSearchQueryPipe
 from pjk.pipes.sample import SamplePipe
 from pjk.pipes.user_pipe_factory import UserPipeFactory
 
@@ -40,7 +41,8 @@ COMPONENTS = {
         'sample': SamplePipe,
         'explode': DenormPipe,
         'postgres': PostgresPipe,
-        'snowflake': SnowflakePipe
+        'snowflake': SnowflakePipe,
+        'os_query': OpenSearchQueryPipe
     }
 
 class PipeFactory(ComponentFactory):

pjk/pipes/query_pipe.py

@@ -1,11 +1,9 @@
-from pjk.base import Pipe, ParsedToken, Usage, TokenError
-from pjk.common import Lookups
+from pjk.base import Pipe, ParsedToken, Usage
 from typing import Any, Dict, Iterable, Optional
 from abc import abstractmethod
 
 
 class QueryPipe(Pipe):
-    requires_lookups = True
     name: str = None
     desc: str = None
     arg0: tuple[Optional[str], Optional[str]] = (None, None)
@@ -18,8 +16,7 @@ class QueryPipe(Pipe):
             desc=cls.desc,
             component_class=cls
         )
-        u.def_arg(name=cls.arg0[0], usage=f"{cls.arg0[1]} ~/.pjk/lookups.yaml must contain entry '{cls.__name__}-<{cls.arg0[0]}'>\n  with necessary parameters.")
-        u.def_param("query_field", usage="field of query.", default="query")
+        u.def_arg(name=cls.arg0[0], usage=f"{cls.arg0[1]} ~/.pjk/component_configs.yaml must contain entry '{cls.__name__}-<{cls.arg0[0]}'>\n  with necessary parameters.")
         u.def_param("count", usage="Number of search results, (databases may ignore)", is_num=True, default="10")
         u.def_param("shape", usage='the shape of ouput records', is_num=False,
                        valid_values={'xR', 'Q_xR', 'Qxr'}, default='xR')
@@ -32,14 +29,8 @@ class QueryPipe(Pipe):
 
     def __init__(self, ptok: ParsedToken, usage: Usage):
         super().__init__(ptok, usage)
-
-        self.lookup_params = None
-        if type(self).requires_lookups:
-            lookups = Lookups(self)
-            lookup_name = usage.get_arg(type(self).arg0[0])
-            self.lookup_params = lookups.get(lookup_name)
-
         self.output_shape = usage.get_param('shape')
+        self.count = usage.get_param('count')
 
     @abstractmethod
     def execute_query_returning_Q_xR_iterable(self, record) -> Iterable[Dict[str, Any]]:
@@ -83,7 +74,7 @@ class QueryPipe(Pipe):
                         q_out = self._make_q_object(in_rec, out_rec)
                         continue
                     r_list.append(out_rec)
-                q_out['result'] = r_list
+                q_out['child'] = r_list
                 yield q_out
 
 

pjk/sources/format_source.py

@@ -60,9 +60,9 @@ class FormatSource(Source):
         """
 
         pattern = re.compile(
-            r'^(?:(?P<pre_colon>[^:]+):)?'            # optional precolon
-            r'(?P<path>[^:]+?)'                      # main path
-            r'(?:\.(?P<ext>\w+(?:\.gz)?))?$'         # optional extension, e.g. json, csv, json.gz
+            r'^(?:(?P<pre_colon>[^:]+):)?'     # take everything up to the first colon (if any)
+            r'(?P<path>.+?)'                   # then the rest of the path, allowing colons
+            r'(?:\.(?P<ext>[A-Za-z0-9]+(?:\.gz)?))?$'  # optional .json / .csv / .json.gz etc., at the very end
         )
 
         # we don't use framework token parsing (except for params) cuz too complicated

pjk/version.py

@@ -1,4 +1,4 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright 2024 Mike Schultz
 
-__version__ = "0.6.2"
+__version__ = "0.6.4"

{python_jack_knife-0.6.2.dist-info → python_jack_knife-0.6.4.dist-info}/METADATA

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

{python_jack_knife-0.6.2.dist-info → python_jack_knife-0.6.4.dist-info}/RECORD

@@ -1,19 +1,21 @@
 pjk/__init__.py,sha256=6HGDVcFOFv6VPSNjxVnusm9wHqy01pELX3AyCWFzqWg,128
 pjk/base.py,sha256=ObBsoTkfWp5qigr-QdNGZBs6tNH41P18kTnSMSJnntA,12775
-pjk/common.py,sha256=c2Y9TTS1Lz8KNGSaKqN3DMfb7fOGkndZon_d0V0iwm0,4914
+pjk/common.py,sha256=aYM9y-ANM1-_8ICa18etkP3wYNw0oSilZZwd5s7krME,4576
 pjk/log.py,sha256=LjBboWhUrr2Cz-ygpftCIK17ee2-zNHKZjeJyoW0PlA,2163
-pjk/main.py,sha256=fM2xuofSv_lzSBk4rD7ZCWvR1beRMgHiezL4rIBD0dE,3924
+pjk/main.py,sha256=xm33gbTxapj_hTu30BygMOOYhLwz_frXKaZyKKaCEl4,4150
 pjk/man_page.py,sha256=BNxRbzXfvR_5FoPkpCwxApyMsfSSrSdDu2PM-IVblA4,4447
 pjk/parser.py,sha256=2aZiW0SY9KPKb2h4xPasOhxehcxn_l_BEx2swmN_7_E,12673
 pjk/progress.py,sha256=scacaLRbSMBJEEEDeOTYt8sKwXP-CYEGoANG7IXVoQ4,9597
 pjk/registry.py,sha256=0_exY3sivaOHyRtf-v88OSugl2LGAbbFjyFS4cPbGO8,6864
-pjk/version.py,sha256=pUQpi34dOjfho08lZGT_KTgebMk9IucMzzRKSwCd6Bc,91
+pjk/version.py,sha256=smFKtPKnTVCimiTTlUrQYXoyxFS9F6JlapeUCyMHJpY,91
 pjk/integrations/ddb_sink.py,sha256=qFuh0ZkZ1oGrx576-226eu75sauGqa8BF_u-FLs4yW4,1704
-pjk/integrations/postgres_pipe.py,sha256=MZut7dikqbXr0XIrL31yrXM_0ZrgExD6suVA9jd_xmA,6192
-pjk/integrations/snowflake_pipe.py,sha256=z22E4KBfZHnAi6Bb8e9PXJwvwVYPeJjF02FI5o0rRus,8549
+pjk/integrations/opensearch_client.py,sha256=kpDISpLzGRA5maOf3JfdbOTVxpvSSe2gfzUrE1SVU4I,3250
+pjk/integrations/opensearch_query_pipe.py,sha256=JCb1s0amk7u-MeNXr1di8wY2UTKioHSJKDrthRQYzu0,3526
+pjk/integrations/postgres_pipe.py,sha256=z9xbxvwPg1T4bSln_5r57wWMildwe-gHdpf5Y_G6MmA,6178
+pjk/integrations/snowflake_pipe.py,sha256=JzcjxY4CbXHfVKsURD1ryZqgZfkDDfWJN_AjRcOtFms,8007
 pjk/pipes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pjk/pipes/denorm.py,sha256=tL8v3lTDCZPXDlffrx71PIojC_JWjN3PCJriNP6mw0o,2235
-pjk/pipes/factory.py,sha256=rwCWneXB1gosk9I24yr1Z0RDUYHrjHx8swFLrDR1k44,2119
+pjk/pipes/factory.py,sha256=pfdca16CKGfaPE-pqxW651KGmJRinyYqBeOI29y5ptQ,2231
 pjk/pipes/filter.py,sha256=Fo5-MJaNAfTabRZxw9fQ1n4amhgUUCncC_GoOWswdRw,2053
 pjk/pipes/head.py,sha256=5ZAacwzpVWuR_xWCnlHqyJUwbxfEcF8vIogdKIJBTRs,903
 pjk/pipes/join.py,sha256=zE9JrrGnOjDB7OuBT2_FxleptFfbBJJLdFak9FbsOjc,3149
@@ -21,7 +23,7 @@ pjk/pipes/let_reduce.py,sha256=QfCs-omZq-a2hMFr5Nnt1hhQuiXol0IMA2diXwesVUA,7153
 pjk/pipes/map.py,sha256=mOBKjx-AHDmOa3mBMnFfb-PYqFbKnqGVjBj3hx2fcys,5107
 pjk/pipes/move_field.py,sha256=ZgJZZSD7irWVnOdHyhNUq9Mw3oLuGVUr1WKjdjBbwgo,1142
 pjk/pipes/progress_pipe.py,sha256=GfnQFmeAOyeSHl69TXNWWz7sBd6MVpzDvYH2mZBp1Hg,1239
-pjk/pipes/query_pipe.py,sha256=nGcQh0qOcHHzCyVcwfrac5HmT9pPzyGlk--zJtmxVnc,2970
+pjk/pipes/query_pipe.py,sha256=X6hSK-HSPfeUvVa-dNxjQSm0Jfz0aqCQmD4kRtv5mKw,2647
 pjk/pipes/remove_field.py,sha256=QjEO6-phRngM2emBJ6xv8UA2d_iA44tYN8Crx4lhqQ0,1169
 pjk/pipes/sample.py,sha256=_YezoC3hZbG0qpkg9C6AuHLjuWseeAqsYYOXXAMvbOQ,2269
 pjk/pipes/select.py,sha256=OuVAk8x7rCkb0neroBmUUuovxHc-z2q7VaUNNWrEdZY,1331
@@ -53,7 +55,7 @@ pjk/sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pjk/sources/csv_source.py,sha256=Qlk3wB99jQPNIR4yRWmvrpCvGBsc8qcVxjVmtMYPlc0,702
 pjk/sources/dir_source.py,sha256=V8kVrzwSXyAk3bfwCAQA5dzgEFE3HKIuXAdiP_eP7Ls,2474
 pjk/sources/factory.py,sha256=J_cltOaKSE1uAJOyXWzNeoWNqBH2rsLQ2iGApccSUn0,1732
-pjk/sources/format_source.py,sha256=OFLK7lCQN_DckB99FhG_10as1oAy8iCCMWyZ1ArC9P0,4740
+pjk/sources/format_source.py,sha256=Yae2G4sSsKdmFPbxRz68yIPJwxlHBMKojQYUxjradC4,4802
 pjk/sources/inline_source.py,sha256=iskdhxoJ6uzzBZpy-1N2fH0UyJuSATMw7soE_ZRz1Yg,1703
 pjk/sources/json_source.py,sha256=83YG4dsnBErqbp72I3D-_7acJMo6h-H-vQd_PviJxmc,1061
 pjk/sources/lazy_file.py,sha256=fQYaQz7bytG9vY4JNtIQJxfHWFowCn5il51H7vQrTNg,400
@@ -66,9 +68,9 @@ pjk/sources/source_list.py,sha256=5L2vFrtVSl9rKf2NjfpUFOOAb-iypVDKYCw1-3xgcEo,64
 pjk/sources/sql_source.py,sha256=2CpOuikd2BVmMW_UbhVGPfXUf3BJmOcK5yMtmbTMYvw,743
 pjk/sources/tsv_source.py,sha256=37nhEblCZ8XeTNHVo-WcdJ8HbIbiwKgsDES_yzz6EdU,306
 pjk/sources/user_source_factory.py,sha256=0XIz6NkiBhGAteGDP8cNy7MALWsUF3smtLj4Qnj41Q8,1326
-python_jack_knife-0.6.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-python_jack_knife-0.6.2.dist-info/METADATA,sha256=6GiGT2ccWGYUKbaGPIQXPMSKJsHfM7_K8xatC6eGn1w,14641
-python_jack_knife-0.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_jack_knife-0.6.2.dist-info/entry_points.txt,sha256=kzZ10zEisvEaG2xYqqw7xRpuV62rAO_dPEHnM6USelk,38
-python_jack_knife-0.6.2.dist-info/top_level.txt,sha256=r-Ef_I9SbVDL9jD-W0WtshstLos_7guWbpItYxxSllQ,4
-python_jack_knife-0.6.2.dist-info/RECORD,,
+python_jack_knife-0.6.4.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+python_jack_knife-0.6.4.dist-info/METADATA,sha256=x9zWQRClA3ZHnR6ycsh440aCmRn-igSh0XGZG4Xti8I,14641
+python_jack_knife-0.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_jack_knife-0.6.4.dist-info/entry_points.txt,sha256=kzZ10zEisvEaG2xYqqw7xRpuV62rAO_dPEHnM6USelk,38
+python_jack_knife-0.6.4.dist-info/top_level.txt,sha256=r-Ef_I9SbVDL9jD-W0WtshstLos_7guWbpItYxxSllQ,4
+python_jack_knife-0.6.4.dist-info/RECORD,,