thestage 0.5.38__py3-none-any.whl → 0.5.40__py3-none-any.whl

thestage/services/config_provider/config_provider.py

@@ -1,30 +1,56 @@
+import typer
+
+import json
 import os
+from json import JSONDecodeError
 from pathlib import Path
-from typing import Optional, Dict
+from typing import Optional, Dict, Any
 
-import typer
-from thestage_core.entities.config_entity import ConfigEntity
-from thestage_core.services.config_provider.config_provider import ConfigProviderCore
-
-from thestage.config import THESTAGE_AUTH_TOKEN, THESTAGE_API_URL
+from thestage.exceptions.file_system_exception import FileSystemException
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.helpers.ssh_util import parse_private_key
 from thestage.services.connect.dto.remote_server_config import RemoteServerConfig
+from thestage.services.filesystem_service import FileSystemServiceCore
 from thestage.services.project.dto.project_config import ProjectConfig
+from thestage.config import THESTAGE_CONFIG_DIR, THESTAGE_CONFIG_FILE, THESTAGE_AUTH_TOKEN, THESTAGE_API_URL
+
+class ConfigProvider():
+    # path to current physical subject we work with (project / etc) - might be passed explicitly
+    _local_path: Optional[Path] = None
+    _local_config_path: Optional[Path] = None
+    _global_config_path: Optional[Path] = None
+    _global_config_file: Optional[Path] = None
+    _file_system_service = FileSystemServiceCore
 
 
-class ConfigProvider(ConfigProviderCore):
     def __init__(
             self,
-            local_path: str,
+            local_path: Optional[str] = None,
     ):
-        super(ConfigProvider, self).__init__(
-            local_path=local_path,
+        self._file_system_service = FileSystemServiceCore()
+        if local_path:
+            self._local_path = self._file_system_service.get_path(directory=local_path, auto_create=False)
+
+        config_folder_name = self._file_system_service.get_path(f"{THESTAGE_CONFIG_DIR}", False)
+        self._local_config_path = self._local_path.joinpath(config_folder_name)
+
+        home_dir = self._file_system_service.get_home_path()
+        self._global_config_path = home_dir.joinpath(config_folder_name)
+
+        if self._global_config_path:
+            if not self._global_config_path.exists():
+                self._file_system_service.create_if_not_exists_dir(self._global_config_path)
+
+        self._global_config_file = self._global_config_path.joinpath(
+            self._file_system_service.get_path(f"{THESTAGE_CONFIG_FILE}", False)
         )
+        if not self._global_config_file.exists():
+            self._file_system_service.create_if_not_exists_file(self._global_config_file)
+
 
-    def get_full_config(self, check_daemon: bool = False,) -> ConfigEntity:
+    def get_full_config(self) -> ConfigEntity:
         config_values = {}
 
-        # read env data
         config_from_env = {}
         config_from_env['main'] = {}
         if THESTAGE_AUTH_TOKEN:
@@ -35,8 +61,7 @@ class ConfigProvider(ConfigProviderCore):
         if config_from_env:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_env)
 
-        # read global config data
-        config_from_file = self._read_config_file(self._global_config_file)
+        config_from_file = self.__read_config_file(self._global_config_file)
         if config_from_file:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_file)
 
@@ -47,27 +72,25 @@ class ConfigProvider(ConfigProviderCore):
         if self._global_config_path and not config.runtime.config_global_path:
             config.runtime.config_global_path = str(self._global_config_path)
 
-        if check_daemon:
-            self.check_for_daemon(config=config)
-
         return config
 
+
     def save_project_config(self, project_config: ProjectConfig):
-        self.__create_empty_project_config_if_missing()
-        # self.read_project_config()
-        project_config_path = self.__get_project_config_path(with_file=True)
-        self._save_config_file(data=project_config.model_dump(), file_path=project_config_path)
+        project_data_dirpath = self.__get_project_config_path()
+        if not project_data_dirpath.exists():
+            self._file_system_service.create_if_not_exists_dir(project_data_dirpath)
+
+        project_data_filepath = self.__get_project_config_path(with_file=True)
+        if not project_data_filepath.exists():
+            self._file_system_service.create_if_not_exists_file(project_data_filepath)
 
