devservices 1.2.0__tar.gz → 1.2.2__tar.gz

{devservices-1.2.0 → devservices-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.2.0
+Version: 1.2.2
 Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.2.0 → devservices-1.2.2}/README.md

@@ -23,6 +23,8 @@ NOTE: service-name is an optional parameter. If not provided, devservices will a
 - `devservices update` Update devservices to the latest version.
 - `devservices purge`: Purge the local devservices cache.
 - `devservices toggle <service-name>`: Toggle the runtime for a service between containerized and local.
+- `devservices serve`: Run a service's devserver.
+- `devservices foreground <process-name>`: Foreground a process that is currently running in the background. This enables interactive debugging.
 
 ## Installation
 
@@ -31,7 +33,7 @@ NOTE: service-name is an optional parameter. If not provided, devservices will a
 The recommended way to install devservices is through a virtualenv in the requirements.txt. Once that is installed and a devservices config file is added, you should be able to run `devservices up` to begin local development.
 
 ```
-devservices==1.2.0
+devservices==1.2.2
 ```
 
 ### 2. Add devservices config files
@@ -45,7 +47,7 @@ The configuration file is a yaml file that looks like this:
 # - version: The version of the devservices config file. This is used to ensure compatibility between devservices and the config file.
 # - service_name: The name of the service. This is used to identify the service in the config file.
 # - dependencies: A list of dependencies for the service. Each dependency is a yaml block that holds the dependency configuration. There are two types of dependencies:
-#   - local: A dependency that is defined in the config file. These dependencies do not have a remote field. These dependency definitions are specific to the service and are not defined elsewhere.
+#   - local: A dependency that is defined in the config file. These dependencies do not have a remote field and must correspond to either a service defined in the 'services' section or a program defined in the 'x-programs' section.
 #   - remote: A dependency that is defined in the devservices directory in a remote repository. These configs are automatically fetched from the remote repository and installed. Any dependency with a remote field will be treated as a remote dependency. Example: https://github.com/getsentry/snuba/blob/59a5258ccbb502827ebc1d3b1bf80c607a3301bf/devservices/config.yml#L8
 # - modes: A list of modes for the service. Each mode includes a list of dependencies that are used in that mode.
 x-sentry-service-config:
@@ -67,6 +69,27 @@ x-sentry-service-config:
     default: [example-dependency-1, example-remote-dependency]
     custom-mode: [example-dependency-1, example-dependency-2, example-remote-dependency]
 
+# This block defines supervisor programs that can be managed by devservices.
+# Programs defined here are managed using Python's supervisor package and can be:
+# - Started and stopped along with docker services when running `devservices up/down`
+# - Run in the foreground for interactive debugging using `devservices foreground <program-name>`
+# - Used as development server with `devservices serve` (requires a program named "devserver")
+#
+# These are particularly useful for:
+# - Defining a devserver to run locally
+# - Background workers or task processors
+# - Any process that needs to be managed alongside your docker services
+x-programs:
+  # Example devserver
+  devserver:
+    # Required: The command to execute
+    command: "python manage.py run_server"
+    # Optional: You can also specify any of the supervisor program settings defined here: https://supervisord.org/configuration.html#program-x-section-settings
+
+  # Example background worker
+  example-worker:
+    command: "python manage.py worker"
+
 # This will be a standard block used by docker compose to define dependencies.
 #
 # The following fields are important to all dependencies:

{devservices-1.2.0 → devservices-1.2.2}/devservices/commands/down.py

@@ -15,12 +15,12 @@ from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.exceptions import ServiceNotFoundError
+from devservices.exceptions import SupervisorConfigError
 from devservices.exceptions import SupervisorError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
