olca 0.2.59__tar.gz → 0.2.61__tar.gz

{olca-0.2.59 → olca-0.2.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: olca
-Version: 0.2.59
+Version: 0.2.61
 Summary: A Python package for experimental usage of Langchain and Human-in-the-Loop
 Home-page: https://github.com/jgwill/olca
 Author: Jean GUillaume ISabelle
@@ -361,11 +361,13 @@ Requires-Dist: requests
 Requires-Dist: markdown
 Requires-Dist: langchain
 Requires-Dist: langchain-openai
+Requires-Dist: langchain-ollama
 Requires-Dist: langchain-experimental
 Requires-Dist: click
 Requires-Dist: langgraph
 Requires-Dist: langfuse
 Requires-Dist: pytz
+Requires-Dist: google.generativeai
 
 # oLCa
 

{olca-0.2.59 → olca-0.2.61}/olca/fusewill_cli.py

@@ -14,7 +14,9 @@ from fusewill_utils import (
     open_trace_in_browser,
     print_traces,
     print_trace,
-    list_traces_by_score  # Ensure the updated function is imported
+    list_traces_by_score,  # Ensure the updated function is imported
+    export_traces,
+    import_traces
 )
 import dotenv
 import json
@@ -106,6 +108,49 @@ def main():
     parser_search.add_argument('-L', '--limit', type=int, default=100, help='Number of traces to fetch')
     parser_search.add_argument('-o', '--output', type=str, help='Output JSON file path')
 
+    # export_traces command
+    parser_export = subparsers.add_parser('export_traces', help='Export traces', aliases=['et'])
+    parser_export.add_argument('--format', choices=['json','csv'], default='json', help='Export format')
+    parser_export.add_argument('-o','--output', type=str, help='Output file path')
+    parser_export.add_argument('--start_date', type=str, help='Start date in ISO format (e.g., 2024-01-01)')
+    parser_export.add_argument('--end_date', type=str, help='End date in ISO format (e.g., 2024-12-31)')
+
+    # import_traces command
+    parser_import = subparsers.add_parser('import_traces', help='Import traces', aliases=['it'])
+    parser_import.add_argument('--format', choices=['json','csv'], default='json', help='Import format')
+    parser_import.add_argument('--input', type=str, required=True, help='Input file path to read from')
+
+    # list_sessions command
+    parser_list_sessions = subparsers.add_parser('list_sessions', help='List sessions', aliases=['lss'])
+    parser_list_sessions.add_argument('-L','--limit', type=int, default=100, help='Number of sessions to fetch')
+    parser_list_sessions.add_argument('--start_date', type=str, help='Start date in ISO format (e.g., 2024-01-01)')
+    parser_list_sessions.add_argument('--end_date', type=str, help='End date in ISO format (e.g., 2024-12-31)')
+    parser_list_sessions.add_argument('--format', choices=['json','csv'], default='json', help='Output format (json or csv)')
+    parser_list_sessions.add_argument('-o','--output', type=str, help='Optional output file path')
+
+    # get_session command
+    parser_get_session = subparsers.add_parser('get_session', help='Get a session by ID', aliases=['gsess'])
+    parser_get_session.add_argument('session_id', help='Session ID')
+    parser_get_session.add_argument('-o','--output', type=str, help='Output file path (JSON or CSV)')
+
+    # get_media command
+    parser_get_media = subparsers.add_parser('get_media', help='Retrieve media details')
+    parser_get_media.add_argument('media_id', help='Media ID')
+
+    # get_upload_url command
+    parser_upload_url = subparsers.add_parser('get_upload_url', help='Get a presigned upload URL')
+    parser_upload_url.add_argument('trace_id', help='Trace ID')
+    parser_upload_url.add_argument('--content_type', required=True, help='Content-Type of the media')
+    parser_upload_url.add_argument('--content_length', type=int, required=True, help='Size of the media in bytes')
+
+    # get_daily_metrics command
+    parser_daily_metrics = subparsers.add_parser('get_daily_metrics', help='Fetch daily metrics', aliases=['gdm'])
+    parser_daily_metrics.add_argument('--trace_name', type=str, help='Optional trace name filter')
+    parser_daily_metrics.add_argument('--user_id', type=str, help='Optional user ID filter')
+    parser_daily_metrics.add_argument('--tags', nargs='*', help='Optional tags for filtering')
+    parser_daily_metrics.add_argument('--from_timestamp', type=str, help='Start date in ISO format')
+    parser_daily_metrics.add_argument('--to_timestamp', type=str, help='End date in ISO format')
+
     args = parser.parse_args()
 
     if args.command == 'list_traces' or args.command == 'lt':
@@ -219,6 +264,79 @@ def main():
                     fu.print_trace(trace)
         else:
             print("No traces found matching the criteria.")
+    elif args.command == 'export_traces' or args.command == 'et':
+        output_path = args.output
+        if output_path:
+            if not output_path.endswith(f".{args.format}"):
+                output_path += f".{args.format}"
+        fu.export_traces(format=args.format, output_path=output_path, start_date=args.start_date, end_date=args.end_date)
+    elif args.command == 'import_traces' or args.command == 'it':
+        fu.import_traces(format=args.format, input_path=args.input)
+    elif args.command == 'list_sessions' or args.command == 'lss':
+        sessions = fu.list_sessions(
+            limit=args.limit,
+            start_date=args.start_date,
+            end_date=args.end_date
+        )
+
+        if not sessions:
+            print("No sessions found.")
+        else:
+            if not args.output:
+                # Print to standard output
+                for s in sessions:
+                    print(s)
+            else:
+                # Ensure output file extension matches --format
+                output_path = args.output
+                if not output_path.endswith(f".{args.format}"):
+                    output_path += f".{args.format}"
+
+                if args.format == 'csv':
+                    import csv
+                    with open(output_path, 'w', newline='') as f:
+                        writer = csv.DictWriter(f, fieldnames=sessions[0].keys())
+                        writer.writeheader()
+                        for s in sessions:
+                            writer.writerow(s)
+                else:  # default to JSON
+                    import json
+                    with open(output_path, 'w') as f:
+                        json.dump(sessions, f, indent=2)
+
+                print(f"Sessions written to {os.path.realpath(output_path)}")
+    elif args.command == 'get_session' or args.command == 'gsess':
+        session = fu.get_session(args.session_id)
+        if session:
+            if args.output:
+                if args.output.endswith('.csv'):
+                    import csv
+                    with open(args.output, 'w', newline='') as f:
+                        writer = csv.DictWriter(f, fieldnames=session.keys())
+                        writer.writeheader()
+                        writer.writerow(session)
+                    print(f"Session written to {os.path.realpath(args.output)}")
+                else:
+                    import json
+                    with open(args.output, 'w') as f:
+                        json.dump(session, f, indent=2)
+                    print(f"Session written to {os.path.realpath(args.output)}")
+            else:
+                print(session)
+        else:
+            print(f"No session found for ID {args.session_id}")
+    elif args.command == 'get_media':
+        fu.get_media(args.media_id)
+    elif args.command == 'get_upload_url':
+        fu.get_upload_url(args.trace_id, args.content_type, args.content_length)
+    elif args.command == 'get_daily_metrics' or args.command == 'gdm':
+        fu.get_daily_metrics(
+            trace_name=args.trace_name,
+            user_id=args.user_id,
+            tags=args.tags,
+            from_timestamp=args.from_timestamp,
+            to_timestamp=args.to_timestamp
+        )
     else:
         parser.print_help()
         exit(1)

{olca-0.2.59 → olca-0.2.61}/olca/fusewill_utils.py

@@ -8,11 +8,11 @@ import datetime  # Add this import
 import pytz      # Add this import
 
 # Load .env from the current working directory
-dotenv.load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
+dotenv.load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"), override=True)
 
 # Try loading from home directory if variables are still not set
 if not os.environ.get("LANGFUSE_PUBLIC_KEY") or not os.environ.get("LANGFUSE_SECRET_KEY") or not os.environ.get("LANGFUSE_HOST"):
-    dotenv.load_dotenv(dotenv_path=os.path.expanduser("~/.env"))
+    dotenv.load_dotenv(dotenv_path=os.path.expanduser("~/.env"), override=True)
 
 # Final check before exiting
 missing_vars = []
@@ -33,7 +33,6 @@ import sys
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
 import json
 
-import dotenv
 _DEBUG_=False
 if _DEBUG_:
     print(os.environ.get("LANGFUSE_PUBLIC_KEY"))
@@ -43,7 +42,8 @@ if _DEBUG_:
 langfuse = Langfuse(
     public_key=os.environ.get("LANGFUSE_PUBLIC_KEY"),
     secret_key=os.environ.get("LANGFUSE_SECRET_KEY"),
-    host=os.environ.get("LANGFUSE_HOST")
+    host=os.environ.get("LANGFUSE_HOST"),
+    release=os.environ.get("LANGFUSE_RELEASE", None)
 )
     
 def open_trace_in_browser(trace_id):
@@ -241,4 +241,177 @@ def search_traces(
         return filtered_traces
     except Exception as e:
         print(f"Error searching traces: {e}")
-        return []
+        return []
+
+def fetch_all_traces(start_date=None, end_date=None):
+    all_traces = []
+    page = 1
+    chunk_size = 100
+    params = {}
+    if start_date:
+        params['from_timestamp'] = datetime.datetime.fromisoformat(start_date).replace(tzinfo=pytz.UTC)
+    if end_date:
+        params['to_timestamp'] = datetime.datetime.fromisoformat(end_date).replace(tzinfo=pytz.UTC)
+    
+    while True:
+        partial = langfuse.get_traces(limit=chunk_size, page=page, **params)
+        if not partial or not partial.data:
+            break
+        all_traces.extend(partial.data)
+        if len(partial.data) < chunk_size:
+            break
+        page += 1
+    return all_traces
+
+def export_traces(format='json', output_path=None, start_date=None, end_date=None):
+    """
+    Export traces to a given format (json or csv).
+    """
+    try:
+        all_traces = fetch_all_traces(start_date=start_date, end_date=end_date)
+        if not output_path:
+            output_path = f"./traces_export.{format}"
+
+        # Ensure the output directory exists
+        output_dir = os.path.dirname(output_path)
+        if output_dir and not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        if format == 'json':
+            with open(output_path, 'w') as f:
+                json.dump([t.__dict__ for t in all_traces], f, indent=2, default=str)
+        elif format == 'csv':
+            import csv
+            fieldnames = ['id', 'name', 'input', 'output', 'createdAt']
+            with open(output_path, 'w', newline='') as f:
+                writer = csv.DictWriter(f, fieldnames=fieldnames)
+                writer.writeheader()
+                for t in all_traces:
+                    writer.writerow({
+                        'id': t.id,
+                        'name': t.name,
+                        'input': t.input,
+                        'output': t.output,
+                        'createdAt': str(t.createdAt)
+                    })
+
+        if all_traces:
+            # Sort traces by createdAt to ensure the oldest date is first
+            all_traces.sort(key=lambda x: x.createdAt)
+            first_trace_date = datetime.datetime.fromisoformat(all_traces[0].createdAt.replace('Z', '+00:00')).strftime('%Y-%m-%d %H:%M:%S')
+            last_trace_date = datetime.datetime.fromisoformat(all_traces[-1].CreatedAt.replace('Z', '+00:00')).strftime('%Y-%m-%d %H:%M:%S')
+            print(f"Traces exported to {output_path}. Total traces exported: {len(all_traces)}")
+            print(f"Date range: {first_trace_date} to {last_trace_date}")
+        else:
+            print(f"Traces exported to {output_path}. Total traces exported: {len(all_traces)}")
+    except Exception as e:
+        print(f"Error exporting traces: {e}")
+
+def import_traces(format='json', input_path=None):
+    """
+    Import traces from a given file (json or csv) into Langfuse.
+    """
+    if not input_path:
+        print("No input file provided for importing traces.")
+        return
+
+    try:
+        if format == 'json':
+            with open(input_path, 'r') as f:
+                data = json.load(f)
+        elif format == 'csv':
+            import csv
+            data = []
+            with open(input_path, 'r', newline='') as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    data.append(row)
+
+        # Create new traces in Langfuse from data
+        for item in data:
+            langfuse.create_trace(
+                name=item.get('name', 'Imported Trace'),
+                input=item.get('input', ''),
+                output=item.get('output', '')
+                # pass other fields as needed
+            )
+        print(f"Imported {len(data)} traces from {input_path}")
+    except Exception as e:
+        print(f"Error importing traces: {e}")
+
+def list_sessions(limit=100, start_date=None, end_date=None):
+    """
+    List all sessions with optional date filtering.
+    Retrieves multiple pages so we don't miss older sessions.
+    """
+    base_url = os.environ.get("LANGFUSE_HOST")
+    public_key = os.environ.get("LANGFUSE_PUBLIC_KEY")
+    secret_key = os.environ.get("LANGFUSE_SECRET_KEY")
+    url = f"{base_url}/api/public/sessions"
+    sessions = []
+    page = 1
+    while True:
+        params = {
+            "page": page,
+            "limit": limit
+        }
+        if start_date:
+            params["fromTimestamp"] = datetime.datetime.fromisoformat(start_date).isoformat() + 'Z'
+        if end_date:
+            params["toTimestamp"] = datetime.datetime.fromisoformat(end_date).isoformat() + 'Z'
+        
+        try:
+            response = requests.get(url, auth=(public_key, secret_key), params=params)
+            response.raise_for_status()
+            data = response.json()
+        except Exception as e:
+            print(f"Error retrieving sessions: {e}")
+            break
+        
+        if "data" not in data or len(data["data"]) == 0:
+            break
+        
+        sessions.extend(data["data"])
+        if len(data["data"]) < limit:
+            break
+        page += 1
+    
+    return sessions
+
+def get_session(session_id):
+    """
+    Get details of a specific session including its traces.
+    """
+    base_url = os.environ.get("LANGFUSE_HOST")
+    public_key = os.environ.get("LANGFUSE_PUBLIC_KEY")
+    secret_key = os.environ.get("LANGFUSE_SECRET_KEY")
+    url = f"{base_url}/api/public/sessions/{session_id}"
+
+    try:
+        response = requests.get(url, auth=(public_key, secret_key))
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        print(f"Error retrieving session {session_id}: {e}")
+        return None
+
+def get_upload_url(trace_id, content_type, content_length):
+    """
+    Get a presigned URL for media upload.
+    """
+    # TODO: Implement API call to POST /media
+    pass
+
+def get_media(media_id):
+    """
+    Retrieve media record details.
+    """
+    # TODO: Implement API call to GET /media/{mediaId}
+    pass
+
+def get_daily_metrics(trace_name=None, user_id=None, tags=None, from_timestamp=None, to_timestamp=None):
+    """
+    Get daily metrics with optional filtering.
+    """
+    # TODO: Implement API call to GET /metrics/daily with query params
+    pass

{olca-0.2.59 → olca-0.2.61}/olca/olcacli.py

@@ -1,6 +1,7 @@
 #%%
 import os
-from click import prompt
+import sys
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
 import dotenv
 from langchain import hub
 import argparse
@@ -153,6 +154,18 @@ def _parse_args():
     parser.add_argument("-y", "--yes", action="store_true", help="Accept the new file olca.yml")
     return parser.parse_args()
 
+def parse_model_uri(uri: str):
+    # Example: "ollama://llama2@localhost"
+    if "://" not in uri:
+        return "openai", uri, None  # default provider is openai
+    provider, rest = uri.split("://", 1)
+    host = None
+    if "@" in rest:
+        base_model, host = rest.split("@", 1)
+    else:
+        base_model = rest
+    return provider, base_model, host
+
 def main():
     args = _parse_args()
     olca_config_file = 'olca.yml'
@@ -217,20 +230,33 @@ def main():
     system_instructions = config.get('system_instructions', '')
     user_input = config.get('user_input', '')
     default_model_id = "gpt-4o-mini"
-    model_name = config.get('model_name', default_model_id)
     recursion_limit = config.get('recursion_limit', 15)
     disable_system_append = _parse_args().disable_system_append
-    
     # Use the system_instructions and user_input in your CLI logic
+    model_name = config.get('model_name', default_model_id)
+    provider, base_model, host = parse_model_uri(model_name)
+    
+    if provider == "ollama":
+        from langchain_ollama import OllamaLLM
+        model = OllamaLLM(model=base_model, base_url=host if host else None)
+    elif provider == "openai":
+        from langchain_openai import ChatOpenAI
+        model = ChatOpenAI(model=base_model, temperature=0)
+    else:
+        # default fallback
+        from langchain_openai import ChatOpenAI
+        model = ChatOpenAI(model=model_name, temperature=0)
+
     print("System Instructions:", system_instructions)
     print("User Input:", user_input)
-    print("Model Name:", model_name)
     print("Recursion Limit:", recursion_limit)
     print("Trace:", tracing_enabled)
+    print("Model Name:", model_name)
     
-    model = ChatOpenAI(model=model_name, temperature=0)
     selected_tools = ["terminal"]
     
+    disable_system_append = _parse_args().disable_system_append
+    
     human_switch = args.human
     #look in olca_config.yaml for human: true
     if "human" in config:
@@ -240,6 +266,7 @@ def main():
         selected_tools.append("human")
     
     if args.math:
+        from langchain_openai import OpenAI
         math_llm = OpenAI()
         selected_tools.append("llm-math")
         if human_switch:

{olca-0.2.59 → olca-0.2.61}/olca/prompts.py

@@ -1,5 +1,8 @@
 # Create a new file "prompts.py" to store the prompt-related constants.
 
+
+#@STCGoal https://smith.langchain.com/hub/jgwill/olca_system_append
+SYSTEM_PROMPT_APPEND_hub_tag_name="jgwill/olca_system_append"
 SYSTEM_PROMPT_APPEND = """
 You do what is above and consider the following when doing the task:
 ---
@@ -22,6 +25,8 @@ You do what is above and consider the following when doing the task:
 REMEMBER: Dont introduce nor conclude, just output results. No comments. you  present in a coherent format without preambles or fluff. Never use the word "determination" and we never brainstorm (we conceptualize the result we want in the germination phase then transform it into vision by choice and work as assimilating the vision to until the last phase which is completing our work).
 """
 
+#@STCGoal https://smith.langchain.com/hub/jgwill/olca_human_append
+HUMAN_APPEND_PROMPT_hub_tag_name="jgwill/olca_human_append"
 HUMAN_APPEND_PROMPT = """
 * Utilize the 'human' tool for interactions as directed.
 * Communicate clearly and simply, avoiding exaggeration.

{olca-0.2.59 → olca-0.2.61}/olca.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: olca
-Version: 0.2.59
+Version: 0.2.61
 Summary: A Python package for experimental usage of Langchain and Human-in-the-Loop
 Home-page: https://github.com/jgwill/olca
 Author: Jean GUillaume ISabelle
@@ -361,11 +361,13 @@ Requires-Dist: requests
 Requires-Dist: markdown
 Requires-Dist: langchain
 Requires-Dist: langchain-openai
+Requires-Dist: langchain-ollama
 Requires-Dist: langchain-experimental
 Requires-Dist: click
 Requires-Dist: langgraph
 Requires-Dist: langfuse
 Requires-Dist: pytz
+Requires-Dist: google.generativeai
 
 # oLCa
 

{olca-0.2.59 → olca-0.2.61}/olca.egg-info/requires.txt

@@ -8,8 +8,10 @@ requests
 markdown
 langchain
 langchain-openai
+langchain-ollama
 langchain-experimental
 click
 langgraph
 langfuse
 pytz
+google.generativeai

{olca-0.2.59 → olca-0.2.61}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "olca"
-version = "0.2.59"
+version = "0.2.61"
 
 description = "A Python package for experimental usage of Langchain and Human-in-the-Loop"
 readme = "README.md"
@@ -27,11 +27,13 @@ dependencies = [
     "markdown",
     "langchain",
     "langchain-openai",
+    "langchain-ollama",
     "langchain-experimental",
     "click",
     "langgraph",
     "langfuse",
     "pytz",
+    "google.generativeai",
 ]
 classifiers = [
     "Programming Language :: Python :: 3",

{olca-0.2.59 → olca-0.2.61}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='olca',
-    version = "0.2.59",
+    version = "0.2.61",
     author='Jean GUillaume ISabelle',
     author_email='jgi@jgwill.com',
     description='A Python package for experimenting with Langchain agent and interactivity in Terminal modalities.',