agently 4.0.6.7__py3-none-any.whl → 4.0.7__py3-none-any.whl

agently/core/Prompt.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 
 import re
-from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING, cast, overload, TypeVar
+from textwrap import dedent
+from typing import Any, Literal, TYPE_CHECKING, cast, overload, TypeVar
 
-from agently.utils import RuntimeData, Settings
+from agently.utils import RuntimeData, Settings, DataFormatter
 
 if TYPE_CHECKING:
     from agently.types.data.prompt import ChatMessage, PromptStandardSlot
@@ -79,8 +80,6 @@ class Prompt(RuntimeData):
     ):
         super().__init__(prompt_dict, parent=parent_prompt, name=name)
 
-        self._placeholder_pattern = re.compile(r"\$\{\s*([^}]+?)\s*\}")
-
         self.settings = Settings(
             name="Prompt-Settings",
             parent=parent_settings,
@@ -98,42 +97,9 @@ class Prompt(RuntimeData):
         self.to_messages = self.prompt_generator.to_messages
         self.to_prompt_object = self.prompt_generator.to_prompt_object
         self.to_output_model = self.prompt_generator.to_output_model
-
-    def _substitute_placeholder(self, obj: T, variable_mappings: dict[str, Any]) -> T | Any:
-        if not isinstance(variable_mappings, dict):
-            raise TypeError(f"Variable mappings require a dictionary but got: { variable_mappings }")
-
-        if isinstance(obj, str):
-            full_match = self._placeholder_pattern.fullmatch(obj)
-            if full_match:
-                key = full_match.group(1).strip()
-                return variable_mappings.get(key, obj)
-            else:
-
-                def replacer(match):
-                    key = match.group(1).strip()
-                    return str(variable_mappings.get(key, match.group(0)))
-
-                return self._placeholder_pattern.sub(replacer, obj)
-
-        if isinstance(obj, Mapping):
-            return {
-                self._substitute_placeholder(key, variable_mappings): self._substitute_placeholder(
-                    value, variable_mappings
-                )
-                for key, value in obj.items()
-            }
-
-        if isinstance(obj, Sequence) and not isinstance(obj, (str, bytes, bytearray)):
-            if isinstance(obj, tuple):
-                return tuple(self._substitute_placeholder(value, variable_mappings) for value in obj)
-            else:
-                return [self._substitute_placeholder(value, variable_mappings) for value in obj]
-
-        if isinstance(obj, set):
-            return {self._substitute_placeholder(value, variable_mappings) for value in obj}
-
-        return obj
+        self.to_serializable_prompt_data = self.prompt_generator.to_serializable_prompt_data
+        self.to_json_prompt = self.prompt_generator.to_json_prompt
+        self.to_yaml_prompt = self.prompt_generator.to_yaml_prompt
 
     @overload
     def set(
@@ -157,10 +123,12 @@ class Prompt(RuntimeData):
         value: Any,
         mappings: dict[str, Any] | None = None,
     ):
+        if isinstance(value, str):
+            value = dedent(value.strip())
         if mappings is not None:
             super().set(
-                self._substitute_placeholder(key, mappings),
-                self._substitute_placeholder(value, mappings),
+                DataFormatter.substitute_placeholder(key, mappings),
+                DataFormatter.substitute_placeholder(value, mappings),
             )
         else:
             super().set(key, value)
@@ -172,7 +140,7 @@ class Prompt(RuntimeData):
     ):
         if mappings is not None:
             super().update(
-                self._substitute_placeholder(new, mappings),
+                DataFormatter.substitute_placeholder(new, mappings),
             )
         else:
             super().update(new)
@@ -183,10 +151,12 @@ class Prompt(RuntimeData):
         value: Any,
         mappings: dict[str, Any] | None = None,
     ):
+        if isinstance(value, str):
+            value = dedent(value.strip())
         if mappings is not None:
             super().append(
-                self._substitute_placeholder(key, mappings),
-                self._substitute_placeholder(value, mappings),
+                DataFormatter.substitute_placeholder(key, mappings),
+                DataFormatter.substitute_placeholder(value, mappings),
             )
         else:
             super().append(key, value)

