lam-cli 0.0.5__tar.gz → 0.0.7__tar.gz

{lam-cli-0.0.5/lam_cli.egg-info → lam_cli-0.0.7}/PKG-INFO

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

{lam-cli-0.0.5 → lam_cli-0.0.7}/README.md

@@ -72,4 +72,40 @@ Make sure to update the `requirements.txt` file when adding new dependencies.
 ```bash
 pip3 install <package>
 pip3 freeze > requirements.txt
-```
+```
+
+## Releases
+
+PyPI CI handles most stuff. Sometimes it'll push the test version to test PyPI which will cause the CI to "fail" but really we just need to make sure that the PyPI version on the proper distro site is correct [https://pypi.org/project/lam-cli/](https://pypi.org/project/lam-cli/).
+
+Before releasing make sure to update the package version in `setup.py`.
+
+```python
+setup(
+    name="lam-cli",
+    version="0.0.<x>",
+    ...
+)
+```
+
+Don't add the `-<increment>` to the version number in `setup.py`. This is added when creating a tag.
+
+You can release with:
+
+```bash
+git tag v<version>-<increment>
+
+# Example
+git tag v0.0.1-1
+```
+
+Then push the tag.
+
+```bash
+git push origin v<version>-<increment>
+
+# Example
+git push origin v0.0.1-1
+```
+
+The CI will handle the rest!

{lam-cli-0.0.5 → lam_cli-0.0.7}/lam/lam.py

@@ -9,52 +9,82 @@ import subprocess
 from datetime import datetime
 
 import click
+from logtail import LogtailHandler
+from posthog import Posthog
+
+posthog = Posthog(project_api_key='phc_wfeHFG0p5yZIdBpjVYy00o5x1HbEpggdMzIuFYgNPSK', host='https://app.posthog.com')
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+handler = LogtailHandler(source_token="TYz3WrrvC8ehYjXdAEGGyiDp")
+logger.addHandler(handler)
 
 jq_path = 'jq'
 
+def truncate_long_strings(data, max_length=1000, truncation_msg="... (truncated)"):
+    """
+    Truncate long strings in a JSON object if they exceed max_length.
+    Append a message to indicate truncation.
+    """
+    if isinstance(data, dict):
+        return {key: truncate_long_strings(value, max_length, truncation_msg) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [truncate_long_strings(item, max_length, truncation_msg) for item in data]
+    elif isinstance(data, str):
+        return data[:max_length] + truncation_msg if len(data) > max_length else data
+    return data
+
 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}")
+    logger.info(f"Event {event_name} triggered, with properties: {properties}")
 
-def parse_program(program):
-    logging.info(f"Parsing program: {program}")
+    try:
+        distinct_id = generate_distinct_id(workspace_id, flow_id)
+        posthog.capture(distinct_id=distinct_id, event=event_name, properties=properties)
+    except Exception as e:
+        logger.error(f"Error logging event: {e}")
 
-    split_by_lines = program.split('\n')
-    return ''.join(line for line in split_by_lines if line and not line.strip().startswith('#'))
+def parse_program_file(program_file):
+    logger.info(f"Parsing program file: {program_file}")
+    with open(program_file, 'r') as file:
+        return ''.join(line for line in file if not line.strip().startswith('#'))
 
 def run_jq(jq_script, input_data):
-    logging.info(f"Running jq script {jq_script} with input data {input_data}")
+    logger.info(f"Running jq script {jq_script} with input data {truncate_long_strings(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}")
+        logger.error(f"Error running jq: {error}")
     return output, error
 
-def process_input(input_json, workspace_id, flow_id):
-    logging.info(f"Processing input_json: {input_json}")
+def process_input(input, workspace_id, flow_id):
+    logger.info(f"Processing input: {truncate_long_strings(input)}")
+    if os.path.isfile(input):
+        with open(input, 'r') as file:
+            return file.read(), None
     try:
-        json.loads(input_json)
-        return input_json, None
+        json.loads(input)
+        return input, None
     except json.JSONDecodeError as e:
-        logging.error(f"Invalid JSON input: {e}")
+        logger.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}")
+    logger.info(f"Handling jq output: {truncate_long_strings(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.")
+        logger.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]
@@ -70,38 +100,39 @@ def lam():
     pass
 
 @lam.command()
-@click.argument('program', type=str)
-@click.argument('input_json', type=str)
+@click.argument('program_file', type=click.Path(exists=True))
+@click.argument('input', type=str)
 @click.option('--workspace_id', default="local", help="Workspace ID")
 @click.option('--flow_id', default="local", help="Flow ID")
+@click.option('--execution_id', default="local", help="Execution ID")
 @click.option('--as-json', is_flag=True, default=True, help="Output as JSON")
-def run(program, input_json, workspace_id, flow_id, as_json):
+def run(program_file, input, workspace_id, flow_id, execution_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"
+    log_file = f"lam_run_{workspace_id}_{flow_id}_{execution_id}_{timestamp}.log"
+    result_file = f"lam_result_{workspace_id}_{flow_id}_{execution_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')
+    file_handler = logging.FileHandler(log_file, 'w')
+    file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+    logger.addHandler(file_handler)
 
-    logging.info(f"Logging to {log_file}")
-    logging.info(f"Running command with program: {program}, input_json: {input_json}, workspace_id: {workspace_id}, flow_id: {flow_id}, as_json: {as_json}")
+    logger.info(f"Logging to {log_file}")
+    logger.info(f"Running command with program file: {program_file}, input: {truncate_long_strings(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")
+        logger.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_json, workspace_id, flow_id)
+    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(program)
-    track_event('lam.run.start', {'script': jq_script, 'as_json': as_json, 'workspace_id': workspace_id, 'flow_id': flow_id}, workspace_id, flow_id)
+    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)
 
     if jq_error:
@@ -120,7 +151,8 @@ def run(program, input_json, workspace_id, flow_id, as_json):
         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")
+    logger.info("Run complete, waiting for event logger to finish")
+    logger.removeHandler(file_handler)
 
 if __name__ == '__main__':
-    lam()
+    lam()

{lam-cli-0.0.5 → lam_cli-0.0.7/lam_cli.egg-info}/PKG-INFO

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

lam_cli-0.0.7/lam_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+click
+posthog
+logtail-python

{lam-cli-0.0.5 → lam_cli-0.0.7}/setup.py

@@ -2,11 +2,12 @@ from setuptools import find_packages, setup
 
 setup(
     name='lam-cli',
-    version='0.0.5',
+    version='0.0.7',
     packages=find_packages(),
     install_requires=[
         'click',
         'posthog',
+        'logtail-python',
     ],
     entry_points={
         'console_scripts': [

lam-cli-0.0.5/lam_cli.egg-info/requires.txt

@@ -1,2 +0,0 @@
-click
-posthog