pyvider-components 0.0.0.post1__tar.gz

pyvider_components-0.0.0.post1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: pyvider-components
+Version: 0.0.0.post1
+Summary: Standard Components for the Pyvider Framework
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pyvider-telemetry
+Requires-Dist: pyvider-rpcplugin
+Requires-Dist: attrs>=25.3.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: jq>=1.9.1
+Requires-Dist: jinja2>=3.1.6
+
+# Pyvider Provider Components
+
+There's always room for improvement.

pyvider_components-0.0.0.post1/README.md

@@ -0,0 +1,3 @@
+# Pyvider Provider Components
+
+There's always room for improvement.

pyvider_components-0.0.0.post1/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "pyvider-components"
+version = "0.0.0-1"
+description = "Standard Components for the Pyvider Framework"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "pyvider-telemetry",
+    "pyvider-rpcplugin",
+    "attrs>=25.3.0",
+    "httpx>=0.28.1",
+    "jq>=1.9.1",
+    "jinja2>=3.1.6",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.garnish/**/*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[dependency-groups]
+dev = [
+    "bandit>=1.8.3",
+    "grpc-stubs>=1.53.0.6",
+    "grpcio-tools>=1.73.0",
+    "hypothesis>=6.131.0",
+    "mypy>=1.9.0",
+    "psutil>=7.0.0",
+    "pyright>=1.1.401",
+    "pytest>=8.3.0",
+    "pytest-asyncio>=0.25.0",
+    "pytest-cov>=6.0.0",
+    "pytest-mock>=3.14.0",
+    "pytest-xdist>=3.6.0",
+    "ruff>=0.9.0",
+    "twine>=6.0.0",
+    "types-protobuf>=6.30.2.20250516",
+    "memray>=1.17.2",
+    "pytest-benchmark>=5.1.0",
+]
+
+[tool.uv.sources]

pyvider_components-0.0.0.post1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyvider_components-0.0.0.post1/src/pyvider/__init__.py

@@ -0,0 +1,10 @@
+#
+# pyvider/__init__.py
+#
+
+# This file declares 'pyvider' as a namespace package, allowing it to be
+# extended across multiple directories.
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+
+
+# 📦🔧🐍

pyvider_components-0.0.0.post1/src/pyvider/components/__init__.py

@@ -0,0 +1,9 @@
+#
+# pyvider/components/__init__.py
+#
+
+# This file makes pyvider.components a package.
+# Autodiscovery will scan from here.
+
+
+# 🧩📦🔍

pyvider_components-0.0.0.post1/src/pyvider/components/capabilities/__init__.py

@@ -0,0 +1,7 @@
+#
+# pyvider/components/capabilities/__init__.py
+#
+
+# This file makes this directory a Python package.
+
+# 📦🚀🐍

pyvider_components-0.0.0.post1/src/pyvider/components/capabilities/api.py

