uber-compose 2.3.1a2002__tar.gz → 2.3.3__tar.gz

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uber-compose
-Version: 2.3.1a2002
+Version: 2.3.3
 Summary: docker compose testing env orchestrator
 Home-page: https://github.com/ko10ok/uber-compose
 Author: Yuriy Sagitov

uber_compose-2.3.3/setup.cfg

@@ -0,0 +1,28 @@
+[isort]
+line_length = 120
+force_single_line = True
+force_sort_within_sections = True
+known_first_party = uber_compose
+skip = .venv,.git,build,dist,tests/mnt,tests/.vedro,tests/deps,tests/up,tests/build
+skip_glob = **/__pycache__/*,**/*.egg-info/*
+
+[flake8]
+max-line-length = 120
+exclude = 
+	.venv,
+	.git,
+	build,
+	dist,
+	*.egg-info,
+	tests/mnt,
+	tests/.vedro,
+	tests/deps,
+	tests/up,
+	tests/build,
+	__pycache__
+extend-ignore = E203,W503,E731
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/constants.py

@@ -11,7 +11,9 @@ class Constants:
 
         self.project: str = os.environ.get('COMPOSE_PROJECT_NAME')
         self.compose_project_name = os.environ.get('COMPOSE_PROJECT_NAME')
-        assert self.compose_project_name, 'COMPOSE_PROJECT_NAME environment variable is not set: - COMPOSE_PROJECT_NAME=${PWD##*/}'
+        assert self.compose_project_name, (
+            'COMPOSE_PROJECT_NAME environment variable is not set: - COMPOSE_PROJECT_NAME=${PWD##*/}'
+        )
 
         self.docker_host = os.environ.get('DOCKER_HOST', 'unix:///var/run/docker.sock')
 

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/docker_compose.py

@@ -1,11 +1,10 @@
-import os
-import sys
 from asyncio import sleep
+import os
 from pathlib import Path
+import sys
 
 from rich.text import Text
 
-from uber_compose.core.constants import Constants
 from uber_compose.core.docker_compose_shell.interface import ComposeShellInterface
 from uber_compose.core.sequence_run_types import ComposeInstanceFiles
 from uber_compose.core.sequence_run_types import EnvInstanceConfig
@@ -118,7 +117,8 @@ class ComposeInstance:
                     kill_after=False,
                 )
 
-                migration_errors = [error for error in migration_result.stderr.split(b'\n') if error]  # empty or none skips
+                # empty or none skips
+                migration_errors = [error for error in migration_result.stderr.split(b'\n') if error]
                 skipper_migration_errors = [
                     current_error
                     for current_error in migration_errors
@@ -142,20 +142,25 @@ class ComposeInstance:
                 ]
                 if not migration_result.finished or critical_migration_errors:
                     services_status = await self.compose_executor.dc_state()
-                    error = Text(f"Can't migrate service {target_service}, with {substituted_cmd}", style=Style.bad).append(
-                        Text(f"\n{migration_result.stdout=}\n",style=Style.regular)
+                    error = Text(
+                        f"Can't migrate service {target_service}, with {substituted_cmd}", style=Style.bad,
+                    ).append(
+                        Text(f"\n{migration_result.stdout=}\n", style=Style.regular)
                     ).append(
                         Text(f"{migration_result.stderr=}\n", style=Style.bad)
                     ).append(
-                        Text(f"Services status:\n", style=Style.info)
+                        Text("Services status:\n", style=Style.info)
                     ).append(
                         services_status.as_rich_text()
                     )
                     self.logger.error(error)
                     self.logger.error_details(f"\nServices logs:\n {await self.logs(services)}")
-                    raise ServicesUpError(f"Can't migrate service {target_service}, with {substituted_cmd}: {migration_result.finished=}"
-                                          f"\n{migration_result.stdout=}\n{migration_result.stderr=}\n"
-                                          f"\nServices status:\n {services_status.as_rich_text()}") from None
+                    raise ServicesUpError(
+                        f"Can't migrate service {target_service}, with {substituted_cmd}: "
+                        f"{migration_result.finished=}"
+                        f"\n{migration_result.stdout=}\n{migration_result.stderr=}\n"
+                        f"\nServices status:\n {services_status.as_rich_text()}"
+                    ) from None
 
     async def run_services_pack(self, services: list[str], migrations):
 
@@ -184,7 +189,6 @@ class ComposeInstance:
                 f"\nServices status:\n {services_status.as_rich_text()}"
             ) from None
 
-
         await self.run_migration(
             [EventStage.AFTER_SERVICE_START],
             services,
@@ -275,7 +279,6 @@ class ComposeInstance:
                     f"\nServices status:\n {services_status.as_rich_text()}"
                 ) from None
 
-
     async def logs(self, services=None) -> str:
         job_result, log = await self.compose_executor.dc_logs(services, logs_param='')
         return log.decode('utf-8') if job_result == JobResult.GOOD else ''

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/docker_compose_shell/interface.py

@@ -1,13 +1,12 @@
 import asyncio
