pylizlib 0.0.6__tar.gz

pylizlib-0.0.6/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: pylizlib
+Version: 0.0.6
+Summary: Personal python library for general purposes.
+Author: Gabliz
+Author-email: 
+Keywords: python,video,ai,utilities
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Description-Content-Type: text/markdown
+
+
+# PYLIZ
+My personal Python library for various tasks.

pylizlib-0.0.6/README.md

@@ -0,0 +1,2 @@
+# PYLIZ
+My personal Python library for various tasks.

pylizlib-0.0.6/ai/controller/llava_controller.py

@@ -0,0 +1,73 @@
+import base64
+import json
+import os
+
+from ai.core.ai_method import AiMethod
+from ai.core.ai_setting import AiSettings
+from ai.llm.local.llamacpp import LlamaCpp
+from ai.llm.remote.service.ollamaliz import Ollamaliz
+from model.liz_image import LizImage
+from model.operation import Operation
+from util.pylizdir import PylizDir
+
+
+class LlavaController:
+
+    def __init__(self, settings: AiSettings):
+        self.settings = settings
+
+    def __run_from_ollama(self, image_path: str) -> Operation[str]:
+        ollama = Ollamaliz(self.settings.remote_url)
+        model_name = self.settings.source.ollama_name
+        with open(image_path, "rb") as image_file:
+            image_base_64 = base64.b64encode(image_file.read()).decode('utf-8')
+        llava_result = ollama.llava_query(self.settings.prompt.value, image_base_64, model_name)
+        if not llava_result.is_op_ok():
+            return Operation(status=False, error=llava_result.error)
+        return Operation(status=True, payload=llava_result.payload.response)
+
+    def __run_from_local_llamacpp(self, image_path: str) -> Operation[str]:
+        PylizDir.create()
+        path_install: str = os.path.join(PylizDir.get_ai_folder(), "llama.cpp")
+        path_models: str = PylizDir.get_models_folder()
+        path_logs: str = os.path.join(PylizDir.get_logs_path(), "llama.cpp")
+        obj = LlamaCpp(path_install, path_models, path_logs)
+        obj.install_llava(self.settings.power, lambda x: None, lambda x: None)
+        llava_result = obj.run_llava(self.settings.power, image_path, self.settings.prompt.value)
+        if not llava_result.is_op_ok():
+            return Operation(status=False, error=llava_result.error)
+        return Operation(status=True, payload=llava_result.payload)
+
+    def __get_image_from_json(self, output: str, image_path: str) -> Operation[LizImage]:
+        info_json = json.loads(output)
+        output_image = LizImage(image_path)
+        output_image.set_ai_filename(info_json.get("filename")) if self.settings.scan_settings.ai_rename else None
+        output_image.set_ai_description(info_json.get("description")) if self.settings.scan_settings.ai_comment else None
+        output_image.set_ai_tags(info_json.get("tags")) if self.settings.scan_settings.ai_tags else None
+        output_image.set_ai_text(info_json.get("text")) if self.settings.scan_settings.ai_ocr else None
+        output_image.set_ai_scanned(True)
+        return Operation(status=True, payload=output_image)
+
+
+    # def run(self, image_path: str) -> Operation[str]:
+    #     if self.settings.method == AiMethod.LLAVA_OLLAMA:
+    #         return self.__run_from_ollama(image_path)
+    #     elif self.settings.method == AiMethod.LLAVA_LOCAL_LLAMACPP:
+    #         return self.__run_from_local_llamacpp(image_path)
+    #     else:
+    #         raise NotImplementedError("This method is not implemented.")
+
+
+    def run_and_get_liz_media(self, image_path: str) -> Operation[LizImage]:
+        if self.settings.method == AiMethod.LLAVA_OLLAMA_JSON:
+            op = self.__run_from_ollama(image_path)
+            if not op.is_op_ok():
+                return Operation(status=False, error=op.error)
+            return self.__get_image_from_json(op.payload, image_path)
+        elif self.settings.method == AiMethod.LLAVA_LLAMACPP_JSON:
+            op = self.__run_from_local_llamacpp(image_path)
+            if not op.is_op_ok():
+                return Operation(status=False, error=op.error)
+            return self.__get_image_from_json(op.payload, image_path)
+        else:
+            raise NotImplementedError("Current Aimethod is not implemented for this function.")

