machineconfig 1.97__py3-none-any.whl → 2.1__py3-none-any.whl

machineconfig/utils/utils2.py

@@ -1,42 +1,75 @@
-
-
 from pathlib import Path
 from typing import Optional, Any
+# import time
+# from typing import Callable, Literal, TypeVar, ParamSpec
+
 
 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))
+    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}")
+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
+
+
+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)
+        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.
+
+        mydict = pyjson5.loads(Path(path).read_text(encoding="utf-8"), **kwargs)  # file has C-style comments.
     _ = r
     return mydict
-def read_toml(path: 'Path'):
+
+
+def read_toml(path: "Path"):
     import tomli
-    return tomli.loads(path.read_text(encoding='utf-8'))
+
+    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()])
+
+
+def human_friendly_dict(d: dict[str, Any]) -> dict[str, Any]:
+    from datetime import datetime
+
+    result = {}
+    for k, v in d.items():
+        if isinstance(v, float):
+            result[k] = f"{v:.2f}"
+        elif isinstance(v, bool):
+            result[k] = "✓" if v else "✗"
+        elif isinstance(v, int) and len(str(v)) == 13 and v > 0:  # assuming ms timestamp
+            dt = datetime.fromtimestamp(v / 1000)
+            result[k] = dt.strftime("%Y-%m-%d %H:%M")
+        else:
+            result[k] = v
+    return result

machineconfig/utils/utils5.py

@@ -1,39 +1,68 @@
-
-from typing import Callable, Optional, Union, Any
-from logging import Logger as Log
-from machineconfig.utils.utils2 import randstr, get_repr
+from pathlib import Path
+from typing import Callable, Optional, Union, Any, NoReturn, TypeVar, Protocol, List, Generic
+import logging
 import time
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+
+
+class LoggerTemplate(Protocol):
+    handlers: List[logging.Handler]
+
+    def debug(self, msg: str) -> None:
+        pass  # 10
+
+    def info(self, msg: str) -> None:
+        pass  # 20
+
+    def warning(self, msg: str) -> None:
+        pass  # 30
+
+    def error(self, msg: str) -> None:
+        pass  # 40
+
+    def critical(self, msg: str) -> None:
+        pass  # 50
+
+    def fatal(self, msg: str) -> None:
+        pass  # 50
 
 
 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):
+    def __init__(
+        self,
+        routine: Callable[["Scheduler"], Any],
+        wait_ms: int,
+        logger: LoggerTemplate,
+        sess_stats: Optional[Callable[["Scheduler"], dict[str, Any]]] = None,
+        exception_handler: Optional[Callable[[Union[Exception, KeyboardInterrupt], str, "Scheduler"], 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.logger = logger
         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_start_utc_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):
+
+    def __repr__(self):
+        return f"Scheduler with {self.cycle} cycles ran so far. Last cycle was at {self.sess_start_utc_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
+            until_ms = 1_000_000_000_000_000
+        self.sess_start_utc_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')}")
+            duration = timedelta(milliseconds=time1_ms - self.sess_start_utc_ms)
+            self.logger.info(f"Starting Cycle {str(self.cycle).zfill(5)}. Total Run Time = {str(duration).split('.', maxsplit=1)[0]}. UTC🕜 {datetime.now(tz=timezone.utc).strftime('%d %H:%M:%S')}")
             try:
                 self.routine(self)
             except Exception as ex:
@@ -41,44 +70,211 @@ class Scheduler:
             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
+            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.1f}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 get_records_df(self) -> List[dict[str, Any]]:
+        columns = ["start", "finish", "duration", "cycles", "termination reason"] + list(self.sess_stats(self).keys())
+        return [dict(zip(columns, row)) for row in self.records]
+
     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
+        duration_ms = end_time_ms - self.sess_start_utc_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
-                }
+        self.records.append(
+            [
+                self.sess_start_utc_ms,
+                end_time_ms,
+                duration_ms,
+                self.cycle,
+                reason,
+                #  self.logger.file_path
+            ]
+            + list(sess_stats.values())
+        )
+        records_df = self.get_records_df()
+        total_cycles = sum(row["cycles"] for row in records_df)
+        summ = {
+            "start time": f"{str(self.sess_start_utc_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 = {total_cycles}",
+            "termination reason": reason,
+            # "logfile": self.logger.file_path
+        }
         summ.update(sess_stats)
+        from machineconfig.utils.utils2 import get_repr
+
         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))
+        # Format records as table
+        if records_df:
+            headers = list(records_df[0].keys())
+            # Process start, finish, duration to strings without milliseconds
+            processed_records = []
+            for row in records_df:
+                processed = row.copy()
+                processed["start"] = str(row["start"]).split(".", maxsplit=1)[0]
+                processed["finish"] = str(row["finish"]).split(".", maxsplit=1)[0]
+                processed["duration"] = str(row["duration"]).split(".", maxsplit=1)[0]
+                processed_records.append(processed)
+            # Simple aligned table formatting
+            max_lengths = {col: max(len(str(row.get(col, ""))) for row in processed_records) for col in headers}
+            table_lines = ["| " + " | ".join(col.ljust(max_lengths[col]) for col in headers) + " |"]
+            table_lines.append("|" + "-+-".join("-" * max_lengths[col] for col in headers) + "|")
+            for row in processed_records:
+                table_lines.append("| " + " | ".join(str(row.get(col, "")).ljust(max_lengths[col]) for col in headers) + " |")
+            table_str = "\n".join(table_lines)
+        else:
+            table_str = "No records available."
+        self.logger.critical("\n--> Logger history.\n" + table_str)
         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.
+
+    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)
+        self.logger.fatal(str(ex))
         raise ex
+
+
+T = TypeVar("T")
+T2 = TypeVar("T2")
+
+
+class PrintFunc(Protocol):
+    def __call__(self, msg: str) -> Union[NoReturn, None]: ...
+
+def to_pickle(obj: Any, path: Path) -> None:
+    import pickle
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(pickle.dumps(obj))
+def from_pickle(path: Path) -> Any:
+    import pickle
+    return pickle.loads(path.read_bytes())
+
+
+class Cache(Generic[T]):  # This class helps to accelrate access to latest data coming from expensive function. The class has two flavours, memory-based and disk-based variants."""
+    # source_func: Callable[[], T]
+    def __init__(self, source_func: Callable[[], T],
+                 expire: timedelta, logger: Optional[PrintFunc] = None, path: Optional[Path] = None,
+                 saver: Callable[[T, Path], Any] = to_pickle, reader: Callable[[Path], T] = from_pickle, name: Optional[str] = None) -> None:
+        self.cache: T
+        self.source_func = source_func  # function which when called returns a fresh object to be frozen.
+        self.path: Optional[PathExtended] = PathExtended(path) if path is not None else None  # if path is passed, it will function as disk-based flavour.
+        self.time_produced = datetime.now()  # if path is None else
+        self.save = saver
+        self.reader = reader
+        self.logger = logger
+        self.expire = expire
+        self.name = name if isinstance(name, str) else str(self.source_func)
+        self.last_call_is_fresh = False
+    @property
+    def age(self):
+        """Throws AttributeError if called before cache is populated and path doesn't exists"""
+        if self.path is None:  # memory-based cache.
+            return datetime.now() - self.time_produced
+        return datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
+    # def __setstate__(self, state: dict[str, Any]) -> None:
+    #     self.__dict__.update(state)
+    #     self.path = P.home() / self.path if self.path is not None else self.path
+    # def __getstate__(self) -> dict[str, Any]:
+    #     state = self.__dict__.copy()
+    #     state["path"] = self.path.rel2home() if self.path is not None else state["path"]
+    #     return state  # With this implementation, instances can be pickled and loaded up in different machine and still works.
+    def __call__(self, fresh: bool = False) -> T:
+        self.last_call_is_fresh = False
+        if fresh or not hasattr(self, "cache"):  # populate cache for the first time
+            if not fresh and self.path is not None and self.path.exists():
+                age = datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
+                msg1 = f"""
+📦 ════════════════════ CACHE OPERATION ════════════════════
+🔄 {self.name} cache: Reading cached values from `{self.path}`
+⏱️  Lag = {age}
+════════════════════════════════════════════════════════════
+"""
+                try:
+                    self.cache = self.reader(self.path)
+                except Exception as ex:
+                    if self.logger:
+                        msg2 = f"""
+❌ ════════════════════ CACHE ERROR ════════════════════
+⚠️  {self.name} cache: Cache file is corrupted
+🔍 Error: {ex}
+════════════════════════════════════════════════════════
+"""
+                        self.logger(msg1 + msg2)
+                    self.cache = self.source_func()
+                    self.last_call_is_fresh = True
+                    self.time_produced = datetime.now()
+                    # if self.path is not None:
+                    #     self.save(self.cache, self.path)
+                    return self.cache
+                return self(fresh=False)  # may be the cache is old ==> check that by passing it through the logic again.
+            else:
+                if self.logger:
+                    # Previous cache never existed or there was an explicit fresh order.
+                    why = "There was an explicit fresh order." if fresh else "Previous cache never existed or is corrupted."
+                    self.logger(f"""
+🆕 ════════════════════ NEW CACHE ════════════════════
+🔄 {self.name} cache: Populating fresh cache from source func
+ℹ️  Reason: {why}
+════════════════════════════════════════════════════════
+""")
+                self.cache = self.source_func()  # fresh data.
+                self.last_call_is_fresh = True
+                self.time_produced = datetime.now()
+                if self.path is not None: self.save(self.cache, self.path)
+        else:  # cache exists
+            try: age = self.age
+            except AttributeError:  # path doesn't exist (may be deleted) ==> need to repopulate cache form source_func.
+                return self(fresh=True)
+            if age > self.expire:
+                if self.logger:
+                    self.logger(f"""
+🔄 ════════════════════ CACHE UPDATE ════════════════════
+⚠️  {self.name} cache: Updating cache from source func
+⏱️  Age = {age} > {self.expire}
+════════════════════════════════════════════════════════""")
+                self.cache = self.source_func()
+                self.last_call_is_fresh = True
+                self.time_produced = datetime.now()
+                if self.path is not None: self.save(self.cache, self.path)
+            else:
+                if self.logger:
+                    self.logger(f"""
+✅ ════════════════════ USING CACHE ════════════════════
+📦 {self.name} cache: Using cached values
+⏱️  Lag = {age}
+════════════════════════════════════════════════════════""")
+        return self.cache
+    @staticmethod
+    def as_decorator(expire: timedelta, logger: Optional[PrintFunc] = None, path: Optional[Path] = None,
+                     saver: Callable[[T2, Path], Any] = to_pickle,
+                     reader: Callable[[Path], T2] = from_pickle,
+                     name: Optional[str] = None):  # -> Callable[..., 'Cache[T2]']:
+        def decorator(source_func: Callable[[], T2]) -> Cache['T2']:
+            res = Cache(source_func=source_func, expire=expire, logger=logger, path=path, name=name, reader=reader, saver=saver)
+            return res
+        return decorator
+    def from_cloud(self, cloud: str, rel2home: bool = True, root: Optional[str] = None):
+        assert self.path is not None
+        exists = self.path.exists()
+        exists_but_old = exists and ((datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)) > self.expire)
+        if not exists or exists_but_old:
+            returned_path = self.path.from_cloud(cloud=cloud, rel2home=rel2home, root=root)
+            if returned_path is None and not exists:
+                raise FileNotFoundError(f"❌ Failed to get @ {self.path}. Build the cache first with signed API.")
+            elif returned_path is None and exists and self.logger is not None:
+                self.logger(f"""
+⚠️ ════════════════════ CLOUD FETCH WARNING ════════════════════
+🔄 Failed to get fresh data from cloud
+📦 Using old cache @ {self.path}
+════════════════════════════════════════════════════════════════""")
+        else:
+            pass  # maybe we don't need to fetch it from cloud, if its too hot
+        return self.reader(self.path)