@@ -0,0 +1,58 @@
+#
+# pyvider/components/capabilities/api.py
+#
+
+from pyvider.capabilities import BaseCapability, register_capability
+from pyvider.schema import PvsAttribute, a_bool, a_map, a_num, a_str
+
+
+class AbstractApiCapability(BaseCapability):
+    """
+    Provides a standard set of API configuration attributes for a provider.
+    """
+
+    @staticmethod
+    def get_schema_contribution() -> dict[str, PvsAttribute]:
+        return {
+            "api_endpoint": a_str(
+                optional=True, description="The base URL for the API endpoint."
+            ),
+            "api_token": a_str(
+                optional=True,
+                sensitive=True,
+                description="The authentication token for the API.",
+            ),
+            "api_timeout": a_num(
+                optional=True,
+                default=30,
+                description="Timeout in seconds for API requests.",
+            ),
+            "api_retries": a_num(
+                optional=True,
+                default=3,
+                description="Number of retries for failed API requests.",
+            ),
+            "api_insecure_skip_verify": a_bool(
+                optional=True,
+                default=False,
+                description="If true, TLS certificate verification is skipped.",
+            ),
+            "api_headers": a_map(
+                element_type_def=a_str(),
+                optional=True,
+                description="Custom headers to send with every API request.",
+            ),
+        }
+
+
+@register_capability("api")
+class ApiCapability(AbstractApiCapability):
+    """
+    The Pyvider API capability.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+
+# 🔌🌐🛠️

pyvider_components-0.0.0.post1/src/pyvider/components/capabilities/lens.py

@@ -0,0 +1,70 @@
+#
+# pyvider/components/capabilities/lens.py
+#
+
+from typing import Any
+
+import jq
+
+from pyvider.capabilities import BaseCapability, register_capability
+from pyvider.cty import CtyValue
+from pyvider.cty.conversion import infer_cty_type_from_raw
+from pyvider.exceptions import FunctionError
+from pyvider.schema import PvsAttribute, a_bool, a_str
+from pyvider.telemetry import logger
+
+
+@register_capability("lens")
+class LensCapability(BaseCapability):
+    """
+    Provides schema and services for enabling and configuring lens (jq) components.
+    """
+
+    def __init__(self, config: Any | None = None) -> None:
+        super().__init__(config)
+        self._config = config
+
+    @property
+    def is_enabled(self) -> bool:
+        if self._config and hasattr(self._config, "lens_enabled"):
+            return self._config.lens_enabled
+        return True
+
+    def jq(self, query: str, input_data: Any) -> CtyValue:
+        """
+        Executes a JQ query and converts the raw Python result to a CtyValue.
+        """
+        logger.debug(
+            "⚙️ LENS-JQ ✅ Applying jq query via LensCapability service", query=query
+        )
+        try:
+            # THE FIX: Use the correct `compile(...).transform(...)` API.
+            compiled_query = jq.compile(query)
+            final_raw_result = compiled_query.transform(input_data)
+
+            inferred_type = infer_cty_type_from_raw(final_raw_result)
+            return inferred_type.validate(final_raw_result)
+        except Exception as e:
+            logger.error(
+                "⚙️ LENS-JQ ❌ JQ processing failed in capability",
+                error=str(e),
+                exc_info=True,
+            )
+            raise FunctionError(f"jq query failed: {e}") from e
+
+    @staticmethod
+    def get_schema_contribution() -> dict[str, PvsAttribute]:
+        return {
+            "lens_enabled": a_bool(
+                optional=True,
+                default=True,
+                description="Enables or disables all lens (jq) related components.",
+            ),
+            "lens_jq_path": a_str(
+                optional=True,
+                description="Specifies a custom path to the 'jq' executable.",
+            ),
+        }
+
+
+# 🔍👁️🛠️

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/__init__.py

@@ -0,0 +1,26 @@
+#
+# pyvider/components/data_sources/__init__.py
+#
+
+# pyvider/components/data_sources/__init__.py
+"""
+Pyvider Data Sources Components
+==============================
+This package contains all data source components that are automatically discovered
+and registered by the Pyvider framework.
+
+Components in this package must use the @register_data_source decorator.
+"""
+
+# This file intentionally contains no explicit imports.
+# All data source components are discovered automatically by scanning this package.
+
+__all__ = [
+    # No explicit exports - autodiscovery handles registration
+]
+
+# Metadata for the autodiscovery system
+__component_type__ = "data_source"
+__autodiscovery__ = True
+
+# 📦🚀🐍

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/env_variables.garnish/docs/env_variables.tmpl.md

@@ -0,0 +1,15 @@
+---
+page_title: "DataSource: pyvider_env_variables"
+description: |-
+  {{ schema.description or "Provides a pyvider_env_variables DataSource." }}
+---
+
+# pyvider_env_variables (DataSource)
+
+{{ schema.description or "Provides a pyvider_env_variables DataSource." }}
+
+{{ example("example") }}
+
+## Argument Reference
+
+{{ schema() }}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/env_variables.garnish/docs/pyvider_env_variables.tmpl.md

@@ -0,0 +1,17 @@
+---
+page_title: "Data Source: pyvider_env_variables"
+description: |-
+  Terraform data source for pyvider_env_variables
+---
+
+# pyvider_env_variables (Data Source)
+
+Terraform data source for pyvider_env_variables
+
+## Example Usage
+
+{{ example("example") }}
+
+## Argument Reference
+
+{{ schema() }}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/env_variables.garnish/examples/example.tf

@@ -0,0 +1,8 @@
+data "pyvider_env_variables" "example" {
+  # Configuration options here
+}
+
+output "example_data" {
+  description = "Data from pyvider_env_variables"
+  value       = data.pyvider_env_variables.example
+}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/env_variables.py

@@ -0,0 +1,138 @@
+#
+# pyvider/components/data_sources/env_variables.py
+#
+
+import os
+import re
+from typing import cast
+
+import attrs
+
+from pyvider.data_sources.base import BaseDataSource
+from pyvider.data_sources.decorators import register_data_source
+from pyvider.exceptions import DataSourceError
+from pyvider.resources.context import ResourceContext
+from pyvider.schema import PvsSchema, a_bool, a_list, a_map, a_str, s_data_source
+
+
+@attrs.define(frozen=True)
+class EnvVariablesConfig:
+    keys: list[str] | None = None
+    prefix: str | None = None
+    regex: str | None = None
+    exclude_empty: bool | None = None
+    transform_keys: str | None = None
+    transform_values: str | None = None
+    case_sensitive: bool | None = None
+    sensitive_keys: list[str] | None = None
+
+
+@attrs.define(frozen=True)
+class EnvVariablesState:
+    values: dict[str, str] = attrs.field(factory=dict)
+    sensitive_values: dict[str, str] = attrs.field(factory=dict)
+    all_values: dict[str, str] = attrs.field(factory=dict)
+    all_environment: dict[str, str] = attrs.field(factory=dict)
+
+
+@register_data_source("pyvider_env_variables")
+class EnvVariablesDataSource(
+    BaseDataSource["pyvider_env_variables", EnvVariablesState, EnvVariablesConfig]
+):
+    config_class = EnvVariablesConfig
+    state_class = EnvVariablesState
+
+    @classmethod
+    def get_schema(cls) -> PvsSchema:
+        return s_data_source(
+            attributes={
+                "keys": a_list(a_str(), optional=True),
+                "prefix": a_str(optional=True),
+                "regex": a_str(optional=True),
+                "exclude_empty": a_bool(optional=True, default=True),
+                "transform_keys": a_str(optional=True),
+                "transform_values": a_str(optional=True),
+                "case_sensitive": a_bool(optional=True, default=True),
+                "sensitive_keys": a_list(a_str(), optional=True),
+                "values": a_map(a_str(), computed=True),
+                "sensitive_values": a_map(a_str(), computed=True, sensitive=True),
+                "all_values": a_map(a_str(), computed=True),
+                "all_environment": a_map(a_str(), computed=True),
+            }
+        )
+
+    async def _validate_config(self, config: EnvVariablesConfig) -> list[str]:
+        if (
+            sum(1 for v in [config.keys, config.prefix, config.regex] if v is not None)
+            > 1
+        ):
+            return ["Only one of 'keys', 'prefix', or 'regex' can be specified."]
+        return []
+
+    async def read(self, ctx: ResourceContext) -> EnvVariablesState:
+        if not ctx.config:
+            raise DataSourceError("Configuration is required.")
+        config = cast(EnvVariablesConfig, ctx.config)
+        exclude_empty = config.exclude_empty is not False
+        case_sensitive = config.case_sensitive is not False
+        source_vars = os.environ.copy()
+        filtered_vars = {}
+        if config.keys is not None:
+            for key in config.keys:
+                if (value := source_vars.get(key)) is not None:
+                    if exclude_empty and not value:
+                        continue
+                    filtered_vars[key] = value
+        elif config.prefix is not None:
+            prefix_to_match = config.prefix if case_sensitive else config.prefix.lower()
+            for key, value in source_vars.items():
+                key_to_check = key if case_sensitive else key.lower()
+                if key_to_check.startswith(prefix_to_match):
+                    if exclude_empty and not value:
+                        continue
+                    filtered_vars[key] = value
+        elif config.regex is not None:
+            flags = 0 if case_sensitive else re.IGNORECASE
+            try:
+                compiled_regex = re.compile(config.regex, flags)
+                for key, value in source_vars.items():
+                    if compiled_regex.match(key):
+                        if exclude_empty and not value:
+                            continue
+                        filtered_vars[key] = value
+            except re.error as e:
+                raise DataSourceError(f"Invalid regex provided: {e}") from e
+        else:
+            for key, value in source_vars.items():
+                if exclude_empty and not value:
+                    continue
+                filtered_vars[key] = value
+        transformed_vars = {}
+        for key, value in filtered_vars.items():
+            final_key = (
+                key.upper()
+                if config.transform_keys == "upper"
+                else (key.lower() if config.transform_keys == "lower" else key)
+            )
+            final_value = (
+                value.upper()
+                if config.transform_values == "upper"
+                else (value.lower() if config.transform_values == "lower" else value)
+            )
+            transformed_vars[final_key] = final_value
+        sensitive_keys_set = set(config.sensitive_keys or [])
+        sensitive_vals = {
+            k: v for k, v in transformed_vars.items() if k in sensitive_keys_set
+        }
+        non_sensitive_vals = {
+            k: v for k, v in transformed_vars.items() if k not in sensitive_keys_set
+        }
+        return EnvVariablesState(
+            values=non_sensitive_vals,
+            sensitive_values=sensitive_vals,
+            all_values=transformed_vars,
+            all_environment=source_vars,
+        )
+
+
+# 🌍🔤📊

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/file_info.garnish/docs/file_info.tmpl.md

@@ -0,0 +1,15 @@
+---
+page_title: "DataSource: pyvider_file_info"
+description: |-
+  {{ schema.description or "Provides a pyvider_file_info DataSource." }}
+---
+
+# pyvider_file_info (DataSource)
+
+{{ schema.description or "Provides a pyvider_file_info DataSource." }}
+
+{{ example("example") }}
+
+## Argument Reference
+
+{{ schema() }}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/file_info.garnish/docs/pyvider_file_info.tmpl.md

@@ -0,0 +1,17 @@
+---
+page_title: "Data Source: pyvider_file_info"
+description: |-
+  Terraform data source for pyvider_file_info
+---
+
+# pyvider_file_info (Data Source)
+
+Terraform data source for pyvider_file_info
+
+## Example Usage
+
+{{ example("example") }}
+
+## Argument Reference
+
+{{ schema() }}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/file_info.garnish/examples/example.tf

@@ -0,0 +1,8 @@
+data "pyvider_file_info" "example" {
+  # Configuration options here
+}
+
+output "example_data" {
+  description = "Data from pyvider_file_info"
+  value       = data.pyvider_file_info.example
+}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/file_info.py

@@ -0,0 +1,138 @@
+#
+# pyvider/components/data_sources/file_info.py
+#
+
+# components/data_sources/file_info.py
+import datetime
+from pathlib import Path
+import stat
+from typing import cast
+
+import attrs
+
+from pyvider.data_sources.base import BaseDataSource
+from pyvider.data_sources.decorators import register_data_source
+from pyvider.exceptions import DataSourceError
+from pyvider.resources.context import ResourceContext
+from pyvider.schema import PvsSchema, a_bool, a_num, a_str, s_data_source
+
+
+@attrs.define(frozen=True)
+class FileInfoConfig:
+    path: str = attrs.field()
+
+
+@attrs.define(frozen=True)
+class FileInfoState:
+    path: str = attrs.field()
+    exists: bool = attrs.field(default=False)
+    size: int = attrs.field(default=0)
+    is_dir: bool = attrs.field(default=False)
+    is_file: bool = attrs.field(default=False)
+    is_symlink: bool = attrs.field(default=False)
+    modified_time: str = attrs.field(default="")
+    access_time: str = attrs.field(default="")
+    creation_time: str = attrs.field(default="")
+    permissions: str = attrs.field(default="")
+    owner: str = attrs.field(default="")
+    group: str = attrs.field(default="")
+    mime_type: str = attrs.field(default="")
+
+
+@register_data_source("pyvider_file_info")
+class FileInfoDataSource(
+    BaseDataSource["pyvider_file_info", FileInfoState, FileInfoConfig]
+):
+    config_class = FileInfoConfig
+    state_class = FileInfoState
+
+    @classmethod
+    def get_schema(cls) -> PvsSchema:
+        return s_data_source(
+            {
+                "path": a_str(required=True, description="Path to inspect."),
+                "exists": a_bool(computed=True, description="Whether path exists."),
+                "size": a_num(computed=True, description="Size in bytes."),
+                "is_dir": a_bool(computed=True, description="Is it a directory."),
+                "is_file": a_bool(computed=True, description="Is it a regular file."),
+                "is_symlink": a_bool(
+                    computed=True, description="Is it a symbolic link."
+                ),
+                "modified_time": a_str(
+                    computed=True, description="Last modification time."
+                ),
+                "access_time": a_str(computed=True, description="Last access time."),
+                "creation_time": a_str(computed=True, description="Creation time."),
+                "permissions": a_str(computed=True, description="File permissions."),
+                "owner": a_str(
+                    computed=True,
+                    description="Owner username, or numeric UID on non-Unix systems.",
+                ),
+                "group": a_str(
+                    computed=True,
+                    description="Group name, or numeric GID on non-Unix systems.",
+                ),
+                "mime_type": a_str(computed=True, description="MIME type."),
+            }
+        )
+
+    async def _validate_config(self, config: FileInfoConfig) -> list[str]:
+        return []
+
+    async def read(self, ctx: ResourceContext) -> FileInfoState:
+        if not ctx.config:
+            raise DataSourceError("Configuration is missing.")
+        config = cast(FileInfoConfig, ctx.config)
+        path = Path(config.path)
+
+        if not path.exists():
+            return FileInfoState(path=config.path, exists=False)
+
+        stat_info = path.stat()
+        owner, group = str(stat_info.st_uid), str(stat_info.st_gid)
+        try:
+            import pwd
+
+            owner = pwd.getpwuid(stat_info.st_uid).pw_name
+        except (ImportError, KeyError):
+            pass
+        try:
+            import grp
+
+            group = grp.getgrgid(stat_info.st_gid).gr_name
+        except (ImportError, KeyError):
+            pass
+
+        mime_type = ""
+        if path.is_file():
+            try:
+                import mimetypes
+
+                mime_type = mimetypes.guess_type(config.path)[0] or ""
+            except ImportError:
+                pass
+
+        return FileInfoState(
+            path=config.path,
+            exists=True,
+            size=stat_info.st_size,
+            is_dir=path.is_dir(),
+            is_file=path.is_file(),
+            is_symlink=path.is_symlink(),
+            modified_time=datetime.datetime.fromtimestamp(
+                stat_info.st_mtime, tz=datetime.UTC
+            ).isoformat(),
+            access_time=datetime.datetime.fromtimestamp(
+                stat_info.st_atime, tz=datetime.UTC
+            ).isoformat(),
+            creation_time=datetime.datetime.fromtimestamp(
+                stat_info.st_ctime, tz=datetime.UTC
+            ).isoformat(),
+            permissions=oct(stat.S_IMODE(stat_info.st_mode)),
+            owner=owner,
+            group=group,
+            mime_type=mime_type,
+        )
+
+
+# 📄ℹ️📊

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/http_api.garnish/docs/http_api.tmpl.md

@@ -0,0 +1,15 @@
+---
+page_title: "DataSource: pyvider_http_api"
+description: |-
+  {{ schema.description or "Provides a pyvider_http_api DataSource." }}
+---
+
+# pyvider_http_api (DataSource)
+
+{{ schema.description or "Provides a pyvider_http_api DataSource." }}
+
+{{ example("example") }}
+
+## Argument Reference
+
+{{ schema() }}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/http_api.garnish/docs/pyvider_http_api.tmpl.md

@@ -0,0 +1,17 @@
+---
+page_title: "Data Source: pyvider_http_api"
+description: |-
+  Terraform data source for pyvider_http_api
+---
+
+# pyvider_http_api (Data Source)
+
+Terraform data source for pyvider_http_api
+
+## Example Usage
+
+{{ example("example") }}
+
+## Argument Reference
+
+{{ schema() }}

pyvider_components-0.0.0.post1/src/pyvider/components/data_sources/http_api.garnish/examples/example.tf

@@ -0,0 +1,8 @@
+data "pyvider_http_api" "example" {
+  # Configuration options here
+}
+
+output "example_data" {
+  description = "Data from pyvider_http_api"
+  value       = data.pyvider_http_api.example
+}