supervisor-pydantic 1.0.0__py3-none-any.whl

supervisor_pydantic/__init__.py

@@ -0,0 +1,5 @@
+from .client import *
+from .config import *
+from .convenience import *
+
+__version__ = "1.0.0"

supervisor_pydantic/client/__init__.py

@@ -0,0 +1 @@
+from .xmlrpc import *

supervisor_pydantic/client/xmlrpc.py

@@ -0,0 +1,212 @@
+from datetime import datetime
+from enum import Enum
+from typing import Dict, List, Optional
+from xmlrpc.client import Fault, ServerProxy
+
+from pydantic import BaseModel
+
+from ..config import SupervisorConvenienceConfiguration
+
+__all__ = ("SupervisorRemoteXMLRPCClient", "ProcessState", "SupervisorState", "SupervisorMethodResult", "ProcessInfo")
+
+
+class ProcessState(Enum):
+    STOPPED = 0
+    STARTING = 10
+    RUNNING = 20
+    BACKOFF = 30
+    STOPPING = 40
+    EXITED = 100
+    FATAL = 200
+    UNKNOWN = 1000
+
+    @classmethod
+    def _missing_(cls, code):
+        if isinstance(code, str):
+            return getattr(cls, code)
+        if code not in (0, 10, 20, 30, 40, 100, 200):
+            return super().__init__(1000)
+        raise ValueError(code)
+
+
+class SupervisorState(Enum):
+    FATAL = 2
+    RUNNING = 1
+    RESTARTING = 0
+    SHUTDOWN = -1
+
+    @classmethod
+    def _missing_(cls, code):
+        if isinstance(code, str):
+            return getattr(cls, code)
+        raise ValueError(code)
+
+
+class SupervisorMethodResult(Enum):
+    # duplicated from https://github.com/Supervisor/supervisor/blob/29eeb9dd55c55da2e83c5497d01f3a859998ecf9/supervisor/xmlrpc.py
+    UNKNOWN_METHOD = 1
+    INCORRECT_PARAMETERS = 2
+    BAD_ARGUMENTS = 3
+    SIGNATURE_UNSUPPORTED = 4
+    SHUTDOWN_STATE = 6
+    BAD_NAME = 10
+    BAD_SIGNAL = 11
+    NO_FILE = 20
+    NOT_EXECUTABLE = 21
+    FAILED = 30
+    ABNORMAL_TERMINATION = 40
+    SPAWN_ERROR = 50
+    ALREADY_STARTED = 60
+    NOT_RUNNING = 70
+    SUCCESS = 80
+    ALREADY_ADDED = 90
+    STILL_RUNNING = 91
+    CANT_REREAD = 92
+
+
+class ProcessInfo(BaseModel):
+    name: str
+    group: str
+    state: ProcessState
+    description: str
+    start: datetime
+    stop: datetime
+    now: datetime
+    spawner: str = ""
+    exitstatus: int
+    logfile: str
+    stdout_logfile: str
+    stderr_logfile: str
+    pid: int
+
+    def running(self):
+        return self.state in (ProcessState.RUNNING, ProcessState.STOPPING)
+
+    def stopped(self):
+        return self.state in (ProcessState.STOPPED, ProcessState.EXITED, ProcessState.FATAL)
+
+    def done(self, ok_exitstatuses=None):
+        ok_exitstatuses = ok_exitstatuses or (0,)
+        return self.state in (ProcessState.STOPPED,) or (self.state == ProcessState.EXITED and self.exitstatus in ok_exitstatuses)
+
+    def ok(self, ok_exitstatuses=None):
+        ok_exitstatuses = ok_exitstatuses or (0,)
+        return self.state in (
+            # ProcessState.STARTING,
+            ProcessState.RUNNING,
+            ProcessState.STOPPING,
+            ProcessState.STOPPED,
+        ) or (self.state == ProcessState.EXITED and self.exitstatus in ok_exitstatuses)
+
+    def bad(self, ok_exitstatuses=None):
+        ok_exitstatuses = ok_exitstatuses or (0,)
+        return self.state in (ProcessState.FATAL, ProcessState.UNKNOWN) or (
+            self.state == ProcessState.EXITED and self.exitstatus not in ok_exitstatuses
+        )
+
+
+class SupervisorRemoteXMLRPCClient(object):
+    """A light wrapper over the supervisor xmlrpc api: http://supervisord.org/api.html"""
+
+    def __init__(self, cfg: SupervisorConvenienceConfiguration):
+        self._cfg = cfg
+        self._host = cfg.airflow.host
+        self._port = int(cfg.airflow.port.split(":")[-1])
+        self._protocol = cfg.airflow.protocol
+        self._rpcpath = "/" + cfg.airflow.rpcpath if not cfg.airflow.rpcpath.startswith("/") else cfg.airflow.rpcpath
+        self._rpcurl = self._build_rpcurl(username=cfg.airflow.username, password=cfg.airflow.password)
+        self._client = ServerProxy(self._rpcurl)
+
+    def _build_rpcurl(self, username: Optional[str], password: Optional[str]) -> str:
+        # Forces http or https based on port, otherwise resolves to given protocol
+        protocol = {80: "http", 443: "https"}.get(self._port, self._protocol)
+        port = "" if self._port in {80, 443} else f":{self._port}"
+        authentication = f"{username}:{password.get_secret_value()}@" if username and password else ""
+        return f"{protocol}://{authentication}{self._host}{port}{self._rpcpath}"
+
+    #######################
+    # supervisord methods #
+    #######################
+    def getAllProcessInfo(self) -> List[ProcessInfo]:
+        return [ProcessInfo(**_) for _ in self._client.supervisor.getAllProcessInfo()]
+
+    def getState(self):
+        return SupervisorState(self._client.supervisor.getState()["statecode"])
+
+    # def readLog(self):
+    #     return self._client.supervisor.readLog(0, 0)
+
+    def restart(self):
+        return self._client.supervisor.restart()
+
+    def shutdown(self):
+        return self._client.supervisor.shutdown()
+
+    ###################
+    # process methods #
+    ###################
+    def getProcessInfo(self, name: str):
+        if name not in self._cfg.program:
+            raise RuntimeError(f"Unknown process: {name}")
+        return ProcessInfo(**self._client.supervisor.getProcessInfo(name))
+
+    def readProcessLog(self, name: str):
+        if name not in self._cfg.program:
+            raise RuntimeError(f"Unknown process: {name}")
+        return self._client.supervisor.readProcessLog(name, 0, 0)
+
+    def readProcessStderrLog(self, name: str):
+        if name not in self._cfg.program:
+            raise RuntimeError(f"Unknown process: {name}")
+
+        return self._client.supervisor.readProcessStderrLog()
+
+    def readProcessStdoutLog(self, name: str):
+        return self._client.supervisor.readProcessStdoutLog()
+
+    def startAllProcesses(self) -> Dict[str, ProcessInfo]:
+        # start all
+        self._client.supervisor.startAllProcesses()
+        return {name: self.getProcessInfo(name) for name in self._cfg.program}
+
+    def startProcess(self, name: str) -> ProcessInfo:
+        if name not in self._cfg.program:
+            raise RuntimeError(f"Unknown process: {name}")
+        try:
+            if self._client.supervisor.startProcess(name):
+                return self.getProcessInfo(name)
+        except Fault as f:
+            if f.faultCode == SupervisorMethodResult.ALREADY_STARTED.value:
+                return self.getProcessInfo(name)
+            if f.faultCode == SupervisorMethodResult.SPAWN_ERROR.value:
+                return self.getProcessInfo(name)
+            raise f
+        return self.getProcessInfo(name)
+
+    def stopAllProcesses(self) -> Dict[str, ProcessInfo]:
+        # start all
+        self._client.supervisor.stopAllProcesses()
+        return {name: self.getProcessInfo(name) for name in self._cfg.program}
+
+    def stopProcess(self, name: str) -> ProcessInfo:
+        if name not in self._cfg.program:
+            raise RuntimeError(f"Unknown process: {name}")
+        try:
+            if self._client.supervisor.stopProcess(name):
+                return self.getProcessInfo(name)
+        except Fault as f:
+            if f.faultCode == SupervisorMethodResult.NOT_RUNNING.value:
+                return self.getProcessInfo(name)
+            raise f
+        return self.getProcessInfo(name)
+
+    # def reloadConfig(self):
+    #     return self._client.supervisor.reloadConfig()
+
+    # def signalAllProcesses(self, signal):
+    #     return self._client.supervisor.signalAllProcesses()
+
+    def signalProcess(self, name: str, signal):
+        if name not in self._cfg.program:
+            raise RuntimeError(f"Unknown process: {name}")
+        return self._client.supervisor.signalProcess()

supervisor_pydantic/config/__init__.py

@@ -0,0 +1,18 @@
+from .base import HostPort, LogLevel, Octal, OctalUmask, Signal, SupervisorLocation, UnixUserName, UnixUserNameOrGroup
+from .convenience import ConvenienceConfiguration
+from .eventlistener import EventListenerConfiguration
+from .fcgiprogram import FcgiProgramConfiguration
+from .group import GroupConfiguration
+from .include import IncludeConfiguration
+from .inet_http_server import InetHttpServerConfiguration
+from .program import ProgramConfiguration
+from .rpcinterface import RpcInterfaceConfiguration
+from .supervisor import (
+    SupervisorConfiguration,
+    SupervisorConvenienceConfiguration,
+    load_config,
+    load_convenience_config,
+)
+from .supervisorctl import SupervisorctlConfiguration
+from .supervisord import SupervisordConfiguration
+from .unix_http_server import UnixHttpServerConfiguration

supervisor_pydantic/config/base.py

@@ -0,0 +1,92 @@
+import re
+from json import loads
+from typing import Callable, Literal
+
+from pydantic import BaseModel
+from pydantic.functional_validators import AfterValidator
+from typing_extensions import Annotated
+
+_un_regex = re.compile(r"^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\$)$")
+_snake_regex = re.compile(r"(?<!^)(?=[A-Z])")
+
+
+def _is_octal(count: int) -> Callable[..., str]:
+    def _check_is_octal(v: str) -> str:
+        assert len(v) == count
+        assert v[0] == "0"
+        assert v
+        for _ in range(count):
+            assert 0 <= int(v[_]) <= 7
+        return v
+
+    return _check_is_octal
+
+
+def _is_username(v: str) -> str:
+    assert re.match(_un_regex, v)
+    return v
+
+
+def _is_username_or_usernamegroup(v: str) -> str:
+    splits = v.split(":")
+    assert len(splits) == 1 or len(splits) == 2
+    assert re.match(_un_regex, splits[0])
+    return v
+
+
+def _is_host_port(v: str) -> str:
+    splits = v.split(":")
+    assert 0 < int(splits[1]) < 65_535
+    return v
+
+
+Octal = Annotated[str, AfterValidator(_is_octal(4))]
+OctalUmask = Annotated[str, AfterValidator(_is_octal(3))]
+UnixUserNameOrGroup = Annotated[str, AfterValidator(_is_username_or_usernamegroup)]
+UnixUserName = Annotated[str, AfterValidator(_is_username)]
+HostPort = Annotated[str, AfterValidator(_is_host_port)]
+LogLevel = Literal["critical", "error", "warn", "info", "debug", "trace", "blather"]
+Signal = Literal["TERM", "HUP", "INT", "QUIT", "KILL", "USR1", "USR2"]
+EventType = Literal[
+    "PROCESS_STATE",
+    "PROCESS_STATE_STARTING",
+    "PROCESS_STATE_RUNNING",
+    "PROCESS_STATE_BACKOFF",
+    "PROCESS_STATE_STOPPING",
+    "PROCESS_STATE_EXITED",
+    "PROCESS_STATE_STOPPED",
+    "PROCESS_STATE_FATAL",
+    "PROCESS_STATE_UNKNOWN",
+    "REMOTE_COMMUNICATION",
+    "PROCESS_LOG",
+    "PROCESS_LOG_STDOUT",
+    "PROCESS_LOG_STDERR",
+    "PROCESS_COMMUNICATION",
+    "PROCESS_COMMUNICATION_STDOUT",
+    "PROCESS_COMMUNICATION_STDERR",
+    "SUPERVISOR_STATE_CHANGE",
+    "SUPERVISOR_STATE_CHANGE_RUNNING",
+    "SUPERVISOR_STATE_CHANGE_STOPPING",
+    "TICK",
+    "TICK_5",
+    "TICK_60",
+    "TICK_3600",
+    "PROCESS_GROUP",
+    "PROCESS_GROUP_ADDED",
+    "PROCESS_GROUP_REMOVED",
+]
+SupervisorLocation = Literal["local", "remote"]
+
+
+class _BaseCfgModel(BaseModel):
+    def to_cfg(self, key: str = "") -> str:
+        ret = f"[{_snake_regex.sub('_', self.__class__.__name__.replace('Configuration', '')).lower()}{':' + key if key else ''}]"
+        # round trip to json so we're fully
+        # cfg-compatible
+        for k, v in loads(self.model_dump_json()).items():
+            if v is not None:
+                if isinstance(v, bool):
+                    ret += f"\n{k}={str(v).lower()}"
+                else:
+                    ret += f"\n{k}={v}"
+        return ret.strip() + "\n"

