docs_utils.py

import tempfile
from pathlib import Path

from python_on_whales import docker
from python_on_whales.exceptions import DockerException


def write_code(i: int, attribute_access: str, value) -> str:
    string = f"""In [{i}]: super_print({attribute_access})
type = {type(value)}, value = {value}
"""
    return string


def generate_code_demo_networks() -> str:
    result = []

    network = docker.network.create("my-network")
    with network:
        container = docker.run(
            "ubuntu",
            ["sleep", "infinity"],
            name="my_ubuntu",
            detach=True,
            networks=[network],
            remove=True,
        )
        with container:
            to_evaluate = [
                "network.name",
                "network.id",
                "network.created",
                "network.scope",
                "network.driver",
                "network.enable_ipv6",
                "network.ipam.driver",
                "network.ipam.config",
                "network.ipam.options",
                "network.internal",
                "network.attachable",
                "network.ingress",
                "network.containers",
                "network.options",
                "network.labels",
                "network.config_from",
                "network.config_only",
            ]

            for i, attribute_access in enumerate(to_evaluate):
                value = eval(attribute_access)
                result.append(write_code(i + 5, attribute_access, value))

    return "\n".join(result)


def generate_code_demo_nodes() -> str:
    result = []

    docker.swarm.init()
    node = docker.node.list()[0]
    print(node.id)

    to_evaluate = [
        "node.id",
        "node.version.index",
        "node.created_at",
        "node.updated_at",
        "node.spec.name",
        "node.spec.labels",
        "node.spec.role",
        "node.spec.availability",
        "node.description.hostname",
        "node.description.platform.architecture",
        "node.description.platform.os",
        "node.description.resources.nano_cpus",
        "node.description.resources.memory_bytes",
        "node.description.resources.generic_resources",
        "node.description.engine.engine_version",
        "node.description.engine.labels",
        "node.description.engine.plugins",
        "node.description.tls_info.trust_root",
        "node.description.tls_info.cert_issuer_subject",
        "node.description.tls_info.cert_issuer_public_key",
        "node.status.state",
        "node.status.message",
        "node.status.addr",
        "node.manager_status.leader",
        "node.manager_status.reachability",
        "node.manager_status.addr",
    ]

    for i, attribute_access in enumerate(to_evaluate):
        value = eval(attribute_access)
        result.append(write_code(i + 4, attribute_access, value))

    docker.swarm.leave(force=True)

    return "\n".join(result)


def generate_code_demo_services() -> str:
    result = []

    docker.swarm.init()
    service = docker.service.create("busybox", ["ping", "www.google.com"])
    print(service.id)

    to_evaluate = [
        "service.id",
        "service.version",
        "service.created_at",
        "service.updated_at",
        "service.spec.name",
        "service.spec.labels",
        "service.spec.mode",
        "service.spec.update_config",
        "service.spec.rollback_config",
        "service.spec.task_template.container_spec.image",
        "service.spec.task_template.container_spec.labels",
        "service.spec.task_template.container_spec.privileges",
        "service.spec.task_template.container_spec.stop_grace_period",
        "service.spec.task_template.container_spec.isolation",
        "service.spec.task_template.container_spec.env",
        "service.spec.task_template.resources.limits",
        "service.spec.task_template.resources.reservations",
        "service.previous_spec",
        "service.endpoint.spec",
        "service.endpoint.ports",
        "service.endpoint.virtual_ips",
        "service.update_status",
    ]

    for i, attribute_access in enumerate(to_evaluate):
        value = eval(attribute_access)
        result.append(write_code(i + 4, attribute_access, value))

    docker.swarm.leave(force=True)

    return "\n".join(result)


def generate_code_demo_configs() -> str:
    result = []

    docker.swarm.init()

    with tempfile.TemporaryDirectory() as tmp_dir:
        config_file = Path(tmp_dir) / "file.conf"
        config_file.write_text("Hello world!")
        config = docker.config.create(
            "my_config", config_file, labels=dict(hello="world")
        )
        print(config.id)

        to_evaluate = [
            "config.id",
            "config.version.index",
            "config.created_at",
            "config.updated_at",
            "config.spec.name",
            "config.spec.labels",
            "config.spec.data",
            "config.spec.templating",
        ]
        for i, attribute_access in enumerate(to_evaluate):
            value = eval(attribute_access)
            result.append(write_code(i + 4, attribute_access, value))

    docker.swarm.leave(force=True)

    return "\n".join(result)


