mantis-cli 19.2.0__tar.gz → 20.0.0__tar.gz

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: mantis-cli
-Version: 19.2.0
+Name: mantis_cli
+Version: 20.0.0
 Summary: Management command to build and deploy webapps, especially based on Django
 Home-page: https://github.com/PragmaticMates/mantis-cli
 Author: Erik Telepovský
@@ -9,6 +9,7 @@ Maintainer: Pragmatic Mates
 Maintainer-email: info@pragmaticmates.com
 License: GNU General Public License (GPL)
 Keywords: management deployment docker command
+Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Operating System :: OS Independent
 Classifier: Environment :: Web Environment
@@ -18,11 +19,6 @@ Classifier: License :: OSI Approved :: GNU General Public License (GPL)
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cffi
-Requires-Dist: cryptography
-Requires-Dist: pycryptodome
-Requires-Dist: PyYAML
-Requires-Dist: prettytable
 
 # mantis-cli
 
@@ -341,3 +337,4 @@ Works as follows:
 ## Release notes
 
 Mantis uses semantic versioning. See more in [changelog](https://github.com/PragmaticMates/mantis-cli/blob/master/CHANGES.md).
+

mantis_cli-20.0.0/mantis/__init__.py

@@ -0,0 +1 @@
+VERSION = '20.0.0'

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis/command_line.py

@@ -2,12 +2,18 @@
 import os
 import sys
 import inspect
-import prettytable
+
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
 
 from mantis import VERSION
-from mantis.helpers import Colors, CLI, nested_set
+from mantis.helpers import CLI, nested_set
 from mantis.logic import get_manager, execute
-from mantis.managers import AbstractManager
+from mantis.managers import AbstractManager, BaseManager
+from mantis.extensions.django import Django
+from mantis.extensions.nginx import Nginx
+from mantis.extensions.postgres import Postgres
 
 
 def parse_args(arguments):
@@ -43,6 +49,9 @@ def run():
     if params['commands'] == ['--version']:
         return print(version_info)
 
+    if params['commands'] == ['--help']:
+        return help()
+
     # get params
     environment_id = params['environment_id']
     commands = params['commands']
@@ -51,9 +60,6 @@ def run():
     # get manager
     manager = get_manager(environment_id, mode)
 
-    if params['commands'] == ['--help']:
-        return help(manager)
-
     if len(params['commands']) == 0:
         CLI.error('Missing commands. Check mantis --help for more information.')
 
@@ -75,25 +81,24 @@ def run():
                 value=value
             )
 
-    environment_intro = f'Environment ID = {Colors.BOLD}{manager.environment_id}{Colors.ENDC}, ' if manager.environment_id else ''
-
-    if manager.connection and manager.host:
-        host_intro = f'{Colors.RED}{manager.host}{Colors.ENDC}, '
-    else:
-        host_intro = ''
-
-    heading = f'{version_info}, '\
-              f'{environment_intro}'\
-              f'{host_intro}'\
-              f'mode: {Colors.GREEN}{manager.mode}{Colors.ENDC}, '\
-              f'hostname: {Colors.BLUE}{hostname}{Colors.ENDC}'
+    console = Console()
 
-    print(heading)
+    heading = Text.assemble(
+        version_info, ", ",
+        ("Environment ID = ", "") if manager.environment_id else ("(single connection mode), ", "bold") if manager.single_connection_mode else ("", ""),
+        (str(manager.environment_id) + ", ", "bold") if manager.environment_id else ("", ""),
+        (str(manager.host) + ", ", "red") if manager.connection and manager.host else ("", ""),
+        "mode: ", (str(manager.mode), "green"),
+        ", hostname: ", (hostname, "blue")
+    )
+    console.print(heading)
 
     if mode == 'ssh':
+        # Build mantis command - environment_id is optional in single connection mode
+        env_part = f'{environment_id} ' if environment_id else ''
         cmds = [
             f'cd {manager.project_path}',
-            f'mantis {environment_id} --mode=host {" ".join(commands)}'
+            f'mantis {env_part}--mode=host {" ".join(commands)}'
         ]
         cmd = ';'.join(cmds)
         exec = f"ssh -t {manager.user}@{manager.host} -p {manager.port} '{cmd}'"
@@ -109,31 +114,19 @@ def run():
 
             execute(manager, command, params)
 
