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

bulk_chain-0.25.1/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: bulk_chain
+Version: 0.25.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
+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
+Requires-Dist: source-iter==0.24.3
+
+# bulk-chain 0.25.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>
+</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** served in `CSV`/`JSONL`.
+
+### Extra Features
+* ✅ **Progress caching [for remote LLMs]**: withstanding exception during LLM calls by using `sqlite3` engine for caching LLM answers;
+
+
+# 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)
+
+## Shell
+
+> **NOTE:** You have to install `source-iter` and `tqdm` packages that actual [dependencies](dependencies.txt) of this project
+
+1. ⬇️ Download [replicate](https://replicate.com/) provider for `bulk-chain`:
+```bash
+wget https://raw.githubusercontent.com/nicolay-r/nlp-thirdgate/refs/heads/master/llm/replicate_104.py
+```
+2. 📜 Setup your reasoning `schema.json` according to the [following example ↗️](test/schema/default.json)
+3. 🚀 Launch inference using `DeepSeek-R1`:
+```bash
+python3 -m bulk_chain.infer \
+    --src "<PATH-TO-YOUR-CSV-or-JSONL>" \
+    --schema "test/schema/default.json" \
+    --adapter "replicate_104.py:Replicate" \
+    %%m \
+    --model_name "deepseek-ai/deepseek-r1" \
+    --api_token "<REPLICATE-API-TOKEN>"
+```
+
+Or, you can launch **demo mode** to interact with LLM via command line: 
+> **NOTE:** Demo supports streaming!
+```bash
+python3 -m bulk_chain.demo \
+    --schema "test/schema/thor_cot_schema.json" \
+    --adapter "dynamic:replicate_104.py:Replicate" \
+    %%m \
+    --model_name "meta/meta-llama-3-70b-instruct" \
+    --api_token "<REPLICATE-API-TOKEN>" \
+    --stream
+```
+
+# 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-0.25.1/README.md

@@ -0,0 +1,111 @@
+# bulk-chain 0.25.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>
+</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** served in `CSV`/`JSONL`.
+
+### Extra Features
+* ✅ **Progress caching [for remote LLMs]**: withstanding exception during LLM calls by using `sqlite3` engine for caching LLM answers;
+
+
+# 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)
+
+## Shell
+
+> **NOTE:** You have to install `source-iter` and `tqdm` packages that actual [dependencies](dependencies.txt) of this project
+
+1. ⬇️ Download [replicate](https://replicate.com/) provider for `bulk-chain`:
+```bash
+wget https://raw.githubusercontent.com/nicolay-r/nlp-thirdgate/refs/heads/master/llm/replicate_104.py
+```
+2. 📜 Setup your reasoning `schema.json` according to the [following example ↗️](test/schema/default.json)
+3. 🚀 Launch inference using `DeepSeek-R1`:
+```bash
+python3 -m bulk_chain.infer \
+    --src "<PATH-TO-YOUR-CSV-or-JSONL>" \
+    --schema "test/schema/default.json" \
+    --adapter "replicate_104.py:Replicate" \
+    %%m \
+    --model_name "deepseek-ai/deepseek-r1" \
+    --api_token "<REPLICATE-API-TOKEN>"
+```
+
+Or, you can launch **demo mode** to interact with LLM via command line: 
+> **NOTE:** Demo supports streaming!
+```bash
+python3 -m bulk_chain.demo \
+    --schema "test/schema/thor_cot_schema.json" \
+    --adapter "dynamic:replicate_104.py:Replicate" \
+    %%m \
+    --model_name "meta/meta-llama-3-70b-instruct" \
+    --api_token "<REPLICATE-API-TOKEN>" \
+    --stream
+```
+
+# 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-0.25.1/bulk_chain/api.py

@@ -0,0 +1,99 @@
+import os
+from itertools import chain
+
+from bulk_chain.core.llm_base import BaseLM
+from bulk_chain.core.service_batch import BatchIterator, BatchService
+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
+
+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))
+}
+
+
+CWD = os.getcwd()
+
+
+def _update_batch_content(c, batch, schema, infer_func):
+    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)
+    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))
+
+
+def _infer_batch(batch, schema, infer_func, cols=None):
+    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
+
+    for c in cols:
+        _update_batch_content(c=c, batch=batch, schema=schema, infer_func=infer_func)
+
+    return batch
+
+
+def iter_content(input_dicts_it, llm, schema, batch_size=1, return_batch=True, limit_prompt=None):
+    """ 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 (isinstance(llm, BaseLM))
+
+    # Quick initialization of the schema.
+    if isinstance(schema, str):
+        schema = JsonService.read(schema)
+    if isinstance(schema, dict):
+        schema = SchemaService(json_data=schema)
+
+    prompts_it = map(
+        lambda data: DictionaryService.custom_update(src_dict=data, other_dict=schema.cot_args),
+        input_dicts_it
+    )
+
+    content_it = (_infer_batch(batch=batch,
+                               infer_func=lambda batch: INFER_MODES["batch"](llm, batch, limit_prompt),
+                               schema=schema)
+                  for batch in BatchIterator(prompts_it, batch_size=batch_size))
+
+    yield from content_it if return_batch else chain.from_iterable(content_it)
+
+
+def init_llm(adapter, **model_kwargs):
+    """ This method perform dynamic initialization of LLM from third-party resource.
+    """
+
+    # 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-0.25.1/bulk_chain/core/llm_base.py

@@ -0,0 +1,52 @@
+import logging
+import time
+
+from bulk_chain.core.utils import format_model_name
+
+
+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 = self.ask(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]
+
+                response = self.ask(content)
+
+                # Wrapping into batch the response in the case of non-batching mode.
+                return response if self.__support_batching else [response]
+
+            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)
+
+        raise Exception("Can't infer")
+
+    def ask(self, content):
+        raise NotImplemented()
+
+    def name(self):
+        return format_model_name(self.__name)

{bulk_chain-0.24.2 → bulk_chain-0.25.1}/bulk_chain/core/service_args.py

@@ -12,6 +12,11 @@ class CmdArgsService:
     def iter_arguments(lst):
 
         def __release():
+
+            # We use the True value by default to treat the related parameter as flag.
+            if len(buf) == 0:
+                buf.append(True)
+
             return key, buf if len(buf) > 1 else buf[0]
 
         key = None
@@ -29,18 +34,37 @@ class CmdArgsService:
                 buf.append(a)
 
         # Sharing the remaining params.
-        if len(buf) > 0:
+        if key is not None:
             yield __release()
 
     @staticmethod
-    def partition_list(lst, sep):
+    def __find_suffix_ind(lst, idx_from, end_prefix):
+        for i in range(idx_from, len(lst)):
+            if lst[i].startswith(end_prefix):
+                return i
+        return len(lst)
+
+    @staticmethod
+    def extract_native_args(lst, end_prefix):
+        return lst[:CmdArgsService.__find_suffix_ind(lst, idx_from=0, end_prefix=end_prefix)]
+
+    @staticmethod
+    def find_grouped_args(lst, starts_with, end_prefix):
         """Slices a list in two, cutting on index matching "sep"
         """
-        if sep in lst:
-            idx = lst.index(sep)
-            return (lst[:idx], lst[idx+1:])
-        else:
-            return (lst[:], None)
+
+        # Checking the presence of starts_with.
+        # We have to return empty content in the case of absence starts_with in the lst.
+        if starts_with not in lst:
+            return []
+
+        # Assigning start index.
+        idx_from = lst.index(starts_with) + 1
+
+        # Assigning end index.
+        idx_to = CmdArgsService.__find_suffix_ind(lst, idx_from=idx_from, end_prefix=end_prefix)
+
+        return lst[idx_from:idx_to]
 
     @staticmethod
     def args_to_dict(args):

bulk_chain-0.25.1/bulk_chain/core/service_batch.py

@@ -0,0 +1,51 @@
+class BatchService(object):
+
+    @staticmethod
+    def handle_param_as_batch(batch, src_param, tgt_param, handle_func):
+        assert (isinstance(batch, list))
+        assert (isinstance(src_param, str))
+        assert (callable(handle_func))
+
+        _batch = [item[src_param] for item in batch]
+
+        # Do handling for the batch.
+        _handled_batch = handle_func(_batch)
+        assert (isinstance(_handled_batch, list))
+
+        # Apply changes.
+        for i, item in enumerate(batch):
+            item[tgt_param] = _handled_batch[i]
+
+
+class BatchIterator:
+
+    def __init__(self, data_iter, batch_size, end_value=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
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        buffer = []
+        while True:
+            try:
+                data = next(self.__data_iter)
+            except StopIteration:
+                break
+            buffer.append(data)
+            if len(buffer) == self.__batch_size:
+                break
+
+        if len(buffer) > 0:
+            self.__index += 1
+            return buffer
+
+        if self.__end_value is None:
+            raise StopIteration
+        else:
+            return self.__end_value()

{bulk_chain-0.24.2 → bulk_chain-0.25.1}/bulk_chain/core/service_data.py

@@ -20,3 +20,7 @@ class DataService(object):
         field_names = list(parse_fields_func(prompt))
         return DataService.compose_prompt_text(
             prompt=prompt, data_dict=data_dict, field_names=field_names)
+
+    @staticmethod
+    def limit_prompts(prompts_list, limit=None):
+        return [p[:limit] if limit is not None else p for p in prompts_list]

bulk_chain-0.25.1/bulk_chain/core/service_dict.py

@@ -0,0 +1,10 @@
+class DictionaryService:
+
+    @staticmethod
+    def custom_update(src_dict, other_dict):
+        for k, v in other_dict.items():
+            if k in src_dict:
+                raise Exception(f"The key `{k}` is already defined in both dicts with values: "
+                                f"`{src_dict[k]}` (src) and `{v}` (other)")
+            src_dict[k] = v
+        return src_dict

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

@@ -1,8 +1,7 @@
-import logging
-
 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):
@@ -23,29 +22,32 @@ def nice_output(text, width, pad=4, remove_new_line=False):
     return text_wrap(content=short_text, width=width, handle_line=lambda line: pad_str(line, pad=pad))
 
 
-def chat_with_lm(lm, chain=None, model_name=None):
+def chat_with_lm(lm, preset_dict=None, chain=None, model_name=None, line_width=80, pad=0):
     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)
+    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:
 
-        logger.info("----------------")
+        streamed_logger.info("----------------")
+        streamed_logger.info("\n")
 
         # Launching the CoT engine loop.
-        data_dict = {}
-        for prompt_args in chain:
+        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):
 
@@ -54,6 +56,7 @@ def chat_with_lm(lm, chain=None, model_name=None):
 
                 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
@@ -64,19 +67,37 @@ def chat_with_lm(lm, chain=None, model_name=None):
             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.
-            pad = 4
-            logger.info(pad_str(f"{model_name} (ask) ->", pad=pad))
-            logger.info(nice_output(actual_prompt, pad=pad*2, remove_new_line=True, width=80))
+            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, pad=pad, remove_new_line=True, width=line_width))
+            streamed_logger.info("\n\n")
 
             # Response.
-            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))
+            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, pad=pad, remove_new_line=False, width=line_width))
+                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"]] = response
+            data_dict[prompt_args["out"]] = "".join(buffer)

{bulk_chain-0.24.2 → bulk_chain-0.25.1}/bulk_chain/core/service_schema.py

@@ -2,12 +2,11 @@ class SchemaService(object):
 
     def __init__(self, json_data):
         self.src = json_data
-        self.name = self.src["name"]
         self.r2p, self.p2r, self.cot_args, self.chain = SchemaService.__init_schema(prompts=json_data["schema"])
 
     @classmethod
     def from_prompt(cls, prompt):
-        prompt_schema = {"name": "prompt", "schema": [{"prompt": prompt, "out": "response", "in": "prompt"}]}
+        prompt_schema = {"schema": [{"prompt": prompt, "out": "response", "in": "prompt"}]}
         return cls(prompt_schema)
 
     @staticmethod

bulk_chain-0.25.1/bulk_chain/core/utils_logger.py

@@ -0,0 +1,41 @@
+import logging
+
+
+def StreamedLogger(name: str) -> logging.Logger:
+    """ https://medium.com/@r.das699/optimizing-logging-practices-for-streaming-data-in-python-521798e1ed82
+    """
+    root_handlers = logging.getLogger().handlers
+    current_logger = logging.getLogger(name)
+    if not root_handlers:
+        new_handler = logging.StreamHandler()
+        new_handler.terminator = ""
+        new_handler.setFormatter(logging.Formatter("%(message)s"))
+        current_logger.addHandler(new_handler)
+        current_logger.propagate = False
+        current_logger.setLevel(logging.INFO)
+        return current_logger
+
+    for handler in current_logger.handlers[:]:
+        current_logger.removeHandler(handler)
+
+    for handler_r in root_handlers:
+        if type(handler_r) is logging.StreamHandler:
+            new_handler = logging.StreamHandler()
+            new_handler.terminator = ""
+            new_handler.setFormatter(logging.Formatter("%(message)s"))
+            current_logger.addHandler(new_handler)
+        elif type(handler_r) is logging.FileHandler:
+            new_handler = logging.FileHandler(
+                handler_r.baseFilename,
+                handler_r.mode,
+                handler_r.encoding,
+                handler_r.delay,
+                handler_r.errors,
+            )
+            new_handler.terminator = ""  # This will stop the printing in new line
+            new_handler.setFormatter(logging.Formatter("%(message)s"))
+            current_logger.addHandler(new_handler)
+        else:
+            continue
+    current_logger.propagate = False  # Don't propagate to root logger
+    return current_logger