Upload 22 files

.github/workflows/sync_to_hf_space.yml

@@ -0,0 +1,18 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push -f https://Hansimov:[email protected]/spaces/Hansimov/hf-llm-api main

.gitignore

@@ -0,0 +1,2 @@
+secrets.json
+__pycache__

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+WORKDIR $HOME/app
+COPY . .
+RUN pip install -r requirements.txt
+VOLUME /data
+EXPOSE 23333
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+RUN mkdir -p $HOME/app/models
+RUN chmod 777 $HOME/app/models
+ENV MODELS_PATH=$HOME/app/models
+RUN mkdir -p $HOME/app/uploads
+RUN chmod 777 $HOME/app/uploads
+
+CMD ["python", "-m", "apis.chat_api"]

README.md

@@ -1,12 +1,87 @@
----
-title: Selam Translate
-emoji: 🚀
-colorFrom: purple
-colorTo: gray
-sdk: docker
-pinned: false
-license: mit
-short_description: Selam Translate API.
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Selam Translate API
+emoji: ☯️
+colorFrom: gray
+colorTo: gray
+sdk: docker
+app_port: 23333
+---
+
+## Selam Translate API
+Multilingual Translation and Language Detection API.
+
+## Features
+
+✅ Implemented:
+
+- Language detection (`/detect`)
+- Translation via Google Translate (`/translate`)
+- Translation via local AI models (`/translate/ai`) using Hugging Face `transformers`
+- Docker deployment
+
+🔤 Supported languages (primary):
+
+`auto`, `en` (English), `am` (Amharic), `ar` (Arabic), `ti` (Tigrinya), `om` (Oromo), `so` (Somali), `ko` (Korean), `zh-CN` (Chinese Simplified), `zh-TW` (Chinese Traditional), `fr` (French), `it` (Italian), `ja` (Japanese), `de` (German)
+
+## Run API service
+
+### Run in Command Line
+
+**Install dependencies:**
+
+```bash
+# pipreqs . --force --mode no-pin
+pip install -r requirements.txt
+```
+
+**Run API:**
+
+```bash
+python -m apis.chat_api
+```
+
+## Run via Docker
+
+**Docker build:**
+
+```bash
+sudo docker build -t hf-llm-api:1.0 . --build-arg http_proxy=$http_proxy --build-arg https_proxy=$https_proxy
+```
+
+**Docker run:**
+
+```bash
+# no proxy
+sudo docker run -p 23333:23333 hf-llm-api:1.0
+
+# with proxy
+sudo docker run -p 23333:23333 --env http_proxy="http://<server>:<port>" hf-llm-api:1.0
+```
+
+## API Usage
+
+### API Usage
+
+- Detect language
+
+```bash
+curl -X POST http://127.0.0.1:23333/detect \
+  -H "Content-Type: application/json" \
+  -d '{"input_text": "Hello, how are you?"}'
+```
+
+- Translate (Google)
+
+```bash
+curl -X POST http://127.0.0.1:23333/translate \
+  -H "Content-Type: application/json" \
+  -d '{"to_language": "ar", "input_text": "Hello"}'
+```
+
+- Translate (AI model)
+
+```bash
+curl -X POST http://127.0.0.1:23333/translate/ai \
+  -H "Content-Type: application/json" \
+  -d '{"model": "t5-base", "from_language": "en", "to_language": "fr", "input_text": "How are you?"}'
+```

apis/chat_api.py

