poetry-plugin-ivcap 0.1.0__tar.gz

poetry_plugin_ivcap-0.1.0/AUTHORS.md

@@ -0,0 +1,5 @@
+# Initial version authors
+
+* Max Ott <max.ott@csiro.au>
+
+# Partial list of contributors

poetry_plugin_ivcap-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Commonwealth Scientific and Industrial Research Organisation (CSIRO) ABN 41 687 119 230
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* 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.
+
+* 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.

poetry_plugin_ivcap-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.3
+Name: poetry-plugin-ivcap
+Version: 0.1.0
+Summary: A custom Poetry command for IVCAP deployments
+License: MIT
+Author: Max Ott
+Author-email: max.ott@csiro.au
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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-Dist: humanize (>=4.12.3,<5.0.0)
+Requires-Dist: pydantic (>=2.11.5,<3.0.0)
+Description-Content-Type: text/markdown
+
+# poetry-plugin-ivcap
+
+A custom Poetry plugin that adds a `poetry ivcap` command for local and Docker-based deployments.
+
+## Example Configuration
+
+Add to your `pyproject.toml`:
+
+```toml
+[tool.poetry-plugin-ivcap]
+default_target = "docker"
+docker_tag = "myapp:dev"
+```
+
+## Installation
+
+```bash
+poetry self add poetry-plugin-ivcap
+```
+
+## Usage
+
+```bash
+poetry ivcap
+poetry ivcap docker
+```
+
+## Development
+
+### Build the Plugin Package
+
+```bash
+poetry build
+```
+
+This creates .whl and .tar.gz files in the dist/ directory.
+
+### Publish to PyPI
+
+Create an account at https://pypi.org/account/register/
+
+Add your credentials:
+```bash
+poetry config pypi-token.pypi <your-token>
+```
+
+Publish:
+```bash
+poetry publish --build
+```
+
+### Optional: Test on TestPyPI First
+
+To verify your setup without publishing to the real PyPI:
+
+```bash
+poetry config repositories.test-pypi https://test.pypi.org/legacy/
+poetry publish -r test-pypi --build
+```
+
+Then test installing via:
+
+```bash
+poetry self add --source test-pypi poetry-plugin-deploy
+```
+

poetry_plugin_ivcap-0.1.0/README.md

@@ -0,0 +1,65 @@
+# poetry-plugin-ivcap
+
+A custom Poetry plugin that adds a `poetry ivcap` command for local and Docker-based deployments.
+
+## Example Configuration
+
+Add to your `pyproject.toml`:
+
+```toml
+[tool.poetry-plugin-ivcap]
+default_target = "docker"
+docker_tag = "myapp:dev"
+```
+
+## Installation
+
+```bash
+poetry self add poetry-plugin-ivcap
+```
+
+## Usage
+
+```bash
+poetry ivcap
+poetry ivcap docker
+```
+
+## Development
+
+### Build the Plugin Package
+
+```bash
+poetry build
+```
+
+This creates .whl and .tar.gz files in the dist/ directory.
+
+### Publish to PyPI
+
+Create an account at https://pypi.org/account/register/
+
+Add your credentials:
+```bash
+poetry config pypi-token.pypi <your-token>
+```
+
+Publish:
+```bash
+poetry publish --build
+```
+
+### Optional: Test on TestPyPI First
+
+To verify your setup without publishing to the real PyPI:
+
+```bash
+poetry config repositories.test-pypi https://test.pypi.org/legacy/
+poetry publish -r test-pypi --build
+```
+
+Then test installing via:
+
+```bash
+poetry self add --source test-pypi poetry-plugin-deploy
+```

poetry_plugin_ivcap-0.1.0/poetry_plugin_ivcap/docker.py

