bulk-chain 0.24.1__tar.gz → 0.24.2__tar.gz

{bulk_chain-0.24.1 → bulk_chain-0.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bulk_chain
-Version: 0.24.1
+Version: 0.24.2
 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
@@ -16,8 +16,9 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tqdm
+Requires-Dist: source-iter==0.24.2
 
-# bulk-chain 0.24.1
+# bulk-chain 0.24.2
 ![](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.24.1 → bulk_chain-0.24.2}/README.md

@@ -1,4 +1,4 @@
-# bulk-chain 0.24.1
+# bulk-chain 0.24.2
 ![](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.24.2/bulk_chain/core/llm_base.py

@@ -0,0 +1,35 @@
+import logging
+import time
+
+from bulk_chain.core.utils import format_model_name
+
+
+class BaseLM(object):
+
+    def __init__(self, name, attempts=None, delay_sec=1, enable_log=True, **kwargs):
+        self.__name = name
+        self.__attempts = 1 if attempts is None else attempts
+        self.__delay_sec = delay_sec
+
+        if enable_log:
+            self.__logger = logging.getLogger(__name__)
+            logging.basicConfig(level=logging.INFO)
+
+    def ask_safe(self, prompt):
+
+        for i in range(self.__attempts):
+            try:
+                response = self.ask(prompt)
+                return response
+            except:
+                if self.__logger is not None:
+                    self.__logger.info("Unable to infer the result. Try {} out of {}.".format(i, self.__attempts))
+                time.sleep(self.__delay_sec)
+
+        raise Exception("Can't infer")
+
+    def ask(self, prompt):
+        raise NotImplemented()
+
+    def name(self):
+        return format_model_name(self.__name)

bulk_chain-0.24.2/bulk_chain/core/service_json.py

@@ -0,0 +1,10 @@
+import json
+
+
+class JsonService(object):
+
+    @staticmethod
+    def read(src):
+        assert (isinstance(src, str))
+        with open(src, "r") as f:
+            return json.load(f)

{bulk_chain-0.24.1 → bulk_chain-0.24.2}/bulk_chain/core/service_llm.py

@@ -4,9 +4,6 @@ from bulk_chain.core.llm_base import BaseLM
 from bulk_chain.core.service_data import DataService
 from bulk_chain.core.utils import iter_params
 
-logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
-
 
 def pad_str(text, pad):
     return text.rjust(len(text) + pad, ' ')
@@ -27,9 +24,12 @@ def nice_output(text, width, pad=4, remove_new_line=False):
 
 
 def chat_with_lm(lm, chain=None, model_name=None):
-    assert(isinstance(lm, BaseLM))
-    assert(isinstance(chain, list))
-    assert(isinstance(model_name, str) or model_name is None)
+    assert (isinstance(lm, BaseLM))
+    assert (isinstance(chain, list))
+    assert (isinstance(model_name, str) or model_name is None)
+
+    logger = logging.getLogger(__name__)
+    logging.basicConfig(level=logging.INFO)
 
     do_exit = False
     model_name = model_name if model_name is not None else "agent"
@@ -74,7 +74,7 @@ def chat_with_lm(lm, chain=None, model_name=None):
             logger.info(nice_output(actual_prompt, pad=pad*2, remove_new_line=True, width=80))
 
             # Response.
-            response = lm.ask(actual_prompt)
+            response = lm.ask_safe(actual_prompt)
             logger.info(pad_str(f"{model_name} (resp)->", pad=pad))
             logger.info(nice_output(response, pad=pad*2, remove_new_line=False, width=80))
 

{bulk_chain-0.24.1 → bulk_chain-0.24.2}/bulk_chain/infer.py

@@ -1,16 +1,18 @@
+import os
+from os.path import join, basename
+
 import argparse
 import logging
-import os
 import sys
 
 from tqdm import tqdm
 
-from os.path import join, basename
+from source_iter.service_csv import CsvService
+from source_iter.service_jsonl import JsonlService
+from source_iter.service_sqlite import SQLite3Service
 
 from bulk_chain.core.llm_base import BaseLM
-from bulk_chain.core.provider_sqlite import SQLiteProvider
 from bulk_chain.core.service_args import CmdArgsService
-from bulk_chain.core.service_csv import CsvService
 from bulk_chain.core.service_data import DataService
 from bulk_chain.core.service_json import JsonService
 from bulk_chain.core.service_llm import chat_with_lm
@@ -45,7 +47,7 @@ def init_llm(**model_kwargs):
 
 
 def init_schema(json_filepath):
-    return SchemaService(json_data=JsonService.read_data(json_filepath))
+    return SchemaService(json_data=JsonService.read(json_filepath))
 
 
 def iter_content(input_dicts_iter, llm, schema, cache_target, cache_table, id_column_name):
@@ -59,7 +61,7 @@ def iter_content(input_dicts_iter, llm, schema, cache_target, cache_table, id_co
     assert (isinstance(cache_table, str))
 
     infer_modes = {
-        "default": lambda prompt: llm.ask(prompt[:args.limit_prompt] if args.limit_prompt is not None else prompt)
+        "default": lambda prompt: llm.ask_safe(prompt[:args.limit_prompt] if args.limit_prompt is not None else prompt)
     }
 
     def optional_update_data_records(c, data):
@@ -75,7 +77,7 @@ def iter_content(input_dicts_iter, llm, schema, cache_target, cache_table, id_co
         return data[c]
 
     cache_providers = {
-        "sqlite": lambda filepath, table_name, data_it: SQLiteProvider.write_auto(
+        "sqlite": lambda filepath, table_name, data_it: SQLite3Service.write_missed(
             data_it=data_it, target=filepath,
             data2col_func=optional_update_data_records,
             table_name=handle_table_name(table_name if table_name is not None else "contents"),
@@ -90,13 +92,14 @@ def iter_content(input_dicts_iter, llm, schema, cache_target, cache_table, id_co
     # Provide data caching.
     cache_providers["sqlite"](cache_target, table_name=tgt_meta, data_it=tqdm(queries_it, desc="Iter content"))
 
-    return SQLiteProvider.iter_rows(cache_target, table=cache_table)
+    return SQLite3Service.read(cache_target, table=cache_table)
 
 
 if __name__ == '__main__':
 
     parser = argparse.ArgumentParser(description="Infer Instruct LLM inference based on CoT schema")
     parser.add_argument('--adapter', dest='adapter', type=str, default=None)
+    parser.add_argument('--attempts', dest='attempts', type=int, default=None)
     parser.add_argument('--id-col', dest='id_col', type=str, default="uid")
     parser.add_argument('--src', dest='src', type=str, default=None)
     parser.add_argument('--schema', dest='schema', type=str, default=None,
@@ -113,7 +116,7 @@ if __name__ == '__main__':
     args = parser.parse_args(args=native_args[1:])
 
     # Initialize Large Language Model.
-    model_args_dict = CmdArgsService.args_to_dict(model_args)
+    model_args_dict = CmdArgsService.args_to_dict(model_args) | {"attempts": args.attempts}
     llm, llm_model_name = init_llm(**model_args_dict)
 
     # Setup schema.
@@ -123,19 +126,19 @@ if __name__ == '__main__':
 
     input_providers = {
         None: lambda _: chat_with_lm(llm, chain=schema.chain, model_name=llm_model_name),
-        "csv": lambda filepath: CsvService.read(target=filepath, row_id_key=args.id_col,
+        "csv": lambda filepath: CsvService.read(src=filepath, row_id_key=args.id_col,
                                                 as_dict=True, skip_header=True,
                                                 delimiter=model_args_dict.get("delimiter", "\t"),
                                                 escapechar=model_args_dict.get("escapechar", None)),
-        "jsonl": lambda filepath: JsonService.read_lines(src=filepath, row_id_key=args.id_col)
+        "jsonl": lambda filepath: JsonlService.read(src=filepath, row_id_key=args.id_col)
     }
 
     output_providers = {
         "csv": lambda filepath, data_it, header:
-        CsvService.write_handled(target=filepath, data_it=data_it, header=header, data2col_func=lambda v: list(v)),
+            CsvService.write(target=filepath, data_it=data_it, header=header, it_type=None),
         "jsonl": lambda filepath, data_it, header:
-        JsonService.write_lines(target=filepath,
-                                data_it=map(lambda item: {key:item[i] for i, key in enumerate(header)}, data_it))
+        JsonlService.write(target=filepath,
+                           data_it=map(lambda item: {key: item[i] for i, key in enumerate(header)}, data_it))
     }
 
     # Setup output.
@@ -170,4 +173,4 @@ if __name__ == '__main__':
     # Perform output writing process.
     output_providers[tgt_ext](filepath=output_target,
                               data_it=data_it,
-                              header=SQLiteProvider.get_columns(target=cache_target, table=cache_table))
+                              header=SQLite3Service.read_columns(target=cache_target, table=cache_table))

{bulk_chain-0.24.1 → bulk_chain-0.24.2}/bulk_chain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bulk_chain
-Version: 0.24.1
+Version: 0.24.2
 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
@@ -16,8 +16,9 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tqdm
+Requires-Dist: source-iter==0.24.2
 
-# bulk-chain 0.24.1
+# bulk-chain 0.24.2
 ![](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.24.1 → bulk_chain-0.24.2}/bulk_chain.egg-info/SOURCES.txt

@@ -10,9 +10,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_csv.py
 bulk_chain/core/service_data.py
 bulk_chain/core/service_json.py
 bulk_chain/core/service_llm.py

bulk_chain-0.24.2/bulk_chain.egg-info/requires.txt

@@ -0,0 +1,2 @@
+tqdm
+source-iter==0.24.2

{bulk_chain-0.24.1 → bulk_chain-0.24.2}/setup.py

@@ -15,7 +15,7 @@ def get_requirements(filenames):
 
 setup(
     name='bulk_chain',
-    version='0.24.1',
+    version='0.24.2',
     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.24.1/bulk_chain/core/llm_base.py

@@ -1,13 +0,0 @@
-from bulk_chain.core.utils import format_model_name
-
-
-class BaseLM(object):
-
-    def __init__(self, name):
-        self.__name = name
-
-    def ask(self, prompt):
-        raise NotImplemented()
-
-    def name(self):
-        return format_model_name(self.__name)

bulk_chain-0.24.1/bulk_chain/core/provider_sqlite.py

@@ -1,78 +0,0 @@
-import sqlite3
-
-
-class SQLiteProvider(object):
-
-    @staticmethod
-    def __create_table(table_name, columns, id_column_name,
-                       id_column_type, sqlite3_column_types, cur):
-
-        # 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 write_auto(data_it, target, data2col_func, table_name, id_column_name="id",
-                   id_column_type="INTEGER"):
-        """ NOTE: data_it is an iterator of dictionaries.
-            This implementation automatically creates the table and
-        """
-        with sqlite3.connect(target) as con:
-            cur = con.cursor()
-
-            columns = None
-            for data in data_it:
-                assert(isinstance(data, dict))
-
-                # Extracting columns from data.
-                row_columns = list(data.keys())
-                assert(id_column_name in row_columns)
-
-                # Optionally create table.
-                if columns is None:
-
-                    # Setup list of columns.
-                    columns = row_columns
-                    # Place ID column first.
-                    columns.insert(0, columns.pop(columns.index(id_column_name)))
-
-                    SQLiteProvider.__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=["TEXT"] * len(columns))
-
-                # 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]
-
-                uid = data[id_column_name]
-                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])
-                cur.execute(f"INSERT INTO {table_name}({row_columns_str}) VALUES ({params})",
-                            [data2col_func(c, data) for c in row_columns])
-                con.commit()
-
-            cur.close()
-
-    @staticmethod
-    def iter_rows(target, table="content"):
-        with sqlite3.connect(target) as conn:
-            cursor = conn.cursor()
-            cursor.execute(f"SELECT * FROM {table}")
-            for row in cursor:
-                yield row
-                
-    @staticmethod
-    def get_columns(target, table="content"):
-        with sqlite3.connect(target) as conn:
-            cursor = conn.cursor()
-            cursor.execute(f"PRAGMA table_info({table})")
-            return [row[1] for row in cursor.fetchall()]

bulk_chain-0.24.1/bulk_chain/core/service_csv.py

@@ -1,57 +0,0 @@
-import csv
-import logging
-
-logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
-
-
-class CsvService:
-
-    @staticmethod
-    def write(target, lines_it):
-        f = open(target, "w")
-        logger.info(f"Saving: {target}")
-        w = csv.writer(f, delimiter="\t", quotechar='"', quoting=csv.QUOTE_MINIMAL)
-        for content in lines_it:
-            w.writerow(content)
-
-    @staticmethod
-    def write_handled(target, data_it, data2col_func, header):
-
-        def __it():
-            yield header
-            for data in data_it:
-                content = data2col_func(data)
-                assert(len(content) == len(header))
-                yield content
-
-        CsvService.write(target, lines_it=__it())
-
-    @staticmethod
-    def read(target, skip_header=False, cols=None, as_dict=False, row_id_key=None, **csv_kwargs):
-        assert (isinstance(row_id_key, str) or row_id_key is None)
-        assert (isinstance(cols, list) or cols is None)
-
-        header = None
-        with open(target, newline='\n') as f:
-            for row_id, row in enumerate(csv.reader(f, **csv_kwargs)):
-                if skip_header and row_id == 0:
-                    header = ([row_id_key] if row_id_key is not None else []) + row
-                    continue
-
-                # Determine the content we wish to return.
-                if cols is None:
-                    content = row
-                else:
-                    row_d = {header[col_ind]: value for col_ind, value in enumerate(row)}
-                    content = [row_d[col_name] for col_name in cols]
-
-                content = ([row_id-1] if row_id_key is not None else []) + content
-
-                # Optionally attach row_id to the content.
-                if as_dict:
-                    assert (header is not None)
-                    assert (len(content) == len(header))
-                    yield {k: v for k, v in zip(header, content)}
-                else:
-                    yield content

bulk_chain-0.24.1/bulk_chain/core/service_json.py

@@ -1,26 +0,0 @@
-import json
-
-
-class JsonService(object):
-
-    @staticmethod
-    def read_data(src):
-        assert (isinstance(src, str))
-        with open(src, "r") as f:
-            return json.load(f)
-
-    @staticmethod
-    def read_lines(src, row_id_key=None):
-        assert (isinstance(src, str))
-        with open(src, "r") as f:
-            for line_ind, line in enumerate(f.readlines()):
-                content = json.loads(line)
-                if row_id_key is not None:
-                    content[row_id_key] = line_ind
-                yield content
-
-    @staticmethod
-    def write_lines(target, data_it):
-        with open(target, "w") as f:
-            for item in data_it:
-                f.write(f"{json.dumps(item, ensure_ascii=False)}\n")

bulk_chain-0.24.1/bulk_chain.egg-info/requires.txt

@@ -1 +0,0 @@
-tqdm