@@ -0,0 +1,232 @@
+import argparse
+import uvicorn
+import sys
+import os
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import time
+import json
+import torch
+import logging
+
+
+from fastapi import FastAPI
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+from googletrans import Translator
+from fastapi.middleware.cors import CORSMiddleware
+
+class ChatAPIApp:
+    def __init__(self):
+        self.app = FastAPI(
+            docs_url="/",
+            title="Selam Translate API",
+            swagger_ui_parameters={"defaultModelsExpandDepth": -1},
+            version="1.0",
+        )
+        self.setup_routes()
+
+    def get_available_langs(self):
+        f = open('apis/lang_name.json', "r")
+        self.available_models = json.loads(f.read())
+        return self.available_models
+
+    class TranslateCompletionsPostItem(BaseModel):
+        from_language: str = Field(
+            default="en",
+            description="(str) `Detect`",
+        )
+        to_language: str = Field(
+            default="fa",
+            description="(str) `en`",
+        )
+        input_text: str = Field(
+            default="Hello",
+            description="(str) `Text for translate`",
+        )
+   
+
+    def translate_completions(self, item: TranslateCompletionsPostItem):
+        translator = Translator()
+        f = open('apis/lang_name.json', "r")
+        available_langs = json.loads(f.read())
+        from_lang = 'en'
+        to_lang = 'en'
+        for lang_item in available_langs:
+          if item.to_language == lang_item['code']:
+              to_lang = item.to_language
+              break
+              
+          
+        translated = translator.translate(item.input_text, dest=to_lang)
+        item_response = {
+            "from_language": translated.src,
+            "to_language": translated.dest,
+            "text": item.input_text,
+            "translate": translated.text
+        }
+        json_compatible_item_data = jsonable_encoder(item_response)
+        return JSONResponse(content=json_compatible_item_data)
+
+    def translate_ai_completions(self, item: TranslateCompletionsPostItem):
+        translator = Translator()
+        f = open('apis/lang_name.json', "r")
+        available_langs = json.loads(f.read())
+        from_lang = 'en'
+        to_lang = 'en'
+        for lang_item in available_langs:
+            if item.to_language == lang_item['code']:
+                to_lang = item.to_language
+            if item.from_language == lang_item['code']:
+                from_lang = item.from_language
+
+        if to_lang == 'auto':
+            to_lang = 'en'
+
+        if from_lang == 'auto':
+            from_lang = translator.detect(item.input_text).lang
+
+        # Map ISO/lang codes to NLLB-200 language codes
+        nllb_code_map = {
+            'en': 'eng_Latn',
+            'am': 'amh_Ethi',
+            'ar': 'arb_Arab',
+            'ti': 'tir_Ethi',
+            'om': 'orm_Latn',
+            'so': 'som_Latn',
+            'ko': 'kor_Hang',
+            'zh-CN': 'zho_Hans',
+            'zh-TW': 'zho_Hant',
+            'fr': 'fra_Latn',
+            'de': 'deu_Latn',
+            'it': 'ita_Latn',
+            'ja': 'jpn_Jpan',
+        }
+
+        nllb_src = nllb_code_map.get(from_lang, 'eng_Latn')
+        nllb_tgt = nllb_code_map.get(to_lang, 'eng_Latn')
+
+        if torch.cuda.is_available():
+            device = torch.device("cuda:0")
+        else:
+            device = torch.device("cpu")
+            logging.warning("GPU not found, using CPU, translation will be very slow.")
+
+        time_start = time.time()
+        pretrained_model = "facebook/nllb-200-distilled-1.3B"
+        cache_dir = "models/"
+        tokenizer = AutoTokenizer.from_pretrained(pretrained_model, cache_dir=cache_dir)
+        model = AutoModelForSeq2SeqLM.from_pretrained(pretrained_model, cache_dir=cache_dir).to(device)
+        model.eval()
+
+        tokenizer.src_lang = nllb_src
+        with torch.no_grad():
+            encoded_input = tokenizer(item.input_text, return_tensors="pt").to(device)
+            generated_tokens = model.generate(
+                **encoded_input,
+                forced_bos_token_id=tokenizer.lang_code_to_id[nllb_tgt],
+            )
+            translated_text = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
+
+        time_end = time.time()
+        translated = translated_text
+        item_response = {
+            "from_language": from_lang,
+            "to_language": to_lang,
+            "text": item.input_text,
+            "translate": translated,
+            "start": str(time_start),
+            "end": str(time_end)
+        }
+        json_compatible_item_data = jsonable_encoder(item_response)
+        return JSONResponse(content=json_compatible_item_data)
+
+    
+    class DetectLanguagePostItem(BaseModel):
+        input_text: str = Field(
+            default="Hello, how are you?",
+            description="(str) `Text for detection`",
+        )
+
+    def detect_language(self, item: DetectLanguagePostItem):
+        translator = Translator()
+        detected = translator.detect(item.input_text)
+
+        item_response = {
+            "lang": detected.lang,
+            "confidence": detected.confidence,
+        }
+        json_compatible_item_data = jsonable_encoder(item_response)
+        return JSONResponse(content=json_compatible_item_data)
+        
+    def setup_routes(self):
+        for prefix in ["", "/v1"]:
+            self.app.get(
+                prefix + "/langs",
+                summary="Get available languages",
+            )(self.get_available_langs)
+
+            self.app.post(
+                prefix + "/translate",
+                summary="translate text",
+            )(self.translate_completions)
+
+            self.app.post(
+                prefix + "/translate/ai",
+                summary="translate text with ai",
+            )(self.translate_ai_completions)
+            
+            self.app.post(
+                prefix + "/detect",
+                summary="detect language",
+            )(self.detect_language)
+
+class ArgParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        super(ArgParser, self).__init__(*args, **kwargs)
+
+        self.add_argument(
+            "-s",
+            "--server",
+            type=str,
+            default="0.0.0.0",
+            help="Server IP for HF LLM Chat API",
+        )
+        self.add_argument(
+            "-p",
+            "--port",
+            type=int,
+            default=23333,
+            help="Server Port for HF LLM Chat API",
+        )
+
+        self.add_argument(
+            "-d",
+            "--dev",
+            default=False,
+            action="store_true",
+            help="Run in dev mode",
+        )
+
+        self.args = self.parse_args(sys.argv[1:])
+
+
+app = ChatAPIApp().app
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+    
+if __name__ == "__main__":
+    args = ArgParser().args
+    if args.dev:
+        uvicorn.run("__main__:app", host=args.server, port=args.port, reload=True)
+    else:
+        uvicorn.run("__main__:app", host=args.server, port=args.port, reload=False)
+
+    # python -m apis.chat_api      # [Docker] on product mode
+    # python -m apis.chat_api -d   # [Dev]    on develop mode