@@ -305,22 +305,36 @@ def _bring_down_dependency(
     return run_cmd(cmd.full_command, current_env)
 
 
+def _stop_supervisor_program(
+    manager: SupervisorManager, program: str, status: Status
+) -> None:
+    """Stop a single supervisor program."""
+    status.info(f"Stopping {program}")
+    manager.stop_process(program)
+
+
 def bring_down_supervisor_programs(
     supervisor_programs: list[str], service: Service, status: Status
 ) -> None:
     if len(supervisor_programs) == 0:
         return
-    programs_config_path = os.path.join(
-        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
-    )
-    manager = SupervisorManager(
-        programs_config_path,
-        service_name=service.name,
+
+    config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
 
-    for program in supervisor_programs:
-        status.info(f"Stopping {program}")
-        manager.stop_process(program)
+    try:
+        manager = SupervisorManager(service.name, config_file_path)
+    except SupervisorConfigError:
+        raise
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = [
+            executor.submit(_stop_supervisor_program, manager, program, status)
+            for program in supervisor_programs
+        ]
+        for future in concurrent.futures.as_completed(futures):
+            _ = future.result()
 
     status.info("Stopping supervisor daemon")
     manager.stop_supervisor_daemon()

{devservices-1.2.0 → devservices-1.2.2}/devservices/commands/foreground.py

@@ -9,9 +9,9 @@ from argparse import Namespace
 
 from sentry_sdk import capture_exception
 
+from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import ServiceNotFoundError
@@ -92,14 +92,15 @@ def foreground(args: Namespace) -> None:
         )
         return
 
-    programs_config_path = os.path.join(
-        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
+    config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
 
-    manager = SupervisorManager(
-        programs_config_path,
-        service_name=service.name,
-    )
+    try:
+        manager = SupervisorManager(service.name, config_file_path)
+    except SupervisorConfigError as e:
+        capture_exception(e, level="info")
+        return
 
     try:
         program_command = manager.get_program_command(program_name)

{devservices-1.2.0 → devservices-1.2.2}/devservices/commands/logs.py

@@ -16,7 +16,6 @@ from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
 from devservices.constants import MAX_LOG_LINES
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import DependencyError
@@ -178,12 +177,11 @@ def _supervisor_logs(
 
     supervisor_logs: dict[str, str] = {}
 
-    programs_config_path = os.path.join(
-        service.repo_path, DEVSERVICES_DIR_NAME, PROGRAMS_CONF_FILE_NAME
+    config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
-
     try:
-        manager = SupervisorManager(programs_config_path, service_name=service.name)
+        manager = SupervisorManager(service.name, config_file_path)
     except SupervisorConfigError as e:
         capture_exception(e)
         return supervisor_logs

{devservices-1.2.0 → devservices-1.2.2}/devservices/commands/serve.py

@@ -9,8 +9,8 @@ from argparse import Namespace
 
 from sentry_sdk import capture_exception
 
+from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import SupervisorConfigError
@@ -46,16 +46,24 @@ def serve(args: Namespace) -> None:
         console.failure(str(e))
         exit(1)
 
-    programs_config_path = os.path.join(
-        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
+    config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
-    if not os.path.exists(programs_config_path):
-        console.failure(f"No programs.conf file found in {programs_config_path}.")
+
+    try:
+        manager = SupervisorManager(service.name, config_file_path)
+    except SupervisorConfigError as e:
+        capture_exception(e, level="info")
+        console.failure(
+            f"Unable to bring up devserver due to supervisor config error: {str(e)}"
+        )
+        return
+
+    if not manager.has_programs:
+        console.failure(
+            "No programs found in config. Please add the devserver in the `x-programs` block to your config.yml"
+        )
         return
-    manager = SupervisorManager(
-        programs_config_path,
-        service_name=service.name,
-    )
 
     try:
         devserver_command = manager.get_program_command("devserver")

{devservices-1.2.0 → devservices-1.2.2}/devservices/commands/status.py

@@ -20,12 +20,12 @@ from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.exceptions import ServiceNotFoundError
+from devservices.exceptions import SupervisorConfigError
 from devservices.utils.console import Console
 from devservices.utils.dependencies import construct_dependency_graph
 from devservices.utils.dependencies import DependencyGraph
@@ -103,16 +103,18 @@ def status(args: Namespace) -> None:
         console.warning(f"Status unavailable. {service.name} is not running standalone")
         return  # Since exit(0) is captured as an internal_error by sentry
 
-    programs_config_path = os.path.join(
-        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
+    config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
     process_statuses = {}
-    if os.path.exists(programs_config_path):
-        supervisor_manager = SupervisorManager(
-            programs_config_path,
-            service.name,
-        )
+
+    try:
+        supervisor_manager = SupervisorManager(service.name, config_file_path)
         process_statuses = supervisor_manager.get_all_process_info()
+    except SupervisorConfigError as e:
+        capture_exception(e)
+        console.failure(str(e))
+        exit(1)
 
     try:
         status_tree = get_status_for_service(service, process_statuses)

{devservices-1.2.0 → devservices-1.2.2}/devservices/commands/up.py

@@ -17,7 +17,6 @@ from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR
 from devservices.constants import DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigError
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import ContainerHealthcheckFailedError
@@ -25,6 +24,7 @@ from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.exceptions import ModeDoesNotExistError
 from devservices.exceptions import ServiceNotFoundError
+from devservices.exceptions import SupervisorConfigError
 from devservices.exceptions import SupervisorError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
@@ -98,14 +98,16 @@ def up(args: Namespace, existing_status: Status | None = None) -> None:
 
     with Status(
         lambda: (
-            console.warning(f"Starting '{service.name}' in mode: '{mode}'")
+            console.warning(f"Starting '{service.name}' dependencies in mode: '{mode}'")
             if existing_status is None
-            else existing_status.warning(f"Starting '{service.name}' in mode: '{mode}'")
+            else existing_status.warning(
+                f"Starting '{service.name}' dependencies in mode: '{mode}'"
+            )
         ),
         lambda: (
-            console.success(f"{service.name} started")
+            console.success(f"{service.name} dependencies started")
             if existing_status is None
-            else existing_status.success(f"{service.name} started")
+            else existing_status.success(f"{service.name} dependencies started")
         ),
     ) as status:
         local_runtime_dependency_names = set()
@@ -381,6 +383,14 @@ def bring_up_docker_compose_services(
         exit(1)
 
 
+def _start_supervisor_program(
+    manager: SupervisorManager, program: str, status: Status
+) -> None:
+    """Start a single supervisor program."""
+    status.info(f"Starting {program}")
+    manager.start_process(program)
+
+
 def bring_up_supervisor_programs(
     service: Service, supervisor_programs: list[str], status: Status
 ) -> None:
@@ -391,18 +401,23 @@ def bring_up_supervisor_programs(
             f"Cannot bring up supervisor programs from outside the service repository. Please run the command from the service repository ({service.repo_path})"
         )
         return
-    programs_config_path = os.path.join(
-        service.repo_path, f"{DEVSERVICES_DIR_NAME}/{PROGRAMS_CONF_FILE_NAME}"
-    )
 
-    manager = SupervisorManager(
-        programs_config_path,
-        service_name=service.name,
+    config_file_path = os.path.join(
+        service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
 
+    try:
+        manager = SupervisorManager(service.name, config_file_path)
+    except SupervisorConfigError:
+        raise
+
     status.info("Starting supervisor daemon")
     manager.start_supervisor_daemon()
 
-    for program in supervisor_programs:
-        status.info(f"Starting {program}")
-        manager.start_process(program)
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = [
+            executor.submit(_start_supervisor_program, manager, program, status)
+            for program in supervisor_programs
+        ]
+        for future in concurrent.futures.as_completed(futures):
+            _ = future.result()

{devservices-1.2.0 → devservices-1.2.2}/devservices/configs/service_config.py

@@ -10,10 +10,10 @@ from supervisor.options import ServerOptions
 from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DependencyType
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import ConfigParseError
 from devservices.exceptions import ConfigValidationError
+from devservices.utils.supervisor import ProgramData
 from devservices.utils.supervisor import SupervisorManager
 
 VALID_VERSIONS = [0.1]
@@ -91,8 +91,10 @@ def load_service_config_from_file(repo_path: str) -> ServiceConfig:
 
         docker_compose_services = config.get("services", {}).keys()
 
-        supervisor_programs = load_supervisor_programs_from_file(
-            repo_path, service_config_data.get("service_name")
+        supervisor_programs = load_supervisor_programs_from_programs_data(
+            config_path,
+            service_config_data.get("service_name"),
+            config.get("x-programs", {}),
         )
 
         valid_dependency_keys = {field.name for field in fields(Dependency)}
@@ -113,7 +115,7 @@ def load_service_config_from_file(repo_path: str) -> ServiceConfig:
                         dependency_type = DependencyType.COMPOSE
                     else:
                         raise ConfigValidationError(
-                            f"Dependency '{key}' is not remote but is not defined in docker-compose services or programs file"
+                            f"Dependency '{key}' is not remote but is not defined in docker-compose services or x-programs"
                         )
                 else:
                     dependency_type = DependencyType.SERVICE
@@ -142,13 +144,15 @@ def load_service_config_from_file(repo_path: str) -> ServiceConfig:
         return service_config
 
 
-def load_supervisor_programs_from_file(repo_path: str, service_name: str) -> set[str]:
-    programs_config_path = os.path.join(
-        repo_path, DEVSERVICES_DIR_NAME, PROGRAMS_CONF_FILE_NAME
-    )
-    if not os.path.exists(programs_config_path):
+def load_supervisor_programs_from_programs_data(
+    service_config_path: str, service_name: str, programs_data: ProgramData
+) -> set[str]:
+    if not programs_data:
         return set()
-    manager = SupervisorManager(programs_config_path, service_name=service_name)
+
+    manager = SupervisorManager(
+        service_name=service_name, service_config_path=service_config_path
+    )
     opts = ServerOptions()
     opts.configfile = manager.config_file_path
     opts.process_config()

{devservices-1.2.0 → devservices-1.2.2}/devservices/constants.py

@@ -25,7 +25,6 @@ class DependencyType(StrEnum):
 MINIMUM_DOCKER_COMPOSE_VERSION = "2.29.7"
 DEVSERVICES_DIR_NAME = "devservices"
 CONFIG_FILE_NAME = "config.yml"
-PROGRAMS_CONF_FILE_NAME = "programs.conf"
 DOCKER_CONFIG_DIR = os.environ.get("DOCKER_CONFIG", os.path.expanduser("~/.docker"))
 DOCKER_USER_PLUGIN_DIR = os.path.join(DOCKER_CONFIG_DIR, "cli-plugins/")
 

{devservices-1.2.0 → devservices-1.2.2}/devservices/utils/docker.py

@@ -10,6 +10,7 @@ from devservices.constants import HEALTHCHECK_TIMEOUT
 from devservices.exceptions import ContainerHealthcheckFailedError
 from devservices.exceptions import DockerDaemonNotRunningError
 from devservices.exceptions import DockerError
+from devservices.utils.console import Console
 from devservices.utils.console import Status
 
 
@@ -20,6 +21,7 @@ class ContainerNames(NamedTuple):
 
 def check_docker_daemon_running() -> None:
     """Checks if the Docker daemon is running. Raises DockerDaemonNotRunningError if not."""
+    console = Console()
     try:
         subprocess.run(
             ["docker", "info"],
@@ -27,7 +29,13 @@ def check_docker_daemon_running() -> None:
             text=True,
             check=True,
         )
+        return
+    except subprocess.CalledProcessError:
+        console.info("Docker daemon is not running. Checking if colima is available")
+    try:
+        subprocess.run(["devenv", "colima", "start"], check=True)
     except subprocess.CalledProcessError as e:
+        console.failure("Failed to start colima")
         raise DockerDaemonNotRunningError from e
 
 

{devservices-1.2.0 → devservices-1.2.2}/devservices/utils/supervisor.py

@@ -10,6 +10,7 @@ import xmlrpc.client
 from enum import IntEnum
 from typing import TypedDict
 
+import yaml
 from sentry_sdk import capture_exception
 from supervisor.options import ServerOptions
 
@@ -91,24 +92,81 @@ class ProcessInfo(TypedDict):
     group: str
 
 
+class SupervisorProgramConfig(TypedDict, total=False):
+    """Supervisor program configuration."""
+
+    command: str
+    autostart: str | bool
+    autorestart: str | bool
+    directory: str
+    environment: str
+    user: str
+    priority: str | int
+    startsecs: str | int
+    startretries: str | int
+    stdout_logfile: str
+    stderr_logfile: str
+    redirect_stderr: str | bool
+
+
+ProgramData = dict[str, SupervisorProgramConfig]
+
+
+# Default values for supervisor program configuration
+SUPERVISOR_PROGRAM_DEFAULTS = {
+    "autostart": "false",
+    "autorestart": "true",
+}
+
+
 class SupervisorManager:
-    def __init__(self, config_file_path: str, service_name: str) -> None:
+    def __init__(
+        self,
+        service_name: str,
+        service_config_path: str,
+    ) -> None:
         self.service_name = service_name
-        if not os.path.exists(config_file_path):
-            raise SupervisorConfigError(
-                f"Config file {config_file_path} does not exist"
-            )
         self.socket_path = os.path.join(
             DEVSERVICES_SUPERVISOR_CONFIG_DIR, f"{service_name}.sock"
         )
-        self.config_file_path = self._extend_config_file(config_file_path)
 
-    def _extend_config_file(self, config_file_path: str) -> str:
-        """Extend the supervisor config file passed into devservices with configuration settings that should be abstracted from users."""
+        # Load service config and extract x-programs data
+        if os.path.exists(service_config_path):
+            with open(service_config_path, "r", encoding="utf-8") as stream:
+                config = yaml.safe_load(stream)
+        else:
+            raise SupervisorConfigError(f"Config file {service_config_path} not found")
+
+        if config is None:
+            raise SupervisorConfigError(f"Config file {service_config_path} is empty")
 
+        programs_data: ProgramData = config.get("x-programs", {})
+
+        self.has_programs = len(programs_data.keys()) > 0
+
+        # Generate supervisor config file from x-programs data
+        self.config_file_path = self._generate_config_from_programs_data(programs_data)
+
+    def _generate_config_from_programs_data(self, programs_data: ProgramData) -> str:
         config = configparser.ConfigParser()
 
-        config.read(config_file_path)
+        # Add program sections
+        for program_name, program_config in programs_data.items():
+            section_name = f"program:{program_name}"
+            config[section_name] = {}
+
+            # Apply defaults for any missing configuration values
+            program_config_with_defaults = {
+                **SUPERVISOR_PROGRAM_DEFAULTS,
+                **program_config,
+            }
+
+            for key, value in program_config_with_defaults.items():
+                if isinstance(value, bool):
+                    config[section_name][key] = str(value).lower()
+                else:
+                    config[section_name][key] = str(value)
+
         os.makedirs(DEVSERVICES_SUPERVISOR_CONFIG_DIR, exist_ok=True)
 
         # Set unix http server to use the socket path
@@ -129,13 +187,13 @@ class SupervisorManager:
             "supervisor.rpcinterface_factory": "supervisor.rpcinterface:make_main_rpcinterface"
         }
 
-        extended_config_file_path = os.path.join(
+        config_file_path = os.path.join(
             DEVSERVICES_SUPERVISOR_CONFIG_DIR, f"{self.service_name}.processes.conf"
         )
-        with open(extended_config_file_path, "w") as f:
+        with open(config_file_path, "w") as f:
             config.write(f)
 
-        return extended_config_file_path
+        return config_file_path
 
     def _get_rpc_client(self) -> xmlrpc.client.ServerProxy:
         """Get or create an XML-RPC client that connects to the supervisor daemon."""
@@ -317,6 +375,9 @@ class SupervisorManager:
     def get_all_process_info(self) -> dict[str, ProcessInfo]:
         """Get status information for all supervisor programs."""
         # Check if supervisor client is up first, return empty list if down
+        if not self.has_programs:
+            return {}
+
         try:
             client = self._get_rpc_client()
             client.supervisor.getState()

{devservices-1.2.0 → devservices-1.2.2}/devservices.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.2.0
+Version: 1.2.2
 Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.2.0 → devservices-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devservices"
-version = "1.2.0"
+version = "1.2.2"
 # 3.11 is just for internal pypi compat
 requires-python = ">=3.11"
 dependencies = [

{devservices-1.2.0 → devservices-1.2.2}/testing/utils.py

@@ -8,7 +8,6 @@ from pathlib import Path
 import yaml
 
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import PROGRAMS_CONF_FILE_NAME
 
 TESTING_DIR = os.path.abspath(os.path.dirname(__file__))
 
@@ -27,14 +26,6 @@ def create_config_file(
         yaml.dump(config, f, sort_keys=False, default_flow_style=False)
 
 
-def create_programs_conf_file(tmp_path: Path, config: str) -> None:
-    devservices_dir = Path(tmp_path, DEVSERVICES_DIR_NAME)
-    devservices_dir.mkdir(parents=True, exist_ok=True)
-    tmp_file = Path(devservices_dir, PROGRAMS_CONF_FILE_NAME)
-    with tmp_file.open("w") as f:
-        f.write(config)
-
-
 def run_git_command(command: list[str], cwd: Path) -> None:
     subprocess.run(
         ["git", *command], cwd=cwd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL