kittycad.py/kittycad/models/connection.py

import datetime
from typing import Any, Dict, List, Type, TypeVar, Union

import attr
from dateutil.parser import isoparse

from ..models.cluster import Cluster
from ..models.gateway import Gateway
from ..models.jetstream import Jetstream
from ..models.leaf_node import LeafNode
from ..types import UNSET, Unset

PC = TypeVar("PC", bound="Connection")


@attr.s(auto_attribs=True)
class Connection:
    """Metadata about a pub-sub connection.

    This is mostly used for internal purposes and debugging."""  # noqa: E501

    auth_timeout: Union[Unset, int] = UNSET
    cluster: Union[Unset, Cluster] = UNSET
    config_load_time: Union[Unset, datetime.datetime] = UNSET
    connections: Union[Unset, int] = UNSET
    cores: Union[Unset, int] = UNSET
    cpu: Union[Unset, float] = UNSET
    gateway: Union[Unset, Gateway] = UNSET
    git_commit: Union[Unset, str] = UNSET
    go: Union[Unset, str] = UNSET
    gomaxprocs: Union[Unset, int] = UNSET
    host: Union[Unset, str] = UNSET
    http_base_path: Union[Unset, str] = UNSET
    http_host: Union[Unset, str] = UNSET
    http_port: Union[Unset, int] = UNSET
    http_req_stats: Union[Unset, Dict[str, int]] = UNSET
    https_port: Union[Unset, int] = UNSET
    in_bytes: Union[Unset, int] = UNSET
    in_msgs: Union[Unset, int] = UNSET
    jetstream: Union[Unset, Jetstream] = UNSET
    leaf: Union[Unset, LeafNode] = UNSET
    leafnodes: Union[Unset, int] = UNSET
    max_connections: Union[Unset, int] = UNSET
    max_control_line: Union[Unset, int] = UNSET
    max_payload: Union[Unset, int] = UNSET
    max_pending: Union[Unset, int] = UNSET
    mem: Union[Unset, int] = UNSET
    now: Union[Unset, datetime.datetime] = UNSET
    out_bytes: Union[Unset, int] = UNSET
    out_msgs: Union[Unset, int] = UNSET
    ping_interval: Union[Unset, int] = UNSET
    ping_max: Union[Unset, int] = UNSET
    port: Union[Unset, int] = UNSET
    proto: Union[Unset, int] = UNSET
    remotes: Union[Unset, int] = UNSET
    routes: Union[Unset, int] = UNSET
    server_id: Union[Unset, str] = UNSET
    server_name: Union[Unset, str] = UNSET
    slow_consumers: Union[Unset, int] = UNSET
    start: Union[Unset, datetime.datetime] = UNSET
    subscriptions: Union[Unset, int] = UNSET
    system_account: Union[Unset, str] = UNSET
    tls_timeout: Union[Unset, int] = UNSET
    total_connections: Union[Unset, int] = UNSET
    uptime: Union[Unset, str] = UNSET
    version: Union[Unset, str] = UNSET
    write_deadline: Union[Unset, int] = UNSET

    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        auth_timeout = self.auth_timeout
        if not isinstance(self.cluster, Unset):
            cluster = self.cluster
        config_load_time: Union[Unset, str] = UNSET
        if not isinstance(self.config_load_time, Unset):
            config_load_time = self.config_load_time.isoformat()
        connections = self.connections
        cores = self.cores
        cpu = self.cpu
        if not isinstance(self.gateway, Unset):
            gateway = self.gateway
        git_commit = self.git_commit
        go = self.go
        gomaxprocs = self.gomaxprocs
        host = self.host
        http_base_path = self.http_base_path
        http_host = self.http_host
        http_port = self.http_port
        http_req_stats = self.http_req_stats

        https_port = self.https_port
        in_bytes = self.in_bytes
        in_msgs = self.in_msgs
        if not isinstance(self.jetstream, Unset):
            jetstream = self.jetstream
        if not isinstance(self.leaf, Unset):
            leaf = self.leaf
        leafnodes = self.leafnodes
        max_connections = self.max_connections
        max_control_line = self.max_control_line
        max_payload = self.max_payload
        max_pending = self.max_pending
        mem = self.mem
        now: Union[Unset, str] = UNSET
        if not isinstance(self.now, Unset):
            now = self.now.isoformat()
        out_bytes = self.out_bytes
        out_msgs = self.out_msgs
        ping_interval = self.ping_interval
        ping_max = self.ping_max
        port = self.port
        proto = self.proto
        remotes = self.remotes
        routes = self.routes
        server_id = self.server_id
        server_name = self.server_name
        slow_consumers = self.slow_consumers
        start: Union[Unset, str] = UNSET
        if not isinstance(self.start, Unset):
            start = self.start.isoformat()
        subscriptions = self.subscriptions
        system_account = self.system_account
        tls_timeout = self.tls_timeout
        total_connections = self.total_connections
        uptime = self.uptime
        version = self.version
        write_deadline = self.write_deadline

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update({})
        if auth_timeout is not UNSET:
            field_dict["auth_timeout"] = auth_timeout
        if cluster is not UNSET:
            field_dict["cluster"] = cluster
        if config_load_time is not UNSET:
            field_dict["config_load_time"] = config_load_time
        if connections is not UNSET:
            field_dict["connections"] = connections
        if cores is not UNSET:
            field_dict["cores"] = cores
        if cpu is not UNSET:
            field_dict["cpu"] = cpu
        if gateway is not UNSET:
            field_dict["gateway"] = gateway
        if git_commit is not UNSET:
            field_dict["git_commit"] = git_commit
        if go is not UNSET:
            field_dict["go"] = go
        if gomaxprocs is not UNSET:
            field_dict["gomaxprocs"] = gomaxprocs
        if host is not UNSET:
            field_dict["host"] = host
        if http_base_path is not UNSET:
            field_dict["http_base_path"] = http_base_path
        if http_host is not UNSET:
            field_dict["http_host"] = http_host
        if http_port is not UNSET:
            field_dict["http_port"] = http_port
        if http_req_stats is not UNSET:
            field_dict["http_req_stats"] = http_req_stats
        if https_port is not UNSET:
            field_dict["https_port"] = https_port
        if in_bytes is not UNSET:
            field_dict["in_bytes"] = in_bytes
        if in_msgs is not UNSET:
            field_dict["in_msgs"] = in_msgs
        if jetstream is not UNSET:
            field_dict["jetstream"] = jetstream
        if leaf is not UNSET:
            field_dict["leaf"] = leaf
        if leafnodes is not UNSET:
            field_dict["leafnodes"] = leafnodes
        if max_connections is not UNSET:
            field_dict["max_connections"] = max_connections
        if max_control_line is not UNSET:
            field_dict["max_control_line"] = max_control_line
        if max_payload is not UNSET:
            field_dict["max_payload"] = max_payload
        if max_pending is not UNSET:
            field_dict["max_pending"] = max_pending
        if mem is not UNSET:
            field_dict["mem"] = mem
        if now is not UNSET:
            field_dict["now"] = now
        if out_bytes is not UNSET:
            field_dict["out_bytes"] = out_bytes
        if out_msgs is not UNSET:
            field_dict["out_msgs"] = out_msgs
        if ping_interval is not UNSET:
            field_dict["ping_interval"] = ping_interval
        if ping_max is not UNSET:
            field_dict["ping_max"] = ping_max
        if port is not UNSET:
            field_dict["port"] = port
        if proto is not UNSET:
            field_dict["proto"] = proto
        if remotes is not UNSET:
            field_dict["remotes"] = remotes
        if routes is not UNSET:
            field_dict["routes"] = routes
        if server_id is not UNSET:
            field_dict["server_id"] = server_id
        if server_name is not UNSET:
            field_dict["server_name"] = server_name
        if slow_consumers is not UNSET:
            field_dict["slow_consumers"] = slow_consumers
        if start is not UNSET:
            field_dict["start"] = start
        if subscriptions is not UNSET:
            field_dict["subscriptions"] = subscriptions
        if system_account is not UNSET:
            field_dict["system_account"] = system_account
        if tls_timeout is not UNSET:
            field_dict["tls_timeout"] = tls_timeout
        if total_connections is not UNSET:
            field_dict["total_connections"] = total_connections
        if uptime is not UNSET:
            field_dict["uptime"] = uptime
        if version is not UNSET:
            field_dict["version"] = version
        if write_deadline is not UNSET:
            field_dict["write_deadline"] = write_deadline

        return field_dict

    @classmethod
    def from_dict(cls: Type[PC], src_dict: Dict[str, Any]) -> PC:
        d = src_dict.copy()
        auth_timeout = d.pop("auth_timeout", UNSET)

        _cluster = d.pop("cluster", UNSET)
        cluster: Union[Unset, Cluster]
        if isinstance(_cluster, Unset):
            cluster = UNSET
        else:
            cluster = _cluster  # type: ignore[arg-type]

        _config_load_time = d.pop("config_load_time", UNSET)
        config_load_time: Union[Unset, datetime.datetime]
        if isinstance(_config_load_time, Unset):
            config_load_time = UNSET
        else:
            config_load_time = isoparse(_config_load_time)

        connections = d.pop("connections", UNSET)

        cores = d.pop("cores", UNSET)

        cpu = d.pop("cpu", UNSET)

        _gateway = d.pop("gateway", UNSET)
        gateway: Union[Unset, Gateway]
        if isinstance(_gateway, Unset):
            gateway = UNSET
        else:
            gateway = _gateway  # type: ignore[arg-type]

        git_commit = d.pop("git_commit", UNSET)

        go = d.pop("go", UNSET)

        gomaxprocs = d.pop("gomaxprocs", UNSET)

        host = d.pop("host", UNSET)

        http_base_path = d.pop("http_base_path", UNSET)

        http_host = d.pop("http_host", UNSET)

        http_port = d.pop("http_port", UNSET)

        http_req_stats = d.pop("http_req_stats", UNSET)

        https_port = d.pop("https_port", UNSET)

        in_bytes = d.pop("in_bytes", UNSET)

        in_msgs = d.pop("in_msgs", UNSET)

        _jetstream = d.pop("jetstream", UNSET)
        jetstream: Union[Unset, Jetstream]
        if isinstance(_jetstream, Unset):
            jetstream = UNSET
        else:
            jetstream = _jetstream  # type: ignore[arg-type]

        _leaf = d.pop("leaf", UNSET)
        leaf: Union[Unset, LeafNode]
        if isinstance(_leaf, Unset):
            leaf = UNSET
        else:
            leaf = _leaf  # type: ignore[arg-type]

        leafnodes = d.pop("leafnodes", UNSET)

        max_connections = d.pop("max_connections", UNSET)

        max_control_line = d.pop("max_control_line", UNSET)

        max_payload = d.pop("max_payload", UNSET)

        max_pending = d.pop("max_pending", UNSET)

        mem = d.pop("mem", UNSET)

        _now = d.pop("now", UNSET)
        now: Union[Unset, datetime.datetime]
        if isinstance(_now, Unset):
            now = UNSET
        else:
            now = isoparse(_now)

        out_bytes = d.pop("out_bytes", UNSET)

        out_msgs = d.pop("out_msgs", UNSET)

        ping_interval = d.pop("ping_interval", UNSET)

        ping_max = d.pop("ping_max", UNSET)

        port = d.pop("port", UNSET)

        proto = d.pop("proto", UNSET)

        remotes = d.pop("remotes", UNSET)

        routes = d.pop("routes", UNSET)

        server_id = d.pop("server_id", UNSET)

        server_name = d.pop("server_name", UNSET)

        slow_consumers = d.pop("slow_consumers", UNSET)

        _start = d.pop("start", UNSET)
        start: Union[Unset, datetime.datetime]
        if isinstance(_start, Unset):
            start = UNSET
        else:
            start = isoparse(_start)

        subscriptions = d.pop("subscriptions", UNSET)

        system_account = d.pop("system_account", UNSET)

        tls_timeout = d.pop("tls_timeout", UNSET)

        total_connections = d.pop("total_connections", UNSET)

        uptime = d.pop("uptime", UNSET)

        version = d.pop("version", UNSET)

        write_deadline = d.pop("write_deadline", UNSET)

        connection = cls(
            auth_timeout=auth_timeout,
            cluster=cluster,
            config_load_time=config_load_time,
            connections=connections,
            cores=cores,
            cpu=cpu,
            gateway=gateway,
            git_commit=git_commit,
            go=go,
            gomaxprocs=gomaxprocs,
            host=host,
            http_base_path=http_base_path,
            http_host=http_host,
            http_port=http_port,
            http_req_stats=http_req_stats,
            https_port=https_port,
            in_bytes=in_bytes,
            in_msgs=in_msgs,
            jetstream=jetstream,
            leaf=leaf,
            leafnodes=leafnodes,
            max_connections=max_connections,
            max_control_line=max_control_line,
            max_payload=max_payload,
            max_pending=max_pending,
            mem=mem,
            now=now,
            out_bytes=out_bytes,
            out_msgs=out_msgs,
            ping_interval=ping_interval,
            ping_max=ping_max,
            port=port,
            proto=proto,
            remotes=remotes,
            routes=routes,
            server_id=server_id,
            server_name=server_name,
            slow_consumers=slow_consumers,
            start=start,
            subscriptions=subscriptions,
            system_account=system_account,
            tls_timeout=tls_timeout,
            total_connections=total_connections,
            uptime=uptime,
            version=version,
            write_deadline=write_deadline,
        )

        connection.additional_properties = d
        return connection

    @property
    def additional_keys(self) -> List[str]:
        return list(self.additional_properties.keys())

    def __getitem__(self, key: str) -> Any:
        return self.additional_properties[key]

    def __setitem__(self, key: str, value: Any) -> None:
        self.additional_properties[key] = value

    def __delitem__(self, key: str) -> None:
        del self.additional_properties[key]

    def __contains__(self, key: str) -> bool:
        return key in self.additional_properties