-    def save_remote_server_config(self, remote_server_config: RemoteServerConfig):
-        self.__create_empty_project_config_if_missing()
-        # self.read_project_config()
         project_config_path = self.__get_project_config_path(with_file=True)
-        self._save_config_file(data=remote_server_config.model_dump(), file_path=project_config_path)
+        self.__save_config_file(data=project_config.model_dump(), file_path=project_config_path)
 
 
     def save_project_deploy_ssh_key(self, deploy_ssh_key: str, project_slug: str, project_id: int) -> str:
         deploy_key_dirpath = self._global_config_path.joinpath('project_deploy_keys')
-        self._file_system_service.create_if_not_exists(deploy_key_dirpath)
+        self._file_system_service.create_if_not_exists_dir(deploy_key_dirpath)
 
         deploy_key_filepath = deploy_key_dirpath.joinpath(f'project_deploy_key_{project_id}_{project_slug}')
         self._file_system_service.create_if_not_exists_file(deploy_key_filepath)
@@ -79,30 +102,20 @@ class ConfigProvider(ConfigProviderCore):
 
         return str(deploy_key_filepath)
 
+
     def read_project_config(self) -> Optional[ProjectConfig]:
         project_data_dirpath = self.__get_project_config_path()
         if not project_data_dirpath.exists():
             return None
-            # self._file_system_service.create_if_not_exists(project_data_dirpath)
 
         project_data_filepath = self.__get_project_config_path(with_file=True)
         if not project_data_filepath.exists():
             return None
 
-        config_data = self._read_config_file(project_data_filepath) if project_data_filepath and project_data_filepath.exists() else {}
+        config_data = self.__read_config_file(project_data_filepath) if project_data_filepath and project_data_filepath.exists() else {}
         return ProjectConfig.model_validate(config_data)
 
 
-    def __create_empty_project_config_if_missing(self):
-        project_data_dirpath = self.__get_project_config_path()
-        if not project_data_dirpath.exists():
-            self._file_system_service.create_if_not_exists(project_data_dirpath)
-
-        project_data_filepath = self.__get_project_config_path(with_file=True)
-        if not project_data_filepath.exists():
-            self._file_system_service.create_if_not_exists_file(project_data_filepath)
-
-
     def __get_project_config_path(self, with_file: bool = False) -> Path:
         if with_file:
             return self._local_config_path.joinpath('project.json')
@@ -124,7 +137,7 @@ class ConfigProvider(ConfigProviderCore):
                 typer.echo("Could not identify provided private key (expected RSA, ECDSA, ED25519)")
                 raise typer.Exit(1)
 
-        config = self.read_remote_server_config()
+        config = self.__read_remote_server_config()
         remote_server_config_filepath = self.__get_remote_server_config_path()
         if config:
             if not config.ip_address_to_ssh_key_map:
@@ -142,21 +155,22 @@ class ConfigProvider(ConfigProviderCore):
             self._file_system_service.create_if_not_exists_file(remote_server_config_filepath)
             config = RemoteServerConfig(ip_address_to_ssh_key_map={ip_address: str(ssh_key_path)})
 
-        self._save_config_file(data=config.model_dump(), file_path=remote_server_config_filepath)
+        self.__save_config_file(data=config.model_dump(), file_path=remote_server_config_filepath)
 
         return str(remote_server_config_filepath)
 
 
-    def read_remote_server_config(self) -> Optional[RemoteServerConfig]:
+    def __read_remote_server_config(self) -> Optional[RemoteServerConfig]:
         config_filepath = self.__get_remote_server_config_path()
         if not config_filepath.is_file():
             return None
 
-        config_data = self._read_config_file(config_filepath) if config_filepath and config_filepath.exists() else {}
+        config_data = self.__read_config_file(config_filepath) if config_filepath and config_filepath.exists() else {}
         return RemoteServerConfig.model_validate(config_data)
 
+
     def get_valid_private_key_path_by_ip_address(self, ip_address: str) -> Optional[str]:
-        remote_server_config = self.read_remote_server_config()
+        remote_server_config = self.__read_remote_server_config()
         if remote_server_config and remote_server_config.ip_address_to_ssh_key_map:
             private_key_path = remote_server_config.ip_address_to_ssh_key_map.get(ip_address)
             if private_key_path and Path(private_key_path).is_file():
@@ -165,10 +179,50 @@ class ConfigProvider(ConfigProviderCore):
                 self.update_remote_server_config_entry(ip_address, None)
         return None
 
+
     @staticmethod
     def __update_config_values_dict(values_to_update: Dict, new_values: Dict):
         if 'main' in new_values:
             if 'main' in values_to_update:
                 values_to_update['main'].update(new_values['main'])
             else:
-                values_to_update['main'] = new_values['main']
+                values_to_update['main'] = new_values['main']
+
+
+    def __read_config_file(self, path: Path) -> Dict[str, Any]:
+        result = {}
+        try:
+            if path and path.exists():
+                with path.open("r") as file:
+                    try:
+                        if os.stat(path).st_size != 0:
+                            result = json.load(file)
+                    except JSONDecodeError:
+                        pass
+        except OSError:
+            raise FileSystemException(f"Could not open config file: {path}")
+        return result
+
+
+    @staticmethod
+    def __save_config_file(data: Dict, file_path: Path):
+        with open(file_path, 'w') as configfile:
+            json.dump(data, configfile, indent=1)
+
+
+    def save_config(self, config: ConfigEntity):
+        data: Dict[str, Any] = self.__read_config_file(self._global_config_file)
+        data.update(config.model_dump(exclude_none=True, by_alias=True, exclude={'runtime', 'RUNTIME', 'daemon', 'DAEMON'}))
+        self.__save_config_file(data=data, file_path=self._global_config_file)
+
+
+    def clear_config(self, ):
+        if self._global_config_path and self._global_config_path.exists():
+            self._file_system_service.remove_folder(str(self._global_config_path))
+
+        os.unsetenv('THESTAGE_CONFIG_DIR')
+        os.unsetenv('THESTAGE_CONFIG_FILE')
+        os.unsetenv('THESTAGE_CLI_ENV')
+        os.unsetenv('THESTAGE_API_URL')
+        os.unsetenv('THESTAGE_LOG_FILE')
+        os.unsetenv('THESTAGE_AUTH_TOKEN')

thestage/services/connect/connect_service.py

@@ -1,8 +1,8 @@
 from typing import Optional
 import typer
-from thestage_core.exceptions.http_error_exception import HttpClientException
 
 from thestage.i18n.translation import __
+from thestage.services.clients.thestage_api.core.http_client_exception import HttpClientException
 from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
 from thestage.services.clients.thestage_api.dtos.enums.selfhosted_status import SelfhostedBusinessStatus
 from thestage.services.clients.thestage_api.dtos.enums.instance_rented_status import InstanceRentedBusinessStatus

thestage/services/container/container_service.py

@@ -1,22 +1,16 @@
-import uuid
 from pathlib import Path
 from typing import List, Tuple, Optional, Dict
 
 import typer
-from thestage_core.entities.config_entity import ConfigEntity
-from thestage_core.entities.file_item import FileItemEntity
-from thestage_core.services.filesystem_service import FileSystemServiceCore
-
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.entities.container import DockerContainerEntity
-from thestage.helpers.logger.app_logger import app_logger
 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.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
-from thestage.services.clients.thestage_api.dtos.project_response import ProjectDto
-from thestage.services.clients.thestage_api.dtos.sftp_path_helper import SftpFileItemEntity
 from thestage.services.container.mapper.container_mapper import ContainerMapper
+from thestage.services.filesystem_service import FileSystemServiceCore
 from thestage.services.remote_server_service import RemoteServerService
 from thestage.i18n.translation import __
 from thestage.services.abstract_service import AbstractService