-def help(manager):
-    print(f'\nUsage:\n\
-    mantis [--mode=remote|ssh|host] [environment] --command[:params]')
-
-    print('\nModes:\n\
-    remote \truns commands remotely from local machine using DOCKER_HOST or DOCKER_CONTEXT (default)\n\
-    ssh \tconnects to host via ssh and run all mantis commands on remote machine directly (nantis-cli needs to be installed on server)\n\
-    host \truns mantis on host machine directly without invoking connection (used as proxy for ssh mode)')
-
-    print(f'\nEnvironment:\n\
-    Either "local" or any custom environment identifier defined as connection in your config file.')
-
-    print(f'\nCommands:')
-
-    table = prettytable.PrettyTable(align='l')
-    table.set_style(prettytable.SINGLE_BORDER)
-    table.field_names = ["Command", "Description"]
+def get_class_commands(cls, exclude_from=None):
+    """
+    Extract commands from a class for help display.
+    Returns list of tuples: (command_str, description)
+    """
+    commands = []
+    exclude_methods = dir(exclude_from) if exclude_from else []
 
-    # Get all methods of the class
-    methods = inspect.getmembers(manager, predicate=inspect.ismethod)
+    methods = inspect.getmembers(cls, predicate=inspect.isfunction)
 
-    # Iterate over each method
     for method_name, method in methods:
-        # skip methods of abstract manager
-        if method_name in dir(AbstractManager):
+        # skip private methods and excluded methods
+        if method_name.startswith('_') or method_name in exclude_methods:
             continue
 
         command = method_name.replace('_', '-')
@@ -141,33 +134,82 @@ def help(manager):
         # Get the method signature
         signature = inspect.signature(method)
 
-        # Parameters
-        parameters = list(signature.parameters.keys())
+        # Parameters (skip 'self')
+        parameters = [p for p in signature.parameters.keys() if p != 'self']
 
         # Check if parameters are optional
         params_are_optional = True
 
         for param_name, param in signature.parameters.items():
-            if not param.default:
+            if param_name == 'self':
+                continue
+            if param.default == inspect.Parameter.empty:
                 params_are_optional = False
 
-        # Print method name and its parameters
+        # Build command string
         command = f"--{command}"
-        params = ""
+        params_str = ""
 
-        if signature.parameters:
+        if parameters:
             if not params_are_optional:
-                params += '['
+                params_str += '['
 
-            params += ':'
+            params_str += ':'
 
-            params += ','.join(parameters)
+            params_str += ','.join(parameters)
 
             if not params_are_optional:
-                params += ']'
+                params_str += ']'
 
         docs = method.__doc__ or ''
 
-        table.add_row([f"{command}{params}", docs.strip()])
+        commands.append((f"{command}{params_str}", docs.strip()))
+
+    return commands
+
+
+def help():
+    print(f'\nUsage:\n\
+    mantis [--mode=remote|ssh|host] [environment] --command[:params]')
+
+    print('\nModes:\n\
+    remote \truns commands remotely from local machine using DOCKER_HOST or DOCKER_CONTEXT (default)\n\
+    ssh \tconnects to host via ssh and run all mantis commands on remote machine directly (mantis-cli needs to be installed on server)\n\
+    host \truns mantis on host machine directly without invoking connection (used as proxy for ssh mode)')
+
+    print(f'\nEnvironment:\n\
+    Either "local" or any custom environment identifier defined as connection in your config file.\n\
+    Optional when using single connection mode (config has "connection" instead of "connections").')
+
+    console = Console()
 
-    print(table)
+    # Base commands
+    print(f'\nCommands:')
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Command", style="cyan")
+    table.add_column("Description")
+
+    for command, description in get_class_commands(BaseManager, exclude_from=AbstractManager):
+        table.add_row(command, description)
+
+    console.print(table)
+
+    # Extension commands
+    extensions = [
+        ('Django', Django),
+        ('Nginx', Nginx),
+        ('Postgres', Postgres),
+    ]
+
+    for ext_name, ext_class in extensions:
+        ext_commands = get_class_commands(ext_class)
+        if ext_commands:
+            print(f'\n{ext_name} extension:')
+            ext_table = Table(show_header=True, header_style="bold")
+            ext_table.add_column("Command", style="yellow")
+            ext_table.add_column("Description")
+
+            for command, description in ext_commands:
+                ext_table.add_row(command, description)
+
+            console.print(ext_table)

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis/environment.py

@@ -1,14 +1,17 @@
 import os
 
-from mantis.helpers import CLI, Colors
+from mantis.helpers import CLI
 
 
 class Environment(object):
-    def __init__(self, environment_id, folder):
+    def __init__(self, environment_id, folder, single_mode=False):
         self.id = environment_id
         self.folder = folder
+        self.single_mode = single_mode
 