apis/lang_name.json

@@ -0,0 +1,17 @@
+[
+  { "code": "auto", "name": "Detect language" },
+  { "code": "en", "name": "English" },
+  { "code": "am", "name": "Amharic" },
+  { "code": "ar", "name": "Arabic" },
+  { "code": "ti", "name": "Tigrinya" },
+  { "code": "om", "name": "Oromo" },
+  { "code": "so", "name": "Somali" },
+  { "code": "ko", "name": "Korean" },
+  { "code": "zh-CN", "name": "Chinese (Simplified)" },
+  { "code": "zh-TW", "name": "Chinese (Traditional)" },
+  { "code": "fr", "name": "French" },
+  { "code": "de", "name": "German" },
+  { "code": "it", "name": "Italian" },
+  { "code": "ja", "name": "Japanese" }
+]
+

examples/__init__.py

@@ -0,0 +1 @@
+#source

examples/chat_with_openai.py

@@ -0,0 +1,25 @@
+from openai import OpenAI
+
+# If runnning this service with proxy, you might need to unset `http(s)_proxy`.
+base_url = "http://127.0.0.1:23333"
+api_key = "sk-xxxxx"
+
+client = OpenAI(base_url=base_url, api_key=api_key)
+response = client.chat.completions.create(
+    model="mixtral-8x7b",
+    messages=[
+        {
+            "role": "user",
+            "content": "what is your model",
+        }
+    ],
+    stream=True,
+)
+
+for chunk in response:
+    if chunk.choices[0].delta.content is not None:
+        print(chunk.choices[0].delta.content, end="", flush=True)
+    elif chunk.choices[0].finish_reason == "stop":
+        print()
+    else:
+        pass

examples/chat_with_post.py

@@ -0,0 +1,55 @@
+import ast
+import httpx
+import json
+import re
+
+# If runnning this service with proxy, you might need to unset `http(s)_proxy`.
+chat_api = "http://127.0.0.1:23333"
+api_key = "sk-xxxxx"
+requests_headers = {}
+requests_payload = {
+    "model": "mixtral-8x7b",
+    "messages": [
+        {
+            "role": "user",
+            "content": "what is your model",
+        }
+    ],
+    "stream": True,
+}
+
+with httpx.stream(
+    "POST",
+    chat_api + "/chat/completions",
+    headers=requests_headers,
+    json=requests_payload,
+    timeout=httpx.Timeout(connect=20, read=60, write=20, pool=None),
+) as response:
+    # https://docs.aiohttp.org/en/stable/streams.html
+    # https://github.com/openai/openai-cookbook/blob/main/examples/How_to_stream_completions.ipynb
+    response_content = ""
+    for line in response.iter_lines():
+        remove_patterns = [r"^\s*data:\s*", r"^\s*\[DONE\]\s*"]
+        for pattern in remove_patterns:
+            line = re.sub(pattern, "", line).strip()
+
+        if line:
+            try:
+                line_data = json.loads(line)
+            except Exception as e:
+                try:
+                    line_data = ast.literal_eval(line)
+                except:
+                    print(f"Error: {line}")
+                    raise e
+            # print(f"line: {line_data}")
+            delta_data = line_data["choices"][0]["delta"]
+            finish_reason = line_data["choices"][0]["finish_reason"]
+            if "role" in delta_data:
+                role = delta_data["role"]
+            if "content" in delta_data:
+                delta_content = delta_data["content"]
+                response_content += delta_content
+                print(delta_content, end="", flush=True)
+            if finish_reason == "stop":
+                print()