thestage/services/core_files/config_entity.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+# saved to file
+class MainConfigEntity(BaseModel):
+    thestage_auth_token: Optional[str] = Field(None, alias='thestage_auth_token')
+    thestage_api_url: Optional[str] = Field(None, alias='thestage_api_url')
+
+
+class DaemonConfigEntity(BaseModel):
+    daemon_token: Optional[str] = Field(None, alias='daemon_token')
+    backend_api_url: Optional[str] = Field(None, alias='backend_api_url')
+
+# not saved to file
+class RuntimeConfigEntity(BaseModel):
+    working_directory: Optional[str] = Field(None, alias='working_directory')
+    config_global_path: Optional[str] = Field(None, alias='config_global_path')
+
+
+class ConfigEntity(BaseModel):
+    main: MainConfigEntity = Field(default_factory=MainConfigEntity, alias='main')
+    runtime: RuntimeConfigEntity = Field(default_factory=RuntimeConfigEntity, alias="runtime") # TODO merge with main
+    daemon: DaemonConfigEntity = Field(default_factory=DaemonConfigEntity, alias="daemon") # TODO this should not be in core package
+    start_on_daemon: bool = Field(False, alias='start_on_daemon') # TODO this should not be in core package

thestage/services/filesystem_service.py

@@ -0,0 +1,115 @@
+import os
+import shutil
+from pathlib import Path
+from typing import Optional, List
+
+from thestage.entities.file_item import FileItemEntity
+from thestage.exceptions.file_system_exception import FileSystemException
+
+
+class FileSystemServiceCore:
+
+    def get_ssh_path(self) -> Optional[Path]:
+        home_path = self.get_home_path()
+        ssh_path = home_path.joinpath('.ssh')
+        if not ssh_path.exists():
+            raise FileSystemException(f"Path does not exist: {ssh_path}")
+        return ssh_path
+
+    def get_home_path(self) -> Optional[Path]:
+        try:
+            return Path.home()
+        except RuntimeError | OSError as ex1:
+            raise FileSystemException("Error getting user home path") from ex1
+
+    def create_if_not_exists_dir(self, path: Path) -> Path:
+        if not path.exists():
+            try:
+                path.mkdir(exist_ok=True, parents=True)
+            except FileNotFoundError as ex1:
+                raise FileSystemException(message=f"FileNotFoundError (dir): {path}") from ex1
+            except OSError as ex2:
+                raise FileSystemException(message=f"Could not create directory: {path}") from ex2
+        return path
+
+    def create_if_not_exists_file(self, path: Path) -> Path:
+        if not path.exists():
+            try:
+                path.touch(exist_ok=True)
+            except FileNotFoundError as ex1:
+                raise FileSystemException(message=f"FileNotFoundError (file): {path}") from ex1
+            except OSError as ex2:
+                raise FileSystemException(message=f"Could not create file: {path}") from ex2
+        return path
+
+    def get_path(self, directory: str, auto_create: bool = True) -> Path:
+        path = Path(directory)
+        if auto_create:
+            self.create_if_not_exists_dir(path)
+        return path
+
+    def is_folder_empty(self, folder: str, auto_create: bool) -> bool:
+        path = self.get_path(folder, auto_create)
+        if not path.exists():
+            return True
+        if not path.is_dir():
+            raise FileSystemException(message=f"Expected directory but found a file: {path}")
+        objects = os.listdir(path)
+        if len(objects) == 0:
+            return True
+        else:
+            return False
+
+    def is_folder_exists(self, folder: str, auto_create: bool = True) -> bool:
+        path = self.get_path(folder, auto_create=auto_create)
+        if path.exists():
+            return True
+        else:
+            return False
+
+    def find_line_in_text_file(self, file: str, find: str) -> bool:
+        path = self.get_path(file, auto_create=False)
+        if path and path.exists():
+            with open(path, 'r') as file:
+                for line in file.readlines():
+                    if (find + "\n") == line:
+                        return True
+        return False
+
+    def add_line_to_text_file(self, file: str, new_line: str):
+        path = self.get_path(file, auto_create=False)
+        if path and path.exists():
+            with open(path, 'a') as file:
+                file.write(new_line)
+                file.write('\n')
+
+    def check_if_path_exist(self, file: str) -> bool:
+        path = self.get_path(file, auto_create=False)
+        if path.exists():
+            return True
+        else:
+            return False
+
+    def get_path_items(self, folder: str) -> List[FileItemEntity]:
+        path = self.get_path(folder, auto_create=False)
+        path_items = []
+        if not path.exists():
+            return path_items
+
+        parent = FileItemEntity.build_from_path(path=path)
+        path_items.append(parent)
+        if path.is_dir():
+            objects = os.listdir(path)
+            if objects:
+                for item in objects:
+                    elem = path.joinpath(item)
+                    if elem.is_dir():
+                        parent.children.extend(self.get_path_items(folder=str(elem)))
+                    else:
+                        parent.children.append(FileItemEntity.build_from_path(path=elem))
+        return path_items
+
+    def remove_folder(self, path: str):
+        real_path = self.get_path(directory=path, auto_create=False)
+        if real_path and real_path.exists():
+            shutil.rmtree(real_path)