+from asyncio import subprocess
+from dataclasses import dataclass
 import os
+from pathlib import Path
 import pprint
 import shlex
 import sys
-from asyncio import subprocess
-from dataclasses import dataclass
-from pathlib import Path
 from typing import Callable
-from typing import Coroutine
 from typing import NamedTuple
 
 from rich.text import Text
@@ -19,13 +18,9 @@ from uber_compose.core.utils.process_command_output import process_output_till_d
 from uber_compose.core.utils.shell_process import parse_process_command_name
 from uber_compose.helpers.jobs_result import JobResult
 from uber_compose.helpers.jobs_result import OperationError
-from uber_compose.output.console import CONSOLE
 from uber_compose.output.console import Logger
 from uber_compose.output.styles import Style
 
-DC_BIN = '/usr/bin/docker'
-COMPOSE = f'{DC_BIN} compose'
-
 
 class NoDockerCompose(BaseException):
     ...
@@ -68,28 +63,25 @@ class ComposeShellInterface:
             self.execution_envs |= execution_envs
         self.extra_exec_params = self.cfg_constants.docker_compose_extra_exec_params
 
+        self.compose_bin = '/usr/bin/docker'
+        self.compose_cmd = f'{self.compose_bin} compose'
+
         if self.cfg_constants.cli_compose_util_override:
             logger.system_commands(
                 f'Using overridden {self.cfg_constants.cli_compose_util_override} CLI compose command'
             )
+            self.compose_bin = self.cfg_constants.cli_compose_util_override
+            self.compose_cmd = self.cfg_constants.cli_compose_util_override
 
-            # for check binary existance
-            global DC_BIN
-            DC_BIN = self.cfg_constants.cli_compose_util_override
-
-            # for binary usage
-            global COMPOSE
-            COMPOSE = self.cfg_constants.cli_compose_util_override
-
-        # check if DC_BIN exists
-        if not Path(DC_BIN).exists():
+        if not Path(self.compose_bin).exists():
             raise NoDockerCompose(
-                f'Docker Compose binary not found at {DC_BIN}. Please install Docker Client with compose: \n   Alpine - apk add docker-cli docker-cli-compose\n   Debian/Ubuntu - apt install docker-ce-cli docker-compose-plugin')
-
-    @retry(attempts=10, delay=1, until=lambda x: x == JobResult.BAD)
-    async def dc_state(self, env: dict = None, root: Path | str = None) -> ServicesComposeState | OperationError:
-        sys.stdout.flush()
+                f'Docker Compose binary not found at {self.compose_bin}. '
+                'Please install Docker Client with compose: \n'
+                '   Alpine - apk add docker-cli docker-cli-compose\n'
+                '   Debian/Ubuntu - apt install docker-ce-cli docker-compose-plugin'
+            )
 
+    def _prepare_env_root(self, env: dict = None, root: Path | str = None) -> tuple[dict, str]:
         if env is None:
             env = {}
         env = self.execution_envs | env
@@ -97,8 +89,16 @@ class ComposeShellInterface:
         if root is None:
             root = self.in_docker_project_root
 
+        return env, root
+
+    @retry(attempts=10, delay=1, until=lambda x: x == JobResult.BAD)
+    async def dc_state(self, env: dict = None, root: Path | str = None) -> ServicesComposeState | OperationError:
+        sys.stdout.flush()
+
+        env, root = self._prepare_env_root(env, root)
+
         process = await asyncio.create_subprocess_shell(
-            cmd := f"{COMPOSE} --project-directory {root}" + " ps -a --format='{{json .}}'",
+            cmd := f"{self.compose_cmd} --project-directory {root}" + " ps -a --format='{{json .}}'",
             env=env,
             cwd=root,
             stdout=subprocess.PIPE,
@@ -122,15 +122,10 @@ class ComposeShellInterface:
     async def dc_up(self, services: list[str], env: dict = None, root: Path | str = None) -> JobResult | OperationError:
         sys.stdout.flush()
 
-        if env is None:
-            env = {}
-        env = self.execution_envs | env
-
-        if root is None:
-            root = self.in_docker_project_root
+        env, root = self._prepare_env_root(env, root)
 
         process = await asyncio.create_subprocess_shell(
-            cmd := f'{COMPOSE} --project-directory {root} up --timestamps --no-deps --pull missing '
+            cmd := f'{self.compose_cmd} --project-directory {root} up --timestamps --no-deps --pull missing '
                    '--timeout 300 -d ' + ' '.join(services),
             env=env,
             cwd=root,
@@ -157,19 +152,14 @@ class ComposeShellInterface:
                       ) -> tuple[JobResult, bytes] | tuple[OperationError, None]:
         sys.stdout.flush()
 
-        if env is None:
-            env = {}
-        env = self.execution_envs | env
-
-        if root is None:
-            root = self.in_docker_project_root
+        env, root = self._prepare_env_root(env, root)
 
         if services is None:
             services = []
         services = ' '.join(services)
 
         process = await asyncio.create_subprocess_shell(
-            cmd := f'{COMPOSE} --project-directory {root} logs {logs_param} {services}',
+            cmd := f'{self.compose_cmd} --project-directory {root} logs {logs_param} {services}',
             env=env,
             cwd=root,
             stdout=asyncio.subprocess.PIPE,
@@ -186,9 +176,12 @@ class ComposeShellInterface:
             state_result = await self.dc_state()
             if state_result == JobResult.GOOD:
                 return OperationError(
-                    f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result.as_rich_text()}'
+                    f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\n'
+                    f'ComposeState:\n{state_result.as_rich_text()}'
                 ), None
-            return OperationError(f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result}'), None
+            return OperationError(
+                f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result}'
+            ), None
 
         return JobResult.GOOD, stdout
 