pylizlib-0.0.6/ai/core/ai_method.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class AiMethod(Enum):
+    # LLAVA_OLLAMA = "LLAVA with ollama server"
+    # LLAVA_LOCAL_LLAMACPP = "LLAVA with local power"
+    # LLAVA_LLAMACPP_AFTER_OLLAMA = "LLAVA with ollama and llamacpp"
+
+    LLAVA_OLLAMA_JSON = "LLAVA with ollama server"
+    LLAVA_LLAMACPP_JSON = "LLAVA with local power"

pylizlib-0.0.6/ai/core/ai_model_list.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class AiModelList(Enum):
+    LLAVA = "llava"
+    WHISPER = "whisper"

pylizlib-0.0.6/ai/core/ai_models.py

@@ -0,0 +1,58 @@
+from ai.core.ai_method import AiMethod
+from ai.core.ai_power import AiPower
+from ai.core.ai_source import AiSource
+from ai.core.ai_source_type import AiSourceType
+from ai.core.hg_file import HgFile
+from model.file_type import FileType
+
+
+class AiModels:
+
+    llava_15_7b_mmproj_f16 = HgFile("mmproj-model-f16.gguf", "https://huggingface.co/mys/ggml_llava-v1.5-7b/resolve/main/mmproj-model-f16.gguf", FileType.HG_MMPROJ)
+    llava_15_7b_ggml_model_q4 = HgFile("ggml-model-q4_k.gguf", "https://huggingface.co/mys/ggml_llava-v1.5-7b/resolve/main/ggml-model-q4_k.gguf", FileType.HG_GGML)
+    llava_15_7b_bundle = [llava_15_7b_mmproj_f16, llava_15_7b_ggml_model_q4]
+    llava_15_7b_name = "llava157b"
+
+
+
+    def __init__(self):
+        pass
+
+
+    class Llava:
+
+        @staticmethod
+        def get_llava(power: AiPower, source: AiSourceType) -> AiSource:
+            if power == AiPower.LOW:
+                return AiModels.Llava.get_llava_power_low(source)
+            elif power == AiPower.MEDIUM:
+                return AiModels.Llava.get_llava_power_medium(source)
+            elif power == AiPower.HIGH:
+                return AiModels.Llava.get_llava_power_high(source)
+            raise Exception("No model found for the given power and method.")
+
+        @staticmethod
+        def get_llava_power_low(source: AiSourceType) -> AiSource:
+            if source == AiSourceType.OLLAMA_SERVER:
+                return AiSource(ollama_name="llava:7b")
+            if source == AiSourceType.LOCAL_LLAMACPP:
+                return AiSource(local_name=AiModels.llava_15_7b_name, hg_files=AiModels.llava_15_7b_bundle)
+            raise Exception("No model found for the given power and method.")
+
+        @staticmethod
+        def get_llava_power_medium(source: AiSourceType) -> AiSource:
+            if source == AiSourceType.OLLAMA_SERVER:
+                return AiSource(ollama_name="llava:13b")
+            if source == AiSourceType.LOCAL_LLAMACPP:
+                return AiSource(local_name=AiModels.llava_15_7b_name, hg_files=AiModels.llava_15_7b_bundle)
+            raise Exception("No model found for the given power and method.")
+
+        @staticmethod
+        def get_llava_power_high(source: AiSourceType) -> AiSource:
+            if source == AiSourceType.OLLAMA_SERVER:
+                return AiSource(ollama_name="llava:13b")
+            if source == AiSourceType.LOCAL_LLAMACPP:
+                return AiSource(local_name=AiModels.llava_15_7b_name, hg_files=AiModels.llava_15_7b_bundle)
+            raise Exception("No model found for the given power and method.")
+
+

