donazopy 1.0.10__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
donazopy/__init__.py ADDED
@@ -0,0 +1,11 @@
1
+ # this_file: src/donazopy/__init__.py
2
+ """DNS and domain-provider management CLI package."""
3
+
4
+ from importlib.metadata import PackageNotFoundError, version
5
+
6
+ try:
7
+ __version__ = version("donazopy")
8
+ except PackageNotFoundError:
9
+ __version__ = "0.0.0"
10
+
11
+ __all__ = ["__version__"]
donazopy/__main__.py ADDED
@@ -0,0 +1,15 @@
1
+ # this_file: src/donazopy/__main__.py
2
+ """Command-line entry point for donazopy."""
3
+
4
+ import fire
5
+
6
+ from donazopy.cli import Donazopy
7
+
8
+
9
+ def main() -> None:
10
+ """Run the Fire-powered donazopy CLI."""
11
+ fire.Fire(Donazopy)
12
+
13
+
14
+ if __name__ == "__main__":
15
+ main()
donazopy/_version.py ADDED
@@ -0,0 +1,24 @@
1
+ # file generated by vcs-versioning
2
+ # don't change, don't track in version control
3
+ from __future__ import annotations
4
+
5
+ __all__ = [
6
+ "__version__",
7
+ "__version_tuple__",
8
+ "version",
9
+ "version_tuple",
10
+ "__commit_id__",
11
+ "commit_id",
12
+ ]
13
+
14
+ version: str
15
+ __version__: str
16
+ __version_tuple__: tuple[int | str, ...]
17
+ version_tuple: tuple[int | str, ...]
18
+ commit_id: str | None
19
+ __commit_id__: str | None
20
+
21
+ __version__ = version = '1.0.10'
22
+ __version_tuple__ = version_tuple = (1, 0, 10)
23
+
24
+ __commit_id__ = commit_id = None
donazopy/cli.py ADDED
@@ -0,0 +1,305 @@
1
+ # this_file: src/donazopy/cli.py
2
+ """Fire-powered donazopy CLI built around the unified target notation."""
3
+
4
+ from __future__ import annotations
5
+
6
+ from collections.abc import Callable, Mapping
7
+ from pathlib import Path
8
+
9
+ from donazopy import __version__
10
+ from donazopy.providers.base import (
11
+ DNSHostingProvider,
12
+ ProviderAPIError,
13
+ RegistrarProvider,
14
+ credential_status,
15
+ require_provider_credentials,
16
+ )
17
+ from donazopy.providers.registry import (
18
+ create_dns_provider,
19
+ create_registrar_provider,
20
+ get_provider,
21
+ list_providers,
22
+ )
23
+ from donazopy.target import Target, TargetError, looks_like_path, parse_target, resolve_provider_key
24
+ from donazopy.zonefile import (
25
+ diff_zone_records,
26
+ filter_zone_text,
27
+ normalize_zone_file,
28
+ records_from_zone_file,
29
+ records_from_zone_text,
30
+ validate_zone_file,
31
+ write_text_safely,
32
+ )
33
+
34
+ DnsFactory = Callable[..., DNSHostingProvider]
35
+ RegistrarFactory = Callable[..., RegistrarProvider]
36
+
37
+
38
+ def _operational_keys() -> tuple[str, ...]:
39
+ return tuple(provider.key for provider in list_providers())
40
+
41
+
42
+ def _split_types(skip_types: str | None) -> tuple[str, ...]:
43
+ if not skip_types:
44
+ return ()
45
+ return tuple(part.strip() for part in skip_types.split(",") if part.strip())
46
+
47
+
48
+ def _dotenv(dotenv_path: str | None) -> Path | None:
49
+ return None if dotenv_path is None else Path(dotenv_path)
50
+
51
+
52
+ class Donazopy:
53
+ """donazopy CLI: DNS and domain-provider management."""
54
+
55
+ def __init__(
56
+ self,
57
+ *,
58
+ dns_factory: DnsFactory = create_dns_provider,
59
+ registrar_factory: RegistrarFactory = create_registrar_provider,
60
+ ) -> None:
61
+ self._dns_factory = dns_factory
62
+ self._registrar_factory = registrar_factory
63
+
64
+ # -- internal helpers -------------------------------------------------
65
+
66
+ def _resolve_target(self, text: str) -> tuple[str, Target]:
67
+ target = parse_target(text)
68
+ key = resolve_provider_key(target, _operational_keys())
69
+ return key, target
70
+
71
+ def _dns_provider(self, key: str, dotenv_path: str | None) -> DNSHostingProvider:
72
+ spec = get_provider(key)
73
+ credentials = require_provider_credentials(spec, dotenv_path=_dotenv(dotenv_path))
74
+ return self._dns_factory(key, credentials)
75
+
76
+ def _registrar_provider(self, key: str, dotenv_path: str | None) -> RegistrarProvider:
77
+ spec = get_provider(key)
78
+ credentials = require_provider_credentials(spec, dotenv_path=_dotenv(dotenv_path))
79
+ return self._registrar_factory(key, credentials)
80
+
81
+ @staticmethod
82
+ def _require_domain(target: Target) -> str:
83
+ if target.domain is None or target.domain == "*":
84
+ msg = (
85
+ f"target {target.raw!r} must name a single domain for this operation; "
86
+ "use 'donazopy domains <provider>' to list a provider's domains"
87
+ )
88
+ raise TargetError(msg)
89
+ return target.domain
90
+
91
+ def _provider_key(self, provider: str) -> str:
92
+ """Resolve a provider key from a bare key (``ionos``) or a target (``ionos/*``)."""
93
+ if provider in _operational_keys():
94
+ return provider
95
+ key, _ = self._resolve_target(provider)
96
+ return key
97
+
98
+ def _provider_info(self, key: str, dotenv_path: str | None) -> dict[str, object]:
99
+ spec = get_provider(key)
100
+ metadata = {
101
+ "key": spec.key,
102
+ "display_name": spec.display_name,
103
+ "category": spec.category,
104
+ "docs_url": spec.docs_url,
105
+ "credentials": list(spec.credentials),
106
+ "capabilities": [capability.name for capability in spec.capabilities],
107
+ "notes": spec.notes,
108
+ }
109
+ status = credential_status(spec, dotenv_path=_dotenv(dotenv_path))
110
+ return {"metadata": metadata, "credential_status": status.to_dict()}
111
+
112
+ def _records_from_side(self, text: str, origin: str | None, dotenv_path: str | None) -> tuple:
113
+ if looks_like_path(text):
114
+ return records_from_zone_file(Path(text), origin)
115
+ key, target = self._resolve_target(text)
116
+ domain = self._require_domain(target)
117
+ zone_text = self._dns_provider(key, dotenv_path).export_zone(domain)
118
+ return records_from_zone_text(zone_text, origin or domain.rstrip(".") + ".")
119
+
120
+ # -- commands ---------------------------------------------------------
121
+
122
+ def version(self) -> str:
123
+ """Return the installed donazopy version."""
124
+ return __version__
125
+
126
+ def providers(self) -> list[str]:
127
+ """List the operational provider keys."""
128
+ return list(_operational_keys())
129
+
130
+ def domains(self, provider: str, dotenv_path: str | None = None) -> list[str]:
131
+ """List the domains/zones managed by a provider.
132
+
133
+ ``provider`` is a provider key (e.g. ``ionos``) or a target like ``ionos/*``.
134
+ """
135
+ key = self._provider_key(provider)
136
+ return self._dns_provider(key, dotenv_path).list_zones()
137
+
138
+ def status(self, target: str | None = None, dotenv_path: str | None = None) -> dict[str, object]:
139
+ """Show provider metadata and credential status.
140
+
141
+ With no argument, returns one entry per operational provider. With a provider
142
+ key or full target string, returns just that provider's entry.
143
+ """
144
+ if target is None:
145
+ return {key: self._provider_info(key, dotenv_path) for key in _operational_keys()}
146
+ operational = _operational_keys()
147
+ if target in operational:
148
+ return self._provider_info(target, dotenv_path)
149
+ key, _ = self._resolve_target(target)
150
+ return self._provider_info(key, dotenv_path)
151
+
152
+ def records(self, target: str, dotenv_path: str | None = None) -> list[Mapping[str, object]]:
153
+ """List DNS records for the domain in ``target``, applying record-level filters."""
154
+ key, parsed = self._resolve_target(target)
155
+ domain = self._require_domain(parsed)
156
+ records = self._dns_provider(key, dotenv_path).list_records(domain)
157
+ return [record for record in records if parsed.matches_record(record)]
158
+
159
+ def export(
160
+ self,
161
+ target: str,
162
+ dotenv_path: str | None = None,
163
+ output: str | None = None,
164
+ overwrite: bool = False,
165
+ skip_ns: bool = False,
166
+ skip_types: str | None = None,
167
+ ) -> str:
168
+ """Export a zone as BIND text, optionally dropping NS records or given types."""
169
+ key, parsed = self._resolve_target(target)
170
+ domain = self._require_domain(parsed)
171
+ zone_text = self._dns_provider(key, dotenv_path).export_zone(domain)
172
+ origin = domain.rstrip(".") + "."
173
+ filtered = filter_zone_text(zone_text, origin, skip_ns=skip_ns, skip_types=_split_types(skip_types))
174
+ if output is not None:
175
+ write_text_safely(Path(output), filtered, overwrite=overwrite)
176
+ return filtered
177
+
178
+ def import_zone(
179
+ self,
180
+ target: str,
181
+ path: str,
182
+ dotenv_path: str | None = None,
183
+ proxied: bool | None = None,
184
+ ) -> Mapping[str, object]:
185
+ """Import BIND zone text from ``path`` into the domain in ``target``."""
186
+ key, parsed = self._resolve_target(target)
187
+ domain = self._require_domain(parsed)
188
+ zone_text = Path(path).read_text(encoding="utf-8")
189
+ return self._dns_provider(key, dotenv_path).import_zone(domain, zone_text, proxied=proxied)
190
+
191
+ def create_zone(self, target: str, dotenv_path: str | None = None) -> Mapping[str, object]:
192
+ """Create a hosted zone for the domain in ``target`` on its provider.
193
+
194
+ Idempotent where the provider supports it (returns the existing zone). Providers
195
+ that cannot create zones (the zone exists with the domain registration) raise a
196
+ clear "not supported" error.
197
+ """
198
+ key, parsed = self._resolve_target(target)
199
+ domain = self._require_domain(parsed)
200
+ return self._dns_provider(key, dotenv_path).create_zone(domain)
201
+
202
+ def copy(
203
+ self,
204
+ source: str,
205
+ dest: str,
206
+ dotenv_path: str | None = None,
207
+ skip_ns: bool = False,
208
+ skip_types: str | None = None,
209
+ replace: bool = False,
210
+ create: bool = True,
211
+ ) -> Mapping[str, object]:
212
+ """Copy a zone from ``source`` to ``dest``, optionally replacing existing records.
213
+
214
+ ``source`` and ``dest`` are full targets. If the destination domain is ``*`` or
215
+ omitted, it defaults to the source domain. By default the destination zone is
216
+ created first if it does not exist and the provider supports it (useful when
217
+ migrating a domain to a new DNS host); pass ``--create=False`` to skip that. The
218
+ result's ``created`` entry is the created/existing zone object, or ``None`` when
219
+ the destination provider does not support zone creation.
220
+ """
221
+ source_key, source_target = self._resolve_target(source)
222
+ source_domain = self._require_domain(source_target)
223
+ dest_key, dest_target = self._resolve_target(dest)
224
+ dest_domain = source_domain if dest_target.domain in (None, "*") else dest_target.domain
225
+
226
+ source_zone_text = self._dns_provider(source_key, dotenv_path).export_zone(source_domain)
227
+ origin = source_domain.rstrip(".") + "."
228
+ filtered = filter_zone_text(source_zone_text, origin, skip_ns=skip_ns, skip_types=_split_types(skip_types))
229
+ exported_records = len([line for line in filtered.splitlines() if line.strip()])
230
+
231
+ dest_provider = self._dns_provider(dest_key, dotenv_path)
232
+ created: Mapping[str, object] | None = None
233
+ if create:
234
+ try:
235
+ created = dest_provider.create_zone(dest_domain)
236
+ except ProviderAPIError as error:
237
+ # Some providers create the DNS zone with the domain registration; tolerate that.
238
+ if "not supported" not in str(error).lower():
239
+ raise
240
+ replaced: Mapping[str, object] | None = None
241
+ if replace:
242
+ replaced = dest_provider.delete_all_records(dest_domain)
243
+ import_result = dest_provider.import_zone(dest_domain, filtered)
244
+ return {
245
+ "source": source_target.to_dict(),
246
+ "dest": {**dest_target.to_dict(), "domain": dest_domain},
247
+ "exported_records": exported_records,
248
+ "created": created,
249
+ "replaced": replaced,
250
+ "import_result": import_result,
251
+ }
252
+
253
+ def nameservers(
254
+ self,
255
+ target: str,
256
+ *new_nameservers: str,
257
+ dotenv_path: str | None = None,
258
+ ) -> object:
259
+ """Read nameservers for a domain, or assign them when values are given.
260
+
261
+ ``target`` with a wildcard domain (``provider/*``) reads nameservers for every
262
+ domain the provider manages and returns a ``{domain: [nameserver, ...]}`` map.
263
+ Assigning nameservers always requires a single concrete domain.
264
+ """
265
+ key, parsed = self._resolve_target(target)
266
+ provider = self._registrar_provider(key, dotenv_path)
267
+ if parsed.domain in (None, "*"):
268
+ if new_nameservers:
269
+ self._require_domain(parsed) # raise the standard "single domain" error
270
+ dns_provider = self._dns_provider(key, dotenv_path)
271
+ return {domain: list(provider.read_nameservers(domain)) for domain in dns_provider.list_zones()}
272
+ domain = self._require_domain(parsed)
273
+ if not new_nameservers:
274
+ return list(provider.read_nameservers(domain))
275
+ return provider.assign_nameservers(domain, list(new_nameservers))
276
+
277
+ def diff(
278
+ self,
279
+ a: str,
280
+ b: str,
281
+ origin: str | None = None,
282
+ dotenv_path: str | None = None,
283
+ ) -> dict[str, object]:
284
+ """Diff two zones; each side is a local zone file path or a provider target."""
285
+ before = self._records_from_side(a, origin, dotenv_path)
286
+ after = self._records_from_side(b, origin, dotenv_path)
287
+ zone_diff = diff_zone_records(before, after)
288
+ return {"summary": zone_diff.summary(), "changes": zone_diff.to_dict()}
289
+
290
+ def validate(self, path: str, origin: str | None = None) -> str:
291
+ """Validate a local BIND zone file."""
292
+ return validate_zone_file(Path(path), origin)
293
+
294
+ def normalize(
295
+ self,
296
+ path: str,
297
+ origin: str | None = None,
298
+ output: str | None = None,
299
+ overwrite: bool = False,
300
+ ) -> str:
301
+ """Return (and optionally write) a canonical normalized dump of a zone file."""
302
+ normalized = normalize_zone_file(Path(path), origin)
303
+ if output is not None:
304
+ write_text_safely(Path(output), normalized, overwrite=overwrite)
305
+ return normalized
donazopy/models.py ADDED
@@ -0,0 +1,29 @@
1
+ # this_file: src/donazopy/models.py
2
+ """Shared data models for provider metadata and DNS operation boundaries."""
3
+
4
+ from dataclasses import dataclass
5
+
6
+
7
+ @dataclass(frozen=True, slots=True)
8
+ class ProviderCapability:
9
+ """A named provider capability exposed by a DNS or registrar integration."""
10
+
11
+ name: str
12
+ description: str
13
+
14
+
15
+ @dataclass(frozen=True, slots=True)
16
+ class ProviderSpec:
17
+ """Static metadata describing a provider integration module."""
18
+
19
+ key: str
20
+ display_name: str
21
+ category: str
22
+ docs_url: str
23
+ credentials: tuple[str, ...]
24
+ capabilities: tuple[ProviderCapability, ...]
25
+ notes: str
26
+
27
+ def supports(self, capability_name: str) -> bool:
28
+ """Return whether this provider advertises a capability by name."""
29
+ return any(capability.name == capability_name for capability in self.capabilities)
@@ -0,0 +1,6 @@
1
+ # this_file: src/donazopy/providers/__init__.py
2
+ """Provider integration modules for DNS hosts and domain registrars."""
3
+
4
+ from donazopy.providers.registry import get_provider, list_providers
5
+
6
+ __all__ = ["get_provider", "list_providers"]
@@ -0,0 +1,12 @@
1
+ # this_file: src/donazopy/providers/aws.py
2
+ from donazopy.providers.base import DNS_AND_REGISTRAR, ProviderSpec
3
+
4
+ PROVIDER = ProviderSpec(
5
+ key="aws",
6
+ display_name="AWS Route 53",
7
+ category="dns_and_registrar",
8
+ docs_url="https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/route53.html",
9
+ credentials=("AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"),
10
+ capabilities=DNS_AND_REGISTRAR,
11
+ notes="Route 53 separates hosted-zone record changes from domain registration and nameserver operations.",
12
+ )
@@ -0,0 +1,12 @@
1
+ # this_file: src/donazopy/providers/azure.py
2
+ from donazopy.providers.base import DNS_ONLY, ProviderSpec
3
+
4
+ PROVIDER = ProviderSpec(
5
+ key="azure",
6
+ display_name="Azure DNS",
7
+ category="dns_host",
8
+ docs_url="https://learn.microsoft.com/en-us/rest/api/dns/",
9
+ credentials=("AZURE_TENANT_ID", "AZURE_CLIENT_ID", "AZURE_CLIENT_SECRET", "AZURE_SUBSCRIPTION_ID"),
10
+ capabilities=DNS_ONLY,
11
+ notes="Azure DNS manages hosted zones and record sets; registrar delegation is handled elsewhere.",
12
+ )
@@ -0,0 +1,211 @@
1
+ # this_file: src/donazopy/providers/base.py
2
+
3
+ from __future__ import annotations
4
+
5
+ import os
6
+ from collections.abc import Mapping, Sequence
7
+ from dataclasses import dataclass
8
+ from pathlib import Path
9
+ from typing import Protocol, runtime_checkable
10
+
11
+ from dotenv import dotenv_values, find_dotenv
12
+
13
+ from donazopy.models import ProviderCapability, ProviderSpec
14
+
15
+ ZONE_READ = ProviderCapability("zone_read", "Read hosted DNS zones and records.")
16
+ ZONE_WRITE = ProviderCapability("zone_write", "Create, update, delete, or import hosted DNS records.")
17
+ ZONE_EXPORT = ProviderCapability("zone_export", "Export DNS configuration to BIND-compatible zone text.")
18
+ ZONE_IMPORT = ProviderCapability("zone_import", "Import or synchronize DNS configuration from zone text.")
19
+ DELEGATION_READ = ProviderCapability("delegation_read", "Read registrar-level nameserver delegation.")
20
+ DOMAIN_READ = ProviderCapability("domain_read", "List or inspect registered domains.")
21
+
22
+ DNS_ONLY = (ZONE_READ, ZONE_WRITE, ZONE_EXPORT, ZONE_IMPORT)
23
+ DNS_AND_REGISTRAR_READ = DNS_ONLY + (DOMAIN_READ, DELEGATION_READ)
24
+ DNS_AND_REGISTRAR = DNS_AND_REGISTRAR_READ
25
+
26
+
27
+ class ProviderError(RuntimeError):
28
+ pass
29
+
30
+
31
+ class ProviderCredentialError(ProviderError):
32
+ pass
33
+
34
+
35
+ class ProviderAPIError(ProviderError):
36
+ pass
37
+
38
+
39
+ @dataclass(frozen=True, slots=True)
40
+ class CredentialStatus:
41
+ provider_key: str
42
+ required: tuple[str, ...]
43
+ present: tuple[str, ...]
44
+ missing: tuple[str, ...]
45
+ sources: Mapping[str, str]
46
+
47
+ @property
48
+ def is_complete(self) -> bool:
49
+ return not self.missing
50
+
51
+ def to_dict(self) -> dict[str, object]:
52
+ return {
53
+ "provider_key": self.provider_key,
54
+ "required": list(self.required),
55
+ "present": list(self.present),
56
+ "missing": list(self.missing),
57
+ "complete": self.is_complete,
58
+ "sources": dict(self.sources),
59
+ "redacted": dict.fromkeys(self.present, "***"),
60
+ }
61
+
62
+
63
+ @dataclass(frozen=True, slots=True)
64
+ class LoadedCredentials:
65
+ values: Mapping[str, str]
66
+ sources: Mapping[str, str]
67
+
68
+
69
+ @runtime_checkable
70
+ class DNSHostingProvider(Protocol):
71
+ spec: ProviderSpec
72
+
73
+ def export_zone(self, domain: str) -> str: ...
74
+
75
+ def import_zone(self, domain: str, zone_text: str, *, proxied: bool | None = None) -> Mapping[str, object]: ...
76
+
77
+ def list_records(self, domain: str) -> list[Mapping[str, object]]: ...
78
+
79
+ def delete_all_records(self, domain: str) -> Mapping[str, object]:
80
+ """Delete every deletable record in a zone.
81
+
82
+ Implementations that cannot do this should raise :class:`ProviderAPIError`.
83
+ """
84
+ ...
85
+
86
+ def list_zones(self) -> list[str]:
87
+ """Return all zone names hosted by the provider.
88
+
89
+ Implementations that cannot enumerate zones should raise :class:`ProviderAPIError`.
90
+ """
91
+ ...
92
+
93
+ def create_zone(self, domain: str) -> Mapping[str, object]:
94
+ """Create a hosted zone for ``domain`` and return the provider's zone object.
95
+
96
+ Implementations should be idempotent (returning the existing zone if it already
97
+ exists) and should raise :class:`ProviderAPIError` if they cannot create zones.
98
+ """
99
+ ...
100
+
101
+
102
+ @runtime_checkable
103
+ class RegistrarProvider(Protocol):
104
+ spec: ProviderSpec
105
+
106
+ def read_nameservers(self, domain: str) -> tuple[str, ...]: ...
107
+
108
+ def assign_nameservers(self, domain: str, nameservers: Sequence[str]) -> Mapping[str, object]:
109
+ """Set registrar nameserver delegation for a domain.
110
+
111
+ Implementations that cannot do this should raise :class:`ProviderAPIError`.
112
+ """
113
+ ...
114
+
115
+
116
+ def dotenv_environment(
117
+ *,
118
+ dotenv_path: Path | None = None,
119
+ env: Mapping[str, str] | None = None,
120
+ discover: bool = True,
121
+ ) -> LoadedCredentials:
122
+ merged: dict[str, str] = {}
123
+ sources: dict[str, str] = {}
124
+
125
+ discovered = find_dotenv(usecwd=True) if discover else ""
126
+ dotenv_files = [Path(discovered)] if discovered else []
127
+ if dotenv_path is not None:
128
+ dotenv_files.append(dotenv_path)
129
+
130
+ for path in dotenv_files:
131
+ if path.exists():
132
+ for key, value in dotenv_values(path).items():
133
+ if value:
134
+ merged[key] = value
135
+ sources[key] = str(path)
136
+
137
+ environment = os.environ if env is None else env
138
+ for key, value in environment.items():
139
+ if value:
140
+ merged[key] = value
141
+ sources[key] = "environment"
142
+
143
+ return LoadedCredentials(values=merged, sources=sources)
144
+
145
+
146
+ def load_provider_credentials(
147
+ spec: ProviderSpec,
148
+ *,
149
+ dotenv_path: Path | None = None,
150
+ env: Mapping[str, str] | None = None,
151
+ discover: bool = True,
152
+ ) -> dict[str, str]:
153
+ loaded = dotenv_environment(dotenv_path=dotenv_path, env=env, discover=discover)
154
+ return {name: loaded.values[name] for name in spec.credentials if loaded.values.get(name)}
155
+
156
+
157
+ def credential_status(
158
+ spec: ProviderSpec,
159
+ *,
160
+ dotenv_path: Path | None = None,
161
+ env: Mapping[str, str] | None = None,
162
+ discover: bool = True,
163
+ ) -> CredentialStatus:
164
+ loaded = dotenv_environment(dotenv_path=dotenv_path, env=env, discover=discover)
165
+ credentials = {name: loaded.values[name] for name in spec.credentials if loaded.values.get(name)}
166
+ present = tuple(name for name in spec.credentials if name in credentials)
167
+ missing = tuple(name for name in spec.credentials if name not in credentials)
168
+ sources = {name: loaded.sources[name] for name in present if name in loaded.sources}
169
+ return CredentialStatus(
170
+ provider_key=spec.key, required=spec.credentials, present=present, missing=missing, sources=sources
171
+ )
172
+
173
+
174
+ def require_provider_credentials(
175
+ spec: ProviderSpec,
176
+ *,
177
+ dotenv_path: Path | None = None,
178
+ env: Mapping[str, str] | None = None,
179
+ discover: bool = True,
180
+ ) -> dict[str, str]:
181
+ status = credential_status(spec, dotenv_path=dotenv_path, env=env, discover=discover)
182
+ if not status.is_complete:
183
+ missing = ", ".join(status.missing)
184
+ raise ProviderCredentialError(f"missing required credentials for {spec.key}: {missing}")
185
+ return load_provider_credentials(spec, dotenv_path=dotenv_path, env=env, discover=discover)
186
+
187
+
188
+ __all__ = [
189
+ "CredentialStatus",
190
+ "DELEGATION_READ",
191
+ "DNSHostingProvider",
192
+ "DNS_AND_REGISTRAR",
193
+ "DNS_AND_REGISTRAR_READ",
194
+ "DNS_ONLY",
195
+ "DOMAIN_READ",
196
+ "LoadedCredentials",
197
+ "ProviderAPIError",
198
+ "ProviderCapability",
199
+ "ProviderCredentialError",
200
+ "ProviderError",
201
+ "ProviderSpec",
202
+ "RegistrarProvider",
203
+ "ZONE_EXPORT",
204
+ "ZONE_IMPORT",
205
+ "ZONE_READ",
206
+ "ZONE_WRITE",
207
+ "credential_status",
208
+ "dotenv_environment",
209
+ "load_provider_credentials",
210
+ "require_provider_credentials",
211
+ ]
@@ -0,0 +1,12 @@
1
+ # this_file: src/donazopy/providers/bluehost.py
2
+ from donazopy.providers.base import DNS_AND_REGISTRAR, ProviderSpec
3
+
4
+ PROVIDER = ProviderSpec(
5
+ key="bluehost",
6
+ display_name="Bluehost",
7
+ category="dns_and_registrar",
8
+ docs_url="https://www.bluehost.com/",
9
+ credentials=("BLUEHOST_API_TOKEN",),
10
+ capabilities=DNS_AND_REGISTRAR,
11
+ notes="Bluehost automation may require account-specific APIs or registrar workflows; verify before enabling writes.",
12
+ )