agently/core/TriggerFlow/BluePrint.py

@@ -132,6 +132,7 @@ class TriggerFlowBluePrint:
         *,
         execution_id: str | None = None,
         skip_exceptions: bool = False,
+        concurrency: int | None = None,
     ):
         handlers_snapshot: TriggerFlowAllHandlers = {
             "event": {k: v.copy() for k, v in self._handlers["event"].items()},
@@ -143,6 +144,7 @@ class TriggerFlowBluePrint:
             trigger_flow=trigger_flow,
             id=execution_id,
             skip_exceptions=skip_exceptions,
+            concurrency=concurrency,
         )
 
     def copy(self, *, name: str | None = None):

agently/core/TriggerFlow/Chunk.py

@@ -30,16 +30,17 @@ class TriggerFlowChunk:
         *,
         name: str | None = None,
     ):
-        self.name = name if name is not None else uuid.uuid4().hex
+        self.id = uuid.uuid4().hex
+        self.name = name if name is not None else self.id
         self._handler = handler
-        self.trigger = f"Chunk[{ handler.__name__ }]-{ self.name }"
+        self.trigger = f"Chunk[{ handler.__name__ }]-{ self.id }"
 
     async def async_call(self, data: "TriggerFlowEventData"):
         result = await FunctionShifter.asyncify(self._handler)(data)
-        await data.async_emit(self.trigger, result, layer_marks=data.layer_marks.copy())
+        await data.async_emit(self.trigger, result, _layer_marks=data._layer_marks.copy())
         return result
 
     def call(self, data: "TriggerFlowEventData"):
         result = FunctionShifter.syncify(self._handler)(data)
-        data.emit(self.trigger, result, layer_marks=data.layer_marks.copy())
+        data.emit(self.trigger, result, _layer_marks=data._layer_marks.copy())
         return result

agently/core/TriggerFlow/Execution.py

@@ -16,6 +16,7 @@
 import uuid
 import asyncio
 import warnings
+from contextvars import ContextVar
 
 from typing import Any, Literal, TYPE_CHECKING
 
@@ -37,6 +38,7 @@ class TriggerFlowExecution:
         trigger_flow: "TriggerFlow",
         id: str | None = None,
         skip_exceptions: bool = False,
+        concurrency: int | None = None,
     ):
         # Basic Attributions
         self.id = id if id is not None else uuid.uuid4().hex
@@ -45,6 +47,11 @@ class TriggerFlowExecution:
         self._runtime_data = RuntimeData()
         self._system_runtime_data = RuntimeData()
         self._skip_exceptions = skip_exceptions
+        self._concurrency_semaphore = asyncio.Semaphore(concurrency) if concurrency and concurrency > 0 else None
+        self._concurrency_depth = ContextVar(
+            f"trigger_flow_execution_concurrency_depth_{ self.id }",
+            default=0,
+        )
 
         # Settings
         self.settings = Settings(
@@ -97,7 +104,7 @@ class TriggerFlowExecution:
         self,
         trigger_event: str,
         value: Any = None,
-        layer_marks: list[str] | None = None,
+        _layer_marks: list[str] | None = None,
         *,
         trigger_type: Literal["event", "runtime_data", "flow_data"] = "event",
     ):
@@ -126,19 +133,29 @@ class TriggerFlowExecution:
                     },
                     self.settings,
                 )
