LocalAdapt 0.1.0__tar.gz

localadapt-0.1.0/LocalAdapt/__init__.py

@@ -0,0 +1,19 @@
+import os
+
+def _ensure_runtime():
+    try:
+        from . import adapters, test
+        return True
+    except ImportError:
+        return False
+
+if not _ensure_runtime():
+    try:
+        from . import install
+        install.main()
+
+        # Nach Installation nochmal versuchen
+        from . import adapters, test
+
+    except Exception as e:
+        print("LocalAdapt initialization failed:", e)

localadapt-0.1.0/LocalAdapt/adapters/__init__.py

@@ -0,0 +1,7 @@
+from .router import Router
+from .llm import LLMAdapter
+
+router = Router()
+llmAdapt = LLMAdapter()
+
+router.register_adapter(llmAdapt)

localadapt-0.1.0/LocalAdapt/adapters/base_adapter.py

@@ -0,0 +1,41 @@
+# adapters/router.py
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from PIL import Image
+
+@dataclass
+class Value:
+    text:str = None
+    image:Image = None
+    path:str = None
+    done:bool = False
+
+class BaseAdapter(ABC):
+    def __init__(self):
+        super().__init__()
+        self.model = None
+
+    @abstractmethod
+    def supports(self, request: dict) -> bool:
+        """Return True if this adapter can handle the request."""
+        pass
+
+    @abstractmethod
+    def register_model(self, **kwargs):
+        """Return a Dataclass for the given model and parameters."""
+        pass
+
+    @abstractmethod
+    def load(self, model):
+        """Loads an model into the Adapter(Lazy load)."""
+        pass
+
+    @abstractmethod
+    def unload(self):
+        """Unloads the loaded model."""
+        self.model = None
+
+    @abstractmethod
+    def run(self, request) -> Value:
+        """Runs the loaded model with the given request and returns the result as an Value object."""
+        pass

localadapt-0.1.0/LocalAdapt/adapters/llm.py

