better-python-doppler 0.1.0__py3-none-any.whl

better_python_doppler/__init__.py

@@ -0,0 +1,10 @@
+# src\better_python_doppler\__init__.py
+
+from better_python_doppler.doppler_sdk import Doppler
+from better_python_doppler.secret import Secrets
+
+
+__all__ = [
+    "Doppler",
+    "Secrets",
+]

better_python_doppler/apis/__init__.py

@@ -0,0 +1,11 @@
+from .environment_apis  import EnvironmentAPI
+from .config_apis       import ConfigAPI
+from .secret_apis       import SecretAPI
+from .project_apis      import ProjectAPI
+
+__all__ = [
+    "EnvironmentAPI", 
+    "ConfigAPI", 
+    "SecretAPI", 
+    "ProjectAPI"
+    ]

better_python_doppler/apis/config_apis.py

@@ -0,0 +1,51 @@
+# src\better_python_doppler\apis\config_apis.py
+
+import requests
+from requests import Response
+from urllib.parse import quote as url_encode
+
+class ConfigAPI:
+
+    @staticmethod
+    def list_configs(
+            auth: str, 
+            project_name: str, 
+            environment_slug: str = "Environment slug", 
+            page: int = 1, 
+            per_page: int = 20
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/configs"
+        params = {
+            "project":      project_name,
+            "environment":  url_encode(environment_slug),
+            "page":         page,
+            "per_page":     per_page
+            }
+
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+            }
+
+        return requests.get(base_url, params, headers=headers)
+
+    @staticmethod
+    def get_config(
+            auth: str, 
+            project_name: str, 
+            config_name: str
+        ) -> Response:
+        
+        base_url = "https://api.doppler.com/v3/configs/config"
+        params = {
+            "project": project_name,
+            "config":  config_name
+            }
+
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+            }
+
+        return requests.get(base_url, params, headers=headers)

better_python_doppler/apis/environment_apis.py

@@ -0,0 +1,44 @@
+# src\better_python_doppler\apis\environment_apis.py
+
+import requests
+from requests import Response
+
+class EnvironmentAPI:
+
+    @staticmethod
+    def list_environments(
+            auth: str, 
+            project_name: str
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/environments"
+        params = {
+            "project": project_name
+            }
+
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+            }
+
+        return requests.get(base_url, params, headers=headers)
+
+    @staticmethod
+    def get_environment(
+            auth: str, 
+            project_name: str, 
+            environment_name: str
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/environments/environment"
+        params = {
+            "project":      project_name,
+            "environment":  environment_name
+            }
+
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+            }
+
+        return requests.get(base_url, params, headers=headers)

better_python_doppler/apis/project_apis.py

@@ -0,0 +1,42 @@
+# src\better_python_doppler\apis\project_apis.py
+
+import requests
+from requests import Response
+
+class ProjectAPI:
+    
+    @staticmethod
+    def list_projects(
+            auth: str, 
+            page: int = 1, 
+            per_page: int = 20
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/projects"
+        params = {
+            "page":     page,
+            "per_page": per_page
+            }
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+            }
+
+        return requests.get(base_url, params, headers=headers)
+    @staticmethod
+    def get_project(
+            auth: str, 
+            project_name: str
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/projects/project"
+        params = {
+            "project": project_name
+            }
+
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+            }
+
+        return requests.get(base_url, params, headers=headers)

better_python_doppler/apis/secret_apis.py