machineconfig/utils/ve.py

@@ -1,4 +1,4 @@
-from machineconfig.utils.path_reduced import P as PathExtended
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.utils2 import read_ini
 import platform
 from typing import Optional
@@ -19,10 +19,10 @@ def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[s
                 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()
+            ipy_profile = tmp.joinpath(".ipy_profile").read_text(encoding="utf-8").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", "")
+            ve_path = tmp.joinpath(".ve_path").read_text(encoding="utf-8").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")
@@ -37,6 +37,7 @@ def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[s
 
 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
@@ -44,8 +45,12 @@ def get_repo_root(choice_file: str) -> Optional[str]:
         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.")
+    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.97.dist-info → machineconfig-2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 1.97
+Version: 2.1
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0
@@ -9,22 +9,28 @@ 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.11
+Requires-Python: >=3.13
 Description-Content-Type: text/markdown
-Requires-Dist: crocodile
 Requires-Dist: rich>=14.0.0
 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: fire>=0.7.0
 Requires-Dist: pydantic>=2.11.3
-Requires-Dist: clipboard>=0.0.4
 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
+Requires-Dist: pytz>=2025.2
+Requires-Dist: tomli>=2.2.1
+Requires-Dist: toml>=0.10.2
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: pyjson5>=1.6.9
+Requires-Dist: requests>=2.32.5
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: joblib>=1.5.2
+Requires-Dist: randomname>=0.2.1
+Requires-Dist: cryptography>=44.0.2
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: markdown>=3.9
 Provides-Extra: windows
 Requires-Dist: pywin32; extra == "windows"
 Provides-Extra: docs
@@ -93,7 +99,7 @@ iwr https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/mac
 (iwr bit.ly/cfgwt).Content | iex
 . $HOME/code/machineconfig/src/machineconfig/setup_windows/symlinks.ps1
 
-& "$HOME\venvs\ve\Scripts\activate.ps1"
+& "$HOME\code\machineconfig\.venv\Scripts\activate.ps1"
 python -m fire machineconfig.profile.create main2 --choice=all
 deactivate