messagers/message_composer.py

@@ -0,0 +1,128 @@
+import re
+from pprint import pprint
+
+
+class MessageComposer:
+    """
+    models:
+    - mixtral-8x7b (mistralai/Mixtral-8x7B-Instruct-v0.1)
+    """
+
+    def __init__(self, model: str = None):
+        self.inst_roles = ["user", "system", "inst"]
+        self.answer_roles = ["assistant", "bot", "answer"]
+
+    def concat_messages_by_role(self, messages):
+        def is_same_role(role1, role2):
+            if (
+                (role1 == role2)
+                or (role1 in self.inst_roles and role2 in self.inst_roles)
+                or (role1 in self.answer_roles and role2 in self.answer_roles)
+            ):
+                return True
+            else:
+                return False
+
+        concat_messages = []
+        for message in messages:
+            role = message["role"]
+            content = message["content"]
+            if concat_messages and is_same_role(role, concat_messages[-1]["role"]):
+                concat_messages[-1]["content"] += "\n" + content
+            else:
+                if role in self.inst_roles:
+                    message["role"] = "inst"
+                elif role in self.answer_roles:
+                    message["role"] = "answer"
+                else:
+                    message["role"] = "inst"
+                concat_messages.append(message)
+        return concat_messages
+
+    def merge(self, messages) -> str:
+        # <s> [INST] Instruction [/INST] Model answer </s> [INST] Follow-up instruction [/INST]
+
+        self.messages = self.concat_messages_by_role(messages)
+        self.merged_str = ""
+        self.cached_str = ""
+        for message in self.messages:
+            role = message["role"]
+            content = message["content"]
+            if role in self.inst_roles:
+                self.cached_str = f"[INST] {content} [/INST]"
+            elif role in self.answer_roles:
+                self.merged_str += f"<s> {self.cached_str} {content} </s>\n"
+                self.cached_str = ""
+            else:
+                self.cached_str = f"[INST] {content} [/INST]"
+        if self.cached_str:
+            self.merged_str += f"{self.cached_str}"
+
+        return self.merged_str
+
+    def split(self, merged_str) -> list:
+        self.messages = []
+        self.merged_str = merged_str
+        pair_pattern = (
+            r"<s>\s*\[INST\](?P<inst>[\s\S]*?)\[/INST\](?P<answer>[\s\S]*?)</s>"
+        )
+        pair_matches = re.finditer(pair_pattern, self.merged_str, re.MULTILINE)
+        pair_matches_list = list(pair_matches)
+
+        if len(pair_matches_list) <= 0:
+            self.messages = [
+                {
+                    "role": "user",
+                    "content": self.merged_str,
+                }
+            ]
+        else:
+            for match in pair_matches_list:
+                inst = match.group("inst")
+                answer = match.group("answer")
+                self.messages.extend(
+                    [
+                        {"role": "user", "content": inst.strip()},
+                        {"role": "assistant", "content": answer.strip()},
+                    ]
+                )
+
+        inst_pattern = r"\[INST\](?P<inst>[\s\S]*?)\[/INST\]"
+        inst_matches = re.finditer(inst_pattern, self.merged_str, re.MULTILINE)
+        inst_matches_list = list(inst_matches)
+
+        if len(inst_matches_list) > len(pair_matches_list):
+            self.messages.extend(
+                [
+                    {
+                        "role": "user",
+                        "content": inst_matches_list[-1].group("inst").strip(),
+                    }
+                ]
+            )
+
+        return self.messages
+
+
+if __name__ == "__main__":
+    composer = MessageComposer()
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a LLM developed by OpenAI. Your name is GPT-4.",
+        },
+        {"role": "user", "content": "Hello, who are you?"},
+        {"role": "assistant", "content": "I am a bot."},
+        # {"role": "user", "content": "What is your name?"},
+        {"role": "assistant", "content": "My name is Bing."},
+        # {"role": "user", "content": "Tell me a joke."},
+        # {"role": "assistant", "content": "What is a robot's favorite type of music?"},
+        # {
+        #     "role": "user",
+        #     "content": "How many questions have I asked? Please list them.",
+        # },
+    ]
+    merged_str = composer.merge(messages)
+    print(merged_str)
+    pprint(composer.split(merged_str))
+    # print(composer.merge(composer.split(merged_str)))

