thestage 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

thestage/{services/container → docker_container/business}/container_service.py

@@ -1,38 +1,47 @@
+import re
 from pathlib import Path
 from typing import List, Tuple, Optional, Dict
+from rich import print
 
 import typer
-from thestage.entities.container import DockerContainerEntity
-from thestage.services.clients.thestage_api.dtos.container_param_request import DockerContainerActionRequestDto
-from thestage.services.clients.thestage_api.dtos.enums.container_pending_action import DockerContainerAction
-from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
-from thestage.entities.enums.shell_type import ShellType
+
+from thestage.color_scheme.color_scheme import ColorScheme
+from thestage.connect.communication.connect_api_client import ConnectApiClient
+from thestage.docker_container.communication.docker_container_api_client import DockerContainerApiClient
+from thestage.docker_container.dto.container_entity import DockerContainerEntity
+from thestage.docker_container.dto.container_action_request import DockerContainerActionRequest
+from thestage.docker_container.dto.enum.container_pending_action import DockerContainerAction
+from thestage.docker_container.dto.enum.container_status import DockerContainerStatus
+from thestage.global_dto.enums.shell_type import ShellType
 from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
-from thestage.services.container.mapper.container_mapper import ContainerMapper
+from thestage.docker_container.business.mapper.container_mapper import ContainerMapper
 from thestage.services.filesystem_service import FileSystemService
-from thestage.services.remote_server_service import RemoteServerService
+from thestage.connect.business.remote_server_service import RemoteServerService
 from thestage.i18n.translation import __
 from thestage.services.abstract_service import AbstractService
-from thestage.services.clients.thestage_api.dtos.container_response import DockerContainerDto
+from thestage.docker_container.dto.container_response import DockerContainerDto
 from thestage.helpers.error_handler import error_handler
-from thestage.services.clients.thestage_api.api_client import TheStageApiClient
-from thestage.services.config_provider.config_provider import ConfigProvider
+from thestage.config.business.config_provider import ConfigProvider
 
 
 class ContainerService(AbstractService):
 
-    __thestage_api_client: TheStageApiClient = None
+    __docker_container_api_client: DockerContainerApiClient = None
     __config_provider: ConfigProvider = None
+    __connect_api_client: ConnectApiClient = None
 
     def __init__(
             self,
-            thestage_api_client: TheStageApiClient,
+            docker_container_api_client: DockerContainerApiClient,
             config_provider: ConfigProvider,
             remote_server_service: RemoteServerService,
             file_system_service: FileSystemService,
+            connect_api_client: ConnectApiClient,
+
     ):
         self.__config_provider = config_provider
-        self.__thestage_api_client = thestage_api_client
+        self.__connect_api_client = connect_api_client
+        self.__docker_container_api_client = docker_container_api_client
         self.__remote_server_service = remote_server_service
         self.__file_system_service = file_system_service
 
@@ -46,7 +55,7 @@ class ContainerService(AbstractService):
             project_slug: Optional[str],
             statuses: List[str],
     ):