supervisor_pydantic/config/convenience.py

@@ -0,0 +1,102 @@
+from typing import List, Optional
+
+from pydantic import Field, SecretStr, field_serializer, field_validator, model_validator
+
+from .base import HostPort, Signal, SupervisorLocation, UnixUserName, _BaseCfgModel
+
+__all__ = ("ConvenienceConfiguration",)
+
+
+class ConvenienceConfiguration(_BaseCfgModel):
+    """Convenience layer, settings that MUST be set when running via convenience API"""
+
+    ############
+    # programs #
+    ############
+    # autostart = False
+    # autorestart = False
+    startsecs: Optional[int] = Field(
+        default=1,
+        description="The total number of seconds which the program needs to stay running after a startup to consider the start successful (moving the process from the STARTING state to the RUNNING state). Set to 0 to indicate that the program needn’t stay running for any particular amount of time. Even if a process exits with an “expected” exit code (see exitcodes), the start will still be considered a failure if the process exits quicker than startsecs.",
+    )
+    startretries: Optional[int] = Field(
+        default=None,
+        description="The number of serial failure attempts that supervisord will allow when attempting to start the program before giving up and putting the process into an FATAL state. After each failed restart, process will be put in BACKOFF state and each retry attempt will take increasingly more time.",
+    )
+    exitcodes: Optional[List[int]] = Field(
+        default=[0],
+        description="The list of “expected” exit codes for this program used with autorestart. If the autorestart parameter is set to unexpected, and the process exits in any other way than as a result of a supervisor stop request, supervisord will restart the process if it exits with an exit code that is not defined in this list.",
+    )
+    stopsignal: Optional[Signal] = Field(
+        default="TERM",
+        description="The signal used to kill the program when a stop is requested. This can be specified using the signal’s name or its number. It is normally one of: TERM, HUP, INT, QUIT, KILL, USR1, or USR2.",
+    )
+    stopwaitsecs: Optional[int] = Field(
+        default=30,
+        description="The number of seconds to wait for the OS to return a SIGCHLD to supervisord after the program has been sent a stopsignal. If this number of seconds elapses before supervisord receives a SIGCHLD from the process, supervisord will attempt to kill it with a final SIGKILL.",
+    )
+
+    ####################
+    # inet_http_server #
+    ####################
+    # port not optional
+    port: HostPort = Field(
+        default="*:9001",
+        description="A TCP host:port value or (e.g. 127.0.0.1:9001) on which supervisor will listen for HTTP/XML-RPC requests. supervisorctl will use XML-RPC to communicate with supervisord over this port. To listen on all interfaces in the machine, use :9001 or *:9001. Please read the security warning above.",
+    )
+    username: Optional[UnixUserName] = Field(default=None, description="The username required for authentication to the HTTP/Unix Server.")
+    password: Optional[SecretStr] = Field(
+        default=None,
+        description="The password required for authentication to the HTTP/Unix server. This can be a cleartext password, or can be specified as a SHA-1 hash if prefixed by the string {SHA}. For example, {SHA}82ab876d1387bfafe46cc1c8a2ef074eae50cb1d is the SHA-stored version of the password “thepassword”. Note that hashed password must be in hex format.",
+    )
+
+    #################
+    # rpc_interface #
+    ###################
+    rpcinterface_factory: str = Field(
+        default="supervisor.rpcinterface:make_main_rpcinterface",
+        description="pkg_resources “entry point” dotted name to your RPC interface’s factory function.",
+    )
+
+    #########
+    # Other #
+    #########
+    local_or_remote: Optional[SupervisorLocation] = Field(
+        default="local",
+        description="Location of supervisor, either local for same-machine or remote. If same-machine, communicates via Unix sockets by default, if remote, communicates via inet http server",
+    )
+    host: str = Field(
+        default="localhost",
+        description="Hostname of the supervisor host. Used by the XMLRPC client",
+    )
+    protocol: str = Field(
+        default="http",
+        description="Protocol of the supervisor XMLRPC HTTP API. Used by the XMLRPC client",
+    )
+    rpcpath: str = Field(
+        default="/RPC2",
+        description="Path for supervisor XMLRPC HTTP API. Used by the XMLRPC client",
+    )
+
+    @model_validator(mode="after")
+    def validate_remote_accessible(self):
+        if self.local_or_remote == "remote" and self.port.startswith(("localhost", "127.0.0.1")):
+            raise ValueError("Supervisor binds only to loopback (localhost/127.0.0.1), but asked for remote")
+        if self.local_or_remote == "remote" and self.host.startswith(("localhost", "127.0.0.1")):
+            raise ValueError("Supervisor client expecting hostname, got localhost/127.0.0.1")
+        return self
+
+    @field_serializer("exitcodes", when_used="json")
+    def _dump_exitcodes(self, v):
+        if v:
+            return ",".join(str(_) for _ in v)
+        return None
+
+    @field_validator("exitcodes", mode="before")
+    @classmethod
+    def _load_exitcodes(cls, v):
+        if isinstance(v, str):
+            v = v.split(",")
+        if isinstance(v, list):
+            return [int(_) for _ in v]
+        return v

