mm-std 0.4.17__py3-none-any.whl → 0.5.0__py3-none-any.whl

mm_std/concurrency/async_task_runner.py

@@ -1,126 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-from collections.abc import Awaitable
-from dataclasses import dataclass
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncTaskRunner:
-    """
-    AsyncTaskRunner executes a batch of asynchronous tasks with controlled concurrency.
-    Note: This runner is designed for one-time use. Create a new instance for each batch of tasks.
-    """
-
-    @dataclass
-    class Result:
-        results: dict[str, Any]  # Maps task_id to result
-        exceptions: dict[str, Any]  # Maps task_id to exception (if any)
-        is_ok: bool  # True if no exception and no timeout occurred
-        is_timeout: bool  # True if at least one task was cancelled due to timeout
-
-    @dataclass
-    class Task:
-        """Individual task representation"""
-
-        task_id: str
-        awaitable: Awaitable[Any]
-
-    def __init__(
-        self, max_concurrent_tasks: int, timeout: float | None = None, name: str | None = None, no_logging: bool = False
-    ) -> None:
-        """
-        :param max_concurrent_tasks: Maximum number of tasks that can run concurrently.
-        :param timeout: Optional overall timeout in seconds for running all tasks.
-        :param name: Optional name for the runner.
-        :param no_logging: If True, suppresses logging for task exception.
-        """
-        if timeout is not None and timeout <= 0:
-            raise ValueError("Timeout must be positive if specified.")
-        self.max_concurrent_tasks: int = max_concurrent_tasks
-        self.timeout: float | None = timeout
-        self.name = name
-        self.no_logging = no_logging
-        self.semaphore: asyncio.Semaphore = asyncio.Semaphore(max_concurrent_tasks)
-        self._tasks: list[AsyncTaskRunner.Task] = []
-        self._was_run: bool = False
-        self._task_ids: set[str] = set()
-
-    def add_task(
-        self,
-        task_id: str,
-        awaitable: Awaitable[Any],
-    ) -> None:
-        """
-        Adds a task to the runner that will be executed when run() is called.
-
-        :param task_id: Unique identifier for the task.
-        :param awaitable: The awaitable (coroutine) to execute.
-        :raises RuntimeError: If the runner has already been used.
-        :raises ValueError: If task_id is empty or already exists.
-        """
-        if self._was_run:
-            raise RuntimeError("This AsyncTaskRunner has already been used. Create a new instance for new tasks.")
-
-        if not task_id:
-            raise ValueError("Task ID cannot be empty")
-
-        if task_id in self._task_ids:
-            raise ValueError(f"Task ID '{task_id}' already exists. All task IDs must be unique.")
-
-        self._task_ids.add(task_id)
-        self._tasks.append(AsyncTaskRunner.Task(task_id, awaitable))
-
-    def _task_name(self, task_id: str) -> str:
-        return f"{self.name}-{task_id}" if self.name else task_id
-
-    async def run(self) -> AsyncTaskRunner.Result:
-        """
-        Executes all added tasks with concurrency limited by the semaphore.
-        If a timeout is specified, non-finished tasks are cancelled.
-
-        :return: AsyncTaskRunner.Result containing task results, exceptions, and flags indicating overall status.
-        :raises RuntimeError: If the runner has already been used.
-        """
-        if self._was_run:
-            raise RuntimeError("This AsyncTaskRunner instance can only be run once. Create a new instance for new tasks.")
-
-        self._was_run = True
-        results: dict[str, Any] = {}
-        exceptions: dict[str, Any] = {}
-        is_timeout: bool = False
-
-        async def run_task(task: AsyncTaskRunner.Task) -> None:
-            async with self.semaphore:
-                try:
-                    res: Any = await task.awaitable
-                    results[task.task_id] = res
-                except Exception as e:
-                    if not self.no_logging:
-                        logger.exception("Task raised an exception", extra={"task_id": task.task_id})
-                    exceptions[task.task_id] = e
-
-        # Create asyncio tasks for all runner tasks
-        tasks = [asyncio.create_task(run_task(task), name=self._task_name(task.task_id)) for task in self._tasks]
-
-        try:
-            if self.timeout is not None:
-                # Run with timeout
-                await asyncio.wait_for(asyncio.gather(*tasks), timeout=self.timeout)
-            else:
-                # Run without timeout
-                await asyncio.gather(*tasks)
-        except TimeoutError:
-            # Cancel all running tasks on timeout
-            for task in tasks:
-                if not task.done():
-                    task.cancel()
-            # Wait for tasks to complete cancellation
-            await asyncio.gather(*tasks, return_exceptions=True)
-            is_timeout = True
-
-        is_ok: bool = (not exceptions) and (not is_timeout)
-        return AsyncTaskRunner.Result(results=results, exceptions=exceptions, is_ok=is_ok, is_timeout=is_timeout)