@@ -0,0 +1,187 @@
+# src\better_python_doppler\apis\secret_apis.py
+
+import requests
+from requests import Response
+from typing import Literal
+
+class SecretAPI:
+
+    @staticmethod
+    def list_secrets(
+        auth: str,
+        project_name: str,
+        config_name: str,
+        include_dynamic_secrets: bool = True,
+        dynamic_secrets_ttl_sec: int = 1800,
+        secrets: list[str] | None = None,
+        include_managed_secrets: bool = True
+    ) -> Response:
+        base_url = "https://api.doppler.com/v3/configs/config/secrets"
+        params = {
+            "project":  project_name,
+            "config":   config_name,
+            "include_dynamic_secrets": str(include_dynamic_secrets).lower(),
+            "dynamic_secrets_ttl_sec": dynamic_secrets_ttl_sec,
+            "include_managed_secrets": str(include_managed_secrets).lower(),
+            }
+        
+        headers = {
+            "Accept":           "application/json",
+            "Authorization":    f"Bearer {auth}",
+            }
+        
+        if secrets:
+            params["secrets"] = ",".join(secrets)
+
+        return requests.get(base_url, params, headers=headers)
+
+    @staticmethod
+    def list_secret_names(
+            auth: str, 
+            project_name: str, 
+            config_name: str, 
+            include_dynamic_secrets: bool = False, 
+            include_managed_secrets: bool = True
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/configs/config/secrets/names"
+        params = {
+            "project":  project_name,
+            "config":   config_name,
+            "include_dynamic_secrets":  str(include_dynamic_secrets).lower(),
+            "include_managed_secrets":  str(include_managed_secrets).lower(),
+            }
+        
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+            }
+        
+        return requests.get(base_url, params, headers=headers)
+
+    @staticmethod
+    def get_secret(
+            auth: str, 
+            project_name: str, 
+            config_name: str,
+            secret_name: str 
+        ) -> Response:
+        base_url = "https://api.doppler.com/v3/configs/config/secret"
+        params = {
+            "project":  project_name,
+            "config":   config_name,
+            "name":     secret_name
+            }
+
+        headers = {
+            "accept":           "application/json",
+            "authorization":    f"Bearer {auth}"
+        }
+
+        return requests.get(base_url, params, headers=headers)
+
+    @staticmethod
+    def update_secrets(
+            auth: str, 
+            project_name: str, 
+            config_name: str, 
+            secrets: dict[str, str]
+        ) -> Response:
+        base_url = "https://api.doppler.com/v3/configs/config/secrets"
+
+        payload = {
+            "project":  project_name,
+            "config":   config_name,
+            "secrets":  secrets
+        }
+
+        headers = {
+            "accept":           "application/json",
+            "content-type":     "application/json",
+            "authorization":    f"Bearer {auth}"
+        }
+
+        return requests.post(base_url, headers=headers, json=payload)
+
+    @staticmethod
+    def download_secrets(
+            auth: str, 
+            project_name: str, 
+            config_name: str,
+            format: Literal["json", "dotnet-json", "env", "yaml" , "docker", "env-no-quotes"] = "json",
+            name_transformer: Literal["camel", "upper-camel", "lower-snake", "tf-var", "dotnet", "dotnet-env", "lower-kebab"] | None = None,
+            include_dynamic_secrets: bool = False,
+            dynamic_secrets_ttl_sec: int = 1800,
+            secrets: list[str] = []
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/configs/config/secrets/download"
+        params = {
+            "project":  project_name,
+            "config":   config_name,
+            "format":   format,
+            "include_dynamic_secrets" : str(include_dynamic_secrets).lower(),
+            "dynamic_secrets_ttl_sec" : str(dynamic_secrets_ttl_sec).lower(),
+        }
+
+        if name_transformer:
+            params["name_transformer"] = name_transformer
+        if secrets:
+            params["secrets"] = ",".join(secrets)
+
+        accept_header = "application/json"
+        if format not in ["json", "dotnet-json"]:
+            accept_header = "text/plain"
+
+        headers = {
+            "accept": accept_header,
+            "authorization": f"Bearer {auth}"
+        }
+
+        return requests.get(base_url, params, headers=headers)
+
+    @staticmethod
+    def delete_secret(
+            auth: str, 
+            project_name: str, 
+            config_name: str, 
+            secret_name: str
+        ) -> Response:
+        base_url = "https://api.doppler.com/v3/configs/config/secret"
+        params = {
+            "project":  project_name,
+            "config":   config_name,
+            "name":     secret_name
+        }
+
+        headers = {
+            "accept": "application/json",
+            "authorization": f"Bearer {auth}"
+        }
+
+        return requests.delete(base_url, params=params, headers=headers)
+
+    @staticmethod   
+    def update_note(
+            auth: str, 
+            project_name: str, 
+            secret_name: str,
+            note: str 
+        ) -> Response:
+
+        base_url = "https://api.doppler.com/v3/projects/project/note"
+        params = {
+            "project": project_name
+        }
+
+        payload = {
+            "secret": secret_name,
+            "note": note
+        }
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "authorization": f"Bearer {auth}"
+        }
+
+        return requests.post(base_url, params=params, headers=headers, json=payload)

