Return 0 token counts and cost for via_streaming for now

Author: johann-petrak

llms_wrapper/llms.py

@@ -796,10 +796,13 @@ def cleaned_args(args: dict):
                         ret["response"] = response
                     ret["answer"] = answer
                     ret["n_chunks"] = n_chunks
-                    ret["cost"] = None
                     ret["elapsed_time"] = time.time() - start
                     ret["ok"] = True
                     ret["error"] = ""
+                    # TODO: for now return 0, may perhaps be possible to do better?
+                    ret["cost"] = 0
+                    ret["n_prompt_tokens"] = 0
+                    ret["n_completion_tokens"] = 0
                     return ret
                 except Exception as e:
                     tb = traceback.extract_tb(e.__traceback__)

llms_wrapper/version.py

@@ -1,3 +1,3 @@
 import importlib.metadata
-__version__ = "0.5.5"
+__version__ = "0.5.6"
 

notebooks/test-via-streaming.ipynb

@@ -293,10 +293,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "491b0ddb",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PROCESSING OK, chunks: 1\n",
+      "A **monoid** is a fundamental algebraic structure in mathematics and computer science that consists of:\n",
+      "\n",
+      "1. **A set** (e.g., numbers, strings, functions).\n",
+      "2. **An associative binary operation** (e.g., addition, concatenation) that combines two elements of the set to produce another element of the same set.\n",
+      "3. **An identity element** (e.g., 0 for addition, the empty string for concatenation) that leaves other elements unchanged when combined with them.\n",
+      "\n",
+      "### Simple Example: Strings with Concatenation\n",
+      "- **Set**: All possible strings (e.g., `\"a\"`, `\"hello\"`, `\"\"`).\n",
+      "- **Operation**: Concatenation (e.g., `\"a\" + \"b\" = \"ab\"`).\n",
+      "- **Identity element**: The empty string `\"\"` (since `\"a\" + \"\" = \"a\"`).\n",
+      "\n",
+      "This forms a monoid because:\n",
+      "- Concatenation is **associative**: `(x + y) + z = x + (y + z)`.\n",
+      "- The empty string is the **identity**: `x + \"\" = x`.\n",
+      "\n",
+      "---\n",
+      "\n",
+      "### Why Monoids Are Useful\n",
+      "1. **Abstraction**: Monoids generalize common operations (like addition, multiplication, or list appending) into a single framework, making it easier to reason about them.\n",
+      "2. **Parallelism**: Associativity allows operations to be performed in any order, enabling efficient parallel computation (e.g., MapReduce uses monoids to combine results from distributed workers).\n",
+      "3. **Functional Programming**: Monoids are key in functional programming for combining data (e.g., folding lists, merging data structures).\n",
+      "4. **Category Theory**: Monoids appear in advanced math and CS as a building block for more complex structures (e.g., monads).\n",
+      "\n",
+      "### Another Example: Numbers with Addition\n",
+      "- **Set**: Integers `{0, 1, -1, 2, ...}`.\n",
+      "- **Operation**: Addition (`+`).\n",
+      "- **Identity**: `0` (since `x + 0 = x`).\n",
+      "\n",
+      "This is also a monoid because addition is associative and `0` is the identity.\n",
+      "\n",
+      "---\n",
+      "### Key Takeaway\n",
+      "A monoid is a simple but powerful way to describe \"combinable things with a neutral element.\" Its properties enable efficient, predictable, and scalable computations in many areas.\n"
+     ]
+    }
+   ],
    "source": [
     "# Standard/default way to do it .... \n",
     "logger.disable(\"llms_wrapper\")\n",