poetry-plugin-ivcap 0.2.0__tar.gz → 0.2.3__tar.gz

{poetry_plugin_ivcap-0.2.0 → poetry_plugin_ivcap-0.2.3}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: poetry-plugin-ivcap
-Version: 0.2.0
+Version: 0.2.3
 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
+Requires-Python: >=3.9
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
@@ -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
 

{poetry_plugin_ivcap-0.2.0 → poetry_plugin_ivcap-0.2.3}/README.md

@@ -8,9 +8,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
 

{poetry_plugin_ivcap-0.2.0 → poetry_plugin_ivcap-0.2.3}/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.2.0 → poetry_plugin_ivcap-0.2.3}/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.0 → poetry_plugin_ivcap-0.2.3}/poetry_plugin_ivcap/plugin.py

@@ -3,11 +3,14 @@
 # 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
@@ -31,9 +34,9 @@ Available subcommands:
     tool-register       Register the service as an AI Tool with IVCAP
 
 Example:
-  poetry ivcap run
+  poetry ivcap run -- --port 8080
 
-Configurable optiosn in pyproject.toml:
+Configurable options in pyproject.toml:
 
   [tool.poetry-plugin-ivcap]
   service-file = "service.py"  # The Python file that implements the service
@@ -44,20 +47,26 @@ Configurable optiosn in pyproject.toml:
   docker-run-template = "docker run -rm -p #PORT#:#PORT#"
 """
     arguments = [
-        argument("subcommand", optional=True, description="Subcommand: run, deploy, etc.")
+        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)
+            self.run_service(data, args, self.line)
         elif sub == "docker-build":
             docker_build(data, self.line)
         elif sub == "docker-run":
-            docker_run(data, self.line)
+            docker_run(data, args, self.line)
         elif sub == "docker-publish":
             docker_publish(data, self.line)
         elif sub == "service-register":
@@ -72,18 +81,26 @@ Configurable optiosn in pyproject.toml:
                 self.line(f"<error>Unknown subcommand: {sub}</error>")
             print(self.help)
 
-    def run_service(self, data):
+    def run_service(self, data, args, line):
         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>")
+        if not service:
+            self.line("<error>Missing 'service-file' 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)])
+        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):

{poetry_plugin_ivcap-0.2.0 → poetry_plugin_ivcap-0.2.3}/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.2.0 → poetry_plugin_ivcap-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "poetry-plugin-ivcap"
-version = "0.2.0"
+version = "0.2.3"
 description = "A custom Poetry command for IVCAP deployments"
 authors = ["Max Ott <max.ott@csiro.au>"]
 license = "MIT"
@@ -8,7 +8,7 @@ readme = "README.md"
 packages = [{ include = "poetry_plugin_ivcap" }]
 
 [tool.poetry.dependencies]
-python = "^3.9"
+python = ">=3.9"
 pydantic = "^2.11.5"
 humanize = "^4.12.3"