-        container_status_map = self.__thestage_api_client.get_container_business_status_map()
+        container_status_map = self.__docker_container_api_client.get_container_business_status_map()
 
         if not statuses:
             statuses = ({key: container_status_map[key] for key in [
@@ -99,7 +108,7 @@ class ContainerService(AbstractService):
             project_slug: Optional[str] = None,
     ) -> PaginatedEntityList[DockerContainerDto]:
 
-        list = self.__thestage_api_client.get_container_list(
+        list = self.__docker_container_api_client.get_container_list(
             statuses=statuses,
             page=page,
             limit=row,
@@ -116,7 +125,7 @@ class ContainerService(AbstractService):
             container_public_id: Optional[str] = None,
             container_slug: Optional[str] = None,
     ) -> Optional[DockerContainerDto]:
-        return self.__thestage_api_client.get_container(
+        return self.__docker_container_api_client.get_container(
             container_public_id=container_public_id,
             container_slug=container_slug,
         )
@@ -150,7 +159,7 @@ class ContainerService(AbstractService):
             if private_key_path:
                 typer.echo(f'Using configured private key for {ip_address}: {private_key_path}')
             else:
-                typer.echo(f'Using SSH agent to connect to {ip_address}')
+                typer.echo(f'Using SSH agent to connect to {ip_address} as {username}')
         else:
             self.__config_provider.update_remote_server_config_entry(ip_address, Path(private_key_path))
             typer.echo(f'Updated private key path for {ip_address}: {private_key_path}')
@@ -267,22 +276,49 @@ class ContainerService(AbstractService):
     @error_handler()
     def put_file_to_container(
             self,
-            container: DockerContainerDto,
-            src_path: str,
-            copy_only_folder_contents: bool,
-            destination_path: Optional[str] = None,
-            username_param: Optional[str] = None,
+            source_path: str,
+            destination: str,
+            username_param: Optional[str],
     ):
-        if not self.__file_system_service.check_if_path_exist(file=src_path):
-            typer.echo(__("File not found at specified path"))
+        container_args = re.match(r"^([\w\W]+?):([\w\W]+)$", destination)
+        if container_args is None:
+            typer.echo(__('Container name and source file path are required as the second argument'))
+            typer.echo(__('Example: container_name:/path/to/file'))
             raise typer.Exit(1)
+        container_identifier = container_args.groups()[0]
+        destination_path = container_args.groups()[1].rstrip("/")
 
-        username, ip_address, private_key_path = self.get_server_auth(
-            container=container,
-            username_param=username_param,
-            private_key_path_override=None
+        if not container_identifier:
+            typer.echo('Container identifier (container_id_or_name) is required')
+            raise typer.Exit(1)
+
+        resolved_options = self.__connect_api_client.resolve_user_input(entity_identifier=container_identifier)
+        container_public_id = None
+        valid_container_count = 0
+        for container_item in resolved_options.dockerContainerMatchData:
+            message = f"Found a container with matching {container_item.matchedField} in status: '{container_item.frontendStatus.status_translation}' (ID: {container_item.publicId})"
+            line_color = ColorScheme.SUCCESS.value if container_item.canDownloadUploadOnContainer else 'default'
+            print(f"[{line_color}]{message}[{line_color}]")
+            if container_item.canDownloadUploadOnContainer:
+                valid_container_count += 1
+                container_public_id = container_item.publicId
+
+        if valid_container_count != 1:
+            typer.echo(f"Failed to resolve the container by provided identifier, as total of {valid_container_count} containers are valid options")
+            raise typer.Exit(1)
+
+        container: Optional[DockerContainerDto] = self.__docker_container_api_client.get_container(
+            container_public_id=container_public_id,
         )
 
+        if not container:
+            typer.echo(f"Unexpected error: container '{container_public_id}' not found")
+            raise typer.Exit(1)
+
+        if not self.__file_system_service.check_if_path_exist(file=source_path):
+            typer.echo(__("File not found at specified path"))
+            raise typer.Exit(1)
+
         if not container.mappings or not container.mappings.directory_mappings:
             typer.echo(__("Mapping folders not found"))
             raise typer.Exit(1)
@@ -296,10 +332,18 @@ class ContainerService(AbstractService):
             typer.echo(__("Cannot find matching container volume mapping for specified file path"))
             raise typer.Exit(1)
 
+        username, ip_address, private_key_path = self.get_server_auth(
+            container=container,
+            username_param=username_param,
+            private_key_path_override=None
+        )
+
+        copy_only_folder_contents = source_path.endswith("/")
+
         self.__remote_server_service.upload_data_to_container(
             ip_address=ip_address,
             username=username,
-            src_path=src_path,
+            src_path=source_path,
             dest_path=destination_path,
             instance_path=instance_path,
             container_path=container_path,
@@ -310,31 +354,67 @@ class ContainerService(AbstractService):
     @error_handler()
     def get_file_from_container(
             self,
-            container: DockerContainerDto,
-            src_path: str,
-            copy_only_folder_contents: bool,
-            destination_path: Optional[str] = None,
+            source: str,
+            destination_path: str,
             username_param: Optional[str] = None,
     ):
-        username, ip_address, private_key_path = self.get_server_auth(
-            container=container,
-            username_param=username_param,
-            private_key_path_override=None,
+        container_args = re.match(r"^([\w\W]+?):([\w\W]+)$", source)
+
+        if container_args is None:
+            typer.echo(__('Container name and source directory path are required as the first argument'))
+            typer.echo(__('Example: container_name:/path/to/file'))
+            raise typer.Exit(1)
+        container_identifier = container_args.groups()[0]
+        source_path = container_args.groups()[1]
+
+        if not container_identifier:
+            typer.echo('Container identifier (container_id_or_name) is required')
+            raise typer.Exit(1)
+
+        resolved_options = self.__connect_api_client.resolve_user_input(entity_identifier=container_identifier)
+        container_public_id = None
+        valid_container_count = 0
+        for container_item in resolved_options.dockerContainerMatchData:
+            message = f"Found a container with matching {container_item.matchedField} in status: '{container_item.frontendStatus.status_translation}' (ID: {container_item.publicId})"
+            line_color = ColorScheme.SUCCESS.value if container_item.canDownloadUploadOnContainer else 'default'
+            print(f"[{line_color}]{message}[{line_color}]")
+            if container_item.canDownloadUploadOnContainer:
+                valid_container_count += 1
+                container_public_id = container_item.publicId
+
+        if valid_container_count != 1:
+            typer.echo(f"Failed to resolve the container by provided identifier, as total of {valid_container_count} containers are valid options")
+            raise typer.Exit(1)
+
+        container: Optional[DockerContainerDto] = self.__docker_container_api_client.get_container(
+            container_public_id=container_public_id,
         )
 
+        if not container:
+            typer.echo(f"Unexpected error: container '{container_public_id}' not found")
+            raise typer.Exit(1)
+
         if not container.mappings or not container.mappings.directory_mappings:
             typer.echo(__("Mapping folders not found"))
             raise typer.Exit(1)
 
         instance_path, container_path = self._get_new_path_from_mapping(
             directory_mapping=container.mappings.directory_mappings,
-            destination_path=src_path,
+            destination_path=source_path,
         )
 
         if not instance_path and not container_path:
             typer.echo(__("Cannot find matching container volume mapping for specified file path"))
             raise typer.Exit(1)
 
+        username, ip_address, private_key_path = self.get_server_auth(
+            container=container,
+            username_param=username_param,
+            private_key_path_override=None,
+        )
+
+        copy_only_folder_contents=source_path.endswith("/")
+
         self.__remote_server_service.download_data_from_container(
             ip_address=ip_address,
             username=username,
@@ -366,11 +446,11 @@ class ContainerService(AbstractService):
         if action in [DockerContainerAction.STOP, DockerContainerAction.RESTART]:
             self.check_if_container_running(container=container)
 
-        request_params = DockerContainerActionRequestDto(
+        request_params = DockerContainerActionRequest(
             dockerContainerPublicId=container.public_id,
             action=action,
         )
-        result = self.__thestage_api_client.container_action(
+        result = self.__docker_container_api_client.container_action(
             request_param=request_params,
         )
 

thestage/{services/container → docker_container/business}/mapper/container_mapper.py

@@ -1,7 +1,7 @@
-from typing import Optional, Tuple
+from typing import Optional
 
-from thestage.services.clients.thestage_api.dtos.container_response import DockerContainerDto
-from thestage.entities.container import DockerContainerEntity
+from thestage.docker_container.dto.container_response import DockerContainerDto
+from thestage.docker_container.dto.container_entity import DockerContainerEntity
 from thestage.services.abstract_mapper import AbstractMapper
 
 

thestage/{controllers/container_controller.py → docker_container/communication/docker_command.py}

@@ -1,20 +1,17 @@
-
-import re
 from pathlib import Path
 from typing import Optional, List
 
+import typer
+
 from thestage.cli_command import CliCommand
 from thestage.cli_command_helper import get_command_metadata, check_command_permission
-from thestage.services.clients.thestage_api.dtos.enums.container_pending_action import DockerContainerAction
-from thestage.services.clients.thestage_api.dtos.container_response import DockerContainerDto
-from thestage.i18n.translation import __
-from thestage.services.container.container_service import ContainerService
-from thestage.helpers.logger.app_logger import app_logger
 from thestage.controllers.utils_controller import validate_config_and_get_service_factory, get_current_directory
-
-import typer
-
-from thestage.services.logging.logging_service import LoggingService
+from thestage.docker_container.business.container_service import ContainerService
+from thestage.docker_container.dto.container_response import DockerContainerDto
+from thestage.docker_container.dto.enum.container_pending_action import DockerContainerAction
+from thestage.helpers.logger.app_logger import app_logger
+from thestage.i18n.translation import __
+from thestage.logging.business.logging_service import LoggingService
 
 app = typer.Typer(no_args_is_help=True, help=__("Manage containers"))
 
@@ -62,7 +59,7 @@ def list_containers(
     check_command_permission(command_name)
 
     if sum(v is not None for v in [project_public_id, project_slug]) > 1:
-        typer.echo("Please provide a single identifier for project - ID or name.")
+        typer.echo("Provide a single identifier for project - ID or name.")
         raise typer.Exit(1)
 
     service_factory = validate_config_and_get_service_factory()
@@ -101,7 +98,7 @@ def container_info(
     check_command_permission(command_name)
 
     if sum(v is not None for v in [container_public_id, container_slug]) != 1:
-        typer.echo("Please provide a single identifier for container - ID or name.")
+        typer.echo("Provide a single identifier for container - ID or name.")
         raise typer.Exit(1)
 
     service_factory = validate_config_and_get_service_factory()
@@ -191,7 +188,7 @@ def container_connect(
     check_command_permission(command_name)
 
     if sum(v is not None for v in [container_public_id, container_slug]) != 1:
-        typer.echo("Please provide a single identifier for container - ID or name.")
+        typer.echo("Provide a single identifier for container - ID or name.")
         raise typer.Exit(1)
 
     if private_ssh_key_path and not Path(private_ssh_key_path).is_file():
@@ -215,7 +212,7 @@ def container_connect(
 @app.command(name="upload", no_args_is_help=True, help=__("Upload file to container"), **get_command_metadata(CliCommand.CONTAINER_UPLOAD))
 def upload_file(
         source_path: str = typer.Argument(help=__("Source file path"),),
-        destination: Optional[str] = typer.Argument(help=__("Destination directory path in container. Format: container_name:/path/to/file"),),
+        destination: Optional[str] = typer.Argument(help=__("Destination directory path in container. Format: container_id_or_name:/path/to/file"),),
         username: Optional[str] = typer.Option(
             None,
             '--username',
@@ -228,50 +225,22 @@ def upload_file(
     app_logger.info(f'Running {command_name} from {get_current_directory()}')
     check_command_permission(command_name)
 
-    container_args = re.match(r"^([\w\W]+?):([\w\W]+)$", destination)
-
-    if container_args is None:
-        typer.echo(__('Container name and source file path are required as the second argument'))
-        typer.echo(__('Example: container_uid:/path/to/file'))
-        raise typer.Exit(1)
-    container_slug = container_args.groups()[0]
-    destination_path = container_args.groups()[1].rstrip("/")
-
-    if not container_slug:
-        typer.echo(__('Container name is required'))
-        raise typer.Exit(1)
-
     service_factory = validate_config_and_get_service_factory()
     container_service: ContainerService = service_factory.get_container_service()
 
-    container: Optional[DockerContainerDto] = container_service.get_container(
-        container_slug=container_slug,
+    container_service.put_file_to_container(
+        source_path=source_path,
+        destination=destination,
+        username_param=username,
     )
 
-    if container:
-        container_service.check_if_container_running(
-            container=container
-        )
-
-        typer.echo(f"Uploading file(s) to container '{container_slug}'")
-
-        container_service.put_file_to_container(
-            container=container,
-            src_path=source_path,
-            destination_path=destination_path,
-            username_param=username,
-            copy_only_folder_contents=source_path.endswith("/")
-        )
-    else:
-        typer.echo(__("Container not found: %container_item%", {'container_item': container_slug}))
-
-    app_logger.info(f'End send files to container')
+    app_logger.info(f'File upload completed')
     raise typer.Exit(0)
 
 
 @app.command(name="download", no_args_is_help=True, help=__("Download file from container"), **get_command_metadata(CliCommand.CONTAINER_DOWNLOAD))
 def download_file(
-        source_path: str = typer.Argument(help=__("Source file path in container. Format: container_name:/path/to/file"),),
+        source: str = typer.Argument(help=__("Source file path in container. Format: container_name:/path/to/file"),),
         destination_path: str = typer.Argument(help=__("Destination directory path on local machine"),),
         username: Optional[str] = typer.Option(
             None,
@@ -285,44 +254,16 @@ def download_file(
     app_logger.info(f'Running {command_name} from {get_current_directory()}')
     check_command_permission(command_name)
 
-    container_args = re.match(r"^([\w\W]+?):([\w\W]+)$", source_path)
-
-    if container_args is None:
-        typer.echo(__('Container name and source directory path are required as the first argument'))
-        typer.echo(__('Example: container-uid:/path/to/file'))
-        raise typer.Exit(1)
-    container_slug = container_args.groups()[0]
-    source_path = container_args.groups()[1]
-
-    if not container_slug:
-        typer.echo(__('Container name is required'))
-        raise typer.Exit(1)
-
     service_factory = validate_config_and_get_service_factory()
     container_service: ContainerService = service_factory.get_container_service()
 
-    container: Optional[DockerContainerDto] = container_service.get_container(
-        container_slug=container_slug,
+    container_service.get_file_from_container(
+        source=source,
+        destination_path=destination_path.rstrip("/"),
+        username_param=username,
     )
 
-    if container:
-        container_service.check_if_container_running(
-            container=container
-        )
-
-        typer.echo(f"Downloading files from container: '{container_slug}'")
-
-        container_service.get_file_from_container(
-            container=container,
-            src_path=source_path,
-            destination_path=destination_path.rstrip("/"),
-            username_param=username,
-            copy_only_folder_contents=source_path.endswith("/"),
-        )
-    else:
-        typer.echo(f"Container not found: {container_slug}")
-
-    app_logger.info(f'End download files from container')
+    app_logger.info(f'File download completed')
     raise typer.Exit(0)
 
 
@@ -360,7 +301,7 @@ def start_container(
         action=DockerContainerAction.START
     )
 
-    app_logger.info(f'End start container')
+    app_logger.info(f'Container start completed')
     raise typer.Exit(0)
 
 
@@ -398,7 +339,7 @@ def stop_container(
         action=DockerContainerAction.STOP
     )
 
-    app_logger.info(f'End stop container')
+    app_logger.info(f'Container stop completed')
     raise typer.Exit(0)
 
 
@@ -436,7 +377,7 @@ def restart_container(
         action=DockerContainerAction.RESTART
     )
 
-    app_logger.info(f'End stop container')
+    app_logger.info(f'Container restart completed')
     raise typer.Exit(0)
 
 
@@ -483,5 +424,5 @@ def container_logs(
     else:
         logging_service.print_last_container_logs(container_public_id=container_public_id, container_slug=container_slug, logs_number=logs_number)
 
-    app_logger.info(f'Container logs - end')
+    app_logger.info(f'Container log streaming completed')
     raise typer.Exit(0)

thestage/docker_container/communication/docker_container_api_client.py

@@ -0,0 +1,99 @@
+from typing import Optional, List, Dict
+
+from thestage.config.business.config_provider import ConfigProvider
+from thestage.global_dto.enums.order_direction_type import OrderDirectionType
+from thestage.services.clients.thestage_api.core.api_client_core import TheStageApiClientCore
+from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
+from thestage.services.clients.thestage_api.dtos.entity_filter_request import EntityFilterRequest
+from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
+
+from thestage.docker_container.dto.container_action_request import DockerContainerActionRequest
+from thestage.docker_container.dto.container_response import (
+    DockerContainerDto,
+    DockerContainerViewResponse,
+    ContainerBusinessStatusMapperResponse
+)
+from thestage.docker_container.dto.docker_container_list_request import DockerContainerListRequest
+from thestage.docker_container.dto.docker_container_list_response import DockerContainerListResponse
+
+
+class DockerContainerApiClient(TheStageApiClientCore):
+    def __init__(self, config_provider: ConfigProvider):
+        super().__init__(url=config_provider.get_config().main.thestage_api_url)
+        self.__config_provider = config_provider
+
+    def get_container_list(
+            self,
+            project_public_id: Optional[str] = None,
+            project_slug: Optional[str] = None,
+            statuses: List[str] = [],
+            page: int = 1,
+            limit: int = 10,
+    ) -> PaginatedEntityList[DockerContainerDto]:
+        request = DockerContainerListRequest(
+            statuses=statuses,
+            projectPublicId=project_public_id,
+            projectSlug=project_slug,
+            entityFilterRequest=EntityFilterRequest(
+                orderByField="createdAt",
+                orderByDirection=OrderDirectionType.DESC,
+                page=page,
+                limit=limit,
+            ),
+        )
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v2/docker-container/list',
+            data=request.model_dump(),
+            token=self.__config_provider.get_config().main.thestage_auth_token
+        )
+
+        result = DockerContainerListResponse.model_validate(response) if response else None
+        # return result.paginatedList.entities, result.paginatedList.pagination_data.total_pages if result and result.is_success else None
+        return result.paginatedList if result and result.is_success else None
+
+    def get_container(
+            self,
+            container_slug: Optional[str] = None,
+            container_public_id: Optional[str] = None,
+    ) -> Optional[DockerContainerDto]:
+        data = {
+            "dockerContainerPublicId": container_public_id,
+            "dockerContainerSlug": container_slug,
+        }
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v2/docker-container/view',
+            data=data,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        return DockerContainerViewResponse.model_validate(response).docker_container if response else None
+
+    def container_action(
+            self,
+            request_param: DockerContainerActionRequest,
+    ) -> TheStageBaseResponse:
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v2/docker-container/action',
+            data=request_param.model_dump(by_alias=True),
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        result = TheStageBaseResponse.model_validate(response) if response else None
+        return result
+
+    def get_container_business_status_map(self) -> Optional[Dict[str, str]]:
+        response = self._request(
+            method='POST',
+            url='/user-api/v1/docker-container/status-localized-mapping',
+            data=None,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        data = ContainerBusinessStatusMapperResponse.model_validate(response) if response else None
+        return data.docker_container_status_map if data else None

thestage/docker_container/dto/container_action_request.py

@@ -0,0 +1,11 @@
+from typing import Optional
+
+from pydantic import Field, BaseModel, ConfigDict
+
+from thestage.docker_container.dto.enum.container_pending_action import DockerContainerAction
+
+class DockerContainerActionRequest(BaseModel):
+    model_config = ConfigDict(use_enum_values=True)
+
+    dockerContainerPublicId: Optional[str] = Field(None, alias='dockerContainerPublicId')
+    action: DockerContainerAction = Field(None, alias='action')

thestage/{services/clients/thestage_api/dtos → docker_container/dto}/container_response.py

@@ -2,11 +2,11 @@ from typing import Optional, List, Dict
 
 from pydantic import Field, BaseModel, ConfigDict
 
-from thestage.services.clients.thestage_api.dtos.docker_container_mapping import DockerContainerMappingDto
+from thestage.docker_container.dto.docker_container_mapping import DockerContainerMappingDto
 from thestage.services.clients.thestage_api.dtos.frontend_status import FrontendStatusDto
-from thestage.services.clients.thestage_api.dtos.instance_rented_response import InstanceRentedDto
-from thestage.services.clients.thestage_api.dtos.project_response import ProjectDto
-from thestage.services.clients.thestage_api.dtos.selfhosted_instance_response import SelfHostedInstanceDto
+from thestage.instance.dto.instance_rented_response import InstanceRentedDto
+from thestage.project.dto.project_response import ProjectDto
+from thestage.instance.dto.selfhosted_instance_response import SelfHostedInstanceDto
 from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse, TheStageBasePaginatedResponse
 from thestage.services.clients.thestage_api.dtos.pagination_data import PaginationData
 

thestage/{services/clients/thestage_api/dtos/docker_container_controller → docker_container/dto}/docker_container_list_response.py

@@ -1,11 +1,9 @@
-from typing import List, Optional
-
-from pydantic import Field, ConfigDict, BaseModel
+from pydantic import Field, ConfigDict
 
 from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
-from thestage.services.clients.thestage_api.dtos.container_response import DockerContainerDto
+from thestage.docker_container.dto.container_response import DockerContainerDto
 from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
-from thestage.services.clients.thestage_api.dtos.pagination_data import PaginationData
+
 
 class DockerContainerListResponse(TheStageBaseResponse):
     model_config = ConfigDict(use_enum_values=True)