@@ -0,0 +1,185 @@
+#
+# Copyright (c) 2025 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import os
+import re
+import sys
+import tempfile
+from typing import Dict, Optional
+from pydantic import BaseModel, Field
+import subprocess
+
+from .util import command_exists, get_name
+
+DOCKER_BUILD_TEMPLATE = """
+docker buildx build
+    -t #DOCKER_NAME#
+    --platform linux/#ARCH#
+    --build-arg VERSION=#VERSION#
+    --build-arg BUILD_PLATFORM=linux/#ARCH#
+    -f #PROJECT_DIR#/#DOCKERFILE#
+    --load #PROJECT_DIR#
+"""
+
+DOCKER_RUN_TEMPLATE = """
+	docker run -it
+        -p #PORT#:#PORT#
+		--platform=linux/#ARCH#
+		--rm \
+		#NAME#_#ARCH#:#TAG# --port #PORT#
+"""
+
+class DockerConfig(BaseModel):
+    name: Optional[str] = Field(None)
+    tag: Optional[str] = Field(None)
+    arch: Optional[str] = Field(None)
+    version: Optional[str] = Field(None)
+    dockerfile: Optional[str] = Field("Dockerfile")
+    project_dir: Optional[str] = Field(".")
+
+    @property
+    def docker_name(self) -> str:
+        return f"{self.name}_{self.arch}:{self.tag}"
+
+    def from_build_template(self, data: dict) -> str:
+        pdata = data.get("tool", {}).get("poetry-plugin-ivcap", {})
+        template = pdata.get("docker-build-template", DOCKER_BUILD_TEMPLATE).strip()
+        t = template.strip()\
+            .replace("#DOCKER_NAME#", self.docker_name)\
+            .replace("#NAME#", self.name)\
+            .replace("#TAG#", self.tag)\
+            .replace("#ARCH#", self.arch)\
+            .replace("#VERSION#", self.version)\
+            .replace("#DOCKERFILE#", self.dockerfile)\
+            .replace("#PROJECT_DIR#", self.project_dir)\
+            .split()
+        return t
+
+    def from_run_template(self, data) -> str:
+        pdata = data.get("tool", {}).get("poetry-plugin-ivcap", {})
+        template = pdata.get("docker-run-template", DOCKER_RUN_TEMPLATE).strip()
+        opts = pdata.get("docker-run-opts", {"port": 8080})
+        t = template.strip()\
+            .replace("#NAME#", self.name)\
+            .replace("#TAG#", self.tag)\
+            .replace("#ARCH#", self.arch)\
+            .replace("#VERSION#", self.version)\
+            .replace("#PROJECT_DIR#", self.project_dir)
+
+        for key, value in opts.items():
+            t = t.replace(f"#{key.upper()}#", str(value))
+
+        return t.split()
+
+
+def docker_build(data: dict, line, arch = None) -> None:
+    check_docker_cmd(line)
+    config = _docker_cfg(data, line, arch)
+    build_cmd = config.from_build_template(data)
+    line(f"<info>INFO: {' '.join(build_cmd)}</info>")
+    process = subprocess.Popen(build_cmd, stdout=sys.stdout, stderr=sys.stderr)
+    exit_code = process.wait()
+    if exit_code != 0:
+        line(f"<error>ERROR: Docker build failed with exit code {exit_code}</error>")
+    else:
+        line("<info>INFO: Docker build completed successfully</info>")
+    return config.docker_name
+
+def docker_run(data: dict, line) -> None:
+    check_docker_cmd(line)
+    config = _docker_cfg(data, line)
+    build_run = config.from_run_template(data)
+    line(f"<info>INFO: {' '.join(build_run)}</info>")
+    process = subprocess.Popen(build_run, stdout=sys.stdout, stderr=sys.stderr)
+    exit_code = process.wait()
+    if exit_code != 0:
+        line(f"<error>ERROR: Docker run failed with exit code {exit_code}</error>")
+    else:
+        line("<info>INFO: Docker run completed successfully</info>")
+
+def _docker_cfg(data: dict, line, arch = None) -> DockerConfig:
+    project_data = data.get("project", {})
+    name = get_name(data)
+    version = project_data.get("version", None)
+
+    pdata = data.get("tool", {}).get("poetry-plugin-ivcap", {})
+    config = DockerConfig(name=name, version=version, **pdata.get("docker", {}))
+    if arch:
+        # override architecture if provided
+        config.arch = arch
+
+    if not config.version:
+        try:
+            config.version = subprocess.check_output(['git', 'describe', '--tags', '--abbrev=0']).decode().strip()
+        except Exception as e:
+            line(f"<error>Error retrieving latest tag: {e}</error>")
+            config.version = "???"
+
+    if not config.tag:
+        try:
+            config.tag = subprocess.check_output(['git', 'rev-parse', "--short", 'HEAD']).decode().strip()
+        except Exception as e:
+            line(f"<warning>WARN: retrieving commit hash: {e}</warning>")
+            config.tag = "latest"
+
+    if not config.arch:
+        try:
+            config.arch = subprocess.check_output(['uname', '-m']).decode().strip()
+        except Exception as e:
+            line(f"<error>ERROR: cannot obtain build architecture: {e}</error>")
+            os.exit(1)
+
+    return config
+
+def docker_push(docker_img, line):
+    push_cmd = ["ivcap", "package", "push", "--force", "--local", docker_img]
+    line(f"<debug>Running: {' '.join(push_cmd)} </debug>")
+    p1 = subprocess.Popen(push_cmd, stdout=subprocess.PIPE, stderr=sys.stderr)
+
+    with tempfile.NamedTemporaryFile(mode='w+', delete=False) as tmp:
+        tmp_path = tmp.name
+
+    try:
+        # Pipe its output to tee (or to the screen via /dev/tty)
+        p2 = subprocess.Popen(
+            ["tee", tmp_path],
+            stdin=p1.stdout,
+            stdout=sys.stdout,
+            stderr=sys.stderr
+        )
+        p1.stdout.close()
+        # Wait for both to finish
+        p2.communicate()
+        exit_code = p1.wait()
+        if exit_code != 0:
+            line(f"<error>ERROR: package push failed with exit code {exit_code}</error>")
+            sys.exit(1)
+
+        # Lookginf for "45a06508-5c3a-4678-8e6d-e6399bf27538/gene_onology_term_mapper_amd64:9a9a7cc pushed\n"
+        pattern = re.compile(
+            r'([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/[^\s]+) pushed'
+        )
+        package_name = None
+        with open(tmp_path, 'r') as f:
+            for l in f:
+                match = pattern.search(l)
+                if match:
+                    package_name = match.group(1)
+                    break
+
+        if not package_name:
+            line("<error>ERROR: No package name found in output</error>")
+            sys.exit(1)
+
+        line("<info>INFO: package push completed successfully</info>")
+        return package_name
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+def check_docker_cmd(line):
+    if not command_exists("docker"):
+        line("<error>'docker' command not found. Please install it first.</error>")
+        sys.exit(1)