-        if self.id:
+        if self.single_mode:
+            self.setup_single_mode()
+        elif self.id:
             self.setup()
 
     def setup(self):
@@ -30,6 +33,31 @@ class Environment(object):
             self.files = list(map(lambda x: os.path.join(dirpath, x), environment_filenames))
             self.encrypted_files = list(map(lambda x: os.path.join(dirpath, x), encrypted_environment_filenames))
 
+    def setup_single_mode(self):
+        """
+        Setup for single connection mode: look for env files directly in the folder
+        instead of environment subfolders
+        """
+        self.path = self.folder
+
+        if not os.path.exists(self.path):
+            CLI.warning(f"Environment path '{self.path}' does not exist")
+            self.files = []
+            self.encrypted_files = []
+            return
+
+        if not os.path.isdir(self.path):
+            CLI.error(f"Environment path '{self.path}' is not directory")
+
+        CLI.info(f"Found environment path (single mode): '{self.path}'")
+
+        # Look for env files directly in the folder (not in subdirectories)
+        files = os.listdir(self.path)
+        environment_filenames = list(filter(lambda f: f.endswith('.env') and not f.endswith('.encrypted'), files))
+        encrypted_environment_filenames = list(filter(lambda f: f.endswith('.env.encrypted'), files))
+        self.files = list(map(lambda x: os.path.join(self.path, x), environment_filenames))
+        self.encrypted_files = list(map(lambda x: os.path.join(self.path, x), encrypted_environment_filenames))
+
     def _get_path(self, id):
         possible_folder_names = [f'.{id}', id]
         possible_folders = list(map(lambda x: os.path.normpath(os.path.join(self.folder, x)), possible_folder_names))

mantis_cli-20.0.0/mantis/helpers.py

@@ -0,0 +1,98 @@
+from rich.console import Console
+from rich.text import Text
+
+# Shared console instance
+_console = Console()
+
+
+class CLI(object):
+    @staticmethod
+    def _print(text, style, end='\n'):
+        styled_text = Text(str(text), style=style)
+        _console.print(styled_text, end=end)
+
+    @staticmethod
+    def error(text):
+        styled_text = Text(str(text), style='red')
+        _console.print(styled_text)
+        exit(1)
+
+    @staticmethod
+    def bold(text, end='\n'):
+        return CLI._print(text=text, style='bold', end=end)
+
+    @staticmethod
+    def info(text, end='\n'):
+        return CLI._print(text=text, style='blue', end=end)
+
+    @staticmethod
+    def pink(text, end='\n'):
+        return CLI._print(text=text, style='magenta', end=end)
+
+    @staticmethod
+    def success(text, end='\n'):
+        return CLI._print(text=text, style='green', end=end)
+
+    @staticmethod
+    def warning(text, end='\n'):
+        return CLI._print(text=text, style='yellow', end=end)
+
+    @staticmethod
+    def danger(text, end='\n'):
+        return CLI._print(text=text, style='red', end=end)
+
+    @staticmethod
+    def underline(text, end='\n'):
+        return CLI._print(text=text, style='underline', end=end)
+
+    @staticmethod
+    def step(index, total, text, end='\n'):
+        return CLI._print(text=f'[{index}/{total}] {text}', style='yellow', end=end)
+
+    @staticmethod
+    def link(uri, label=None):
+        if label is None:
+            label = uri
+        return f'[link={uri}]{label}[/link]'
+
+
+def nested_set(dic, keys, value):
+    for key in keys[:-1]:
+        dic = dic.setdefault(key, {})
+    dic[keys[-1]] = value
+
+
+def import_string(path):
+    components = path.split('.')
+    mod = __import__('.'.join(components[0:-1]), globals(), locals(), [components[-1]])
+    return getattr(mod, components[-1])
+
+
+def random_string(n=10):
+    import random
+    import string
+    
+    chars = string.ascii_lowercase + string.ascii_uppercase + string.digits
+    return ''.join(random.choice(chars) for _ in range(n))
+
+def merge_json(obj1, obj2):
+    # Base case: if both values are dictionaries, merge recursively
+    if isinstance(obj1, dict) and isinstance(obj2, dict):
+        merged = {}
+        for key in obj1.keys() | obj2.keys():  # Union of both sets of keys
+            if key in obj1 and key in obj2:
+                merged[key] = merge_json(obj1[key], obj2[key])
+            elif key in obj1:
+                merged[key] = obj1[key]
+            else:
+                merged[key] = obj2[key]
+        return merged
+    # If both are lists, combine them
+    elif isinstance(obj1, list) and isinstance(obj2, list):
+        return obj1 + obj2
+    # If both values are not dicts or lists, return value from obj2
+    else:
+        if obj1 == obj2:
+            return obj1
+        else:
+            raise ValueError(f'Trying to merge objects: {obj1} and {obj2}')

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis/logic.py

