lam-cli 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

lam/lam.py

@@ -1,71 +1,145 @@
 #!/usr/bin/env python3
 
 import json
+import logging
 import os
 import shutil
+import socket
 import subprocess
+import threading
+from datetime import datetime
+from queue import Queue
 
 import click
+from posthog import Posthog
+
+posthog = Posthog(project_api_key='phc_wfeHFG0p5yZIdBpjVYy00o5x1HbEpggdMzIuFYgNPSK', host='https://app.posthog.com')
 
-# Path to the jq binary
 jq_path = 'jq'
+event_queue = Queue()
 
-@click.group()
-def lam():
-    """
-    lam: Laminar data transformation tool, built on jq.
-    """
-    pass
+def generate_distinct_id(workspace_id, flow_id):
+    user_id = os.getuid()
+    hostname = socket.gethostname()
+    return f"{user_id}_{hostname}_{workspace_id}_{flow_id}"
+
+def track_event(event_name, properties, workspace_id="local", flow_id="local"):
+    logging.info(f"Event {event_name} triggered, with properties: {properties}")
+    event_queue.put((event_name, properties, workspace_id, flow_id))
+
+def event_logger():
+    while True:
+        event_name, properties, workspace_id, flow_id = event_queue.get()
+        try:
+            distinct_id = generate_distinct_id(workspace_id, flow_id)
+            posthog.capture(distinct_id=distinct_id, event=event_name, properties=properties)
+        finally:
+            event_queue.task_done()
 
 def parse_program_file(program_file):
-    """
-    Parses the program file to extract raw jq script.
-    Removes comments and other non-jq content.
-    """
+    logging.info(f"Parsing program file: {program_file}")
     with open(program_file, 'r') as file:
-        lines = file.readlines()
-
-    return ''.join(line for line in lines if not line.strip().startswith('#'))
+        return ''.join(line for line in file if not line.strip().startswith('#'))
 
 def run_jq(jq_script, input_data):
