poetry-plugin-ivcap 0.1.0__tar.gz → 0.2.2__tar.gz

{poetry_plugin_ivcap-0.1.0 → poetry_plugin_ivcap-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: poetry-plugin-ivcap
-Version: 0.1.0
+Version: 0.2.2
 Summary: A custom Poetry command for IVCAP deployments
 License: MIT
 Author: Max Ott
@@ -27,9 +27,11 @@ Add to your `pyproject.toml`:
 
 ```toml
 [tool.poetry-plugin-ivcap]
-default_target = "docker"
-docker_tag = "myapp:dev"
-```
+service-file = "service.py"
+service-id = "urn:ivcap:service:ac158a1f-dfb4-5dac-bf2e-9bf15e0f2cc7"
+port = 8077
+# docker
+# docker-run-opts = { port = 8079 }```
 
 ## Installation
 
@@ -40,8 +42,44 @@ poetry self add poetry-plugin-ivcap
 ## Usage
 
 ```bash
-poetry ivcap
-poetry ivcap docker
+poetry ivcap run
+poetry ivcap docker-build
+poetry ivcap docker-run
+poetry ivcap docker-publish
+poetry ivcap service-register
+poetry ivcap create-service-id
+poetry ivcap tool-register
+```
+
+To get help on the currently installed version
+```
+% poetry ivcap
+
+IVCAP plugin
+
+Supporting the development of services and tools for the IVCAP platform
+
+Available subcommands:
+    run                 Run the service locally
+    docker-build        Build the docker image for this service
+    docker-run          Run the service's docker image locally
+    docker-publish      Publish the service's docker image to IVCAP
+    service-register    Register the service with IVCAP
+    create-service-id   Create a unique service ID for the service
+    tool-register       Register the service as an AI Tool with IVCAP
+
+Example:
+  poetry ivcap run
+
+Configurable optiosn in pyproject.toml:
+
+  [tool.poetry-plugin-ivcap]
+  service-file = "service.py"  # The Python file that implements the service
+  service-file = "service.py"
+  service-id = "urn:ivcap:service:ac158a1f-dfb4-5dac-bf2e-9bf15e0f2cc7" # A unique identifier for the service
+
+  docker-build-template = "docker buildx build -t #DOCKER_NAME#  ."
+  docker-run-template = "docker run -rm -p #PORT#:#PORT#"
 ```
 
 ## Development

poetry_plugin_ivcap-0.2.2/README.md

@@ -0,0 +1,103 @@
+# 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]
+service-file = "service.py"
+service-id = "urn:ivcap:service:ac158a1f-dfb4-5dac-bf2e-9bf15e0f2cc7"
+port = 8077
+# docker
+# docker-run-opts = { port = 8079 }```
+
+## Installation
+
+```bash
+poetry self add poetry-plugin-ivcap
+```
+
+## Usage
+
+```bash
+poetry ivcap run
+poetry ivcap docker-build
+poetry ivcap docker-run
+poetry ivcap docker-publish
+poetry ivcap service-register
+poetry ivcap create-service-id
+poetry ivcap tool-register
+```
+
+To get help on the currently installed version
+```
+% poetry ivcap
+
+IVCAP plugin
+
+Supporting the development of services and tools for the IVCAP platform
+
+Available subcommands:
+    run                 Run the service locally
+    docker-build        Build the docker image for this service
+    docker-run          Run the service's docker image locally
+    docker-publish      Publish the service's docker image to IVCAP
+    service-register    Register the service with IVCAP
+    create-service-id   Create a unique service ID for the service
+    tool-register       Register the service as an AI Tool with IVCAP
+
+Example:
+  poetry ivcap run
+
+Configurable optiosn in pyproject.toml:
+
+  [tool.poetry-plugin-ivcap]
+  service-file = "service.py"  # The Python file that implements the service
+  service-file = "service.py"
+  service-id = "urn:ivcap:service:ac158a1f-dfb4-5dac-bf2e-9bf15e0f2cc7" # A unique identifier for the service
+
+  docker-build-template = "docker buildx build -t #DOCKER_NAME#  ."
+  docker-run-template = "docker run -rm -p #PORT#:#PORT#"
+```
+
+## 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-0.2.2}/poetry_plugin_ivcap/docker.py

@@ -3,15 +3,16 @@
 # 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 datetime import datetime, timezone
 import os
 import re
 import sys
 import tempfile
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 from pydantic import BaseModel, Field
 import subprocess
 
-from .util import command_exists, get_name
+from .util import command_exists, get_name, get_version
 
 DOCKER_BUILD_TEMPLATE = """
 docker buildx build
@@ -23,12 +24,20 @@ docker buildx build
     --load #PROJECT_DIR#
 """
 
-DOCKER_RUN_TEMPLATE = """
+DOCKER_LAMBDA_RUN_TEMPLATE = """
 	docker run -it
         -p #PORT#:#PORT#
 		--platform=linux/#ARCH#
 		--rm \
-		#NAME#_#ARCH#:#TAG# --port #PORT#
+		#NAME#_#ARCH#:#TAG#
+"""
+
+DOCKER_BATCH_RUN_TEMPLATE = """
+	docker run -it
+		--platform=linux/#ARCH#
+        -v #PROJECT_DIR#:/data
+		--rm \
+		#NAME#_#ARCH#:#TAG#
 """
 
 class DockerConfig(BaseModel):
@@ -37,7 +46,7 @@ class DockerConfig(BaseModel):
     arch: Optional[str] = Field(None)
     version: Optional[str] = Field(None)
     dockerfile: Optional[str] = Field("Dockerfile")
-    project_dir: Optional[str] = Field(".")
+    project_dir: Optional[str] = Field(os.getcwd())
 
     @property
     def docker_name(self) -> str:
@@ -57,26 +66,61 @@ class DockerConfig(BaseModel):
             .split()
         return t
 
-    def from_run_template(self, data) -> str:
+    def from_run_template(self, data, args, line) -> List[any]:
         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})
+        template = pdata.get("docker-run-template")
+        if template is None:
+            smode = pdata.get("service-type")
+            if smode is None:
+                line("<error>ERROR: 'service-type' is not defined in [poetry-plugin-ivcap]</error>")
+                sys.exit(1)
+            if smode == "lambda":
+                template = DOCKER_LAMBDA_RUN_TEMPLATE
+            elif smode == "batch":
+                template = DOCKER_BATCH_RUN_TEMPLATE
+            else:
+                line(f"<error>ERROR: Unknown service type '{smode}' in [poetry-plugin-ivcap]</error>")
+                sys.exit(1)
+
+        opts = pdata.get("docker-run-opts", [])
+        port = get_port_value(args)
+        port_in_args = True
+        if not port:
+            port = get_port_value(opts)
+        if not port:
+            port_in_args = False
+            port = str(pdata.get("port", 8000))
+
+        # elif opts.get('port') is not None:
+        #     opts['port'] = opts.get('port')
+        # elif '--port' in template:
+        #     # If the template has a port but no port is provided, use a default
+        #     opts['port'] = '8000'
+
         t = template.strip()\
             .replace("#NAME#", self.name)\
             .replace("#TAG#", self.tag)\
+            .replace("#PORT#", port)\
             .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))
+        # for key, value in opts.items():
+        #     if key != "port":
+        #         t = t.replace(f"#{key.upper()}#", str(value))
 
-        return t.split()
+
+        cmd = t.split()
+        cmd.extend(opts)
+        cmd.extend(args)
+        if smode == "lambda" and not port_in_args:
+            cmd.extend(["--port", port])
+        return cmd
 
 
 def docker_build(data: dict, line, arch = None) -> None:
     check_docker_cmd(line)
-    config = _docker_cfg(data, line, arch)
+    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)
@@ -87,10 +131,10 @@ def docker_build(data: dict, line, arch = None) -> None:
         line("<info>INFO: Docker build completed successfully</info>")
     return config.docker_name
 
-def docker_run(data: dict, line) -> None:
+def docker_run(data: dict, args, line) -> None:
     check_docker_cmd(line)
-    config = _docker_cfg(data, line)
-    build_run = config.from_run_template(data)
+    config = docker_cfg(data, line)
+    build_run = config.from_run_template(data, args, line)
     line(f"<info>INFO: {' '.join(build_run)}</info>")
     process = subprocess.Popen(build_run, stdout=sys.stdout, stderr=sys.stderr)
     exit_code = process.wait()
@@ -99,24 +143,15 @@ def docker_run(data: dict, line) -> None:
     else:
         line("<info>INFO: Docker run completed successfully</info>")
 
-def _docker_cfg(data: dict, line, arch = None) -> DockerConfig:
-    project_data = data.get("project", {})
+def docker_cfg(data: dict, line, arch = None) -> DockerConfig:
     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", {}))
+    config = DockerConfig(name=name, **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()
@@ -124,6 +159,9 @@ def _docker_cfg(data: dict, line, arch = None) -> DockerConfig:
             line(f"<warning>WARN: retrieving commit hash: {e}</warning>")
             config.tag = "latest"
 
+    if not config.version:
+        config.version = get_version(data, config.tag, line)
+
     if not config.arch:
         try:
             config.arch = subprocess.check_output(['uname', '-m']).decode().strip()
@@ -183,3 +221,12 @@ def check_docker_cmd(line):
     if not command_exists("docker"):
         line("<error>'docker' command not found. Please install it first.</error>")
         sys.exit(1)
+
+def get_port_value(arr):
+    try:
+        index = arr.index('--port')
+        return arr[index + 1]
+    except ValueError:
+        return None
+    except IndexError:
+        return None

{poetry_plugin_ivcap-0.1.0 → poetry_plugin_ivcap-0.2.2}/poetry_plugin_ivcap/ivcap.py

@@ -11,14 +11,12 @@ import tempfile
 import uuid
 import humanize
 
-from .docker import _docker_cfg, docker_build, docker_push
+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)
+    dname = docker_build(data, line, arch="amd64")
 
     size_cmd = ["docker", "inspect", "--format='{{.Size}}'", dname]
     line(f"<debug>Running: {' '.join(size_cmd)} </debug>")
@@ -38,7 +36,7 @@ def service_register(data, line):
         line("<error>Missing 'service-file' in [tool.poetry-plugin-ivcap]</error>")
         return
 
-    dcfg = _docker_cfg(data, line, "amd64")
+    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()

poetry_plugin_ivcap-0.2.2/poetry_plugin_ivcap/plugin.py

@@ -0,0 +1,107 @@
+#
+# 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
+from poetry.plugins.application_plugin import ApplicationPlugin
+from cleo.commands.command import Command
+from cleo.helpers import argument
+import subprocess
+
+from poetry_plugin_ivcap.util import get_version
+
+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
+
+Supporting the development of services and tools for the IVCAP platform
+
+Available subcommands:
+    run                 Run the service locally
+    docker-build        Build the docker image for this service
+    docker-run          Run the service's docker image locally
+    docker-publish      Publish the service's docker image to IVCAP
+    service-register    Register the service with IVCAP
+    create-service-id   Create a unique service ID for the service
+    tool-register       Register the service as an AI Tool with IVCAP
+
+Example:
+  poetry ivcap run -- --port 8080
+
+Configurable options in pyproject.toml:
+
+  [tool.poetry-plugin-ivcap]
+  service-file = "service.py"  # The Python file that implements the service
+  service-file = "service.py"
+  service-id = "urn:ivcap:service:ac158a1f-dfb4-5dac-bf2e-9bf15e0f2cc7" # A unique identifier for the service
+
+  docker-build-template = "docker buildx build -t #DOCKER_NAME#  ."
+  docker-run-template = "docker run -rm -p #PORT#:#PORT#"
+"""
+    arguments = [
+        argument("subcommand", optional=True, description="Subcommand: run, deploy, etc."),
+        argument("args", optional=True, multiple=True, description="Additional arguments for subcommand"),
+    ]
+
+    allow_extra_args = True
+    ignore_validation_errors = True
+
+    def handle(self):
+        poetry = self.application.poetry
+        data = poetry.pyproject.data
+
+        sub = self.argument("subcommand")
+        args = self.argument("args")
+
+        if sub == "run":
+            self.run_service(data, args, self.line)
+        elif sub == "docker-build":
+            docker_build(data, self.line)
+        elif sub == "docker-run":
+            docker_run(data, args, 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:
+            if not (sub == None or sub == "help"):
+                self.line(f"<error>Unknown subcommand: {sub}</error>")
+            print(self.help)
+
+    def run_service(self, data, args, line):
+        config = data.get("tool", {}).get("poetry-plugin-ivcap", {})
+
+        service = config.get("service-file")
+        if not service:
+            self.line("<error>Missing 'service-file' in [tool.poetry-plugin-ivcap]</error>")
+            return
+
+        if not '--port' in args:
+            port = config.get("port")
+            if port:
+                args.extend(["--port", str(port)])
+
+        env = os.environ.copy()
+        env["VERSION"] = get_version(data, None, line)
+
+        cmd = ["poetry", "run", "python", service]
+        cmd.extend(args)
+        self.line(f"<info>Running: {' '.join(cmd)}</info>")
+        subprocess.run(cmd, env=env)
+
+class IvcapPlugin(ApplicationPlugin):
+    def activate(self, application):
+        application.command_loader.register_factory("ivcap", lambda: IvcapCommand())

{poetry_plugin_ivcap-0.1.0 → poetry_plugin_ivcap-0.2.2}/poetry_plugin_ivcap/util.py

@@ -5,6 +5,7 @@
 #
 import subprocess
 import platform
+from datetime import datetime, timezone
 
 def get_name(data) -> str:
     project_data = data.get("project", {})
@@ -85,3 +86,23 @@ def execute_subprocess_and_capture_output(command):
         full_output += line
 
     return full_output
+
+def get_version(data, tag, line):
+    if not tag:
+        try:
+            tag = subprocess.check_output(['git', 'rev-parse', "--short", 'HEAD']).decode().strip()
+        except Exception as e:
+            line(f"<warning>WARN: retrieving commit hash: {e}</warning>")
+            tag = "latest"
+
+    project_data = data.get("project", {})
+    v = project_data.get("version", None)
+    if not v:
+        try:
+            v = subprocess.check_output(['git', 'describe', '--tags', '--abbrev=0']).decode().strip()
+        except Exception as e:
+            line(f"<error>Error retrieving latest tag: {e}</error>")
+            v = "???"
+    now = datetime.now(timezone.utc).astimezone()
+    version = f"{v}|{tag}|{now.replace(microsecond=0).isoformat()}"
+    return version

{poetry_plugin_ivcap-0.1.0 → poetry_plugin_ivcap-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "poetry-plugin-ivcap"
-version = "0.1.0"
+version = "0.2.2"
 description = "A custom Poetry command for IVCAP deployments"
 authors = ["Max Ott <max.ott@csiro.au>"]
 license = "MIT"

poetry_plugin_ivcap-0.1.0/README.md

@@ -1,65 +0,0 @@
-# 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/plugin.py

@@ -1,70 +0,0 @@
-#
-# 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())