poetry_plugin_ivcap-0.1.0/poetry_plugin_ivcap/ivcap.py

@@ -0,0 +1,147 @@
+#
+# Copyright (c) 2025 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import uuid
+import humanize
+
+from .docker import _docker_cfg, docker_build, docker_push
+from .util import command_exists, execute_subprocess_and_capture_output, get_name, string_to_number
+
+def docker_publish(data, line):
+    check_ivcap_cmd(line)
+    #dname = docker_build(data, line, arch="amd64")
+    dname = "gene_onology_term_mapper_amd64:9a9a7cc"
+    print(dname)
+
+    size_cmd = ["docker", "inspect", "--format='{{.Size}}'", dname]
+    line(f"<debug>Running: {' '.join(size_cmd)} </debug>")
+    size = string_to_number(subprocess.check_output(size_cmd).decode())
+    if size is None:
+        line("<error>Failed to retrieve image size</error>")
+        return
+    line(f"<info>INFO: Image size {humanize.naturalsize(size)}</info>")
+    pkg_name = docker_push(dname, line)
+
+def service_register(data, line):
+    check_ivcap_cmd(line)
+    config = data.get("tool", {}).get("poetry-plugin-ivcap", {})
+
+    service = config.get("service-file")
+    if not service:
+        line("<error>Missing 'service-file' in [tool.poetry-plugin-ivcap]</error>")
+        return
+
+    dcfg = _docker_cfg(data, line, "amd64")
+    pkg_cmd = ["ivcap", "package", "list", dcfg.docker_name]
+    line(f"<debug>Running: {' '.join(pkg_cmd)} </debug>")
+    pkg = subprocess.check_output(pkg_cmd).decode()
+    if not pkg or pkg == "":
+        line(f"<error>No package '{dcfg.docker_name}' found. Please build and publish it first.</error>")
+        return
+    service_id = get_service_id(data, line)
+
+    cmd = ["poetry", "run", "python", service, "--print-service-description"]
+    line(f"<debug>Running: {' '.join(cmd)} </debug>")
+    svc = subprocess.check_output(cmd).decode()
+
+    svc = svc.replace("#DOCKER_IMG#", pkg.strip())\
+            .replace("#SERVICE_ID#", service_id)
+
+    with tempfile.NamedTemporaryFile(mode='w+', delete=False) as tmp:
+        tmp.write(svc)
+        tmp_path = tmp.name  # Save the file name for subprocess
+
+    try:
+        policy = get_policy(data, line)
+        up_cmd = ["ivcap", "aspect", "update", "--policy", policy, service_id, "-f", tmp_path]
+        try:
+            line(f"<debug>Running: {' '.join(up_cmd)} </debug>")
+            jaid = subprocess.check_output(up_cmd).decode().strip()
+            p = re.compile(r'.*(urn:[^"]*)')
+            aid = p.search(jaid).group(1)
+            line(f"<info>INFO: service definition successfully uploaded - {aid}</info>")
+        except Exception as e:
+            line(f"<error>ERROR: cannot upload service definitiion: {e}</error>")
+            sys.exit(1)
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+def tool_register(data, line):
+    check_ivcap_cmd(line)
+    config = data.get("tool", {}).get("poetry-plugin-ivcap", {})
+
+    service = config.get("service-file")
+    if not service:
+        line("<error>Missing 'service-file' in [tool.poetry-plugin-ivcap]</error>")
+        return
+
+    cmd = ["poetry", "run", "python", service, "--print-tool-description"]
+    line(f"<debug>Running: {' '.join(cmd)} </debug>")
+    svc = subprocess.check_output(cmd).decode()
+
+    service_id = get_service_id(data, line)
+    svc = svc.replace("#SERVICE_ID#", service_id)
+
+    with tempfile.NamedTemporaryFile(mode='w+', delete=False) as tmp:
+        tmp.write(svc)
+        tmp_path = tmp.name  # Save the file name for subprocess
+
+    try:
+        policy = get_policy(data, line)
+        up_cmd = ["ivcap", "aspect", "update", "--policy", policy, service_id, "-f", tmp_path]
+        try:
+            line(f"<debug>Running: {' '.join(up_cmd)} </debug>")
+            jaid = subprocess.check_output(up_cmd).decode().strip()
+            p = re.compile(r'.*(urn:[^"]*)')
+            aid = p.search(jaid).group(1)
+            line(f"<info>INFO: tool description successfully uploaded - {aid}</info>")
+        except Exception as e:
+            line(f"<error>ERROR: cannot upload tool description: {e}</error>")
+            sys.exit(1)
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+def get_service_id(data, line):
+    service_id = data.get("tool", {}).get("poetry-plugin-ivcap", {}).get("service-id")
+    if not service_id:
+        service_id = create_service_id(data, line)
+    return service_id
+
+def create_service_id(data, line):
+    check_ivcap_cmd(line)
+    name = get_name(data)
+    account_id = get_account_id(data, line)
+    id = uuid.uuid5(uuid.NAMESPACE_DNS, f"{name}{account_id}")
+    return f"urn:ivcap:service:{id}"
+
+def get_policy(data, line):
+    policy = data.get("tool", {}).get("poetry-plugin-ivcap", {}).get("policy")
+    if not policy:
+        policy = "urn:ivcap:policy:ivcap.open.metadata"
+    return policy
+
+def get_account_id(data, line):
+    check_ivcap_cmd(line)
+    cmd = ["ivcap", "context", "get", "account-id"]
+    line(f"<debug>Running: {' '.join(cmd)} </debug>")
+    try:
+        account_id = subprocess.check_output(cmd).decode().strip()
+        return account_id
+    except subprocess.CalledProcessError as e:
+        line(f"<error>Error retrieving account ID: {e}</error>")
+        sys.exit(1)
+
+def check_ivcap_cmd(line):
+    if not command_exists("ivcap"):
+        line("<error>'ivcap' command not found. Please install the IVCAP CLI tool.</error>")
+        line("<error>... see https://github.com/ivcap-works/ivcap-cli?tab=readme-ov-file#install-released-binaries for instructions</error>")
+        os.exit(1)

