pragmatiks-gcp-provider 0.64.0__py3-none-any.whl

gcp_provider/__init__.py

@@ -0,0 +1,25 @@
+"""GCP provider for Pragmatiks.
+
+Provides GCP resources for managing infrastructure in Google Cloud Platform
+using user-provided credentials (multi-tenant SaaS pattern).
+"""
+
+from pragma_sdk import Provider
+
+from gcp_provider.resources import GKE, GKEConfig, GKEOutputs, Secret, SecretConfig, SecretOutputs
+
+gcp = Provider(name="gcp")
+
+# Register resources
+gcp.resource("gke")(GKE)
+gcp.resource("secret")(Secret)
+
+__all__ = [
+    "gcp",
+    "GKE",
+    "GKEConfig",
+    "GKEOutputs",
+    "Secret",
+    "SecretConfig",
+    "SecretOutputs",
+]

gcp_provider/resources/__init__.py

@@ -0,0 +1,24 @@
+"""Resource definitions for gcp provider.
+
+Import and export your Resource classes here for discovery by the runtime.
+"""
+
+from gcp_provider.resources.gke import (
+    GKE,
+    GKEConfig,
+    GKEOutputs,
+)
+from gcp_provider.resources.secret import (
+    Secret,
+    SecretConfig,
+    SecretOutputs,
+)
+
+__all__ = [
+    "GKE",
+    "GKEConfig",
+    "GKEOutputs",
+    "Secret",
+    "SecretConfig",
+    "SecretOutputs",
+]

gcp_provider/resources/gke.py

