granny-devops 0.14.0__tar.gz → 0.15.0__tar.gz

{granny_devops-0.14.0 → granny_devops-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: granny-devops
-Version: 0.14.0
+Version: 0.15.0
 Summary: Cloud tools collection -- AWS infrastructure, CDN, and DevOps automation
 Author-email: Martin Wieser <martin.wieser@pseekoo.com>
 License: MIT License

{granny_devops-0.14.0 → granny_devops-0.15.0}/granny/__init__.py

@@ -1,6 +1,6 @@
 """Granny -- Cloud tools collection for AWS infrastructure and DevOps automation."""
 
-__version__ = "0.14.0"
+__version__ = "0.15.0"
 __all__ = [
     "get_secret",
     "load_secrets_into_env",

granny_devops-0.15.0/granny/aws/bedrock.py

@@ -0,0 +1,90 @@
+"""Amazon Bedrock foundation-model inspection helpers.
+
+Thin boto3 wrapper around the Bedrock control-plane (``bedrock``) client.
+``list-models`` / ``check-access`` need ``bedrock:ListFoundationModels`` /
+``bedrock:GetFoundationModel``.
+
+Bedrock has no per-model "deployment" object and **no public API to grant
+on-demand foundation-model access** — that is done once in the console (Model
+access). Once granted, callers invoke a model directly by id
+(e.g. ``anthropic.claude-sonnet-4-20250514-v1:0``); the gateway routes it as
+``bedrock/<model-id>``. These helpers therefore discover model ids and report a
+model's availability/lifecycle so a caller can build a route; they do not (and
+cannot) enable access. The only API-driven "deployment" is Provisioned
+Throughput (``create_provisioned_model_throughput``), which is a paid,
+committed capacity resource and out of scope here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import boto3
+
+
+@dataclass
+class FoundationModel:
+    model_id: str
+    provider_name: str | None
+    model_name: str | None
+    input_modalities: list[str]
+    output_modalities: list[str]
+    response_streaming: bool | None
+    inference_types: list[str]
+    lifecycle: str | None
+    raw: dict[str, Any]
+
+
+def _client(profile: str | None, region: str | None) -> Any:
+    session = boto3.Session(
+        profile_name=profile if profile and profile != "default" else None,
+        region_name=region,
+    )
+    return session.client("bedrock")
+
+
+def _parse_model(item: dict[str, Any]) -> FoundationModel:
+    lifecycle = item.get("modelLifecycle", {})
+    return FoundationModel(
+        model_id=item.get("modelId", ""),
+        provider_name=item.get("providerName"),
+        model_name=item.get("modelName"),
+        input_modalities=list(item.get("inputModalities", [])),
+        output_modalities=list(item.get("outputModalities", [])),
+        response_streaming=item.get("responseStreamingSupported"),
+        inference_types=list(item.get("inferenceTypesSupported", [])),
+        lifecycle=lifecycle.get("status") if isinstance(lifecycle, dict) else None,
+        raw=item,
+    )
+
+
+def list_foundation_models(
+    *,
+    profile: str | None = None,
+    region: str | None = None,
+    by_provider: str | None = None,
+) -> list[FoundationModel]:
+    """List Bedrock foundation models available in the region."""
+    client = _client(profile, region)
+    kwargs: dict[str, Any] = {}
+    if by_provider:
+        kwargs["byProvider"] = by_provider
+    resp = client.list_foundation_models(**kwargs)
+    return [_parse_model(m) for m in resp.get("modelSummaries", [])]
+
+
+def get_foundation_model(
+    *,
+    model_id: str,
+    profile: str | None = None,
+    region: str | None = None,
+) -> FoundationModel:
+    """Fetch one foundation model's details (id, modalities, lifecycle).
+
+    Reports the model's availability, not the account's access grant — Bedrock
+    exposes no per-account on-demand access status via API.
+    """
+    client = _client(profile, region)
+    resp = client.get_foundation_model(modelIdentifier=model_id)
+    return _parse_model(resp.get("modelDetails", {}))

{granny_devops-0.14.0 → granny_devops-0.15.0}/granny/azure/_client.py

@@ -85,6 +85,16 @@ def post(
     return response.status_code
 
 
+def post_json(
+    url: str, body: dict[str, Any] | None = None, *, token: str | None = None
+) -> dict[str, Any]:
+    """POST an ARM action endpoint (e.g. listKeys) and return the JSON body."""
+    response = requests.post(url, headers=headers(token), json=body, timeout=60)
+    if response.status_code not in (200, 201, 202):
+        raise_response_error("POST", url, response)
+    return response.json() if response.content else {}
+
+
 def paginate(url: str, *, token: str | None = None) -> Iterator[dict[str, Any]]:
     """Yield each item from a paginated ARM ``value``/``nextLink`` collection."""
     bearer = token if token is not None else get_management_token()

granny_devops-0.15.0/granny/azure/openai.py

@@ -0,0 +1,311 @@
+"""Azure Cognitive Services (incl. Azure OpenAI) account and deployment listing."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from granny.azure import _client
+
+_API_VERSION = "2023-05-01"
+# Deployment create/update needs a newer API version than the read path so the
+# GlobalStandard / DataZoneStandard deployment SKUs are accepted.
+_DEPLOY_API_VERSION = "2024-10-01"
+
+
+@dataclass
+class CognitiveAccount:
+    subscription: str
+    resource_group: str | None
+    name: str
+    kind: str | None
+    sku: str | None
+    location: str | None
+    endpoint: str | None
+    provisioning_state: str | None
+    id: str
+    raw: dict[str, Any]
+
+
+@dataclass
+class CognitiveDeployment:
+    subscription: str
+    resource_group: str | None
+    account_name: str
+    name: str
+    model_name: str | None
+    model_version: str | None
+    sku: str | None
+    sku_capacity: int | None
+    provisioning_state: str | None
+    created_at: str | None
+    last_used: str | None
+    id: str
+    raw: dict[str, Any]
+
+
+def list_accounts(subscription: str) -> list[CognitiveAccount]:
+    """List Cognitive Services accounts in the subscription."""
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/providers/Microsoft.CognitiveServices/accounts"
+        f"?api-version={_API_VERSION}"
+    )
+    return [
+        _parse_account(subscription=subscription, item=item)
+        for item in _client.paginate(url)
+    ]
+
+
+def list_account_deployments(
+    subscription: str,
+    resource_group: str,
+    account_name: str,
+) -> list[CognitiveDeployment]:
+    """List model deployments under one Cognitive Services account."""
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/resourceGroups/{resource_group}"
+        f"/providers/Microsoft.CognitiveServices/accounts/{account_name}/deployments"
+        f"?api-version={_API_VERSION}"
+    )
+    return [
+        _parse_deployment(
+            subscription=subscription,
+            resource_group=resource_group,
+            account_name=account_name,
+            item=item,
+        )
+        for item in _client.paginate(url)
+    ]
+
+
+def list_all_deployments(
+    subscription: str,
+    kind_filter: str | None = None,
+) -> list[CognitiveDeployment]:
+    """List every model deployment across every Cognitive Services account."""
+    deployments: list[CognitiveDeployment] = []
+    for account in list_accounts(subscription):
+        if kind_filter and (account.kind or "").lower() != kind_filter.lower():
+            continue
+        if not account.resource_group:
+            continue
+        deployments.extend(
+            list_account_deployments(
+                subscription=subscription,
+                resource_group=account.resource_group,
+                account_name=account.name,
+            )
+        )
+    return deployments
+
+
+def account_deployment_usage(
+    subscription: str,
+    resource_group: str,
+    account_name: str,
+    days: int = 90,
+) -> dict[str, str | None]:
+    """Return ``{deployment_name: last_used_iso}`` from Azure Monitor.
+
+    Uses the ``ModelRequests`` metric (Total, daily, split by
+    ``ModelDeploymentName``) over the last ``days`` (platform-metric retention
+    is ~93 days). ``None`` means no requests in the window. Requires
+    ``Microsoft.Insights/metrics/read`` on the account.
+    """
+    end = datetime.now(timezone.utc)
+    start = end - timedelta(days=days)
+    fmt = "%Y-%m-%dT%H:%M:%SZ"
+    rid = (
+        f"/subscriptions/{subscription}/resourceGroups/{resource_group}"
+        f"/providers/Microsoft.CognitiveServices/accounts/{account_name}"
+    )
+    url = (
+        f"{_client.MANAGEMENT_URL}{rid}/providers/microsoft.insights/metrics"
+        f"?api-version=2019-07-01&metricnames=ModelRequests&aggregation=Total"
+        f"&interval=P1D&timespan={start.strftime(fmt)}/{end.strftime(fmt)}"
+        f"&$filter=ModelDeploymentName eq '*'"
+    )
+    data = _client.get(url)
+    out: dict[str, str | None] = {}
+    for metric in data.get("value", []):
+        for ts in metric.get("timeseries", []):
+            dep = None
+            for md in ts.get("metadatavalues", []):
+                mn = md.get("name", {})
+                if (mn.get("value") if isinstance(mn, dict) else mn) == "ModelDeploymentName":
+                    dep = md.get("value")
+            if dep is None:
+                continue
+            last = None
+            for pt in ts.get("data", []):
+                if pt.get("total"):
+                    last = pt.get("timeStamp")
+            out[dep] = last
+    return out
+
+
+def get_account(
+    subscription: str,
+    resource_group: str,
+    account_name: str,
+) -> CognitiveAccount:
+    """Fetch a single Cognitive Services account (incl. its endpoint)."""
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/resourceGroups/{resource_group}"
+        f"/providers/Microsoft.CognitiveServices/accounts/{account_name}"
+        f"?api-version={_API_VERSION}"
+    )
+    return _parse_account(subscription=subscription, item=_client.get(url))
+
+
+def get_account_keys(
+    subscription: str,
+    resource_group: str,
+    account_name: str,
+) -> dict[str, str]:
+    """Return the account's access keys (``{"key1": ..., "key2": ...}``)."""
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/resourceGroups/{resource_group}"
+        f"/providers/Microsoft.CognitiveServices/accounts/{account_name}"
+        f"/listKeys?api-version={_API_VERSION}"
+    )
+    keys = _client.post_json(url)
+    return {k: v for k, v in keys.items() if k in ("key1", "key2")}
+
+
+def create_account(
+    *,
+    subscription: str,
+    resource_group: str,
+    account_name: str,
+    location: str,
+    custom_subdomain: str | None = None,
+    sku_name: str = "S0",
+) -> CognitiveAccount:
+    """Create (or update) an Azure OpenAI (Cognitive Services) account via ARM PUT.
+
+    ``custom_subdomain`` must be globally unique (it becomes the ``*.openai.azure.com``
+    host); defaults to ``account_name``. The create is async — the returned account
+    may show provisioningState ``Accepted``/``Creating``; poll :func:`get_account`
+    until ``Succeeded`` before creating deployments.
+    """
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/resourceGroups/{resource_group}"
+        f"/providers/Microsoft.CognitiveServices/accounts/{account_name}"
+        f"?api-version={_API_VERSION}"
+    )
+    body = {
+        "location": location,
+        "kind": "OpenAI",
+        "sku": {"name": sku_name},
+        "properties": {
+            "customSubDomainName": custom_subdomain or account_name,
+            "publicNetworkAccess": "Enabled",
+        },
+    }
+    item = _client.put(url, body)
+    return _parse_account(subscription=subscription, item=item)
+
+
+def create_deployment(
+    *,
+    subscription: str,
+    resource_group: str,
+    account_name: str,
+    deployment_name: str,
+    model_name: str,
+    model_version: str | None = None,
+    model_format: str = "OpenAI",
+    sku_name: str = "GlobalStandard",
+    sku_capacity: int = 1,
+) -> CognitiveDeployment:
+    """Create (or update) an Azure OpenAI model deployment via ARM PUT.
+
+    ``deployment_name`` is the name callers request at inference time;
+    ``model_name`` (+ optional ``model_version``) is the underlying model, e.g.
+    ``gpt-4o`` / ``2024-08-06``. ``sku_capacity`` is in thousands of TPM for the
+    standard SKUs. Idempotent: PUT on an existing deployment updates it.
+    """
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/resourceGroups/{resource_group}"
+        f"/providers/Microsoft.CognitiveServices/accounts/{account_name}"
+        f"/deployments/{deployment_name}"
+        f"?api-version={_DEPLOY_API_VERSION}"
+    )
+    model: dict[str, Any] = {"format": model_format, "name": model_name}
+    if model_version:
+        model["version"] = model_version
+    body = {
+        "sku": {"name": sku_name, "capacity": sku_capacity},
+        "properties": {"model": model},
+    }
+    item = _client.put(url, body)
+    return _parse_deployment(
+        subscription=subscription,
+        resource_group=resource_group,
+        account_name=account_name,
+        item=item,
+    )
+
+
+def _parse_account(subscription: str, item: dict[str, Any]) -> CognitiveAccount:
+    properties = item.get("properties", {}) if isinstance(item, dict) else {}
+    sku = item.get("sku", {}) if isinstance(item, dict) else {}
+    resource_id = item.get("id", "")
+    return CognitiveAccount(
+        subscription=subscription,
+        resource_group=_resource_group_from_id(resource_id),
+        name=item.get("name", ""),
+        kind=item.get("kind"),
+        sku=sku.get("name") if isinstance(sku, dict) else None,
+        location=item.get("location"),
+        endpoint=properties.get("endpoint"),
+        provisioning_state=properties.get("provisioningState"),
+        id=resource_id,
+        raw=item,
+    )
+
+
+def _parse_deployment(
+    subscription: str,
+    resource_group: str,
+    account_name: str,
+    item: dict[str, Any],
+) -> CognitiveDeployment:
+    properties = item.get("properties", {}) if isinstance(item, dict) else {}
+    model = properties.get("model", {}) if isinstance(properties, dict) else {}
+    sku = item.get("sku", {}) if isinstance(item, dict) else {}
+    system = item.get("systemData", {}) if isinstance(item, dict) else {}
+    return CognitiveDeployment(
+        subscription=subscription,
+        resource_group=resource_group,
+        account_name=account_name,
+        name=item.get("name", ""),
+        model_name=model.get("name") if isinstance(model, dict) else None,
+        model_version=model.get("version") if isinstance(model, dict) else None,
+        sku=sku.get("name") if isinstance(sku, dict) else None,
+        sku_capacity=sku.get("capacity") if isinstance(sku, dict) else None,
+        provisioning_state=properties.get("provisioningState"),
+        created_at=system.get("createdAt") if isinstance(system, dict) else None,
+        last_used=None,  # filled in on demand via account_deployment_usage()
+        id=item.get("id", ""),
+        raw=item,
+    )
+
+
+def _resource_group_from_id(resource_id: str) -> str | None:
+    parts = resource_id.lower().split("/")
+    try:
+        idx = parts.index("resourcegroups")
+    except ValueError:
+        return None
+    if idx + 1 < len(parts):
+        return resource_id.split("/")[idx + 1]
+    return None

