atlas-init 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

atlas_init/tf_ext/gen_resource_main.py

@@ -0,0 +1,195 @@
+import logging
+from dataclasses import fields
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Iterable
+
+from ask_shell import run_and_wait
+
+from atlas_init.tf_ext.models_module import ModuleGenConfig, ResourceAbs, ResourceGenConfig
+from atlas_init.tf_ext.schema_to_dataclass import ResourceTypePythonModule
+
+logger = logging.getLogger(__name__)
+
+
+def local_name_varsx(resource_type: str) -> str:
+    return f"{resource_type}_varsx"
+
+
+def local_name_vars(resource_type: str) -> str:
+    return f"{resource_type}_vars"
+
+
+def locals_def(module: ResourceTypePythonModule) -> str:
+    base_defs = "\n".join(f"        {name} = var.{name}" for name in module.base_field_names_not_computed)
+    if extras := module.extra_fields_names:
+        extra_defs = "\n".join(f"        {name} = var.{name}" for name in extras)
+        base_def = f"    {local_name_varsx(module.resource_type)} = {{\n{base_defs}\n    }}"
+        extra_def = f"\n    {local_name_vars(module.resource_type)} = {{\n{extra_defs}\n    }}"
+    else:
+        base_def = f"    {local_name_vars(module.resource_type)} = {{\n{base_defs}\n    }}"
+        extra_def = ""
+    return f"""
+locals {{
+    {base_def}{extra_def}
+}}
+"""
+
+
+def data_external(module: ResourceTypePythonModule, config: ModuleGenConfig) -> str:
+    input_json_parts = [
+        f"local.{local_name_vars(module.resource_type)}",
+    ]
+    if module.extra_fields_names:
+        input_json_parts.append(f"local.{local_name_varsx(module.resource_type)}")
+    if extras := config.inputs_json_hcl_extras:
+        input_json_parts.extend(extras)
+    inputs_json_merge = input_json_parts[0] if len(input_json_parts) == 1 else f"merge({', '.join(input_json_parts)})"
+    return f"""
+data "external" "{module.resource_type}" {{
+    program = ["python3", "${{path.module}}/{module.resource_type}.py"]
+    query = {{
+        input_json = jsonencode({inputs_json_merge})
+    }}
+}}
+"""
+
+
+def resource_declare_direct(py_module: ResourceTypePythonModule, config: ResourceGenConfig) -> str:
+    parent_cls = py_module.resource
+    resource_type = py_module.resource_type
+    assert parent_cls, f"{resource_type} does not have a resource"
+    field_base = f"var.{resource_type}." if config.use_single_variable else "var."
+    field_values = "\n".join(
+        _field_value(parent_cls, name, field_base) for name in py_module.base_field_names_not_computed
+    )
+
+    return f"""
+resource "{py_module.resource_type}" "this" {{
+{field_values}
+}}
+"""
+
+
+def _field_value(parent_cls: type[ResourceAbs], field_name: str, field_base: str = "var.") -> str:
+    if ResourceAbs.is_computed_only(field_name, parent_cls):
+        return ""
+    this_indent = "  "
+    if ResourceAbs.is_block(field_name, parent_cls):
+        return "\n".join(f"{this_indent}{line}" for line in _handle_dynamic(parent_cls, field_name, field_base))
+    return this_indent + f"{field_name} = {field_base}{field_name}"
+
+
+def _handle_dynamic(
+    parent_cls: type[ResourceAbs], dynamic_field_name: str, existing_ref: str = "var."
+) -> Iterable[str]:
+    try:
+        container_type = next(
+            t for name, t in ResourceTypePythonModule.container_types(parent_cls) if name == dynamic_field_name
+        )
+    except StopIteration:
+        raise ValueError(f"Could not find container type for field {dynamic_field_name} in {parent_cls}")
+    hcl_ref = f"{dynamic_field_name}.value."
+    yield f'dynamic "{dynamic_field_name}" {{'
+    ref = existing_ref + dynamic_field_name
+    if container_type.is_list or container_type.is_set:
+        if container_type.is_optional:
+            yield f"  for_each = {ref} == null ? [] : {ref}"
+        else:
+            yield f"  for_each = {ref}"
+    elif container_type.is_dict:
+        raise NotImplementedError(f"Dict not supported for {dynamic_field_name} in {parent_cls}")
+    else:  # singular
+        if container_type.is_optional:
+            yield f"  for_each = {ref} == null ? [] : [{ref}]"
+        else:
+            yield f"  for_each = [{ref}]"
+    yield "  content {"
+    yield from [f"    {line}" for line in _nested_fields(container_type.type, hcl_ref)]
+    yield "  }"
+    yield "}"
+
+
+def _nested_fields(cls: type[ResourceAbs], hcl_ref: str) -> Iterable[str]:
+    for field in fields(cls):
+        field_name = field.name
+        if ResourceAbs.is_computed_only(field_name, cls):
+            continue
+        if ResourceAbs.is_block(field_name, cls):
+            yield from _handle_dynamic(cls, field_name, hcl_ref)
+        else:
+            yield _field_value(cls, field_name, hcl_ref)
+
+
+def resource_declare(
+    resource_type: str, required_fields: set[str], nested_fields: set[str], field_names: list[str]
+) -> str:
+    def output_field(field_name: str) -> str:
+        return f"data.external.{resource_type}.result.{field_name}"
+
+    def as_output_field(field_name: str) -> str:
+        if field_name in nested_fields:
+            if field_name in required_fields:
+                return f"jsondecode({output_field(field_name)})"
+            return f'{output_field(field_name)} == "" ? null : jsondecode({output_field(field_name)})'
+        if field_name in required_fields:
+            return output_field(field_name)
+        return f'{output_field(field_name)} == "" ? null : {output_field(field_name)}'
+
+    required = [f"    {field_name} = {as_output_field(field_name)}" for field_name in sorted(required_fields)]
+    non_required = [
+        f"    {field_name} = {as_output_field(field_name)}"
+        for field_name in sorted(field_names)
+        if field_name not in required_fields
+    ]
+    return f"""
+resource "{resource_type}" "this" {{
+    lifecycle {{
+        precondition {{
+            condition = length({output_field("error_message")}) == 0
+            error_message = {output_field("error_message")}
+        }}
+    }}
+
+{"\n".join(required)}
+{"\n".join(non_required)}
+}}
+"""
+
+
+def format_tf_content(content: str) -> str:
+    with TemporaryDirectory() as tmp_dir:
+        tmp_file = Path(tmp_dir) / "content.tf"
+        tmp_file.write_text(content)
+        try:
+            run_and_wait("terraform fmt .", cwd=tmp_dir)
+        except Exception as e:
+            logger.error(f"Failed to format tf content:\n{content}")
+            raise e
+        return tmp_file.read_text()
+
+
+def generate_resource_main(python_module: ResourceTypePythonModule, config: ModuleGenConfig) -> str:
+    resource = python_module.resource_ext or python_module.resource
+    assert resource, f"{python_module} does not have a resource"
+    resource_hcl = (
+        resource_declare_direct(python_module, config.resource_config(python_module.resource_type))
+        if config.skip_python
+        else resource_declare(
+            resource_type=python_module.resource_type,
+            required_fields=resource.REQUIRED_ATTRIBUTES,
+            nested_fields=resource.NESTED_ATTRIBUTES,
+            field_names=python_module.base_field_names_not_computed,
+        )
+    )
+    return format_tf_content(
+        "\n".join(
+            [
+                *([] if config.skip_python else [locals_def(python_module)]),
+                *([] if config.skip_python else [data_external(python_module, config)]),
+                "",
+                resource_hcl,
+                "",
+            ]
+        )
+    )

