olca 0.2.63__tar.gz → 0.2.64__tar.gz

{olca-0.2.63 → olca-0.2.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: olca
-Version: 0.2.63
+Version: 0.2.64
 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

{olca-0.2.63 → olca-0.2.64}/olca/fusewill_utils.py

@@ -123,7 +123,7 @@ def list_traces_by_score(score_name, min_value=None, max_value=None, limit=100):
     return filtered_traces
 
 def add_score_to_a_trace(trace_id, generation_id, name, value, data_type="NUMERIC", comment=""):
-    langfuse.score(
+    result_add_score_to_a_trace=langfuse.score(
         trace_id=trace_id,
         observation_id=generation_id,
         name=name,
@@ -131,11 +131,16 @@ def add_score_to_a_trace(trace_id, generation_id, name, value, data_type="NUMERI
         data_type=data_type,
         comment=comment
     )
+    return result_add_score_to_a_trace
 
 def create_score(name, data_type, description="", possible_values=None, min_value=None, max_value=None):
-    langfuse.score(
+    placeholder_value = ""
+    if data_type.upper() == "BOOLEAN":
+        placeholder_value = "1"
+
+    resulting_score = langfuse.score(
         name=name,
-        value="",  # Provide a placeholder value
+        value=placeholder_value,
         data_type=data_type,
         description=description,
         # For categorical:
@@ -143,11 +148,17 @@ def create_score(name, data_type, description="", possible_values=None, min_valu
         # For numeric:
         **({"min_value": min_value, "max_value": max_value} if data_type == "NUMERIC" and min_value is not None and max_value is not None else {})
     )
+    return resulting_score
 
 def score_exists(name):
-    scores = langfuse.get_scores()
-    for score in scores.data:
-        if score.name == name:
+    """
+    Check if a score with the given name exists by calling list_scores().
+    """
+    scores = list_scores()
+    if not scores or scores.get('meta', {}).get('totalItems', 0) == 0:
+        return False
+    for sc in scores:
+        if sc.get("name") == name:
             return True
     return False
 
@@ -265,7 +276,7 @@ def fetch_all_traces(start_date=None, end_date=None):
 
 def export_traces(format='json', output_path=None, start_date=None, end_date=None):
     """
-    Export traces to a given format (json or csv).
+    Export traces along with their full score details.
     """
     try:
         all_traces = fetch_all_traces(start_date=start_date, end_date=end_date)
@@ -277,9 +288,23 @@ def export_traces(format='json', output_path=None, start_date=None, end_date=Non
         if output_dir and not os.path.exists(output_dir):
             os.makedirs(output_dir)
 
+        all_scores=list_scores()
+        exported_data = []
+        for t in all_traces:
+            # fetch full score details
+            score_details = []
+            if t.scores:
+                for s_id in t.scores:
+                    s_detail = get_score_by_id(s_id)
+                    if s_detail:
+                        score_details.append(s_detail)
+            t_dict = t.__dict__
+            t_dict["score_details"] = score_details
+            exported_data.append(t_dict)
+
         if format == 'json':
             with open(output_path, 'w') as f:
-                json.dump([t.__dict__ for t in all_traces], f, indent=2, default=str)
+                json.dump(exported_data, f, indent=2, default=str)
         elif format == 'csv':
             import csv
             fieldnames = ['id', 'name', 'input', 'output', 'createdAt']
@@ -299,7 +324,7 @@ def export_traces(format='json', output_path=None, start_date=None, end_date=Non
             # 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')
+            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:
@@ -307,9 +332,29 @@ def export_traces(format='json', output_path=None, start_date=None, end_date=Non
     except Exception as e:
         print(f"Error exporting traces: {e}")
 
+def create_new_trace(name, input_text, output_text, session_id=None, metadata=None, timestamp=None):
+    """
+    Creates a new trace with an optional timestamp.
+    """
+    parsed_timestamp = None
+    if timestamp:
+        try:
+            parsed_timestamp = datetime.datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+        except ValueError:
+            pass
+    trace_created=langfuse.trace(
+        name=name,
+        input=input_text,
+        output=output_text,
+        session_id=session_id,
+        metadata=metadata,
+        timestamp=parsed_timestamp
+    )
+    return trace_created
+
 def import_traces(format='json', input_path=None):
     """
-    Import traces from a given file (json or csv) into Langfuse.
+    Import traces. If any score doesn't exist, create it and attach it to the trace.
     """
     if not input_path:
         print("No input file provided for importing traces.")
@@ -327,14 +372,51 @@ def import_traces(format='json', input_path=None):
                 for row in reader:
                     data.append(row)
 
+        if isinstance(data, dict):
+            data = [data]
+
         # Create new traces in Langfuse from data
         for item in data:
-            langfuse.create_trace(
+            trace_timestamp = item.get('timestamp') or item.get('createdAt')
+            new_trace = create_new_trace(
                 name=item.get('name', 'Imported Trace'),
-                input=item.get('input', ''),
-                output=item.get('output', '')
-                # pass other fields as needed
+                input_text=item.get('input', ''),
+                output_text=item.get('output', ''),
+                session_id=item.get('session_id'),
+                metadata=item.get('metadata'),
+                timestamp=trace_timestamp
             )
+            # handle imported scores
+            for s_detail in item.get("score_details", []):
+                score_name = s_detail["name"]
+                score_value = str(s_detail.get("value", "0"))
+                score_data_type = s_detail.get("dataType", "NUMERIC")
+                score_comment = s_detail.get("comment", "")
+                score_description = s_detail.get("description", "")
+                score_possible_values = s_detail.get("possible_values")
+                minimum_score_value = s_detail.get("min_value")
+                max_score_value = s_detail.get("max_value")
+                if not score_exists(score_name):
+                    resulting_score=create_score(
+                        name=score_name,
+                        data_type=score_data_type,
+                        description=score_description,
+                        possible_values=score_possible_values,
+                        min_value=minimum_score_value,
+                        max_value=max_score_value
+                        
+                    )
+                result_add_score_to_a_trace=add_score_to_a_trace(
+                    trace_id=new_trace.id,
+                    generation_id=None,  # Replace as needed if your data includes observation IDs
+                    name=score_name,
+                    value=score_value,
+                    data_type=score_data_type,
+                    comment=score_comment
+                )
+                print(f"Added score {score_name} to trace {new_trace.id}")
+                print(result_add_score_to_a_trace)
+                
         print(f"Imported {len(data)} traces from {input_path}")
     except Exception as e:
         print(f"Error importing traces: {e}")

olca-0.2.64/olca/oiv.py

@@ -0,0 +1,145 @@
+#!/bin/env python
+#@STCGoal Create an agent callable with command line
+#@STCIssue The original script was not callable from the command line.
+
+from langchain import hub
+from langchain.agents import AgentExecutor, create_react_agent
+from langchain_community.agent_toolkits.load_tools import load_tools
+from langchain_openai import ChatOpenAI
+import argparse
+import os
+import json
+import tlid
+import warnings
+
+warnings.filterwarnings("ignore", message="The function `loads` is in beta. It is actively being worked on, so the API may change.")
+DEBUG_MODE=False
+
+prompt=None
+def _create_agent_tools(tool_name = "arxiv",temperature = 0.0,tool_hub_tag = "jgwill/react",chatbot_model = "gpt-4o-mini"):
+    global prompt
+    
+    llm = ChatOpenAI(temperature=temperature,name=chatbot_model)
+    
+    tools = load_tools(
+        [tool_name],
+        )
+    if DEBUG_MODE:
+          
+      print("Tools:")
+      print(tools)
+      print("--------------")
+    prompt = hub.pull(tool_hub_tag)
+    
+    if DEBUG_MODE:
+      print("prompt:")
+      print(prompt)
+      print("--------------")
+
+    agent = create_react_agent(llm, tools, prompt)
+    
+    if DEBUG_MODE:
+      print("Agent:")
+      print(agent)
+      print("--------------")
+    return tools,agent
+
+
+def create_agent_executor(tools, agent) -> AgentExecutor:
+    return AgentExecutor(agent=agent, tools=tools, verbose=True,handle_parsing_errors=True)
+   
+
+
+
+# tools, agent=_create_agent_tools()
+
+# agent_executor=create_agent_executor(tools, agent)
+def ask_agent(input_request, agent_executor=None,tool_hub_tag = "jgwill/react",chatbot_model = "gpt-4o-mini"):
+  if agent_executor is None:
+    tools, agent = _create_agent_tools(tool_hub_tag=tool_hub_tag)
+    agent_executor = create_agent_executor(tools, agent)
+  
+  resp = agent_executor.invoke(
+    {
+      "input": input_request,
+    }
+  )
+  
+  return resp
+
+def serialize_response_to_json(resp):
+    return json.dumps(resp)
+
+def serialize_response_to_json_file(resp, filename):
+  json_str=serialize_response_to_json(resp)
+  with open(filename, 'w') as f:
+    f.write(json_str)
+    
+def serialize_response_to_markdown(o):
+    output=o["output"]["output"]
+    string_md="# Output\n"
+    #string_md+=f"## Model\n{o['model']}\n"
+    #string_md+=f"## Prompt\n{o['prompt']['prompt']}\n"
+    string_md+=f"## Input\n{o['input']}\n"
+    string_md+=f"## Output\n{output}\n"
+    return string_md
+
+def serialize_response_to_markdown_file(o, filename):
+    string_md=serialize_response_to_markdown(o)
+    with open(filename, 'w') as f:
+        f.write(string_md)
+
+
+def main():
+    global prompt
+    args = parse_cli_arguments()
+
+    input_request = args.input
+    tool_hub_tag = "jgwill/react" if args.hub_tag is None else args.hub_tag
+    resp = ask_agent(input_request,tool_hub_tag=tool_hub_tag,chatbot_model=args.chatbot_model)
+    outdir=os.path.join(os.getcwd(),"output")
+    os.makedirs(outdir, exist_ok=True)
+    out_filename = f"{args.prefix}output-{tlid.get_minutes()}.json"
+    outfile=os.path.join(outdir,out_filename)
+    o={}
+    prompt_dict = {
+        "prompt": str(prompt)
+    }
+    o["model"]=args.chatbot_model
+    o["prompt"]=prompt_dict
+    o["input"]=input_request
+    o["output"]=resp
+    serialize_response_to_json_file(o, outfile)
+    serialize_response_to_markdown_file(o, outfile.replace(".json",".md"))
+    VERBOSE_RESULT=False
+    if VERBOSE_RESULT:
+        print("==================================")
+        print(input_request)
+        print("============RESPONSE============")
+        print(resp)
+        print("==================================")
+        print("=============INPUT Request=====================")
+        print(input_request)
+        print("==================================")
+        print("============OUTPUT============")
+    output=resp["output"]
+    print(output)
+
+def parse_cli_arguments():
+    parser = argparse.ArgumentParser(description='Process Input request for pattern search.')
+    parser.add_argument('-I','--input', type=str,
+                        help='an input request for the searched article')
+    ##--hub_tag
+    parser.add_argument('-H','-ht','--hub_tag', type=str,
+                        help='The hub tag for the process',default="jgwill/react")
+    #--chatbot_model
+    parser.add_argument('-M','-m','--chatbot_model', type=str,
+                        help='a chatbot model for the processing',default="gpt-4o-mini")
+    #--prefix
+    parser.add_argument('-P','-p','--prefix', type=str,
+                        help='a file prefix for output',default="arxiv-")
+    args = parser.parse_args()
+    return args
+
+if __name__ == "__main__":
+    main()

{olca-0.2.63 → olca-0.2.64}/olca.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: olca
-Version: 0.2.63
+Version: 0.2.64
 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

{olca-0.2.63 → olca-0.2.64}/olca.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ setup.py
 olca/__init__.py
 olca/fusewill_cli.py
 olca/fusewill_utils.py
+olca/oiv.py
 olca/olcacli.py
 olca/olcahelper.py
 olca/prompts.py

{olca-0.2.63 → olca-0.2.64}/olca.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
 fusewill = olca.fusewill_cli:main
+oiv = olca.oiv:main
 olca = olca.olcacli:main
 olca2 = olca.olcacli:main

{olca-0.2.63 → olca-0.2.64}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "olca"
-version = "0.2.63"
+version = "0.2.64"
 
 description = "A Python package for experimental usage of Langchain and Human-in-the-Loop"
 readme = "README.md"
@@ -45,3 +45,5 @@ classifiers = [
 olca2 = "olca.olcacli:main"
 olca = "olca.olcacli:main"
 fusewill = "olca.fusewill_cli:main"
+oiv = "olca.oiv:main"
+

{olca-0.2.63 → olca-0.2.64}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='olca',
-    version = "0.2.63",
+    version = "0.2.64",
     author='Jean GUillaume ISabelle',
     author_email='jgi@jgwill.com',
     description='A Python package for experimenting with Langchain agent and interactivity in Terminal modalities.',
@@ -31,7 +31,8 @@ setup(
         'langchain-ollama',
         'langgraph',
         'llm',
-        'langgraph'
+        'langgraph',
+        'arxiv',
     ],
     entry_points={
         'console_scripts': [