poetry_plugin_ivcap-0.1.0/poetry_plugin_ivcap/plugin.py

@@ -0,0 +1,70 @@
+#
+# Copyright (c) 2025 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+from poetry.plugins.application_plugin import ApplicationPlugin
+from cleo.commands.command import Command
+from cleo.helpers import argument
+import subprocess
+
+from .ivcap import create_service_id, service_register, tool_register
+from .docker import docker_build, docker_run
+from .ivcap import docker_publish
+
+class IvcapCommand(Command):
+    name = "ivcap"
+    description = "IVCAP plugin `poetry ivcap <subcommand>`"
+    help = """\
+IVCAP plugin
+
+Available subcommands:
+  run       Run the configured service
+  deploy    Deploy using configured settings
+
+Example:
+  poetry ivcap run
+"""
+    arguments = [
+        argument("subcommand", optional=True, description="Subcommand: run, deploy, etc.")
+    ]
+
+    def handle(self):
+        poetry = self.application.poetry
+        data = poetry.pyproject.data
+
+        sub = self.argument("subcommand")
+        if sub == "run":
+            self.run_service(data)
+        elif sub == "docker-build":
+            docker_build(data, self.line)
+        elif sub == "docker-run":
+            docker_run(data, self.line)
+        elif sub == "docker-publish":
+            docker_publish(data, self.line)
+        elif sub == "service-register":
+            service_register(data, self.line)
+        elif sub == "create-service-id":
+            sid = create_service_id(data, self.line)
+            print(sid)
+        elif sub == "tool-register":
+            tool_register(data, self.line)
+        else:
+            self.line(f"<error>Unknown subcommand: {sub}</error>")
+
+    def run_service(self, data):
+        config = data.get("tool", {}).get("poetry-plugin-ivcap", {})
+
+        service = config.get("service-file")
+        port = config.get("port")
+
+        if not service or not port:
+            self.line("<error>Missing 'service-file' or 'port' in [tool.poetry-plugin-ivcap]</error>")
+            return
+
+        self.line(f"<info>Running: python {service} --port {port}</info>")
+        subprocess.run(["poetry", "run", "python", service, "--port", str(port)])
+
+class IvcapPlugin(ApplicationPlugin):
+    def activate(self, application):
+        application.command_loader.register_factory("ivcap", lambda: IvcapCommand())