atlas_init/tf_ext/gen_resource_output.py

@@ -0,0 +1,71 @@
+from dataclasses import fields
+from typing import Iterable
+from atlas_init.tf_ext.models_module import ContainerType, ResourceTypePythonModule, ModuleGenConfig, ResourceAbs
+
+
+def as_output(resource_type: str, field_name: str, output_name: str) -> str:
+    return _as_output(output_name, f"{resource_type}.this.{field_name}")
+
+
+def _as_output(name: str, value: str) -> str:
+    return f"""\
+output "{name}" {{
+    value = {value}
+}}
+"""
+
+
+def as_nested_output(
+    resource_type: str,
+    parent_cls: type[ResourceAbs],
+    nested_types: dict[str, ContainerType[ResourceAbs]],
+    config: ModuleGenConfig,
+) -> Iterable[str]:
+    resource_id = f"{resource_type}.this"
+    for field_name, container_type in nested_types.items():
+        if container_type.is_any:
+            continue
+        computed_nested_fields = [
+            nested_field.name
+            for nested_field in fields(container_type.type)
+            if ResourceAbs.is_computed_only(nested_field.name, container_type.type)
+        ]
+        if container_type.is_list:
+            for computed_field_name in computed_nested_fields:
+                if container_type.is_optional and not ResourceAbs.is_required(field_name, parent_cls):
+                    yield _as_output(
+                        config.output_name(resource_type, field_name, computed_field_name),
+                        f"{resource_id}.{field_name} == null ? null : {resource_id}.{field_name}[*].{computed_field_name}",
+                    )
+                else:
+                    yield _as_output(
+                        config.output_name(resource_type, field_name, computed_field_name),
+                        f"{resource_id}.{field_name}[*].{computed_field_name}",
+                    )
+        elif container_type.is_set:
+            continue  # block type "limits" is represented by a set of objects, and set elements do not have addressable keys. To find elements matching specific criteria, use a "for" expression with an "if" clause.
+        elif container_type.is_dict or container_type.is_set:
+            raise NotImplementedError("Dict and set container types not supported yet")
+        else:
+            for computed_field_name in computed_nested_fields:
+                if container_type.is_optional and not ResourceAbs.is_required(field_name, parent_cls):
+                    yield _as_output(
+                        config.output_name(resource_type, field_name, computed_field_name),
+                        f"{resource_id}.{field_name} == null ? null : {resource_id}.{field_name}.{computed_field_name}",
+                    )
+                else:
+                    yield _as_output(
+                        config.output_name(resource_type, field_name, computed_field_name),
+                        f"{resource_id}.{field_name}.{computed_field_name}",
+                    )
+
+
+def generate_resource_output(py_module: ResourceTypePythonModule, config: ModuleGenConfig) -> str:
+    nested_types = dict(py_module.nested_field_types)
+    base_resource = py_module.resource
+    assert base_resource is not None, f"Resource {py_module.resource_type} has no base resource"
+    computed_field_names = [name for name in py_module.base_field_names_computed if name not in nested_types]
+    return "\n".join(
+        as_output(py_module.resource_type, field_name, config.output_name(py_module.resource_type, field_name))
+        for field_name in computed_field_names
+    ) + "\n".join(as_nested_output(py_module.resource_type, base_resource, nested_types, config))