pylizlib-0.0.6/ai/core/ai_power.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class AiPower(Enum):
+    LOW = "Low"
+    MEDIUM = "Medium"
+    HIGH = "High"
+
+    @staticmethod
+    def get_llava_from_power(ai_power: str) -> str:
+        if ai_power == AiPower.HIGH.value:
+            return "llava:13b"
+        elif ai_power == AiPower.MEDIUM.value:
+            return "llava:13b"
+        else:
+            return "llava:7b"

pylizlib-0.0.6/ai/core/ai_prompts.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+prompt_llava_1 = """
+Analyze the image thoroughly and provide a detailed description of every visible element. Return a json including the following information:
+- "description": a detailed description of the image (minimum 15-20 words), considering colors, objects, actions, and any other relevant details.
+- "tags": a list of tags that describe the image. Include specific objects, actions, locations, and any discernible themes. (minimum 5 maximum 10 tags)
+- "text": a list of all the text found in the image (if any).
+- "filename": phrase that summarizes the image content (maximum 30 characters).
+"""
+
+prompt_llava_detailed_STEP1 = """
+Analyze the image thoroughly and provide a detailed description of every visible element. 
+If there are people, try to recognize them. If there are objects, try to identify them.
+If the are texts, try to read them.
+"""
+
+
+class AiPrompt(Enum):
+    LLAVA_JSON = prompt_llava_1
+    LLAVA_DETAILED = prompt_llava_detailed_STEP1
+
+
+

pylizlib-0.0.6/ai/core/ai_scan_settings.py

@@ -0,0 +1,23 @@
+
+class AiScanSettings:
+
+    def __init__(
+            self,
+            ai_tags: bool = False,
+            ai_file_metadata: bool = False,
+            ai_comment: bool = False,
+            ai_rename: bool = False,
+            ai_ocr: bool = False,
+    ):
+        self.ai_tags = ai_tags
+        self.ai_file_metadata = ai_file_metadata
+        self.ai_comment = ai_comment
+        self.ai_rename = ai_rename
+        self.ai_ocr = ai_ocr
+
+    def set_all_true(self):
+        self.ai_tags = True
+        self.ai_file_metadata = True
+        self.ai_comment = True
+        self.ai_rename = True
+        self.ai_ocr = True

pylizlib-0.0.6/ai/core/ai_setting.py

@@ -0,0 +1,50 @@
+from ai.core.ai_method import AiMethod
+from ai.core.ai_model_list import AiModelList
+from ai.core.ai_models import AiModels
+from ai.core.ai_power import AiPower
+from ai.core.ai_prompts import AiPrompt
+from ai.core.ai_scan_settings import AiScanSettings
+from ai.core.ai_source import AiSource
+from ai.core.ai_source_type import AiSourceType
+
+
+class AiSettings:
+    def __init__(
+            self,
+            model: AiModelList,
+            source_type: AiSourceType,
+            power: AiPower,
+            prompt: AiPrompt,
+            remote_url: str | None = None,
+            scan_settings: AiScanSettings | None = None
+    ):
+        self.source: AiSource | None = None
+        self.method = None
+
+        self.model = model
+        self.source_type = source_type
+        self.remote_url = remote_url
+        self.power = power
+        self.prompt = prompt
+        self.scan_settings = scan_settings
+
+        self.check()
+        self.setup()
+
+    def __setup_llava(self):
+        if self.source_type == AiSourceType.OLLAMA_SERVER and self.prompt == AiPrompt.LLAVA_JSON:
+            self.method = AiMethod.LLAVA_OLLAMA_JSON
+        elif self.source_type == AiSourceType.LOCAL_LLAMACPP and self.prompt == AiPrompt.LLAVA_JSON:
+            self.method = AiMethod.LLAVA_LLAMACPP_JSON
+        else:
+            raise NotImplementedError("This combination of source and prompt is not implemented.")
+        self.source = AiModels.Llava.get_llava(self.power, self.source_type)
+
+    def setup(self):
+        if self.model == AiModelList.LLAVA:
+            self.__setup_llava()
+
+    def check(self):
+        if self.source_type == AiSourceType.OLLAMA_SERVER and self.remote_url is None:
+            raise ValueError("Remote URL is required for Ollama Server.")
+