messagers/message_outputer.py

@@ -0,0 +1,63 @@
+import json
+
+
+class OpenaiStreamOutputer:
+    """
+    Create chat completion - OpenAI API Documentation
+    * https://platform.openai.com/docs/api-reference/chat/create
+    """
+
+    def data_to_string(self, data={}, content_type=""):
+        data_str = f"{json.dumps(data)}"
+
+        return data_str
+
+    def output(self, content=None, content_type="Completions") -> str:
+        data = {
+            "created": 1700000000,
+            "id": "chatcmpl-hugginface",
+            "object": "chat.completion.chunk",
+            # "content_type": content_type,
+            "model": "hugginface",
+            "choices": [],
+        }
+        if content_type == "Role":
+            data["choices"] = [
+                {
+                    "index": 0,
+                    "delta": {"role": "assistant"},
+                    "finish_reason": None,
+                }
+            ]
+        elif content_type in [
+            "Completions",
+            "InternalSearchQuery",
+            "InternalSearchResult",
+            "SuggestedResponses",
+        ]:
+            if content_type in ["InternalSearchQuery", "InternalSearchResult"]:
+                content += "\n"
+            data["choices"] = [
+                {
+                    "index": 0,
+                    "delta": {"content": content},
+                    "finish_reason": None,
+                }
+            ]
+        elif content_type == "Finished":
+            data["choices"] = [
+                {
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": "stop",
+                }
+            ]
+        else:
+            data["choices"] = [
+                {
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": None,
+                }
+            ]
+        return self.data_to_string(data, content_type)

networks/message_streamer.py

@@ -0,0 +1,97 @@
+import json
+import re
+import requests
+from messagers.message_outputer import OpenaiStreamOutputer
+from utils.logger import logger
+from utils.enver import enver
+
+
+class MessageStreamer:
+    MODEL_MAP = {
+        "mixtral-8x7b": "mistralai/Mixtral-8x7B-Instruct-v0.1",  # 72.62, fast [Recommended]
+        "mistral-7b": "mistralai/Mistral-7B-Instruct-v0.2",  # 65.71, fast
+        "openchat-3.5": "openchat/openchat_3.5",  # 61.24, fast
+        # "zephyr-7b-alpha": "HuggingFaceH4/zephyr-7b-alpha",  # 59.5, fast
+        # "zephyr-7b-beta": "HuggingFaceH4/zephyr-7b-beta",  # 61.95, slow
+        "default": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    }
+
+    def __init__(self, model: str):
+        if model in self.MODEL_MAP.keys():
+            self.model = model
+        else:
+            self.model = "default"
+        self.model_fullname = self.MODEL_MAP[self.model]
+        self.message_outputer = OpenaiStreamOutputer()
+
+    def parse_line(self, line):
+        line = line.decode("utf-8")
+        line = re.sub(r"data:\s*", "", line)
+        data = json.loads(line)
+        content = data["token"]["text"]
+        return content
+
+    def chat(
+        self,
+        prompt: str = None,
+        temperature: float = 0.01,
+        max_new_tokens: int = 8192,
+        stream: bool = True,
+        yield_output: bool = False,
+    ):
+        # https://huggingface.co/docs/api-inference/detailed_parameters?code=curl
+        # curl --proxy http://<server>:<port> https://api-inference.huggingface.co/models/<org>/<model_name> -X POST -d '{"inputs":"who are you?","parameters":{"max_new_token":64}}' -H 'Content-Type: application/json' -H 'Authorization: Bearer <HF_TOKEN>'
+        self.request_url = (
+            f"https://api-inference.huggingface.co/models/{self.model_fullname}"
+        )
+        self.request_headers = {
+            "Content-Type": "application/json",
+        }
+        # References:
+        #   huggingface_hub/inference/_client.py:
+        #     class InferenceClient > def text_generation()
+        #   huggingface_hub/inference/_text_generation.py:
+        #     class TextGenerationRequest > param `stream`
+        # https://huggingface.co/docs/text-generation-inference/conceptual/streaming#streaming-with-curl
+        self.request_body = {
+            "inputs": prompt,
+            "parameters": {
+                "temperature": max(temperature, 0.01),  # must be positive
+                "max_new_tokens": max_new_tokens,
+                "return_full_text": False,
+            },
+            "stream": stream,
+        }
+        logger.back(self.request_url)
+        enver.set_envs(proxies=True)
+        stream = requests.post(
+            self.request_url,
+            headers=self.request_headers,
+            json=self.request_body,
+            proxies=enver.requests_proxies,
+            stream=stream,
+        )
+        status_code = stream.status_code
+        if status_code == 200:
+            logger.success(status_code)
+        else:
+            logger.err(status_code)
+
+        for line in stream.iter_lines():
+            if not line:
+                continue
+
+            content = self.parse_line(line)
+
+            if content.strip() == "</s>":
+                content_type = "Finished"
+                logger.success("\n[Finished]")
+            else:
+                content_type = "Completions"
+                logger.back(content, end="")
+
+            if yield_output:
+                output = self.message_outputer.output(
+                    content=content, content_type=content_type
+                )
+                yield output

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+pydantic
+uvicorn
+googletrans==3.1.0a0
+torch
+transformers
+transformers[sentencepiece]
+requests
+termcolor