@@ -0,0 +1,121 @@
+from .base_adapter import BaseAdapter, Value
+from dataclasses import dataclass
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+import threading
+
+
+@dataclass
+class LLM:
+    model_path: str
+    device: str = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+class LLMAdapter(BaseAdapter):
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+
+    def supports(self, request):
+        return request.get("type") == "llm"
+
+    def register_model(self, **kwargs) -> LLM:
+        return LLM(**kwargs)
+
+    def load(self, model: LLM):
+        self.tokenizer = AutoTokenizer.from_pretrained(model.model_path)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model.model_path
+        ).to(model.device)
+
+        print(f"Model {model.model_path} loaded")
+        print(f"You can now run it on {model.device}")
+
+    def unload(self):
+        if self.model:
+            del self.model
+            self.model = None
+
+        if self.tokenizer:
+            del self.tokenizer
+            self.tokenizer = None
+
+        torch.cuda.empty_cache()
+        return super().unload()
+
+    def run(self, request: dict) -> Value:
+        if not self.model or not self.tokenizer:
+            raise ValueError("You have to load a model first!")
+
+        prompt = request.get("prompt", "")
+        max_new_tokens = request.get("max_length", 100)
+        stream = request.get("stream", False)
+        do_sample = request.get("do_sample", True)
+        temperature = request.get("temperature", 1.0)
+
+        result = Value(text="")
+
+        messages = request.get("history", []).copy()
+
+        inputs = self.tokenizer.apply_chat_template(
+            messages,
+            return_tensors="pt",
+            add_generation_prompt=True
+        ).to(self.model.device)
+
+        if stream:
+            streamer = TextIteratorStreamer(
+                self.tokenizer,
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=False
+            )
+
+            def generate():
+                with torch.no_grad():
+                    top_p = request.get("top_p", 0.9)
+                    repetition_penalty = request.get("repetition_penalty", 1.1)
+                    self.model.generate(
+                        **inputs,
+                        max_new_tokens=max_new_tokens,
+                        do_sample=do_sample,
+                        temperature=temperature,
+                        eos_token_id=self.tokenizer.eos_token_id,
+                        pad_token_id=self.tokenizer.eos_token_id,
+                        streamer=streamer,
+                        top_p=top_p,
+                        repetition_penalty=repetition_penalty
+                    )
+
+            threading.Thread(target=generate, daemon=True).start()
+
+            def stream_output():
+                for text in streamer:
+                    result.text += text
+                result.done = True
+
+            threading.Thread(target=stream_output, daemon=True).start()
+
+            return result
+
+        else:
+            with torch.no_grad():
+                output_ids = self.model.generate(
+                    **inputs,
+                    max_new_tokens=max_new_tokens,
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    eos_token_id=self.tokenizer.eos_token_id,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+
+            input_length = inputs["input_ids"].shape[1]
+            new_tokens = output_ids[0][input_length:]
+
+            result.text = self.tokenizer.decode(
+                new_tokens,
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=False
+            )
+            result.done = True
+
+            return result

localadapt-0.1.0/LocalAdapt/adapters/router.py

@@ -0,0 +1,16 @@
+from .base_adapter import BaseAdapter, Value
+
+class Router:
+    def __init__(self):
+        self.adapters:list[BaseAdapter] = []
+
+    def register_adapter(self, adapter:BaseAdapter):
+        self.adapters.append(adapter)
+    
+    def route(self, request:dict):
+        for adapter in self.adapters:
+            if adapter.supports(request):
+                if adapter.model is None:
+                    adapter.load(adapter.register_model(**request.get("model_kwargs", {})))
+                return adapter.run(request)
+        raise ValueError(f"Couldn't find adapter for request: {request}")

localadapt-0.1.0/LocalAdapt/common.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+class Color(Enum):
+    RESET = "\033[0m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+
+def print_col(txt, col:Color, pref="", suff=""):
+    print(f"{pref}{col.value}{txt}{Color.RESET.value}{suff}")

localadapt-0.1.0/LocalAdapt/install.py

@@ -0,0 +1,52 @@
+import subprocess
+import sys
+from . import common
+import shutil
+
+# ===========================
+# Hilfsfunktionen
+# ===========================
+
+def run(cmd):
+    """Führt Shell-Befehle aus und bricht bei Fehlern ab."""
+    common.print_col(cmd, common.Color.CYAN, pref="> ")
+    result = subprocess.run(cmd, shell=True)
+    if result.returncode != 0:
+        common.print_col(f"Fehler beim Ausführen: {cmd}", common.Color.RED)
+        sys.exit(1)
+
+def write_requirements(packages):
+    with open("requirements.txt", "w") as f:
+        for pkg in packages:
+            f.write(f"{pkg}\n")
+    common.print_col("requirements.txt erstellt!", common.Color.BLUE)
+
+def main():
+    common.print_col("Upgrading pip if necessary...", common.Color.BLUE)
+    run("python.exe -m pip install --upgrade pip")
+
+    common.print_col("Checking CUDA avaibility...", common.Color.BLUE)
+    cuda_available = False
+    if shutil.which("nvidia-smi") is not None:
+        try:
+            output = subprocess.check_output("nvidia-smi", shell=True)
+            if b"NVIDIA" in output:
+                cuda_available = True
+        except subprocess.CalledProcessError:
+            cuda_available = False
+
+    packages = ["transformers", "Pillow", "PySide6"]
+
+    if cuda_available:
+        common.print_col("CUDA-enabled GPU detected! Install PyTorch with CUDA...", common.Color.BLUE)
+        packages.append("torch --index-url https://download.pytorch.org/whl/cu121")
+    else:
+        common.print_col("No CUDA GPU found. Installing CPU version of PyTorch...", common.Color.YELLOW)
+        packages.append("torch")
+
+    for pkg in packages:
+        run(f"{sys.executable} -m pip install {pkg}")
+
+    write_requirements(packages)
+
+    common.print_col("Installation abgeschlossen ✅", common.Color.GREEN)

localadapt-0.1.0/LocalAdapt/test.py

@@ -0,0 +1,53 @@
+from .adapters import router
+import os
+import time
+
+def main():
+    print("Start")
+
+    os.environ["HF_HOME"] = "D:/AnyAI/models"
+
+    model_path = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+    max_length = 200
+
+    request = {
+        "type": "llm",
+        "max_length": max_length,
+        "do_sample": True,
+        "temperature": 0.8,
+        "stream": True,
+        "history": [],
+        "model_kwargs": {
+            "model_path": model_path
+        }
+    }
+    router.adapters[0].load(router.adapters[0].register_model(**request["model_kwargs"]))
+    os.system("cls")
+    # Repl-artige Schleife
+    history = [{"role": "system", "content": """You are a helpful and concise assistant. 
+    Answer the user questions factually and briefly.
+    Do not provide examples, do not speculate, do not invent code or explanations unless explicitly asked.
+    Stop after giving a direct answer."""}]
+    while True:
+        prompt = input(">>> ")
+        request["prompt"] = prompt
+        history.append({"role": "user", "content": prompt})
+        request["history"] = history
+        result = router.route(request)
+
+        last_len = 0
+        while True:
+            if len(result.text) > last_len:
+                print(result.text[last_len:], end="", flush=True)
+                last_len = len(result.text)
+
+            # Check if stream finished
+            if getattr(result, "done", False):
+                print()  # Neue Zeile am Ende
+                break
+
+            time.sleep(0.05)
+        history.append({"role": "assistant", "content": result.text})
+
+if __name__ == '__main__':
+    main()

localadapt-0.1.0/LocalAdapt.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: LocalAdapt
+Version: 0.1.0
+Summary: Local AI Model adapters
+Author: Nathan Lange

localadapt-0.1.0/LocalAdapt.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+pyproject.toml
+LocalAdapt/__init__.py
+LocalAdapt/common.py
+LocalAdapt/install.py
+LocalAdapt/test.py
+LocalAdapt.egg-info/PKG-INFO
+LocalAdapt.egg-info/SOURCES.txt
+LocalAdapt.egg-info/dependency_links.txt
+LocalAdapt.egg-info/top_level.txt
+LocalAdapt/adapters/__init__.py
+LocalAdapt/adapters/base_adapter.py
+LocalAdapt/adapters/diffusion.py
+LocalAdapt/adapters/ersgan.py
+LocalAdapt/adapters/llm.py
+LocalAdapt/adapters/router.py

localadapt-0.1.0/LocalAdapt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

localadapt-0.1.0/LocalAdapt.egg-info/top_level.txt

@@ -0,0 +1 @@
+LocalAdapt

localadapt-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: LocalAdapt
+Version: 0.1.0
+Summary: Local AI Model adapters
+Author: Nathan Lange

localadapt-0.1.0/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "LocalAdapt"
+version = "0.1.0"
+description = "Local AI Model adapters"
+authors = [{name = "Nathan Lange"}]
+
+dependencies = []

localadapt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+