pylizlib-0.0.6/ai/core/ai_source.py

@@ -0,0 +1,41 @@
+from typing import List
+
+from ai.core.hg_file import HgFile
+from model.file_type import FileType
+from network import netutils
+from util import unitutils
+
+
+class AiSource:
+
+    def __init__(
+            self,
+            ollama_name: str | None = None,
+            local_name: str | None = None,
+            url: str | None = None,
+            hg_files: List[HgFile] | None = None,
+    ):
+        self.url = url
+        self.hg_files = hg_files
+        self.ollama_name = ollama_name
+        self.local_name = local_name
+
+    def get_ggml_file(self) -> HgFile:
+        for hg_file in self.hg_files:
+            if hg_file.file_type == FileType.HG_GGML:
+                return hg_file
+        raise Exception("No ggml file found in the source.")
+
+    def get_mmproj_file(self) -> HgFile:
+        for hg_file in self.hg_files:
+            if hg_file.file_type == FileType.HG_MMPROJ:
+                return hg_file
+        raise Exception("No mmproj file found in the source.")
+
+    def get_files_size_mb(self) -> float:
+        total = 0.0
+        for hg_file in self.hg_files:
+            size_byte = hg_file.get_file_size_byte()
+            size_mb = unitutils.convert_byte_to_mb(size_byte)
+            total += size_mb
+        return total

pylizlib-0.0.6/ai/core/ai_source_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class AiSourceType(Enum):
+    OLLAMA_SERVER = "Ollama Remote"
+    # LOCAL_AI = "Local AI"
+    LOCAL_LLAMACPP = "Local Llamacpp"

pylizlib-0.0.6/ai/core/hg_file.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+from model.file_type import FileType
+from network import netutils
+
+
+class HgFile:
+    def __init__(
+            self,
+            file_name: str,
+            url: str,
+            file_type: FileType
+    ):
+        self.file_name = file_name
+        self.url = url
+        self.file_type = file_type
+
+    def get_file_size_byte(self) -> int:
+        return netutils.get_file_size_byte(self.url)
+

pylizlib-0.0.6/ai/llm/local/llamacpp.py