thestage/services/instance/instance_service.py

@@ -2,8 +2,7 @@ from pathlib import Path
 from typing import List, Optional, Dict
 
 import typer
-from thestage_core.entities.config_entity import ConfigEntity
-
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.i18n.translation import __
 from thestage.services.clients.thestage_api.dtos.enums.selfhosted_status import SelfhostedBusinessStatus
 from thestage.services.clients.thestage_api.dtos.enums.instance_rented_status import InstanceRentedBusinessStatus

thestage/services/logging/logging_service.py

@@ -8,8 +8,9 @@ import aioconsole
 import typer
 from httpx import ReadTimeout, ConnectError, ConnectTimeout
 from requests.exceptions import ChunkedEncodingError
-from thestage_core.entities.config_entity import ConfigEntity
 
+from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.services.clients.thestage_api.dtos.enums.inference_simulator_status import InferenceSimulatorStatus
 from thestage.services.clients.thestage_api.dtos.enums.task_status import TaskStatus
 from thestage.services.clients.thestage_api.dtos.inference_controller.get_inference_simulator_response import \
@@ -69,25 +70,23 @@ class LoggingService(AbstractService):
 
 
     @error_handler()
-    def stream_container_logs(self, config: ConfigEntity, container: DockerContainerDto):
-        typer.echo(__(
-            f"Log stream for docker container '%container_slug%' started",
-            {
-                'container_slug': container.slug,
-            }
-        ))
-        typer.echo(__("Press CTRL+C to stop"))
-        try:
-            for log_json in self.__thestage_api_client.get_container_log_stream(
-                    token=config.main.thestage_auth_token,
-                    container_id=container.id
-            ):
-                self.__print_log_line(log_json)
-        except ChunkedEncodingError as e1:  # handling server timeout
-            typer.echo(__('Log stream disconnected (1)'))
+    def print_last_container_logs(self, config: ConfigEntity, container_uid: str, logs_number: Optional[int]):
+        container: Optional[DockerContainerDto] = self.__thestage_api_client.get_container(
+            token=config.main.thestage_auth_token,
+            container_slug=container_uid,
+        )
+
+        if not container:
+            typer.echo("Container was not found")
             raise typer.Exit(1)
 
-        typer.echo(__('Log stream disconnected'))
+        logs = self.__thestage_api_client.query_user_logs(
+            token=config.main.thestage_auth_token,
+            container_id=container.id,
+            limit=logs_number
+        )
+        for log_message in reversed(logs.queryResult):
+            self.__print_log_line_object(log_message)
 
 
     @error_handler()
@@ -134,7 +133,7 @@ class LoggingService(AbstractService):
 
         typer.echo(__("CTRL+C to cancel the task. CTRL+D to disconnect from log stream."))
 
-        print_logs_task = asyncio.create_task(self.print_task_or_inference_simulator_logs(config.main.thestage_auth_token, task.id))
+        print_logs_task = asyncio.create_task(self.print_realtime_logs(token=config.main.thestage_auth_token, task_id=task.id))
         input_task = asyncio.create_task(self.read_log_stream_input())
 
         def sigint_handler():
