bulk-chain 1.0.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

bulk_chain/api.py

@@ -1,41 +1,36 @@
+import asyncio
 import collections
+import logging
 import os
 from itertools import chain
+from types import AsyncGeneratorType
 
 from bulk_chain.core.llm_base import BaseLM
+from bulk_chain.core.service_asyncio import AsyncioService
 from bulk_chain.core.service_batch import BatchIterator
 from bulk_chain.core.service_data import DataService
 from bulk_chain.core.service_dict import DictionaryService
 from bulk_chain.core.service_json import JsonService
 from bulk_chain.core.service_schema import SchemaService
-from bulk_chain.core.utils import dynamic_init, find_by_prefix
+from bulk_chain.core.utils import attempt_wrapper
 
 
 INFER_MODES = {
-    "batch": lambda llm, batch, limit_prompt=None: llm.ask_core(
-        DataService.limit_prompts(batch, limit=limit_prompt))
+    "single": lambda llm, batch, **kwargs: [llm.ask(prompt) for prompt in batch],
+    "batch": lambda llm, batch, **kwargs: llm.ask_batch(batch),
+    "single_stream": lambda llm, batch, **kwargs: [llm.ask_stream(prompt) for prompt in batch],
+    "batch_async": lambda llm, batch, **kwargs: AsyncioService.run_tasks(
+        batch=batch, async_handler=llm.ask_async, event_loop=kwargs.get("event_loop")
+    ),
+    "batch_stream_async": lambda llm, batch, **kwargs: AsyncioService.run_tasks(
+        batch=batch, async_handler=llm.ask_stream_async, event_loop=kwargs.get("event_loop")
+    ),
 }
 
 
 CWD = os.getcwd()
 
 