granny_devops-0.15.0/granny/azure/resourcegroup.py

@@ -0,0 +1,52 @@
+"""Azure resource-group create/list helpers (ARM REST via ``_client``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from granny.azure import _client
+
+_API_VERSION = "2021-04-01"
+
+
+@dataclass
+class ResourceGroup:
+    subscription: str
+    name: str
+    location: str | None
+    provisioning_state: str | None
+    id: str
+    raw: dict[str, Any]
+
+
+def _parse(subscription: str, item: dict[str, Any]) -> ResourceGroup:
+    props = item.get("properties", {}) if isinstance(item, dict) else {}
+    return ResourceGroup(
+        subscription=subscription,
+        name=item.get("name", ""),
+        location=item.get("location"),
+        provisioning_state=props.get("provisioningState") if isinstance(props, dict) else None,
+        id=item.get("id", ""),
+        raw=item,
+    )
+
+
+def create_resource_group(
+    *, subscription: str, name: str, location: str
+) -> ResourceGroup:
+    """Create (or update) a resource group. Idempotent."""
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/resourcegroups/{name}?api-version={_API_VERSION}"
+    )
+    return _parse(subscription, _client.put(url, {"location": location}))
+
+
+def list_resource_groups(subscription: str) -> list[ResourceGroup]:
+    """List resource groups in the subscription."""
+    url = (
+        f"{_client.MANAGEMENT_URL}/subscriptions/{subscription}"
+        f"/resourcegroups?api-version={_API_VERSION}"
+    )
+    return [_parse(subscription, item) for item in _client.paginate(url)]

{granny_devops-0.14.0 → granny_devops-0.15.0}/granny/cli/aws.py

@@ -168,6 +168,85 @@ def quota_request(
         click.echo(f"Case ID:    {result.case_id}")
 
 
+@aws.group()
+def bedrock() -> None:
+    """Inspect and enable Amazon Bedrock foundation models."""
+
+
+@bedrock.command("list-models")
+@click.option("--by-provider", default=None, help="Filter by provider, e.g. Anthropic / Meta / Amazon")
+@click.option("--profile", default=None, help="AWS profile name")
+@click.option("--region", default=None, help="AWS region, e.g. eu-central-1")
+@click.option("--json-output", "as_json", is_flag=True, help="Output as JSON")
+def bedrock_list_models(
+    by_provider: str | None,
+    profile: str | None,
+    region: str | None,
+    as_json: bool,
+) -> None:
+    """List Bedrock foundation models available in the region."""
+    from dataclasses import asdict
+
+    from granny.aws.bedrock import list_foundation_models
+
+    with _friendly_errors():
+        rows = list_foundation_models(
+            profile=profile, region=region, by_provider=by_provider
+        )
+    if as_json:
+        click.echo(json.dumps([asdict(r) for r in rows], indent=2, default=str))
+        return
+
+    if not rows:
+        click.echo("No Bedrock foundation models found.")
+        return
+
+    click.echo(f"\n{'Model ID':<52} {'Provider':<16} Streaming")
+    click.echo("-" * 90)
+    for row in rows:
+        streaming = "-" if row.response_streaming is None else ("yes" if row.response_streaming else "no")
+        click.echo(f"{row.model_id:<52} {(row.provider_name or ''):<16} {streaming}")
+
+
+@bedrock.command("check-access")
+@click.option("--model-id", required=True, help="Foundation model id, e.g. anthropic.claude-sonnet-4-20250514-v1:0")
+@click.option("--profile", default=None, help="AWS profile name")
+@click.option("--region", default=None, help="AWS region, e.g. eu-central-1")
+@click.option("--json-output", "as_json", is_flag=True, help="Output as JSON")
+def bedrock_check_access(
+    model_id: str,
+    profile: str | None,
+    region: str | None,
+    as_json: bool,
+) -> None:
+    """Report a Bedrock foundation model's availability and on-demand support.
+
+    Bedrock has no API to grant on-demand access — that is a one-time console
+    step (Model access). This confirms the model exists, is ACTIVE, and supports
+    ON_DEMAND, then tells you the route id. If a later invoke returns
+    AccessDenied, enable the model in the console.
+    """
+    from dataclasses import asdict
+
+    from granny.aws.bedrock import get_foundation_model
+
+    with _friendly_errors():
+        fm = get_foundation_model(model_id=model_id, profile=profile, region=region)
+    on_demand = "ON_DEMAND" in fm.inference_types
+    if as_json:
+        out = asdict(fm)
+        out["on_demand"] = on_demand
+        out["route_model"] = f"bedrock/{fm.model_id}"
+        click.echo(json.dumps(out, indent=2, default=str))
+        return
+    click.echo(f"Model:      {fm.model_id}")
+    click.echo(f"Provider:   {fm.provider_name or '-'}")
+    click.echo(f"Lifecycle:  {fm.lifecycle or '-'}")
+    click.echo(f"On-demand:  {'yes' if on_demand else 'no'}")
+    click.echo(f"Route as:   bedrock/{fm.model_id}")
+    click.echo("Access is granted in the Bedrock console (Model access); no public API.")
+
+
 @quota.command("status")
 @click.argument("quota_ref", default="gpu")
 @click.option("--service-code", default=None, help="Override service code (default: ec2)")