supervisor_pydantic/config/eventlistener.py

@@ -0,0 +1,48 @@
+from typing import List, Optional
+
+from pydantic import Field, field_serializer, field_validator
+
+from .base import EventType
+from .program import ProgramConfiguration
+
+__all__ = ("EventListenerConfiguration",)
+
+
+class EventListenerConfiguration(ProgramConfiguration):
+    def to_cfg(self, key: str) -> str:
+        # Overload to require key
+        return super().to_cfg(key=key).replace("[event_listener", "[eventlistener")
+
+    buffer_size: Optional[int] = Field(
+        default=None,
+        description="The event listener pool’s event queue buffer size. When a listener pool’s event buffer is overflowed (as can happen when an event listener pool cannot keep up with all of the events sent to it), the oldest event in the buffer is discarded.",
+    )
+    events: Optional[List[EventType]] = Field(
+        default=None,
+        description="A comma-separated list of event type names that this listener is “interested” in receiving notifications for (see Event Types for a list of valid event type names).",
+    )
+    result_handler: Optional[str] = Field(
+        default=None,
+        description="A pkg_resources entry point string that resolves to a Python callable. The default value is supervisor.dispatchers:default_handler. Specifying an alternate result handler is a very uncommon thing to need to do, and as a result, how to create one is not documented.",
+    )
+
+    # TODO can't inherit stdout_capture_maxbytes
+    @field_validator("stdout_capture_maxbytes")
+    @classmethod
+    def _event_listener_cant_use_stdout_capture_maxbytes(cls, v: str) -> str:
+        if v:
+            raise ValueError("eventlistener cannot use stdout_capture_maxbytes")
+        return None
+
+    @field_serializer("events", when_used="json")
+    def _dump_events(self, v):
+        if v:
+            return ",".join(v)
+        return None
+
+    @field_validator("events", mode="before")
+    @classmethod
+    def _load_events(cls, v):
+        if isinstance(v, str):
+            return v.split(",")
+        return v

supervisor_pydantic/config/fcgiprogram.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from pydantic import Field
+
+from .base import Octal, UnixUserNameOrGroup
+from .program import ProgramConfiguration
+
+__all__ = ("FcgiProgramConfiguration",)
+
+
+class FcgiProgramConfiguration(ProgramConfiguration):
+    def to_cfg(self, key: str) -> str:
+        # Overload to require key
+        return super().to_cfg(key=key).replace("[fcgi_program", "[fcgi-program")
+
+    socket: str = Field(
+        description="The FastCGI socket for this program, either TCP or UNIX domain socket. For TCP sockets, use this format: tcp://localhost:9002. For UNIX domain sockets, use unix:///absolute/path/to/file.sock. String expressions are evaluated against a dictionary containing the keys “program_name” and “here” (the directory of the supervisord config file)."
+    )
+    socket_backlog: Optional[str] = Field(default=None, description="Sets socket listen(2) backlog.")
+    socket_owner: Optional[UnixUserNameOrGroup] = Field(
+        default=None,
+        description="For UNIX domain sockets, this parameter can be used to specify the user and group for the FastCGI socket. May be a UNIX username (e.g. chrism) or a UNIX username and group separated by a colon (e.g. chrism:wheel).",
+    )
+    socket_mode: Optional[Octal] = Field(
+        default=None, description="For UNIX domain sockets, this parameter can be used to specify the permission mode."
+    )