@@ -0,0 +1,156 @@
+import os
+import subprocess
+from typing import Callable
+
+from git import Repo
+
+from ai.core.ai_method import AiMethod
+from ai.core.ai_models import AiModels
+from ai.core.ai_power import AiPower
+from ai.core.ai_source import AiSource
+from ai.core.ai_source_type import AiSourceType
+from model.operation import Operation
+from util import pathutils, osutils, fileutils, datautils
+
+
+# noinspection PyMethodMayBeStatic
+class LlamaCpp:
+
+    GITHUB_URL = "https://github.com/ggerganov/llama.cpp.git"
+
+    def __init__(
+            self,
+            # path_install: str = os.path.join(PylizDir.get_ai_folder(), "llama.cpp"),
+            # path_models: str = PylizDir.get_models_folder(),
+            # path_logs: str = os.path.join(PylizDir.get_logs_path(), "llama.cpp")
+            path_install: str,
+            path_models: str,
+            path_logs: str
+    ):
+        # Init paths
+        self.path_install = path_install
+        self.path_models = path_models
+        self.path_logs = path_logs
+        self.log_build_folder = os.path.join(self.path_logs, "build")
+        pathutils.check_path(self.log_build_folder, True)
+
+
+    def __clone_repo(self, on_log: Callable[[str], None] = lambda x: None):
+        on_log("Cloning LlamaCpp...")
+        # check if the folder already exists
+        if os.path.exists(self.path_install):
+            on_log("LlamaCpp already installed.")
+            return
+        else:
+            on_log("LlamaCpp not installed. Proceeding...")
+            pathutils.check_path(self.path_install, True)
+        # checking folder
+        pathutils.check_path_dir(self.path_install)
+        # Cloning github repo
+        Repo.clone_from(LlamaCpp.GITHUB_URL, self.path_install)
+        on_log("Clone successful.")
+
+
+    def __check_requirements(self, on_log: Callable[[str], None] = lambda x: None):
+        on_log("Checking requirements...")
+        make_ok = osutils.is_command_available("make")
+        is_os_unix = osutils.is_os_unix()
+        if not make_ok:
+            raise Exception("Make command not available. Please install make.")
+        if not is_os_unix:
+            raise Exception("This component (LlamaCPP) is only available on Unix systems.")
+
+
+    def __build_sources(self, on_log: Callable[[str], None] = lambda x: None):
+        on_log("Building sources...")
+        risultato = subprocess.run(["make"], check=True, cwd=self.path_install, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        on_log("Build successful.")
+        return risultato
+
+
+    def __crete_build_log(self, risultato, ):
+        log_build_name = datautils.gen_timestamp_log_name("llamacpp-", ".txt")
+        log_build_path = os.path.join(self.log_build_folder, log_build_name)
+        with open(log_build_path, "w") as f:
+            f.write(risultato.stdout)
+            f.write("***********************************\n")
+            f.write(risultato.stderr)
+
+    def __download_llava_local_models(
+            self,
+            source: AiSource,
+            folder: str,
+            on_log: Callable[[str], None] = lambda x: None,
+            on_progress: Callable[[int], None] = lambda x: None
+    ):
+        on_log("LLava require " + str(len(source.hg_files)) + " files to download.")
+        for hg_file in source.hg_files:
+            current_file = os.path.join(folder, hg_file.file_name)
+            already_exist = os.path.exists(current_file)
+            if already_exist:
+                on_log("Model " + hg_file.file_name + " already installed.")
+                continue
+            on_log("Downloading model " + hg_file.file_name + " from Huggingface...")
+            op = fileutils.download_file(hg_file.url, current_file, on_progress)
+            if op.status is False:
+                raise Exception("Error downloading model: " + op.error)
+
+
+    def clone_and_build(self, on_log: Callable[[str], None] = lambda x: None):
+        self.__clone_repo(on_log)
+        self.__check_requirements(on_log)
+        build = self.__build_sources(on_log)
+        self.__crete_build_log(build)
+
+
+    def install_llava(
+            self,
+            power: AiPower,
+            on_log: Callable[[str], None] = lambda x: None,
+            on_progress: Callable[[int], None] = lambda x: None
+    ):
+        self.clone_and_build(on_log)
+        on_log("Installing LLava...")
+        # creating and checking files/folders
+        source = AiModels.Llava.get_llava(power, AiSourceType.LOCAL_LLAMACPP)
+        folder = os.path.join(self.path_models, source.local_name)
+        pathutils.check_path(folder, True)
+        pathutils.check_path_dir(folder)
+        # Checking available space
+        models_size = source.get_files_size_mb()
+        has_space = osutils.has_disk_free_space(folder, models_size)
+        if not has_space:
+            raise Exception("Not enough free space to install LLava.")
+        # Downloading files
+        self.__download_llava_local_models(source, folder, on_log, on_progress)
+        on_log("LLava model installed.")
+
+    def run_llava(
+            self,
+            power: AiPower,
+            image_path: str,
+            prompt: str,
+    ) -> Operation[str]:
+        try:
+            # Creating variables and checking requirements
+            source = AiModels.Llava.get_llava(power, AiSourceType.LOCAL_LLAMACPP)
+            folder = os.path.join(self.path_models, source.local_name)
+            if not os.path.exists(folder):
+                raise Exception("LLava model not installed.")
+            # Run the model
+            path_model_file = os.path.join(self.path_models, source.local_name, source.get_ggml_file().file_name)
+            path_mmproj_file = os.path.join(self.path_models, source.local_name, source.get_mmproj_file().file_name)
+            command = ["./llama-llava-cli", "-m", path_model_file, "--mmproj", path_mmproj_file, "--image", image_path, "-p", prompt ]
+            # saving and extracting the result
+            log_file = os.path.join(self.path_logs, datautils.gen_timestamp_log_name("llava-result", ".txt"))
+            with open(log_file, 'w') as file:
+                result = subprocess.run(command, cwd=self.path_install, stdout=file, stderr=subprocess.PIPE)
+            if result.returncode != 0:
+                raise Exception("Error running LLava: " + result.stderr.decode())
+            with open(log_file, 'r') as file:
+                return Operation(status=True, payload=file.read())
+        except Exception as e:
+            return Operation(status=False, error=str(e))
+
+
+

pylizlib-0.0.6/ai/llm/local/llamacpplib.py

@@ -0,0 +1,22 @@
+from huggingface_hub import hf_hub_download
+from llama_cpp import Llama
+
+from util.pylizdir import PylizDir
+
+# https://github.com/abetlen/llama-cpp-python
+
+
+class LlamaCppLib:
+
+    @staticmethod
+    def run_llama3(prompt: str):
+        model_name = "Orenguteng/Llama-3-8B-Lexi-Uncensored-GGUF"
+        model_file = "Lexi-Llama-3-8B-Uncensored_Q4_K_M.gguf"
+        model_path = hf_hub_download(model_name,
+                                     filename=model_file,
+                                     local_dir=PylizDir.get_models_folder(),
+                                     )
+        llm = Llama(model_path, n_gpu_layers=1)
+        response = llm(prompt)
+        print(response)
+

pylizlib-0.0.6/ai/llm/local/whisper.py

@@ -0,0 +1,29 @@
+import moviepy.editor as mp
+import whisper
+
+from network.ssl import ignore_context_ssl
+
+
+def transcribe(
+    video_path: str,
+    audio_path: str,
+    model_path: str,
+    transcription_path: str | None = None
+):
+
+    ignore_context_ssl()
+
+    # Estrarre l'audio dal video
+    video = mp.VideoFileClip(video_path)
+    video.audio.write_audiofile(audio_path)
+
+    # Caricare il modello Whisper
+    model = whisper.load_model(model_path)
+
+    # Trascrivere l'audio
+    result = model.transcribe(audio_path)
+    if transcription_path is not None:
+        # Salvare la trascrizione su un file di test
+        with open(transcription_path, 'w') as f:
+            f.write(result["text"])
+    return result

pylizlib-0.0.6/ai/llm/remote/data/ollamapi.py

@@ -0,0 +1,81 @@
+import json
+from typing import Callable
+
+import ollama
+from ollama import Client
+
+from network.netres import NetResponse
+from network.netutils import exec_get, exec_post
+
+OLLAMA_PORT = "11434"
+OLLAMA_HTTP_LOCALHOST_URL = "http://localhost:" + OLLAMA_PORT
+
+# https://github.com/ollama/ollama-python
+# https://github.com/ollama/ollama/blob/main/docs/api.md
+
+
+class OllamaApiLegacy:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def check_ollama_status(url) -> NetResponse:
+        return exec_get(url)
+
+    @staticmethod
+    def get_installed_models(url) -> NetResponse:
+        api_url = url + "/api/tags"
+        return exec_get(api_url)
+
+    @staticmethod
+    def send_query(
+            url: str,
+            prompt: str,
+            model_name: str,
+    ) -> NetResponse:
+        api_url = url + "/api/generate"
+        payload = {
+            "model": model_name,
+            "prompt": prompt,
+            "stream": False
+        }
+        return exec_post(api_url, payload, False)
+
+    @staticmethod
+    def send_llava_query(
+            url: str,
+            prompt: str,
+            image_base_64: str,
+            model_name: str,
+    ) -> NetResponse:
+        api_url = url + "/api/generate"
+        payload = {
+            "model": model_name,
+            "prompt": prompt,
+            "images": [image_base_64],
+            "format": "json",
+            "stream": False
+        }
+        return exec_post(api_url, payload, False)
+
+
+class Ollamapi:
+
+    def __init__(self, url: str):
+        self.url = url
+        self.client = ollama.client = Client(host=url)
+
+    def get_models_list(self):
+        mappings = self.client.list()
+        json_str = json.dumps(mappings)
+        return json_str
+
+    def download_model(self, name: str, en_stream: bool, callback: Callable[[str], None] | None = None):
+        stream = self.client.pull(
+            model='name',
+            stream=en_stream,
+        )
+        if en_stream:
+            for data in stream:
+                if callback:
+                    callback(data["status"])