def generate_code_demo_volumes() -> str:
    result = []

    volume = docker.volume.create()

    with volume:
        to_evaluate = [
            "volume.name",
            "volume.driver",
            "volume.mountpoint",
            "volume.created_at",
            "volume.status",
            "volume.labels",
            "volume.scope",
            "volume.options",
        ]

        for i, attribute_access in enumerate(to_evaluate):
            value = eval(attribute_access)
            result.append(write_code(i + 4, attribute_access, value))

    return "\n".join(result)


def generate_code_demo_builders() -> str:
    result = []

    builder = docker.buildx.create()

    with builder:
        to_evaluate = [
            "builder.name",
            "builder.driver",
        ]

        for i, attribute_access in enumerate(to_evaluate):
            value = eval(attribute_access)
            result.append(write_code(i + 4, attribute_access, value))

    return "\n".join(result)


def generate_code_demo_images() -> str:
    result = []

    image = docker.image._pull_if_necessary("ubuntu")
    print(f"Generating example for {image.repo_tags}")
    to_evaluate = [
        "image.id",
        "image.repo_tags",
        "image.repo_digests",
        "image.parent",
        "image.comment",
        "image.created",
        "image.container",
        "image.container_config",
        "image.docker_version",
        "image.author",
        "image.config",
        "image.architecture",
        "image.os",
        "image.os_version",
        "image.size",
        "image.virtual_size",
        "image.graph_driver.name",
        "image.graph_driver.data",
        "image.root_fs.type",
        "image.root_fs.layers",
        "image.root_fs.base_layer",
        "image.metadata",
    ]

    for i, attribute_access in enumerate(to_evaluate):
        value = eval(attribute_access)
        result.append(write_code(i + 4, attribute_access, value))

    return "\n".join(result)


def generate_code_demo_plugins() -> str:
    result = []

    try:
        plugin = docker.plugin.inspect("mochoa/s3fs-volume-plugin")
    except DockerException:
        plugin = docker.plugin.install("mochoa/s3fs-volume-plugin")

    print(f"Generating example for {plugin.name}")
    to_evaluate = [
        "plugin.id",
        "plugin.name",
        "plugin.enabled",
        "plugin.settings",
        "plugin.plugin_reference",
        "plugin.config",
    ]

    for i, attribute_access in enumerate(to_evaluate):
        value = eval(attribute_access)
        result.append(write_code(i + 4, attribute_access, value))

    return "\n".join(result)


