machineconfig 5.15__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/utils/code.py

@@ -1,105 +1,104 @@
-import platform
-from typing import Optional
-import subprocess
-from rich.console import Console
-from rich.panel import Panel
-from rich.syntax import Syntax
 
+from typing import Any, Literal, Optional, Callable, cast
 from machineconfig.utils.accessories import randstr
-from machineconfig.utils.ve import get_ve_activate_line
-from machineconfig.utils.path_extended import PathExtended
+from pathlib import Path
 
 
-def get_shell_script_executing_python_file(python_file: str, func: Optional[str], ve_path: str, strict_execution: bool = True):
-    if func is None:
-        exec_line = f"""python {python_file}"""
-    else:
-        exec_line = f"""python -m fire {python_file} {func}"""
-    shell_script = f"""
-echo "Executing `{exec_line}`"
-{get_ve_activate_line(ve_path)}
-{exec_line}
-deactivate || true
-"""
-    if strict_execution:
-        if platform.system() == "Windows":
-            shell_script = """$ErrorActionPreference = "Stop" """ + "\n" + shell_script
-        if platform.system() in ["Linux", "Darwin"]:
-            shell_script = "set -e" + "\n" + shell_script
-    if platform.system() in ["Linux", "Darwin"]:
-        shell_script = "#!/bin/bash" + "\n" + shell_script  # vs #!/usr/bin/env bash
-    return shell_script
-
-
-def get_shell_file_executing_python_script(python_script: str, ve_path: str, verbose: bool = True):
-    if verbose:
-        python_script = f"""
-code = r'''{python_script}'''
-try:
-    from machineconfig.utils.utils import print_code
-    print_code(code=code, lexer="python", desc="Python Script")
-except ImportError:
-    from rich.console import Console
-    from rich.panel import Panel
-    console = Console()
-    console.print(Panel(f'''📜 PYTHON SCRIPT:\n\n{{code}}''', title="Python Script", expand=False))
-""" + python_script
-    python_file = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
-    python_file.parent.mkdir(parents=True, exist_ok=True)
-    python_file.write_text(python_script, encoding="utf-8")
-    shell_script = get_shell_script_executing_python_file(python_file=str(python_file), func=None, ve_path=ve_path)
-    shell_file = write_shell_script_to_file(shell_script)
-    return shell_file
+def get_uv_run_command(platform: str) -> str:
+    res = cast(Literal["Windows", "windows", "nt", "Linux", "linux", "Darwin", "darwin", "macos"], platform)
+    match res:
+        case "Windows" | "windows" | "nt":
+            return """& "$env:USERPROFILE/.local/bin/uv" run"""
+        case "Linux" | "linux" | "Darwin" | "darwin" | "macos":
+            return """$HOME/.local/bin/uv run"""
+        case _:
+            return """$HOME/.local/bin/uv run"""
 
+def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
+    import platform
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.syntax import Syntax
+        if lexer == "shell":
+            if platform.system() == "Windows":
+                lexer = "powershell"
+            elif platform.system() in ["Linux", "Darwin"]:
+                lexer = "sh"
+            else:
+                raise NotImplementedError(f"Platform {platform.system()} not supported for lexer {lexer}")
+        console = Console()
+        console.print(Panel(Syntax(code=code, lexer=lexer), title=f"📄 {desc}", subtitle=subtitle), style="bold red")
+    except ImportError:
+        print(f"--- {desc} ---")
+        print(code)
+        print(f"--- End of {desc} ---")
 
-def write_shell_script_to_file(shell_script: str):
-    if platform.system() in ["Linux", "Darwin"]:
-        suffix = ".sh"
-    elif platform.system() == "Windows":
-        suffix = ".ps1"
+
+def get_uv_command_executing_python_script(python_script: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str],
+                                           prepend_print: bool = True) -> tuple[str, Path]:
+    python_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", randstr() + ".py")
+    python_file.parent.mkdir(parents=True, exist_ok=True)
+    if uv_with is not None and len(uv_with) > 0:
+        if prepend_print: uv_with.append("rich")
+        uv_with_arg = "--with " + '"' + ",".join(uv_with) + '"'
+    else:
+        if prepend_print:
+            uv_with_arg = "--with rich"
+        else:
+            uv_with_arg = ""
+    if uv_project_dir is not None:
+        uv_project_dir_arg = "--project" + f' "{uv_project_dir}"'
+    else:
+        uv_project_dir_arg = ""
+    
+    if prepend_print:
+        from machineconfig.utils.meta import lambda_to_python_script
+        print_code_string = lambda_to_python_script(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"),
+                                                    in_global=True, import_module=False)
+        python_file.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
     else:
