weco 0.1.7__tar.gz → 0.1.9__tar.gz

{weco-0.1.7 → weco-0.1.9}/.github/workflows/release.yml

@@ -74,15 +74,12 @@ jobs:
         inputs: >-
           ./dist/*.tar.gz
           ./dist/*.whl
-    - name: Debug Print github.ref_name
-      run: >-
-        echo "github.ref_name: ${{ github.ref_name }}"
     - name: Create GitHub Release
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: >-
         gh release create
-        'v0.1.7'
+        'v0.1.9'
         --repo '${{ github.repository }}'
         --notes ""
     - name: Upload artifact signatures to GitHub Release
@@ -93,5 +90,5 @@ jobs:
       # sigstore-produced signatures and certificates.
       run: >-
         gh release upload
-        'v0.1.7' dist/**
+        'v0.1.9' dist/**
         --repo '${{ github.repository }}'

{weco-0.1.7 → weco-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: weco
-Version: 0.1.7
+Version: 0.1.9
 Summary: A client facing API for interacting with the WeCo AI function builder service.
 Author-email: WeCo AI Team <dhruv@weco.ai>
 License: MIT
@@ -52,12 +52,16 @@ pip install weco
 ```
 
 ## Features
+- Synchronous & Asynchronous client.
+- Batch API
+- Multimodality (Language & Vision)
+- Interpretability (view the reasoning behind outputs)
+
+
+## What We Offer
 
 - The **build** function enables quick and easy prototyping of new functions via LLMs through just natural language. We encourage users to do this through our [web console](https://weco-app.vercel.app/function) for maximum control and ease of use, however, you can also do this through our API as shown in [here](examples/cookbook.ipynb).
 - The **query** function allows you to test and use the newly created function in your own code.
-- We offer asynchronous versions of the above clients.
-- We provide a **batch_query** functions that allows users to batch functions for various inputs as well as multiple inputs for the same function in a query. This is helpful to make a large number of queries more efficiently.
-- We also offer multimodality capabilities. You can now query our client with both **language** AND **vision** inputs!
 
 We provide both services in two ways:
 - `weco.WecoAI` client to be used when you want to maintain the same client service across a portion of code. This is better for dense service usage.

{weco-0.1.7 → weco-0.1.9}/README.md

@@ -25,12 +25,16 @@ pip install weco
 ```
 
 ## Features
+- Synchronous & Asynchronous client.
+- Batch API
+- Multimodality (Language & Vision)
+- Interpretability (view the reasoning behind outputs)
+
+
+## What We Offer
 
 - The **build** function enables quick and easy prototyping of new functions via LLMs through just natural language. We encourage users to do this through our [web console](https://weco-app.vercel.app/function) for maximum control and ease of use, however, you can also do this through our API as shown in [here](examples/cookbook.ipynb).
 - The **query** function allows you to test and use the newly created function in your own code.
-- We offer asynchronous versions of the above clients.
-- We provide a **batch_query** functions that allows users to batch functions for various inputs as well as multiple inputs for the same function in a query. This is helpful to make a large number of queries more efficiently.
-- We also offer multimodality capabilities. You can now query our client with both **language** AND **vision** inputs!
 
 We provide both services in two ways:
 - `weco.WecoAI` client to be used when you want to maintain the same client service across a portion of code. This is better for dense service usage.

{weco-0.1.7 → weco-0.1.9}/examples/cookbook.ipynb

@@ -144,7 +144,7 @@
     "with open(\"/path/to/home_exterior.jpeg\", \"rb\") as img_file:\n",
     "    my_home_exterior = base64.b64encode(img_file.read()).decode('utf-8')\n",
     "\n",
-    "response = query(\n",
+    "query_response = query(\n",
     "    fn_name=fn_name,\n",
     "    text_input=request,\n",
     "    images_input=[\n",
@@ -154,7 +154,10 @@
     "    ]\n",
     ")\n",
     "\n",
-    "print(response)"
+    "for key, value in query_response[\"output\"].items(): print(f\"{key}: {value}\")\n",
+    "print(f\"Input Tokens: {query_response['in_tokens']}\")\n",
+    "print(f\"Output Tokens: {query_response['out_tokens']}\")\n",
+    "print(f\"Latency: {query_response['latency_ms']} ms\")"
    ]
   },
   {
@@ -214,7 +217,10 @@
     "    fn_name=fn_name,\n",
     "    text_input=\"I want to train a model to predict house prices using the Boston Housing dataset hosted on Kaggle.\"\n",
     ")\n",
-    "for key, value in query_response.items(): print(f\"{key}: {value}\")"
+    "for key, value in query_response[\"output\"].items(): print(f\"{key}: {value}\")\n",
+    "print(f\"Input Tokens: {query_response['in_tokens']}\")\n",
+    "print(f\"Output Tokens: {query_response['out_tokens']}\")\n",
+    "print(f\"Latency: {query_response['latency_ms']} ms\")"
    ]
   },
   {
@@ -274,7 +280,12 @@
     "query_responses = batch_query(\n",
     "    fn_names=fn_name,\n",
     "    batch_inputs=[input_1, input_2]\n",
-    ")"
+    ")\n",
+    "for i, query_response in enumerate(query_responses):\n",
+    "    print(\"-\"*50)\n",
+    "    print(f\"For input {i + 1}\")\n",
+    "    for key, value in query_response[\"output\"].items(): print(f\"{key}: {value}\")\n",
+    "    print(\"-\"*50)"
    ]
   },
   {
@@ -323,14 +334,49 @@
     "    fn_name=fn_name,\n",
     "    text_input=\"I want to train a model to predict house prices using the Boston Housing dataset hosted on Kaggle.\"\n",
     ")\n",
-    "for key, value in query_response.items(): print(f\"{key}: {value}\")"
+    "for key, value in query_response[\"output\"].items(): print(f\"{key}: {value}\")\n",
+    "print(f\"Input Tokens: {query_response['in_tokens']}\")\n",
+    "print(f\"Output Tokens: {query_response['out_tokens']}\")\n",
+    "print(f\"Latency: {query_response['latency_ms']} ms\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## A/B Testing with Function Versions"
+    "## Interpretability"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can now understand why a model generated an output simply by passing `return_reasoning=True` at query time!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from weco import build, query\n",
+    "\n",
+    "# Describe the task you want the function to perform\n",
+    "fn_name, fn_desc = build(task_description=task_description)\n",
+    "print(f\"AI Function {fn_name} built. This does the following - \\n{fn_desc}.\")\n",
+    "\n",
+    "# Query the function with a specific input\n",
+    "query_response = query(\n",
+    "    fn_name=fn_name,\n",
+    "    text_input=\"I want to train a model to predict house prices using the Boston Housing dataset hosted on Kaggle.\",\n",
+    "    return_reasoning=True\n",
+    ")\n",
+    "for key, value in query_response[\"output\"].items(): print(f\"{key}: {value}\")\n",
+    "for i, step in enumerate(query_response[\"reasoning_steps\"]): print(f\"Step {i+1}: {step}\")\n",
+    "print(f\"Input Tokens: {query_response['in_tokens']}\")\n",
+    "print(f\"Output Tokens: {query_response['out_tokens']}\")\n",
+    "print(f\"Latency: {query_response['latency_ms']} ms\")"
    ]
   },
   {

{weco-0.1.7 → weco-0.1.9}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
 ]
 description = "A client facing API for interacting with the WeCo AI function builder service."
 readme = "README.md"
-version = "0.1.7"
+version = "0.1.9"
 license = {text = "MIT"}
 requires-python = ">=3.8"
 dependencies = ["asyncio", "httpx[http2]", "pillow"]

{weco-0.1.7 → weco-0.1.9}/tests/test_asynchronous.py

@@ -20,13 +20,14 @@ async def assert_query_response(query_response):
     assert isinstance(query_response["in_tokens"], int)
     assert isinstance(query_response["out_tokens"], int)
     assert isinstance(query_response["latency_ms"], float)
+    assert "reasoning_steps" not in query_response
 
 
 @pytest.fixture
 async def text_evaluator():
     fn_name, version_number, fn_desc = await abuild(
         task_description="Evaluate the sentiment of the given text. Provide a json object with 'sentiment' and 'explanation' keys.",
-        multimodal=False
+        multimodal=False,
     )
     return fn_name, version_number, fn_desc
 
@@ -44,7 +45,7 @@ async def test_text_aquery(text_evaluator):
 async def image_evaluator():
     fn_name, version_number, fn_desc = await abuild(
         task_description="Describe the contents of the given images. Provide a json object with 'description' and 'objects' keys.",
-        multimodal=True
+        multimodal=True,
     )
     return fn_name, version_number, fn_desc
 
@@ -69,7 +70,7 @@ async def test_image_aquery(image_evaluator):
 async def text_and_image_evaluator():
     fn_name, version_number, fn_desc = await abuild(
         task_description="Evaluate, solve and arrive at a numerical answer for the image provided. Provide a json object with 'answer' and 'explanation' keys.",
-        multimodal=True
+        multimodal=True,
     )
     return fn_name, version_number, fn_desc
 

{weco-0.1.7 → weco-0.1.9}/tests/test_batching.py

@@ -9,7 +9,7 @@ from weco import batch_query, build
 def ml_task_evaluator():
     fn_name, version_number, _ = build(
         task_description="I want to evaluate the feasibility of a machine learning task. Give me a json object with three keys - 'feasibility', 'justification', and 'suggestions'.",
-        multimodal=False
+        multimodal=False,
     )
     return fn_name, version_number
 
@@ -18,7 +18,9 @@ def ml_task_evaluator():
 def ml_task_inputs():
     return [
         {"text_input": "I want to train a model to predict house prices using the Boston Housing dataset hosted on Kaggle."},
-        {"text_input": "I want to train a model to classify digits using the MNIST dataset hosted on Kaggle using a Google Colab notebook."},
+        {
+            "text_input": "I want to train a model to classify digits using the MNIST dataset hosted on Kaggle using a Google Colab notebook."
+        },
     ]
 
 
@@ -26,7 +28,7 @@ def ml_task_inputs():
 def image_evaluator():
     fn_name, version_number, _ = build(
         task_description="Describe the contents of the given images. Provide a json object with 'description' and 'objects' keys.",
-        multimodal=True
+        multimodal=True,
     )
     return fn_name, version_number
 
@@ -34,7 +36,11 @@ def image_evaluator():
 @pytest.fixture
 def image_inputs():
     return [
-        {"images_input": ["https://www.integratedtreatmentservices.co.uk/wp-content/uploads/2013/12/Objects-of-Reference.jpg"]},
+        {
+            "images_input": [
+                "https://www.integratedtreatmentservices.co.uk/wp-content/uploads/2013/12/Objects-of-Reference.jpg"
+            ]
+        },
         {"images_input": ["https://t4.ftcdn.net/jpg/05/70/90/23/360_F_570902339_kNj1reH40GFXakTy98EmfiZHci2xvUCS.jpg"]},
     ]
 
@@ -70,6 +76,7 @@ def test_batch_query_image(image_evaluator, image_inputs):
         assert isinstance(query_response["in_tokens"], int)
         assert isinstance(query_response["out_tokens"], int)
         assert isinstance(query_response["latency_ms"], float)
+        assert "reasoning_steps" not in query_response
 
         output = query_response["output"]
-        assert set(output.keys()) == {"description", "objects"}
+        assert set(output.keys()) == {"description", "objects"}

weco-0.1.9/tests/test_reasoning.py

@@ -0,0 +1,58 @@
+import pytest
+
+from weco import build, query
+
+
+def assert_query_response(query_response):
+    assert isinstance(query_response, dict)
+    assert isinstance(query_response["output"], dict)
+    assert isinstance(query_response["reasoning_steps"], list)
+    for step in query_response["reasoning_steps"]:
+        assert isinstance(step, str)
+    assert isinstance(query_response["in_tokens"], int)
+    assert isinstance(query_response["out_tokens"], int)
+    assert isinstance(query_response["latency_ms"], float)
+
+
+@pytest.fixture
+def text_reasoning_evaluator():
+    fn_name, version_number, fn_desc = build(
+        task_description="Evaluate the sentiment of the given text. Provide a json object with 'sentiment' and 'explanation' keys.",
+        multimodal=False,
+    )
+    return fn_name, version_number, fn_desc
+
+
+def test_text_reasoning_query(text_reasoning_evaluator):
+    fn_name, version_number, _ = text_reasoning_evaluator
+    query_response = query(
+        fn_name=fn_name, version_number=version_number, text_input="I love this product!", return_reasoning=True
+    )
+
+    assert_query_response(query_response)
+    assert set(query_response["output"].keys()) == {"sentiment", "explanation"}
+
+
+@pytest.fixture
+def vision_reasoning_evaluator():
+    fn_name, version_number, fn_desc = build(
+        task_description="Evaluate, solve and arrive at a numerical answer for the image provided. Perform any additional things if instructed. Provide a json object with 'answer' and 'explanation' keys.",
+        multimodal=True,
+    )
+    return fn_name, version_number, fn_desc
+
+
+def test_vision_reasoning_query(vision_reasoning_evaluator):
+    fn_name, version_number, _ = vision_reasoning_evaluator
+    query_response = query(
+        fn_name=fn_name,
+        version_number=version_number,
+        text_input="Find x and y.",
+        images_input=[
+            "https://i.ytimg.com/vi/cblHUeq3bkE/hq720.jpg?sqp=-oaymwEhCK4FEIIDSFryq4qpAxMIARUAAAAAGAElAADIQj0AgKJD&rs=AOn4CLAKn3piY91QRCBzRgnzAPf7MPrjDQ"
+        ],
+        return_reasoning=True,
+    )
+
+    assert_query_response(query_response)
+    assert set(query_response["output"].keys()) == {"answer", "explanation"}

{weco-0.1.7 → weco-0.1.9}/tests/test_synchronous.py

@@ -19,13 +19,14 @@ def assert_query_response(query_response):
     assert isinstance(query_response["in_tokens"], int)
     assert isinstance(query_response["out_tokens"], int)
     assert isinstance(query_response["latency_ms"], float)
+    assert "reasoning_steps" not in query_response
 
 
 @pytest.fixture
 def text_evaluator():
     fn_name, version_number, fn_desc = build(
         task_description="Evaluate the sentiment of the given text. Provide a json object with 'sentiment' and 'explanation' keys.",
-        multimodal=False
+        multimodal=False,
     )
     return fn_name, version_number, fn_desc
 
@@ -42,7 +43,7 @@ def test_text_query(text_evaluator):
 def image_evaluator():
     fn_name, version_number, fn_desc = build(
         task_description="Describe the contents of the given images. Provide a json object with 'description' and 'objects' keys.",
-        multimodal=True
+        multimodal=True,
     )
     return fn_name, version_number, fn_desc
 
@@ -66,7 +67,7 @@ def test_image_query(image_evaluator):
 def text_and_image_evaluator():
     fn_name, version_number, fn_desc = build(
         task_description="Evaluate, solve and arrive at a numerical answer for the image provided. Perform any additional things if instructed. Provide a json object with 'answer' and 'explanation' keys.",
-        multimodal=True
+        multimodal=True,
     )
     return fn_name, version_number, fn_desc
 

{weco-0.1.7 → weco-0.1.9}/weco/client.py

@@ -31,7 +31,7 @@ class WecoAI:
     ----------
     api_key : str
         The API key used for authentication.
-    
+
     timeout : float
         The timeout for the HTTP requests in seconds. Default is 120.0.
 
@@ -39,7 +39,7 @@ class WecoAI:
         Whether to use HTTP/2 protocol for the HTTP requests. Default is True.
     """
 
-    def __init__(self, api_key: str = None, timeout: float = 120.0, http2: bool = True) -> None:
+    def __init__(self, api_key: Union[str, None] = None, timeout: float = 120.0, http2: bool = True) -> None:
         """Initializes the WecoAI client with the provided API key and base URL.
 
         Parameters
@@ -68,6 +68,7 @@ class WecoAI:
         self.http2 = http2
         self.timeout = timeout
         self.base_url = "https://function.api.weco.ai"
+
         # Setup clients
         self.client = httpx.Client(http2=http2, timeout=timeout)
         self.async_client = httpx.AsyncClient(http2=http2, timeout=timeout)
@@ -153,24 +154,29 @@ class WecoAI:
         for _warning in response.get("warnings", []):
             warnings.warn(_warning)
 
-        return {
+        returned_response = {
             "output": response["response"],
             "in_tokens": response["num_input_tokens"],
             "out_tokens": response["num_output_tokens"],
             "latency_ms": response["latency_ms"],
         }
+        if "reasoning_steps" in response:
+            returned_response["reasoning_steps"] = response["reasoning_steps"]
+        return returned_response
 
-    def _build(self, task_description: str, multimodal: bool, is_async: bool) -> Union[Tuple[str, int, str], Coroutine[Any, Any, Tuple[str, int, str]]]:
+    def _build(
+        self, task_description: str, multimodal: bool, is_async: bool
+    ) -> Union[Tuple[str, int, str], Coroutine[Any, Any, Tuple[str, int, str]]]:
         """Internal method to handle both synchronous and asynchronous build requests.
 
         Parameters
         ----------
         task_description : str
             A description of the task for which the function is being built.
-        
+
         multimodal : bool
             Whether the function is multimodal or not.
-        
+
         is_async : bool
             Whether to perform an asynchronous request.
 
@@ -212,7 +218,7 @@ class WecoAI:
         ----------
         task_description : str
             A description of the task for which the function is being built.
-        
+
         multimodal : bool, optional
             Whether the function is multimodal or not (default is False).
 
@@ -230,7 +236,7 @@ class WecoAI:
         ----------
         task_description : str
             A description of the task for which the function is being built.
-        
+
         multimodal : bool, optional
             Whether the function is multimodal or not (default is False).
 
@@ -385,7 +391,13 @@ class WecoAI:
         return image_info
 
     def _query(
-        self, is_async: bool, fn_name: str, version_number: Optional[int], text_input: Optional[str], images_input: Optional[List[str]]
+        self,
+        is_async: bool,
+        fn_name: str,
+        version_number: Optional[int],
+        text_input: Optional[str],
+        images_input: Optional[List[str]],
+        return_reasoning: Optional[bool],
     ) -> Union[Dict[str, Any], Coroutine[Any, Any, Dict[str, Any]]]:
         """Internal method to handle both synchronous and asynchronous query requests.
 
@@ -401,6 +413,8 @@ class WecoAI:
             The text input to the function.
         images_input : List[str], optional
             A list of image URLs or images encoded in base64 with their metadata to be sent as input to the function.
+        return_reasoning : bool, optional
+            Whether to return reasoning for the output.
 
         Returns
         -------
@@ -427,7 +441,13 @@ class WecoAI:
 
         # Make the request
         endpoint = "query"
-        data = {"name": fn_name, "text": text_input, "images": image_urls, "version_number": version_number}
+        data = {
+            "name": fn_name,
+            "text": text_input,
+            "images": image_urls,
+            "version_number": version_number,
+            "return_reasoning": return_reasoning,
+        }
         request = self._make_request(endpoint=endpoint, data=data, is_async=is_async)
 
         if is_async:
@@ -442,7 +462,12 @@ class WecoAI:
             return self._process_query_response(response=response)
 
     async def aquery(
-        self, fn_name: str, version_number: Optional[int] = -1, text_input: Optional[str] = "", images_input: Optional[List[str]] = []
+        self,
+        fn_name: str,
+        version_number: Optional[int] = -1,
+        text_input: Optional[str] = "",
+        images_input: Optional[List[str]] = [],
+        return_reasoning: Optional[bool] = False,
     ) -> Dict[str, Any]:
         """Asynchronously queries a function with the given function ID and input.
 
@@ -456,6 +481,8 @@ class WecoAI:
             The text input to the function.
         images_input : List[str], optional
             A list of image URLs or images encoded in base64 with their metadata to be sent as input to the function.
+        return_reasoning : bool, optional
+            Whether to return reasoning for the output. Default is False.
 
         Returns
         -------
@@ -463,9 +490,23 @@ class WecoAI:
             A dictionary containing the output of the function, the number of input tokens, the number of output tokens,
             and the latency in milliseconds.
         """
-        return await self._query(fn_name=fn_name, version_number=version_number, text_input=text_input, images_input=images_input, is_async=True)
-
-    def query(self, fn_name: str, version_number: Optional[int] = -1, text_input: Optional[str] = "", images_input: Optional[List[str]] = []) -> Dict[str, Any]:
+        return await self._query(
+            fn_name=fn_name,
+            version_number=version_number,
+            text_input=text_input,
+            images_input=images_input,
+            return_reasoning=return_reasoning,
+            is_async=True,
+        )
+
+    def query(
+        self,
+        fn_name: str,
+        version_number: Optional[int] = -1,
+        text_input: Optional[str] = "",
+        images_input: Optional[List[str]] = [],
+        return_reasoning: Optional[bool] = False,
+    ) -> Dict[str, Any]:
         """Synchronously queries a function with the given function ID and input.
 
         Parameters
@@ -478,6 +519,8 @@ class WecoAI:
             The text input to the function.
         images_input : List[str], optional
             A list of image URLs or images encoded in base64 with their metadata to be sent as input to the function.
+        return_reasoning : bool, optional
+            Whether to return reasoning for the output. Default is False.
 
         Returns
         -------
@@ -485,23 +528,36 @@ class WecoAI:
             A dictionary containing the output of the function, the number of input tokens, the number of output tokens,
             and the latency in milliseconds.
         """
-        return self._query(fn_name=fn_name, version_number=version_number, text_input=text_input, images_input=images_input, is_async=False)
-
-    def batch_query(self, fn_name: str, batch_inputs: List[Dict[str, Any]], version_number: Optional[int] = -1) -> List[Dict[str, Any]]:
+        return self._query(
+            fn_name=fn_name,
+            version_number=version_number,
+            text_input=text_input,
+            images_input=images_input,
+            return_reasoning=return_reasoning,
+            is_async=False,
+        )
+
+    def batch_query(
+        self,
+        fn_name: str,
+        batch_inputs: List[Dict[str, Any]],
+        version_number: Optional[int] = -1,
+        return_reasoning: Optional[bool] = False,
+    ) -> List[Dict[str, Any]]:
         """Batch queries a function version with a list of inputs.
 
         Parameters
         ----------
         fn_name : str
             The name of the function or a list of function names to query.
-
         batch_inputs : List[Dict[str, Any]]
             A list of inputs for the functions to query. The input must be a dictionary containing the data to be processed. e.g.,
             when providing for a text input, the dictionary should be {"text_input": "input text"}, for an image input, the dictionary should be {"images_input": ["url1", "url2", ...]}
             and for a combination of text and image inputs, the dictionary should be {"text_input": "input text", "images_input": ["url1", "url2", ...]}.
-        
         version_number : int, optional
             The version number of the function to query. If not provided, the latest version will be used. Pass -1 to use the latest version.
+        return_reasoning : bool, optional
+            Whether to return reasoning for the output. Default is False.
 
         Returns
         -------
@@ -509,11 +565,16 @@ class WecoAI:
             A list of dictionaries, each containing the output of a function query,
             in the same order as the input queries.
         """
+
         async def run_queries():
-            tasks = list(map(
-                lambda fn_input: self.aquery(fn_name=fn_name, version_number=version_number, **fn_input),
-                batch_inputs
-            ))
+            tasks = list(
+                map(
+                    lambda fn_input: self.aquery(
+                        fn_name=fn_name, version_number=version_number, return_reasoning=return_reasoning, **fn_input
+                    ),
+                    batch_inputs,
+                )
+            )
             return await asyncio.gather(*tasks)
 
         return asyncio.run(run_queries())

{weco-0.1.7 → weco-0.1.9}/weco/functional.py

@@ -48,7 +48,12 @@ async def abuild(task_description: str, multimodal: bool = False, api_key: str =
 
 
 def query(
-    fn_name: str, version_number: Optional[int] = -1, text_input: Optional[str] = "", images_input: Optional[List[str]] = [], api_key: Optional[str] = None
+    fn_name: str,
+    version_number: Optional[int] = -1,
+    text_input: Optional[str] = "",
+    images_input: Optional[List[str]] = [],
+    return_reasoning: Optional[bool] = False,
+    api_key: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Queries a function synchronously with the given function ID and input.
 
@@ -62,6 +67,8 @@ def query(
         The text input to the function.
     images_input : List[str], optional
         A list of image URLs or base64 encoded images to be used as input to the function.
+    return_reasoning : bool, optional
+        A flag to indicate if the reasoning should be returned. Default is False.
     api_key : str
         The API key for the WecoAI service. If not provided, the API key must be set using the environment variable - WECO_API_KEY.
 
@@ -72,12 +79,23 @@ def query(
         and the latency in milliseconds.
     """
     client = WecoAI(api_key=api_key)
-    response = client.query(fn_name=fn_name, version_number=version_number, text_input=text_input, images_input=images_input)
+    response = client.query(
+        fn_name=fn_name,
+        version_number=version_number,
+        text_input=text_input,
+        images_input=images_input,
+        return_reasoning=return_reasoning,
+    )
     return response
 
 
 async def aquery(
-    fn_name: str, version_number: Optional[int] = -1, text_input: Optional[str] = "", images_input: Optional[List[str]] = [], api_key: Optional[str] = None
+    fn_name: str,
+    version_number: Optional[int] = -1,
+    text_input: Optional[str] = "",
+    images_input: Optional[List[str]] = [],
+    return_reasoning: Optional[bool] = False,
+    api_key: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Queries a function asynchronously with the given function ID and input.
 
@@ -91,6 +109,8 @@ async def aquery(
         The text input to the function.
     images_input : List[str], optional
         A list of image URLs to be used as input to the function.
+    return_reasoning : bool, optional
+        A flag to indicate if the reasoning should be returned. Default is False.
     api_key : str
         The API key for the WecoAI service. If not provided, the API key must be set using the environment variable - WECO_API_KEY.
 
@@ -101,12 +121,22 @@ async def aquery(
         and the latency in milliseconds.
     """
     client = WecoAI(api_key=api_key)
-    response = await client.aquery(fn_name=fn_name, version_number=version_number, text_input=text_input, images_input=images_input)
+    response = await client.aquery(
+        fn_name=fn_name,
+        version_number=version_number,
+        text_input=text_input,
+        images_input=images_input,
+        return_reasoning=return_reasoning,
+    )
     return response
 
 
 def batch_query(
-    fn_name: str, batch_inputs: List[Dict[str, Any]], version_number: Optional[int] = -1, api_key: Optional[str] = None
+    fn_name: str,
+    batch_inputs: List[Dict[str, Any]],
+    version_number: Optional[int] = -1,
+    return_reasoning: Optional[bool] = False,
+    api_key: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
     """Synchronously queries multiple functions using asynchronous calls internally.
 
@@ -119,15 +149,14 @@ def batch_query(
         The name of the function or a list of function names to query.
         Note that if a single function name is provided, it will be used for all queries.
         If a list of function names is provided, the length must match the number of queries.
-
     batch_inputs : List[str]
        A list of inputs for the functions to query. The input must be a dictionary containing the data to be processed. e.g.,
        when providing for a text input, the dictionary should be {"text_input": "input text"}, for an image input, the dictionary should be {"images_input": ["url1", "url2", ...]}
        and for a combination of text and image inputs, the dictionary should be {"text_input": "input text", "images_input": ["url1", "url2", ...]}.
-
     version_number : int, optional
         The version number of the function to query. If not provided, the latest version is used. Default is -1 for the same behavior.
-
+    return_reasoning : bool, optional
+        A flag to indicate if the reasoning should be returned. Default is False.
     api_key : str, optional
         The API key for the WecoAI service. If not provided, the API key must be set using the environment variable - WECO_API_KEY.
 
@@ -138,5 +167,7 @@ def batch_query(
         in the same order as the input queries.
     """
     client = WecoAI(api_key=api_key)
-    responses = client.batch_query(fn_name=fn_name, version_number=version_number, batch_inputs=batch_inputs)
+    responses = client.batch_query(
+        fn_name=fn_name, version_number=version_number, batch_inputs=batch_inputs, return_reasoning=return_reasoning
+    )
     return responses

{weco-0.1.7 → weco-0.1.9}/weco.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: weco
-Version: 0.1.7
+Version: 0.1.9
 Summary: A client facing API for interacting with the WeCo AI function builder service.
 Author-email: WeCo AI Team <dhruv@weco.ai>
 License: MIT
@@ -52,12 +52,16 @@ pip install weco
 ```
 
 ## Features
+- Synchronous & Asynchronous client.
+- Batch API
+- Multimodality (Language & Vision)
+- Interpretability (view the reasoning behind outputs)
+
+
+## What We Offer
 
 - The **build** function enables quick and easy prototyping of new functions via LLMs through just natural language. We encourage users to do this through our [web console](https://weco-app.vercel.app/function) for maximum control and ease of use, however, you can also do this through our API as shown in [here](examples/cookbook.ipynb).
 - The **query** function allows you to test and use the newly created function in your own code.
-- We offer asynchronous versions of the above clients.
-- We provide a **batch_query** functions that allows users to batch functions for various inputs as well as multiple inputs for the same function in a query. This is helpful to make a large number of queries more efficiently.
-- We also offer multimodality capabilities. You can now query our client with both **language** AND **vision** inputs!
 
 We provide both services in two ways:
 - `weco.WecoAI` client to be used when you want to maintain the same client service across a portion of code. This is better for dense service usage.

{weco-0.1.7 → weco-0.1.9}/weco.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ assets/weco.svg
 examples/cookbook.ipynb
 tests/test_asynchronous.py
 tests/test_batching.py
+tests/test_reasoning.py
 tests/test_synchronous.py
 weco/__init__.py
 weco/client.py