poetry_plugin_ivcap-0.1.0/poetry_plugin_ivcap/util.py

@@ -0,0 +1,87 @@
+#
+# Copyright (c) 2025 Commonwealth Scientific and Industrial Research Organisation (CSIRO). All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file. See the AUTHORS file for names of contributors.
+#
+import subprocess
+import platform
+
+def get_name(data) -> str:
+    project_data = data.get("project", {})
+    name = project_data.get("name").replace("-", "_").replace(".", "_")
+    return name
+
+
+def command_exists(cmd: str) -> bool:
+    system = platform.system()
+
+    check_cmd = {
+        "Windows": ["where", cmd],
+        "Linux": ["which", cmd],
+        "Darwin": ["which", cmd],
+    }.get(system)
+
+    if not check_cmd:
+        raise RuntimeError(f"Unsupported OS: {system}")
+
+    try:
+        subprocess.run(check_cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+def string_to_number(s):
+  """Converts a string to a number (int)."""
+  s = s.replace("'", "")  # Remove all single quotes
+  try:
+    return int(s.strip())
+  except ValueError as e:
+    print(e)
+    return None  # Or raise an exception, depending on your needs
+
+import io
+import sys
+
+def execute_subprocess_and_capture_output(command):
+    """
+    Executes a subprocess, prints all outputs to the console in real-time, and returns a full copy of the output.
+
+    Args:
+        command (list): A list of strings representing the command to execute.
+
+    Returns:
+        str: A string containing the full output of the subprocess.
+    """
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+    full_output = ""
+
+    # Read stdout and stderr in real-time
+    while True:
+        stdout_line = process.stdout.readline()
+        stderr_line = process.stderr.readline()
+
+        if stdout_line:
+            print("Stdout:", stdout_line, end="")  # Print to console immediately
+            sys.stdout.flush()
+            full_output += stdout_line
+        if stderr_line:
+            print("Stderr:", stderr_line, end="")  # Print to console immediately
+            sys.stderr.flush()
+            full_output += stderr_line
+
+        # Check if the process has finished
+        if process.poll() is not None:
+            break
+
+    # Read any remaining output
+    for line in process.stdout:
+        print("Stdout:", line, end="")
+        sys.stdout.flush()
+        full_output += line
+    for line in process.stderr:
+        print("Stderr:", line, end="")
+        sys.stderr.flush()
+        full_output += line
+
+    return full_output

poetry_plugin_ivcap-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[tool.poetry]
+name = "poetry-plugin-ivcap"
+version = "0.1.0"
+description = "A custom Poetry command for IVCAP deployments"
+authors = ["Max Ott <max.ott@csiro.au>"]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "poetry_plugin_ivcap" }]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+pydantic = "^2.11.5"
+humanize = "^4.12.3"
+
+[tool.poetry.plugins."poetry.application.plugin"]
+ivcap = "poetry_plugin_ivcap.plugin:IvcapPlugin"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"