supervisor_pydantic/config/group.py

@@ -0,0 +1,29 @@
+from typing import List, Optional
+
+from pydantic import Field, field_serializer, field_validator
+
+from .base import _BaseCfgModel
+
+__all__ = ("GroupConfiguration",)
+
+
+class GroupConfiguration(_BaseCfgModel):
+    def to_cfg(self, key: str) -> str:
+        # Overload to require key
+        return super().to_cfg(key=key)
+
+    programs: List[str] = Field(description="A comma-separated list of program names. The programs which are listed become members of the group.")
+    priority: Optional[int] = Field(default=None, description="A priority number analogous to a [program:x] priority value assigned to the group.")
+
+    @field_serializer("programs", when_used="json")
+    def _dump_programs(self, v):
+        if v:
+            return ",".join(v)
+        return None
+
+    @field_validator("programs", mode="before")
+    @classmethod
+    def _load_programs(cls, v):
+        if isinstance(v, str):
+            return v.split(",")
+        return v

supervisor_pydantic/config/hydra/base.yaml

@@ -0,0 +1,18 @@
+# @package _global_
+
+defaults:
+  # https://hydra.cc/docs/configure_hydra/logging/
+  - supervisord/default
+  - override hydra/job_logging: custom
+  - override hydra/hydra_logging: custom
+  - _self_
+
+_target_: supervisor_pydantic.SupervisorConfiguration
+unix_http_server:
+pinet_http_server:
+include:
+program:
+group:
+fcgiprogram:
+eventlistener:
+rpcinterface:

supervisor_pydantic/config/hydra/eventlistener/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+eventlistener:

supervisor_pydantic/config/hydra/fcgiprogram/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+fcgiprogram:

supervisor_pydantic/config/hydra/group/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+group:

supervisor_pydantic/config/hydra/hydra/hydra_logging/custom.yaml

@@ -0,0 +1,24 @@
+version: 1
+formatters:
+  simple:
+    format: '[%(levelname)s] - %(message)s'
+  colorlog:
+    '()': 'colorlog.ColoredFormatter'
+    format: '[%(cyan)s%(asctime)s%(reset)s][%(threadName)s][%(blue)s%(name)s%(reset)s][%(log_color)s%(levelname)s%(reset)s]: %(message)s'
+    log_colors:
+      DEBUG: cyan
+      INFO: green
+      WARNING: yellow
+      ERROR: red
+      CRITICAL: red
+handlers:
+  console:
+    class: logging.StreamHandler
+    formatter: colorlog
+    level: INFO
+    stream: ext://sys.stdout
+root:
+  handlers: [console]
+  level: INFO
+
+disable_existing_loggers: false

supervisor_pydantic/config/hydra/hydra/job_logging/custom.yaml

@@ -0,0 +1,24 @@
+version: 1
+formatters:
+  simple:
+    format: '[%(levelname)s] - %(message)s'
+  colorlog:
+    '()': 'colorlog.ColoredFormatter'
+    format: '[%(cyan)s%(asctime)s%(reset)s][%(threadName)s][%(blue)s%(name)s%(reset)s][%(log_color)s%(levelname)s%(reset)s]: %(message)s'
+    log_colors:
+      DEBUG: cyan
+      INFO: green
+      WARNING: yellow
+      ERROR: red
+      CRITICAL: red
+handlers:
+  console:
+    class: logging.StreamHandler
+    formatter: colorlog
+    level: INFO
+    stream: ext://sys.stdout
+root:
+  handlers: [console]
+  level: INFO
+
+disable_existing_loggers: false

supervisor_pydantic/config/hydra/include/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+include:

supervisor_pydantic/config/hydra/inet_http_server/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+inet_http_server:

supervisor_pydantic/config/hydra/program/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+program:

supervisor_pydantic/config/hydra/rpcinterface/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+rpcinterface:

supervisor_pydantic/config/hydra/supervisorctl/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+supervisorctl:

supervisor_pydantic/config/hydra/supervisord/default.yaml

@@ -0,0 +1,3 @@
+# @package _global_
+supervisord:
+  _target_: supervisor_pydantic.SupervisordConfiguration

supervisor_pydantic/config/hydra/unix_http_server/default.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+unix_http_server: