docker-dev-env 0.1.0__py3-none-any.whl

docker_dev_env/bash_scripts/README.md

@@ -0,0 +1,5 @@
+# Development helper scripts
+Bash Scripts for development, can be used with your terminal program (e.g. tilix)
+
+ - bash_container.bash - runs a new bash inside your container for debugging.
+ - docker_log.bash - runs "docker compose logs -f" with your env-file

docker_dev_env/bash_scripts/bash_container.bash

@@ -0,0 +1,17 @@
+#!/bin/bash
+SCRIPT_PATH="$(dirname "$0")"
+BASE_PATH=$(realpath "$SCRIPT_PATH/..")
+SERVICE=$1
+
+cd "$BASE_PATH" || exit
+
+if [ $# -eq 1 ]; then
+  ENV_FILE=$(realpath $BASE_PATH/local_vars.env)
+else
+  ENV_FILE=$2
+fi
+
+ENV_FILE=$ENV_FILE docker compose --env-file $ENV_FILE run --rm "$SERVICE" bash
+
+echo "Press CTRL+C to close..."
+sleep infinity

docker_dev_env/bash_scripts/docker_log.bash

@@ -0,0 +1,36 @@
+#!/bin/bash
+SCRIPT_PATH="$(dirname "$0")"
+BASE_PATH=$(realpath $SCRIPT_PATH/..)
+DOCKER_PATH=$(realpath $BASE_PATH/$1)
+SERVICE=$2
+
+if [ $# -eq 2 ]; then
+  ENV_FILE=$(realpath $BASE_PATH/local_vars.env)
+else
+  ENV_FILE=$3
+fi
+
+emoji[0]="😖"
+emoji[1]="😭"
+emoji[2]="😫"
+emoji[3]="😞"
+emoji[4]="😓"
+
+
+cd $DOCKER_PATH
+
+while :
+do
+  ENV_FILE=$ENV_FILE docker compose --env-file $ENV_FILE logs -f --tail=50 $SERVICE
+
+  size=${#emoji[@]}
+  index=$(($RANDOM % $size))
+  echo "${emoji[$index]} $SERVICE log ended, press <CTRL+C> to close..."
+  sleep 5
+done
+
+
+ENV_FILE=$ENV_FILE docker compose --env-file $ENV_FILE logs -f $SERVICE
+
+echo "Press CTRL+C to close..."
+sleep infinity

docker_dev_env/cli.py

@@ -0,0 +1,60 @@
+import argparse
+
+from .docker_utils import DockerUtils
+from .fun import goodbye
+from .model.project import Project
+from .ui import DockerDevEnvUi
+
+
+def _setup_argparse() -> argparse.ArgumentParser:
+    """Configure argument parser."""
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument(
+        '-c', '--cleanup', action='store_true',
+        help='just cleanup')
+    parser.add_argument(
+        '-n', '--no-cleanup', action='store_true',
+        help='no cleanup after finish')
+    parser.add_argument(
+        '-p', '--project', default='project-config.yml',
+        help='project yaml file')
+    parser.add_argument(
+        '-s', '--stopped', action='store_true',
+        help='do not create container')
+    parser.add_argument(
+        '-r', '--rebuild', action='store_true',
+        help='rebuild container before start')
+    # we show "-i"/init for --help but as its already handled
+    # by the ./run bash script we ignore it.
+    parser.add_argument(
+        '-i', '--init', action='store_true',
+        help='(re)init: deletes the local dev')
+    return parser
+
+
+def main():
+    parser = _setup_argparse()
+    args = parser.parse_args()
+    project = Project.load(args.project)
+    _docker_utils = DockerUtils(project)
+    if args.cleanup:
+        _docker_utils.cleanup()
+        return
+    if args.rebuild:
+        _docker_utils.build_all()
+
+    if not args.stopped:
+        _docker_utils.autostart()
+    app = DockerDevEnvUi(_docker_utils)
+    app.run()
+
+    # Cleanup at the end
+    if not args.no_cleanup:
+        _docker_utils.cleanup()
+    goodbye()
+
+
+if __name__ == '__main__':
+    main()

docker_dev_env/docker_utils.py

@@ -0,0 +1,202 @@
+import asyncio
+import subprocess
+import threading
+
+from typing import List
+
+import docker
+
+from .model.project import Project, Service
+
+
+class DockerUtils:
+    """Wrapper around Popen and docker to manage docker container."""
+
+    def __init__(self, project: Project):
+        self.docker_client = docker.from_env()
+        self.project = project
+
+    def autostart(self):
+        if self.project.networks:
+            self.create_network(self.project.networks, )
+        for service in self.project.services:
+            if service.autostart:
+                self.compose_start(service, )
+
+    def run_background(self, cmds):
+        def run_docker_command():
+            for cmd in cmds:
+                # FIXME: use asyncio.create_subprocess_exec instead
+                subprocess.run(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    text=True)
+
+        thread = threading.Thread(target=run_docker_command, daemon=True)
+        thread.start()
+
+    def compose_cmd(self, cmd: List):
+        docker_cmd = ['docker', 'compose']
+        if self.project.env_file:
+            docker_cmd += ['--env-file', self.project.env_file]
+        if isinstance(cmd, str):
+            docker_cmd.append(cmd)
+        else:
+            docker_cmd += cmd
+        return docker_cmd
+
+    def logs_cmd(self, service):
+        return self.compose_cmd(['logs', '-f', '--tail=50', service.name])
+
+    def compose_start_cmd(self, service: Service):
+        return self.compose_cmd(['up', '-d', service.name])
+
+    def compose_start(self, service: Service):
+        """Start docker compose command."""
+        if hasattr(service, 'description') and service.description:
+            print(f'🚀 Starting {service.description}...')
+        cmd = self.compose_start_cmd(service)
+        subprocess.run(cmd)
+
+    def compose_kill_cmd(self, service: Service):
+        """Kill container using compose (for faster down)."""
+        return self.compose_cmd(['kill', service.name])
+
+    def compose_kill(self, service: Service):
+        """Kill container using compose (for faster down)."""
+        title = service.name
+        if hasattr(service, 'description') and service.description:
+            title = service.description
+        print(f'➜ Kill container {title}')
+        cmd = self.compose_kill_cmd(service)
+        subprocess.run(cmd)
+
+    def compose_build_cmd(self, service: Service):
+        """Build image by service name."""
+        return self.compose_cmd(['build', service.name])
+
+    def compose_build(self, service: Service):
+        """Build image by service name."""
+        cmd = self.compose_build_cmd(service)
+        subprocess.run(cmd)
+
+    def compose_down(self):
+        """Run docker compose down to clean up."""
+        cmd = self.compose_cmd(['down'])
+        subprocess.run(cmd)
+
+    def create_network(self, networks):
+        if isinstance(networks, str):
+            networks = [networks]
+        for network in networks:
+            print(f'🌐 Create docker network {network}')
+            docker_cmd = ['docker', 'network', 'create', network]
+            subprocess.run(docker_cmd)
+
+    def rm_network(self, networks):
+        if isinstance(networks, str):
+            networks = [networks]
+        for network in networks:
+            print(f'➜ Remove network {network}')
+            docker_cmd = ['docker', 'network', 'rm', network]
+            subprocess.run(docker_cmd)
+
+    def _not_available(self, service: Service):
+        return {
+            'service': service.title,
+            'container_id': 'N/A',
+            'status': 'not running',
+            'health': 'unknown',
+            'image': 'N/A',
+        }
+
+    def _get_health_status(self, container) -> str:
+        """Get health check status from container."""
+        container.reload()
+        state = container.attrs.get('State', {})
+
+        if state.get('Health'):
+            health = state['Health'].get('Status', 'unknown')
+            if health == 'healthy':
+                color = 'green'
+            elif health == 'unhealthy':
+                color = 'red'
+            else:
+                color = 'yellow'
+            return f'[{color}]{health}[/]'
+        return 'no check'
+
+    def service_status(self, service: Service):
+        containers = self.docker_client.containers.list(
+            all=True,
+            filters={'label': f'com.docker.compose.service={service.name}'}
+        )
+        if not containers:
+            return self._not_available(service)
+        container = containers[0]
+        health_status = self._get_health_status(container)
+        tags = container.image.tags
+        return {
+            'service': service.title,
+            'container_id': container.short_id,
+            'status': container.status,
+            'health': health_status,
+            'image': tags[0] if tags else 'unknown',
+        }
+
+    def service_running(self, service: Service):
+        containers = self.docker_client.containers.list(
+            all=True,
+            filters={'label': f'com.docker.compose.service={service.name}'}
+        )
+        if not containers:
+            return False
+        container = containers[0]
+        return container.status == 'running'
+
+    @property
+    def services(self):
+        return self.project.services
+
+    def health_row(self, service: Service):
+        service_status = self.service_status(service)
+        return [
+            service_status['service'],
+            service_status['container_id'],
+            service_status['status'],
+            service_status['health'],
+            service_status['image'],
+        ]
+
+    def rebuild(self, service: Service):
+        cmds = [
+            self.compose_kill_cmd(service),
+            self.compose_build_cmd(service)
+        ]
+        if service.autostart:
+            cmds.append(self.compose_start_cmd(service))
+        self.run_background(cmds)
+
+    def restart(self, service: Service):
+        cmds = []
+        if self.service_running(service):
+            cmds.append(self.compose_kill_cmd(service))
+        cmds.append(self.compose_start_cmd(service))
+        self.run_background(cmds)
+
+    def kill(self, service: Service):
+        self.run_background([self.compose_kill_cmd(service)])
+
+    def build_all(self):
+        for service in self.services:
+            if service.rebuild:
+                self.compose_build(service)
+
+    def cleanup(self):
+        for service in self.services:
+            self.compose_kill(service)
+        self.compose_down()
+        if self.project.networks and self.project.cleanup_networks:
+            self.rm_network(self.project.networks)
+        print(' 🧽 Cleanup complete.')

docker_dev_env/fun.py

@@ -0,0 +1,18 @@
+import random
+
+FAREWELL = [
+    'How lucky I am to have something that makes saying goodbye so hard.',
+    "Don't cry because it's over, smile because it happened.",
+    'The pain of parting is nothing to the joy of meeting again.',
+    "Man's feelings are always purest and most glowing in the "
+    'hour of meeting and farewell.',
+    'So long, and thanks for all the fish.',
+    'We only part to meet again.',
+    'Every goodbye makes the next hello closer.',
+    'Let there be spaces in your togetherness.',
+    'My battery is low, and its getting dark.'
+]
+
+
+def goodbye():
+    print(f'\n 👋 Goodbye: {random.choice(FAREWELL)} ')

docker_dev_env/model/project.py

@@ -0,0 +1,73 @@
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import List
+
+import yaml
+
+
+@dataclass
+class Service:
+    name: str
+    description: str | None = None
+    rebuild: bool = True
+    autostart: bool = True
+
+    @property
+    def title(self):
+        """Return the title we show to the user."""
+        return self.description if self.description else self.name
+
+
+class ProjectEnv:
+    services: List[Service]
+    docker_compose_path: str = './compose.yml'
+    update_interval: int = 1
+    log_tail: int = 100
+    build_timeout: float = 3600
+    env_file: str | None = None
+    networks: List | None = None
+    cleanup_networks: bool = True
+
+
+@dataclass
+class Project:
+    name: str
+    # environments: Dict[ProjectEnv]
+    services: List[Service]
+    docker_compose_path: str = './compose.yml'
+    update_interval: int = 1
+    log_tail: int = 100
+    build_timeout: float = 3600
+    env_file: None | str = None
+    networks: List | None = None
+    cleanup_networks: bool = True
+
+    def save(self, path: str):
+        with open(path, 'w') as f:
+            yaml.safe_dump(asdict(self), f)
+
+    @staticmethod
+    def create_new(path: str):
+        print('Create new Project config file.')
+        project = Project('new_project', [])
+        project.save(path)
+        return project
+
+    @staticmethod
+    def load(path: str):
+        if not Path(path).exists():
+            return Project.create_new(path)
+        with open(path, 'r') as f:
+            data = yaml.safe_load(f)
+            if not data:
+                return Project.create_new(path)
+            return Project(**data)
+
+    def __post_init__(self):
+        services = []
+        for _service in self.services:
+            if isinstance(_service, Service):
+                services.append(_service)
+            else:
+                services.append(Service(**_service))
+        self.services = services

docker_dev_env/screens/log_service.py

@@ -0,0 +1,53 @@
+import asyncio
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.screen import ModalScreen
+from textual.widgets import Footer, Header, Log
+
+from ..model.project import Service
+
+
+class LogService(ModalScreen):
+    CSS_PATH = 'log_service.tcss'
+    BINDINGS = [
+        Binding('escape', 'close_modal', 'Close', show=True),
+    ]
+
+    def __init__(self, service: Service):
+        super().__init__()
+        self.docker_utils = self.app.docker_utils
+        self.service = service
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Log(id='docker_logs')
+        yield Footer()
+
+    def action_close_modal(self) -> None:
+        """Close the modal screen."""
+        self.app.pop_screen()
+
+    def on_mount(self) -> None:
+        """Start streaming Docker logs when modal mounts."""
+        log_widget = self.query_one('#docker_logs')
+        self.run_worker(self.stream_docker_logs(log_widget))
+
+    async def stream_docker_logs(self, log_widget: Log) -> None:
+        try:
+            cmd = self.docker_utils.logs_cmd(self.service)
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            while True:
+                line = await process.stdout.readline()
+                if not line:
+                    break
+                # Decode and write to log widget
+                log_widget.write(line.decode().rstrip() + '\n')
+        except Exception as e:
+            log_widget.write(f'Error: {str(e)}')
+        finally:
+            if process:
+                process.terminate()

docker_dev_env/tilix.py

@@ -0,0 +1,12 @@
+import json
+
+
+# TODO: create temporary JSON file based on YAML-config file.
+# TODO: if no config is given just create a fitting layout, either 
+# rows colums
+# 1, 2
+# 2, 2
+# 3, 2
+# 4, 2
+
+# allow groups

docker_dev_env/ui.py

@@ -0,0 +1,97 @@
+from textual.app import App, ComposeResult, on
+from textual.binding import Binding
+from textual.containers import Container
+from textual.widgets import \
+    DataTable, Footer, Static, Header
+from textual.css.query import NoMatches
+
+from .model.project import Service
+from .docker_utils import DockerUtils
+from .screens.log_service import LogService
+
+
+class ContainerTable(DataTable):
+    """DataTable displaying known Docker services and their health."""
+
+    def on_mount(self) -> None:
+        self.cursor_type = 'row'
+        self.add_columns(
+            'Service',
+            'Container ID',
+            'Status',
+            'Health',
+            'Image',
+        )
+
+
+class DockerStats(Static):
+    """Display Docker daemon connection status."""
+
+    status = 'Initializing...'
+
+    def render(self) -> str:
+        return f'[bold cyan]Status:[/bold cyan] {self.status}'
+
+
+class DockerDevEnvUi(App):
+    CSS_PATH = 'ui.tcss'
+    BINDINGS = [
+        Binding('q', 'quit', 'Quit'),
+        Binding('r', 'rebuild', 'Rebuild'),
+        Binding('s', 'restart', '(Re)Start'),
+        Binding('k', 'kill', 'Kill'),
+        Binding('enter', 'logs', 'Logs'),
+        # Binding('t', 'tiilix', 'Tilix Window')
+    ]
+
+    def __init__(self, docker_utils: DockerUtils):
+        super().__init__()
+        self.docker_utils = docker_utils
+
+    def current_service(self) -> Service:
+        table = self.query_one('#containers')
+        return self.docker_utils.services[table.cursor_row]
+
+    def action_rebuild(self):
+        self.docker_utils.rebuild(self.current_service())
+
+    def action_restart(self):
+        self.docker_utils.restart(self.current_service())
+
+    def action_kill(self):
+        self.docker_utils.kill(self.current_service())
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets."""
+        yield Header()
+        yield ContainerTable(id='containers')
+        # with Container(id='stats_box'):
+        #     yield DockerStats(id='stats')
+        yield Footer()
+
+    def on_data_table_row_selected(
+            self, event: ContainerTable.CellSelected) -> None:
+        """Handle click/enter on a cell."""
+        self.push_screen(LogService(self.current_service()))
+
+    def init_services(self):
+        try:
+            containers = self.query_one('#containers')
+        except NoMatches:
+            return
+        for service in self.docker_utils.services:
+            containers.add_row(*self.docker_utils.health_row(service))
+
+    def update_services(self):
+        try:
+            containers = self.query_one('#containers')
+        except NoMatches:
+            return
+        for row, service in enumerate(self.docker_utils.services):
+            for col, val in enumerate(self.docker_utils.health_row(service)):
+                containers.update_cell_at((row, col), val)
+
+    def on_mount(self) -> None:
+        self.init_services()
+        self.update_services()
+        self.set_interval(1, self.update_services)

docker_dev_env/ui.tcss

@@ -0,0 +1,9 @@
+#stats_box {
+    height: 3;
+    border: solid $accent;
+    background: $panel;
+}
+
+#containers {
+    height: 1fr;
+}

docker_dev_env-0.1.0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: docker_dev_env
+Version: 0.1.0
+Summary: Docker based development environment
+Author-email: Andreas Bresser <andreas.bresser@dfki.de>
+License: BSD-3-Clause
+Project-URL: Homepage, https://codeberg.org/brean/docker-dev-env
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argcomplete
+Requires-Dist: docker
+Requires-Dist: dotenv
+Requires-Dist: pyyaml
+Requires-Dist: textual
+Dynamic: license-file
+
+# docker-dev-env
+
+Python and Bash scripts around docker to manage a docker compose based development environments.
+
+## Usage
+just copy the `project-config.yml` and `run.bash`-file in your project root directory and modify the `project-config.yml` to tell it what services to manage.
+
+It will ask to install `docker` and `docker compose` if they are not installed.
+
+At first run it asks to install as local virutal environment inside your project and adds this to your .gitignore.
+
+## Features
+- just one run.bash-script needed to manage the whole project
+- keyboard-shortcuts and args to start, (re)build and log docker container
+- include provided env-file for secrets and deployment
+
+## Screenshot
+![](docs/screenshot1.png)

docker_dev_env-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+docker_dev_env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docker_dev_env/cli.py,sha256=5d3BXZs879RXkK6QUltnZH--NDQJCKOQ4349I4gZzq4,1702
+docker_dev_env/docker_utils.py,sha256=wf2afvM8CmeRTCYJso9ThRLSracJnbRmk3lMsckZGBg,6716
+docker_dev_env/fun.py,sha256=9tlhqxxcG0w46Qj-7DUjtR5N2BhcZssfxNEqQwIzbIA,637
+docker_dev_env/tilix.py,sha256=iMhu760JuJnkc2HPaVblZbVYhSx1PMS_QLc-RnmOx9g,201
+docker_dev_env/ui.py,sha256=q-PZ3bDOSEVKmFXEff2wyoHCVPFOgC6ozZCqGaQNdXQ,2961
+docker_dev_env/ui.tcss,sha256=FwvZ21KCS8Rk0WC5R62t3_mQoAsPA_cQ2f8e0unZwtE,114
+docker_dev_env/bash_scripts/README.md,sha256=TglpBEqOZgPDoWMuO_TsimtjzzCijhKNLc5zOXqq5BA,259
+docker_dev_env/bash_scripts/bash_container.bash,sha256=PwXNvOznDQloNVS5VwvdRDbVExJ2-ITVKM49hgcn7QM,340
+docker_dev_env/bash_scripts/docker_log.bash,sha256=gha4V-J70JB9Ekd5JuOMf0qjbEjqV4jQxMie1C3C_UE,677
+docker_dev_env/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docker_dev_env/model/project.py,sha256=HwMMKtjKArWUsW6S7h8HgUYbwF1-yWwJlem3AKOcdKk,1897
+docker_dev_env/screens/log_service.py,sha256=cMRukcS7BRaqv4V_ZJDAwi5YITU80HXJLGempMa9Dc8,1691
+docker_dev_env-0.1.0.dist-info/licenses/LICENSE,sha256=qeAwnsqJbKlClZS--g3HQl_42jGt0vnUyUeyjCOPh0Q,1466
+docker_dev_env-0.1.0.dist-info/METADATA,sha256=h55dP4oN_7hCa3BpQ8FtzxnzGgZxOrcoI-sjSqq5Ce0,1197
+docker_dev_env-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+docker_dev_env-0.1.0.dist-info/entry_points.txt,sha256=wpCncpE8AalYZ7ojdxxKpfY3zhldnMsDIFh8XvT5JRk,59
+docker_dev_env-0.1.0.dist-info/top_level.txt,sha256=-i2tXphymAOjHchvnFDohcv3C9MXmiXVvpeZjU4ADkQ,15
+docker_dev_env-0.1.0.dist-info/RECORD,,

docker_dev_env-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

docker_dev_env-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+docker_dev_env = docker_dev_env.cli:main

docker_dev_env-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2026 Andreas Bresser. 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

docker_dev_env-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+docker_dev_env