bulk-chain 0.25.2__tar.gz → 0.25.3__tar.gz

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bulk_chain
-Version: 0.25.2
+Version: 0.25.3
 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
@@ -18,7 +18,7 @@ License-File: LICENSE
 Requires-Dist: tqdm
 Requires-Dist: source-iter==0.24.3
 
-# bulk-chain 0.25.2
+# bulk-chain 0.25.3
 ![](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)

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/README.md

@@ -1,4 +1,4 @@
-# bulk-chain 0.25.2
+# bulk-chain 0.25.3
 ![](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)

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain/api.py

@@ -1,3 +1,4 @@
+import collections
 import os
 from itertools import chain
 
@@ -9,9 +10,8 @@ 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
 
+
 INFER_MODES = {
-    "default": lambda llm, prompt, limit_prompt=None: llm.ask_core(
-        prompt[:limit_prompt] if limit_prompt is not None else prompt),
     "batch": lambda llm, batch, limit_prompt=None: llm.ask_core(
         DataService.limit_prompts(batch, limit=limit_prompt))
 }
@@ -20,40 +20,67 @@ INFER_MODES = {
 CWD = os.getcwd()
 
 
-def _update_batch_content(c, batch, schema, infer_func):
+def _handle_entry(entry, entry_info=None, **kwargs):
+
+    if isinstance(entry, str):
+        kwargs.get("callback_str_func", lambda *_: None)(entry, entry_info)
+        return entry
+    elif isinstance(entry, collections.abc.Iterable):
+        chunks = []
+        h = kwargs.get("callback_stream_func", lambda *_: None)
+
+        h(None, entry_info | {"action": "start"})
+
+        for chunk in map(lambda item: str(item), entry):
+            chunks.append(chunk)
+            h(chunk, entry_info)
+
+        h(None, entry_info | {"action": "end"})
+
+        return "".join(chunks)
+
+    raise Exception(f"Non supported type `{type(entry)}` for handling output from batch")
+
+
+def _update_batch_content(c, batch, schema, **kwargs):
     assert (isinstance(batch, list))
     assert (isinstance(c, str))
 
     if c in schema.p2r:
         for batch_item in batch:
-            batch_item[c] = DataService.get_prompt_text(prompt=batch_item[c]["prompt"], data_dict=batch_item)
+            batch_item[c] = DataService.get_prompt_text(
+                prompt=batch_item[c]["prompt"],
+                data_dict=batch_item,
+                handle_missed_func=kwargs["handle_missed_value_func"])
     if c in schema.r2p:
         p_column = schema.r2p[c]
         # This instruction takes a lot of time in a non-batching mode.
-        BatchService.handle_param_as_batch(batch=batch,
-                                           src_param=p_column,
-                                           tgt_param=c,
-                                           handle_func=lambda b: infer_func(b))
+        BatchService.handle_param_as_batch(
+            batch=batch,
+            src_param=p_column,
+            tgt_param=c,
+            handle_batch_func=lambda b: kwargs["handle_batch_func"](b),
+            handle_entry_func=lambda entry, info: _handle_entry(entry=entry, entry_info=info, **kwargs)
+        )
 
 
-def _infer_batch(batch, schema, infer_func, cols=None):
+def _infer_batch(batch, schema, cols=None, **kwargs):
     assert (isinstance(batch, list))
-    assert (callable(infer_func))
 
     if len(batch) == 0:
         return batch
 
     if cols is None:
         first_item = batch[0]
-        cols = first_item.keys() if cols is None else cols
+        cols = list(first_item.keys()) if cols is None else cols
 
     for c in cols:
-        _update_batch_content(c=c, batch=batch, schema=schema, infer_func=infer_func)
+        _update_batch_content(c=c, batch=batch, schema=schema, **kwargs)
 
     return batch
 
 
-def iter_content(input_dicts_it, llm, schema, batch_size=1, return_batch=True, limit_prompt=None):
+def iter_content(input_dicts_it, llm, schema, batch_size=1, return_batch=True, limit_prompt=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`
@@ -72,8 +99,9 @@ def iter_content(input_dicts_it, llm, schema, batch_size=1, return_batch=True, l
     )
 
     content_it = (_infer_batch(batch=batch,
-                               infer_func=lambda batch: INFER_MODES["batch"](llm, batch, limit_prompt),
-                               schema=schema)
+                               handle_batch_func=lambda batch: INFER_MODES["batch"](llm, batch, limit_prompt),
+                               schema=schema,
+                               **kwargs)
                   for batch in BatchIterator(prompts_it, batch_size=batch_size))
 
     yield from content_it if return_batch else chain.from_iterable(content_it)
@@ -82,6 +110,7 @@ def iter_content(input_dicts_it, llm, schema, batch_size=1, return_batch=True, l
 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 = {

bulk_chain-0.25.3/bulk_chain/core/provider_sqlite.py

@@ -0,0 +1,127 @@
+import sqlite3
+
+
+class SQLite3Service(object):
+
+    @staticmethod
+    def __create_table(table_name, columns, id_column_name,
+                       id_column_type, cur, sqlite3_column_types=None):
+
+        # Setting up default column types.
+        if sqlite3_column_types is None:
+            types_count = len(columns) if id_column_name in columns else len(columns) - 1
+            sqlite3_column_types = ["TEXT"] * types_count
+
+        # Provide the ID column.
+        sqlite3_column_types = [id_column_type] + sqlite3_column_types
+
+        # Compose the whole columns list.
+        content = ", ".join([f"[{item[0]}] {item[1]}" for item in zip(columns, sqlite3_column_types)])
+        cur.execute(f"CREATE TABLE IF NOT EXISTS {table_name}({content})")
+        cur.execute(f"CREATE INDEX IF NOT EXISTS [{id_column_name}] ON {table_name}([{id_column_name}])")
+
+    @staticmethod
+    def __it_row_lists(cursor):
+        for row in cursor:
+            yield row
+
+    @staticmethod
+    def create_table_if_not_exist(**kwargs):
+        return SQLite3Service.__create_table(**kwargs)
+
+    @staticmethod
+    def entry_exist(table_name, target, id_column_name, id_value, **connect_kwargs) -> bool:
+        with sqlite3.connect(target, **connect_kwargs) as con:
+            cursor = con.cursor()
+
+            # Check table existance.
+            query = "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+            cursor.execute(query, (table_name,))
+            if cursor.fetchone() is None:
+                return False
+
+            # Check element.
+            r = cursor.execute(f"SELECT EXISTS(SELECT 1 FROM {table_name} WHERE [{id_column_name}]='{id_value}');")
+            ans = r.fetchone()[0]
+            return ans == 1
+
+    @staticmethod
+    def write(data_it, target, table_name, columns=None, id_column_name="id", data2col_func=None,
+              id_column_type="INTEGER", sqlite3_column_types=None, it_type='dict',
+              create_table_if_not_exist=True, skip_existed=True, **connect_kwargs):
+
+        need_set_column_id = True
+        need_initialize_columns = columns is None
+
+        # Setup default columns.
+        columns = [] if columns is None else columns
+
+        with sqlite3.connect(target, **connect_kwargs) as con:
+            cur = con.cursor()
+
+            for content in data_it:
+
+                if it_type == 'dict':
+                    # Extracting columns from data.
+                    data = content
+                    uid = data[id_column_name]
+                    row_columns = list(data.keys())
+                    row_params_func = lambda: [data2col_func(c, data) if data2col_func is not None else data[c]
+                                               for c in row_columns]
+                    # Append columns if needed.
+                    if need_initialize_columns:
+                        columns = list(row_columns)
+                elif it_type is None:
+                    # Setup row columns.
+                    uid, data = content
+                    row_columns = columns
+                    row_params_func = lambda: [uid] + data
+                else:
+                    raise Exception(f"it_type {it_type} does not supported!")
+
+                if need_set_column_id:
+                    # Register ID column.
+                    if id_column_name not in columns:
+                        columns.append(id_column_name)
+                    # Place ID column first.
+                    columns.insert(0, columns.pop(columns.index(id_column_name)))
+                    need_set_column_id = False
+
+                if create_table_if_not_exist:
+                    SQLite3Service.__create_table(
+                        columns=columns, table_name=table_name, cur=cur,
+                        id_column_name=id_column_name, id_column_type=id_column_type,
+                        sqlite3_column_types=sqlite3_column_types)
+
+                # Check that each rows satisfies criteria of the first row.
+                [Exception(f"{column} is expected to be in row!") for column in row_columns if column not in columns]
+
+                if skip_existed:
+                    r = cur.execute(f"SELECT EXISTS(SELECT 1 FROM {table_name} WHERE [{id_column_name}]='{uid}');")
+                    ans = r.fetchone()[0]
+
+                    if ans == 1:
+                        continue
+
+                params = ", ".join(tuple(['?'] * (len(columns))))
+                row_columns_str = ", ".join([f"[{col}]" for col in row_columns])
+                content_list = row_params_func()
+                cur.execute(f"INSERT INTO {table_name}({row_columns_str}) VALUES ({params})", content_list)
+                con.commit()
+
+            cur.close()
+
+    @staticmethod
+    def read(src, table="content", **connect_kwargs):
+        with sqlite3.connect(src, **connect_kwargs) as conn:
+            cursor = conn.cursor()
+            cursor.execute(f"SELECT * FROM {table}")
+            for record_list in SQLite3Service.__it_row_lists(cursor):
+                yield record_list
+
+    @staticmethod
+    def read_columns(target, table="content", **connect_kwargs):
+        with sqlite3.connect(target, **connect_kwargs) as conn:
+            cursor = conn.cursor()
+            cursor.execute(f"PRAGMA table_info({table})")
+            return [row[1] for row in cursor.fetchall()]

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain/core/service_batch.py

@@ -1,31 +1,32 @@
 class BatchService(object):
 
     @staticmethod
-    def handle_param_as_batch(batch, src_param, tgt_param, handle_func):
+    def handle_param_as_batch(batch, src_param, tgt_param, handle_batch_func, handle_entry_func):
         assert (isinstance(batch, list))
         assert (isinstance(src_param, str))
-        assert (callable(handle_func))
+        assert (callable(handle_batch_func))
 
         _batch = [item[src_param] for item in batch]
 
         # Do handling for the batch.
-        _handled_batch = handle_func(_batch)
+        _handled_batch = handle_batch_func(_batch)
         assert (isinstance(_handled_batch, list))
 
         # Apply changes.
         for i, item in enumerate(batch):
-            item[tgt_param] = _handled_batch[i]
+            item[tgt_param] = handle_entry_func(entry=_handled_batch[i], info={"ind": i, "param": tgt_param})
 
 
 class BatchIterator:
 
-    def __init__(self, data_iter, batch_size, end_value=None):
+    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)
         self.__data_iter = data_iter
         self.__index = 0
         self.__batch_size = batch_size
         self.__end_value = end_value
+        self.__filter_func = (lambda _: True) if filter_func is None else filter_func
 
     def __iter__(self):
         return self
@@ -37,7 +38,8 @@ class BatchIterator:
                 data = next(self.__data_iter)
             except StopIteration:
                 break
-            buffer.append(data)
+            if self.__filter_func(data):
+                buffer.append(data)
             if len(buffer) == self.__batch_size:
                 break
 

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain/core/service_data.py

@@ -4,8 +4,8 @@ from bulk_chain.core.utils import iter_params
 class DataService(object):
 
     @staticmethod
-    def compose_prompt_text(prompt, data_dict, field_names):
-        assert(isinstance(data_dict, dict))
+    def __compose_prompt_text(prompt, data_dict, field_names):
+        assert (isinstance(data_dict, dict))
         fmt_d = {col_name: data_dict[col_name] for col_name in field_names}
 
         # Guarantee that items has correct type.
@@ -16,10 +16,14 @@ class DataService(object):
         return prompt.format(**fmt_d)
 
     @staticmethod
-    def get_prompt_text(prompt, data_dict, parse_fields_func=iter_params):
+    def get_prompt_text(prompt, data_dict, parse_fields_func=iter_params, handle_missed_func=None):
         field_names = list(parse_fields_func(prompt))
-        return DataService.compose_prompt_text(
-            prompt=prompt, data_dict=data_dict, field_names=field_names)
+
+        for col_name in field_names:
+            if col_name not in data_dict:
+                data_dict[col_name] = handle_missed_func(col_name)
+
+        return DataService.__compose_prompt_text(prompt=prompt, data_dict=data_dict, field_names=field_names)
 
     @staticmethod
     def limit_prompts(prompts_list, limit=None):

bulk_chain-0.25.3/bulk_chain/core/service_llm.py

@@ -0,0 +1,68 @@
+from bulk_chain.api import iter_content
+from bulk_chain.core.llm_base import BaseLM
+from bulk_chain.core.utils_logger import StreamedLogger
+
+
+def pad_str(text, pad):
+    return text.rjust(len(text) + pad, ' ')
+
+
+def nice_output(text, remove_new_line=False):
+    short_text = text.replace("\n", "") if remove_new_line else text
+    return short_text
+
+
+def chat_with_lm(lm, preset_dict=None, schema=None, model_name=None, pad=0):
+    assert (isinstance(lm, BaseLM))
+    assert (isinstance(model_name, str) or model_name is None)
+
+    preset_dict = {} if preset_dict is None else preset_dict
+
+    streamed_logger = StreamedLogger(__name__)
+    do_exit = False
+    model_name = model_name if model_name is not None else "agent"
+
+    while not do_exit:
+
+        # Launching the CoT engine loop.
+        data_dict = {} | preset_dict
+
+        def callback_str_func(entry, info):
+            streamed_logger.info(pad_str(f"{model_name} ({info['param']})->\n", pad=pad))
+            streamed_logger.info(nice_output(entry, remove_new_line=False))
+            streamed_logger.info("\n\n")
+
+        def handle_missed_value(col_name):
+            user_input = input(f"Enter your prompt for `{col_name}`"
+                               f"(or 'exit' to quit): ")
+
+            if user_input.lower() == 'exit':
+                exit(0)
+
+            return user_input
+
+        def callback_stream_func(entry, info):
+            if entry is None and info["action"] == "start":
+                streamed_logger.info(pad_str(f"{model_name} ({info['param']})->\n", pad=pad))
+                return
+            if entry is None and info["action"] == "end":
+                streamed_logger.info("\n\n")
+                return
+
+            streamed_logger.info(entry)
+
+        content_it = iter_content(
+            input_dicts_it=[data_dict],
+            llm=lm,
+            schema=schema,
+            batch_size=1,
+            return_batch=True,
+            handle_missed_value_func=handle_missed_value,
+            callback_str_func=callback_str_func,
+            callback_stream_func=callback_stream_func,
+        )
+
+        for _ in content_it:
+            user_input = input(f"Enter to continue (or 'exit' to quit) ...\n")
+            if user_input.lower() == 'exit':
+                do_exit = True

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain/core/utils.py

@@ -2,6 +2,7 @@ import importlib
 import logging
 import sys
 from collections import Counter
+from os.path import dirname, join, basename
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
@@ -82,13 +83,24 @@ def auto_import(name, is_class=False):
 
 
 def dynamic_init(class_dir, class_filepath, class_name=None):
-    sys.path.append(class_dir)
+
+    # Registering path.
+    target = join(class_dir, dirname(class_filepath))
+    logger.info(f"Adding sys path for `{target}`")
+    sys.path.insert(1, target)
     class_path_list = class_filepath.split('/')
-    class_path_list[-1] = '.'.join(class_path_list[-1].split('.')[:-1])
+
+    # Composing proper class name.
+    class_filename = basename(class_path_list[-1])
+    if class_filename.endswith(".py"):
+        class_filename = class_filename[:-len(".py")]
+
+    # Loading library.
     class_name = class_path_list[-1].title() if class_name is None else class_name
-    class_path = ".".join(class_path_list + [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)
+
     return cls
 
 

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain/demo.py

@@ -81,4 +81,4 @@ if __name__ == '__main__':
             preset_dict[key] = value
 
     # Launch Demo.
-    chat_with_lm(llm, preset_dict=preset_dict, chain=schema.chain, model_name=llm_model_name)
+    chat_with_lm(llm, preset_dict=preset_dict, schema=schema, model_name=llm_model_name)

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain/infer.py

@@ -1,3 +1,4 @@
+from itertools import chain
 from os.path import join, basename
 
 import argparse
@@ -6,12 +7,13 @@ import sys
 
 from source_iter.service_csv import CsvService
 from source_iter.service_jsonl import JsonlService
-from source_iter.service_sqlite import SQLite3Service
 from tqdm import tqdm
 
 from bulk_chain.api import INFER_MODES, _infer_batch, CWD, init_llm
 from bulk_chain.core.llm_base import BaseLM
+from bulk_chain.core.provider_sqlite import SQLite3Service
 from bulk_chain.core.service_args import CmdArgsService
+from bulk_chain.core.service_batch import BatchIterator
 from bulk_chain.core.service_dict import DictionaryService
 from bulk_chain.core.service_json import JsonService
 from bulk_chain.core.service_schema import SchemaService
@@ -21,9 +23,8 @@ logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
 
 WRITER_PROVIDERS = {
-    "sqlite": lambda filepath, table_name, data_it, infer_data_func, **kwargs: SQLite3Service.write(
-        data_it=data_it, target=filepath, table_name=table_name, data2col_func=infer_data_func,
-        skip_existed=True, **kwargs)
+    "sqlite": lambda filepath, table_name, data_it, **kwargs: SQLite3Service.write(
+        data_it=data_it, target=filepath, table_name=table_name, skip_existed=True, **kwargs)
 }
 
 READER_PROVIDERS = {
@@ -31,7 +32,19 @@ READER_PROVIDERS = {
 }
 
 
-def iter_content_cached(input_dicts_it, llm, schema, cache_target, limit_prompt=None, **cache_kwargs):
+def infer_batch(batch, columns=None, **kwargs):
+    assert (len(batch) > 0)
+    # TODO. Support proper selection of columns.
+    cols = batch[0].keys() if columns is None else columns
+    return _infer_batch(batch=batch, cols=cols, **kwargs)
+
+
+def raise_(ex):
+    raise ex
+
+
+def iter_content_cached(input_dicts_it, llm, schema, cache_target, batch_size, id_column_name, limit_prompt=None,
+                        **cache_kwargs):
     assert (isinstance(llm, BaseLM))
     assert (isinstance(cache_target, str))
 
@@ -41,23 +54,40 @@ def iter_content_cached(input_dicts_it, llm, schema, cache_target, limit_prompt=
     if isinstance(schema, dict):
         schema = SchemaService(json_data=schema)
 
+    # Parse target.
+    cache_filepath, _, cache_table = parse_filepath(filepath=cache_target)
+
     # Iterator of the queries.
     prompts_it = map(
         lambda data: DictionaryService.custom_update(src_dict=data, other_dict=schema.cot_args),
         input_dicts_it
     )
 
-    # Parse target.
-    cache_filepath, _, cache_table = parse_filepath(filepath=cache_target)
+    prompts_batched_it = BatchIterator(
+        data_iter=iter(tqdm(prompts_it, desc="Iter Content")),
+        batch_size=batch_size,
+        filter_func=lambda data: not SQLite3Service.entry_exist(
+            id_column_name=id_column_name, table_name=cache_table, target=cache_filepath,
+            id_value=data[id_column_name], **cache_kwargs)
+    )
+
+    results_it = map(
+        lambda batch: infer_batch(
+            batch=batch, schema=schema,
+            handle_batch_func=lambda batch: INFER_MODES["batch"](llm, batch, limit_prompt),
+            handle_missed_value_func=lambda col_name: raise_(
+                Exception(f"Value for {col_name} is undefined. Filling undefined values is not supported")
+            )
+        ),
+        prompts_batched_it
+    )
 
     # Perform caching first.
     WRITER_PROVIDERS["sqlite"](
-        filepath=cache_filepath, table_name=cache_table,
-        data_it=tqdm(prompts_it, desc="Iter content"),
-        infer_data_func=lambda c, prompt: _infer_batch(
-            batch=[prompt], cols=[c],
-            infer_func=lambda batch: INFER_MODES["default"](llm, batch, limit_prompt),
-            schema=schema)[0][c],
+        filepath=cache_filepath,
+        table_name=cache_table,
+        data_it=chain.from_iterable(results_it),
+        id_column_name=id_column_name,
         **cache_kwargs)
 
     # Then retrieve data.
@@ -76,6 +106,7 @@ if __name__ == '__main__':
     parser.add_argument('--output', dest='output', type=str, default=None)
     parser.add_argument('--limit', dest='limit', type=int, default=None,
                         help="Limit amount of source texts for prompting.")
+    parser.add_argument('--batch-size', dest='batch_size', type=int, default=1)
     parser.add_argument('--limit-prompt', dest="limit_prompt", type=int, default=None,
                         help="Optional trimming prompt by the specified amount of characters.")
 
@@ -89,7 +120,7 @@ if __name__ == '__main__':
 
     # Extract model-related arguments and Initialize Large Language Model.
     model_args = CmdArgsService.find_grouped_args(lst=sys.argv, starts_with="%%m", end_prefix="%%")
-    model_args_dict = CmdArgsService.args_to_dict(model_args) | {"attempts": args.attempts}
+    model_args_dict = CmdArgsService.args_to_dict(model_args) | {"attempts": 1}
     llm, llm_model_name = init_llm(adapter=args.adapter, **model_args_dict)
 
     # Setup schema.
@@ -148,6 +179,7 @@ if __name__ == '__main__':
                                   limit_prompt=args.limit_prompt,
                                   schema=schema,
                                   llm=llm,
+                                  batch_size=args.batch_size,
                                   id_column_name=args.id_col,
                                   cache_target=":".join([cache_filepath, cache_table]))
 

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bulk_chain
-Version: 0.25.2
+Version: 0.25.3
 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
@@ -18,7 +18,7 @@ License-File: LICENSE
 Requires-Dist: tqdm
 Requires-Dist: source-iter==0.24.3
 
-# bulk-chain 0.25.2
+# bulk-chain 0.25.3
 ![](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)

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/bulk_chain.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ bulk_chain.egg-info/requires.txt
 bulk_chain.egg-info/top_level.txt
 bulk_chain/core/__init__.py
 bulk_chain/core/llm_base.py
+bulk_chain/core/provider_sqlite.py
 bulk_chain/core/service_args.py
 bulk_chain/core/service_batch.py
 bulk_chain/core/service_data.py
@@ -23,6 +24,7 @@ bulk_chain/core/utils.py
 bulk_chain/core/utils_logger.py
 test/test.py
 test/test_api.py
+test/test_api_streaming.py
 test/test_args_seeking.py
 test/test_cmdargs.py
 test/test_provider_batching.py

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/setup.py

@@ -15,7 +15,7 @@ def get_requirements(filenames):
 
 setup(
     name='bulk_chain',
-    version='0.25.2',
+    version='0.25.3',
     python_requires=">=3.6",
     description='A lightweight, no-strings-attached Chain-of-Thought framework for your LLM, '
                 'ensuring reliable results for bulk input requests.',

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/test/test_api.py

@@ -4,13 +4,14 @@ from os.path import join
 from bulk_chain.api import iter_content, CWD
 from bulk_chain.core.utils import dynamic_init
 from bulk_chain.infer import iter_content_cached
+from utils import current_dir, API_TOKEN
 
 
 class TestAPI(unittest.TestCase):
 
     llm = dynamic_init(class_dir=join(CWD, ".."),
                        class_filepath="providers/replicate_104.py",
-                       class_name="Replicate")(api_token="<API-KEY>",
+                       class_name="Replicate")(api_token=API_TOKEN,
                                                model_name="deepseek-ai/deepseek-r1")
 
     def it_data(self, n):
@@ -20,7 +21,8 @@ class TestAPI(unittest.TestCase):
     def test_iter_cached(self):
         data_it = iter_content_cached(input_dicts_it=self.it_data(20),
                                       llm=self.llm,
-                                      schema="../schema/default.json",
+                                      batch_size=1,
+                                      schema=join(current_dir, "schema/default.json"),
                                       # Cache-related extra parameters.
                                       cache_target="out.sqlite:content",
                                       id_column_name="ind")
@@ -33,7 +35,8 @@ class TestAPI(unittest.TestCase):
                                llm=self.llm,
                                batch_size=1,
                                return_batch=True,
-                               schema="../schema/default.json")
+                               handle_missed_value_func=lambda *_: None,
+                               schema=join(current_dir, "schema/default.json"))
 
         for data in data_it:
             print(data)

bulk_chain-0.25.3/test/test_api_streaming.py

@@ -0,0 +1,42 @@
+import unittest
+from os.path import join
+
+from tqdm import tqdm
+
+from bulk_chain.api import CWD, iter_content
+from bulk_chain.core.utils import dynamic_init
+from bulk_chain.core.utils_logger import StreamedLogger
+from utils import API_TOKEN, iter_test_jsonl_samples
+
+
+class TestAPI_Streaming(unittest.TestCase):
+
+    llm = dynamic_init(class_dir=join(CWD, ".."),
+                       class_filepath="providers/replicate_104.py",
+                       class_name="Replicate")(api_token=API_TOKEN,
+                                               model_name="meta/meta-llama-3-70b-instruct",
+                                               stream=True)
+
+    def test_iter(self):
+
+        streamed_logger = StreamedLogger(__name__)
+
+        def callback(chunk, info):
+            if chunk is None and info["action"] == "start":
+                streamed_logger.info(f"\n{info['param']} (batch_ind={info['ind']}):\n")
+                return
+            if chunk is None and info["action"] == "end":
+                streamed_logger.info("\n\n")
+                return
+            streamed_logger.info(chunk)
+
+        input_dicts_it = iter_test_jsonl_samples()
+        data_it = iter_content(input_dicts_it=input_dicts_it,
+                               llm=self.llm,
+                               return_batch=False,
+                               callback_stream_func=callback,
+                               handle_missed_value_func=lambda *_: None,
+                               schema="schema/thor_cot_schema.json")
+
+        for _ in tqdm(data_it):
+            streamed_logger.info("\n|NEXT ENTRY|\n")

{bulk_chain-0.25.2 → bulk_chain-0.25.3}/test/test_provider_batching.py

@@ -10,7 +10,7 @@ from utils import iter_test_jsonl_samples
 
 class TestProviderBatching(unittest.TestCase):
 
-    llm = dynamic_init(class_dir=join(CWD, ".."),
+    llm = dynamic_init(class_dir=join(CWD),
                        class_filepath="providers/transformers_flan_t5.py",
                        class_name="FlanT5")(model_name="nicolay-r/flan-t5-tsa-thor-base",
                                             max_new_tokens=128)
@@ -19,9 +19,10 @@ class TestProviderBatching(unittest.TestCase):
         input_dicts_it = iter_test_jsonl_samples()
         data_it = iter_content(input_dicts_it=input_dicts_it,
                                llm=self.llm,
-                               batch_size=20,
+                               batch_size=10,
                                return_batch=False,
-                               schema="schema/default.json")
+                               handle_missed_value_func=lambda *_: None,
+                               schema="schema/thor_cot_schema.json")
 
         for item in tqdm(data_it):
             print(item)

bulk_chain-0.25.2/bulk_chain/core/service_llm.py

@@ -1,94 +0,0 @@
-from bulk_chain.core.llm_base import BaseLM
-from bulk_chain.core.service_data import DataService
-from bulk_chain.core.utils import iter_params
-from bulk_chain.core.utils_logger import StreamedLogger
-
-
-def pad_str(text, pad):
-    return text.rjust(len(text) + pad, ' ')
-
-
-def nice_output(text, remove_new_line=False):
-    short_text = text.replace("\n", "") if remove_new_line else text
-    return short_text
-
-
-def chat_with_lm(lm, preset_dict=None, chain=None, model_name=None, pad=0):
-    assert (isinstance(lm, BaseLM))
-    assert (isinstance(chain, list))
-    assert (isinstance(model_name, str) or model_name is None)
-
-    preset_dict = {} if preset_dict is None else preset_dict
-
-    streamed_logger = StreamedLogger(__name__)
-
-    do_exit = False
-    model_name = model_name if model_name is not None else "agent"
-
-    while not do_exit:
-
-        streamed_logger.info("----------------")
-        streamed_logger.info("\n")
-
-        # Launching the CoT engine loop.
-        data_dict = {} | preset_dict
-        for chain_ind, prompt_args in enumerate(chain):
-
-            # Processing the prompt.
-            prompt = prompt_args["prompt"]
-
-            # Filling necessary parameters.
-            user_informed = False
-            field_names = list(iter_params(prompt))
-            for ind, f_name in enumerate(field_names):
-
-                if f_name in data_dict:
-                    continue
-
-                user_input = input(f"Enter your prompt for `{f_name}` ({ind+1}/{len(field_names)}) "
-                                   f"(or 'exit' to quit): ")
-                user_informed = True
-
-                if user_input.lower() == 'exit':
-                    do_exit = True
-                    break
-
-                data_dict[f_name] = user_input
-
-            if do_exit:
-                break
-
-            # In the case of the initial interaction with the chain.
-            # we make sure that aware user for starting interaction.
-            if chain_ind == 0 and not user_informed:
-                user_input = input(f"Enter to continue (or 'exit' to quit) ...")
-                if user_input.lower() == 'exit':
-                    do_exit = True
-
-            # Finally asking LLM.
-            DataService.compose_prompt_text(prompt=prompt, data_dict=data_dict, field_names=field_names)
-            actual_prompt = DataService.get_prompt_text(prompt=prompt, data_dict=data_dict)
-
-            # Returning meta information, passed to LLM.
-            streamed_logger.info(pad_str(f"{model_name} (ask [{chain_ind+1}/{len(chain)}]) ->", pad=pad))
-            streamed_logger.info("\n")
-            streamed_logger.info(nice_output(actual_prompt, remove_new_line=True))
-            streamed_logger.info("\n\n")
-
-            # Response.
-            response = lm.ask_core(batch=[actual_prompt])[0]
-            streamed_logger.info(pad_str(f"{model_name} (resp [{chain_ind+1}/{len(chain)}])->", pad=pad))
-            streamed_logger.info("\n")
-            if isinstance(response, str):
-                streamed_logger.info(nice_output(response, remove_new_line=False))
-                buffer = [response]
-            else:
-                buffer = []
-                for chunk in response:
-                    streamed_logger.info(chunk)
-                    buffer.append(str(chunk))
-
-            streamed_logger.info("\n\n")
-
-            # Collecting the answer for the next turn.
-            data_dict[prompt_args["out"]] = "".join(buffer)