Merge pull request #74 from innightwolfsleep/env_and_oneclick_running

Env and oneclick running

.env.example

@@ -0,0 +1 @@
+BOT_TOKEN=XXXXXXXXXX:YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY

.gitignore

@@ -8,3 +8,4 @@ characters/*
 !characters/Coder.json
 history/*
 history/telegram_history_here.txt
+.env

generators/generator_langchain_llama_cpp.py

@@ -27,14 +27,7 @@ def __init__(self, model_path, n_ctx=2048, seed=0, n_gpu_layers=0):
         )
 
     def get_answer(
-        self,
-        prompt,
-        generation_params,
-        eos_token,
-        stopping_strings,
-        default_answer,
-        turn_template="",
-        **kwargs
+        self, prompt, generation_params, eos_token, stopping_strings, default_answer, turn_template="", **kwargs
     ):
         if "max_tokens" in generation_params:
             llm.max_tokens = generation_params["max_tokens"]
@@ -44,9 +37,7 @@ def get_answer(
             llm.top_p = generation_params["top_p"]
         if "top_k" in generation_params:
             llm.top_k = generation_params["top_k"]
-        prompt_template = PromptTemplate(
-            template="{prompt}", input_variables=["prompt"]
-        )
+        prompt_template = PromptTemplate(template="{prompt}", input_variables=["prompt"])
         llm.stop = stopping_strings
         llm_chain = LLMChain(prompt=prompt_template, llm=self.llm)
         answer = llm_chain.run(prompt)

generators/generator_llama_cpp.py

@@ -13,19 +13,10 @@ def __init__(self, model_path: str, n_ctx=4096, seed=0, n_gpu_layers=0):
         self.seed = seed
         self.n_gpu_layers = n_gpu_layers
         print(n_gpu_layers)
-        self.llm = Llama(
-            model_path=model_path, n_ctx=n_ctx, seed=seed, n_gpu_layers=n_gpu_layers
-        )
+        self.llm = Llama(model_path=model_path, n_ctx=n_ctx, seed=seed, n_gpu_layers=n_gpu_layers)
 
     def get_answer(
-        self,
-        prompt,
-        generation_params,
-        eos_token,
-        stopping_strings,
-        default_answer: str,
-        turn_template="",
-        **kwargs
+        self, prompt, generation_params, eos_token, stopping_strings, default_answer: str, turn_template="", **kwargs
     ):
         # Preparing, add stopping_strings
         answer = default_answer
@@ -58,6 +49,4 @@ def get_model_list(self):
 
     def load_model(self, model_file: str):
         with open("models\\" + model_file, "r") as model:
-            self.llm: Llama = Llama(
-                model_path=model.read(), n_ctx=self.n_ctx, seed=self.seed
-            )
+            self.llm: Llama = Llama(model_path=model.read(), n_ctx=self.n_ctx, seed=self.seed)

generators/generator_text_generator_webui.py

@@ -15,52 +15,30 @@ def __init__(self, model_path="", n_ctx=2048, n_gpu_layers=0):
         pass
 
     @staticmethod
-    def get_answer(
-        prompt,
-        generation_params,
-        eos_token,
-        stopping_strings,
-        default_answer,
-        turn_template="",
-        **kwargs
-    ):
+    def get_answer(prompt, generation_params, eos_token, stopping_strings, default_answer, turn_template="", **kwargs):
         generation_params.update({"turn_template": turn_template})
         generation_params.update(
             {
                 "stream": False,
                 "max_new_tokens": int(
-                    generation_params.get(
-                        "max_new_tokens", generation_params.get("max_length", 200)
-                    )
+                    generation_params.get("max_new_tokens", generation_params.get("max_length", 200))
                 ),
                 "do_sample": bool(generation_params.get("do_sample", True)),
                 "temperature": float(generation_params.get("temperature", 0.5)),
                 "top_p": float(generation_params.get("top_p", 1)),
-                "typical_p": float(
-                    generation_params.get(
-                        "typical_p", generation_params.get("typical", 1)
-                    )
-                ),
+                "typical_p": float(generation_params.get("typical_p", generation_params.get("typical", 1))),
                 "epsilon_cutoff": float(generation_params.get("epsilon_cutoff", 0)),
                 "eta_cutoff": float(generation_params.get("eta_cutoff", 0)),
                 "tfs": float(generation_params.get("tfs", 1)),
                 "top_a": float(generation_params.get("top_a", 0)),
                 "repetition_penalty": float(
-                    generation_params.get(
-                        "repetition_penalty", generation_params.get("rep_pen", 1.1)
-                    )
-                ),
-                "repetition_penalty_range": int(
-                    generation_params.get("repetition_penalty_range", 0)
-                ),
-                "encoder_repetition_penalty": float(
-                    generation_params.get("encoder_repetition_penalty", 1.0)
+                    generation_params.get("repetition_penalty", generation_params.get("rep_pen", 1.1))
                 ),
+                "repetition_penalty_range": int(generation_params.get("repetition_penalty_range", 0)),
+                "encoder_repetition_penalty": float(generation_params.get("encoder_repetition_penalty", 1.0)),
                 "top_k": int(generation_params.get("top_k", 0)),
                 "min_length": int(generation_params.get("min_length", 0)),
-                "no_repeat_ngram_size": int(
-                    generation_params.get("no_repeat_ngram_size", 0)
-                ),
+                "no_repeat_ngram_size": int(generation_params.get("no_repeat_ngram_size", 0)),
                 "num_beams": int(generation_params.get("num_beams", 1)),
                 "penalty_alpha": float(generation_params.get("penalty_alpha", 0)),
                 "length_penalty": float(generation_params.get("length_penalty", 1)),
@@ -77,16 +55,12 @@ def get_answer(
                     )
                 ),
                 "ban_eos_token": bool(generation_params.get("ban_eos_token", False)),
-                "skip_special_tokens": bool(
-                    generation_params.get("skip_special_tokens", True)
-                ),
+                "skip_special_tokens": bool(generation_params.get("skip_special_tokens", True)),
                 "custom_stopping_strings": "",  # leave this blank
                 "stopping_strings": generation_params.get("stopping_strings", []),
             }
         )
-        generator = generate_reply(
-            question=prompt, state=generation_params, stopping_strings=stopping_strings
-        )
+        generator = generate_reply(question=prompt, state=generation_params, stopping_strings=stopping_strings)
         # This is "bad" implementation of getting answer, should be reworked
         answer = default_answer
         for a in generator:

readme.md

@@ -21,16 +21,17 @@ pip install -r llm_telegram_bot\requirements.txt
 ```
 
 HOW TO USE:
-1) add your bot token to configs/telegram_token.txt (ask https://t.me/BotFather how to get token)
-2) add your model bin file to models/
-3) write path to your bin model file in configs/telegram_config.json - model_path
-2) run "python llm_telegram_bot/main.py"
+1) get bot token from https://t.me/BotFather 
+2) add bot token to environment (look `.env.example`) OR file `configs/telegram_token.txt`
+3) move your model file to `models/`
+4) set **model_path** to your model in `configs/telegram_config.json` 
+5) start `run.cmd` or `run.sh` or `python3 run.py`
 
 FEATURES:
 - chat and notebook modes
 - session for all users are separative (by chat_id)
 - local session history - conversation won't be lost if server restarts. Separated history between users and chars.
-- nice "X typing" during generating (users will not think that bot stucking)
+- nice "X typing" during generating (users will not think that bot stuck)
 - buttons: continue previous message, regenerate last message, remove last messages from history, reset history button, new char loading menu
 - you can load new characters from text-generation-webui\characters with button
 - you can load new model during conversation with button

requirements.txt

@@ -10,4 +10,5 @@ torch>=2.0.1
 backoff>=2.2.1
 langchain>=0.0.286
 requests>=2.31.0
-urllib3>=2.0.4
+urllib3>=2.0.4
+python-dotenv==1.0.0

run.cmd

@@ -0,0 +1 @@
+call python run.py

run.py

@@ -1,12 +1,19 @@
 import sys
+import os
 from threading import Thread
 from telegram_bot_wrapper import TelegramBotWrapper
+from dotenv import load_dotenv
+
+config_file_path = "configs/telegram_config.json"
 
 
 def run_server(token):
+    if not token:
+        load_dotenv()
+        token = os.environ.get("BOT_TOKEN", "")
     # create TelegramBotWrapper instance
     # by default, read parameters in telegram_config.cfg
-    tg_server = TelegramBotWrapper(config_file_path="configs/telegram_config.json")
+    tg_server = TelegramBotWrapper(config_file_path=config_file_path)
     # by default - read token from telegram_token.txt
     tg_server.run_telegram_bot(bot_token=str(token))
 

run.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/bash
+python3 run.py

script.py

@@ -1,13 +1,20 @@
+import os
 from threading import Thread
-from extensions.telegram_bot.TelegramBotWrapper import TelegramBotWrapper
+from extensions.telegram_bot.telegram_bot_wrapper import TelegramBotWrapper
+from dotenv import load_dotenv
 
+# This module added to get compatibility with text-generation-webui-telegram_bot
 
-def run_server():
+config_file_path = "extensions/telegram_bot/configs/telegram_config.json"
+
+
+def run_server(token=""):
+    if not token:
+        load_dotenv()
+        token = os.environ.get("BOT_TOKEN", "")
     # create TelegramBotWrapper instance
     # by default, read parameters in telegram_config.cfg
-    tg_server = TelegramBotWrapper(
-        config_file_path="extensions/telegram_bot/configs/telegram_config.json"
-    )
+    tg_server = TelegramBotWrapper(config_file_path=config_file_path)
     # by default - read token from extensions/telegram_bot/telegram_token.txt
     tg_server.run_telegram_bot()
 

telegram_bot_generator.py

@@ -24,9 +24,7 @@ def init(script="GeneratorLlamaCpp", model_path="", n_ctx=4096, n_gpu_layers=0):
       n_gpu_layers: n_gpu_layers for llama
     """
     try:
-        generator_class = getattr(
-            importlib.import_module("generators." + script), "Generator"
-        )
+        generator_class = getattr(importlib.import_module("generators." + script), "Generator")
     except ImportError:
         generator_class = getattr(
             importlib.import_module("extensions.telegram_bot.generators." + script),
@@ -37,13 +35,7 @@ def init(script="GeneratorLlamaCpp", model_path="", n_ctx=4096, n_gpu_layers=0):
 
 
 def get_answer(
-    prompt,
-    generation_params,
-    eos_token,
-    stopping_strings,
-    default_answer: str,
-    turn_template="",
-    **kwargs
+    prompt, generation_params, eos_token, stopping_strings, default_answer: str, turn_template="", **kwargs
 ) -> str:
     """Generate and return answer string.
 

telegram_bot_sd_api.py

@@ -31,9 +31,7 @@ def txt_to_image(self, prompt: str):
             image = Image.open(io.BytesIO(base64.b64decode(i.split(",", 1)[0])))
 
             png_payload = {"image": "data:image/png;base64," + i}
-            response2 = requests.post(
-                url=f"{self.url}/sdapi/v1/png-info", json=png_payload
-            )
+            response2 = requests.post(url=f"{self.url}/sdapi/v1/png-info", json=png_payload)
             output_file = str(random.random()) + ".png"
             png_info = PngImagePlugin.PngInfo()
             png_info.add_text("parameters", response2.json().get("info"))

telegram_bot_silero.py

@@ -92,21 +92,11 @@ def get_audio(self, text: str, user_id: int, user: User):
         if user.silero_speaker == "None" or user.silero_model_id == "None":
             return None
         if user.silero_speaker == "None" or user.silero_model_id == "None":
-            user.silero_model_id, user.silero_speaker = self.get_default_audio_settings(
-                user.language
-            )
-        if (
-            user.silero_speaker
-            not in self.voices[user.language]["male"]
-            + self.voices[user.language]["female"]
-        ):
-            user.silero_model_id, user.silero_speaker = self.get_default_audio_settings(
-                user.language
-            )
+            user.silero_model_id, user.silero_speaker = self.get_default_audio_settings(user.language)
+        if user.silero_speaker not in self.voices[user.language]["male"] + self.voices[user.language]["female"]:
+            user.silero_model_id, user.silero_speaker = self.get_default_audio_settings(user.language)
         if user.silero_model_id not in self.voices[user.language]["model"]:
-            user.silero_model_id, user.silero_speaker = self.get_default_audio_settings(
-                user.language
-            )
+            user.silero_model_id, user.silero_speaker = self.get_default_audio_settings(user.language)
 
         try:
             model, _ = torch.hub.load(
@@ -142,9 +132,7 @@ def preprocess(self, string):
         # For example, you need to remove the commas in numbers before expanding them
         string = self.remove_surrounded_chars(string)
         string = string.replace('"', "")
-        string = string.replace("\u201D", "").replace(
-            "\u201C", ""
-        )  # right and left quote
+        string = string.replace("\u201D", "").replace("\u201C", "")  # right and left quote
         string = string.replace("\u201F", "")  # italic looking quote
         string = string.replace("\n", " ")
         string = string.replace("*", " ! ")
@@ -192,11 +180,7 @@ def convert_num_locale(text):
 
             start = match.start()
             end = match.end()
-            result = (
-                result[0:start]
-                + result[start:end].replace(".", "").replace(",", ".")
-                + result[end : len(result)]
-            )
+            result = result[0:start] + result[start:end].replace(".", "").replace(",", ".") + result[end : len(result)]
 
         # removes comma separators from existing American numbers
         pattern = re.compile(r"(\d),(\d)")
@@ -262,19 +246,13 @@ def replace_abbreviations(self, string):
 
             start = match.start()
             end = match.end()
-            result = (
-                result[0:start]
-                + self.replace_abbreviation(result[start:end])
-                + result[end : len(result)]
-            )
+            result = result[0:start] + self.replace_abbreviation(result[start:end]) + result[end : len(result)]
 
         return result
 
     def replace_lowercase_abbreviations(self, string):
         # abbreviations 1 to 4 characters long, separated by dots i.e. e.g.
-        pattern = re.compile(
-            rf"(^|[\s(.\'\[<])(([a-z]\.){{1,4}})({self.punctuation}|$)"
-        )
+        pattern = re.compile(rf"(^|[\s(.\'\[<])(([a-z]\.){{1,4}})({self.punctuation}|$)")
         result = string
         while True:
             match = pattern.search(result)
@@ -283,11 +261,7 @@ def replace_lowercase_abbreviations(self, string):
 
             start = match.start()
             end = match.end()
-            result = (
-                result[0:start]
-                + self.replace_abbreviation(result[start:end].upper())
-                + result[end : len(result)]
-            )
+            result = result[0:start] + self.replace_abbreviation(result[start:end].upper()) + result[end : len(result)]
 
         return result