machineconfig 1.94__py3-none-any.whl → 1.96__py3-none-any.whl

machineconfig/utils/utils2.py

@@ -0,0 +1,42 @@
+
+
+from pathlib import Path
+from typing import Optional, Any
+
+def randstr(length: int = 10, lower: bool = True, upper: bool = True, digits: bool = True, punctuation: bool = False, safe: bool = False, noun: bool = False) -> str:
+    if safe:
+        import secrets
+        return secrets.token_urlsafe(length)  # interannly, it uses: random.SystemRandom or os.urandom which is hardware-based, not pseudo
+    if noun:
+        import randomname
+        return randomname.get_name()
+    import string
+    import random
+    population = (string.ascii_lowercase if lower else "") + (string.ascii_uppercase if upper else "") + (string.digits if digits else "") + (string.punctuation if punctuation else "")
+    return ''.join(random.choices(population, k=length))
+
+
+def read_ini(path: 'Path', encoding: Optional[str] = None):
+    if not Path(path).exists() or Path(path).is_dir(): raise FileNotFoundError(f"File not found or is a directory: {path}")
+    import configparser
+    res = configparser.ConfigParser()
+    res.read(filenames=[str(path)], encoding=encoding)
+    return res
+def read_json(path: 'Path', r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
+    import json
+    try:
+        mydict = json.loads(Path(path).read_text(encoding='utf-8'), **kwargs)
+    except Exception:
+        import pyjson5
+        mydict = pyjson5.loads(Path(path).read_text(encoding='utf-8'), **kwargs)  # file has C-style comments.
+    _ = r
+    return mydict
+def read_toml(path: 'Path'):
+    import tomli
+    return tomli.loads(path.read_text(encoding='utf-8'))
+
+def pprint(obj: dict[Any, Any], title: str) -> None:
+    from rich import inspect
+    inspect(type("TempStruct", (object,), obj)(), value=False, title=title, docs=False, dunder=False, sort=False)
+def get_repr(obj: dict[Any, Any], sep: str = "\n", justify: int = 15, quotes: bool = False):
+    return sep.join([f"{key:>{justify}} = {repr(val) if quotes else val}" for key, val in obj.items()])

machineconfig/utils/utils5.py

@@ -0,0 +1,84 @@
+
+from typing import Callable, Optional, Union, Any
+from logging import Logger as Log
+from machineconfig.utils.utils2 import randstr, get_repr
+import time
+from datetime import datetime, timezone
+
+
+class Scheduler:
+    def __init__(self, routine: Callable[['Scheduler'], Any],
+                 wait_ms: int,
+                 exception_handler: Optional[Callable[[Union[Exception, KeyboardInterrupt], str, 'Scheduler'], Any]] = None,
+                 logger: Optional[Log] = None,
+                 sess_stats: Optional[Callable[['Scheduler'], dict[str, Any]]] = None,
+                 max_cycles: int = 1_000_000_000,
+                 records: Optional[list[list[Any]]] = None):
+        self.routine = routine  # main routine to be repeated every `wait` time period
+        self.logger = logger if logger is not None else Log(name="SchedLogger_" + randstr(noun=True))
+        self.exception_handler = exception_handler if exception_handler is not None else self.default_exception_handler
+        self.records: list[list[Any]] = records if records is not None else []
+        self.wait_ms = wait_ms  # wait period between routine cycles.
+        self.cycle: int = 0
+        self.max_cycles: int = max_cycles
+        self.sess_start_time_ms: int
+        self.sess_stats = sess_stats or (lambda _sched: {})
+    def __repr__(self): return f"Scheduler with {self.cycle} cycles ran so far. Last cycle was at {self.sess_start_time_ms}."
+    def run(self, max_cycles: Optional[int]=None, until_ms: Optional[int]=None):
+        if max_cycles is not None:
+            self.max_cycles = max_cycles
+        if until_ms is None:
+            until_ms = 1_000_000_000_000
+        self.sess_start_time_ms = time.time_ns() // 1_000_000
+        while (time.time_ns() // 1_000_000) < until_ms and self.cycle < self.max_cycles:
+            # 1- Time before Ops, and Opening Message
+            time1_ms = time.time_ns() // 1_000_000
+            self.logger.info(f"Starting Cycle {str(self.cycle).zfill(5)}. Total Run Time = {str(time1_ms - self.sess_start_time_ms).split('.', maxsplit=1)[0]}. UTC🕜 {datetime.now(tz=timezone.utc).strftime('%d %H:%M:%S')}")
+            try:
+                self.routine(self)
+            except Exception as ex:
+                self.exception_handler(ex, "routine", self)  # 2- Perform logic
+            time2_ms = time.time_ns() // 1_000_000
+            time_left_ms = int(self.wait_ms - (time2_ms - time1_ms))  # 4- Conclude Message
+            self.cycle += 1
+            self.logger.info(f"Finishing Cycle {str(self.cycle - 1).zfill(5)} in {str((time2_ms - time1_ms)*0.001).split('.', maxsplit=1)[0]}s. Sleeping for {self.wait_ms*0.001:0.1f}s ({time_left_ms*0.001:0.1}s left)\n" + "-" * 100)
+            try: time.sleep(time_left_ms*0.001 if time_left_ms > 0 else 0.0)  # # 5- Sleep. consider replacing by Asyncio.sleep
+            except KeyboardInterrupt as ex:
+                self.exception_handler(ex, "sleep", self)
+                return  # that's probably the only kind of exception that can rise during sleep.
+        self.record_session_end(reason=f"Reached maximum number of cycles ({self.max_cycles})" if self.cycle >= self.max_cycles else f"Reached due stop time ({until_ms})")
+    def get_records_df(self):
+        import polars as pl
+        columns = ["start", "finish", "duration", "cycles", "termination reason", "logfile"] + list(self.sess_stats(self).keys())
+        return pl.DataFrame(self.records, schema=columns)
+    def record_session_end(self, reason: str):
+        import polars as pl
+        end_time_ms = time.time_ns() // 1_000_000
+        duration_ms = end_time_ms - self.sess_start_time_ms
+        sess_stats = self.sess_stats(self)
+        self.records.append([self.sess_start_time_ms, end_time_ms, duration_ms, self.cycle, reason,
+                            #  self.logger.file_path
+                             ] + list(sess_stats.values()))
+        summ = {"start time": f"{str(self.sess_start_time_ms)}",
+                "finish time": f"{str(end_time_ms)}.",
+                "duration": f"{str(duration_ms)} | wait time {self.wait_ms/1_000: 0.1f}s",
+                "cycles ran": f"{self.cycle} | Lifetime cycles = {self.get_records_df().select(pl.col('cycles').sum()).item()}",
+                "termination reason": reason,
+                # "logfile": self.logger.file_path
+                }
+        summ.update(sess_stats)
+        tmp = get_repr(summ)
+        self.logger.critical("\n--> Scheduler has finished running a session. \n" + tmp + "\n" + "-" * 100)
+        df = self.get_records_df()
+        df = df.with_columns([
+            pl.col("start").map_elements(lambda x: str(x).split(".", maxsplit=1)[0], return_dtype=pl.String),
+            pl.col("finish").map_elements(lambda x: str(x).split(".", maxsplit=1)[0], return_dtype=pl.String),
+            pl.col("duration").map_elements(lambda x: str(x).split(".", maxsplit=1)[0], return_dtype=pl.String)
+        ])
+        self.logger.critical("\n--> Logger history.\n" + str(df))
+        return self
+    def default_exception_handler(self, ex: Union[Exception, KeyboardInterrupt], during: str, sched: 'Scheduler') -> None:  # user decides on handling and continue, terminate, save checkpoint, etc.  # Use signal library.
+        print(sched)
+        self.record_session_end(reason=f"during {during}, " + str(ex))
+        self.logger.exception(ex)
+        raise ex

machineconfig/utils/ve.py

@@ -1,105 +1,51 @@
-"""python and ve installation related utils
-"""
-
-from crocodile.core import Struct, List
-from crocodile.file_management import P
-
+from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.utils2 import read_ini
 import platform
-from dataclasses import dataclass
-from typing import Optional, Literal
-
-from machineconfig.utils.ve_utils.ve1 import get_installed_interpreters
-from machineconfig.utils.ve_utils.ve1 import get_ve_specs
-from machineconfig.utils.ve_utils.ve2 import get_bash_repos_install_script
-from machineconfig.utils.ve_utils.ve2 import get_ps1_repos_install_script
-from machineconfig.utils.ve_utils.ve2 import get_bash_ve_install_script
-from machineconfig.utils.ve_utils.ve2 import get_ps1_ve_install_script
-from machineconfig.utils.ve_utils.ve2 import create_symlinks
-from machineconfig.utils.ve_utils.ve2 import make_installation_recipe
-
-
-
-@dataclass
-class VE_Specs:
-    ve_name: str
-    py_version: str
-    ipy_profile: str
-    os: str
-
-
-@dataclass
-class VE_INI:
-    specs: VE_Specs
-
-
-def get_ve_install_script(ve_name: Optional[str] = None, py_version: Optional[str] = None,
-                          install_crocodile_and_machineconfig: Optional[bool] = None,
-                          delete_if_exists: bool=True,
-                          ) -> str:
-    from rich.console import Console
-    console = Console()
-    if py_version is None:
-        print("""
-{'=' * 60}
-🔍 AVAILABLE PYTHON VERSIONS
-{'=' * 60}
-""")
-        res = get_installed_interpreters()
-        List(res).print()
-        print("""
-{'=' * 60}
-""")
-        dotted_py_version = input("🔢 Enter python version (3.11): ") or "3.11"
+from typing import Optional
+
+
+def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[str], Optional[str]]:
+    """Works with .ve.ini .venv and .ve_path"""
+    ve_path: Optional[str] = None
+    ipy_profile: Optional[str] = None
+    tmp = init_path
+    for _ in init_path.parents:
+        if tmp.joinpath(".ve.ini").exists():
+            ini = read_ini(tmp.joinpath(".ve.ini"))
+            if ve_path is None:
+                ve_path = ini["specs"]["ve_path"]
+                print(f"🐍 Using Virtual Environment: {ve_path}. This is based on this file {tmp.joinpath('.ve.ini')}")
+            if ipy_profile is None:
+                ipy_profile = ini["specs"]["ipy_profile"]
+                print(f"✨ Using IPython profile: {ipy_profile}")
+        if ipy_profile is None and tmp.joinpath(".ipy_profile").exists():
+            ipy_profile = tmp.joinpath(".ipy_profile").read_text().rstrip()
+            print(f"✨ Using IPython profile: {ipy_profile}. This is based on this file {tmp.joinpath('.ipy_profile')}")
+        if ve_path is None and tmp.joinpath(".ve_path").exists():
+            ve_path = tmp.joinpath(".ve_path").read_text().rstrip().replace("\n", "")
+            print(f"🔮 Using Virtual Environment found @ {tmp}/.ve_path: {ve_path}")
+        if ve_path is None and tmp.joinpath(".venv").exists():
+            print(f"🔮 Using Virtual Environment found @ {tmp}/.venv")
+            ve_path = tmp.joinpath(".venv").resolve().__str__()
+        tmp = tmp.parent
+        if ve_path and ipy_profile:
+            break
     else:
-        dotted_py_version = py_version
-
-    if ve_name is None:
-        console.rule("📦 Existing Virtual Environments")
-        for ve_path in P.home().joinpath("venvs").search("*", files=False):
-            try:
-                ve_specs = get_ve_specs(ve_path)
-            except Exception as _e:
-                continue
-            Struct(ve_specs).print(title=ve_path.stem, as_config=True)
-        default_ve_name = P.cwd().name
-        ve_name = input(f"📝 Enter virtual environment name ({default_ve_name}): ") or default_ve_name
-
-    if install_crocodile_and_machineconfig is None:
-        essential_repos = input("🔄 Install essential repos? (y/[n]): ") == "y"
-        other_repos = input("📦 Input space separated other packages: ")
-    else:
-        essential_repos = install_crocodile_and_machineconfig
-        other_repos = ""
-
-    env_path = P.home().joinpath("venvs", ve_name)
-    if delete_if_exists and env_path.exists():
-        sure = input(f"⚠️ An existing environment found. Are you sure you want to delete {env_path} before making new one? (y/[n]): ") == "y"
-        console.rule("🗑️ Deleting existing environment with similar name")
-        env_path.delete(sure=sure)
-
-    system: Literal["Windows", "Linux"]
-    if platform.system() == "Windows":
-        system = "Windows"
-        script = get_ps1_ve_install_script(ve_name=ve_name, py_version=dotted_py_version, use_web=False, system=system)
-    elif platform.system() == "Linux":
-        system = "Linux"
-        script = get_bash_ve_install_script(ve_name=ve_name, py_version=dotted_py_version, use_web=False, system=system)
-    else:
-        raise NotImplementedError(f"❌ System {platform.system()} not supported.")
-
-    if essential_repos:
-        if system == "Windows":
-            script += "\n" + get_ps1_repos_install_script(ve_name=ve_name, use_web=False, system=system)
-        elif system == "Linux":
-            script += "\n" + get_bash_repos_install_script(ve_name=ve_name, use_web=False, system=system)
-        else:
-            raise NotImplementedError(f"❌ System {system} not supported.")
-
-    if other_repos != "":
-        script += "\nuv pip install " + other_repos
-
-    link_ve: bool = input("🔗 Create symlinks? [y/[n]] ") == "y"
-    if link_ve: create_symlinks(repo_root=P.cwd(), ve_name=ve_name, dotted_py_version=dotted_py_version, system=system, ipy_profile="default")
-    make_installation_recipe(repo_root=P.cwd(), ve_name=ve_name, py_version=dotted_py_version)
-    return script
-
+        print("🔍 No Virtual Environment or IPython profile found.")
+    return ve_path, ipy_profile
+
+
+def get_repo_root(choice_file: str) -> Optional[str]:
+    from git import Repo, InvalidGitRepositoryError
+    try:
+        repo = Repo(PathExtended(choice_file), search_parent_directories=True)
+        repo_root = str(repo.working_tree_dir) if repo.working_tree_dir else None
+    except InvalidGitRepositoryError:
+        repo_root = None
+    return repo_root
+
+def get_ve_activate_line(ve_root: str):
+    if platform.system() == "Windows": activate_ve_line = f". {ve_root}/Scripts/activate.ps1"
+    elif platform.system() in ["Linux", "Darwin"]: activate_ve_line = f". {ve_root}/bin/activate"
+    else: raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    return activate_ve_line

{machineconfig-1.94.dist-info → machineconfig-1.96.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 1.94
+Version: 1.96
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0
@@ -9,7 +9,7 @@ Project-URL: Bug Tracker, https://github.com/thisismygitrepo/machineconfig/issue
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: crocodile
 Requires-Dist: rich>=14.0.0
@@ -17,7 +17,6 @@ Requires-Dist: paramiko>=3.5.1
 Requires-Dist: psutil>=7.0.0
 Requires-Dist: openai>=1.75.0
 Requires-Dist: nbformat>=5.10.4
-Requires-Dist: streamlit>=1.44.1
 Requires-Dist: fire>=0.7.0
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: clipboard>=0.0.4
@@ -25,8 +24,11 @@ Requires-Dist: gitpython>=3.1.44
 Requires-Dist: pudb>=2024.1.3
 Requires-Dist: pyfzf>=0.3.1
 Requires-Dist: call-function-with-timeout>=1.1.1
+Requires-Dist: rclone-python>=0.1.23
 Provides-Extra: windows
 Requires-Dist: pywin32; extra == "windows"
+Provides-Extra: docs
+Requires-Dist: pdoc>=15.0.2; extra == "docs"
 
 
 <p align="center">