python-dotenvx 2.0.0__cp38-abi3-macosx_10_12_x86_64.whl

dotenvx/__init__.py

@@ -0,0 +1,3 @@
+from .main import dotenv_values, find_dotenv, load_dotenv, load_dotenvx
+
+__all__ = ["dotenv_values", "find_dotenv", "load_dotenv", "load_dotenvx"]

dotenvx/__version__.py

@@ -0,0 +1,9 @@
+from importlib.metadata import version
+
+__title__ = "python-dotenvx"
+__description__ = "a secure dotenv–from the creator of `dotenv`"
+__url__ = "https://github.com/dotenvx/python-dotenvx"
+__version__ = version("python-dotenvx")
+__author__ = "dotenv"
+__author_email__ = "mot@dotenvx.com"
+__license__ = "BSD-3-Clause"

dotenvx/main.py

@@ -0,0 +1,181 @@
+import os
+import re
+from pathlib import Path
+from typing import Dict, List, Optional, TextIO, Tuple, Union
+
+from ._native import parse_dotenv
+
+StrPath = Union[str, os.PathLike]
+Values = Dict[str, Optional[str]]
+
+
+def find_dotenv(
+        filename: str = ".env",
+        raise_error_if_not_found: bool = False,
+        usecwd: bool = False
+) -> str:
+    """Find ``filename`` by walking from the current directory toward root."""
+    del usecwd  # The package intentionally uses cwd for predictable discovery.
+    directory = Path.cwd()
+
+    for candidate_directory in (directory, *directory.parents):
+        candidate = candidate_directory / filename
+        if candidate.is_file():
+            return str(candidate)
+
+    if raise_error_if_not_found:
+        raise IOError("File not found")
+    return ""
+
+
+def _source(
+        dotenv_path: Optional[StrPath],
+        stream: Optional[TextIO],
+        encoding: Optional[str]
+) -> Tuple[str, Optional[Path]]:
+    if stream is not None:
+        return stream.read(), None
+
+    path = Path(dotenv_path) if dotenv_path is not None else Path(find_dotenv())
+    if not str(path) or not path.is_file():
+        return "", None
+    return path.read_text(encoding=encoding or "utf-8"), path
+
+
+def _key_files(path: Optional[Path]) -> List[str]:
+    if path is None:
+        return []
+
+    candidates = [path.with_name(f"{path.name}.keys")]
+    if path.name != ".env":
+        candidates.append(path.with_name(".env.keys"))
+    return [str(candidate) for candidate in candidates if candidate.is_file()]
+
+
+def _parse(
+        dotenv_path: Optional[StrPath] = None,
+        stream: Optional[TextIO] = None,
+        override: bool = False,
+        interpolate: bool = True,
+        encoding: Optional[str] = "utf-8"
+) -> Tuple[Values, Dict[str, str], bool]:
+    source, path = _source(dotenv_path, stream, encoding)
+    if path is None and not source:
+        return {}, {}, False
+
+    parsed, injected = parse_dotenv(
+        source,
+        dict(os.environ),
+        override,
+        _key_files(path),
+        interpolate,
+    )
+    has_values = bool(parsed)
+    for key in _bare_keys(source):
+        parsed.setdefault(key, None)
+    return parsed, injected, has_values
+
+
+def _bare_keys(source: str) -> List[str]:
+    pattern = re.compile(
+        r"^([A-Za-z_][A-Za-z0-9_.-]*)\s*(?:#.*)?$"
+    )
+    keys = []
+    multiline_quote = None
+
+    for raw_line in source.splitlines():
+        if multiline_quote is not None:
+            if _has_unescaped_quote(raw_line, multiline_quote):
+                multiline_quote = None
+            continue
+
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("export "):
+            line = line[7:].lstrip()
+
+        if "=" in line:
+            value = line.split("=", 1)[1].lstrip()
+            if value[:1] in {"'", '"', "`"}:
+                quote = value[0]
+                if not _has_unescaped_quote(value[1:], quote):
+                    multiline_quote = quote
+            continue
+
+        match = pattern.fullmatch(line)
+        if match:
+            keys.append(match.group(1))
+
+    return keys
+
+
+def _has_unescaped_quote(value: str, quote: str) -> bool:
+    escaped = False
+    for character in value:
+        if character == quote and not escaped:
+            return True
+        if character == "\\":
+            escaped = not escaped
+        else:
+            escaped = False
+    return False
+
+
+def dotenv_values(
+        dotenv_path: Optional[StrPath] = None,
+        stream: Optional[TextIO] = None,
+        verbose: bool = False,
+        interpolate: bool = True,
+        encoding: Optional[str] = "utf-8"
+) -> Values:
+    """Parse a dotenv source without changing ``os.environ``."""
+    del verbose
+    parsed, _, _ = _parse(
+        dotenv_path=dotenv_path,
+        stream=stream,
+        override=True,
+        interpolate=interpolate,
+        encoding=encoding,
+    )
+    return parsed
+
+
+def load_dotenv(
+        dotenv_path: Optional[StrPath] = None,
+        stream: Optional[TextIO] = None,
+        verbose: bool = False,
+        override: bool = False,
+        interpolate: bool = True,
+        encoding: Optional[str] = "utf-8"
+) -> bool:
+    """Load dotenv values into ``os.environ`` using native Rust primitives."""
+    del verbose
+
+    if os.environ.get("PYTHON_DOTENV_DISABLED", "").lower() in {
+        "1", "true", "t", "yes", "y"
+    }:
+        return False
+
+    _, injected, found = _parse(
+        dotenv_path=dotenv_path,
+        stream=stream,
+        override=override,
+        interpolate=interpolate,
+        encoding=encoding,
+    )
+    os.environ.update(injected)
+    return found
+
+
+def load_dotenvx(
+        dotenv_path: Optional[StrPath] = None,
+        override: bool = False
+) -> Values:
+    """Backward-compatible dotenvx loader returning the parsed mapping."""
+    parsed, injected, _ = _parse(
+        dotenv_path=dotenv_path,
+        override=override,
+    )
+    os.environ.update(injected)
+    return parsed

python_dotenvx-2.0.0.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: python-dotenvx
+Version: 2.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Rust
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+Summary: a secure dotenv–from the creator of `dotenv`
+Keywords: environment,environment variables,env,dotenv,python,dotenvx
+Author-email: dotenv <mot@dotenvx.com>
+License: BSD-3-Clause
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://dotenvx.com
+Project-URL: Repository, https://github.com/dotenvx/python-dotenvx
+
+[![dotenvx](https://dotenvx.com/better-banner.png)](https://dotenvx.com)
+
+*a better dotenv*–from the creator of [`dotenv`](https://github.com/motdotla/dotenv).
+
+* run anywhere (cross-platform)
+* multi-environment
+* encrypted envs
+
+&nbsp;
+
+
+### Quickstart [![PyPI version](https://badge.fury.io/py/python-dotenvx.svg)](http://badge.fury.io/py/python-dotenvx)
+
+Install and use it in code just like `python-dotenv`.
+
+```sh
+pip install python-dotenvx
+```
+
+The wheel includes native dotenvx Rust primitives. No dotenvx executable or
+post-install download is required.
+
+```python
+# main.py
+import os
+from dotenvx import load_dotenv
+
+load_dotenv()  # take environment variables from .env
+
+print(os.getenv("S3_BUCKET"))
+```
+
+You can also parse values without changing the environment:
+
+```python
+from dotenvx import dotenv_values
+
+values = dotenv_values(".env")
+```
+
+Encrypted values are decrypted using `DOTENV_PRIVATE_KEY` from the environment
+or a neighboring `.env.keys` file.
+
+&nbsp;
+

python_dotenvx-2.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dotenvx/__init__.py,sha256=yjjqD_ZhBJhcz1UG0_ATJ-33XhgxPv5eAEjWLSLLt0w,147
+dotenvx/__version__.py,sha256=RP_uGDG00O0aVt1QxPoR1krfYkPHeZjbP5zbJDdV--c,318
+dotenvx/_native.abi3.so,sha256=8YlHGfCXr1IWrt3kE5Qg-vFAj3cCg5YER5yb8vZ2ImE,2681472
+dotenvx/main.py,sha256=_eiB_SP4wDmKoNMTYu4QtDuvql5Fq1bdDdaksvIAidU,5011
+python_dotenvx-2.0.0.dist-info/METADATA,sha256=HJF7hSz2yCThuJymnRIJ89FcTv1k-u4vP7lNNJ2tNGY,1696
+python_dotenvx-2.0.0.dist-info/WHEEL,sha256=VyMvuaqQgQmqWzNqy4G89nzRACgEEQLHjJrW08Pp8ys,105
+python_dotenvx-2.0.0.dist-info/licenses/LICENSE,sha256=Lt6wCRSMNsJJcSVkhx2Cl9kglLiOQXIo5PPOfbWe6e0,1498
+python_dotenvx-2.0.0.dist-info/sboms/python-dotenvx-native.cyclonedx.json,sha256=wgtxlzqZPt0XH3RnUWU8OeIKI3880Ca3HoOv8LjF0Qw,81330
+python_dotenvx-2.0.0.dist-info/RECORD,,

python_dotenvx-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.14.1)
+Root-Is-Purelib: false
+Tag: cp38-abi3-macosx_10_12_x86_64

python_dotenvx-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Scott Motte
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.