@@ -205,19 +198,17 @@ class ComposeShellInterface:
             f'-e {key}={shlex.quote(str(value))}' for key, value in extra_env.items()
         )
 
-        if env is None:
-            env = {}
-        env = self.execution_envs | env
-
-        if root is None:
-            root = self.in_docker_project_root
+        env, root = self._prepare_env_root(env, root)
 
         detached_param_str = '-d' if detached else ''
         detached_end_str = ' &' if detached else ''
         detached_end_str = ''
 
         process = await asyncio.create_subprocess_shell(
-            cmd := f'{COMPOSE} --project-directory {root} exec {extra_env_str} {detached_param_str} {self.extra_exec_params} {container} {cmd} {detached_end_str}',
+            cmd := (
+                f'{self.compose_cmd} --project-directory {root} exec {extra_env_str} '
+                f'{detached_param_str} {self.extra_exec_params} {container} {cmd} {detached_end_str}'
+            ),
             env=env,
             cwd=root,
             stdout=asyncio.subprocess.PIPE,
@@ -237,7 +228,8 @@ class ComposeShellInterface:
             state_result = await self.dc_state()
             if state_result == JobResult.GOOD:
                 return OperationError(
-                    f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result.as_rich_text()}'
+                    f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\n'
+                    f'ComposeState:\n{state_result.as_rich_text()}'
                 ), stdout, stderr
             return OperationError(
                 f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result}'
@@ -249,17 +241,19 @@ class ComposeShellInterface:
                                     cmd: str,
                                     env: dict = None,
                                     root: Path | str = None,
-                                    ) -> tuple[JobResult, bytes, bytes] | list[int] | tuple[OperationError, bytes, bytes]:
-        if env is None:
-            env = {}
-        env = self.execution_envs | env
-
-        if root is None:
-            root = self.in_docker_project_root
+                                    ) -> (
+                                        tuple[JobResult, bytes, bytes]
+                                        | list[int]
+                                        | tuple[OperationError, bytes, bytes]
+                                    ):
+        env, root = self._prepare_env_root(env, root)
 
         cmd = parse_process_command_name(cmd)
         process_state = await asyncio.create_subprocess_shell(
-            check_cmd := f'{COMPOSE} --project-directory {root} exec {self.extra_exec_params} {container} pidof {cmd}',
+            check_cmd := (
+                f'{self.compose_cmd} --project-directory {root} exec '
+                f'{self.extra_exec_params} {container} pidof {cmd}'
+            ),
             env=env,
             cwd=root,
             stdout=asyncio.subprocess.PIPE,
@@ -272,7 +266,9 @@ class ComposeShellInterface:
         check_output = stdout.decode('utf-8')
         sys_error = stderr.decode("utf-8")
 
-        self.logger.system_commands_debug(f'Pids of command "{cmd}" in "{container}":\n {check_output} \nErr: {sys_error}')
+        self.logger.system_commands_debug(
+            f'Pids of command "{cmd}" in "{container}":\n {check_output} \nErr: {sys_error}'
+        )
 
         if check_output != '':
             try:
@@ -295,15 +291,10 @@ class ComposeShellInterface:
                                        env: dict = None,
                                        root: Path | str = None,
                                        ) -> None:
-        if env is None:
-            env = {}
-        env = self.execution_envs | env
-
-        if root is None:
-            root = self.in_docker_project_root
+        env, root = self._prepare_env_root(env, root)
 
         processes_state = await asyncio.create_subprocess_shell(
-            get_cmd := f'{COMPOSE} --project-directory {root} exec {self.extra_exec_params} {container} top -n 1',
+            f'{self.compose_cmd} --project-directory {root} exec {self.extra_exec_params} {container} top -n 1',
             env=env,
             cwd=root,
             stdout=asyncio.subprocess.PIPE,
@@ -403,15 +394,10 @@ class ComposeShellInterface:
         self.logger.stage_info(f'Downing {services} containers')
         sys.stdout.flush()
 
-        if env is None:
-            env = {}
-        env = self.execution_envs | env
-
-        if root is None:
-            root = self.in_docker_project_root
+        env, root = self._prepare_env_root(env, root)
 
         process = await asyncio.create_subprocess_shell(
-            cmd := f'{COMPOSE} --project-directory {root} down ' + ' '.join(services),
+            cmd := f'{self.compose_cmd} --project-directory {root} down ' + ' '.join(services),
             env=env,
             cwd=root,
             stdout=asyncio.subprocess.PIPE,
@@ -433,8 +419,11 @@ class ComposeShellInterface:
             state_result = await self.dc_state()
             if state_result == JobResult.GOOD:
                 return OperationError(
-                    f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result.as_rich_text()}'
+                    f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\n'
+                    f'ComposeState:\n{state_result.as_rich_text()}'
                 )
-            return OperationError(f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result}')
+            return OperationError(
+                f'Command: {cmd}\nStdout:\n{stdout}\n\nStderr:\n{stderr}\n\nComposeState:\n{state_result}'
+            )
 
         return JobResult.GOOD

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/docker_compose_shell/types.py

@@ -1,5 +1,5 @@
-import json
 from dataclasses import dataclass
+import json
 from typing import Callable
 from typing import Iterator
 
@@ -173,7 +173,7 @@ class ServicesComposeState:
             if service_state.check(label, value):
                 return service_state
 
-        return 
+        return None
 
     def __len__(self):
         return len(self._services)

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/system_docker_compose.py

@@ -1,17 +1,15 @@
-import pprint
-from itertools import groupby
 from pathlib import Path
+import pprint
 
 from rich.text import Text
+
 from uber_compose.core.constants import Constants
 from uber_compose.core.docker_compose_shell.interface import ComposeShellInterface
 from uber_compose.core.docker_compose_shell.types import ServicesComposeState
-from uber_compose.core.utils.compose_instance_cfg import get_service_map
 from uber_compose.env_description.env_types import Environment
 from uber_compose.helpers.bytes_pickle import base64_pickled
 from uber_compose.helpers.bytes_pickle import debase64_pickled
 from uber_compose.helpers.labels import Label
-from uber_compose.output.console import CONSOLE
 from uber_compose.output.console import Logger
 from uber_compose.output.styles import Style
 from uber_compose.utils.docker_compose_files_path import get_absolute_compose_files
@@ -29,7 +27,9 @@ class SystemDockerCompose:
             scan_for_compose_files(inner_project_root, self.cfg_constants.docker_compose_files_scan_depth)
         )
         self.logger.commands(f'All found compose files: {self.default_compose_files}')
