mmar-envops 1.0.1__tar.gz

mmar_envops-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 evjava
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mmar_envops-1.0.1/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: mmar-envops
+Version: 1.0.1
+Summary: Environment and configuration operations for Python applications
+Keywords: environment,configuration,config,env,settings,dotenv
+Author: Tagin
+Author-email: Tagin <evjava@yandex.ru>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Documentation
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Dist: pyyaml~=6.0 ; extra == 'all'
+Requires-Dist: gitpython~=3.1 ; extra == 'all'
+Requires-Python: >=3.12
+Provides-Extra: all
+Description-Content-Type: text/markdown
+
+# mmar-envops
+
+Environment and configuration operations for Python applications.
+
+A facade for managing environment variables, configuration files, and system operations in Python applications.
+
+## Features
+
+- **Environment file handling**: Read and parse `.env` files
+- **Configuration management**: YAML-based configuration with environment-aware loading
+- **Settings integration**: Pydantic settings support
+- **System operations**: File system, git, and execution context utilities
+
+## Installation
+
+```bash
+pip install mmar-envops
+```
+
+## Quick Start
+
+```python
+from mmar_envops import EnvFileAccessor, Config
+
+# Load environment variables from .env file
+env = EnvFileAccessor.from_file(".env")
+api_key = env.get("API_KEY")
+
+# Load configuration from YAML
+config = Config.from_yaml("config.yaml")
+```
+
+## License
+
+MIT

mmar_envops-1.0.1/README.md

@@ -0,0 +1,35 @@
+# mmar-envops
+
+Environment and configuration operations for Python applications.
+
+A facade for managing environment variables, configuration files, and system operations in Python applications.
+
+## Features
+
+- **Environment file handling**: Read and parse `.env` files
+- **Configuration management**: YAML-based configuration with environment-aware loading
+- **Settings integration**: Pydantic settings support
+- **System operations**: File system, git, and execution context utilities
+
+## Installation
+
+```bash
+pip install mmar-envops
+```
+
+## Quick Start
+
+```python
+from mmar_envops import EnvFileAccessor, Config
+
+# Load environment variables from .env file
+env = EnvFileAccessor.from_file(".env")
+api_key = env.get("API_KEY")
+
+# Load configuration from YAML
+config = Config.from_yaml("config.yaml")
+```
+
+## License
+
+MIT

mmar_envops-1.0.1/pyproject.toml

@@ -0,0 +1,69 @@
+[project]
+name = "mmar-envops"
+# dynamic version is not supported yet on uv_build
+version = "1.0.1"
+description = "Environment and configuration operations for Python applications"
+authors = [{name = "Tagin", email = "evjava@yandex.ru"}]
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = ["environment", "configuration", "config", "env", "settings", "dotenv"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Documentation",
+    "Topic :: Software Development",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+all = [
+    "pyyaml~=6.0",
+    "gitpython~=3.1",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.14,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "mmar_envops"
+source-exclude = [".ruff_cache"]
+
+[dependency-groups]
+ci = [
+    "ruff>=0.4",
+    "pytest>=8.2",
+    "pytest-asyncio>=1.0.0",
+]
+
+[tool.uv]
+default-groups = ["ci"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[pytest]
+python_files = [ "test_*.py" ]
+testpaths = [ "tests" ]
+
+# action:message_regex:warning_class:module_regex:line
+filterwarnings = [ "error" ]
+
+[mypy]
+ignore_missing_imports = true
+exclude = "tests/fixtures/"
+warn_unused_ignores = true
+show_error_codes = true

mmar_envops-1.0.1/src/mmar_envops/__init__.py

@@ -0,0 +1,13 @@
+"""
+System operations package.
+
+This package provides interfaces to system-level operations including:
+- Shell command execution
+- File system operations
+- SSH tunnel management
+- Environment file operations
+- Environment variable parsing
+- Interactive REPL utilities
+- Output formatting and colors
+- Execution context and configuration
+"""

mmar_envops-1.0.1/src/mmar_envops/aka_pydantic_settings.py

@@ -0,0 +1,176 @@
+"""Auxiliary very lightweight pydantic-settings alternative"""
+
+import os
+from dataclasses import dataclass
+from typing import Any, ClassVar, Literal, TypeVar, get_args, get_origin
+
+T = TypeVar("T")
+
+SupportedTypes = str | int | bool | float
+
+
+def _str_to_bool(value: str) -> bool:
+    """Convert string to boolean."""
+    normalized = value.lower()
+    if normalized in {"1", "true", "yes", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "off"}:
+        return False
+    raise ValueError(f"Invalid bool value: '{value}'")
+
+
+def _str_to_int(value: str) -> int:
+    """Convert string to int."""
+    try:
+        return int(value)
+    except ValueError:
+        raise ValueError(f"Invalid int value: '{value}'") from None
+
+
+def _str_to_float(value: str) -> float:
+    """Convert string to float."""
+    try:
+        return float(value)
+    except ValueError:
+        return 0.0
+
+
+def _str_to_literal(value: str, literal_values: tuple) -> Any:
+    """Convert string to one of the allowed literal values."""
+    for lit_val in literal_values:
+        if isinstance(lit_val, str) and value == lit_val:
+            return lit_val
+        if isinstance(lit_val, bool) and _str_to_bool(value) == lit_val:
+            return lit_val
+        if isinstance(lit_val, int) and value.isdigit():
+            if int(value) == lit_val:
+                return lit_val
+        if isinstance(lit_val, float):
+            try:
+                if float(value) == lit_val:
+                    return lit_val
+            except ValueError:
+                pass
+    raise ValueError(f"Invalid value '{value}' for Literal, expected one of {literal_values}")
+
+
+@dataclass(frozen=True)
+class AkaField:
+    """Field descriptor with default value and alias support."""
+
+    default: Any = None
+    alias: str | None = None
+
+
+class _FieldInfo:
+    """Internal field metadata storage."""
+
+    __slots__ = ("name", "type", "default", "alias", "has_alias", "is_literal", "literal_values")
+
+    def __init__(self, name: str, type_: type, default: Any, alias: str | None = None):
+        self.name = name
+        self.type = type_
+        self.default = default
+        self.alias = alias
+        self.has_alias = alias is not None
+        self.is_literal = get_origin(type_) is Literal
+        self.literal_values = get_args(type_) if self.is_literal else ()
+
+
+class AkaBaseSettings:
+    """Base settings class that reads from environment variables.
+
+    Features:
+    - Field aliases: e.g., debug with alias="d" can be set via DEBUG or D env var
+    - Type coercion for str/int/bool/float/Literal
+    - Default values
+    - Ignores extra environment variables
+    """
+
+    _field_info: ClassVar[dict[str, _FieldInfo]] = {}
+
+    def __init_subclass__(cls, **kwargs: Any):
+        """Parse class annotations and build field metadata."""
+        super().__init_subclass__(**kwargs)
+
+        fields = {}
+
+        for name, type_ in cls.__annotations__.items():
+            default_value = getattr(cls, name, None)
+            alias = None
+
+            if isinstance(default_value, AkaField):
+                alias = default_value.alias
+                default_value = default_value.default
+            elif default_value is None:
+                # For None defaults, check if it's Optional or required
+                pass
+
+            fields[name] = _FieldInfo(name, type_, default_value, alias)
+
+        cls._field_info = fields
+
+    def __init__(self, **kwargs: Any):
+        """Initialize settings from environment variables and keyword arguments.
+
+        Priority: environment variables > passed kwargs > default values.
+        Extra kwargs that don't match any field are ignored.
+        """
+        self._set_values(**kwargs)
+
+    def _set_values(self, **kwargs: Any) -> None:
+        """Set field values from environment, kwargs, or defaults."""
+        for info in self._field_info.values():
+            value = self._get_value(info, **kwargs)
+            object.__setattr__(self, info.name, value)
+
+    def _get_value(self, info: _FieldInfo, **kwargs: Any) -> Any:
+        """Get value for a field from env, kwargs, or default.
+
+        Priority:
+        1. Environment variable (alias first, then field name)
+        2. Passed kwargs
+        3. Default value
+        """
+        # Check environment by alias first, then by field name
+        env_value = None
+
+        if info.has_alias:
+            env_value = os.environ.get(info.alias.upper())
+
+        if env_value is None:
+            env_value = os.environ.get(info.name.upper())
+
+        if env_value is not None:
+            return self._convert_type(env_value, info.type, info.is_literal, info.literal_values)
+
+        # Check kwargs by alias first, then by field name
+        if info.has_alias and info.alias in kwargs:
+            kwarg_value = kwargs[info.alias]
+            return self._convert_type(str(kwarg_value), info.type, info.is_literal, info.literal_values)
+
+        if info.name in kwargs:
+            kwarg_value = kwargs[info.name]
+            return self._convert_type(str(kwarg_value), info.type, info.is_literal, info.literal_values)
+
+        return info.default
+
+    def _convert_type(self, value: str, target_type: type, is_literal: bool, literal_values: tuple) -> Any:
+        """Convert string value to target type."""
+
+        if is_literal:
+            return _str_to_literal(value, literal_values)
+
+        if target_type is str:
+            return value
+
+        if target_type is int:
+            return _str_to_int(value)
+
+        if target_type is float:
+            return _str_to_float(value)
+
+        if target_type is bool:
+            return _str_to_bool(value)
+
+        return value

mmar_envops-1.0.1/src/mmar_envops/config.py

@@ -0,0 +1,39 @@
+import os
+from typing import Literal
+
+from mmar_envops.aka_pydantic_settings import AkaBaseSettings, AkaField
+
+
+class ExecConfig(AkaBaseSettings):
+    debug: bool = AkaField(default=False, alias="d")
+    time: bool = AkaField(default=False, alias="t")
+    autoyes: bool = AkaField(default=False)
+    dry: bool = False
+    color: bool = True
+    ripgrep_max_columns: int = 500
+    prefer_env_keys: Literal["upper", "lower", "no"] = "no"
+
+    def fix_key_case(self, key: str):
+        pref = self.prefer_env_keys
+        match pref:
+            case "upper":
+                return key.upper()
+            case "lower":
+                return key.lower()
+            case _:
+                return key
+
+
+def is_debug():
+    env = os.environ
+    return (env.get("debug") or env.get("d")) in {"1", "true", "yes"} or False
+
+
+def is_force():
+    env = os.environ
+    return env.get("force") in {"1", "true", "yes"} or False
+
+
+def is_autoyes():
+    env = os.environ
+    return (env.get("autoyes")) in {"1", "true", "yes"} or False