atlas_init/tf_ext/gen_resource_variables.py

@@ -0,0 +1,159 @@
+import logging
+from contextlib import contextmanager
+from dataclasses import Field, fields, is_dataclass
+from typing import Dict, List, Set, Union, get_args, get_origin, get_type_hints
+
+from model_lib import Entity
+from pydantic import Field as PydanticField
+
+from atlas_init.tf_ext.gen_resource_main import format_tf_content
+from atlas_init.tf_ext.models_module import ResourceAbs, ResourceGenConfig, ResourceTypePythonModule
+
+logger = logging.getLogger(__name__)
+
+
+class DefaultValueContext(Entity):
+    default_lines: list[str] = PydanticField(default_factory=list)
+    field_path: list[str] = PydanticField(default_factory=list)
+    ignored_names: set[str] = PydanticField(default_factory=set)
+
+    @property
+    def final_str(self) -> str:
+        if not self.default_lines:
+            return "null"
+        return "\n".join(self.default_lines)
+
+    @property
+    def current_field_path(self) -> str:
+        return ".".join(self.field_path)
+
+    def at_root(self, field_name: str) -> bool:
+        return field_name == self.current_field_path
+
+    @property
+    def _prefix(self) -> str:
+        return "  " * len(self.field_path)
+
+    @contextmanager
+    def add_nested_field(self, field_name: str):
+        if not self.at_root(field_name):
+            self.field_path.append(field_name)
+        default_index_before = len(self.default_lines)
+        try:
+            yield
+            default_index_after = len(self.default_lines)
+            if (
+                default_index_before == default_index_after
+            ):  # no child had a default, so we don't need to add default lines
+                return
+            if self.at_root(field_name):
+                self.default_lines.insert(default_index_before, "{")
+            else:
+                self.default_lines.insert(default_index_before, f"{self._prefix}{field_name} = {{")
+            self.default_lines.append(f"{self._prefix}}}")
+        finally:
+            self.field_path.pop()
+
+    def add_default(self, field_name: str, default_value: str) -> None:
+        if self.at_root(field_name):  # root field default value, no field name needed
+            self.default_lines.append(default_value)
+        else:
+            self.default_lines.append(f"{self._prefix}{field_name} = {default_value}")
+
+
+def python_type_to_terraform_type(field: Field, py_type: type, context: DefaultValueContext) -> str:
+    # Unwrap Optional/Union
+    origin = get_origin(py_type)
+    args = get_args(py_type)
+    if origin is Union and type(None) in args:
+        # Optional[X] or Union[X, None] -> X
+        not_none = [a for a in args if a is not type(None)]
+        return python_type_to_terraform_type(field, not_none[0], context) if not_none else "any"
+    if origin is list or origin is List:
+        elem_type = python_type_to_terraform_type(field, args[0], context)
+        return f"list({elem_type})"
+    elif origin is set or origin is Set:
+        elem_type = python_type_to_terraform_type(field, args[0], context)
+        return f"set({elem_type})"
+    elif origin is dict or origin is Dict:
+        elem_type = python_type_to_terraform_type(field, args[1], context)
+        return f"map({elem_type})"
+    elif is_dataclass(py_type):
+        return dataclass_to_object_type(field.name, py_type, context)
+    elif py_type is str:
+        return "string"
+    elif py_type is int or py_type is float:
+        return "number"
+    elif py_type is bool:
+        return "bool"
+    else:
+        return "any"
+
+
+def dataclass_to_object_type(name: str, cls: type, context: DefaultValueContext) -> str:
+    lines = ["object({"]
+    hints = get_type_hints(cls)
+    with context.add_nested_field(name):
+        for f in fields(cls):
+            # Skip ClassVars and internal fields
+            nested_field_name = f.name
+            is_computed_only = ResourceAbs.is_computed_only(nested_field_name, cls)
+            if is_computed_only or nested_field_name in context.ignored_names:
+                continue
+            tf_type = python_type_to_terraform_type(f, hints[nested_field_name], context)
+            is_required = ResourceAbs.is_required(nested_field_name, cls)
+            if default_value := ResourceAbs.default_hcl_string(nested_field_name, cls):
+                context.add_default(nested_field_name, default_value)
+                lines.append(f"  {nested_field_name} = optional({tf_type}, {default_value})")
+            elif is_required:
+                lines.append(f"  {nested_field_name} = {tf_type}")
+            else:
+                lines.append(f"  {nested_field_name} = optional({tf_type})")
+        lines.append("})")
+    return "\n".join(lines)
+
+
+def generate_module_variables(
+    python_module: ResourceTypePythonModule, resource_config: ResourceGenConfig
+) -> tuple[str, str]:
+    base_resource = python_module.resource
+    assert base_resource is not None, f"{python_module} does not have a resource"
+    skipped_names_in_resource_ext = set(python_module.base_field_names)
+    return generate_resource_variables(base_resource, resource_config), generate_resource_variables(
+        python_module.resource_ext, resource_config, skipped_names_in_resource_ext
+    )
+
+
+def generate_resource_variables(
+    resource: type[ResourceAbs] | None, resource_config: ResourceGenConfig, extra_skipped: set[str] | None = None
+) -> str:
+    extra_skipped = extra_skipped or set()
+    required_variables = resource_config.required_variables
+    if resource is None:
+        return ""
+    out = []
+    hints = get_type_hints(resource)
+    ignored_names = (
+        resource_config.skip_variables_extra
+        | resource.COMPUTED_ONLY_ATTRIBUTES
+        | getattr(resource, ResourceAbs.SKIP_VARIABLES_NAME, set())
+        | extra_skipped
+    )
+    if resource_config.use_single_variable:
+        context = DefaultValueContext(field_path=[], ignored_names=ignored_names)
+        tf_type = dataclass_to_object_type(resource_config.name, resource, context)
+        return format_tf_content(f'''variable "{resource_config.name}" {{
+  type     = {tf_type}
+}}\n''')
+    for f in fields(resource):  # type: ignore
+        field_name = f.name
+        if field_name.isupper() or field_name in ignored_names:
+            continue
+        context = DefaultValueContext(field_path=[field_name])
+        tf_type = python_type_to_terraform_type(f, hints[field_name], context)
+        default_line = f"\n  default  = {context.final_str}" if field_name not in required_variables else ""
+        nullable_line = "\n  nullable = true" if field_name not in required_variables else ""
+        out.append(f'''variable "{field_name}" {{
+  type     = {tf_type}{nullable_line}{default_line}
+}}\n''')
+    return format_tf_content("\n".join(out))

atlas_init/tf_ext/gen_versions.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+from atlas_init.tf_ext.provider_schema import get_providers_tf
+from zero_3rdparty.file_utils import ensure_parents_write_text
+
+
+def dump_versions_tf(module_path: Path, skip_python: bool = False, minimal: bool = False) -> Path:
+    provider_path = module_path / "versions.tf"
+    if not provider_path.exists():
+        ensure_parents_write_text(provider_path, get_providers_tf(skip_python=skip_python, minimal=minimal))
+    return provider_path