mm_std/concurrency/sync_decorators.py

@@ -1,35 +0,0 @@
-import functools
-from collections import defaultdict
-from collections.abc import Callable
-from threading import Lock
-
-
-def synchronized_parameter[T, **P](arg_index: int = 0, skip_if_locked: bool = False) -> Callable[..., Callable[P, T | None]]:
-    locks: dict[object, Lock] = defaultdict(Lock)
-
-    def outer(func: Callable[P, T]) -> Callable[P, T | None]:
-        @functools.wraps(func)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T | None:
-            if skip_if_locked and locks[args[arg_index]].locked():
-                return None
-            try:
-                with locks[args[arg_index]]:
-                    return func(*args, **kwargs)
-            finally:
-                locks.pop(args[arg_index], None)
-
-        wrapper.locks = locks  # type: ignore[attr-defined]
-        return wrapper
-
-    return outer
-
-
-def synchronized[T, **P](fn: Callable[P, T]) -> Callable[P, T]:
-    lock = Lock()
-
-    @functools.wraps(fn)
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-        with lock:
-            return fn(*args, **kwargs)
-
-    return wrapper

mm_std/concurrency/sync_scheduler.py

@@ -1,73 +0,0 @@
-import time
-from dataclasses import dataclass, field
-from datetime import datetime
-from logging import Logger
-from threading import Thread
-
-from mm_std.date import is_too_old, utc_now
-from mm_std.types_ import Func
-
-
-class Scheduler:
-    def __init__(self, log: Logger, loop_delay: float = 0.5, debug: bool = False) -> None:
-        self.log = log
-        self.debug = debug
-        self.loop_delay = loop_delay
-        self.stopped = False
-        self.jobs: list[Scheduler.Job] = []
-        self.run_immediately_jobs: list[Scheduler.Job] = []
-        self._debug("init")
-
-    @dataclass
-    class Job:
-        func: Func
-        args: tuple[object, ...]
-        interval: int
-        is_running: bool = False
-        last_at: datetime = field(default_factory=utc_now)
-
-        def __str__(self) -> str:
-            return str(self.func)
-
-    def add_job(self, func: Func, interval: int, args: tuple[object, ...] = (), run_immediately: bool = False) -> None:
-        job = Scheduler.Job(func, args, interval)
-        self.jobs.append(job)
-        if run_immediately:
-            self.run_immediately_jobs.append(job)
-
-    def _run_job(self, job: Job) -> None:
-        self._debug(f"_run_job: {job}")
-        if self.stopped:
-            return
-        try:
-            job.func(*job.args)
-            self._debug(f"_run_job: {job} done")
-        except Exception:
-            self.log.exception("scheduler error")
-            self._debug(f"_run_job: {job} error")
-        finally:
-            job.is_running = False
-
-    def _start(self) -> None:
-        self._debug(f"_start: jobs={len(self.jobs)}, run_immediately_jobs={len(self.run_immediately_jobs)}")
-        for j in self.run_immediately_jobs:
-            j.is_running = True
-            j.last_at = utc_now()
-            Thread(target=self._run_job, args=(j,)).start()
-        while not self.stopped:
-            for j in self.jobs:
-                if not j.is_running and is_too_old(j.last_at, j.interval):
-                    j.is_running = True
-                    j.last_at = utc_now()
-                    Thread(target=self._run_job, args=(j,)).start()
-            time.sleep(self.loop_delay)
-
-    def _debug(self, message: str) -> None:
-        if self.debug:
-            self.log.debug("Scheduler: %s", message)
-
-    def start(self) -> None:
-        Thread(target=self._start).start()
-
-    def stop(self) -> None:
-        self.stopped = True

mm_std/concurrency/sync_task_runner.py

@@ -1,45 +0,0 @@
-import concurrent
-from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
-
-from mm_std.types_ import Args, Func, Kwargs
-
-
-class ConcurrentTasks:
-    def __init__(self, max_workers: int = 5, timeout: int | None = None, thread_name_prefix: str = "concurrent_tasks") -> None:
-        self.max_workers = max_workers
-        self.timeout = timeout
-        self.thread_name_prefix = thread_name_prefix
-        self.tasks: list[ConcurrentTasks.Task] = []
-        self.exceptions: dict[str, Exception] = {}
-        self.error = False
-        self.timeout_error = False
-        self.result: dict[str, object] = {}
-
-    @dataclass
-    class Task:
-        key: str
-        func: Func
-        args: Args
-        kwargs: Kwargs
-
-    def add_task(self, key: str, func: Func, args: Args = (), kwargs: Kwargs | None = None) -> None:
-        if kwargs is None:
-            kwargs = {}
-        self.tasks.append(ConcurrentTasks.Task(key, func, args, kwargs))
-
-    def execute(self) -> None:
-        with ThreadPoolExecutor(self.max_workers, thread_name_prefix=self.thread_name_prefix) as executor:
-            future_to_key = {executor.submit(task.func, *task.args, **task.kwargs): task.key for task in self.tasks}
-            try:
-                result_map = concurrent.futures.as_completed(future_to_key, timeout=self.timeout)
-                for future in result_map:
-                    key = future_to_key[future]
-                    try:
-                        self.result[key] = future.result()
-                    except Exception as err:
-                        self.error = True
-                        self.exceptions[key] = err
-            except concurrent.futures.TimeoutError:
-                self.error = True
-                self.timeout_error = True

mm_std/config.py

@@ -1,81 +0,0 @@
-import sys
-import tomllib
-from pathlib import Path
-from typing import Any, NoReturn, Self, TypeVar
-
-from pydantic import BaseModel, ConfigDict, ValidationError
-
-from .print_ import print_json, print_plain
-from .result import Result
-from .zip import read_text_from_zip_archive
-
-T = TypeVar("T", bound="BaseConfig")
-
-
-class BaseConfig(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    def print_and_exit(self, exclude: set[str] | None = None, count: set[str] | None = None) -> NoReturn:
-        data = self.model_dump(exclude=exclude)
-        if count:
-            for k in count:
-                data[k] = len(data[k])
-        print_json(data)
-        sys.exit(0)
-
-    @classmethod
-    def read_toml_config_or_exit(cls, config_path: Path, zip_password: str = "") -> Self:  # nosec
-        res: Result[Self] = cls.read_toml_config(config_path, zip_password)
-        if res.is_ok():
-            return res.unwrap()
-        cls._print_error_and_exit(res)
-
-    @classmethod
-    async def read_toml_config_or_exit_async(cls, config_path: Path, zip_password: str = "") -> Self:  # nosec
-        res: Result[Self] = await cls.read_toml_config_async(config_path, zip_password)
-        if res.is_ok():
-            return res.unwrap()
-        cls._print_error_and_exit(res)
-
-    @classmethod
-    def read_toml_config(cls, config_path: Path, zip_password: str = "") -> Result[Self]:  # nosec
-        try:
-            config_path = config_path.expanduser()
-            if config_path.name.endswith(".zip"):
-                data = tomllib.loads(read_text_from_zip_archive(config_path, password=zip_password))
-            else:
-                with config_path.open("rb") as f:
-                    data = tomllib.load(f)
-            return Result.ok(cls(**data))
-        except ValidationError as e:
-            return Result.err(("validator_error", e), extra={"errors": e.errors()})
-        except Exception as e:
-            return Result.err(e)
-
-    @classmethod
-    async def read_toml_config_async(cls, config_path: Path, zip_password: str = "") -> Result[Self]:  # nosec
-        try:
-            config_path = config_path.expanduser()
-            if config_path.name.endswith(".zip"):
-                data = tomllib.loads(read_text_from_zip_archive(config_path, password=zip_password))
-            else:
-                with config_path.open("rb") as f:
-                    data = tomllib.load(f)
-            model = await cls.model_validate(data)  # type:ignore[misc]
-            return Result.ok(model)
-        except ValidationError as e:
-            return Result.err(("validator_error", e), extra={"errors": e.errors()})
-        except Exception as e:
-            return Result.err(e)
-
-    @classmethod
-    def _print_error_and_exit(cls, res: Result[Any]) -> NoReturn:
-        if res.error == "validator_error" and res.extra:
-            print_plain("config validation errors")
-            for e in res.extra["errors"]:
-                loc = e["loc"]
-                field = ".".join(str(lo) for lo in loc) if len(loc) > 0 else ""
-                print_plain(f"{field} {e['msg']}")
-        else:
-            print_plain(f"can't parse config file: {res.error} {res.exception}")
-        sys.exit(1)

mm_std/crypto/fernet.py

@@ -1,13 +0,0 @@
-from cryptography.fernet import Fernet
-
-
-def fernet_generate_key() -> str:
-    return Fernet.generate_key().decode()
-
-
-def fernet_encrypt(*, data: str, key: str) -> str:
-    return Fernet(key).encrypt(data.encode()).decode()
-
-
-def fernet_decrypt(*, encoded_data: str, key: str) -> str:
-    return Fernet(key).decrypt(encoded_data).decode()

mm_std/crypto/openssl.py

@@ -1,207 +0,0 @@
-from base64 import b64decode, b64encode
-from hashlib import pbkdf2_hmac
-from os import urandom
-from pathlib import Path
-
-from cryptography.hazmat.primitives import padding
-from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-
-MAGIC = b"Salted__"
-SALT_SIZE = 8
-KEY_SIZE = 32  # for AES-256
-IV_SIZE = 16
-
-
-def openssl_encrypt(input_path: Path, output_path: Path, password: str, iterations: int = 1_000_000) -> None:
-    """
-    Encrypt a file using OpenSSL-compatible AES-256-CBC with PBKDF2 and output in binary format.
-
-    This function creates encrypted files that are fully compatible with OpenSSL command:
-    openssl enc -aes-256-cbc -pbkdf2 -iter 1000000 -salt -in message.txt -out message.enc
-
-    Args:
-        input_path: Path to the input file to encrypt
-        output_path: Path where the encrypted binary file will be saved
-        password: Password for encryption
-        iterations: Number of PBKDF2 iterations (minimum 1000, default 1,000,000)
-
-    Raises:
-        ValueError: If iterations < 1000
-
-    Example:
-        >>> from pathlib import Path
-        >>> openssl_encrypt(Path("secret.txt"), Path("secret.enc"), "mypassword")
-
-        # Decrypt with OpenSSL:
-        # openssl enc -d -aes-256-cbc -pbkdf2 -iter 1000000 -in secret.enc -out secret_decrypted.txt -pass pass:mypassword
-    """
-    if iterations < 1000:
-        raise ValueError("Iteration count must be at least 1000 for security")
-
-    data: bytes = input_path.read_bytes()
-    salt: bytes = urandom(SALT_SIZE)
-
-    key_iv: bytes = pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations, KEY_SIZE + IV_SIZE)
-    key: bytes = key_iv[:KEY_SIZE]
-    iv: bytes = key_iv[KEY_SIZE:]
-
-    padder = padding.PKCS7(algorithms.AES.block_size).padder()
-    padded_data: bytes = padder.update(data) + padder.finalize()
-
-    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
-    encryptor = cipher.encryptor()
-    ciphertext: bytes = encryptor.update(padded_data) + encryptor.finalize()
-
-    output_path.write_bytes(MAGIC + salt + ciphertext)
-
-
-def openssl_decrypt(input_path: Path, output_path: Path, password: str, iterations: int = 1_000_000) -> None:
-    """
-    Decrypt a binary file created by OpenSSL-compatible AES-256-CBC with PBKDF2.
-
-    This function decrypts files that were encrypted with OpenSSL command:
-    openssl enc -aes-256-cbc -pbkdf2 -iter 1000000 -salt -in message.txt -out message.enc
-
-    Args:
-        input_path: Path to the encrypted binary file
-        output_path: Path where the decrypted file will be saved
-        password: Password for decryption
-        iterations: Number of PBKDF2 iterations (minimum 1000, default 1,000,000)
-
-    Raises:
-        ValueError: If iterations < 1000, invalid file format, or wrong password
-
-    Example:
-        >>> from pathlib import Path
-        >>> openssl_decrypt(Path("secret.enc"), Path("secret_decrypted.txt"), "mypassword")
-
-        # Encrypt with OpenSSL:
-        # openssl enc -aes-256-cbc -pbkdf2 -iter 1000000 -salt -in secret.txt -out secret.enc -pass pass:mypassword
-    """
-    if iterations < 1000:
-        raise ValueError("Iteration count must be at least 1000 for security")
-
-    raw: bytes = input_path.read_bytes()
-    if not raw.startswith(MAGIC):
-        raise ValueError("Invalid file format: missing OpenSSL Salted header")
-
-    salt: bytes = raw[8:16]
-    ciphertext: bytes = raw[16:]
-
-    key_iv: bytes = pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations, KEY_SIZE + IV_SIZE)
-    key: bytes = key_iv[:KEY_SIZE]
-    iv: bytes = key_iv[KEY_SIZE:]
-
-    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
-    decryptor = cipher.decryptor()
-    padded_plaintext: bytes = decryptor.update(ciphertext) + decryptor.finalize()
-
-    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
-    try:
-        plaintext: bytes = unpadder.update(padded_plaintext) + unpadder.finalize()
-    except ValueError as e:
-        raise ValueError("Decryption failed: invalid padding or wrong password") from e
-
-    output_path.write_bytes(plaintext)
-
-
-def openssl_encrypt_base64(input_path: Path, output_path: Path, password: str, iterations: int = 1_000_000) -> None:
-    """
-    Encrypt a file using OpenSSL-compatible AES-256-CBC with PBKDF2 and output in base64 format.
-
-    This function creates encrypted files that are fully compatible with OpenSSL command:
-    openssl enc -aes-256-cbc -pbkdf2 -iter 1000000 -salt -base64 -in message.txt -out message.enc
-
-    Args:
-        input_path: Path to the input file to encrypt
-        output_path: Path where the encrypted base64 file will be saved
-        password: Password for encryption
-        iterations: Number of PBKDF2 iterations (minimum 1000, default 1,000,000)
-
-    Raises:
-        ValueError: If iterations < 1000
-
-    Example:
-        >>> from pathlib import Path
-        >>> openssl_encrypt_base64(Path("secret.txt"), Path("secret.enc"), "mypassword")
-
-        # Decrypt with OpenSSL:
-        # openssl enc -d -aes-256-cbc -pbkdf2 -iter 1000000 -base64 -in secret.enc -out secret_decrypted.txt -pass pass:mypassword
-    """
-    if iterations < 1000:
-        raise ValueError("Iteration count must be at least 1000 for security")
-
-    data: bytes = input_path.read_bytes()
-    salt: bytes = urandom(SALT_SIZE)
-
-    key_iv: bytes = pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations, KEY_SIZE + IV_SIZE)
-    key: bytes = key_iv[:KEY_SIZE]
-    iv: bytes = key_iv[KEY_SIZE:]
-
-    padder = padding.PKCS7(algorithms.AES.block_size).padder()
-    padded_data: bytes = padder.update(data) + padder.finalize()
-
-    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
-    encryptor = cipher.encryptor()
-    ciphertext: bytes = encryptor.update(padded_data) + encryptor.finalize()
-
-    # Encode binary data to base64
-    binary_data: bytes = MAGIC + salt + ciphertext
-    base64_data: str = b64encode(binary_data).decode("ascii")
-    output_path.write_text(base64_data)
-
-
-def openssl_decrypt_base64(input_path: Path, output_path: Path, password: str, iterations: int = 1_000_000) -> None:
-    """
-    Decrypt a base64-encoded file created by OpenSSL-compatible AES-256-CBC with PBKDF2.
-
-    This function decrypts files that were encrypted with OpenSSL command:
-    openssl enc -aes-256-cbc -pbkdf2 -iter 1000000 -salt -base64 -in message.txt -out message.enc
-
-    Args:
-        input_path: Path to the encrypted base64 file
-        output_path: Path where the decrypted file will be saved
-        password: Password for decryption
-        iterations: Number of PBKDF2 iterations (minimum 1000, default 1,000,000)
-
-    Raises:
-        ValueError: If iterations < 1000, invalid file format, or wrong password
-
-    Example:
-        >>> from pathlib import Path
-        >>> openssl_decrypt_base64(Path("secret.enc"), Path("secret_decrypted.txt"), "mypassword")
-
-        # Encrypt with OpenSSL:
-        # openssl enc -aes-256-cbc -pbkdf2 -iter 1000000 -salt -base64 -in secret.txt -out secret.enc -pass pass:mypassword
-    """
-    if iterations < 1000:
-        raise ValueError("Iteration count must be at least 1000 for security")
-
-    # Decode base64 to binary data
-    try:
-        base64_data: str = input_path.read_text().strip()
-        raw: bytes = b64decode(base64_data)
-    except Exception as e:
-        raise ValueError("Invalid base64 format") from e
-
-    if not raw.startswith(MAGIC):
-        raise ValueError("Invalid file format: missing OpenSSL Salted header")
-
-    salt: bytes = raw[8:16]
-    ciphertext: bytes = raw[16:]
-
-    key_iv: bytes = pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations, KEY_SIZE + IV_SIZE)
-    key: bytes = key_iv[:KEY_SIZE]
-    iv: bytes = key_iv[KEY_SIZE:]
-
-    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
-    decryptor = cipher.decryptor()
-    padded_plaintext: bytes = decryptor.update(ciphertext) + decryptor.finalize()
-
-    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
-    try:
-        plaintext: bytes = unpadder.update(padded_plaintext) + unpadder.finalize()
-    except ValueError as e:
-        raise ValueError("Decryption failed: invalid padding or wrong password") from e
-
-    output_path.write_bytes(plaintext)