@@ -0,0 +1,435 @@
+"""GCP GKE cluster resource supporting both Autopilot and Standard modes."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from collections.abc import AsyncIterator
+from datetime import datetime
+from typing import Annotated, Any, ClassVar, Literal, Self
+
+from google.api_core.exceptions import AlreadyExists, NotFound
+from google.cloud.container_v1 import ClusterManagerAsyncClient
+from google.cloud.container_v1.types import (
+    Cluster,
+    CreateClusterRequest,
+    DeleteClusterRequest,
+    GetClusterRequest,
+    NodeConfig,
+    NodePool,
+)
+from google.cloud.logging_v2 import Client as LoggingClient
+from google.oauth2 import service_account
+from pydantic import Field, field_validator, model_validator
+from pragma_sdk import Config, HealthStatus, LogEntry, Outputs, Resource
+
+_CLUSTER_NAME_PATTERN = re.compile(r"^[a-z][a-z0-9-]{0,38}[a-z0-9]$|^[a-z]$")
+
+
+class GKEConfig(Config):
+    """Configuration for a GKE cluster.
+
+    Attributes:
+        project_id: GCP project ID where the cluster will be created.
+        credentials: GCP service account credentials JSON object or string.
+        location: GCP location - either a region (e.g., europe-west4) for regional
+            clusters or a zone (e.g., europe-west4-a) for zonal clusters.
+        name: Name of the GKE cluster.
+        autopilot: Whether to create an Autopilot cluster. Defaults to True.
+        network: VPC network name. Defaults to "default".
+        subnetwork: VPC subnetwork name. If not specified, uses network default.
+        release_channel: Release channel for cluster updates.
+        initial_node_count: Number of nodes in default pool (standard clusters only).
+        machine_type: Machine type for nodes (standard clusters only).
+        disk_size_gb: Boot disk size in GB (standard clusters only).
+    """
+
+    project_id: str
+    credentials: dict[str, Any] | str
+    location: str
+    name: str
+    autopilot: bool = True
+    network: str = "default"
+    subnetwork: str | None = None
+    release_channel: Literal["RAPID", "REGULAR", "STABLE"] = "REGULAR"
+    initial_node_count: Annotated[int, Field(ge=1)] = 1
+    machine_type: str = "e2-medium"
+    disk_size_gb: Annotated[int, Field(ge=10)] = 100
+
+    @field_validator("name")
+    @classmethod
+    def validate_cluster_name(cls, v: str) -> str:
+        """Validate cluster name follows GCP naming rules."""
+        if not _CLUSTER_NAME_PATTERN.match(v):
+            msg = (
+                "Cluster name must start with a lowercase letter, contain only "
+                "lowercase letters, numbers, and hyphens, and be 1-40 characters"
+            )
+            raise ValueError(msg)
+        return v
+
+    @model_validator(mode="after")
+    def validate_standard_cluster_config(self) -> Self:
+        """Validate node configuration for standard clusters."""
+        if not self.autopilot and self.initial_node_count < 1:
+            msg = "Standard clusters require initial_node_count >= 1"
+            raise ValueError(msg)
+        return self
+
+
+class GKEOutputs(Outputs):
+    """Outputs from GKE cluster creation.
+
+    Attributes:
+        name: Cluster name.
+        endpoint: Cluster API server endpoint URL.
+        cluster_ca_certificate: Base64-encoded cluster CA certificate.
+        location: Cluster location (region or zone).
+        status: Cluster status (RUNNING, PROVISIONING, etc.).
+        console_url: URL to view cluster in GCP Console.
+        logs_url: URL to view cluster logs in Cloud Logging.
+    """
+
+    name: str
+    endpoint: str
+    cluster_ca_certificate: str
+    location: str
+    status: str
+    console_url: str
+    logs_url: str
+
+
+# Polling configuration for cluster operations
+_POLL_INTERVAL_SECONDS = 30
+_MAX_POLL_ATTEMPTS = 40  # 40 * 30s = 20 minutes max wait
+
+
+class GKE(Resource[GKEConfig, GKEOutputs]):
+    """GCP GKE cluster resource supporting Autopilot and Standard modes.
+
+    Creates and manages GKE clusters using user-provided service account
+    credentials (multi-tenant SaaS pattern).
+
+    Modes:
+        - Autopilot (default): Fully managed, no node configuration needed
+        - Standard: Manual node pool with configurable machine type and count
+
+    Lifecycle:
+        - on_create: Creates cluster, waits for RUNNING state
+        - on_update: Limited updates (some require recreation)
+        - on_delete: Deletes cluster, waits for completion
+    """
+
+    provider: ClassVar[str] = "gcp"
+    resource: ClassVar[str] = "gke"
+
+    def _get_client(self) -> ClusterManagerAsyncClient:
+        """Get Cluster Manager async client with user-provided credentials.
+
+        Returns:
+            Configured Cluster Manager async client.
+
+        Raises:
+            ValueError: If credentials format is invalid.
+        """
+        creds_data = self.config.credentials
+
+        if isinstance(creds_data, str):
+            creds_data = json.loads(creds_data)
+
+        credentials = service_account.Credentials.from_service_account_info(creds_data)
+        return ClusterManagerAsyncClient(credentials=credentials)
+
+    def _cluster_path(self) -> str:
+        """Build cluster resource path.
+
+        Returns:
+            Full GCP resource path for this cluster.
+        """
+        return f"projects/{self.config.project_id}/locations/{self.config.location}/clusters/{self.config.name}"
+
+    def _parent_path(self) -> str:
+        """Build parent resource path for cluster creation.
+
+        Returns:
+            Parent path (project/location).
+        """
+        return f"projects/{self.config.project_id}/locations/{self.config.location}"
+
+    def _build_outputs(self, cluster: Cluster) -> GKEOutputs:
+        """Build outputs from cluster object."""
+        project = self.config.project_id
+        location = self.config.location
+        name = self.config.name
+
+        console_url = (
+            f"https://console.cloud.google.com/kubernetes/clusters/details/"
+            f"{location}/{name}/details?project={project}"
+        )
+        logs_url = (
+            f"https://console.cloud.google.com/logs/query;query="
+            f"resource.type%3D%22k8s_cluster%22%0A"
+            f"resource.labels.cluster_name%3D%22{name}%22%0A"
+            f"resource.labels.location%3D%22{location}%22"
+            f"?project={project}"
+        )
+
+        return GKEOutputs(
+            name=cluster.name,
+            endpoint=cluster.endpoint,
+            cluster_ca_certificate=cluster.master_auth.cluster_ca_certificate,
+            location=cluster.location,
+            status=Cluster.Status(cluster.status).name,
+            console_url=console_url,
+            logs_url=logs_url,
+        )
+
+    async def _wait_for_running(self, client: ClusterManagerAsyncClient) -> Cluster:
+        """Poll cluster until it reaches RUNNING state.
+
+        Args:
+            client: Cluster Manager client.
+
+        Returns:
+            Cluster in RUNNING state.
+
+        Raises:
+            TimeoutError: If cluster doesn't reach RUNNING in time.
+            RuntimeError: If cluster enters ERROR state.
+        """
+        for _ in range(_MAX_POLL_ATTEMPTS):
+            cluster = await client.get_cluster(request=GetClusterRequest(name=self._cluster_path()))
+
+            if cluster.status == Cluster.Status.RUNNING:
+                return cluster
+
+            if cluster.status == Cluster.Status.ERROR:
+                msg = f"Cluster entered ERROR state: {cluster.status_message}"
+                raise RuntimeError(msg)
+
+            if cluster.status in (
+                Cluster.Status.STOPPING,
+                Cluster.Status.DEGRADED,
+            ):
+                msg = f"Cluster in unexpected state: {cluster.status.name}"
+                raise RuntimeError(msg)
+
+            await asyncio.sleep(_POLL_INTERVAL_SECONDS)
+
+        msg = f"Cluster did not reach RUNNING state within {_MAX_POLL_ATTEMPTS * _POLL_INTERVAL_SECONDS} seconds"
+        raise TimeoutError(msg)
+
+    async def _wait_for_deletion(self, client: ClusterManagerAsyncClient) -> None:
+        """Poll until cluster is deleted.
+
+        Args:
+            client: Cluster Manager client.
+
+        Raises:
+            TimeoutError: If cluster doesn't delete in time.
+        """
+        for _ in range(_MAX_POLL_ATTEMPTS):
+            try:
+                await client.get_cluster(request=GetClusterRequest(name=self._cluster_path()))
+                await asyncio.sleep(_POLL_INTERVAL_SECONDS)
+            except NotFound:
+                return
+
+        msg = f"Cluster was not deleted within {_MAX_POLL_ATTEMPTS * _POLL_INTERVAL_SECONDS} seconds"
+        raise TimeoutError(msg)
+
+    def _build_cluster_config(self) -> Cluster:
+        """Build cluster configuration object.
+
+        Returns:
+            Cluster configuration for create request.
+        """
+        cluster = Cluster(
+            name=self.config.name,
+            network=self.config.network,
+            release_channel={"channel": self.config.release_channel},
+        )
+
+        if self.config.subnetwork:
+            cluster.subnetwork = self.config.subnetwork
+
+        if self.config.autopilot:
+            cluster.autopilot = {"enabled": True}
+        else:
+            cluster.node_pools = [
+                NodePool(
+                    name="default-pool",
+                    initial_node_count=self.config.initial_node_count,
+                    config=NodeConfig(
+                        machine_type=self.config.machine_type,
+                        disk_size_gb=self.config.disk_size_gb,
+                    ),
+                )
+            ]
+
+        return cluster
+
+    async def on_create(self) -> GKEOutputs:
+        """Create GKE cluster and wait for RUNNING state.
+
+        Idempotent: If cluster already exists, returns its current state.
+
+        Returns:
+            GKEOutputs with cluster details.
+        """
+        client = self._get_client()
+
+        try:
+            await client.create_cluster(
+                request=CreateClusterRequest(
+                    parent=self._parent_path(),
+                    cluster=self._build_cluster_config(),
+                )
+            )
+        except AlreadyExists:
+            pass
+
+        cluster = await self._wait_for_running(client)
+
+        return self._build_outputs(cluster)
+
+    async def on_update(self, previous_config: GKEConfig) -> GKEOutputs:
+        """Update cluster configuration.
+
+        Most GKE cluster properties require recreation. This method validates
+        that immutable fields haven't changed and returns current state.
+
+        Args:
+            previous_config: The previous configuration before update.
+
+        Returns:
+            GKEOutputs with current cluster state.
+
+        Raises:
+            ValueError: If immutable fields changed (requires delete + create).
+        """
+        if previous_config.project_id != self.config.project_id:
+            msg = "Cannot change project_id; delete and recreate resource"
+            raise ValueError(msg)
+
+        if previous_config.location != self.config.location:
+            msg = "Cannot change location; delete and recreate resource"
+            raise ValueError(msg)
+
+        if previous_config.name != self.config.name:
+            msg = "Cannot change name; delete and recreate resource"
+            raise ValueError(msg)
+
+        if previous_config.network != self.config.network:
+            msg = "Cannot change network; delete and recreate resource"
+            raise ValueError(msg)
+
+        if previous_config.autopilot != self.config.autopilot:
+            msg = "Cannot change autopilot mode; delete and recreate resource"
+            raise ValueError(msg)
+
+        # For unchanged configs, return existing outputs if available
+        if self.outputs is not None:
+            return self.outputs
+
+        # Fetch current cluster state
+        client = self._get_client()
+        cluster = await client.get_cluster(request=GetClusterRequest(name=self._cluster_path()))
+
+        return self._build_outputs(cluster)
+
+    async def on_delete(self) -> None:
+        """Delete cluster and wait for completion.
+
+        Idempotent: Succeeds if cluster doesn't exist.
+        """
+        client = self._get_client()
+
+        try:
+            await client.delete_cluster(request=DeleteClusterRequest(name=self._cluster_path()))
+            await self._wait_for_deletion(client)
+        except NotFound:
+            pass
+
+    async def health(self) -> HealthStatus:
+        """Check cluster health by querying cluster status."""
+        client = self._get_client()
+
+        try:
+            cluster = await client.get_cluster(
+                request=GetClusterRequest(name=self._cluster_path())
+            )
+        except NotFound:
+            return HealthStatus(
+                status="unhealthy",
+                message="Cluster not found",
+            )
+
+        status = Cluster.Status(cluster.status)
+
+        if status == Cluster.Status.RUNNING:
+            return HealthStatus(
+                status="healthy",
+                message="Cluster is running",
+                details={"node_count": sum(np.initial_node_count for np in cluster.node_pools)},
+            )
+
+        if status in (Cluster.Status.PROVISIONING, Cluster.Status.RECONCILING):
+            return HealthStatus(
+                status="degraded",
+                message=f"Cluster is {status.name.lower()}",
+            )
+
+        return HealthStatus(
+            status="unhealthy",
+            message=f"Cluster status: {status.name}",
+            details={"status_message": cluster.status_message} if cluster.status_message else None,
+        )
+
+    async def logs(
+        self,
+        since: datetime | None = None,
+        tail: int = 100,
+    ) -> AsyncIterator[LogEntry]:
+        """Fetch cluster logs from Cloud Logging."""
+        creds_data = self.config.credentials
+        if isinstance(creds_data, str):
+            creds_data = json.loads(creds_data)
+
+        credentials = service_account.Credentials.from_service_account_info(creds_data)
+        logging_client = LoggingClient(credentials=credentials, project=self.config.project_id)
+
+        filter_parts = [
+            'resource.type="k8s_cluster"',
+            f'resource.labels.cluster_name="{self.config.name}"',
+            f'resource.labels.location="{self.config.location}"',
+        ]
+        if since:
+            filter_parts.append(f'timestamp>="{since.isoformat()}Z"')
+
+        filter_str = " AND ".join(filter_parts)
+
+        entries = logging_client.list_entries(
+            filter_=filter_str,
+            order_by="timestamp desc",
+            max_results=tail,
+        )
+
+        for entry in entries:
+            level = "info"
+            if hasattr(entry, "severity"):
+                severity = str(entry.severity).lower()
+                if "error" in severity or "critical" in severity:
+                    level = "error"
+                elif "warn" in severity:
+                    level = "warn"
+                elif "debug" in severity:
+                    level = "debug"
+
+            yield LogEntry(
+                timestamp=entry.timestamp,
+                level=level,
+                message=str(entry.payload) if entry.payload else "",
+                metadata={"log_name": entry.log_name} if entry.log_name else None,
+            )

gcp_provider/resources/secret.py

@@ -0,0 +1,172 @@
+"""GCP Secret Manager resource."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, ClassVar
+
+from google.api_core.exceptions import AlreadyExists, NotFound
+from google.cloud.secretmanager_v1 import SecretManagerServiceAsyncClient
+from google.oauth2 import service_account
+from pragma_sdk import Config, Outputs, Resource
+
+
+class SecretConfig(Config):
+    """Configuration for a GCP Secret Manager secret.
+
+    Attributes:
+        project_id: GCP project ID where the secret will be created.
+        secret_id: Identifier for the secret within GCP (must be unique per project).
+        data: Secret payload data to store.
+        credentials: GCP service account credentials JSON object or string.
+            Required for multi-tenant SaaS - no ADC fallback.
+            Use a pragma/secret resource with a FieldReference to provide credentials.
+    """
+
+    project_id: str
+    secret_id: str
+    data: str
+    credentials: dict[str, Any] | str
+
+
+class SecretOutputs(Outputs):
+    """Outputs from GCP Secret Manager secret creation.
+
+    Attributes:
+        resource_name: Full GCP resource name (projects/{project}/secrets/{id}).
+        version_name: Full version resource name including version number.
+        version_id: The version number as a string.
+    """
+
+    resource_name: str
+    version_name: str
+    version_id: str
+
+
+class Secret(Resource[SecretConfig, SecretOutputs]):
+    """GCP Secret Manager secret resource.
+
+    Creates and manages secrets in GCP Secret Manager using user-provided
+    service account credentials (multi-tenant SaaS pattern).
+
+    Lifecycle:
+        - on_create: Creates secret and initial version
+        - on_update: Creates new version if data changed
+        - on_delete: Deletes secret and all versions
+    """
+
+    provider: ClassVar[str] = "gcp"
+    resource: ClassVar[str] = "secret"
+
+    def _get_client(self) -> SecretManagerServiceAsyncClient:
+        """Get Secret Manager async client with user-provided credentials.
+
+        Creates a client authenticated with the user's GCP service account
+        credentials rather than using ADC/Workload Identity. This is required
+        for multi-tenant SaaS where each user operates in their own GCP project.
+
+        Returns:
+            Configured Secret Manager async client using user's credentials.
+
+        Raises:
+            ValueError: If credentials format is invalid.
+        """
+        creds_data = self.config.credentials
+
+        if isinstance(creds_data, str):
+            creds_data = json.loads(creds_data)
+
+        credentials = service_account.Credentials.from_service_account_info(creds_data)
+        return SecretManagerServiceAsyncClient(credentials=credentials)
+
+    def _secret_path(self) -> str:
+        """Build secret resource path.
+
+        Returns:
+            Full GCP resource path for this secret.
+        """
+        return f"projects/{self.config.project_id}/secrets/{self.config.secret_id}"
+
+    async def on_create(self) -> SecretOutputs:
+        """Create GCP secret with initial version.
+
+        Idempotent: If secret already exists, adds a new version.
+
+        Returns:
+            SecretOutputs with resource name and version info.
+        """
+        client = self._get_client()
+        parent = f"projects/{self.config.project_id}"
+
+        try:
+            secret = await client.create_secret(
+                request={
+                    "parent": parent,
+                    "secret_id": self.config.secret_id,
+                    "secret": {"replication": {"automatic": {}}},
+                }
+            )
+        except AlreadyExists:
+            secret = await client.get_secret(name=self._secret_path())
+
+        version = await client.add_secret_version(
+            request={
+                "parent": secret.name,
+                "payload": {"data": self.config.data.encode("utf-8")},
+            }
+        )
+
+        return SecretOutputs(
+            resource_name=secret.name,
+            version_name=version.name,
+            version_id=version.name.split("/")[-1],
+        )
+
+    async def on_update(self, previous_config: SecretConfig) -> SecretOutputs:
+        """Update secret by creating new version if data changed.
+
+        Args:
+            previous_config: The previous configuration before update.
+
+        Returns:
+            SecretOutputs with updated version info.
+
+        Raises:
+            ValueError: If project_id or secret_id changed (requires delete + create).
+        """
+        if previous_config.project_id != self.config.project_id:
+            msg = "Cannot change project_id; delete and recreate resource"
+            raise ValueError(msg)
+
+        if previous_config.secret_id != self.config.secret_id:
+            msg = "Cannot change secret_id; delete and recreate resource"
+            raise ValueError(msg)
+
+        if previous_config.data == self.config.data and self.outputs is not None:
+            return self.outputs
+
+        client = self._get_client()
+        version = await client.add_secret_version(
+            request={
+                "parent": self._secret_path(),
+                "payload": {"data": self.config.data.encode("utf-8")},
+            }
+        )
+
+        return SecretOutputs(
+            resource_name=self._secret_path(),
+            version_name=version.name,
+            version_id=version.name.split("/")[-1],
+        )
+
+    async def on_delete(self) -> None:
+        """Delete secret and all versions.
+
+        Idempotent: Succeeds if secret doesn't exist.
+        """
+        client = self._get_client()
+
+        try:
+            await client.delete_secret(name=self._secret_path())
+        except NotFound:
+            pass

