dockerclustermon 0.2.0__tar.gz

dockerclustermon-0.2.0/.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+.vscode/
+
+/uv.lock

dockerclustermon-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Michael Kennedy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dockerclustermon-0.2.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.3
+Name: dockerclustermon
+Version: 0.2.0
+Summary: A CLI tool for a live view of your docker containers running on a remote server.
+Project-URL: Homepage, https://github.com/mikeckennedy/dockerclustermon
+Author-email: Michael Kennedy <michael@talkpython.fm>
+License: MIT
+Keywords: Docker,Docker Compose,Monitoring
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: rich>=13.9.4
+Requires-Dist: typer>=0.13.1
+Description-Content-Type: text/markdown
+
+# dockerclustermon - A TUI utility to monitor your docker containers
+
+A TUI tool for a live view of your docker containers running on a remote server. Here's a graphic of it running (refreshes every 5 seconds or so automatically):
+
+![](https://mkennedy-shared.nyc3.digitaloceanspaces.com/docker-status.gif)
+
+Notice that it uses color to communicate outlier values. For example, low CPU is green, middle-of-the-road CPU is cyan, and heavy CPU usage is red. Similarly for memory. The memory limit column reflects the deploy>memory limit in Docker Compose for that container and the percentage reported is for the imposed memory limit rather than the machine physical memory limits.
+
+## Usage
+
+To use the tool, it has one command, `dockerstatus` with a shorter alias `ds`. If you are running a set of Docker containers (say via Docker Compose) on server `my-docker-host`, then just run:
+
+```bash
+dockerstatus my-docker-host
+```
+
+You can optionally pass the username if you're not logging in a `root`. Here is the full help text (thank you Typer):
+
+```bash
+ Usage: dockerstatus [OPTIONS] HOST [USERNAME]                          
+╭─ Arguments ───────────────────────────────────────────────────────────╮
+│ * host     TEXT       The server DNS name or IP address (e.g. 91.7.5.1│ 
+│                       or google.com). [default: None]  [required]     │
+│   username [USERNAME] The username of the ssh user for interacting    │
+│                       with the server. [default: root]                │
+╰───────────────────────────────────────────────────────────────────────╯
+╭─ Options ─────────────────────────────────────────────────────────────╮
+│ --help          Show this message and exit.                           │
+╰───────────────────────────────────────────────────────────────────────╯
+```
+
+## Installation
+
+This package is available on PyPI as dockerclustermon. However, it is ideally used as a CLI tool 
+and not imported into programs. As such, using **uv** or **pipx** will be most useful. Take your pick:
+
+### uv
+
+```bash
+uv tool install dockerclustermon
+```
+
+Of course this requires that you have 
+[uv installed](https://docs.astral.sh/uv/getting-started/installation/) 
+and in the path.
+
+### pipx
+
+```bash
+pipx install dockerclustermon
+```
+
+And this requires that you have [pipx installed](https://pipx.pypa.io/stable/installation/) 
+and in the path.
+
+
+Compatibility
+-------------
+
+Docker Cluster Monitor has been tested against Ubunutu Linux. It should work on any system that 
+supports SSH and has the Docker CLI tools installed. Note that it does **not** work on the local 
+machine at the moment. PRs are welcome. ;)

dockerclustermon-0.2.0/README.md

@@ -0,0 +1,62 @@
+# dockerclustermon - A TUI utility to monitor your docker containers
+
+A TUI tool for a live view of your docker containers running on a remote server. Here's a graphic of it running (refreshes every 5 seconds or so automatically):
+
+![](https://mkennedy-shared.nyc3.digitaloceanspaces.com/docker-status.gif)
+
+Notice that it uses color to communicate outlier values. For example, low CPU is green, middle-of-the-road CPU is cyan, and heavy CPU usage is red. Similarly for memory. The memory limit column reflects the deploy>memory limit in Docker Compose for that container and the percentage reported is for the imposed memory limit rather than the machine physical memory limits.
+
+## Usage
+
+To use the tool, it has one command, `dockerstatus` with a shorter alias `ds`. If you are running a set of Docker containers (say via Docker Compose) on server `my-docker-host`, then just run:
+
+```bash
+dockerstatus my-docker-host
+```
+
+You can optionally pass the username if you're not logging in a `root`. Here is the full help text (thank you Typer):
+
+```bash
+ Usage: dockerstatus [OPTIONS] HOST [USERNAME]                          
+╭─ Arguments ───────────────────────────────────────────────────────────╮
+│ * host     TEXT       The server DNS name or IP address (e.g. 91.7.5.1│ 
+│                       or google.com). [default: None]  [required]     │
+│   username [USERNAME] The username of the ssh user for interacting    │
+│                       with the server. [default: root]                │
+╰───────────────────────────────────────────────────────────────────────╯
+╭─ Options ─────────────────────────────────────────────────────────────╮
+│ --help          Show this message and exit.                           │
+╰───────────────────────────────────────────────────────────────────────╯
+```
+
+## Installation
+
+This package is available on PyPI as dockerclustermon. However, it is ideally used as a CLI tool 
+and not imported into programs. As such, using **uv** or **pipx** will be most useful. Take your pick:
+
+### uv
+
+```bash
+uv tool install dockerclustermon
+```
+
+Of course this requires that you have 
+[uv installed](https://docs.astral.sh/uv/getting-started/installation/) 
+and in the path.
+
+### pipx
+
+```bash
+pipx install dockerclustermon
+```
+
+And this requires that you have [pipx installed](https://pipx.pypa.io/stable/installation/) 
+and in the path.
+
+
+Compatibility
+-------------
+
+Docker Cluster Monitor has been tested against Ubunutu Linux. It should work on any system that 
+supports SSH and has the Docker CLI tools installed. Note that it does **not** work on the local 
+machine at the moment. PRs are welcome. ;)

dockerclustermon-0.2.0/dockerclustermon/__init__.py

@@ -0,0 +1,461 @@
+"""dockerclustermon - A CLI tool for a live view of your docker containers running on a remote server."""
+
+__version__ = "0.2.0"
+__author__ = "Michael Kennedy <michael@talkpython.fm>"
+__all__ = []
+
+import datetime
+import re
+import subprocess
+import time
+from subprocess import CalledProcessError
+from threading import Thread
+from typing import Annotated, Callable, Tuple
+
+# noinspection PyPackageRequirements
+import rich.console
+# noinspection PyPackageRequirements
+import rich.live
+# noinspection PyPackageRequirements
+import rich.table
+import typer
+# noinspection PyPackageRequirements
+from rich.text import Text
+
+results = {
+    "ps": [],
+    "stat": [],
+    "free": (0.0, 0.0, 0.0),
+    "error": None,
+}
+workers = []
+
+__host_type = Annotated[
+    str,
+    typer.Argument(
+        help="The server DNS name or IP address (e.g. 91.7.5.1 or google.com)."
+    ),
+]
+__user_type = Annotated[
+    str,
+    typer.Argument(
+        help="The username of the ssh user for interacting with the server."
+    ),
+]
+
+
+def live_status(host: __host_type, username: __user_type = "root"):
+    try:
+        print()
+        if host == 'version':
+            print(f'dockerclustermon monitoring utility version {__version__}.')
+            return
+
+        table = build_table(username, host)
+        if not table:
+            return
+
+        with rich.live.Live(table, auto_refresh=False) as live:
+            while True:
+                table = build_table(username, host)
+                live.update(table)
+                live.refresh()
+    except KeyboardInterrupt:
+        for w in workers:
+            w.join()
+        print("kthxbye!")
+
+
+def process_results():
+    ps_lines: list[dict[str, str]] = results["ps"]
+    stat_lines: list[dict[str, str]] = results["stat"]
+    total, used, avail = results["free"]
+    joined = join_results(ps_lines, stat_lines)
+    reduced = reduce_lines(joined)
+    total_cpu = total_percent(reduced, "CPU")
+    total_mem = total_sizes(reduced, "Mem")
+    return reduced, total, total_cpu, total_mem, used
+
+
+def run_update(username: str, host: str):
+    global workers
+
+    workers.clear()
+    workers.append(
+        Thread(target=lambda: run_stat_command(username, host), daemon=True)
+    )
+    workers.append(
+        Thread(target=lambda: run_ps_command(username, host), daemon=True)
+    )
+    workers.append(
+        Thread(target=lambda: run_free_command(username, host), daemon=True)
+    )
+
+    for w in workers:
+        w.start()
+    for w in workers:
+        w.join()
+
+    if results["error"]:
+        raise results["error"]
+
+
+def build_table(username: str, host: str):
+    # Keys: 'Name', 'Created', 'Status', 'CPU', 'Mem', 'Mem %', 'Limit'
+    formatted_date = datetime.datetime.now().strftime("%b %d, %Y @ %I:%M %p")
+    table = rich.table.Table(title=f"Docker cluster {host} status {formatted_date}")
+
+    table.add_column("Name", style="white", no_wrap=True)
+    # table.add_column("Created",  style="white", no_wrap=True)
+    table.add_column("Status", style="green", no_wrap=True)
+    table.add_column("CPU %", justify="right", style="white")
+    table.add_column("Mem %", justify="right", style="white")
+    table.add_column("Mem", justify="right", style="white")
+    table.add_column("Limit", justify="right", style="white")
+    # noinspection PyBroadException
+    try:
+        run_update(username, host)
+        reduced, total, total_cpu, total_mem, used = process_results()
+    except CalledProcessError as cpe:
+        print(f"Error: {cpe}")
+        return None
+    except Exception as x:
+        table.add_row("Error", str(x), "", "", "", "")
+        time.sleep(1)
+        return table
+
+    for container in reduced:
+        table.add_row(
+            Text(container["Name"], style="bold"),
+            color_text(
+                container["Status"],
+                lambda t: not any(w in t for w in {"unhealthy", "restart"}),
+            ),
+            color_number(container["CPU"], low=5, mid=25),
+            color_number(container["Mem %"], low=25, mid=65),
+            container["Mem"],
+            container["Limit"],
+        )
+
+    table.add_row()
+    table.add_row("Totals", "", f"{total_cpu:,.0f} %", "", f"{total_mem:,.2f} GB", "")
+    table.add_row()
+
+    total_server_mem_pct = used / total * 100
+    table.add_row(
+        "Server",
+        "",
+        "",
+        f"{total_server_mem_pct:,.0f} %",
+        f"{used:,.2f} GB",
+        f"{total:,.2f} GB",
+    )
+    return table
+
+
+def color_number(text: str, low: int, mid: int) -> Text:
+    num_text = (
+        text.replace("%", "").replace("GB", "").replace("MB", "").replace("KB", "")
+    )
+    num = float(num_text)
+
+    if num <= low:
+        return Text(text, style="green")
+
+    if num <= mid:
+        return Text(text, style="cyan")
+
+    return Text(text, style="red")
+
+
+def color_text(text: str, good: Callable) -> Text:
+    if good(text):
+        return Text(text)
+
+    return Text(text, style="bold red")
+
+
+def run_free_command(username: str, host: str) -> Tuple[float, float, float]:
+    try:
+        # print("Starting free")
+        # Run the program and capture its output
+        output = subprocess.check_output(["ssh", f"{username}@{host}", "free -m"])
+
+        # Convert the output to a string
+        output_string = bytes.decode(output, "utf-8")
+
+        # Convert the string to individual lines
+        lines = [
+            line.strip() for line in output_string.split("\n") if line and line.strip()
+        ]
+
+        # total        used        free      shared  buff/cache   available
+        # Mem:            7937        4257         242         160        3436        3211
+        mem_line = lines[1]
+        while "  " in mem_line:
+            mem_line = mem_line.replace("  ", " ")
+
+        parts = mem_line.split(" ")
+        used = int(parts[2]) / 1024
+        avail = int(parts[5]) / 1024
+        total = int(parts[1]) / 1024
+
+        t = total, used, avail
+        results["free"] = t
+
+        # print("Free done")
+
+        return t
+    except Exception as x:
+        results["error"] = x
+
+
+def total_sizes(rows: list[dict[str, str]], key: str) -> float:
+    # e.g. 1.5GB, 1.5MB, 1.5KB
+    total = 0
+    for row in rows:
+        value = row[key]
+        if "GB" in value:
+            value = float(value.replace("GB", ""))
+        elif "MB" in value:
+            value = float(value.replace("MB", ""))
+            value = value / 1024
+        elif "KB" in value:
+            value = float(value.replace("KB", ""))
+            value = value / 1024 / 1024
+        total += value
+
+    return total
+
+
+def total_percent(rows: list[dict[str, str]], key: str) -> float:
+    # e.g. 50.88%
+    total = 0
+    for row in rows:
+        value = float(row[key].replace("%", ""))
+        total += value
+
+    return total
+
+
+def reduce_lines(joined: list[dict[str, str]]) -> list[dict[str, str]]:
+    new_lines = []
+    # keep_keys = { 'NAME', 'CREATED', 'STATUS', 'CPU %', 'MEM USAGE / LIMIT', 'MEM %'}
+
+    for j in joined:
+        j = split_mem(j)
+        reduced = {
+            "Name": j["NAME"],
+            "Created": j["CREATED"],
+            "Status": j["STATUS"],
+            "CPU": str(int(float(j["CPU %"].replace("%", "")))) + " %",
+            "Mem": j["MEM USAGE"]
+            .replace("MB", " MB")
+            .replace("GB", " GB")
+            .replace("  ", " "),
+            "Mem %": str(int(float(j["MEM %"].replace("%", "")))) + " %",
+            "Limit": j["MEM LIMIT"]
+            .replace("MB", " MB")
+            .replace("GB", " GB")
+            .replace("  ", " "),
+        }
+        new_lines.append(reduced)
+
+    # Sort by uptime (youngest first), then by name.
+    new_lines.sort(
+        key=lambda d: (
+            get_seconds_key_from_string(d.get("Status", "")),
+            d.get("Name", "").lower().strip(),
+        )
+    )
+
+    return new_lines
+
+
+def split_mem(j: dict) -> dict:
+    key = "MEM USAGE / LIMIT"
+    # Example: 781.5MiB / 1.5GiB
+    value = j[key]
+    parts = [v.strip() for v in value.split("/")]
+
+    j["MEM USAGE"] = parts[0].replace("iB", "B")
+    j["MEM LIMIT"] = parts[1].replace("iB", "B")
+
+    return j
+
+
+def join_results(ps_lines, stat_lines) -> list[dict[str, str]]:
+    join_on = "NAME"
+
+    joined_lines = []
+    ps_dict: dict[str, str]
+    stat_lines: dict[str, str]
+
+    for ps_dict, stat_dict in zip(ps_lines, stat_lines):
+        if ps_dict[join_on] != stat_dict[join_on]:
+            raise Exception("Lines do not match")
+
+        joined = ps_dict.copy()
+        joined.update(**stat_dict)
+
+        joined_lines.append(joined)
+
+    return joined_lines
+
+
+def run_stat_command(username: str, host: str) -> list[dict[str, str]]:
+    # noinspection PyBroadException
+    try:
+        # print("Starring stat")
+        # Run the program and capture its output
+        output = subprocess.check_output(
+            ["ssh", f"{username}@{host}", "docker stats --no-stream"]
+        )
+
+        # Convert the output to a string
+        output_string = bytes.decode(output, "utf-8")
+
+        # Convert the string to individual lines
+        lines = [
+            line.strip() for line in output_string.split("\n") if line and line.strip()
+        ]
+
+        header = parse_stat_header(lines[0])
+        # print(header)
+
+        entries = []
+        for line in lines[1:]:
+            entries.append(parse_line(line, header))
+
+        results["stat"] = entries
+
+        # print("Done with stat")
+        return entries
+    except CalledProcessError as e:
+        results["error"] = e
+    except Exception as x:
+        results["error"] = x
+
+
+def parse_free_header(header_text: str) -> list[Tuple[str, int]]:
+    names = ["system", "used", "free", "shared", "buff/cache", "available"]
+    positions = []
+    for n in names:
+        idx = header_text.index(n)
+        item = (n, idx)
+        positions.append(item)
+
+    return positions
+
+
+def parse_stat_header(header_text: str) -> list[Tuple[str, int]]:
+    names = [
+        "CONTAINER ID",
+        "NAME",
+        "CPU %",
+        "MEM USAGE / LIMIT",
+        "MEM %",
+        "NET I/O",
+        "BLOCK I/O",
+        "PIDS",
+    ]
+    positions = []
+    for n in names:
+        idx = header_text.index(n)
+        item = (n, idx)
+        positions.append(item)
+
+    return positions
+
+
+def run_ps_command(username: str, host: str) -> list[dict[str, str]]:
+    try:
+        # print("Starting ps ...")
+        # Run the program and capture its output
+        output = subprocess.check_output(["ssh", f"{username}@{host}", "docker ps"])
+
+        # Convert the output to a string
+        output_string = bytes.decode(output, "utf-8")
+
+        # Convert the string to individual lines
+        lines = [
+            line.strip() for line in output_string.split("\n") if line and line.strip()
+        ]
+
+        header = parse_ps_header(lines[0])
+        # print(header)
+
+        entries = []
+        for line in lines[1:]:
+            entries.append(parse_line(line, header))
+
+        results["ps"] = entries
+        # print("Done with ps")
+        return entries
+    except Exception as x:
+        results["error"] = x
+
+
+def parse_line(line: str, header: list[Tuple[str, int]]) -> dict[str, str]:
+    local_results = {}
+    tmp_headers = header + [("END", 100000)]
+    total_len = 0
+    for (name, idx), (_, next_idx) in zip(tmp_headers[:-1], tmp_headers[1:]):
+        total_len += idx
+
+        # print("Going from {} to {}".format(idx, next_idx))
+        value = line[idx:next_idx].strip()
+        # print(name + ' -> ' + value)
+        if name == "NAMES":
+            name = "NAME"
+        local_results[name] = value
+
+    return local_results
+
+
+def parse_ps_header(header_text: str) -> list[Tuple[str, int]]:
+    names = ["CONTAINER ID", "IMAGE", "COMMAND", "CREATED", "STATUS", "PORTS", "NAMES"]
+    positions = []
+    for n in names:
+        idx = header_text.index(n)
+        item = (n, idx)
+        positions.append(item)
+
+    return positions
+
+
+def get_seconds_key_from_string(uptime_str: str) -> int:
+    if match := re.search(r"(\d+) second", uptime_str):
+        dt = int(match.group(1))
+        return dt
+
+    if re.search(r"About a minute", uptime_str):
+        return 60
+
+    if match := re.search(r"(\d+) minute", uptime_str):
+        dt = int(match.group(1))
+        return dt * 60
+
+    if re.search(r"About an hour", uptime_str):
+        return 60 * 60
+
+    if match := re.search(r"(\d+) hour", uptime_str):
+        dt = int(match.group(1))
+        return dt * 60 * 60
+
+    if re.search(r"About a day", uptime_str):
+        return 60 * 60 * 24
+
+    if match := re.search(r"(\d+) day", uptime_str):
+        dt = int(match.group(1))
+        return dt * 60 * 60 * 24
+
+    return 1_000_000
+
+
+def run_live_status():
+    typer.run(live_status)
+
+
+if __name__ == "__main__":
+    run_live_status()

dockerclustermon-0.2.0/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "dockerclustermon"
+version = "0.2.0"
+description = "A CLI tool for a live view of your docker containers running on a remote server."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "rich>=13.9.4",
+    "typer>=0.13.1",
+]
+license = { text = "MIT" }
+authors = [
+    { name = "Michael Kennedy", email = "michael@talkpython.fm" }
+]
+keywords = ["Docker", "Docker Compose", "Monitoring"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/mikeckennedy/dockerclustermon"
+
+
+
+[project.scripts]
+ds = "dockerclustermon:run_live_status"
+dockerstatus = "dockerclustermon:run_live_status"
+
+
+[build-system]
+requires = ["hatchling>=1.21.0", "hatch-vcs>=0.3.0"]
+build-backend = "hatchling.build"
+
+
+[tool.hatch.build.targets.sdist]
+packages = ["dockerclustermon"]
+exclude = [
+    "/.github",
+    "/dist",
+    "/tests",
+    "/example",
+    "/readme_resources",
+    "/venv",
+    "/.venv",
+    "tox.ini",
+    "uv.lock",
+    "ruff.toml",
+    "requirements-dev.txt",
+    "settings.json",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["dockerclustermon"]
+exclude = [
+    "/.github",
+    "/dist",
+    "/tests",
+    "/example",
+    "/venv",
+    "/readme_resources",
+    "/.venv",
+    "tox.ini",
+    "uv.lock",
+    "ruff.toml",
+    "requirements-dev.txt",
+    "settings.json",
+]