@@ -200,7 +199,7 @@ class LoggingService(AbstractService):
         typer.echo(__("CTRL+D to disconnect from log stream."))
 
         print_task_or_inference_simulator_logs = asyncio.create_task(
-            self.print_task_or_inference_simulator_logs(config.main.thestage_auth_token, inference_simulator_id=inference_simulator.id)
+            self.print_realtime_logs(token=config.main.thestage_auth_token, inference_simulator_id=inference_simulator.id)
         )
         input_task = asyncio.create_task(self.read_log_stream_input())
 
@@ -212,6 +211,49 @@ class LoggingService(AbstractService):
             typer.echo(__(f"Disconnected from log stream. You can try to reconnect with 'thestage project inference-simulator logs {slug}'."))
 
 
+    @error_handler()
+    def stream_container_logs_with_controls(self, config: ConfigEntity, container_uid: str):
+        asyncio.run(
+            self.__stream_container_logs_with_controls_async(
+                config=config,
+                container_uid=container_uid
+            )
+        )
+
+
+    @error_handler()
+    async def __stream_container_logs_with_controls_async(self, config: ConfigEntity, container_uid: str):
+        container: Optional[DockerContainerDto] = self.__thestage_api_client.get_container(
+            token=config.main.thestage_auth_token,
+            container_slug=container_uid,
+        )
+
+        if container:
+            if container.frontend_status.status_key not in [DockerContainerStatus.RUNNING]:
+                typer.echo(f"Container status: '{container.frontend_status.status_translation}'")
+        else:
+            typer.echo("Container was not found")
+            raise typer.Exit(1)
+
+        typer.echo(f"Log stream for Docker container started")
+        typer.echo("CTRL+D to disconnect from log stream.")
+
+        print_logs_task = asyncio.create_task(self.print_realtime_logs(token=config.main.thestage_auth_token, docker_container_id=container.id))
+        input_task = asyncio.create_task(self.read_log_stream_input())
+
+        def sigint_handler():
+            input_task.cancel()
+
+        loop = asyncio.get_event_loop()
+        for signal_item in [SIGINT]:  # SIGINT == CTRL+C
+            loop.add_signal_handler(signal_item, sigint_handler)
+
+        done, pending = await asyncio.wait([print_logs_task, input_task], return_when=asyncio.FIRST_COMPLETED)
+
+        if input_task in done:
+            print_logs_task.cancel()
+
+
     async def read_log_stream_input(self):
         try:
             while True:
@@ -223,7 +265,13 @@ class LoggingService(AbstractService):
             pass
 
 
-    async def print_task_or_inference_simulator_logs(self, token: str, task_id: Optional[int] = None, inference_simulator_id: Optional[int] = None):
+    async def print_realtime_logs(
+            self,
+            token: str,
+            task_id: Optional[int] = None,
+            inference_simulator_id: Optional[int] = None,
+            docker_container_id: Optional[int] = None,
+    ):
         polling_interval_seconds: float = 4  # also adjust polling api method timeout if changed
         between_logs_sleeping_coef: float = 1  # we emulate delay between logs, but if for any reason code runs for too long - delays will be controlled with this coef
         last_iteration_log_timestamp: Optional[str] = None  # pointer to next iteration polling start (obtained from each response)
@@ -249,7 +297,7 @@ class LoggingService(AbstractService):
                     token=token,
                     task_id=task_id,
                     inference_simulator_id=inference_simulator_id,
-                    docker_container_id=None,
+                    docker_container_id=docker_container_id,
                     last_log_timestamp=last_iteration_log_timestamp,
                     last_log_id=last_log_id
                 )
@@ -283,82 +331,15 @@ class LoggingService(AbstractService):
                     errors_started_at = datetime.utcnow()
 
             if consecutive_error_count > 7:
+                seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
                 if inference_simulator_id:
-                    seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
                     print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage inference-simulator logs <inference-simulator-UID>' to reconnect.", writer)
-                    break
+                elif task_id:
+                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage project task logs {task_id}' to reconnect.", writer)
+                elif docker_container_id:
+                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage container logs <docker-container-UID>' to reconnect.", writer)
                 else:
-                    seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
-                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage project inference-simulator logs {task_id}' to reconnect.", writer)
-                    break
-
-            # depending on iteration duration - sleep for the remaining time and adjust log sleep coefficient if needed
-            iteration_duration = (datetime.utcnow() - iteration_started_at).total_seconds()
-            if iteration_duration > polling_interval_seconds:
-                between_logs_sleeping_coef *= 0.85
-            else:
-                await asyncio.sleep(polling_interval_seconds - iteration_duration)
-                if between_logs_sleeping_coef < 1:
-                    between_logs_sleeping_coef = min(1.0, between_logs_sleeping_coef * 1.15)
-
-
-    async def print_inference_simulator_logs(self, token: str, inference_simulator_id: int):
-        polling_interval_seconds: float = 4  # also adjust polling api method timeout if changed
-        between_logs_sleeping_coef: float = 1  # we emulate delay between logs, but if for any reason code runs for too long - delays will be controlled with this coef
-        last_iteration_log_timestamp: Optional[str] = None  # pointer to next iteration polling start (obtained from each response)
-        last_log_id: Optional[str] = None  # pointer to next iteration polling start - to exclude the log id from result (obtained from each response)
-        consecutive_error_count: int = 0  # connectivity errors count - stream will disconnect if too many errors in a row
-        iteration_started_at: datetime  # used to control iteration duration - polling should be done at around exact rate
-        errors_started_at: Optional[datetime] = None  # time since errors started to stream disconnect
-
-        is_no_more_logs = False
-        while not is_no_more_logs:
-            log_wait_remaining_limit: float = polling_interval_seconds  # hard limit just in case
-            iteration_started_at = datetime.utcnow()
-            last_printed_log_timestamp: Optional[datetime] = None
-            reader, writer = await aioconsole.get_standard_streams()
-
-            # this shows (somewhat accurate) time difference between logs here and in real time. should not grow.
-            # if last_iteration_log_timestamp:
-            #     last_log_timestamp_parsed = datetime.strptime(last_iteration_log_timestamp, '%Y-%m-%dT%H:%M:%S.%f')
-            #     stream_to_logs_diff = datetime.utcnow() - last_log_timestamp_parsed
-            #     print_nonblocking(f'TDIFF {stream_to_logs_diff.total_seconds()}', writer)
-            try:
-                logs_response = await self.__thestage_api_client.poll_logs_httpx(
-                    token=token,
-                    inference_simulator_id=inference_simulator_id,
-                    docker_container_id=None,
-                    last_log_timestamp=last_iteration_log_timestamp,
-                    last_log_id=last_log_id
-                )
-
-                if consecutive_error_count > 0:
-                    consecutive_error_count = 0
-                    errors_started_at = None
-                    log_wait_remaining_limit = 0   # no log delays after reconnect
-
-                last_iteration_log_timestamp = logs_response.lastLogTimestamp
-                last_log_id = logs_response.lastLogId
-
-                for log_item in logs_response.logs:
-                    current_log_timestamp = datetime.strptime(log_item.timestamp[:26], '%Y-%m-%dT%H:%M:%S.%f')  # python does not like nanoseconds
-                    if last_printed_log_timestamp is not None and log_wait_remaining_limit > 0:
-                        logs_sleeptime = (current_log_timestamp - last_printed_log_timestamp).total_seconds() * between_logs_sleeping_coef
-                        await asyncio.sleep(logs_sleeptime)
-                        log_wait_remaining_limit -= logs_sleeptime
-                    self.__print_log_line_object_nonblocking(log_item, writer)
-                    last_printed_log_timestamp = current_log_timestamp
-
-            except (ReadTimeout, ConnectError, ConnectTimeout) as e:
-                consecutive_error_count += 1
-                if consecutive_error_count == 1:
-                    print_nonblocking("Network issues, attempting to re-establish connection...", writer, BytePrintStyle.ORANGE)
-                if not errors_started_at:
-                    errors_started_at = datetime.utcnow()
-
-            if consecutive_error_count > 7:
-                seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
-                print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds).", writer)
+                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds)", writer)
                 break
 
             # depending on iteration duration - sleep for the remaining time and adjust log sleep coefficient if needed