-        assert self.default_compose_files, f'No docker-compose files found in the project root {inner_project_root} directory.'
+        assert self.default_compose_files, (
+            f'No docker-compose files found in the project root {inner_project_root} directory.'
+        )
 
         self.default_environment = make_default_environment(
             compose_files=get_absolute_compose_files(self.default_compose_files, inner_project_root),
@@ -54,7 +54,9 @@ class SystemDockerCompose:
         services_state = await self.dc_shell.dc_state()
         services_states = services_state.get_all_for(
             lambda service_state: (
-                service_state.check(Label.ENV_CONFIG_TEMPLATE, base64_pickled(Environment.from_environment(config_template)))
+                service_state.check(
+                    Label.ENV_CONFIG_TEMPLATE, base64_pickled(Environment.from_environment(config_template))
+                )
                 and service_state.check(Label.COMPOSE_FILES, compose_files)
             )
         )

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/utils/compose_files.py

@@ -1,12 +1,10 @@
 import collections
-import os
-import shutil
-from _warnings import warn
 from copy import deepcopy
+import os
 from pathlib import Path
+import shutil
 
 import yaml
-from uber_compose.env_description.env_types import OverridenService
 
 from uber_compose.core.sequence_run_types import ComposeInstanceFiles
 from uber_compose.core.sequence_run_types import EnvInstanceConfig
@@ -14,6 +12,7 @@ from uber_compose.core.utils.compose_instance_cfg import made_up_instance_compos
 from uber_compose.env_description.env_types import Environment
 from uber_compose.env_description.env_types import EventStage
 from uber_compose.env_description.env_types import Handler
+from uber_compose.env_description.env_types import OverridenService
 from uber_compose.errors.migrations import ServicesMigrationsError
 from uber_compose.helpers.bytes_pickle import base64_pickled
 from uber_compose.helpers.labels import Label
@@ -110,7 +109,12 @@ def patch_service_set(dc_cfg: dict, services_map: dict[str, str] | None):
     return new_dc_cfg
 
 
-def patch_envs(dc_cfg: dict, services_environment_vars: Environment, run_id, overridden_services: list[OverridenService] | None = None) -> dict:
+def patch_envs(
+    dc_cfg: dict,
+    services_environment_vars: Environment,
+    run_id,
+    overridden_services: list[OverridenService] | None = None,
+) -> dict:
     # TODO envs order and override question!!
     #  if we overrides env, should we save order? or insert before, for allow to override codegen
     new_dc_cfg = deepcopy(dc_cfg)
@@ -160,7 +164,11 @@ def patch_envs(dc_cfg: dict, services_environment_vars: Environment, run_id, ove
     return new_dc_cfg
 
 
-def patch_services_names(dc_cfg: dict, services_map: dict[str, str], overridden_services: list[OverridenService] | None = None) -> dict:
+def patch_services_names(
+    dc_cfg: dict,
+    services_map: dict[str, str],
+    overridden_services: list[OverridenService] | None = None,
+) -> dict:
     new_service_dc_cfg = deepcopy(dc_cfg)
     new_service_dc_cfg['services'] = {}
 
@@ -438,7 +446,8 @@ def parse_docker_compose(file_paths):
 
 
 def topological_sort(services_dict):
-    from collections import defaultdict, deque
+    from collections import defaultdict
+    from collections import deque
 
     # Prepare the adjacency list
     graph = defaultdict(list)
@@ -456,7 +465,6 @@ def topological_sort(services_dict):
     topologically_sorted_services = []
 
     while zero_in_degree_queue:
-        level_services = list(zero_in_degree_queue)
         for _ in range(len(zero_in_degree_queue)):
             node = zero_in_degree_queue.popleft()
             topologically_sorted_services.append(node)

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/utils/env_files.py

@@ -12,9 +12,9 @@ def make_debug_bash_env(env_config_compose_instance: ComposeInstanceFiles,
     )
 
     with open(env_config_compose_instance.directory / '.env', 'w') as f:
-        f.write(f'alias dc="docker-compose --project-directory ."\n')
+        f.write('alias dc="docker-compose --project-directory ."\n')
         f.write(f'export COMPOSE_FILE={new_external_compose_file}\n')
-        f.write(f'alias deactivate-env="unset COMPOSE_FILE"\n')
+        f.write('alias deactivate-env="unset COMPOSE_FILE"\n')
         # TODO Envs
         # for k,value in updated_envs.items():
         #     f.write(f'{k}={value}\n')

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/utils/state_waiting.py

@@ -42,7 +42,7 @@ async def wait_all_services_up(attempts, delay_s, logger_func: Callable, get_com
         ]
 
         if not non_ready_services:
-            logger_func(Text(f' ✔ All services up\n', style=output_style.mark_neutral))
+            logger_func(Text(' ✔ All services up\n', style=output_style.mark_neutral))
             return JobResult.GOOD
 
         # some service not ready routine
@@ -54,7 +54,7 @@ async def wait_all_services_up(attempts, delay_s, logger_func: Callable, get_com
             return JobResult.BAD
 
         if state_keeper.not_in_state(services_state):
-            logger_func(Text(f' ✗ Still not ready services:', style=output_style.bad))
+            logger_func(Text(' ✗ Still not ready services:', style=output_style.bad))
             logger_func(services_state.as_rich_text(
                 filter=is_service_in_bad_state,
                 style=output_style

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/env_description/env_types.py

@@ -84,6 +84,8 @@ class Service(NamedTuple):
     mode: ServiceMode = ServiceMode.ON
 
     def __eq__(self, other):
+        if not isinstance(other, Service):
+            return False
         return self.name == other.name
 
     def __repr__(self):
@@ -129,7 +131,9 @@ def remove_dups(*services: Service) -> List[Service]:
 
 class Environment:  # TODO rename Environment
     @classmethod
-    def from_environment(cls, env: 'Environment', *services: Service, description='', services_override = None) -> 'Environment':
+    def from_environment(
+        cls, env: 'Environment', *services: Service, description='', services_override=None,
+    ) -> 'Environment':
         # TODO duplicated services merging
         description = description or env._description
         services_overrides = []
@@ -139,7 +143,9 @@ class Environment:  # TODO rename Environment
             services_overrides += env._services_override
         return Environment(*env._services, *services, description=description, services_override=services_overrides)
 
-    def __init__(self, *services: Service | str, description='', services_override: List[OverridenService] | None = None):
+    def __init__(
+        self, *services: Service | str, description='', services_override: List[OverridenService] | None = None,
+    ):
         # TODO duplicated services merging
         self._description = description
         services = [

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/helpers/broken_services.py

@@ -24,5 +24,6 @@ def calc_broken_services(
         if service.service.name not in services_state.get_services_names()
     ]
     return list(
-        set(non_ready_services) | set(not_included_services) - set(excluded_from_check) - set(skipped_overridden_services)
+        set(non_ready_services) | set(not_included_services)
+        - set(excluded_from_check) - set(skipped_overridden_services)
     )

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/helpers/exec_result.py

@@ -1,4 +1,3 @@
-from dataclasses import dataclass
 from typing import NamedTuple
 
 

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/output/console.py

@@ -37,7 +37,10 @@ class LogPolicySet:
 
 class LogPolicy:
     DEFAULT = LogPolicySet(LogEvents.STAGE, LogEvents.ERROR)
-    VERBOSE = LogPolicySet(LogEvents.STAGE, LogEvents.STAGE_INFO, LogEvents.STAGE_DETAILS, LogEvents.ERROR, LogEvents.COMMANDS, LogEvents.COMMAND_OUTPUT)
+    VERBOSE = LogPolicySet(
+        LogEvents.STAGE, LogEvents.STAGE_INFO, LogEvents.STAGE_DETAILS,
+        LogEvents.ERROR, LogEvents.COMMANDS, LogEvents.COMMAND_OUTPUT,
+    )
     DEBUG = LogPolicySet(LogEvents.GLOBAL_DEBUG)
 
     @staticmethod
@@ -51,7 +54,7 @@ class LogPolicy:
 
 # TODO collect all into file and on level in stdout
 class Logger:
-    def __init__(self, log_policy: LogPolicySet = None, cfg_constants = None):
+    def __init__(self, log_policy: LogPolicySet = None, cfg_constants=None):
         if cfg_constants is None:
             cfg_constants = Constants()
         if log_policy is None:
@@ -64,7 +67,7 @@ class Logger:
         if LogEvents.GLOBAL_DEBUG in self.log_policy:
             if line_no == 0:
                 self.stream.print(f'{level}:', style='bold grey15 on green', end='')
-                self.stream.print(f'', style='white on default')
+                self.stream.print('', style='white on default')
             self.stream.print(text)
             return
 

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/uber_compose.py

@@ -1,19 +1,17 @@
-import shlex
 from dataclasses import dataclass
-from typing import Any
+import shlex
 from typing import Callable
 from uuid import uuid4
 
 from rich.text import Text
 
-from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
-from uber_compose.core.docker_compose_shell.interface import TimeOutCheck
-from uber_compose.core.docker_compose_shell.types import ServicesComposeState
-
 from uber_compose.core.constants import Constants
 from uber_compose.core.docker_compose import ComposeInstance
 from uber_compose.core.docker_compose_shell.interface import ComposeShellInterface
 from uber_compose.core.docker_compose_shell.interface import ProcessExit
+from uber_compose.core.docker_compose_shell.interface import TimeOutCheck
+from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
+from uber_compose.core.docker_compose_shell.types import ServicesComposeState
 from uber_compose.core.sequence_run_types import DEFAULT_ENV_ID
 from uber_compose.core.system_docker_compose import SystemDockerCompose
 from uber_compose.core.utils.compose_instance_cfg import get_new_env_id
@@ -71,9 +69,30 @@ class SystemUberCompose:
                  services_override: list[OverridenService] | None = None,
                  ) -> ReadyEnv:
 
+        compose_files = self._resolve_compose_files(compose_files)
+        config_template = self._resolve_config_template(config_template, compose_files, services_override)
+
+        services_state = await self._get_current_state(config_template, compose_files)
+
+        reusable_env = self._find_reusable_env(services_state, config_template, force_restart)
+        if reusable_env is not None:
+            return reusable_env
+
+        self._log_inflight_and_restart_info(services_state, force_restart)
+
+        return await self._start_new_environment(config_template, compose_files, release_id, parallelism_limit)
+
+    def _resolve_compose_files(self, compose_files: str | None) -> str:
         if not compose_files:
             compose_files = self.system_docker_compose.get_default_compose_files()
-
+        return compose_files
+
+    def _resolve_config_template(
+        self,
+        config_template: Environment | None,
+        compose_files: str,
+        services_override: list[OverridenService] | None,
+    ) -> Environment:
         if not config_template:
             config_template = make_default_environment(
                 compose_files=get_absolute_compose_files(compose_files, self.cfg_constants.in_docker_project_root_path),
@@ -82,6 +101,9 @@ class SystemUberCompose:
         if services_override:
             config_template = config_template.from_environment(config_template, services_override=services_override)
 
+        return config_template
+
+    async def _get_current_state(self, config_template: Environment, compose_files: str) -> ServicesComposeState:
         self.logger.stage_debug(
             f'Searching for environment {config_template} with template: {base64_pickled(config_template)}'
         )
@@ -92,28 +114,50 @@ class SystemUberCompose:
         self.logger.stage_debug(
             f'Found environments containers: {services_state}'
         )
+        return services_state
+
+    def _should_restart(self, services_state: ServicesComposeState, broken_services: list, force_restart: bool) -> bool:
+        return len(services_state) == 0 or len(broken_services) != 0 or force_restart
+
+    def _find_reusable_env(
+        self,
+        services_state: ServicesComposeState,
+        config_template: Environment,
+        force_restart: bool,
+    ) -> ReadyEnv | None:
         broken_services = calc_broken_services(services_state, config_template, self.cfg_constants.non_stop_containers)
         if broken_services:
             self.logger.stage(
                 Text(
-                    f'Not started or not ready containers in current environment: ', style=Style.suspicious
+                    'Not started or not ready containers in current environment: ', style=Style.suspicious
                 ).append(Text(f'{broken_services}', style=Style.regular))
             )
-        if len(services_state) != 0 and len(broken_services) == 0 and not force_restart:
-            existing_env_id = services_state.get_any().labels.get(Label.ENV_ID, None)
-            env_config = debase64_pickled(services_state.get_any().labels.get(Label.ENV_CONFIG))
-            _for = f' for {config_template.description}' if config_template.description else ''
-            self.logger.stage_details(Text(
-                f'Found suitable{_for} ready env: ', style=Style.info
-            ).append(Text(existing_env_id, style=Style.mark)))
-
-            last_release_id = services_state.get_any().labels.get(Label.RELEASE_ID)
-            self.last_release_id = last_release_id
-            return ReadyEnv(existing_env_id, env_config, last_release_id)
 
+        if self._should_restart(services_state, broken_services, force_restart):
+            return None
+
+        existing_env_id = services_state.get_any().labels.get(Label.ENV_ID, None)
+        env_config = debase64_pickled(services_state.get_any().labels.get(Label.ENV_CONFIG))
+        _for = f' for {config_template.description}' if config_template.description else ''
+        self.logger.stage_details(Text(
+            f'Found suitable{_for} ready env: ', style=Style.info
+        ).append(Text(existing_env_id, style=Style.mark)))
+
+        last_release_id = services_state.get_any().labels.get(Label.RELEASE_ID)
+        self.last_release_id = last_release_id
+        return ReadyEnv(existing_env_id, env_config, last_release_id)
+
+    def _log_inflight_and_restart_info(self, services_state: ServicesComposeState, force_restart: bool) -> None:
+        in_flight_templates = [
+            (
+                debase64_pickled(service["labels"][Label.ENV_CONFIG_TEMPLATE]),
+                service["labels"][Label.ENV_CONFIG_TEMPLATE],
+            )
+            for service in services_state.as_json()
+        ]
         self.logger.stage_debug(
             f'In-flight containers:\n'
-            f'{[(debase64_pickled(service["labels"][Label.ENV_CONFIG_TEMPLATE]), service["labels"][Label.ENV_CONFIG_TEMPLATE]) for service in services_state.as_json()]}'
+            f'{in_flight_templates}'
         )
         if force_restart:
             self.logger.stage_details(Text(
@@ -123,7 +167,13 @@ class SystemUberCompose:
                 f'Previous state {services_state.as_json()}', style=Style.info
             ))
 
-
+    async def _start_new_environment(
+        self,
+        config_template: Environment,
+        compose_files: str,
+        release_id: str | None,
+        parallelism_limit: int,
+    ) -> ReadyEnv:
         _for = f' {config_template.description}' if config_template.description else ''
         self.logger.stage(Text(f'Starting new{_for} environment', style=Style.info))
         self.logger.stage_details(f'Use compose files: {compose_files}')
@@ -164,7 +214,7 @@ class SystemUberCompose:
 
         # TODO check if ready by state checking
 
-        self.logger.stage_info(Text(f'New environment started'))
+        self.logger.stage_info(Text('New environment started'))
 
         return ReadyEnv(
             new_env_id,
@@ -191,7 +241,7 @@ class SystemUberCompose:
 
         service_state = dc_state.get_all_for(
             lambda service_state: service_state.check(Label.ENV_ID, env_id)
-                                  and service_state.check(Label.TEMPLATE_SERVICE_NAME, container)
+            and service_state.check(Label.TEMPLATE_SERVICE_NAME, container)
         )
         if len(service_state.as_json()) != 1:
             raise ValueError(f'Container {container} not found in environment {env_id}')

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/utils/services_construction.py

@@ -1,6 +1,5 @@
 from uber_compose.env_description.env_types import Environment
 from uber_compose.env_description.env_types import Service
-from uber_compose.utils.docker_compose_files_path import get_absolute_compose_files
 from uber_compose.utils.docker_compose_service_deps import parse_docker_compose_services_deps
 
 

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/vedro_plugin/base_structures/common_json_cli.py

@@ -1,6 +1,6 @@
+from dataclasses import dataclass
 import json
 import re
-from dataclasses import dataclass
 from typing import Callable
 from typing import Generic
 from typing import List
@@ -9,13 +9,10 @@ from typing import Type
 from typing import TypeVar
 from warnings import warn
 
-from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
-from uber_compose.helpers.exec_result import ExecResult
-
+from uber_compose.core.docker_compose_shell.interface import ProcessExit
 from uber_compose.core.docker_compose_shell.interface import TimeOutCheck
+from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
 from uber_compose.uber_compose import SystemUberCompose
-
-from uber_compose.core.docker_compose_shell.interface import ProcessExit
 from uber_compose.uber_compose import TheUberCompose
 
 
@@ -246,7 +243,10 @@ class CommonJsonCli(Generic[TCommandResult]):
             timeout = self._timeout
 
         if container is None:
-            assert self._container is not None, 'No container specified. Container must be specified either in method call or in CommonJsonCli initialization'
+            assert self._container is not None, (
+                'No container specified. Container must be specified either in method call '
+                'or in CommonJsonCli initialization'
+            )
             container = self._container
 
         if life_cycle_policy is None:

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/vedro_plugin/helpers/test_env_vars_setter.py

@@ -1,5 +1,4 @@
 import os
-from _warnings import warn
 
 from uber_compose.env_description.env_types import Environment
 from uber_compose.env_description.env_types import OverridenService

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/vedro_plugin/plugin.py

@@ -1,24 +1,22 @@
-from collections import OrderedDict
 import sys
 from typing import Type
 from typing import Union
 from uuid import uuid4
 
-import vedro.events
 from rich.text import Text
 from vedro.core import ConfigType
 from vedro.core import Dispatcher
 from vedro.core import Plugin
 from vedro.core import PluginConfig
+import vedro.events
 from vedro.events import ArgParseEvent
 from vedro.events import ArgParsedEvent
 from vedro.events import ConfigLoadedEvent
 from vedro.events import ScenarioRunEvent
 from vedro.events import StartupEvent
 
-from uber_compose import SystemUberCompose
-from uber_compose.output.styles import Style
 from uber_compose import Environment
+from uber_compose import SystemUberCompose
 from uber_compose.core.constants import Constants
 from uber_compose.core.sequence_run_types import ComposeConfig
 from uber_compose.env_description.env_types import DEFAULT_ENV_DESCRIPTION
@@ -26,6 +24,7 @@ from uber_compose.env_description.env_types import OverridenService
 from uber_compose.helpers.health_policy import UpHealthPolicy
 from uber_compose.output.console import LogPolicy
 from uber_compose.output.console import Logger
+from uber_compose.output.styles import Style
 from uber_compose.uber_compose import TheUberCompose as TheUberCompose
 from uber_compose.vedro_plugin.helpers.scenario_ordering import EnvTagsOrderer
 from uber_compose.vedro_plugin.helpers.scenario_tag_processing import extract_scenario_config
@@ -35,12 +34,15 @@ from uber_compose.vedro_plugin.helpers.test_env_vars_setter import setup_env_for
 
 DEFAULT_COMPOSE = 'default'
 
+
 class VedroUberComposePlugin(Plugin):
     def __init__(self, config: Type["VedroUberCompose"], client: SystemUberCompose = None) -> None:
         super().__init__(config)
         self._enabled = config.enabled
         if config.default_env:
-            assert config.default_env._description == DEFAULT_ENV_DESCRIPTION, 'default_env must have description set to DEFAULT_ENV_DESCRIPTION'
+            assert config.default_env._description == DEFAULT_ENV_DESCRIPTION, (
+                'default_env must have description set to DEFAULT_ENV_DESCRIPTION'
+            )
         self._default_env: Environment = config.default_env
 
         # cli args
@@ -94,8 +96,18 @@ class VedroUberComposePlugin(Plugin):
         try:
             if self._compose_choice.parallel_env_limit >= len(needed_configs):
                 for env_config in list(needed_configs):
-                    if env_config == None:
+                    if self._default_env is None and env_config is None:
+                        self._logger.stage(
+                            Text(
+                                '[UberCompose] Warning: some scenarios has no "env" field set.\n'
+                                'Consider adding "env = Envs.DEFAULT" to your scenario.',
+                                style=Style.suspicious
+                            )
+                        )
+
+                    if env_config is None:
                         env_config = self._default_env
+
                     await self._uber_compose_client.up(
                         config_template=env_config,
                         compose_files=self._compose_choice.compose_files,
@@ -115,7 +127,7 @@ class VedroUberComposePlugin(Plugin):
         if self._just_up:
             self._logger.stage(
                 Text(
-                    f'Environment has been started successfully. Exiting as requested.',
+                    'Environment has been started successfully. Exiting as requested.',
                     style=Style.good
                 )
             )

uber_compose-2.3.3/uber_compose/version

@@ -0,0 +1 @@
+2.3.3

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/version.py

@@ -2,5 +2,6 @@ import os
 
 path = os.path.abspath(os.path.dirname(__file__))
 
+
 def get_version(filename=f'{path}/version'):
     return open(filename, "r").read().strip()

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uber-compose
-Version: 2.3.1a2002
+Version: 2.3.3
 Summary: docker compose testing env orchestrator
 Home-page: https://github.com/ko10ok/uber-compose
 Author: Yuriy Sagitov

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+setup.cfg
 setup.py
 uber_compose/__init__.py
 uber_compose/uber_compose.py

uber_compose-2.3.1a2002/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

uber_compose-2.3.1a2002/uber_compose/version

@@ -1 +0,0 @@
-2.3.1

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/__init__.py

@@ -1,6 +1,6 @@
-from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
 from uber_compose.core.docker_compose_shell.interface import ProcessExit
 from uber_compose.core.docker_compose_shell.interface import TimeOutCheck
+from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
 from uber_compose.core.sequence_run_types import ComposeConfig
 from uber_compose.core.sequence_run_types import DEFAULT_ENV_ID
 from uber_compose.env_description.env_types import DEFAULT_ENV_DESCRIPTION

{uber_compose-2.3.1a2002 → uber_compose-2.3.3}/uber_compose/core/sequence_run_types.py

@@ -2,8 +2,8 @@ from pathlib import Path
 from typing import NamedTuple
 from typing import Union
 
-from uber_compose.env_description.env_types import OverridenService
 from uber_compose.env_description.env_types import Environment
+from uber_compose.env_description.env_types import OverridenService
 
 DEFAULT_ENV_ID = 'default_env_id'