better_python_doppler/doppler_sdk.py

@@ -0,0 +1,54 @@
+# src\better_python_doppler\doppler_sdk.py
+
+from better_python_doppler.secret import Secrets
+
+class Doppler:
+
+    def __init__(
+            self,
+            service_token: str | None = None,
+            *,
+            service_token_environ_name: str | None = None
+        ) -> None:
+
+        self._service_token = self._get_service_token(service_token, service_token_environ_name)
+        
+        self._secrets: Secrets | None = None 
+
+
+    def _get_service_token(
+            self, 
+            service_token: str | None = None,
+            service_token_environ_name: str | None = None
+        ) -> str:
+
+        if (service_token is None) == (service_token_environ_name is None):
+            raise ValueError("Either `service_token` OR `service_token_environ_name` must be provided upon init. NOT both or neither.") 
+        
+        if service_token is not None:
+            return service_token
+        else:
+            import os
+            from dotenv import load_dotenv
+            load_dotenv()
+
+            pulled_token = os.getenv(service_token_environ_name) # type: ignore
+
+            if pulled_token is None:
+                raise ValueError("Attempting to retrieve the environmental variable named `%s` returns `None`.", service_token_environ_name)    
+
+            return pulled_token
+        
+    @property
+    def service_token(self) -> str:
+        return self._service_token
+    
+    @property
+    def Secrets(self) -> Secrets:
+        if self._secrets is None:
+            self._secrets = Secrets(self._service_token)
+
+        return self._secrets
+    
+    
+    

better_python_doppler/models/DEPRECATED - config.py

@@ -0,0 +1,61 @@
+# src\better_python_doppler\models\config.py
+
+from datetime import datetime as DateTime
+
+from .project import ProjectModel
+from .environment import EnvironmentModel
+
+class ConfigModel:
+
+    def __init__(
+            self,
+            name: str | None = None,
+            project: ProjectModel = ProjectModel(),
+            environment: EnvironmentModel = EnvironmentModel(),
+            created_at: DateTime | None = None,
+            initial_fetch_at: DateTime | None = None,
+            last_fetch_at: DateTime | None = None,
+            root: bool | None = None,
+            locked: bool | None = None
+        ) -> None:
+        
+        self._name:             str | None      = name 
+        self._project:          ProjectModel         = project
+        self._environment:      EnvironmentModel     = environment
+        self._created_at:       DateTime | None = created_at
+        self._initial_fetch_at: DateTime | None = initial_fetch_at
+        self._last_fetch_at:    DateTime | None = last_fetch_at
+        self._root:             bool | None     = root
+        self._locked:           bool | None     = locked
+    
+    @property
+    def name(self) -> str | None:
+        return self._name
+    
+    @property
+    def project(self) -> ProjectModel:
+        return self._project
+    
+    @property
+    def environment(self) -> EnvironmentModel:
+        return self._environment
+    
+    @property
+    def created_at(self) -> DateTime | None:
+        return self._created_at
+    
+    @property
+    def initial_fetch_at(self) -> DateTime | None:
+        return self._initial_fetch_at
+    
+    @property
+    def last_fetch_at(self) -> DateTime | None:
+        return self._last_fetch_at
+    
+    @property
+    def root(self) -> bool | None:
+        return self._root
+    
+    @property
+    def locked(self) -> bool | None:
+        return self._locked

better_python_doppler/models/DEPRECATED - environment.py

@@ -0,0 +1,44 @@
+# src\better_python_doppler\models\environment.py
+
+from datetime import datetime as DateTime
+from typing import Any
+
+from .project import ProjectModel
+
+class EnvironmentModel:
+
+    def __init__(
+            self,
+            id: str | None = None,
+            name: str | None = None,
+            project: ProjectModel = ProjectModel(),
+            created_at: DateTime | None = None,
+            initial_fetch_at: DateTime | None = None,
+        ) -> None:
+        
+        self._id:               str | None      = id
+        self._name:             str | None      = name
+        self._project:          ProjectModel         = project
+        self._created_at:       DateTime | None = created_at
+        self._initial_fetch_at: DateTime | None = initial_fetch_at
+
+
+    @property
+    def id(self) -> str | None:
+        return self._id
+    
+    @property
+    def name(self) -> str | None:
+        return self._name
+    
+    @property
+    def project(self) -> ProjectModel:
+        return self._project
+    
+    @property
+    def created_at(self) -> DateTime | None:
+        return self._created_at
+    
+    @property
+    def initial_fetch_at(self) -> DateTime | None:
+        return self._initial_fetch_at

better_python_doppler/models/DEPRECATED - project.py

@@ -0,0 +1,34 @@
+# src\better_python_doppler\models\project.py
+
+from datetime import datetime as DateTime
+
+class ProjectModel:
+
+    def __init__(
+            self,
+            id: str | None = None,
+            name: str | None = None,
+            description: str | None = None,
+            created_at: DateTime | None = None,
+        ) -> None:
+        
+        self._id:           str | None         = id
+        self._name:         str | None         = name
+        self._description:  str | None         = description
+        self._created_at:   DateTime | None    = created_at
+
+    @property
+    def id(self) -> str | None:
+        return self._id
+    
+    @property
+    def name(self) -> str | None:
+        return self._name
+    
+    @property
+    def description(self) -> str | None:
+        return self._description
+    
+    @property
+    def created_at(self) -> DateTime | None:
+        return self._created_at

better_python_doppler/models/__init__.py

@@ -0,0 +1,12 @@
+# from .config import ConfigModel
+# from .environment import EnvironmentModel
+# from .project import ProjectModel
+from .secret import SecretModel, SecretValue
+
+__all__ = [
+    # "ConfigModel",
+    # "EnvironmentModel",
+    # "ProjectModel",
+    "SecretModel",
+    "SecretValue",
+]

better_python_doppler/models/secret.py

@@ -0,0 +1,70 @@
+# src\better_python_doppler\models\secret.py
+
+class SecretValue():
+
+    def __init__(
+            self,
+            raw: str | None = None,
+            computed: str | None = None,
+            note: str | None = None
+        ) -> None:
+
+        self._raw:      str | None = raw
+        self._computed: str | None = computed 
+        self._note:     str | None = note
+
+    @property
+    def raw(self) -> str | None:
+        return self._raw
+    
+    @property
+    def computed(self) -> str | None:
+        return self._computed
+    
+    @property
+    def note(self) -> str | None:
+        return self._note
+    
+    @raw.setter
+    def raw(self, raw: str) -> None:
+        self._raw = raw
+    
+    @note.setter
+    def note(self, note: str) -> None:
+        self._note = note
+
+    def __str__(self) -> str:
+        temp = {'raw': self._raw, 'computed': self._computed, 'note': self._note}
+        return str(temp)
+    
+    def dict(self)-> dict:
+        return {'raw': self._raw, 'computed': self._computed, 'note': self._note}
+    
+    
+
+
+class SecretModel():
+
+    def __init__(
+            self,
+            name: str | None = None,
+            value: SecretValue = SecretValue() 
+        ) -> None:
+        
+        self._name: str | None = name
+        self._value: SecretValue = value 
+
+    @property
+    def name(self) -> str | None:
+        return self._name
+    
+    @property
+    def value(self) -> SecretValue:
+        return self._value
+    
+    @name.setter
+    def name(self, name: str) -> None:
+        self._name = name
+
+    def key_value(self) -> str:
+        return f"'{self._name}': '{self._value.raw}'"

better_python_doppler/secret.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+from typing import Literal
+
+from requests import Response
+
+from better_python_doppler.models import SecretModel, SecretValue
+from better_python_doppler.apis import SecretAPI
+
+class Secrets:
+
+    def __init__(
+            self,
+            service_token: str
+        ) -> None:
+        
+        self._service_token = service_token
+    
+    def list(
+        self,
+        project_name: str,
+        config_name: str,
+        include_dynamic_secrets: bool = True,
+        dynamic_secrets_ttl_sec: int = 1800,
+        secrets: list[str] | None = None,
+        include_managed_secrets: bool = True,
+    ) -> list[SecretModel]:
+        response = SecretAPI.list_secrets(
+            auth=self._service_token,
+            project_name=project_name,
+            config_name=config_name,
+            include_dynamic_secrets=include_dynamic_secrets,
+            dynamic_secrets_ttl_sec=dynamic_secrets_ttl_sec,
+            secrets=secrets,
+            include_managed_secrets=include_managed_secrets,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        secrets_dict = data.get("secrets", {})
+        secret_models = []
+        for name, value_dict in secrets_dict.items():
+            secret_value = SecretValue(
+                raw=value_dict.get("raw"),
+                computed=value_dict.get("computed"),
+                note=value_dict.get("note"),
+            )
+            secret_model = SecretModel(name=name, value=secret_value)
+            secret_models.append(secret_model)
+        return secret_models
+
+    def list_names(
+        self,
+        project_name: str,
+        config_name: str,
+        include_dynamic_secrets: bool = False,
+        include_managed_secrets: bool = True,
+    ) -> list[str]:
+        response = SecretAPI.list_secret_names(
+            auth=self._service_token,
+            project_name=project_name,
+            config_name=config_name,
+            include_dynamic_secrets=include_dynamic_secrets,
+            include_managed_secrets=include_managed_secrets,
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data.get("names", [])
+
+    def get(self, project_name: str, config_name: str, secret_name: str) -> SecretModel:
+        response = SecretAPI.get_secret(
+            auth=self._service_token,
+            project_name=project_name,
+            config_name=config_name,
+            secret_name=secret_name,
+        )
+        return response_to_model(response)
+
+    def update(
+        self, project_name: str, config_name: str, secrets: dict[str, str]
+    ) -> list[SecretModel]:
+        response = SecretAPI.update_secrets(
+            auth=self._service_token,
+            project_name=project_name,
+            config_name=config_name,
+            secrets=secrets,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        secrets_dict = data.get("secrets", {})
+        secret_models = []
+        for name, value_dict in secrets_dict.items():
+            secret_value = SecretValue(
+                raw=value_dict.get("raw"),
+                computed=value_dict.get("computed"),
+                note=value_dict.get("note"),
+            )
+            secret_model = SecretModel(name=name, value=secret_value)
+            secret_models.append(secret_model)
+        return secret_models
+    
+    def download(
+        self,
+        project_name: str,
+        config_name: str,
+        format: Literal["json", "dotnet-json", "env", "yaml", "docker", "env-no-quotes"] = "json",
+        name_transformer: Literal["camel", "upper-camel", "lower-snake", "tf-var", "dotnet", "dotnet-env", "lower-kebab"] | None = None,
+        include_dynamic_secrets: bool = False,
+        dynamic_secrets_ttl_sec: int = 1800,
+        secrets: list[str] | None = None,
+    ) -> dict[str, str] | str:
+        response = SecretAPI.download_secrets(
+            auth=self._service_token,
+            project_name=project_name,
+            config_name=config_name,
+            format=format,
+            name_transformer=name_transformer,
+            include_dynamic_secrets=include_dynamic_secrets,
+            dynamic_secrets_ttl_sec=dynamic_secrets_ttl_sec,
+            secrets=secrets or [],
+        )
+        response.raise_for_status()
+        if format in ["json", "dotnet-json"]:
+            return response.json()
+        return response.text
+    
+    def delete(self, project_name: str, config_name: str, secret_name: str) -> None:
+        response = SecretAPI.delete_secret(
+            auth=self._service_token,
+            project_name=project_name,
+            config_name=config_name,
+            secret_name=secret_name,
+        )
+        response.raise_for_status()
+    
+    def update_note(self, project_name: str, secret_name: str, note: str) -> dict:
+        response = SecretAPI.update_note(
+            auth=self._service_token,
+            project_name=project_name,
+            secret_name=secret_name,
+            note=note,
+        )
+        response.raise_for_status()
+        return response.json()
+    
+def response_to_model(response: Response) -> SecretModel:
+    response.raise_for_status()
+    data = response.json()
+
+    value_dict = data.get("value", {})
+    secret_value = SecretValue(
+        raw=value_dict.get("raw"),
+        computed=value_dict.get("computed"),
+        note=value_dict.get("note"),
+    )
+
+    return SecretModel(name=data.get("name"), value=secret_value)

better_python_doppler/utilities/__init__.py

@@ -0,0 +1,5 @@
+from .utilities import list_to_comma_string
+
+__all__ = [
+           "list_to_comma_string"
+          ]

better_python_doppler/utilities/utilities.py

@@ -0,0 +1,3 @@
+def list_to_comma_string(input_list: list[str]) -> str:
+    """Joins a list of strings into a single comma-separated string."""
+    return ",".join(input_list)

better_python_doppler-0.1.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: better-python-doppler
+Version: 0.1.0
+Summary: A simplified and up to date Python SDK for Doppler. Because their current one has stale docs and doesn't provide much IDE support.
+Author-email: Derek Banker <dbb2002@gmail.com>
+License-Expression: Apache-2.0
+Keywords: Doppler,SKD
+Classifier: Programming Language :: Python
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Better Python Doppler
+
+Better Python Doppler is a lightweight SDK around the [Doppler API](https://docs.doppler.com/reference). It wraps common API endpoints in simple Python classes and includes typed models for working with secrets.
+
+## Installation
+
+This project currently requires Python 3.12 or newer. Once published to PyPI it can be installed with `pip`:
+
+```bash
+pip install better-python-doppler
+```
+
+For local development clone the repository and install the dependencies:
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+The example below mirrors `examples/example_secrets.py` and demonstrates basic usage of the SDK. It assumes the environment variables `SERVICE_TOKEN`, `PROJECT_NAME`, `CONFIG_NAME` and `SECRET_NAME` are available.
+
+```python
+from better_python_doppler import Doppler
+
+# Create the SDK instance
+sdk = Doppler(service_token=os.getenv("SERVICE_TOKEN"))
+
+# List secret names
+names = sdk.Secrets.list_names(
+    project_name=os.getenv("PROJECT_NAME"),
+    config_name=os.getenv("CONFIG_NAME")
+)
+
+# Fetch all secrets
+secrets = sdk.Secrets.list(
+    project_name=os.getenv("PROJECT_NAME"),
+    config_name=os.getenv("CONFIG_NAME")
+)
+
+# Retrieve a specific secret value
+secret_value = sdk.Secrets.get(
+    os.getenv("PROJECT_NAME"),
+    os.getenv("CONFIG_NAME"),
+    os.getenv("SECRET_NAME")
+)
+print(secret_value.value.raw)
+```
+
+## Functionality
+
+The SDK focuses on secrets management via the `Doppler.Secrets` interface defined in `secret.py`. Supported operations include:
+
+- `list` – return detailed information for all secrets in a config.
+- `list_names` – fetch only the secret names.
+- `get` – retrieve a single secret as a `SecretModel`.
+- `update` – update one or more secret values.
+- `download` – download secrets in various formats (json, env, yaml, etc.).
+- `delete` – delete a secret.
+- `update_note` – modify the note on an existing secret.
+
+Under the hood these call lightweight API wrappers located in `src/better_python_doppler/apis`. The project also exposes minimal data models in `src/better_python_doppler/models` such as `SecretModel` and `SecretValue` for convenient type checking.
+
+Authentication is performed with a Doppler service token. You can pass the token directly when creating `Doppler` or load it from an environment variable using the `service_token_environ_name` parameter.
+
+## License
+
+This project is licensed under the Apache 2.0 License. See the [LICENSE](LICENSE) file for details.

better_python_doppler-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+better_python_doppler/__init__.py,sha256=4lM6l9uwOkmsvPg6-_4L16JP-zRquxOZIWWkNlom2UM,189
+better_python_doppler/doppler_sdk.py,sha256=HAYcPd5rn50jWbyaEZ2oVPcKUAhocLNFHjskmjJvBdw,1586
+better_python_doppler/secret.py,sha256=7cKO2tICBsBfNFhXue6Szwu7Azx4R0-zbbJbP7QnYKE,5461
+better_python_doppler/apis/__init__.py,sha256=Pt0fc70zmLNdDoFpUm7I6JR36NO_1hgo0TJTKKTwy80,264
+better_python_doppler/apis/config_apis.py,sha256=HMVlbAyfDW9QEVz-ybHBAx8Bx8CLC4DycS3k6UfQDgQ,1378
+better_python_doppler/apis/environment_apis.py,sha256=U7KkYGBOr5JoEiykhcDstc_mAbOODZD8QoSz1PHn2U4,1127
+better_python_doppler/apis/project_apis.py,sha256=sIjCoIf4xemVScFN0Luhp_aJWaxqF3Q3z8JEvraTiWE,1070
+better_python_doppler/apis/secret_apis.py,sha256=IvMQx2g6QoAEEFqrAWTeWVoa2HeiCmfAQnL__V4MbE8,5808
+better_python_doppler/models/DEPRECATED - config.py,sha256=FZEdUOEREa3RE-pr1JajSejaJBa1_TB49FHQ4pVIXO0,1857
+better_python_doppler/models/DEPRECATED - environment.py,sha256=riENHklCpOFU-qMnSSAcKUiU1ppL7BkH-ls9mDdvOjg,1208
+better_python_doppler/models/DEPRECATED - project.py,sha256=mxDASyOr2G8nxhYFoVkc7oc1jGw_WupAj3dNXfT4tUk,904
+better_python_doppler/models/__init__.py,sha256=I8T7L-fQu3gKFcCtLWFGxhTUwgvpy_J1liehO3vwI80,280
+better_python_doppler/models/secret.py,sha256=mBbLgVYJoicWG9Toj6LE5psQnsCglgtCwemJI2NXdVU,1620
+better_python_doppler/utilities/__init__.py,sha256=HEzuOvkIGwZrRbzMAUjuFLblmjlRvJGGDh0J4tnJsKo,102
+better_python_doppler/utilities/utilities.py,sha256=yQ38tyBogLzHejd7ChM57m0qGGFN0SxAcTAvqWkSl40,160
+better_python_doppler-0.1.0.dist-info/licenses/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
+better_python_doppler-0.1.0.dist-info/METADATA,sha256=gFabCeTSTBwH646aN_EAOUS8uwXzlvghuUaJFCETXTc,2918
+better_python_doppler-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+better_python_doppler-0.1.0.dist-info/top_level.txt,sha256=CDeMMzbvM6DRK-cPrljVX0nbYYTVOCIb_pP62UIFFx8,22
+better_python_doppler-0.1.0.dist-info/RECORD,,

better_python_doppler-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

better_python_doppler-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

better_python_doppler-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+better_python_doppler