-def _iter_entry_content(entry, entry_info=None, **kwargs):
-
-    if isinstance(entry, str):
-        kwargs.get("callback_str_func", lambda *_: None)(entry, entry_info)
-        yield entry
-    elif isinstance(entry, collections.abc.Iterable):
-        h = kwargs.get("callback_stream_func", lambda *_: None)
-        h(None, entry_info | {"action": "start"})
-        for chunk in map(lambda item: str(item), entry):
-            yield chunk
-            h(chunk, entry_info)
-        h(None, entry_info | {"action": "end"})
-    else:
-        raise Exception(f"Non supported type `{type(entry)}` for handling output from batch")
-
-
 def _iter_batch_prompts(c, batch_content_it, **kwargs):
     for ind_in_batch, entry in enumerate(batch_content_it):
         content = DataService.get_prompt_text(
@@ -45,19 +40,63 @@ def _iter_batch_prompts(c, batch_content_it, **kwargs):
         yield ind_in_batch, content
 
 
-def _iter_batch_responses(p_column, c, batch_content_it, **kwargs):
+def __handle_agen_to_gen(handle, batch, event_loop):
+    """ This handler provides conversion of the async generator to generator (sync).
+    """
+
+    def __wrap_with_index(async_gens):
+        async def wrapper(index, agen):
+            async for item in agen:
+                yield index, item
+        return [wrapper(i, agen) for i, agen in enumerate(async_gens)]
+
+    agen_list = handle(batch, event_loop=event_loop)
+
+    it = AsyncioService.async_gen_to_iter(
+        gen=AsyncioService.merge_generators(*__wrap_with_index(agen_list)),
+        loop=event_loop)
+
+    for ind_in_batch, chunk in it:
+        yield ind_in_batch, str(chunk)
+
+
+def __handle_gen(handle, batch, event_loop):
+    """ This handler deals with the iteration of each individual element of the batch.
+    """
+
+    def _iter_entry_content(entry):
+        if isinstance(entry, str):
+            yield entry
+        elif isinstance(entry, collections.abc.Iterable):
+            for chunk in map(lambda item: str(item), entry):
+                yield chunk
+        elif isinstance(entry, AsyncGeneratorType):
+            for chunk in AsyncioService.async_gen_to_iter(entry, loop=event_loop):
+                yield str(chunk)
+        else:
+            raise Exception(f"Non supported type `{type(entry)}` for handling output from batch")
+
+    for ind_in_batch, entry in enumerate(handle(batch, event_loop=event_loop)):
+        for chunk in _iter_entry_content(entry=entry):
+            yield ind_in_batch, chunk
+
+
+def _iter_chunks(p_column, batch_content_it, **kwargs):
+    handler = __handle_agen_to_gen if kwargs["infer_mode"] == "batch_stream_async" else __handle_gen
     p_batch = [item[p_column] for item in batch_content_it]
-    # TODO. This part could be async.
-    # TODO. ind_in_batch might be a part of the async return.
-    for ind_in_batch, entry in enumerate(kwargs["handle_batch_func"](p_batch)):
-        yield ind_in_batch, _iter_entry_content(entry=entry, entry_info={"ind": ind_in_batch, "param": c}, **kwargs)
+    it = handler(handle=kwargs["handle_batch_func"], batch=p_batch, event_loop=kwargs["event_loop"])
+    for ind_in_batch, chunk in it:
+        yield ind_in_batch, chunk
 
 
-def _infer_batch(batch, schema, return_mode, cols=None, **kwargs):
+def _column_ordered_chunks_iter(batch, schema, cols=None, keep_prompts=True, **kwargs):
+    """
+    NOTE: we populate `batch` content automatically
+    """
     assert (isinstance(batch, list))
 
     if len(batch) == 0:
-        return batch
+        return
 
     if cols is None:
         first_item = batch[0]
@@ -73,71 +112,118 @@ def _infer_batch(batch, schema, return_mode, cols=None, **kwargs):
 
         # Handling column for inference.
         if c in schema.r2p:
-            content_it = _iter_batch_responses(c=c, p_column=schema.r2p[c], batch_content_it=iter(batch), **kwargs)
-            for ind_in_batch, chunk_it in content_it:
-
-                chunks = []
-                for chunk in chunk_it:
-                    chunks.append(chunk)
-
-                    if return_mode == "chunk":
-                        yield [ind_in_batch, c, chunk]
-
-                batch[ind_in_batch][c] = "".join(chunks)
-
-    if return_mode == "record":
+            content_it = _iter_chunks(p_column=schema.r2p[c], batch_content_it=iter(batch), **kwargs)
+            # Register values.
+            for item in batch:
+                item[c] = []
+            for ind_in_batch, chunk in content_it:
+                # Append batch.
+                batch[ind_in_batch][c].append(chunk)
+                yield [ind_in_batch, c, chunk]
+
+            # Convert content to string.
+            for item in batch:
+                item[c] = "".join(item[c])
+
+    if not keep_prompts:
+        for batch_item in batch:
+            for key in list(batch_item.keys()):
+                prompt_col = SchemaService.col_to_prompt(col_name=key, prompt_data=batch_item)
+                if prompt_col in batch_item:
+                    del batch_item[prompt_col]
+
+
+def _infer_batch(return_type, batch, batch_ind, **kwargs):
+    assert (return_type in ["batch", "chunk", "record"])
+
+    # Filling batch with inference content.
+    for ind_in_batch, column, chunk in _column_ordered_chunks_iter(batch=batch, **kwargs):
+        if return_type == "chunk":
+            global_ind = batch_ind * len(batch) + ind_in_batch
+            yield [global_ind, column, chunk]
+
+    if return_type == "record":
         for record in batch:
             yield record
 
-    if return_mode == "batch":
+    if return_type == "batch":
         yield batch
 
 
-def iter_content(input_dicts_it, llm, schema, batch_size=1, limit_prompt=None, return_mode="batch", **kwargs):
+def get_infer_mode(stream, batch_size, async_mode):
+    if not stream and batch_size == 1:
+        return 'single', 'record'
+    elif not stream and batch_size > 1:
+        if async_mode:
+            return 'batch_async', 'batch'
+        else:
+            return 'batch', 'batch'
+    elif stream and batch_size == 1:
+        return 'single_stream', 'chunk'
+    elif stream and batch_size > 1:
+        return 'batch_stream_async', 'chunk'
+
+    raise ValueError(f"Invalid combination of stream and batch_size: {stream}, {batch_size}")
+
+
+def iter_content(input_dicts_it, llm, schema, batch_size=1, limit_prompt=None,
+                 stream=False, async_mode=False, attempts=1, event_loop=None,
+                 handle_missed_value_func=lambda *_: None, **kwargs):
     """ This method represent Python API aimed at application of `llm` towards
         iterator of input_dicts via cache_target that refers to the SQLite using
         the given `schema`
     """
-    assert (return_mode in ["batch", "chunk"])
     assert (isinstance(llm, BaseLM))
+    assert (isinstance(batch_size, int) and batch_size > 0)
+    assert (isinstance(async_mode, bool)) 
+
+    infer_type, return_type = get_infer_mode(stream=stream, batch_size=batch_size, async_mode=async_mode)
+    infer_mode = INFER_MODES[infer_type]
+
+    # Setup event loop.
+    event_loop = asyncio.get_event_loop_policy().get_event_loop() \
+        if event_loop is None else event_loop
 
     # Quick initialization of the schema.
     if isinstance(schema, str):
         schema = JsonService.read(schema)
     if isinstance(schema, dict):
         schema = SchemaService(json_data=schema)
+    if isinstance(schema, list):
+        schema = SchemaService(json_data={"schema": schema})
 
     prompts_it = map(
         lambda data: DictionaryService.custom_update(src_dict=dict(data), other_dict=schema.cot_args),
         input_dicts_it
     )
 
-    content_it = (_infer_batch(batch=batch,
-                               handle_batch_func=lambda batch: INFER_MODES["batch"](llm, batch, limit_prompt),
-                               return_mode=return_mode,
+    handle_batch_func = lambda batch, **handle_kwargs: infer_mode(
+        llm,
+        DataService.limit_prompts(batch, limit=limit_prompt),
+        **handle_kwargs
+    )
+
+    # Optional wrapping into attempts.
+    if attempts > 1:
+        # Optional setup of the logger.
+        logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.INFO)
+
+        attempt_dec = attempt_wrapper(attempts=attempts,
+                                      delay_sec=kwargs.get("attempt_delay_sec", 1),
+                                      logger=logger)
+        handle_batch_func = attempt_dec(handle_batch_func)
+
+    kwargs["handle_missed_value_func"] = handle_missed_value_func
+
+    content_it = (_infer_batch(return_type=return_type,
+                               batch=batch,
+                               batch_ind=batch_ind,
+                               infer_mode=infer_mode,
+                               handle_batch_func=handle_batch_func,
                                schema=schema,
+                               event_loop=event_loop,
                                **kwargs)
-                  for batch in BatchIterator(prompts_it, batch_size=batch_size))
+                  for batch_ind, batch in enumerate(BatchIterator(prompts_it, batch_size=batch_size)))
 
     yield from chain.from_iterable(content_it)
-
-
-def init_llm(adapter, **model_kwargs):
-    """ This method perform dynamic initialization of LLM from third-party resource.
-    """
-    assert (isinstance(adapter, str))
-
-    # List of the Supported models and their API wrappers.
-    models_preset = {
-        "dynamic": lambda: dynamic_init(class_dir=CWD, class_filepath=llm_model_name,
-                                        class_name=llm_model_params)(**model_kwargs)
-    }
-
-    # Initialize LLM model.
-    params = adapter.split(':')
-    llm_model_type = params[0]
-    llm_model_name = params[1] if len(params) > 1 else params[-1]
-    llm_model_params = ':'.join(params[2:]) if len(params) > 2 else None
-    llm = find_by_prefix(d=models_preset, key=llm_model_type)()
-
-    return llm, llm_model_name

bulk_chain/core/llm_base.py

@@ -1,50 +1,29 @@
-import logging
-import time
-
-
 class BaseLM(object):
 
-    def __init__(self, name=None, attempts=None, delay_sec=1, enable_log=True,
-                 support_batching=False, **kwargs):
-
-        self.__name = name
-        self.__attempts = 1 if attempts is None else attempts
-        self.__delay_sec = delay_sec
-        self.__support_batching = support_batching
-
-        if enable_log:
-            self.__logger = logging.getLogger(__name__)
-            logging.basicConfig(level=logging.INFO)
-
-    def ask_core(self, batch):
-
-        for i in range(self.__attempts):
-            try:
-                if self.__support_batching:
-                    # Launch in batch mode.
-                    content = batch
-                else:
-                    # Launch in non-batch mode.
-                    assert len(batch) == 1, "The LM does not support batching," \
-                                            f" while size of the content is {len(batch)} which is not equal 1. " \
-                                            f"Please enable batch-supporting or set required inference settings."
-                    content = batch[0]
+    def __init__(self, **kwargs):
+        pass
 
-                response = self.ask(content)
-
-                # Wrapping into batch the response in the case of non-batching mode.
-                return response if self.__support_batching else [response]
+    def ask(self, prompt):
+        """ Assumes to return str.
+        """
+        raise NotImplemented()
 
-            except Exception as e:
-                if self.__logger is not None:
-                    self.__logger.info("Unable to infer the result. Try {} out of {}.".format(i, self.__attempts))
-                    self.__logger.info(e)
-                time.sleep(self.__delay_sec)
+    def ask_batch(self, batch):
+        """ Assumes to return generator.
+        """
+        raise NotImplemented()
 
-        raise Exception("Can't infer")
+    def ask_stream(self, prompt):
+        """ Assumes to return generator.
+        """
+        raise NotImplemented()
 
-    def ask(self, content):
+    async def ask_async(self, prompt):
+        """ Assumes to return co-routine.
+        """
         raise NotImplemented()
 
-    def name(self):
-        return self.__name.replace("/", "_")
+    async def ask_stream_async(self, prompt):
+        """ Assumes to return AsyncGenerator.
+        """
+        raise NotImplemented()

bulk_chain/core/service_asyncio.py

@@ -0,0 +1,65 @@
+import asyncio
+from typing import AsyncGenerator, Any
+
+
+class AsyncioService:
+
+    @staticmethod
+    async def _run_tasks_async(batch, async_handler):
+        tasks = [async_handler(prompt) for prompt in batch]
+        return await asyncio.gather(*tasks)
+
+    @staticmethod
+    async def _run_generator(gen, output_queue, idx):
+        try:
+            async for item in gen:
+                await output_queue.put((idx, item))
+        finally:
+            await output_queue.put((idx, StopAsyncIteration))
+
+
+    @staticmethod
+    def run_tasks(event_loop, **tasks_kwargs):
+        return event_loop.run_until_complete(AsyncioService._run_tasks_async(**tasks_kwargs))
+
+    @staticmethod
+    async def merge_generators(*gens: AsyncGenerator[Any, None]) -> AsyncGenerator[Any, None]:
+
+        output_queue = asyncio.Queue()
+        tasks = [
+            asyncio.create_task(AsyncioService._run_generator(gen, output_queue, idx))
+            for idx, gen in enumerate(gens)
+        ]
+
+        finished = set()
+        while len(finished) < len(tasks):
+            idx, item = await output_queue.get()
+            if item is StopAsyncIteration:
+                finished.add(idx)
+            else:
+                yield item
+
+        for task in tasks:
+            task.cancel()
+
+    @staticmethod
+    def async_gen_to_iter(gen, loop=None):
+        """ This approach is limited. Could be considered as legacy.
+            https://stackoverflow.com/questions/71580727/translating-async-generator-into-sync-one/78573267#78573267
+        """
+
+        loop_created = False
+        if loop is None:
+            loop_created = True
+            loop = asyncio.new_event_loop()
+
+        asyncio.set_event_loop(loop)
+        try:
+            while True:
+                try:
+                    yield loop.run_until_complete(gen.__anext__())
+                except StopAsyncIteration:
+                    break
+        finally:
+            if loop_created:
+                loop.close()

bulk_chain/core/service_batch.py

@@ -1,8 +1,8 @@
 class BatchIterator:
 
     def __init__(self, data_iter, batch_size, end_value=None, filter_func=None):
-        assert(isinstance(batch_size, int) and batch_size > 0)
-        assert(callable(end_value) or end_value is None)
+        assert (isinstance(batch_size, int) and batch_size > 0)
+        assert (callable(end_value) or end_value is None)
         self.__data_iter = data_iter
         self.__index = 0
         self.__batch_size = batch_size

bulk_chain/core/service_schema.py

@@ -9,6 +9,10 @@ class SchemaService(object):
         prompt_schema = {"schema": [{"prompt": prompt, "out": "response", "in": "prompt"}]}
         return cls(prompt_schema)
 
+    @staticmethod
+    def col_to_prompt(col_name, prompt_data):
+        return col_name + "_prompt" if "in" not in prompt_data else prompt_data["in"]
+
     @staticmethod
     def __init_schema(prompts):
 
@@ -19,7 +23,7 @@ class SchemaService(object):
 
         for prompt in prompts:
             r_col_name = prompt["out"]
-            p_col_name = r_col_name + "_prompt" if "in" not in prompt else prompt["in"]
+            p_col_name = SchemaService.col_to_prompt(col_name=r_col_name, prompt_data=prompt)
 
             assert r_col_name not in schema_r2p, f"`{r_col_name}` has been already declared!"
             assert p_col_name not in schema_p2r, f"`{p_col_name}` has been already declared!"

bulk_chain/core/utils.py

@@ -1,6 +1,8 @@
+import ast
 import importlib
 import logging
 import sys
+import time
 from collections import Counter
 from os.path import dirname, join, basename
 
@@ -34,18 +36,30 @@ def find_by_prefix(d, key):
     return d[matches[0]]
 
 
+def check_is_param_name(param_name):
+    return param_name.replace("_", "").isalpha()
+
+
 def iter_params(text):
     assert(isinstance(text, str))
     beg = 0
     while beg < len(text):
+        print(beg)
         try:
             pb = text.index('{', beg)
         except ValueError:
             break
-        pe = text.index('}', beg+1)
-        # Yield argument.
-        yield text[pb+1:pe]
-        beg = pe+1
+        pe = text.index('}', pb+1)
+        param_name = text[pb + 1:pe]
+
+        # Check parameter validity.
+        if not check_is_param_name(param_name):
+            beg = pb + 1
+            continue
+
+        # Passing.
+        yield param_name
+        beg = pe + 1
 
 
 def auto_import(name, is_class=False):
@@ -60,10 +74,21 @@ def auto_import(name, is_class=False):
     return m() if is_class else m
 
 
-def dynamic_init(class_dir, class_filepath, class_name=None):
+def get_class_name(file_path):
+    with open(file_path, 'r') as f:
+        tree = ast.parse(f.read(), filename=file_path)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            return node.name
+
+    return None
+
+
+def dynamic_init(class_filepath, class_name=None):
 
     # Registering path.
-    target = join(class_dir, dirname(class_filepath))
+    target = join(dirname(class_filepath))
     logger.info(f"Adding sys path for `{target}`")
     sys.path.insert(1, target)
     class_path_list = class_filepath.split('/')
@@ -74,7 +99,7 @@ def dynamic_init(class_dir, class_filepath, class_name=None):
         class_filename = class_filename[:-len(".py")]
 
     # Loading library.
-    class_name = class_path_list[-1].title() if class_name is None else class_name
+    class_name = get_class_name(class_filepath) if class_name is None else class_name
     class_path = ".".join([class_filename, class_name])
     logger.info(f"Dynamic loading for the file and class `{class_path}`")
     cls = auto_import(class_path, is_class=False)
@@ -89,3 +114,21 @@ def optional_limit_iter(it_data, limit=None):
         if limit is not None and counter["returned"] > limit:
             break
         yield data
+
+
+def attempt_wrapper(attempts, delay_sec=1, logger=None):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            for i in range(attempts):
+                try:
+                    # Do action.
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    if logger is not None:
+                        logger.info(f"Unable to infer the result. Try {i} out of {attempts}.")
+                        logger.info(e)
+                    if delay_sec is not None:
+                        time.sleep(delay_sec)
+            raise Exception(f"Failed after {attempts} attempts")
+        return wrapper
+    return decorator

bulk_chain-1.2.1.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: bulk-chain
+Version: 1.2.1
+Summary: A lightweight, no-strings-attached Chain-of-Thought framework for your LLM, ensuring reliable results for bulk input requests.
+Home-page: https://github.com/nicolay-r/bulk-chain
+Author: Nicolay Rusnachenko
+Author-email: rusnicolay@gmail.com
+License: MIT License
+Keywords: natural language processing,chain-of-thought,reasoning
+Platform: UNKNOWN
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# bulk-chain 1.2.1
+![](https://img.shields.io/badge/Python-3.9-brightgreen.svg)
+[![](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/nicolay-r/bulk-chain/blob/master/bulk_chain_tutorial.ipynb)
+[![twitter](https://img.shields.io/twitter/url/https/shields.io.svg?style=social)](https://x.com/nicolayr_/status/1847969224636961033)
+[![PyPI downloads](https://img.shields.io/pypi/dm/bulk-chain.svg)](https://pypistats.org/packages/bulk-chain)
+
+<p align="center">
+    <img src="logo.png"/>
+</p>
+
+<p align="center">
+  <a href="https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm"><b>Third-party providers hosting</b>↗️</a>
+  <br>
+  <a href="https://github.com/nicolay-r/bulk-chain-shell">👉<b>demo</b>👈</a>
+</p>
+
+A no-strings-attached **framework**  for your LLM that allows applying Chain-of-Thought-alike [prompt `schema`](#chain-of-thought-schema) towards a massive textual collections using custom **[third-party providers ↗️](https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm)**.
+
+### Main Features
+* ✅ **No-strings**: you're free to LLM dependencies and flexible `venv` customization.
+* ✅ **Support schemas descriptions** for Chain-of-Thought concept.
+* ✅ **Provides iterator over infinite amount of input contexts**
+
+# Installation
+
+From PyPI: 
+
+```bash
+pip install --no-deps bulk-chain
+```
+
+or latest version from here:
+
+```bash
+pip install git+https://github.com/nicolay-r/bulk-chain@master
+```
+
+## Chain-of-Thought Schema
+
+To declare Chain-of-Though (CoT) schema we use `JSON` format. 
+The field `schema` is a list of CoT instructions for the Large Language Model.
+Each item of the list represent a dictionary with `prompt` and `out` keys that corresponds to the input prompt and output variable name respectively.
+All the variable names should be mentioned in `{}`.
+
+**Example**:
+```python
+[
+  {"prompt": "extract topic: {text}", "out": "topic"},
+  {"prompt": "extract subject: {text}", "out": "subject"},
+]
+```
+
+# Usage
+
+## 🤖 Prepare 
+
+1. [schema](#chain-of-thought-schema)
+    * [Example for Sentiment Analysis](test/schema/thor_cot_schema.json)
+2. **LLM model** from the [<b>Third-party providers hosting</b>↗️](https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm).
+3. Data (iter of dictionaries)
+
+## 🚀 Launch
+
+> **API**: For more details see the [**related Wiki page**](https://github.com/nicolay-r/bulk-chain/wiki)
+
+```python
+from bulk_chain.core.utils import dynamic_init
+from bulk_chain.api import iter_content
+
+content_it = iter_content(
+    # 1. Your schema.              
+    schema=[
+      {"prompt": "extract topic: {text}", "out": "topic" },
+      {"prompt": "extract subject: {text}", "out": "subject"},
+    ],
+    # 2. Your third-party model implementation.
+    llm=dynamic_init(class_filepath="replicate_104.py")(
+       api_token="<API-KEY>",
+       model_name="meta/meta-llama-3-70b-instruct"),
+    # 3. Toggle streaming if needed
+    stream=False,
+    # 4. Toggle Async API mode usage.
+    async_mode=True,
+    # 5. Batch size.
+    batch_size=10,
+    # 6. Your iterator of dictionaries
+    input_dicts_it=[
+        # Example of data ...
+        { "text": "Rocks are hard" },
+        { "text": "Water is wet" },
+        { "text": "Fire is hot" }
+    ],
+)
+
+for batch in content_it:
+   for entry in batch:
+      print(entry)
+```
+
+Outputs entries represent texts augmented with `topic` and `subject`:
+```jsonl
+{'text': 'Rocks are hard', 'topic': 'The topic is: Geology/Rocks', 'subject': 'The subject is: "Rocks"'}
+{'text': 'Water is wet', 'topic': 'The topic is: Properties of Water', 'subject': 'The subject is: Water'}
+{'text': 'Fire is hot', 'topic': 'The topic is: Temperature/Properties of Fire', 'subject': 'The subject is: "Fire"'}
+```
+
+# API
+
+| Method               | Mode       | Description                                                         |
+|----------------------|------------|---------------------------------------------------------------------|
+| `ask(prompt)`        | Sync       | Infers the model with a single prompt.                              |
+| `ask_stream(prompt)` | Sync       | Returns a generator that yields chunks of the inferred result.      |
+| `ask_async(prompt)`  | Async      | Asynchronously infers the model with a single prompt.               |
+| `ask_stream_async(prompt)` | Async | Asynchronously returns a generator of result chunks of the inferred result.          |
+
+See examples with models [at nlp-thirdgate 🌌](https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm).
+
+

bulk_chain-1.2.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+bulk_chain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bulk_chain/api.py,sha256=bLZXdp58i6LDayZQxRBxsFK4lVT8cZZn1uOY0iaZ5TE,8500
+bulk_chain/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bulk_chain/core/llm_base.py,sha256=H2KmCqChKp9sKOkROE-4zjMRCxizT9xWvNZSF22HeFU,673
+bulk_chain/core/service_asyncio.py,sha256=S-D4K3LBa3noKTm0tXazluYVI8cBgN1IB6v6MFoMyNQ,1972
+bulk_chain/core/service_batch.py,sha256=lWmjO0aU6h2rmfx_kGmNqt0Rdeaf2a4Dn5VyfKFkfDs,1033
+bulk_chain/core/service_data.py,sha256=OWWHHnr_plwxYTxLuvMrhEc1PbSx-XC3rbFzV0hy3vk,1107
+bulk_chain/core/service_dict.py,sha256=lAghLU-3V3xYGv5BTA327Qcw8UJYmgQRMFdggzlrUgo,383
+bulk_chain/core/service_json.py,sha256=6o1xM_8c9QEjH9Q3qEmJylU9nahfRXhUd5sFF2dGJwo,182
+bulk_chain/core/service_schema.py,sha256=YAsdm3N2G4-eTpeJazg4Y-KQ2w9bEPpqreVl8a-M7H0,1311
+bulk_chain/core/utils.py,sha256=hml0zLmnZe865gvc1CagEzRE19Gdh1pF8kx_KueDY3A,3667
+bulk_chain-1.2.1.dist-info/LICENSE,sha256=VF9SjNpwwSSFEY_eP_8A1ocDCrbwfjI1pZexXdCkOwo,1076
+bulk_chain-1.2.1.dist-info/METADATA,sha256=xx1vcG6wkHzh_Ga3iZJV3MBdR97RBGpCf7JO5_lonN0,5339
+bulk_chain-1.2.1.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+bulk_chain-1.2.1.dist-info/top_level.txt,sha256=Hxq_wyH-GDXKBaA63UfBIiMJO2eCHJG5EOrXDphpeB4,11
+bulk_chain-1.2.1.dist-info/RECORD,,

{bulk_chain-1.0.0.dist-info → bulk_chain-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.3)
+Generator: bdist_wheel (0.34.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bulk_chain-1.0.0.dist-info/METADATA

@@ -1,99 +0,0 @@
-Metadata-Version: 2.1
-Name: bulk_chain
-Version: 1.0.0
-Summary: A lightweight, no-strings-attached Chain-of-Thought framework for your LLM, ensuring reliable results for bulk input requests.
-Home-page: https://github.com/nicolay-r/bulk-chain
-Author: Nicolay Rusnachenko
-Author-email: rusnicolay@gmail.com
-License: MIT License
-Keywords: natural language processing,chain-of-thought,reasoning
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Topic :: Text Processing :: Linguistic
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: tqdm
-
-# bulk-chain 1.0.0
-![](https://img.shields.io/badge/Python-3.9-brightgreen.svg)
-[![](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/nicolay-r/bulk-chain/blob/master/bulk_chain_tutorial.ipynb)
-[![twitter](https://img.shields.io/twitter/url/https/shields.io.svg?style=social)](https://x.com/nicolayr_/status/1847969224636961033)
-[![PyPI downloads](https://img.shields.io/pypi/dm/bulk-chain.svg)](https://pypistats.org/packages/bulk-chain)
-
-<p align="center">
-    <img src="logo.png"/>
-</p>
-
-<p align="center">
-  <a href="https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm"><b>Third-party providers hosting</b>↗️</a>
-  <br>
-  <a href="https://github.com/nicolay-r/bulk-chain-shell">👉<b>demo</b>👈</a>
-</p>
-
-A no-strings-attached **framework**  for your LLM that allows applying Chain-of-Thought-alike [prompt `schema`](#chain-of-thought-schema) towards a massive textual collections using custom **[third-party providers ↗️](https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm)**.
-
-### Main Features
-* ✅ **No-strings**: you're free to LLM dependencies and flexible `venv` customization.
-* ✅ **Support schemas descriptions** for Chain-of-Thought concept.
-* ✅ **Provides iterator over infinite amount of input contexts**
-
-# Installation
-
-From PyPI: 
-
-```bash
-pip install --no-deps bulk-chain
-```
-
-or latest version from here:
-
-```bash
-pip install git+https://github.com/nicolay-r/bulk-chain@master
-```
-
-## Chain-of-Thought Schema
-
-To declare Chain-of-Though (CoT) schema, this project exploits `JSON` format.
-This format adopts `name` field for declaring a name and `schema` is a list of CoT instructions for the Large Language Model.
-
-Each step represents a dictionary with `prompt` and `out` keys that corresponds to the input prompt and output variable name respectively.
-All the variable names are expected to be mentioned in `{}`.
-
-Below, is an example on how to declare your own schema:
-
-```python
-{
-"name": "schema-name",
-"schema": [
-    {"prompt": "Given the question '{text}', let's think step-by-step.", 
-     "out": "steps"},
-    {"prompt": "For the question '{text}' the reasoining steps are '{steps}'. what would be an answer?", 
-     "out":  "answer"},
-]
-}
-```
-
-# Usage
-
-Preliminary steps:
-
-1. Define your [schema](#chain-of-thought-schema) ([Example for Sentiment Analysis](/ext/schema/thor_cot_schema.json)))
-2. Wrap or pick **LLM model** from the [<b>Third-party providers hosting</b>↗️](https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm).
-
-
-
-## API
-
-Please take a look at the [**related Wiki page**](https://github.com/nicolay-r/bulk-chain/wiki)
-
-
-# Embed your LLM
-
-All you have to do is to implement `BaseLM` class, that includes:
-* `__init__` -- for setting up *batching mode support* and (optional) *model name*;
-* `ask(prompt)` -- infer your model with the given `prompt`.
-
-See examples with models [at nlp-thirdgate 🌌](https://github.com/nicolay-r/nlp-thirdgate?tab=readme-ov-file#llm).

bulk_chain-1.0.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-bulk_chain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bulk_chain/api.py,sha256=d_c10Je8wUSnCdQjyWCHVx4FGW6M2_pBMMqKsI_YJaY,5119
-bulk_chain/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bulk_chain/core/llm_base.py,sha256=DZ9l4HpCs9uKTZp68miw_XCqmRAJBqQPuYSK889CeUk,1785
-bulk_chain/core/service_batch.py,sha256=LMxrZeQXV_AJAoCaMCHVx8TvjcmCaKUQhNE8K4D8pCo,1031
-bulk_chain/core/service_data.py,sha256=OWWHHnr_plwxYTxLuvMrhEc1PbSx-XC3rbFzV0hy3vk,1107
-bulk_chain/core/service_dict.py,sha256=lAghLU-3V3xYGv5BTA327Qcw8UJYmgQRMFdggzlrUgo,383
-bulk_chain/core/service_json.py,sha256=6o1xM_8c9QEjH9Q3qEmJylU9nahfRXhUd5sFF2dGJwo,182
-bulk_chain/core/service_schema.py,sha256=KIP4n0Tz2h1i7SIMGhgAhoiCgUFXOT1rzMt38yACS2U,1154
-bulk_chain/core/utils.py,sha256=Dx9Gy-jPpk-w_8WUekN0Ij4RBIWVAPg74vA3N0JgGqc,2471
-bulk_chain-1.0.0.dist-info/LICENSE,sha256=VF9SjNpwwSSFEY_eP_8A1ocDCrbwfjI1pZexXdCkOwo,1076
-bulk_chain-1.0.0.dist-info/METADATA,sha256=TR86CmhcHJ3Sep8TlHZ0Ede_PnH8G5iMILUvVvSskJY,3810
-bulk_chain-1.0.0.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
-bulk_chain-1.0.0.dist-info/top_level.txt,sha256=Hxq_wyH-GDXKBaA63UfBIiMJO2eCHJG5EOrXDphpeB4,11
-bulk_chain-1.0.0.dist-info/RECORD,,