utils/__init__.py

@@ -0,0 +1,69 @@
+import json
+import requests
+import os
+
+from pathlib import Path
+
+
+class OSEnver:
+    def __init__(self):
+        self.envs_stack = []
+        self.envs = os.environ.copy()
+
+    def store_envs(self):
+        self.envs_stack.append(self.envs)
+
+    def restore_envs(self):
+        self.envs = self.envs_stack.pop()
+        if self.global_scope:
+            os.environ = self.envs
+
+    def set_envs(self, secrets=True, proxies=None, store_envs=True):
+        # caller_info = inspect.stack()[1]
+        # logger.back(f"OS Envs is set by: {caller_info.filename}")
+
+        if store_envs:
+            self.store_envs()
+
+        if secrets:
+            secrets_path = Path(__file__).parents[1] / "secrets.json"
+            if secrets_path.exists():
+                with open(secrets_path, "r") as rf:
+                    secrets = json.load(rf)
+            else:
+                secrets = {}
+
+        if proxies:
+            for proxy_env in ["http_proxy", "https_proxy"]:
+                if isinstance(proxies, str):
+                    self.envs[proxy_env] = proxies
+                elif "http_proxy" in secrets.keys():
+                    self.envs[proxy_env] = secrets["http_proxy"]
+                elif os.getenv("http_proxy"):
+                    self.envs[proxy_env] = os.getenv("http_proxy")
+                else:
+                    continue
+
+        self.proxy = (
+            self.envs.get("all_proxy")
+            or self.envs.get("http_proxy")
+            or self.envs.get("https_proxy")
+            or None
+        )
+        self.requests_proxies = {
+            "http": self.proxy,
+            "https": self.proxy,
+        }
+
+        # https://www.proxynova.com/proxy-server-list/country-us/
+
+        print(f"Using proxy: [{self.proxy}]")
+        # r = requests.get(
+        #     "http://ifconfig.me/ip",
+        #     proxies=self.requests_proxies,
+        #     timeout=10,
+        # )
+        # print(f"[r.status_code] r.text")
+
+
+enver = OSEnver()

utils/enver.py

@@ -0,0 +1,60 @@
+import json
+import os
+
+from pathlib import Path
+from utils.logger import logger
+
+
+class OSEnver:
+    def __init__(self):
+        self.envs_stack = []
+        self.envs = os.environ.copy()
+
+    def store_envs(self):
+        self.envs_stack.append(self.envs)
+
+    def restore_envs(self):
+        self.envs = self.envs_stack.pop()
+
+    def set_envs(self, secrets=True, proxies=None, store_envs=True):
+        # caller_info = inspect.stack()[1]
+        # logger.back(f"OS Envs is set by: {caller_info.filename}")
+
+        if store_envs:
+            self.store_envs()
+
+        if secrets:
+            secrets_path = Path(__file__).parents[1] / "secrets.json"
+            if secrets_path.exists():
+                with open(secrets_path, "r") as rf:
+                    secrets = json.load(rf)
+            else:
+                secrets = {}
+
+        if proxies:
+            for proxy_env in ["http_proxy", "https_proxy"]:
+                if isinstance(proxies, str):
+                    self.envs[proxy_env] = proxies
+                elif "http_proxy" in secrets.keys():
+                    self.envs[proxy_env] = secrets["http_proxy"]
+                elif os.getenv("http_proxy"):
+                    self.envs[proxy_env] = os.getenv("http_proxy")
+                else:
+                    continue
+
+        self.proxy = (
+            self.envs.get("all_proxy")
+            or self.envs.get("http_proxy")
+            or self.envs.get("https_proxy")
+            or None
+        )
+        self.requests_proxies = {
+            "http": self.proxy,
+            "https": self.proxy,
+        }
+
+        if self.proxy:
+            logger.note(f"Using proxy: [{self.proxy}]")
+
+
+enver = OSEnver()

