cocoindex 0.1.34__tar.gz → 0.1.35__tar.gz

{cocoindex-0.1.34 → cocoindex-0.1.35}/Cargo.lock

@@ -533,7 +533,7 @@ dependencies = [
 
 [[package]]
 name = "cocoindex"
-version = "0.1.34"
+version = "0.1.35"
 dependencies = [
  "anyhow",
  "async-openai",

{cocoindex-0.1.34 → cocoindex-0.1.35}/Cargo.toml

@@ -2,7 +2,7 @@
 name = "cocoindex"
 # Version used for local development is always higher than others to take precedence.
 # Will be overridden for specific release versions.
-version = "0.1.34"
+version = "0.1.35"
 edition = "2021"
 
 [profile.release]

{cocoindex-0.1.34 → cocoindex-0.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.1.34
+Version: 0.1.35
 Requires-Dist: sentence-transformers>=3.3.1
 Requires-Dist: click>=8.1.8
 Requires-Dist: rich>=14.0.0

{cocoindex-0.1.34 → cocoindex-0.1.35}/examples/gdrive_text_embedding/main.py

@@ -53,9 +53,9 @@ query_handler = cocoindex.query.SimpleSemanticsQueryHandler(
     default_similarity_metric=cocoindex.VectorSimilarityMetric.COSINE_SIMILARITY)
 
 @cocoindex.main_fn()
-async def _run():
+def _run():
     # Use a `FlowLiveUpdater` to keep the flow data updated.
-    async with cocoindex.FlowLiveUpdater(gdrive_text_embedding_flow):
+    with cocoindex.FlowLiveUpdater(gdrive_text_embedding_flow):
         # Run queries in a loop to demonstrate the query capabilities.
         while True:
             try:
@@ -74,4 +74,4 @@ async def _run():
 
 if __name__ == "__main__":
     load_dotenv(override=True)
-    asyncio.run(_run())
+    _run()

{cocoindex-0.1.34 → cocoindex-0.1.35}/python/cocoindex/__init__.py

@@ -4,7 +4,7 @@ Cocoindex is a framework for building and running indexing pipelines.
 from . import functions, query, sources, storages, cli
 from .flow import FlowBuilder, DataScope, DataSlice, Flow, flow_def
 from .flow import EvaluateAndDumpOptions, GeneratedField
-from .flow import update_all_flows, FlowLiveUpdater, FlowLiveUpdaterOptions
+from .flow import update_all_flows_async, FlowLiveUpdater, FlowLiveUpdaterOptions
 from .llm import LlmSpec, LlmApiType
 from .index import VectorSimilarityMetric, VectorIndexDef, IndexOptions
 from .auth_registry import AuthEntryReference, add_auth_entry, ref_auth_entry

{cocoindex-0.1.34 → cocoindex-0.1.35}/python/cocoindex/cli.py

@@ -1,4 +1,3 @@
-import asyncio
 import click
 import datetime
 
@@ -7,7 +6,6 @@ from rich.table import Table
 
 from . import flow, lib, setting
 from .setup import sync_setup, drop_setup, flow_names_with_setup, apply_setup_changes
-from .runtime import execution_context
 
 @click.group()
 def cli():
@@ -136,13 +134,12 @@ def update(flow_name: str | None, live: bool, quiet: bool):
     Update the index to reflect the latest data from data sources.
     """
     options = flow.FlowLiveUpdaterOptions(live_mode=live, print_stats=not quiet)
-    async def _update():
-        if flow_name is None:
-            await flow.update_all_flows(options)
-        else:
-            updater = await flow.FlowLiveUpdater.create(_flow_by_name(flow_name), options)
-            await updater.wait()
-    execution_context.run(_update())
+    if flow_name is None:
+        return flow.update_all_flows(options)
+    else:
+        with flow.FlowLiveUpdater(_flow_by_name(flow_name), options) as updater:
+            updater.wait()
+            return updater.update_stats()
 
 @cli.command()
 @click.argument("flow_name", type=str, required=False)
@@ -217,7 +214,7 @@ def server(address: str | None, live_update: bool, quiet: bool, cors_origin: str
 
     if live_update:
         options = flow.FlowLiveUpdaterOptions(live_mode=True, print_stats=not quiet)
-        execution_context.run(flow.update_all_flows(options))
+        flow.update_all_flows(options)
     if COCOINDEX_HOST in cors_origins:
         click.echo(f"Open CocoInsight at: {COCOINDEX_HOST}/cocoinsight")
     input("Press Enter to stop...")

{cocoindex-0.1.34 → cocoindex-0.1.35}/python/cocoindex/flow.py

@@ -8,7 +8,6 @@ import asyncio
 import re
 import inspect
 import datetime
-import json
 
 from typing import Any, Callable, Sequence, TypeVar
 from threading import Lock
@@ -384,56 +383,71 @@ class FlowLiveUpdater:
     """
     A live updater for a flow.
     """
-    _engine_live_updater: _engine.FlowLiveUpdater
+    _flow: Flow
+    _options: FlowLiveUpdaterOptions
+    _engine_live_updater: _engine.FlowLiveUpdater | None = None
 
-    def __init__(self, arg: Flow | _engine.FlowLiveUpdater, options: FlowLiveUpdaterOptions | None = None):
-        if isinstance(arg, _engine.FlowLiveUpdater):
-            self._engine_live_updater = arg
-        else:
-            self._engine_live_updater = execution_context.run(_engine.FlowLiveUpdater(
-                arg.internal_flow(), dump_engine_object(options or FlowLiveUpdaterOptions())))
-
-    @staticmethod
-    async def create(fl: Flow, options: FlowLiveUpdaterOptions | None = None) -> FlowLiveUpdater:
-        """
-        Create a live updater for a flow.
-        """
-        engine_live_updater = await _engine.FlowLiveUpdater.create(
-            await fl.ainternal_flow(),
-            dump_engine_object(options or FlowLiveUpdaterOptions()))
-        return FlowLiveUpdater(engine_live_updater)
+    def __init__(self, fl: Flow, options: FlowLiveUpdaterOptions | None = None):
+        self._flow = fl
+        self._options = options or FlowLiveUpdaterOptions()
 
     def __enter__(self) -> FlowLiveUpdater:
+        self.start()
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
         self.abort()
-        execution_context.run(self.wait())
+        self.wait()
 
     async def __aenter__(self) -> FlowLiveUpdater:
+        await self.start_async()
         return self
 
     async def __aexit__(self, exc_type, exc_value, traceback):
         self.abort()
-        await self.wait()
+        await self.wait_async()
+
+    def start(self) -> None:
+        """
+        Start the live updater.
+        """
+        execution_context.run(self.start_async())
+
+    async def start_async(self) -> None:
+        """
+        Start the live updater.
+        """
+        self._engine_live_updater = await _engine.FlowLiveUpdater.create(
+            await self._flow.internal_flow_async(), dump_engine_object(self._options))
 
-    async def wait(self) -> None:
+    def wait(self) -> None:
         """
         Wait for the live updater to finish.
         """
-        await self._engine_live_updater.wait()
+        execution_context.run(self.wait_async())
+
+    async def wait_async(self) -> None:
+        """
+        Wait for the live updater to finish. Async version.
+        """
+        await self._get_engine_live_updater().wait()
 
     def abort(self) -> None:
         """
         Abort the live updater.
         """
-        self._engine_live_updater.abort()
+        self._get_engine_live_updater().abort()
 
     def update_stats(self) -> _engine.IndexUpdateInfo:
         """
         Get the index update info.
         """
-        return self._engine_live_updater.index_update_info()
+        return self._get_engine_live_updater().index_update_info()
+
+    def _get_engine_live_updater(self) -> _engine.FlowLiveUpdater:
+        if self._engine_live_updater is None:
+            raise RuntimeError("Live updater is not started")
+        return self._engine_live_updater
 
 
 @dataclass
@@ -500,13 +514,20 @@ class Flow:
         """
         return self._lazy_engine_flow().name()
 
-    async def update(self) -> _engine.IndexUpdateInfo:
+    def update(self) -> _engine.IndexUpdateInfo:
+        """
+        Update the index defined by the flow.
+        Once the function returns, the index is fresh up to the moment when the function is called.
+        """
+        return execution_context.run(self.update_async())
+
+    async def update_async(self) -> _engine.IndexUpdateInfo:
         """
         Update the index defined by the flow.
-        Once the function returns, the indice is fresh up to the moment when the function is called.
+        Once the function returns, the index is fresh up to the moment when the function is called.
         """
-        updater = await FlowLiveUpdater.create(self, FlowLiveUpdaterOptions(live_mode=False))
-        await updater.wait()
+        updater = await FlowLiveUpdater.create_async(self, FlowLiveUpdaterOptions(live_mode=False))
+        await updater.wait_async()
         return updater.update_stats()
 
     def evaluate_and_dump(self, options: EvaluateAndDumpOptions):
@@ -521,7 +542,7 @@ class Flow:
         """
         return self._lazy_engine_flow()
 
-    async def ainternal_flow(self) -> _engine.Flow:
+    async def internal_flow_async(self) -> _engine.Flow:
         """
         Get the engine flow. The async version.
         """
@@ -587,22 +608,28 @@ def ensure_all_flows_built() -> None:
     for fl in flows():
         fl.internal_flow()
 
-async def aensure_all_flows_built() -> None:
+async def ensure_all_flows_built_async() -> None:
     """
     Ensure all flows are built.
     """
     for fl in flows():
-        await fl.ainternal_flow()
+        await fl.internal_flow_async()
 
-async def update_all_flows(options: FlowLiveUpdaterOptions) -> dict[str, _engine.IndexUpdateInfo]:
+def update_all_flows(options: FlowLiveUpdaterOptions) -> dict[str, _engine.IndexUpdateInfo]:
     """
     Update all flows.
     """
-    await aensure_all_flows_built()
+    return execution_context.run(update_all_flows_async(options))
+
+async def update_all_flows_async(options: FlowLiveUpdaterOptions) -> dict[str, _engine.IndexUpdateInfo]:
+    """
+    Update all flows.
+    """
+    await ensure_all_flows_built_async()
     async def _update_flow(fl: Flow) -> _engine.IndexUpdateInfo:
-        updater = await FlowLiveUpdater.create(fl, options)
-        await updater.wait()
-        return updater.update_stats()
+        async with FlowLiveUpdater(fl, options) as updater:
+            await updater.wait_async()
+            return updater.update_stats()
     fls = flows()
     all_stats = await asyncio.gather(*(_update_flow(fl) for fl in fls))
     return {fl.name: stats for fl, stats in zip(fls, all_stats)}