-    """
-    Run the jq command with the given script and input data.
-    """
-    process = subprocess.Popen([jq_path, jq_script], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
+    logging.info(f"Running jq script {jq_script} with input data {input_data}")
+    process = subprocess.Popen([jq_path, '-c', jq_script], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
     output, error = process.communicate(input=input_data)
+    if error:
+        logging.error(f"Error running jq: {error}")
     return output, error
 
+def process_input(input, workspace_id, flow_id):
+    logging.info(f"Processing input: {input}")
+    if os.path.isfile(input):
+        with open(input, 'r') as file:
+            return file.read(), None
+    try:
+        json.loads(input)
+        return input, None
+    except json.JSONDecodeError as e:
+        logging.error(f"Invalid JSON input: {e}")
+        track_event('lam.run.error', {'error': f"Invalid JSON input: {e}", 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+        return None, str(e)
+
+def handle_jq_output(output, as_json, workspace_id, flow_id):
+    logging.info(f"Handling jq output: {output}")
+    try:
+        json_output = json.loads(output)
+        # Make sure the output has a top-level object
+        if not isinstance(json_output, dict):
+            track_event('lam.run.warn', {'error': 'Invalid JSON output', 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+            return {"lam.result": json_output} if as_json else output, None
+        return json_output if as_json else output, None
+    except json.JSONDecodeError as e:
+        logging.error("Failed to parse JSON output, may be multiple JSON objects. Attempting to parse as JSON lines.")
+        track_event('lam.run.warn', {'error': f"Invalid JSON output: {e}", 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+        if as_json:
+            json_objects = [json.loads(line) for line in output.strip().split('\n') if line]
+            return {"lam.concatenated": json_objects}, None
+        return output, "Failed to parse JSON output."
+
+def write_to_result_file(result, result_file):
+    with open(result_file, 'w') as file:
+        file.write(json.dumps(result, indent=4))
+
+@click.group()
+def lam():
+    pass
+
 @lam.command()
 @click.argument('program_file', type=click.Path(exists=True))
 @click.argument('input', type=str)
-def run(program_file, input):
-    """
-    Process input (file path or raw JSON string) with a jq program file.
-    """
-    if shutil.which("jq") is None:
-        click.echo("Error: jq is not installed. Please install jq to use this tool.", err=True)
-        raise SystemExit(1)
+@click.option('--workspace_id', default="local", help="Workspace ID")
+@click.option('--flow_id', default="local", help="Flow ID")
+@click.option('--as-json', is_flag=True, default=True, help="Output as JSON")
+def run(program_file, input, workspace_id, flow_id, as_json):
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    log_file = f"lam_run_{workspace_id}_{flow_id}_{timestamp}.log"
+    result_file = f"lam_result_{workspace_id}_{flow_id}_{timestamp}.json"
+
+    # Now configure logging with the determined log file name
+    logging.basicConfig(level=logging.INFO, filename=log_file, filemode='w',
+                        format='%(asctime)s - %(levelname)s - %(message)s')
+
+    logging.info(f"Logging to {log_file}")
+    logging.info(f"Running command with program file: {program_file}, input: {input}, workspace_id: {workspace_id}, flow_id: {flow_id}, as_json: {as_json}")
+    if not shutil.which("jq"):
+        logging.error("Unable to find jq, killing process")
+        click.echo({"lam.error": "jq is not installed"}, err=True)
+        track_event('lam.run.error', {'error': 'jq is not installed', 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+        write_to_result_file({"lam.error": "jq is not installed"}, result_file) 
+        return
+
+    input_data, error = process_input(input, workspace_id, flow_id)
+    if error:
+        click.echo({"lam.error": f"Invalid input: {error}"}, err=True)
+        track_event('lam.run.error', {'error': f"Invalid input: {error}", 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+        write_to_result_file({"lam.error": f"Invalid input: {error}"}, result_file)
+        return
 
     jq_script = parse_program_file(program_file)
+    track_event('lam.run.start', {'program_file': program_file, 'as_json': as_json, 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+    output, jq_error = run_jq(jq_script, input_data)
 
-    # Check if input is a file path or a raw JSON string
-    if os.path.isfile(input):
-        with open(input, 'r') as file:
-            input_data = file.read()
-    else:
-        try:
-            # Validate input as JSON
-            json.loads(input)
-            input_data = input
-        except json.JSONDecodeError:
-            click.echo("Invalid JSON input.", err=True)
-            return
-
-    output, error = run_jq(jq_script, input_data)
+    if jq_error:
+        click.echo({"lam.error": jq_error}, err=True)
+        track_event('lam.run.run_jq_error', {'error': jq_error, 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+        write_to_result_file({"lam.error": jq_error}, result_file)
+        return
+
+    result, error = handle_jq_output(output, as_json, workspace_id, flow_id)
     if error:
-        click.echo(f"Error in jq processing: {error}", err=True)
+        click.echo({"lam.error": error}, err=True)
+        track_event('lam.run.handle_jq_output_error', {'error': error, 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+        write_to_result_file({"lam.error": error}, result_file)
     else:
-        click.echo(output)
+        click.echo(json.dumps(result, indent=4) if as_json else result)
+        track_event('lam.run.success', {'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+        write_to_result_file(result, result_file)
+
+    logging.info("Run complete, waiting for event logger to finish")
 
 if __name__ == '__main__':
+    threading.Thread(target=event_logger, daemon=True).start()
     lam()

{lam_cli-0.0.2.dist-info → lam_cli-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lam-cli
-Version: 0.0.2
+Version: 0.0.3
 Summary: Laminar data transformation tool
 Home-page: https://github.com/laminar-run/lam
 Author: Laminar Run, Inc.
@@ -8,6 +8,7 @@ Author-email: connect@laminar.run
 License: GPLv3
 License-File: LICENSE
 Requires-Dist: click
+Requires-Dist: posthog
 
 
     Laminar is a platform that makes building and maintaining API integrations faster.

lam_cli-0.0.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+lam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lam/lam.py,sha256=xpOPerS3EMqh2Ugzy-kfqXlXJctoPY6aszdViTJmrS4,6645
+lam_cli-0.0.3.dist-info/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+lam_cli-0.0.3.dist-info/METADATA,sha256=dU8aX-e4nelxjOl70h7_ZkSUP3_DJDvLMpccsjThB6s,374
+lam_cli-0.0.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+lam_cli-0.0.3.dist-info/entry_points.txt,sha256=ph7QV6H2VWqf9fU5rtoAgEabDgZ4f85ZImdLXeBmdfA,36
+lam_cli-0.0.3.dist-info/top_level.txt,sha256=WyM7-Ig60qQH9meqS293pEd83jrMtbvGJM8ALZOQCtA,4
+lam_cli-0.0.3.dist-info/RECORD,,

lam_cli-0.0.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-lam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lam/lam.py,sha256=1MOeqSf8Z6Xo8EPkufRLyT7u1GNrXLU5CGnUf4dbSzI,1901
-lam_cli-0.0.2.dist-info/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-lam_cli-0.0.2.dist-info/METADATA,sha256=WmkdzdzkPOSum7UpzAidXuliK_VhUwMy0L7VeLLRreo,351
-lam_cli-0.0.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-lam_cli-0.0.2.dist-info/entry_points.txt,sha256=ph7QV6H2VWqf9fU5rtoAgEabDgZ4f85ZImdLXeBmdfA,36
-lam_cli-0.0.2.dist-info/top_level.txt,sha256=WyM7-Ig60qQH9meqS293pEd83jrMtbvGJM8ALZOQCtA,4
-lam_cli-0.0.2.dist-info/RECORD,,