pragmatiks_gcp_provider-0.64.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.3
+Name: pragmatiks-gcp-provider
+Version: 0.64.0
+Summary: GCP provider for Pragmatiks
+Author: Pragmatiks
+Author-email: Pragmatiks <team@pragmatiks.io>
+Requires-Dist: pragmatiks-sdk>=0.6.0
+Requires-Dist: google-cloud-container>=2.50.0
+Requires-Dist: google-cloud-logging>=3.10.0
+Requires-Dist: google-cloud-secret-manager>=2.20.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# GCP Provider
+
+GCP provider for Pragmatiks - manage Google Cloud resources declaratively.
+
+## Available Resources
+
+### Secret (gcp/secret)
+
+Manages secrets in GCP Secret Manager using user-provided service account credentials.
+
+```python
+from gcp_provider import Secret, SecretConfig
+
+# Define a secret
+secret = Secret(
+    name="my-api-key",
+    config=SecretConfig(
+        project_id="my-gcp-project",
+        secret_id="api-key",
+        data="super-secret-value",
+        credentials={"type": "service_account", ...},  # or JSON string
+    ),
+)
+```
+
+**Config:**
+- `project_id` - GCP project ID where the secret will be created
+- `secret_id` - Identifier for the secret (must be unique per project)
+- `data` - Secret payload data to store
+- `credentials` - GCP service account credentials (JSON object or string)
+
+**Outputs:**
+- `resource_name` - Full GCP resource name (`projects/{project}/secrets/{id}`)
+- `version_name` - Full version resource name including version number
+- `version_id` - The version number as a string
+
+## Installation
+
+```bash
+pip install pragmatiks-gcp-provider
+```
+
+## Development
+
+### Testing
+
+```bash
+# Install dependencies
+uv sync --dev
+
+# Run tests
+uv run pytest tests/
+```
+
+### Writing Tests
+
+Use `ProviderHarness` to test lifecycle methods:
+
+```python
+from pragma_sdk.provider import ProviderHarness
+from gcp_provider import Secret, SecretConfig
+
+async def test_create_secret():
+    harness = ProviderHarness()
+    result = await harness.invoke_create(
+        Secret,
+        name="test-secret",
+        config=SecretConfig(
+            project_id="test-project",
+            secret_id="my-secret",
+            data="secret-value",
+            credentials=mock_credentials,
+        ),
+    )
+    assert result.success
+    assert result.outputs.resource_name is not None
+```
+
+## Deployment
+
+Push your provider to Pragmatiks platform:
+
+```bash
+pragma provider push
+```

pragmatiks_gcp_provider-0.64.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+gcp_provider/__init__.py,sha256=b8pjwnaNe5nJnNXp03jkENxsDXgID0rLheLF0JjgAD8,540
+gcp_provider/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gcp_provider/resources/__init__.py,sha256=ghouF-RCSEMHy6ZwJ29ZgG963unNLHc6z_1grlu-gAg,417
+gcp_provider/resources/gke.py,sha256=KQdQ8Vmm24OuKl6gYuQri9vcJDx7aEG7lCMBhZihHQk,15248
+gcp_provider/resources/secret.py,sha256=pZMMRRG_79VKh6sEA5i6FA5jnmy7-eKWNQWrR1u4-wc,5678
+pragmatiks_gcp_provider-0.64.0.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+pragmatiks_gcp_provider-0.64.0.dist-info/METADATA,sha256=gkopH3XYTtmOhtSoio-SPcId5Gg0U3LAPIpwqtRrs1A,2317
+pragmatiks_gcp_provider-0.64.0.dist-info/RECORD,,

pragmatiks_gcp_provider-0.64.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.27
+Root-Is-Purelib: true
+Tag: py3-none-any