-                tasks.append(
-                    asyncio.ensure_future(
-                        FunctionShifter.asyncify(handler)(
-                            TriggerFlowEventData(
-                                trigger_event=trigger_event,
-                                trigger_type=trigger_type,
-                                value=value,
-                                execution=self,
-                                layer_marks=layer_marks,
-                            )
-                        )
+                async def run_handler(handler_func):
+                    if self._concurrency_semaphore is None:
+                        return await handler_func
+                    depth = self._concurrency_depth.get()
+                    token = self._concurrency_depth.set(depth + 1)
+                    try:
+                        if depth > 0:
+                            return await handler_func
+                        async with self._concurrency_semaphore:
+                            return await handler_func
+                    finally:
+                        self._concurrency_depth.reset(token)
+
+                handler_task = FunctionShifter.asyncify(handler)(
+                    TriggerFlowEventData(
+                        trigger_event=trigger_event,
+                        trigger_type=trigger_type,
+                        value=value,
+                        execution=self,
+                        _layer_marks=_layer_marks,
                     )
                 )
+                tasks.append(asyncio.ensure_future(run_handler(handler_task)))
 
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=self._skip_exceptions)

agently/core/TriggerFlow/TriggerFlow.py

@@ -51,6 +51,7 @@ class TriggerFlow:
         self._skip_exceptions = skip_exceptions
         self._executions: dict[str, "TriggerFlowExecution"] = {}
         self._start_process = TriggerFlowProcess(
+            flow_chunk=self.chunk,
             trigger_event="START",
             blue_print=self._blue_print,
             block_data=TriggerFlowBlockData(
@@ -60,6 +61,8 @@ class TriggerFlow:
 
         self.chunks = self._blue_print.chunks
 
+        self.set_settings = self.settings.set_settings
+
         self.get_flow_data = self._flow_data.get
         self.set_flow_data = FunctionShifter.syncify(self.async_set_flow_data)
         self.append_flow_data = FunctionShifter.syncify(self.async_append_flow_data)
@@ -74,10 +77,6 @@ class TriggerFlow:
         self.start_execution = FunctionShifter.syncify(self.async_start_execution)
         self.start = FunctionShifter.syncify(self.async_start)
 
-    def set_settings(self, key: str, value: "SerializableValue"):
-        self.settings.set_settings(key, value)
-        return self
-
     @overload
     def chunk(self, handler_or_name: "TriggerFlowHandler") -> TriggerFlowChunk: ...
 
@@ -100,13 +99,19 @@ class TriggerFlow:
             self._blue_print.chunks[handler_or_name.__name__] = chunk
             return chunk
 
-    def create_execution(self, *, skip_exceptions: bool | None = None):
+    def create_execution(
+        self,
+        *,
+        skip_exceptions: bool | None = None,
+        concurrency: int | None = None,
+    ):
         execution_id = uuid.uuid4().hex
         skip_exceptions = skip_exceptions if skip_exceptions is not None else self._skip_exceptions
         execution = self._blue_print.create_execution(
             self,
             execution_id=execution_id,
             skip_exceptions=skip_exceptions,
+            concurrency=concurrency,
         )
         self._executions[execution_id] = execution
         return execution
@@ -119,8 +124,14 @@ class TriggerFlow:
             if execution.id in self._executions:
                 del self._executions[execution.id]
 
-    async def async_start_execution(self, initial_value: Any, *, wait_for_result: bool = False):
-        execution = self.create_execution()
+    async def async_start_execution(
+        self,
+        initial_value: Any,
+        *,
+        wait_for_result: bool = False,
+        concurrency: int | None = None,
+    ):
+        execution = self.create_execution(concurrency=concurrency)
         await execution.async_start(initial_value, wait_for_result=wait_for_result)
         return execution
 
@@ -193,8 +204,9 @@ class TriggerFlow:
         *,
         wait_for_result: bool = True,
         timeout: int | None = 10,
+        concurrency: int | None = None,
     ):
-        execution = await self.async_start_execution(initial_value)
+        execution = await self.async_start_execution(initial_value, concurrency=concurrency)
         if wait_for_result:
             return await execution.async_get_result(timeout=timeout)
 
@@ -203,8 +215,9 @@ class TriggerFlow:
         initial_value: Any = None,
         *,
         timeout: int | None = 10,
+        concurrency: int | None = None,
     ):
-        execution = self.create_execution()
+        execution = self.create_execution(concurrency=concurrency)
         return execution.get_async_runtime_stream(
             initial_value,
             timeout=timeout,
@@ -215,8 +228,9 @@ class TriggerFlow:
         initial_value: Any = None,
         *,
         timeout: int | None = 10,
+        concurrency: int | None = None,
     ):
-        execution = self.create_execution()
+        execution = self.create_execution(concurrency=concurrency)
         return execution.get_runtime_stream(
             initial_value,
             timeout=timeout,

agently/core/TriggerFlow/process/BaseProcess.py

@@ -14,10 +14,10 @@
 
 
 import uuid
-from asyncio import Event
+from asyncio import Event, Semaphore
 from threading import Lock
 
-from typing import Any, Literal, TYPE_CHECKING, overload
+from typing import Callable, Any, Literal, TYPE_CHECKING, overload, cast
 from typing_extensions import Self
 
 
@@ -31,15 +31,18 @@ from agently.types.trigger_flow import TriggerFlowBlockData
 
 
 class TriggerFlowBaseProcess:
+
     def __init__(
         self,
         *,
+        flow_chunk,
         trigger_event: str,
         blue_print: "TriggerFlowBluePrint",
         block_data: "TriggerFlowBlockData",
         trigger_type: Literal["event", "runtime_data", "flow_data"] = "event",
         **options,
     ):
+        self._flow_chunk = flow_chunk
         self.trigger_event = trigger_event
         self.trigger_type: Literal["event", "runtime_data", "flow_data"] = trigger_type
         self._blue_print = blue_print
@@ -55,6 +58,7 @@ class TriggerFlowBaseProcess:
         **options,
     ):
         return type(self)(
+            flow_chunk=self._flow_chunk,
             trigger_event=trigger_event,
             trigger_type=trigger_type,
             blue_print=blue_print,
@@ -112,8 +116,12 @@ class TriggerFlowBaseProcess:
         if isinstance(trigger_or_triggers, TriggerFlowChunk):
             trigger_or_triggers = trigger_or_triggers.trigger
         if isinstance(trigger_or_triggers, str):
+            if trigger_or_triggers in self._blue_print.chunks:
+                trigger = self._blue_print.chunks[trigger_or_triggers].trigger
+            else:
+                trigger = trigger_or_triggers
             return self._new(
-                trigger_event=trigger_or_triggers,
+                trigger_event=trigger,
                 trigger_type="event",
                 blue_print=self._blue_print,
                 block_data=TriggerFlowBlockData(
@@ -178,7 +186,7 @@ class TriggerFlowBaseProcess:
                                 if mode == "simple_or"
                                 else (data.trigger_type, data.trigger_event, data.value)
                             ),
-                            layer_marks=data.layer_marks.copy(),
+                            _layer_marks=data._layer_marks.copy(),
                         )
                     case "and":
                         if data.trigger_type in values and data.trigger_event in values[trigger_type]:  # type: ignore
@@ -191,7 +199,7 @@ class TriggerFlowBaseProcess:
                         await data.async_emit(
                             when_trigger,
                             values,
-                            layer_marks=data.layer_marks.copy(),
+                            _layer_marks=data._layer_marks.copy(),
                         )
 
             for trigger_type, trigger_event_dict in values.items():
@@ -213,15 +221,22 @@ class TriggerFlowBaseProcess:
 
     def to(
         self,
-        chunk: "TriggerFlowChunk | TriggerFlowHandler | str",
+        chunk: "TriggerFlowChunk | TriggerFlowHandler | str | tuple[str, TriggerFlowHandler]",
         side_branch: bool = False,
+        name: str | None = None,
     ):
         if isinstance(chunk, str):
             if chunk in self._blue_print.chunks:
                 chunk = self._blue_print.chunks[chunk]
             else:
                 raise NotImplementedError(f"Cannot find chunk named '{ chunk }'")
-        chunk = TriggerFlowChunk(chunk) if callable(chunk) else chunk
+        elif isinstance(chunk, tuple):
+            chunk_name = chunk[0]
+            chunk_func = chunk[1]
+            chunk = self._flow_chunk(chunk_name)(chunk_func)
+        else:
+            chunk = self._flow_chunk(name or chunk.__name__)(chunk) if callable(chunk) else chunk
+        assert isinstance(chunk, TriggerFlowChunk)
         self._blue_print.add_handler(
             self.trigger_type,
             self.trigger_event,
@@ -235,38 +250,65 @@ class TriggerFlowBaseProcess:
             **self._options,
         )
 
-    def side_branch(self, chunk: "TriggerFlowChunk | TriggerFlowHandler"):
-        return self.to(chunk, side_branch=True)
+    def side_branch(
+        self,
+        chunk: "TriggerFlowChunk | TriggerFlowHandler",
+        *,
+        name: str | None = None,
+    ):
+        return self.to(
+            chunk,
+            side_branch=True,
+            name=name,
+        )
 
     def batch(
         self,
-        *chunks: "TriggerFlowChunk | TriggerFlowHandler",
+        *chunks: "TriggerFlowChunk | TriggerFlowHandler | tuple[str, TriggerFlowHandler]",
         side_branch: bool = False,
+        concurrency: int | None = None,
     ):
         batch_trigger = f"Batch-{ uuid.uuid4().hex }"
         results = {}
-        chunks_to_wait = {}
+        triggers_to_wait = {}
+        trigger_to_chunk_name = {}
+        semaphore = Semaphore(concurrency) if concurrency and concurrency > 0 else None
 
         async def wait_all_chunks(data: "TriggerFlowEventData"):
-            if data.event in chunks_to_wait:
-                results[data.event] = data.value
-                chunks_to_wait[data.event] = True
-            for done in chunks_to_wait.values():
+            if data.event in triggers_to_wait:
+                results[trigger_to_chunk_name[data.event]] = data.value
+                triggers_to_wait[data.event] = True
+            for done in triggers_to_wait.values():
                 if done is False:
                     return
             await data.async_emit(
                 batch_trigger,
                 results,
-                layer_marks=data.layer_marks.copy(),
+                _layer_marks=data._layer_marks.copy(),
             )
 
         for chunk in chunks:
-            chunk = TriggerFlowChunk(chunk) if callable(chunk) else chunk
-            chunks_to_wait[chunk.name] = False
+            if isinstance(chunk, tuple):
+                chunk_name = chunk[0]
+                chunk_func = chunk[1]
+                chunk = self._flow_chunk(chunk_name)(chunk_func)
+            else:
+                chunk = self._flow_chunk(chunk.__name__)(chunk) if callable(chunk) else chunk
+            triggers_to_wait[chunk.trigger] = False
+            trigger_to_chunk_name[chunk.trigger] = chunk.name
+            results[chunk.name] = None
+
+            if semaphore is None:
+                handler = chunk.async_call
+            else:
+                async def handler(data: "TriggerFlowEventData", _chunk=chunk):
+                    async with semaphore:
+                        return await _chunk.async_call(data)
+
             self._blue_print.add_handler(
                 self.trigger_type,
                 self.trigger_event,
-                chunk.async_call,
+                handler,
             )
             self._blue_print.add_event_handler(chunk.trigger, wait_all_chunks)
 
@@ -299,13 +341,13 @@ class TriggerFlowBaseProcess:
                 await data.async_emit(
                     collect_trigger,
                     self._block_data.global_data.get(f"collections.{ collection_name}"),
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
             elif mode == "filled_then_empty":
                 await data.async_emit(
                     collect_trigger,
                     self._block_data.global_data.get(f"collections.{ collection_name}"),
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
                 del self._block_data.global_data[f"collections.{ collection_name}"]
 

agently/core/TriggerFlow/process/ForEachProcess.py

@@ -22,7 +22,7 @@ from agently.utils import RuntimeDataNamespace
 
 
 class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
-    def for_each(self):
+    def for_each(self, *, concurrency: int | None = None):
         for_each_id = uuid.uuid4().hex
         for_each_block_data = TriggerFlowBlockData(
             outer_block=self._block_data,
@@ -31,6 +31,7 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
             },
         )
         send_item_trigger = f"ForEach-{ for_each_id }-Send"
+        semaphore = asyncio.Semaphore(concurrency) if concurrency and concurrency > 0 else None
 
         async def send_items(data: "TriggerFlowEventData"):
             data.layer_in()
@@ -38,33 +39,38 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
             assert for_each_instance_id is not None
 
             send_tasks = []
-            if not isinstance(data.value, str) and isinstance(data.value, Sequence):
-                items = list(data.value)
-                for item in items:
-                    data.layer_in()
-                    item_id = data.layer_mark
-                    assert item_id is not None
-                    data._system_runtime_data.set(f"for_each_results.{ for_each_instance_id }.{ item_id }", EMPTY)
-                    send_tasks.append(
-                        data.async_emit(
-                            send_item_trigger,
-                            item,
-                            data.layer_marks.copy(),
-                        )
-                    )
-                    data.layer_out()
-                await asyncio.gather(*send_tasks)
-            else:
+            def prepare_item(item):
                 data.layer_in()
                 item_id = data.layer_mark
                 assert item_id is not None
+                layer_marks = data._layer_marks.copy()
                 data._system_runtime_data.set(f"for_each_results.{ for_each_instance_id }.{ item_id }", EMPTY)
-                await data.async_emit(
-                    send_item_trigger,
-                    data.value,
-                    data.layer_marks.copy(),
-                )
                 data.layer_out()
+                return item_id, layer_marks, item
+
+            async def emit_item(item, layer_marks):
+                if semaphore is None:
+                    await data.async_emit(
+                        send_item_trigger,
+                        item,
+                        layer_marks,
+                    )
+                else:
+                    async with semaphore:
+                        await data.async_emit(
+                            send_item_trigger,
+                            item,
+                            layer_marks,
+                        )
+            if not isinstance(data.value, str) and isinstance(data.value, Sequence):
+                items = list(data.value)
+                for item in items:
+                    _, layer_marks, item_value = prepare_item(item)
+                    send_tasks.append(emit_item(item_value, layer_marks))
+                await asyncio.gather(*send_tasks)
+            else:
+                _, layer_marks, item_value = prepare_item(data.value)
+                await emit_item(item_value, layer_marks)
 
         self.to(send_items)
 
@@ -103,7 +109,7 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
                 await data.async_emit(
                     end_for_each_trigger,
                     list(for_each_results[for_each_instance_id].values()),
-                    data.layer_marks.copy(),
+                    data._layer_marks.copy(),
                 )
                 for_each_results.delete(for_each_instance_id)
 

agently/core/TriggerFlow/process/MatchCaseProcess.py

@@ -58,7 +58,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                         await data.async_emit(
                             f"Match-{ match_id }-Case-{ case_id }",
                             data.value,
-                            layer_marks=data.layer_marks.copy(),
+                            _layer_marks=data._layer_marks.copy(),
                         )
                         return
                     elif mode == "hit_all":
@@ -71,7 +71,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                             data.async_emit(
                                 f"Match-{ match_id }-Case-{ case_id }",
                                 data.value,
-                                layer_marks=data.layer_marks.copy(),
+                                _layer_marks=data._layer_marks.copy(),
                             )
                         )
                         data.layer_out()
@@ -81,13 +81,13 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                     await data.async_emit(
                         f"Match-{ match_id }-Else",
                         data.value,
-                        layer_marks=data.layer_marks.copy(),
+                        _layer_marks=data._layer_marks.copy(),
                     )
                 else:
                     await data.async_emit(
                         f"Match-{ match_id }-Result",
                         data.value,
-                        layer_marks=data.layer_marks.copy(),
+                        _layer_marks=data._layer_marks.copy(),
                     )
 
         self.to(match_case)
@@ -164,7 +164,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                 await data.async_emit(
                     f"Match-{ match_id }-Result",
                     list(match_results.values()),
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
                 del data._system_runtime_data[f"match_results.{ data.upper_layer_mark }"]
             else:
@@ -172,7 +172,7 @@ class TriggerFlowMatchCaseProcess(TriggerFlowBaseProcess):
                 await data.async_emit(
                     f"Match-{ match_id }-Result",
                     data.value,
-                    layer_marks=data.layer_marks.copy(),
+                    _layer_marks=data._layer_marks.copy(),
                 )
 
         for trigger in branch_ends:

agently/integrations/chromadb.py

@@ -1,3 +1,18 @@
+# Copyright 2023-2025 AgentEra(Agently.Tech)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
 from agently.utils import LazyImport
 
 LazyImport.import_package("chromadb")