def generate_code_demo_containers():
    result = []

    container = docker.run("ubuntu", ["sleep", "infinity"], detach=True)

    with container:
        to_evaluate = [
            "container.id",
            "container.created",
            "container.path",
            "container.args",
            "container.state.status",
            "container.state.running",
            "container.state.paused",
            "container.state.restarting",
            "container.state.oom_killed",
            "container.state.dead",
            "container.state.pid",
            "container.state.exit_code",
            "container.state.error",
            "container.state.started_at",
            "container.state.finished_at",
            "container.state.health",
            "container.image",
            "container.resolv_conf_path",
            "container.hostname_path",
            "container.hosts_path",
            "container.log_path",
            "container.node",
            "container.name",
            "container.restart_count",
            "container.driver",
            "container.platform",
            "container.mount_label",
            "container.process_label",
            "container.app_armor_profile",
            "container.exec_ids",
            "container.host_config.cpu_shares",
            "container.host_config.memory",
            "container.host_config.cgroup_parent",
            "container.host_config.blkio_weight",
            "container.host_config.blkio_weight_device",
            "container.host_config.blkio_device_read_bps",
            "container.host_config.blkio_device_write_bps",
            "container.host_config.blkio_device_read_iops",
            "container.host_config.blkio_device_write_iops",
            "container.host_config.cpu_period",
            "container.host_config.cpu_quota",
            "container.host_config.cpu_realtime_period",
            "container.host_config.cpu_realtime_runtime",
            "container.host_config.cpuset_cpus",
            "container.host_config.cpuset_mems",
            "container.host_config.devices",
            "container.host_config.device_cgroup_rules",
            "container.host_config.device_requests",
            "container.host_config.kernel_memory",
            "container.host_config.kernel_memory_tcp",
            "container.host_config.memory_reservation",
            "container.host_config.memory_swap",
            "container.host_config.memory_swappiness",
            "container.host_config.nano_cpus",
            "container.host_config.oom_kill_disable",
            "container.host_config.init",
            "container.host_config.pids_limit",
            "container.host_config.ulimits",
            "container.host_config.cpu_count",
            "container.host_config.cpu_percent",
            "container.host_config.binds",
            "container.host_config.container_id_file",
            "container.host_config.log_config.type",
            "container.host_config.log_config.config",
            "container.host_config.network_mode",
            "container.host_config.port_bindings",
            "container.host_config.restart_policy.name",
            "container.host_config.restart_policy.maximum_retry_count",
            "container.host_config.auto_remove",
            "container.host_config.volume_driver",
            "container.host_config.volumes_from",
            "container.host_config.mounts",
            "container.host_config.capabilities",
            "container.host_config.cap_add",
            "container.host_config.cap_drop",
            "container.host_config.dns",
            "container.host_config.dns_options",
            "container.host_config.dns_search",
            "container.host_config.extra_hosts",
            "container.host_config.group_add",
            "container.host_config.ipc_mode",
            "container.host_config.cgroup",
            "container.host_config.links",
            "container.host_config.oom_score_adj",
            "container.host_config.pid_mode",
            "container.host_config.privileged",
            "container.host_config.publish_all_ports",
            "container.host_config.readonly_rootfs",
            "container.host_config.security_opt",
            "container.host_config.storage_opt",
            "container.host_config.tmpfs",
            "container.host_config.uts_mode",
            "container.host_config.userns_mode",
            "container.host_config.shm_size",
            "container.host_config.sysctls",
            "container.host_config.runtime",
            "container.host_config.console_size",
            "container.host_config.isolation",
            "container.host_config.masked_paths",
            "container.host_config.readonly_paths",
            "container.graph_driver.name",
            "container.graph_driver.data",
            "container.size_rw",
            "container.size_root_fs",
            "container.mounts",
            "container.config.hostname",
            "container.config.domainname",
            "container.config.user",
            "container.config.attach_stdin",
            "container.config.attach_stdout",
            "container.config.attach_stderr",
            "container.config.exposed_ports",
            "container.config.tty",
            "container.config.open_stdin",
            "container.config.stdin_once",
            "container.config.env",
            "container.config.cmd",
            "container.config.healthcheck",
            "container.config.args_escaped",
            "container.config.image",
            "container.config.volumes",
            "container.config.working_dir",
            "container.config.entrypoint",
            "container.config.network_disabled",
            "container.config.mac_address",
            "container.config.on_build",
            "container.config.labels",
            "container.config.stop_signal",
            "container.config.stop_timeout",
            "container.config.shell",
            "container.network_settings.bridge",
            "container.network_settings.sandbox_id",
            "container.network_settings.hairpin_mode",
            "container.network_settings.link_local_ipv6_address",
            "container.network_settings.link_local_ipv6_prefix_length",
            "container.network_settings.ports",
            "container.network_settings.sandbox_key",
            "container.network_settings.secondary_ip_addresses",
            "container.network_settings.secondary_ipv6_addresses",
            "container.network_settings.endpoint_id",
            "container.network_settings.gateway",
            "container.network_settings.global_ipv6_address",
            "container.network_settings.global_ipv6_prefix_length",
            "container.network_settings.ip_address",
            "container.network_settings.ip_prefix_length",
            "container.network_settings.ipv6_gateway",
            "container.network_settings.mac_address",
            "container.network_settings.networks",
        ]

        for i, attribute_access in enumerate(to_evaluate):
            value = eval(attribute_access)
            result.append(write_code(i + 4, attribute_access, value))

    return "\n".join(result)


def add_links(text):
    text = text.replace(
        "`python_on_whales.Container`",
        "[`python_on_whales.Container`](/docker_objects/containers/)",
    )

    return text


def add_code_example(destination, markdown_file: str, code: str):
    path_file = destination / "docker_objects" / markdown_file
    path_file.write_text(path_file.read_text().replace("@INSERT_GENERATED_CODE@", code))
    print("added code example for", markdown_file)


def add_all_code_examples(destination):
    add_code_example(destination, "plugins.md", generate_code_demo_plugins())
    add_code_example(destination, "configs.md", generate_code_demo_configs())
    add_code_example(destination, "networks.md", generate_code_demo_networks())
    add_code_example(destination, "volumes.md", generate_code_demo_volumes())
    add_code_example(destination, "images.md", generate_code_demo_images())
    add_code_example(destination, "containers.md", generate_code_demo_containers())
    add_code_example(destination, "builders.md", generate_code_demo_builders())
    add_code_example(destination, "nodes.md", generate_code_demo_nodes())
    add_code_example(destination, "services.md", generate_code_demo_services())