@@ -2,7 +2,9 @@ import os
 import json
 from json.decoder import JSONDecodeError
 from os.path import dirname, normpath, abspath
-from prettytable import PrettyTable
+
+from rich.console import Console
+from rich.table import Table
 
 from mantis.helpers import CLI, import_string
 
@@ -37,23 +39,36 @@ def find_config(environment_id=None):
     # Multiple mantis files found
     CLI.info(f'Found {total_mantis_files} mantis.json files:')
 
-    table = PrettyTable(align='l')
-    table.field_names = ["#", "Path", "Connections"]
+    console = Console()
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("#", style="cyan")
+    table.add_column("Path")
+    table.add_column("Connections")
 
     for index, path in enumerate(paths):
         config = load_config(path)
-        connections = config.get('connections', {}).keys()
 
-        # TODO: get project names from compose files
+        # Check for single connection mode
+        single_connection = config.get('connection')
+
+        if single_connection:
+            # Single connection mode - display the connection string
+            connections_display = '[green](single)[/green]'
+        else:
+            # Multi-environment mode - display connection keys
+            connections = config.get('connections', {}).keys()
 
-        colorful_connections = []
-        for connection in connections:
-            color = 'success' if connection == environment_id else 'warning'
-            colorful_connections.append(getattr(CLI, color)(connection, end='', return_value=True))
+            # TODO: get project names from compose files
 
-        table.add_row([index + 1, normpath(dirname(path)), ', '.join(colorful_connections)])
+            colorful_connections = []
+            for connection in connections:
+                color = 'green' if connection == environment_id else 'yellow'
+                colorful_connections.append(f'[{color}]{connection}[/{color}]')
+            connections_display = ', '.join(colorful_connections)
 
-    print(table)
+        table.add_row(str(index + 1), normpath(dirname(path)), connections_display)
+
+    console.print(table)
     CLI.danger(f'[0] Exit now and define $MANTIS_CONFIG environment variable')
 
     path_index = None
@@ -92,8 +107,11 @@ def find_keys_only_in_config(config, template, parent_key=""):
 
 def load_config(config_file):
     if not os.path.exists(config_file):
-        CLI.warning(f'File {config_file} does not exist. Returning empty config')
-        return {}
+        CLI.warning(f'File {config_file} does not exist.')
+        CLI.danger(f'Mantis config not found. Double check your current working directory.')
+        exit()
+        # CLI.warning(f'File {config_file} does not exist. Returning empty config')
+        # return {}
 
     with open(config_file, "r") as config:
         try:
@@ -191,7 +209,8 @@ def execute(manager, command, params):
     else:
         methods_without_environment = ['contexts', 'create_context', 'check_config', 'generate_key', 'read_key']
 
-        if manager.environment_id is None and manager_method not in methods_without_environment:
+        # In single connection mode, environment_id is not required
+        if manager.environment_id is None and not manager.single_connection_mode and manager_method not in methods_without_environment:
             CLI.error('Missing environment')
         elif manager.environment_id is not None and manager_method in methods_without_environment:
             CLI.error('Redundant environment')

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis/managers.py

@@ -8,9 +8,12 @@ from os import path
 from os.path import normpath
 from time import sleep
 
+from rich.console import Console
+from rich.table import Table
+
 from mantis.crypto import Crypto
 from mantis.environment import Environment
-from mantis.helpers import CLI, Colors, merge_json
+from mantis.helpers import CLI, merge_json
 from mantis.logic import find_config, load_config, check_config, load_template_config
 
 
@@ -62,7 +65,8 @@ class AbstractManager(object):
 
     @property
     def connection_details(self):
-        if self.env.id is None:
+        # In single connection mode, env.id is None but we still have a connection
+        if not self.single_connection_mode and self.env.id is None:
             return None
 
         property_name = '_connection_details'
@@ -75,7 +79,7 @@ class AbstractManager(object):
         if hasattr(self, property_name):
             return getattr(self, property_name)
 