-        raise NotImplementedError(f"Platform {platform.system()} not implemented.")
-    shell_file = PathExtended.tmp().joinpath("tmp_scripts", "shell", randstr() + suffix)
-    shell_file.parent.mkdir(parents=True, exist_ok=True)
-    shell_file.write_text(shell_script, encoding="utf-8")
-    return shell_file
+        python_file.write_text(python_script, encoding="utf-8")
+    import platform
+    uv_run = get_uv_run_command(platform=platform.system())
+    shell_script = f"""{uv_run} {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
+    return shell_script, python_file
 
 
-def write_shell_script_to_default_program_path(program: str, desc: str, preserve_cwd: bool, display: bool, execute: bool):
-    if preserve_cwd:
-        if platform.system() == "Windows":
-            program = "$orig_path = $pwd\n" + program + "\ncd $orig_path"
-        else:
-            program = 'orig_path=$(cd -- "." && pwd)\n' + program + '\ncd "$orig_path" || exit'
-    if display:
-        print_code(code=program, lexer="shell", desc=desc, subtitle="PROGRAM")
-    if execute:
-        result = subprocess.run(program, shell=True, capture_output=True, text=True)
-        success = result.returncode == 0 and result.stderr == ""
-        if not success:
-            print("❌ 🛠️  EXECUTION | Shell script running failed")
-            if result.stdout:
-                print(f"STDOUT: {result.stdout}")
-            if result.stderr:
-                print(f"STDERR: {result.stderr}")
-            print(f"Return code: {result.returncode}")
-    return None
+def run_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> None:
+    from machineconfig.utils.meta import lambda_to_python_script
+    code = lambda_to_python_script(lmb,
+                                            in_global=True, import_module=False)
+    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=uv_with, uv_project_dir=uv_project_dir)
+    run_shell_script(uv_command)
 
 
-def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
-    if lexer == "shell":
-        if platform.system() == "Windows":
-            lexer = "powershell"
-        elif platform.system() in ["Linux", "Darwin"]:
-            lexer = "sh"
-        else:
-            raise NotImplementedError(f"Platform {platform.system()} not supported for lexer {lexer}")
-    console = Console()
-    console.print(Panel(Syntax(code=code, lexer=lexer), title=f"📄 {desc}", subtitle=subtitle), style="bold red")
+def run_python_script_in_marimo(py_script: str, uv_project_with: Optional[str]):
+    tmp_dir = Path.home().joinpath("tmp_results", "tmp_scripts", "marimo", randstr())
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    pyfile = tmp_dir / "marimo_db_explore.py"
+    pyfile.write_text(py_script, encoding="utf-8")
+    if uv_project_with is not None:
+        requirements = f"""--with "marimo" --project {uv_project_with} """
+    else:
+        requirements = """--with "marimo" """
+    fire_line = f"""
+cd {tmp_dir}
+uv run {requirements} marimo convert {pyfile.name} -o marimo_nb.py
+bat marimo_nb.py
+uv run  {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
+"""
+    print_code(code=py_script, desc="Generated Marimo DB Explore Script", lexer="python")
+    exit_then_run_shell_script(fire_line)
 
 
-def run_shell_script(program: str):
+def run_shell_script(script: str, display_script: bool = True, clean_env: bool = False):
     import tempfile
+    import platform
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+
     if platform.system() == "Windows":
         suffix = ".ps1"
         lexer = "powershell"
@@ -107,25 +106,76 @@ def run_shell_script(program: str):
         suffix = ".sh"
         lexer = "bash"
     with tempfile.NamedTemporaryFile(mode='w', suffix=suffix, delete=False, encoding='utf-8') as temp_file:
-        temp_file.write(program)
-        temp_script_path = PathExtended(temp_file.name)
+        temp_file.write(script)
+        temp_shell_script_path = Path(temp_file.name)
     console = Console()
-    # console.print(f"📝 [blue]Temporary script written to:[/blue] [green]{temp_script_path}[/green]")
-    from rich.syntax import Syntax
-    console.print(Panel(Syntax(code=program, lexer=lexer), title=f"📄script @ {temp_script_path}", subtitle="shell code"), style="bold red")
+    if display_script:
+        from rich.syntax import Syntax
+        console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 shell script @ {temp_shell_script_path}", subtitle="shell script being executed"), style="bold red")
+    env = {} if clean_env else None
     if platform.system() == "Windows":
         import subprocess
-        subprocess.run(f'powershell -ExecutionPolicy Bypass -File "{temp_script_path}"', check=True, shell=True)
+        proc = subprocess.run(f'powershell -ExecutionPolicy Bypass -File "{temp_shell_script_path}"', check=True, shell=True, env=env)
     elif platform.system() == "Linux" or platform.system() == "Darwin":
         import subprocess
-        subprocess.run(f"bash {str(temp_script_path)}", check=True, shell=True)
-    temp_script_path.unlink(missing_ok=True)
-# def run_command(command: str, description: str) -> bool:
-#     """Execute a shell command and return success status."""
-#     console.print(f"\n🔧 {description}", style="bold cyan")
-#     try:
-#         result = subprocess.run(command, shell=True, check=True, capture_output=False)
-#         return result.returncode == 0
-#     except subprocess.CalledProcessError as e:
-#         console.print(f"❌ Error executing command: {e}", style="bold red")
-#         return False
+        proc = subprocess.run(f"bash {str(temp_shell_script_path)}", check=True, shell=True, env=env)
+    else:
+        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    # console.print(f"✅  [green]Script executed successfully:[/green] [blue]{temp_script_path}[/blue]")
+    if proc.returncode != 0:
+        console.print(f"❌  [red]Script execution failed with return code {proc.returncode}:[/red] [blue]{temp_shell_script_path}[/blue]")
+    elif proc.returncode == 0:
+        console.print(f"✅  [green]Script executed successfully:[/green] [blue]{temp_shell_script_path}[/blue]")
+    else:
+        console.print(f"⚠️  [yellow]Script executed with warnings (return code {proc.returncode}):[/yellow] [blue]{temp_shell_script_path}[/blue]")
+    temp_shell_script_path.unlink(missing_ok=True)
+    console.print(f"🗑️  [blue]Temporary script deleted:[/blue] [green]{temp_shell_script_path}[/green]")
+    return proc
+
+
+def exit_then_run_shell_script(script: str, strict: bool = False):
+    import os
+    from rich.console import Console
+    
+    console = Console()
+    op_program_path = os.environ.get("OP_PROGRAM_PATH", None)
+    if op_program_path is not None:
+        exists = Path(op_program_path).exists()
+    else:
+        exists = False
+    # three cases: (op_program_path is None, exists=False), (op_program_path is set, exists=False), (op_program_path is set, exists=True)
+
+    if strict:  # we want to assert op_program_path is set and is not an already existing file
+        if (op_program_path is None or exists):
+            import platform
+            if platform.system() == "Windows":
+                suffix = ".ps1"
+                lexer = "powershell"
+            else:
+                suffix = ".sh"
+                lexer = "bash"
+            op_program_path = Path.home().joinpath("tmp_results", "tmp_scripts", "manual_run", f"manual_script_{randstr()}{suffix}")
+            op_program_path.parent.mkdir(parents=True, exist_ok=True)
+            op_program_path.write_text(script, encoding="utf-8")
+            print_code(code=script, lexer=lexer, desc="script to run manually")
+            console.print("[bold yellow]⚠️  STRICT MODE:[/bold yellow] [cyan]Please run the script manually via your shell by executing:[/cyan]")
+            console.print(f"[green]{str(op_program_path)}[/green]")
+            console.print("[red]❌ OP_PROGRAM_PATH environment variable is not set in strict mode.[/red]")
+            import sys
+            sys.exit(1)
+
+    if op_program_path is not None and not exists:
+        op_program_path = Path(op_program_path)
+        op_program_path.parent.mkdir(parents=True, exist_ok=True)
+        op_program_path.write_text(script, encoding="utf-8")
+        console.print("[cyan]🚀 Handing over to shell script runner via OP_PROGRAM_PATH:[/cyan]")
+        console.print(f"[bold green]{str(op_program_path)}[/bold green]")
+        print_code(code=script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
+    else:
+        if op_program_path is not None and exists:
+            console.print(f"[yellow]⚠️  OP_PROGRAM_PATH @ {str(op_program_path)} already exists.[/yellow] [cyan]Falling back to direct execution.[/cyan]")
+        elif op_program_path is None:
+            console.print("[cyan]ℹ️  OP_PROGRAM_PATH is not set.[/cyan] [yellow]Falling back to direct execution.[/yellow]")
+        run_shell_script(script)
+    import sys
+    sys.exit(0)

machineconfig/utils/files/art/fat_croco.txt

@@ -0,0 +1,10 @@
+                _ ___                /^^\ /^\  /^^\_
+    _          _@)@) \            ,,/ '` ~ `'~~ ', `\.
+  _/o\_ _ _ _/~`.`...'~\        ./~~..,'`','',.,' '  ~:
+ / `,'.~,~.~  .   , . , ~|,   ,/ .,' , ,. .. ,,.   `,  ~\_
+( ' _' _ '_` _  '  .    , `\_/ .' ..' '  `  `   `..  `,   \_
+ ~V~ V~ V~ V~ ~\ `   ' .  '    , ' .,.,''`.,.''`.,.``. ',   \_
+  _/\ /\ /\ /\_/, . ' ,   `_/~\_ .' .,. ,, , _/~\_ `. `. '.,  \_
+ < ~ ~ '~`'~'`, .,  .   `_: ::: \_ '      `_/ ::: \_ `.,' . ',  \_
+  \ ' `_  '`_    _    ',/ _::_::_ \ _    _/ _::_::_ \   `.,'.,`., \-,-,-,_,_,
+   `'~~ `'~~ `'~~ `'~~  \(_)(_)(_)/  `~~' \(_)(_)(_)/ ~'`\_.._,._,'_;_;_;_;_;

machineconfig/utils/files/art/halfwit_croco.txt

@@ -0,0 +1,9 @@
+                    .-._   _ _ _ _ _ _ _ _
+         .-''-.__.-'00  '-' ' ' ' ' ' ' ' '-.
+         '.___ '    .   .--_'-' '-' '-' _'-' '._
+          V: V 'vv-'   '_   '.       .'  _..' '.'.
+            '=.____.=_.--'   :_.__.__:_   '.   : :
+                    (((____.-'        '-.  /   : :
+                                      (((-'\ .' /
+                                    _____..'  .'
+                                   '-._____.-'

machineconfig/utils/files/art/happy_croco.txt

@@ -0,0 +1,22 @@
+                          .--.  .--.
+                         /    \/    \
+                        | .-.  .-.   \
+                        |/_  |/_  |   \
+                        || `\|| `\|    `----.
+                        |\0_/ \0_/    --,    \_
+      .--"""""-.       /              (` \     `-.
+     /          \-----'-.              \          \
+     \  () ()                         /`\          \
+     |                         .___.-'   |          \
+     \                        /` \|      /           ;
+      `-.___             ___.' .-.`.---.|             \
+         \| ``-..___,.-'`\| / /   /     |              `\
+          `      \|      ,`/ /   /   ,  /
+                  `      |\ /   /    |\/
+                   ,   .'`-;   '     \/
+              ,    |\-'  .'   ,   .-'`
+            .-|\--;`` .-'     |\.'
+           ( `"'-.|\ (___,.--'`'
+            `-.    `"`          _.--'
+               `.          _.-'`-.
+                 `''---''``       `."

machineconfig/utils/files/art/water_croco.txt

@@ -0,0 +1,11 @@
+                     _.---._     .---.
+            __...---' .---. `---'-.   `.
+  ~ -~ -.-''__.--' _.'( | )`.  `.  `._ :
+ -.~~ .'__-'_ .--'' ._`---'_.-.  `.   `-`.
+  ~ ~_~-~-~_ ~ -._ -._``---. -.    `-._   `.
+    ~- ~ ~ -_ -~ ~ -.._ _ _ _ ..-_ `.  `-._``--.._
+     ~~-~ ~-_ _~ ~-~ ~ -~ _~~_-~ -._  `-.  -. `-._``--.._.--''. ~ -~_
+         ~~ -~_-~ _~- _~~ _~-_~ ~-_~~ ~-.___    -._  `-.__   `. `. ~ -_~
+             ~~ _~- ~~- -_~  ~- ~ - _~~- _~~ ~---...__ _    ._ .` `. ~-_~
+                ~ ~- _~~- _-_~ ~-_ ~-~ ~_-~ _~- ~_~-_~  ~--.....--~ -~_ ~
+                     ~ ~ - ~  ~ ~~ - ~~-  ~~- ~-  ~ -~ ~ ~ -~~-  ~- ~-~

machineconfig/utils/files/ascii_art.py

@@ -62,7 +62,7 @@ def get_art(comment: Optional[str] = None, artlib: Optional[BOX_OR_CHAR] = None,
         try:
             comment = subprocess.run("fortune", shell=True, capture_output=True, text=True, check=True).stdout
         except Exception:
-            comment = "crocodile"
+            comment = "machineconfig"
     if artlib is None: artlib = random.choice(['boxes', 'cowsay'])
     to_file = '' if not file else f'> {file}'
     if artlib == 'boxes':

machineconfig/utils/files/dbms.py

@@ -0,0 +1,257 @@
+import time
+from typing import Optional, Any, Callable
+
+import polars as pl
+
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import create_engine, text, inspect as inspect__
+from sqlalchemy.engine import Engine
+from sqlalchemy.sql.schema import MetaData
+from pathlib import Path as P
+
+OPLike = Optional[P] | str | None
+
+
+class DBMS:
+    def __init__(self, engine: Engine):
+        self.eng: Engine = engine
+
+    @staticmethod
+    def from_local_db(path: OPLike = None, echo: bool = False, share_across_threads: bool = False, pool_size: int = 5, **kwargs: Any):
+        return DBMS(engine=DBMS.make_sql_engine(path=path, echo=echo, share_across_threads=share_across_threads, pool_size=pool_size, **kwargs))
+
+    def __repr__(self): return f"DataBase @ {self.eng}"
+    def close(self, sleep: int = 2):
+        self.eng.pool.dispose()
+        self.eng.dispose()
+        time.sleep(sleep)
+    @staticmethod
+    def _get_table_identifier(engine: Engine, table: str, sch: Optional[str]):
+        if sch is not None:
+            # Handle DuckDB schema names that contain dots (e.g., "klines.main")
+            if engine.url.drivername == 'duckdb' and '.' in sch and sch.endswith('.main'):
+                # For DuckDB schemas like "klines.main", just use the table name without schema
+                return f'"{table}"'
+            else:
+                return f'"{sch}"."{table}"'
+        else:
+            return f'"{table}"'
+
+    # ==================== QUERIES =====================================
+    def execute_as_you_go(self, *commands: str, res_func: Callable[[Any], Any] = lambda x: x.all(), df: bool = False):
+        with self.eng.begin() as conn:
+            result = None
+            for command in commands:
+                result = conn.execute(text(command))
+            # conn.commit()  # if driver is sqlite3, the connection is autocommitting. # this commit is only needed in case of DBAPI driver.
+            return res_func(result) if not df else pl.DataFrame(res_func(result))
+
+    def execute_begin_once(self, command: str, res_func: Callable[[Any], Any] = lambda x: x.all(), df: bool = False):
+        with self.eng.begin() as conn:
+            result = conn.execute(text(command))  # no need for commit regardless of driver
+            result = res_func(result)
+        return result if not df else pl.DataFrame(result)
+
+    def execute(self, command: str):
+        with self.eng.begin() as conn:
+            result = conn.execute(text(command))
+            # conn.commit()
+        return result
+
+    # def execute_script(self, command: str, df: bool = False):
+    #     with self.eng.begin() as conn: result = conn.executescript(text(command))
+    #     return result if not df else pl.DataFrame(result)
+
+    # ========================== TABLES =====================================
+    def insert_dicts(self, table: str, *mydicts: dict[str, Any]) -> None:
+        cmd = f"""INSERT INTO {table} VALUES """
+        for mydict in mydicts: cmd += f"""({tuple(mydict)}), """
+        self.execute_begin_once(cmd)
+
+    def refresh(self, sch: Optional[str] = None) -> dict[str, Any]:
+        con = self.eng.connect()
+        ses = sessionmaker()(bind=self.eng)
+        meta = MetaData()
+        meta.reflect(bind=self.eng, schema=sch)
+        insp = inspect__(subject=self.eng)
+        schema = insp.get_schema_names()
+        sch_tab = {k: v for k, v in zip(schema, [insp.get_table_names(schema=x) for x in schema])}
+        sch_vws = {k: v for k, v in zip(schema, [insp.get_view_names(schema=x) for x in schema])}
+        return {'con': con, 'ses': ses, 'meta': meta, 'insp': insp, 'schema': schema, 'sch_tab': sch_tab, 'sch_vws': sch_vws}
+
+    def get_columns(self, table: str, sch: Optional[str] = None) -> list[str]:
+        meta = MetaData()
+        meta.reflect(bind=self.eng, schema=sch)
+        return list(meta.tables[self._get_table_identifier(self.eng, table, sch)].exported_columns.keys())
+
+    def read_table(self, table: Optional[str] = None, sch: Optional[str] = None, size: int = 5) -> pl.DataFrame:
+        insp = inspect__(self.eng)
+        schema = insp.get_schema_names()
+        sch_tab = {k: v for k, v in zip(schema, [insp.get_table_names(schema=x) for x in schema])}
+        if sch is None:
+            # First try to find schemas that have tables (excluding system schemas)
+            schemas_with_tables = []
+            for schema_name in schema:
+                if schema_name not in ["information_schema", "pg_catalog", "system"]:
+                    if schema_name in sch_tab and len(sch_tab[schema_name]) > 0:
+                        schemas_with_tables.append(schema_name)
+
+            if len(schemas_with_tables) == 0:
+                raise ValueError(f"No schemas with tables found. Available schemas: {schema}")
+
+            # Prefer non-"main" schemas if available, otherwise use main
+            if len(schemas_with_tables) > 1 and "main" in schemas_with_tables:
+                sch = [s for s in schemas_with_tables if s != "main"][0]
+            else:
+                sch = schemas_with_tables[0]
+            print(f"Auto-selected schema: `{sch}` from available schemas: {schemas_with_tables}")
+
+        if table is None:
+            if sch not in sch_tab:
+                raise ValueError(f"Schema `{sch}` not found. Available schemas: {list(sch_tab.keys())}")
+            tables = sch_tab[sch]
+            assert len(tables) > 0, f"No tables found in schema `{sch}`"
+            import random
+            table = random.choice(tables)
+            print(f"Reading table `{table}` from schema `{sch}`")
+        with self.eng.connect() as conn:
+            try:
+                res = conn.execute(text(f'''SELECT * FROM {self._get_table_identifier(self.eng, table, sch)} '''))
+                return pl.DataFrame(res.fetchmany(size))
+            except Exception:
+                print(f"Error executing query for table `{table}` in schema `{sch}`")
+                print(f"Available schemas and tables: {sch_tab}")
+                raise
+
+    def describe_db(self, sch: Optional[str] = None) -> pl.DataFrame:
+        meta = MetaData()
+        meta.reflect(bind=self.eng, schema=sch)
+        ses = sessionmaker()(bind=self.eng)
+        res_all = []
+        from rich.progress import Progress
+        with Progress() as progress:
+            task = progress.add_task("Inspecting tables", total=len(meta.sorted_tables))
+            for tbl in meta.sorted_tables:
+                table = tbl.name
+                if sch is not None:
+                    table = f"{sch}.{table}"
+                count = ses.query(tbl).count()
+                res = dict(table=table, count=count, size_mb=count * len(tbl.exported_columns) * 10 / 1e6,
+                           columns=len(tbl.exported_columns), schema=sch)
+                res_all.append(res)
+                progress.update(task, advance=1)
+        return pl.DataFrame(res_all)
+
+    def describe_table(self, table: str, sch: Optional[str] = None, dtype: bool = True) -> None:
+        print(table.center(100, "="))
+        meta = MetaData()
+        meta.reflect(bind=self.eng, schema=sch)
+        tbl = meta.tables[self._get_table_identifier(self.eng, table, sch)]
+        ses = sessionmaker()(bind=self.eng)
+        count = ses.query(tbl).count()
+        res = dict(name=table, count=count, size_mb=count * len(tbl.exported_columns) * 10 / 1e6)
+        from machineconfig.utils.accessories import pprint
+        pprint(res, title="TABLE DETAILS")
+        dat = self.read_table(table=table, sch=sch, size=2)
+        df = dat
+        print("SAMPLE:\n", df)
+        insp = inspect__(self.eng)
+        if dtype: print("\nDETAILED COLUMNS:\n", pl.DataFrame(insp.get_columns(self._get_table_identifier(self.eng, table, sch))))
+        print("\n" * 3)
+
+    @staticmethod
+    def make_sql_engine(path: OPLike = None, echo: bool = False, share_across_threads: bool = False, pool_size: int = 5, **kwargs: Any) -> Engine:
+        if path is None:
+            url = 'sqlite:///:memory:'
+        elif isinstance(path, str) and path.startswith(('sqlite://', 'postgresql://', 'mysql://', 'duckdb://')):
+            url = path
+        else:
+            path_str = str(P(path))
+            if path_str.endswith('.duckdb'):
+                url = f'duckdb:///{path_str}'
+            else:
+                url = f'sqlite:///{path_str}'
+        connect_args = {}
+        if share_across_threads and 'sqlite' in url:
+            connect_args['check_same_thread'] = False
+        return create_engine(url, echo=echo, pool_size=pool_size, connect_args=connect_args, **kwargs)
+
+DB_TMP_PATH = P.home().joinpath(".tmp").joinpath("tmp_dbs").joinpath("results").joinpath("data.sqlite")
+
+
+def to_db(table: str, idx: int, idx_max: int, data: Any):
+    import pickle
+    DB_TMP_PATH.parent.mkdir(parents=True, exist_ok=True)
+    db = DBMS.from_local_db(DB_TMP_PATH)
+    time_now = time.time_ns()
+    data_blob = pickle.dumps(data)
+    create_table = f"""CREATE TABLE IF NOT EXISTS "{table}" (time INT PRIMARY KEY, idx INT, idx_max INT, data BLOB)"""
+    insert_row = f"""INSERT INTO "{table}" (time, idx, idx_max, data) VALUES (:time, :idx, :idx_max, :data)"""
+    with db.eng.begin() as conn:
+        conn.execute(text(create_table))
+        conn.execute(
+            text(insert_row),
+            {'time': time_now, 'idx': idx, 'idx_max': idx_max, 'data': data_blob}
+        )
+    db.close()
+
+
+def from_db(table: str):
+    import pickle
+    DB_TMP_PATH.parent.mkdir(parents=True, exist_ok=True)
+    db = DBMS.from_local_db(DB_TMP_PATH)
+    with db.eng.connect() as conn:
+        res = conn.execute(text(f"""SELECT * FROM "{table}" """))
+        records = res.fetchall()
+        df = pl.DataFrame(records, schema=['time', 'idx', 'idx_max', 'data'])
+        df = df.with_columns(pl.col('data').map_elements(pickle.loads))
+        return df
+
+
+def get_table_specs(engine: Engine, table_name: str) -> pl.DataFrame:
+    inspector = inspect__(engine)
+    # Collect table information
+    columns_info = [{
+        'name': col['name'],
+        'type': str(col['type']),
+        'nullable': col['nullable'],
+        'default': col['default'],
+        'autoincrement': col.get('autoincrement'),
+        'category': 'column'
+    } for col in inspector.get_columns(table_name)]
+    # Primary keys
+    pk_info = [{
+        'name': pk,
+        'type': None,
+        'nullable': False,
+        'default': None,
+        'autoincrement': None,
+        'category': 'primary_key'
+    } for pk in inspector.get_pk_constraint(table_name)['constrained_columns']]
+    # Foreign keys
+    fk_info = [{
+        'name': fk['constrained_columns'][0],
+        'type': f"FK -> {fk['referred_table']}.{fk['referred_columns'][0]}",
+        'nullable': None,
+        'default': None,
+        'autoincrement': None,
+        'category': 'foreign_key'
+    } for fk in inspector.get_foreign_keys(table_name)]
+    # Indexe
+    index_info = [{
+        'name': idx['name'],
+        'type': f"Index on {', '.join(col for col in idx['column_names'] if col)}",
+        'nullable': None,
+        'default': None,
+        'autoincrement': None,
+        'category': 'index',
+        'unique': idx['unique']
+    } for idx in inspector.get_indexes(table_name)]
+    # Combine all information
+    all_info = columns_info + pk_info + fk_info + index_info
+    # Convert to DataFrame
+    df = pl.DataFrame(all_info)
+    return df
+
+if __name__ == '__main__':
+    pass