mm_std/dict.py

@@ -1,49 +0,0 @@
-from collections import defaultdict
-from collections.abc import Mapping, MutableMapping
-from typing import TypeVar, cast
-
-K = TypeVar("K")
-V = TypeVar("V")
-DictType = TypeVar("DictType", bound=MutableMapping[K, V])  # type: ignore[valid-type]
-
-
-def replace_empty_dict_entries(
-    data: DictType,
-    defaults: Mapping[K, V] | None = None,
-    zero_is_empty: bool = False,
-    false_is_empty: bool = False,
-    empty_string_is_empty: bool = True,
-) -> DictType:
-    """
-    Replace empty entries in a dictionary with provided default values,
-    or remove them if no default is available. Returns the same type as the input dictionary.
-    """
-    if defaults is None:
-        defaults = {}
-
-    try:
-        if isinstance(data, defaultdict):
-            result: MutableMapping[K, V] = defaultdict(data.default_factory)
-        else:
-            result = data.__class__()
-    except Exception:
-        result = {}
-
-    for key, value in data.items():
-        should_replace = (
-            value is None
-            or (empty_string_is_empty and value == "")
-            or (zero_is_empty and value == 0)
-            or (false_is_empty and value is False)
-        )
-
-        if should_replace:
-            if key in defaults:
-                new_value = defaults[key]
-            else:
-                continue  # Skip the key if no default is available
-        else:
-            new_value = value
-
-        result[key] = new_value
-    return cast(DictType, result)

mm_std/env.py

@@ -1,9 +0,0 @@
-import os
-
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-def get_dotenv(key: str) -> str | None:
-    return os.getenv(key)

mm_std/fs.py

@@ -1,13 +0,0 @@
-from pathlib import Path
-
-
-def read_text(path: str | Path) -> str:
-    if isinstance(path, str):
-        path = Path(path)
-    return path.read_text()
-
-
-def get_filename_without_extension(path: str | Path) -> str:
-    if isinstance(path, str):
-        path = Path(path)
-    return path.stem