-        if 'local' in self.env.id:
+        if self.env.id and 'local' in self.env.id:
             details = {
                 'host': 'localhost',
                 'user': None,
@@ -109,12 +113,14 @@ class AbstractManager(object):
 
     @property
     def docker_connection(self):
-        if self.env.id is None or 'local' in self.env.id:
+        # In single connection mode or when env.id contains 'local', no extra connection needed
+        if not self.single_connection_mode and (self.env.id is None or 'local' in self.env.id):
             return ''
 
         if self.mode == 'remote':
             if self.connection is None:
-                CLI.error(f'Connection for environment {self.env.id} not defined!')
+                env_info = f' for environment {self.env.id}' if self.env.id else ''
+                CLI.error(f'Connection{env_info} not defined!')
             if self.connection.startswith('ssh://'):
                 return f'DOCKER_HOST="{self.connection}"'
             elif self.connection.startswith('context://'):
@@ -139,14 +145,56 @@ class AbstractManager(object):
         # Save merged config to variable
         self.config = defaults.copy()
 
+        # Detect single connection mode (connection string instead of connections dict)
+        has_single_connection = self.config.get('connection') is not None
+        has_multiple_connections = bool(self.config.get('connections', {}))
+
+        # Validate: only one of connection or connections should be defined
+        if has_single_connection and has_multiple_connections:
+            CLI.error('Config error: Cannot define both "connection" and "connections". Use either single connection mode or named environments, not both.')
+
+        self.single_connection_mode = has_single_connection
+
+        # Validate: environment_id should not be provided in single connection mode
+        if self.single_connection_mode and self.environment_id:
+            CLI.error(f'Config error: Environment "{self.environment_id}" was provided, but config uses single connection mode. Remove the environment argument or switch to named environments using "connections".')
+
         self.key_file = normalize(path.join(self.config['encryption']['folder'], 'mantis.key'))
         self.environment_path = normalize(self.config['environment']['folder'])
 
-        if self.environment_id:
+        if self.single_connection_mode:
+            # In single connection mode, compose files are directly in compose folder
+            self.compose_path = normalize(self.config['compose']['folder'])
+        elif self.environment_id:
             self.compose_path = normalize(path.join(self.config['compose']['folder'], self.environment_id))
 
     def init_environment(self):
+        if self.single_connection_mode:
+            # Single connection mode: no environment_id required
+            self.env = Environment(
+                environment_id=None,
+                folder=self.environment_path,
+                single_mode=True,
+            )
+
+            # connection from single 'connection' key
+            self.connection = self.config.get('connection')
+
+            # compose files directly in compose folder
+            compose_file_paths = os.popen(f'find {self.compose_path} -maxdepth 1 -name "*.yml" -o -name "*.yaml"').read().strip().split('\n')
+
+            # Remove empty strings
+            self.compose_files = list(filter(None, compose_file_paths))
+
+            # Read compose files
+            self.compose_config = self.read_compose_configs()
+            return
+
         if not self.environment_id:
+            self.env = Environment(
+                environment_id=None,
+                folder=self.environment_path,
+            )
             self.connection = None
             return
 
@@ -167,6 +215,30 @@ class AbstractManager(object):
         # Read compose files
         self.compose_config = self.read_compose_configs()
 
+    def are_env_files_in_sync(self, env_file):
+        """
+        Checks if .env and .env.encrypted files are in sync.
+        Returns True if they match, False otherwise.
+        """
+        env_file_encrypted = f'{env_file}.encrypted'
+
+        # Check if both files exist
+        if not os.path.exists(env_file):
+            return False
+        if not os.path.exists(env_file_encrypted):
+            return False
+
+        try:
+            decrypted_environment = self.decrypt_env(env_file=env_file, return_value=True)
+            loaded_environment = self.env.load(env_file)
+
+            if decrypted_environment is None or loaded_environment is None:
+                return False
+
+            return loaded_environment == decrypted_environment
+        except Exception:
+            return False
+
     def check_environment_encryption(self, env_file):
         decrypted_environment = self.decrypt_env(env_file=env_file, return_value=True)  # .env.encrypted
         loaded_environment = self.env.load(env_file)  # .env
@@ -345,9 +417,15 @@ class BaseManager(AbstractManager):
 
             return values if return_value else None
 
-        CLI.info(f'Encrypting environment file {env_file}...')
         env_file_encrypted = f'{env_file}.encrypted'
 
+        # Skip if files are already in sync (unless return_value is True, which is used for internal checks)
+        if not return_value and self.are_env_files_in_sync(env_file):
+            CLI.success(f'Skipping {env_file} - already in sync with {env_file_encrypted}')
+            return None
+
+        CLI.info(f'Encrypting environment file {env_file}...')
+
         if not self.KEY:
             CLI.error('Missing mantis key! (%s)' % self.key_file)
 
@@ -408,6 +486,11 @@ class BaseManager(AbstractManager):
 
         env_file_encrypted = f'{env_file}.encrypted'
 
+        # Skip if files are already in sync (unless return_value is True, which is used for internal checks)
+        if not return_value and self.are_env_files_in_sync(env_file):
+            CLI.success(f'Skipping {env_file_encrypted} - already in sync with {env_file}')
+            return None
+
         if not return_value:
             CLI.info(f'Decrypting environment file {env_file_encrypted}...')
 
@@ -614,7 +697,8 @@ class BaseManager(AbstractManager):
         if container not in self.get_containers():
             CLI.error(f"Container {container} not found")
 
-        CLI.info(f'Health-checking {Colors.YELLOW}{container}{Colors.ENDC}...')
+        console = Console()
+        console.print(f'[blue]Health-checking [yellow]{container}[/yellow]...[/blue]')
 
         if self.has_healthcheck(container):
             healthcheck_config = self.get_healthcheck_config(container)
@@ -624,8 +708,8 @@ class BaseManager(AbstractManager):
             interval = healthcheck_interval / coeficient
             retries = healthcheck_retries * coeficient
 
-            CLI.info(f'Interval: {Colors.FAINT}{healthcheck_interval}{Colors.ENDC} s -> {Colors.YELLOW}{interval} s')
-            CLI.info(f'Retries: {Colors.FAINT}{healthcheck_retries}{Colors.ENDC} -> {Colors.YELLOW}{retries}')
+            console.print(f'[blue]Interval: [dim]{healthcheck_interval}[/dim] s -> [yellow]{interval} s[/yellow][/blue]')
+            console.print(f'[blue]Retries: [dim]{healthcheck_retries}[/dim] -> [yellow]{retries}[/yellow][/blue]')
 
             start = time.time()
 
@@ -633,13 +717,13 @@ class BaseManager(AbstractManager):
                 is_healthy, status = self.check_health(container)
 
                 if is_healthy:
-                    print(f"#{retry + 1}/{retries}: Status of '{container}' is {Colors.GREEN}{status}{Colors.ENDC}.")
+                    console.print(f"#{retry + 1}/{retries}: Status of '{container}' is [green]{status}[/green].")
                     end = time.time()
                     loading_time = end - start
-                    print(f'Container {Colors.YELLOW}{container}{Colors.ENDC} took {Colors.BLUE}{Colors.UNDERLINE}{loading_time} s{Colors.ENDC} to become healthy')
+                    console.print(f'Container [yellow]{container}[/yellow] took [blue underline]{loading_time} s[/blue underline] to become healthy')
                     return True
                 else:
-                    print(f"#{retry + 1}/{retries}: Status of '{container}' is {Colors.RED}{status}{Colors.ENDC}.")
+                    console.print(f"#{retry + 1}/{retries}: Status of '{container}' is [red]{status}[/red].")
 
                 if retries > 1:
                     sleep(interval)
@@ -1089,14 +1173,73 @@ class BaseManager(AbstractManager):
         """
         Prints images and containers
         """
+        console = Console()
+
         CLI.info('Getting status...')
         steps = 2
 
         CLI.step(1, steps, 'List of Docker images')
-        self.docker(f'image ls')
+        images_output = self.docker('image ls --format "{{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.CreatedSince}}\t{{.Size}}"', return_output=True)
+
+        if images_output.strip():
+            images_table = Table(show_header=True, header_style="bold")
+            images_table.add_column("REPOSITORY", style="cyan")
+            images_table.add_column("TAG", style="yellow")
+            images_table.add_column("IMAGE ID", style="bright_blue")
+            images_table.add_column("CREATED", style="magenta")
+            images_table.add_column("SIZE", style="green")
+
+            for line in images_output.strip().split('\n'):
+                parts = line.split('\t')
+                if len(parts) >= 5:
+                    repo, tag, image_id, created, size = parts[0], parts[1], parts[2], parts[3], parts[4]
+                    images_table.add_row(repo, tag, image_id, created, size)
+
+            console.print(images_table)
 
         CLI.step(2, steps, 'Docker containers')
-        self.docker(f'container ls -a --size')
+        containers_output = self.docker('container ls -a --format "{{.Names}}\t{{.Status}}\t{{.Image}}\t{{.Ports}}\t{{.Size}}"', return_output=True)
+
+        if containers_output.strip():
+            containers_table = Table(show_header=True, header_style="bold")
+            containers_table.add_column("NAME", style="blue")
+            containers_table.add_column("STATUS")
+            containers_table.add_column("IMAGE", style="magenta")
+            containers_table.add_column("PORTS")
+            containers_table.add_column("SIZE", style="dark_orange")
+
+            for line in containers_output.strip().split('\n'):
+                parts = line.split('\t')
+                if len(parts) >= 5:
+                    name, status, image, ports, size = parts[0], parts[1], parts[2], parts[3], parts[4]
+
+                    # Colorize status based on state
+                    if 'Up' in status:
+                        status_colored = f'[green]{status}[/green]'
+                    elif 'Exited' in status:
+                        status_colored = f'[red]{status}[/red]'
+                    elif 'Created' in status:
+                        status_colored = f'[yellow]{status}[/yellow]'
+                    elif 'Paused' in status:
+                        status_colored = f'[yellow]{status}[/yellow]'
+                    else:
+                        status_colored = status
+
+                    # Split ports into multiple lines with different colors for IPv4/IPv6
+                    ports_list = ports.split(', ') if ports else ['']
+                    colored_ports = []
+                    for port in ports_list:
+                        if '::' in port or '[' in port:
+                            # IPv6 port
+                            colored_ports.append(f'[bright_white]{port}[/bright_white]')
+                        else:
+                            # IPv4 port
+                            colored_ports.append(f'[cyan]{port}[/cyan]')
+                    ports_formatted = '\n'.join(colored_ports)
+
+                    containers_table.add_row(name, status_colored, image, ports_formatted, size)
+
+            console.print(containers_table)
 
     def networks(self):
         """

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis/mantis.tpl

@@ -31,6 +31,7 @@
   },
   "zero_downtime": [],
   "project_path": "~",
+  "connection": null,
   "connections": {
   }
 }

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mantis-cli
-Version: 19.2.0
+Version: 20.0.0
 Summary: Management command to build and deploy webapps, especially based on Django
 Home-page: https://github.com/PragmaticMates/mantis-cli
 Author: Erik Telepovský
@@ -9,6 +9,7 @@ Maintainer: Pragmatic Mates
 Maintainer-email: info@pragmaticmates.com
 License: GNU General Public License (GPL)
 Keywords: management deployment docker command
+Platform: UNKNOWN
 Classifier: Programming Language :: Python
 Classifier: Operating System :: OS Independent
 Classifier: Environment :: Web Environment
@@ -18,11 +19,6 @@ Classifier: License :: OSI Approved :: GNU General Public License (GPL)
 Classifier: Development Status :: 5 - Production/Stable
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cffi
-Requires-Dist: cryptography
-Requires-Dist: pycryptodome
-Requires-Dist: PyYAML
-Requires-Dist: prettytable
 
 # mantis-cli
 
@@ -341,3 +337,4 @@ Works as follows:
 ## Release notes
 
 Mantis uses semantic versioning. See more in [changelog](https://github.com/PragmaticMates/mantis-cli/blob/master/CHANGES.md).
+

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis_cli.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 mantis = mantis.command_line:run
+

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/mantis_cli.egg-info/requires.txt

@@ -2,4 +2,4 @@ cffi
 cryptography
 pycryptodome
 PyYAML
-prettytable
+rich

{mantis_cli-19.2.0 → mantis_cli-20.0.0}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 from mantis import VERSION
 
 setup(
-    name='mantis-cli',
+    name='mantis_cli',
     version=VERSION,
     description='Management command to build and deploy webapps, especially based on Django',
     long_description=open('README.md').read(),
@@ -16,7 +16,7 @@ setup(
     url='https://github.com/PragmaticMates/mantis-cli',
     packages=find_packages(),
     include_package_data=True,
-    install_requires=['cffi', 'cryptography', 'pycryptodome', 'PyYAML', 'prettytable'],
+    install_requires=['cffi', 'cryptography', 'pycryptodome', 'PyYAML', 'rich'],
     entry_points={
         'console_scripts': ['mantis=mantis.command_line:run'],
     },

mantis_cli-19.2.0/mantis/__init__.py

@@ -1 +0,0 @@
-VERSION = '19.2.0'

mantis_cli-19.2.0/mantis/helpers.py

@@ -1,131 +0,0 @@
-class Colors:
-    # https://stackoverflow.com/questions/5947742/how-to-change-the-output-color-of-echo-in-linux
-    BLACK = "\033[0;30m"
-    BLUE = '\033[94m'
-    # BLUE = "\033[0;34m"
-    GREEN = '\033[92m'
-    # GREEN = "\033[0;32m"
-    YELLOW = '\033[93m'
-    # YELLOW = "\033[1;33m"
-    RED = '\033[91m'
-    # RED = "\033[0;31m"
-    PINK = '\033[95m'
-    BOLD = '\033[1m'
-    UNDERLINE = '\033[4m'
-    BROWN = "\033[0;33m"
-    PURPLE = "\033[0;35m"
-    CYAN = "\033[0;36m"
-    LIGHT_GRAY = "\033[0;37m"
-    DARK_GRAY = "\033[1;30m"
-    LIGHT_RED = "\033[1;31m"
-    LIGHT_GREEN = "\033[1;32m"
-    LIGHT_BLUE = "\033[1;34m"
-    LIGHT_PURPLE = "\033[1;35m"
-    LIGHT_CYAN = "\033[1;36m"
-    LIGHT_WHITE = "\033[1;37m"
-    FAINT = "\033[2m"
-    ITALIC = "\033[3m"
-    BLINK_SLOW = "\033[5m"
-    BLINK_FAST = "\033[6m"
-    NEGATIVE = "\033[7m"
-    CROSSED = "\033[9m"
-    RESET = "\033[0m"
-    ENDC = '\033[0m'
-
-
-class CLI(object):
-    @staticmethod
-    def print_or_return(text, color, end='\n', return_value=False):
-        s = f'{color}{text}{Colors.ENDC}'
-        if return_value:
-            return f'{s}{end}'
-        print(s, end=end)
-
-    @staticmethod
-    def error(text):
-        exit(f'{Colors.RED}{text}{Colors.ENDC}')
-
-    @staticmethod
-    def bold(text, end='\n', return_value=False):
-        return CLI.print_or_return(text=text, color=Colors.BOLD, end=end, return_value=return_value)
-
-    @staticmethod
-    def info(text, end='\n', return_value=False):
-        return CLI.print_or_return(text=text, color=Colors.BLUE, end=end, return_value=return_value)
-
-    @staticmethod
-    def pink(text, end='\n', return_value=False):
-        return CLI.print_or_return(text=text, color=Colors.PINK, end=end, return_value=return_value)
-
-    @staticmethod
-    def success(text, end='\n', return_value=False):
-        return CLI.print_or_return(text=text, color=Colors.GREEN, end=end, return_value=return_value)
-
-    @staticmethod
-    def warning(text, end='\n', return_value=False):
-        return CLI.print_or_return(text=text, color=Colors.YELLOW, end=end, return_value=return_value)
-
-    @staticmethod
-    def danger(text, end='\n', return_value=False):
-        return CLI.print_or_return(text=text, color=Colors.RED, end=end, return_value=return_value)
-
-    @staticmethod
-    def underline(text, end='\n', return_value=False):
-        return CLI.print_or_return(text=text, color=Colors.UNDERLINE, end=end, return_value=return_value)
-
-    @staticmethod
-    def step(index, total, text, end='\n', return_value=False):
-        return CLI.print_or_return(text=f'[{index}/{total}] {text}', color=Colors.YELLOW, end=end, return_value=return_value)
-
-    @staticmethod
-    def link(uri, label=None):
-        if label is None: 
-            label = uri
-        parameters = ''
-
-        # OSC 8 ; params ; URI ST <name> OSC 8 ;; ST 
-        escape_mask = '\033]8;{};{}\033\\{}\033]8;;\033\\'
-
-        return escape_mask.format(parameters, uri, label)
-
-
-def nested_set(dic, keys, value):
-    for key in keys[:-1]:
-        dic = dic.setdefault(key, {})
-    dic[keys[-1]] = value
-
-
-def import_string(path):
-    components = path.split('.')
-    mod = __import__('.'.join(components[0:-1]), globals(), locals(), [components[-1]])
-    return getattr(mod, components[-1])
-
-
-def random_string(n=10):
-    import random
-    import string
-    
-    chars = string.ascii_lowercase + string.ascii_uppercase + string.digits
-    return ''.join(random.choice(chars) for _ in range(n))
-
-def merge_json(obj1, obj2):
-    # Base case: if both values are dictionaries, merge recursively
-    if isinstance(obj1, dict) and isinstance(obj2, dict):
-        merged = {}
-        for key in obj1.keys() | obj2.keys():  # Union of both sets of keys
-            if key in obj1 and key in obj2:
-                merged[key] = merge_json(obj1[key], obj2[key])
-            elif key in obj1:
-                merged[key] = obj1[key]
-            else:
-                merged[key] = obj2[key]
-        return merged
-    # If both are lists, combine them
-    elif isinstance(obj1, list) and isinstance(obj2, list):
-        return obj1 + obj2
-    # If both values are not dicts or lists, return value from obj2
-    else:
-        if obj1 == obj2:
-            return obj1
-        else:
-            raise ValueError(f'Trying to merge objects: {obj1} and {obj2}')