utils/logger.py

@@ -0,0 +1,269 @@
+import datetime
+import functools
+import inspect
+import logging
+import os
+import shutil
+import subprocess
+from termcolor import colored
+
+
+def add_fillers(text, filler="=", fill_side="both"):
+    terminal_width = shutil.get_terminal_size().columns
+    text = text.strip()
+    text_width = len(text)
+    if text_width >= terminal_width:
+        return text
+
+    if fill_side[0].lower() == "b":
+        leading_fill_str = filler * ((terminal_width - text_width) // 2 - 1) + " "
+        trailing_fill_str = " " + filler * (
+            terminal_width - text_width - len(leading_fill_str) - 1
+        )
+    elif fill_side[0].lower() == "l":
+        leading_fill_str = filler * (terminal_width - text_width - 1) + " "
+        trailing_fill_str = ""
+    elif fill_side[0].lower() == "r":
+        leading_fill_str = ""
+        trailing_fill_str = " " + filler * (terminal_width - text_width - 1)
+    else:
+        raise ValueError("Invalid fill_side")
+
+    filled_str = f"{leading_fill_str}{text}{trailing_fill_str}"
+    return filled_str
+
+
+class OSLogger(logging.Logger):
+    LOG_METHODS = {
+        "err": ("error", "red"),
+        "warn": ("warning", "light_red"),
+        "note": ("info", "light_magenta"),
+        "mesg": ("info", "light_cyan"),
+        "file": ("info", "light_blue"),
+        "line": ("info", "white"),
+        "success": ("info", "light_green"),
+        "fail": ("info", "light_red"),
+        "back": ("debug", "light_cyan"),
+    }
+    INDENT_METHODS = [
+        "indent",
+        "set_indent",
+        "reset_indent",
+        "store_indent",
+        "restore_indent",
+        "log_indent",
+    ]
+    LEVEL_METHODS = [
+        "set_level",
+        "store_level",
+        "restore_level",
+        "quiet",
+        "enter_quiet",
+        "exit_quiet",
+    ]
+    LEVEL_NAMES = {
+        "critical": logging.CRITICAL,
+        "error": logging.ERROR,
+        "warning": logging.WARNING,
+        "info": logging.INFO,
+        "debug": logging.DEBUG,
+    }
+
+    def __init__(self, name=None, prefix=False):
+        if not name:
+            frame = inspect.stack()[1]
+            module = inspect.getmodule(frame[0])
+            name = module.__name__
+
+        super().__init__(name)
+        self.setLevel(logging.INFO)
+
+        if prefix:
+            formatter_prefix = "[%(asctime)s] - [%(name)s] - [%(levelname)s]\n"
+        else:
+            formatter_prefix = ""
+
+        self.formatter = logging.Formatter(formatter_prefix + "%(message)s")
+
+        stream_handler = logging.StreamHandler()
+        stream_handler.setLevel(logging.INFO)
+        stream_handler.setFormatter(self.formatter)
+        self.addHandler(stream_handler)
+
+        self.log_indent = 0
+        self.log_indents = []
+
+        self.log_level = "info"
+        self.log_levels = []
+
+    def indent(self, indent=2):
+        self.log_indent += indent
+
+    def set_indent(self, indent=2):
+        self.log_indent = indent
+
+    def reset_indent(self):
+        self.log_indent = 0
+
+    def store_indent(self):
+        self.log_indents.append(self.log_indent)
+
+    def restore_indent(self):
+        self.log_indent = self.log_indents.pop(-1)
+
+    def set_level(self, level):
+        self.log_level = level
+        self.setLevel(self.LEVEL_NAMES[level])
+
+    def store_level(self):
+        self.log_levels.append(self.log_level)
+
+    def restore_level(self):
+        self.log_level = self.log_levels.pop(-1)
+        self.set_level(self.log_level)
+
+    def quiet(self):
+        self.set_level("critical")
+
+    def enter_quiet(self, quiet=False):
+        if quiet:
+            self.store_level()
+            self.quiet()
+
+    def exit_quiet(self, quiet=False):
+        if quiet:
+            self.restore_level()
+
+    def log(
+        self,
+        level,
+        color,
+        msg,
+        indent=0,
+        fill=False,
+        fill_side="both",
+        end="\n",
+        *args,
+        **kwargs,
+    ):
+        if type(msg) == str:
+            msg_str = msg
+        else:
+            msg_str = repr(msg)
+            quotes = ["'", '"']
+            if msg_str[0] in quotes and msg_str[-1] in quotes:
+                msg_str = msg_str[1:-1]
+
+        indent_str = " " * (self.log_indent + indent)
+        indented_msg = "\n".join([indent_str + line for line in msg_str.split("\n")])
+
+        if fill:
+            indented_msg = add_fillers(indented_msg, fill_side=fill_side)
+
+        handler = self.handlers[0]
+        handler.terminator = end
+
+        getattr(self, level)(colored(indented_msg, color), *args, **kwargs)
+
+    def route_log(self, method, msg, *args, **kwargs):
+        level, method = method
+        functools.partial(self.log, level, method, msg)(*args, **kwargs)
+
+    def err(self, msg: str = "", *args, **kwargs):
+        self.route_log(("error", "red"), msg, *args, **kwargs)
+
+    def warn(self, msg: str = "", *args, **kwargs):
+        self.route_log(("warning", "light_red"), msg, *args, **kwargs)
+
+    def note(self, msg: str = "", *args, **kwargs):
+        self.route_log(("info", "light_magenta"), msg, *args, **kwargs)
+
+    def mesg(self, msg: str = "", *args, **kwargs):
+        self.route_log(("info", "light_cyan"), msg, *args, **kwargs)
+
+    def file(self, msg: str = "", *args, **kwargs):
+        self.route_log(("info", "light_blue"), msg, *args, **kwargs)
+
+    def line(self, msg: str = "", *args, **kwargs):
+        self.route_log(("info", "white"), msg, *args, **kwargs)
+
+    def success(self, msg: str = "", *args, **kwargs):
+        self.route_log(("info", "light_green"), msg, *args, **kwargs)
+
+    def fail(self, msg: str = "", *args, **kwargs):
+        self.route_log(("info", "light_red"), msg, *args, **kwargs)
+
+    def back(self, msg: str = "", *args, **kwargs):
+        self.route_log(("debug", "light_cyan"), msg, *args, **kwargs)
+
+
+logger = OSLogger()
+
+
+def shell_cmd(cmd, getoutput=False, showcmd=True, env=None):
+    if showcmd:
+        logger.info(colored(f"\n$ [{os.getcwd()}]", "light_blue"))
+        logger.info(colored(f"  $ {cmd}\n", "light_cyan"))
+    if getoutput:
+        output = subprocess.getoutput(cmd, env=env)
+        return output
+    else:
+        subprocess.run(cmd, shell=True, env=env)
+
+
+class Runtimer:
+    def __enter__(self):
+        self.t1, _ = self.start_time()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.t2, _ = self.end_time()
+        self.elapsed_time(self.t2 - self.t1)
+
+    def start_time(self):
+        t1 = datetime.datetime.now()
+        self.logger_time("start", t1)
+        return t1, self.time2str(t1)
+
+    def end_time(self):
+        t2 = datetime.datetime.now()
+        self.logger_time("end", t2)
+        return t2, self.time2str(t2)
+
+    def elapsed_time(self, dt=None):
+        if dt is None:
+            dt = self.t2 - self.t1
+        self.logger_time("elapsed", dt)
+        return dt, self.time2str(dt)
+
+    def logger_time(self, time_type, t):
+        time_types = {
+            "start": "Start",
+            "end": "End",
+            "elapsed": "Elapsed",
+        }
+        time_str = add_fillers(
+            colored(
+                f"{time_types[time_type]} time: [ {self.time2str(t)} ]",
+                "light_magenta",
+            ),
+            fill_side="both",
+        )
+        logger.line(time_str)
+
+    # Convert time to string
+    def time2str(self, t):
+        datetime_str_format = "%Y-%m-%d %H:%M:%S"
+        if isinstance(t, datetime.datetime):
+            return t.strftime(datetime_str_format)
+        elif isinstance(t, datetime.timedelta):
+            hours = t.seconds // 3600
+            hour_str = f"{hours} hr" if hours > 0 else ""
+            minutes = (t.seconds // 60) % 60
+            minute_str = f"{minutes:>2} min" if minutes > 0 else ""
+            seconds = t.seconds % 60
+            second_str = f"{seconds:>2} s"
+            time_str = " ".join([hour_str, minute_str, second_str]).strip()
+            return time_str
+        else:
+            return str(t)