flux-batch 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

flux_batch/service/scribe/__main__.py

@@ -26,9 +26,12 @@ class JournalScribe:
         """
         Initializes the Scribe with a synchronous DB backend and a Flux Journal Consumer.
         """
+        # Get settings from environment
+        self.init_settings()
+
         # Setup Database
         logger.info(f"Connecting to Database: {db_url}")
-        self.db = SQLAlchemyBackend(db_url)
+        self.db = SQLAlchemyBackend(db_url, self.settings["use_ssl"])
         self.db.initialize()
 
         try:
@@ -38,11 +41,22 @@ class JournalScribe:
             logger.critical(f"Failed to connect to Flux: {e}")
             sys.exit(1)
 
+        logger.info(f"🍳 Handle: {self.handle.attr_get('local-uri')}")
+
         # Initialize Journal Consumer
         # This consumes the global event log for the entire instance
         self.consumer = flux.job.JournalConsumer(self.handle)
         self.running = True
 
+    def init_settings(self):
+        """
+        Initialize settings.
+        """
+        self.settings = {
+            "use_ssl": os.environ.get("FLUX_SCRIBE_SSL") not in [None, "no", "false", "off"],
+            "uid": os.environ.get("FLUX_SCRIBE_UID"),
+        }
+
     def _normalize_event(self, event) -> dict:
         """
         Converts a Flux event object into the dictionary format expected by record_event.
@@ -79,7 +93,7 @@ class JournalScribe:
                         # We only care about events associated with a job
                         if hasattr(event, "jobid"):
                             clean_event = self._normalize_event(event)
-                            self.db.record_event("local", clean_event)
+                            self.db.record_event("local", self.settings['uid'], clean_event)
                     else:
                         # If no event, yield a tiny bit of CPU
                         time.sleep(0.01)

flux_batch/service/scribe/database.py

@@ -8,7 +8,7 @@ from sqlalchemy.orm import sessionmaker
 from flux_batch.service.scribe.models import Base, EventModel, EventRecord, JobModel, JobRecord
 
 
-def _record_event_internal(session, cluster: str, event: Dict[str, Any]):
+def _record_event_internal(session, cluster: str, uid: str, event: Dict[str, Any]):
     """
     Shared synchronous logic for recording events.
     Used by both Sync and Async backends.
@@ -18,11 +18,13 @@ def _record_event_internal(session, cluster: str, event: Dict[str, Any]):
     data = event.get("payload", {})
     timestamp = event.get("timestamp", time.time())
 
+    # Add the new event with all metadata
     new_event = EventModel(
         job_id=job_id,
         cluster=cluster,
         timestamp=timestamp,
         event_type=event_type,
+        uid=uid,
         payload=data,
     )
     session.add(new_event)
@@ -40,6 +42,7 @@ def _record_event_internal(session, cluster: str, event: Dict[str, Any]):
                 workdir=data.get("cwd", ""),
                 submit_time=timestamp,
                 last_updated=timestamp,
+                uid=uid,
             )
             session.add(job)
         else:
@@ -63,8 +66,18 @@ class AsyncSQLAlchemyBackend:
     Asynchronous backend for the MCP Gateway.
     """
 
-    def __init__(self, db_url: str):
-        self.engine = create_async_engine(db_url, echo=False)
+    def __init__(self, db_url: str, use_ssl: bool = False):
+        # Use asyncio connection via asyncmy
+        if db_url.startswith("mysql://") or db_url.startswith("mariadb://"):
+            db_url = db_url.replace("mysql://", "mysql+asyncmy://", 1)
+            db_url = db_url.replace("mariadb://", "mysql+asyncmy://", 1)
+
+        connect_args = {"connect_timeout": 10}
+        if use_ssl:
+            print("SSL is enabled.")
+            connect_args["ssl"] = {"ssl_mode": "REQUIRED", "check_hostname": False}
+
+        self.engine = create_async_engine(db_url, echo=False, connect_args=connect_args)
         self.SessionLocal = async_sessionmaker(self.engine, expire_on_commit=False)
 
     async def initialize(self):
@@ -115,10 +128,13 @@ class SQLAlchemyBackend:
     Synchronous backend for the standalone Scribe daemon.
     """
 
-    def __init__(self, db_url: str):
-        # strip 'aiosqlite+' or similar if passed from shared config
-        url = db_url.replace("+aiosqlite", "").replace("+asyncpg", "")
-        self.engine = create_engine(url, echo=False)
+    def __init__(self, db_url: str, use_ssl: bool = False):
+        connect_args = {"connect_timeout": 10}
+        if use_ssl:
+            print("SSL is enabled.")
+            connect_args["ssl"] = {"ssl_mode": "REQUIRED", "check_hostname": False}
+
+        self.engine = create_engine(db_url, echo=False, connect_args=connect_args)
         self.SessionLocal = sessionmaker(bind=self.engine, expire_on_commit=False)
 
     def initialize(self):
@@ -127,10 +143,10 @@ class SQLAlchemyBackend:
     def close(self):
         self.engine.dispose()
 
-    def record_event(self, cluster: str, event: Dict[str, Any]):
+    def record_event(self, cluster: str, uid: str, event: Dict[str, Any]):
         with self.SessionLocal() as session:
             with session.begin():
-                _record_event_internal(session, cluster, event)
+                _record_event_internal(session, cluster, uid, event)
 
     def get_unwatched_job_ids(self, cluster: str) -> List[int]:
         """Specific for Scribe: find jobs that need a watcher."""

flux_batch/service/scribe/models.py

@@ -16,7 +16,7 @@ class JobRecord:
     Returned by get_job() and search_jobs().
     """
 
-    job_id: int
+    job_id: str
     cluster: str
     state: str
     user: str
@@ -24,6 +24,7 @@ class JobRecord:
     exit_code: Optional[int] = None
     submit_time: float = 0.0
     last_updated: float = 0.0
+    uid: str = None
 
 
 @dataclass
@@ -36,6 +37,7 @@ class EventRecord:
     timestamp: float
     event_type: str
     payload: Dict[str, Any]
+    uid: str = None
 
 
 # Database models for SQLAlchemy ORM
@@ -49,12 +51,16 @@ class JobModel(Base):
     __tablename__ = "jobs"
 
     # Composite Primary Key
-    job_id: Mapped[int] = mapped_column(Integer, primary_key=True)
     cluster: Mapped[str] = mapped_column(String(255), primary_key=True)
+    job_id: Mapped[str] = mapped_column(String(255), primary_key=True)
+    uid: Mapped[str] = mapped_column(String(255), nullable=True)
 
     state: Mapped[str] = mapped_column(String(50))
     user: Mapped[str] = mapped_column(String(255), nullable=True)
-    workdir: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+
+    # Fixed: Added length 1024 for MySQL/MariaDB compatibility
+    workdir: Mapped[Optional[str]] = mapped_column(String(1024), nullable=True)
+
     exit_code: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
     submit_time: Mapped[float] = mapped_column(Float, default=0.0)
     last_updated: Mapped[float] = mapped_column(Float, default=0.0)
@@ -72,6 +78,7 @@ class JobModel(Base):
             exit_code=self.exit_code,
             submit_time=self.submit_time,
             last_updated=self.last_updated,
+            uid=self.uid,
         )
 
 
@@ -79,16 +86,22 @@ class EventModel(Base):
     __tablename__ = "events"
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    job_id: Mapped[int] = mapped_column(Integer, index=True)
+    job_id: Mapped[str] = mapped_column(String(255), primary_key=True)
     cluster: Mapped[str] = mapped_column(String(255), index=True)
     timestamp: Mapped[float] = mapped_column(Float)
     event_type: Mapped[str] = mapped_column(String(50))
     payload: Mapped[Dict[str, Any]] = mapped_column(JSON)
+    uid: Mapped[str] = mapped_column(String(255), nullable=True)
 
     def to_record(self) -> EventRecord:
         """
         Helper to convert ORM model to public DTO
         """
         return EventRecord(
-            timestamp=self.timestamp, event_type=self.event_type, payload=self.payload
+            timestamp=self.timestamp,
+            event_type=self.event_type,
+            payload=self.payload,
+            cluster=self.cluster,
+            job_id=self.job_id,
+            uid=self.uid,
         )

flux_batch/service/usernetes/__init__.py

@@ -0,0 +1,2 @@
+MODULE_NAME = "flux_batch.service.usernetes"
+from .template import SERVICE_TEMPLATE, START_MODULE_TEMPLATE, STOP_MODULE_TEMPLATE

flux_batch/service/usernetes/__main__.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+import errno
+import logging
+import os
+import sys
+import time
+
+import flux
+import flux.job
+
+# Not necessary, but it makes it pretty
+from rich import print
+
+# Use the synchronous version of the backend to avoid asyncio-in-thread conflicts
+from flux_batch.service.scribe.database import SQLAlchemyBackend
+
+# Setup logging to stderr (to avoid polluting stdout if run manually)
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s %(levelname)s: %(message)s", stream=sys.stderr
+)
+logger = logging.getLogger("flux-scribe")
+
+
+class JournalScribe:
+    def __init__(self, db_url: str):
+        """
+        Initializes the Scribe with a synchronous DB backend and a Flux Journal Consumer.
+        """
+        # Setup Database
+        logger.info(f"Connecting to Database: {db_url}")
+        self.db = SQLAlchemyBackend(db_url)
+        self.db.initialize()
+
+        try:
+            self.handle = flux.Flux()
+            logger.info("Connected to Flux instance.")
+        except Exception as e:
+            logger.critical(f"Failed to connect to Flux: {e}")
+            sys.exit(1)
+
+        logger.info(f"🍳 Handle: {self.handle.attr_get('local-uri')}")
+
+        # Initialize Journal Consumer
+        # This consumes the global event log for the entire instance
+        self.consumer = flux.job.JournalConsumer(self.handle)
+        self.running = True
+
+    def _normalize_event(self, event) -> dict:
+        """
+        Converts a Flux event object into the dictionary format expected by record_event.
+        Matches the logic provided in your EventsEngine reference.
+        """
+        # Convert the SWIG/CFFI event object to a dictionary
+        payload = dict(event)
+
+        return {
+            "id": str(getattr(event, "jobid", "unknown")),
+            "type": getattr(event, "name", "unknown"),
+            "timestamp": getattr(event, "timestamp", time.time()),
+            "payload": payload,
+            "R": getattr(event, "R", None),
+            "jobspec": getattr(event, "jobspec", None),
+        }
+
+    def run(self):
+        """
+        Main execution loop. Polls the journal and writes to the DB.
+        """
+        try:
+            logger.info("🚀 Flux Scribe (Journal Consumer) started.")
+            self.consumer.start()
+
+            while self.running:
+                try:
+                    # Non-blocking poll (100ms timeout)
+                    # This allows the loop to check for shutdown signals regularly
+                    event = self.consumer.poll(timeout=0.1)
+
+                    if event:
+                        print(event)
+                        # We only care about events associated with a job
+                        if hasattr(event, "jobid"):
+                            clean_event = self._normalize_event(event)
+                            self.db.record_event("local", clean_event)
+                    else:
+                        # If no event, yield a tiny bit of CPU
+                        time.sleep(0.01)
+
+                except EnvironmentError as e:
+                    # Ignore timeouts (no data)
+                    if e.errno == errno.ETIMEDOUT:
+                        continue
+                    logger.error(f"Flux connection error: {e}")
+                    time.sleep(1)
+
+                except Exception as e:
+                    logger.error(f"Unexpected error in event loop: {e}")
+                    time.sleep(1)
+
+        except Exception as e:
+            logger.critical(f"EventsEngine crashed: {e}")
+        finally:
+            self.db.close()
+            logger.info("EventsEngine thread exiting.")
+
+
+def main():
+    # Retrieve DB path from environment or use a default
+    db_path = os.environ.get("FLUX_SCRIBE_DATABASE", "sqlite:///server_state.db")
+    scribe = JournalScribe(db_path)
+    scribe.run()
+
+
+if __name__ == "__main__":
+    main()

flux_batch/service/usernetes/database.py

@@ -0,0 +1,151 @@
+import time
+from typing import Any, Dict, List, Optional
+
+from sqlalchemy import and_, create_engine, select, update
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.orm import sessionmaker
+
+from flux_batch.service.scribe.models import Base, EventModel, EventRecord, JobModel, JobRecord
+
+
+def _record_event_internal(session, cluster: str, event: Dict[str, Any]):
+    """
+    Shared synchronous logic for recording events.
+    Used by both Sync and Async backends.
+    """
+    job_id = event.get("id")
+    event_type = event.get("type")
+    data = event.get("payload", {})
+    timestamp = event.get("timestamp", time.time())
+
+    # Add the new event with all metadata
+    new_event = EventModel(
+        job_id=job_id,
+        cluster=cluster,
+        timestamp=timestamp,
+        event_type=event_type,
+        payload=data,
+    )
+    session.add(new_event)
+
+    if event_type == "submit":
+        stmt = select(JobModel).where(and_(JobModel.job_id == job_id, JobModel.cluster == cluster))
+        job = session.execute(stmt).scalar_one_or_none()
+
+        if not job:
+            job = JobModel(
+                job_id=job_id,
+                cluster=cluster,
+                user=str(data.get("userid", "unknown")),
+                state="submitted",
+                workdir=data.get("cwd", ""),
+                submit_time=timestamp,
+                last_updated=timestamp,
+            )
+            session.add(job)
+        else:
+            job.state = "submitted"
+            job.last_updated = timestamp
+
+    # state transitions
+    elif event_type == "state" or (event_type and event_type.endswith(".finish")):
+        state_name = data.get("state_name", event_type)
+        stmt = select(JobModel).where(and_(JobModel.job_id == job_id, JobModel.cluster == cluster))
+        job = session.execute(stmt).scalar_one_or_none()
+        if job:
+            job.state = state_name
+            job.last_updated = time.time()
+            if "status" in data:
+                job.exit_code = data["status"]
+
+
+class AsyncSQLAlchemyBackend:
+    """
+    Asynchronous backend for the MCP Gateway.
+    """
+
+    def __init__(self, db_url: str):
+        self.engine = create_async_engine(db_url, echo=False)
+        self.SessionLocal = async_sessionmaker(self.engine, expire_on_commit=False)
+
+    async def initialize(self):
+        async with self.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+    async def close(self):
+        await self.engine.dispose()
+
+    async def record_event(self, cluster: str, event: Dict[str, Any]):
+        async with self.SessionLocal() as session:
+            # run_sync bridges our shared logic into the async session
+            await session.run_sync(_record_event_internal, cluster, event)
+            await session.commit()
+
+    async def get_job(self, cluster: str, job_id: int) -> Optional[JobRecord]:
+        async with self.SessionLocal() as session:
+            result = await session.execute(
+                select(JobModel).where(and_(JobModel.job_id == job_id, JobModel.cluster == cluster))
+            )
+            job = result.scalar_one_or_none()
+            return job.to_record() if job else None
+
+    async def get_event_history(self, cluster: str, job_id: int) -> List[EventRecord]:
+        async with self.SessionLocal() as session:
+            result = await session.execute(
+                select(EventModel)
+                .where(and_(EventModel.job_id == job_id, EventModel.cluster == cluster))
+                .order_by(EventModel.timestamp.asc())
+            )
+            return [e.to_record() for e in result.scalars().all()]
+
+    async def search_jobs(
+        self, cluster: str = None, state: str = None, limit: int = 10
+    ) -> List[JobRecord]:
+        async with self.SessionLocal() as session:
+            stmt = select(JobModel)
+            if cluster:
+                stmt = stmt.where(JobModel.cluster == cluster)
+            if state:
+                stmt = stmt.where(JobModel.state == state)
+            result = await session.execute(stmt.limit(limit))
+            return [j.to_record() for j in result.scalars().all()]
+
+
+class SQLAlchemyBackend:
+    """
+    Synchronous backend for the standalone Scribe daemon.
+    """
+
+    def __init__(self, db_url: str):
+        # strip 'aiosqlite+' or similar if passed from shared config
+        url = db_url.replace("+aiosqlite", "").replace("+asyncpg", "")
+        self.engine = create_engine(url, echo=False)
+        self.SessionLocal = sessionmaker(bind=self.engine, expire_on_commit=False)
+
+    def initialize(self):
+        Base.metadata.create_all(self.engine)
+
+    def close(self):
+        self.engine.dispose()
+
+    def record_event(self, cluster: str, event: Dict[str, Any]):
+        with self.SessionLocal() as session:
+            with session.begin():
+                _record_event_internal(session, cluster, event)
+
+    def get_unwatched_job_ids(self, cluster: str) -> List[int]:
+        """Specific for Scribe: find jobs that need a watcher."""
+        with self.SessionLocal() as session:
+            stmt = select(JobModel.job_id).where(
+                and_(JobModel.cluster == cluster, JobModel.state == "submitted")
+            )
+            return list(session.execute(stmt).scalars().all())
+
+    def mark_job_as_watched(self, cluster: str, job_id: int):
+        with self.SessionLocal() as session:
+            with session.begin():
+                session.execute(
+                    update(JobModel)
+                    .where(and_(JobModel.job_id == job_id, JobModel.cluster == cluster))
+                    .values(state="watching")
+                )

flux_batch/service/usernetes/models.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from sqlalchemy import JSON, Float, Integer, String
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+# DTOs are "Public Data Transfer Objects" and they are used by
+# our interfaces and tools
+
+
+@dataclass
+class JobRecord:
+    """
+    Represents a snapshot of a job state.
+    Returned by get_job() and search_jobs().
+    """
+
+    job_id: int
+    cluster: str
+    state: str
+    user: str
+    workdir: Optional[str] = None
+    exit_code: Optional[int] = None
+    submit_time: float = 0.0
+    last_updated: float = 0.0
+
+
+@dataclass
+class EventRecord:
+    """
+    Represents a single historical event.
+    Returned by get_event_history().
+    """
+
+    timestamp: float
+    event_type: str
+    payload: Dict[str, Any]
+
+
+# Database models for SQLAlchemy ORM
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+    pass
+
+
+class JobModel(Base):
+    __tablename__ = "jobs"
+
+    # Composite Primary Key
+    job_id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    cluster: Mapped[str] = mapped_column(String(255), primary_key=True)
+
+    state: Mapped[str] = mapped_column(String(50))
+    user: Mapped[str] = mapped_column(String(255), nullable=True)
+    workdir: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    exit_code: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
+    submit_time: Mapped[float] = mapped_column(Float, default=0.0)
+    last_updated: Mapped[float] = mapped_column(Float, default=0.0)
+
+    def to_record(self) -> JobRecord:
+        """
+        Helper to convert ORM model to public DTO
+        """
+        return JobRecord(
+            job_id=self.job_id,
+            cluster=self.cluster,
+            state=self.state,
+            user=self.user,
+            workdir=self.workdir,
+            exit_code=self.exit_code,
+            submit_time=self.submit_time,
+            last_updated=self.last_updated,
+        )
+
+
+class EventModel(Base):
+    __tablename__ = "events"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    job_id: Mapped[int] = mapped_column(Integer, index=True)
+    cluster: Mapped[str] = mapped_column(String(255), index=True)
+    timestamp: Mapped[float] = mapped_column(Float)
+    event_type: Mapped[str] = mapped_column(String(50))
+    payload: Mapped[Dict[str, Any]] = mapped_column(JSON)
+
+    def to_record(self) -> EventRecord:
+        """
+        Helper to convert ORM model to public DTO
+        """
+        return EventRecord(
+            timestamp=self.timestamp,
+            event_type=self.event_type,
+            payload=self.payload,
+            cluster=self.cluster,
+            job_id=self.job_id,
+        )

flux_batch/service/usernetes/template.py

@@ -0,0 +1,53 @@
+# Template for the Scribe Journal Consumer
+SERVICE_TEMPLATE = """[Unit]
+Description=Flux Scribe Journal Consumer
+After=network.target
+
+[Service]
+ExecStart={python_path} -m flux_batch.service.scribe
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+"""
+
+START_MODULE_TEMPLATE = """
+from flux.modprobe import task
+import flux.subprocess as subprocess
+
+@task(
+    "start-{service_name}",
+    ranks="0",
+    needs_config=["{service_name}"],
+    after=["resource", "job-list"],
+)
+def start_{service_func}(context):
+    # This triggers the systemd user service provisioned earlier
+    # context.bash("systemctl --user start {service_name}")
+    subprocess.rexec_bg(
+        context.handle,
+        ["{python_bin}", "-m", "{module_name}"],
+        label="{service_name}",
+        nodeid=0
+    )
+"""
+
+STOP_MODULE_TEMPLATE = """
+from flux.modprobe import task
+import flux.subprocess as subprocess
+
+@task(
+    "stop-{service_name}",
+    ranks="0",
+    needs_config=["{service_name}"],
+    before=["resource", "job-list"],
+)
+def stop_{service_func}(context):
+    # context.bash("systemctl --user stop {service_name}")
+    subprocess.kill(context.handle, signum=2, label="{service_name}").get()
+    try:
+        status = subprocess.wait(context.handle, label="{service_name}").get()["status"]
+        print(status)
+    except:
+        pass
+"""

flux_batch/version.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.11"
+__version__ = "0.0.13"
 AUTHOR = "Vanessa Sochat"
 AUTHOR_EMAIL = "vsoch@users.noreply.github.com"
 NAME = "flux-batch"

{flux_batch-0.0.11.dist-info → flux_batch-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flux-batch
-Version: 0.0.11
+Version: 0.0.13
 Summary: Python SDK for flux batch jobs and services
 Home-page: https://github.com/converged-computing/flux-batch
 Author: Vanessa Sochat
@@ -47,6 +47,8 @@ Requires-Dist: rich ; extra == 'scribe'
 - [fractale-mcp](https://github.com/compspec/fractale-mcp): (fractale) MCP orchestration (agents, databases, ui interfaces).
 - [hpc-mcp](https://github.com/converged-computing/hpc-mcp): HPC tools for a larger set of HPC and converged computing use cases.
 
+If you are looking for `flux batch` please see the documentation [here](https://flux-framework.readthedocs.io/projects/flux-core/en/latest/man1/flux-batch.html). This library supports Flux Framework and is experimental.
+
 ## Services
 
  - **flux-scribe**: Write job events to a local sqlite database via the JournalConsumer (not added yet, written and needs testing)
@@ -135,7 +137,7 @@ batch.add_job(["sleep", "5"])
 batch.add_job(["echo", "Job 2 finished"])
 
 # Wrap it up into a jobspec
-jobspec = flux_batch.BatchJobspecV1.from_jobs(
+spec = flux_batch.BatchJobspecV1.from_jobs(
     batch,
     nodes=1,
     nslots=1,
@@ -146,14 +148,15 @@ jobspec = flux_batch.BatchJobspecV1.from_jobs(
 )
 
 # Add a prolog and epilog
-jobspec.add_prolog("echo 'Batch Wrapper Starting'")
-jobspec.add_epilog("echo 'Batch Wrapper Finished'")
+spec.add_prolog("echo 'Batch Wrapper Starting'")
+spec.add_epilog("echo 'Batch Wrapper Finished'")
 
 # Add a service (this assumes user level that exists)
-jobspec.add_service("flux-scribe")
+spec.add_service("flux-scribe")
 
-# Preview it
-print(flux_batch.submit(handle, jobspec, dry_run=True))
+# Preview it (batch wrapper), or generate the jobspec (json)
+print(flux_batch.submit(handle, spec, dry_run=True))
+jobspec = flux_batch.jobspec(spec)
 
 # Submit that bad boi.
 jobid = flux_batch.submit(handle, jobspec)

{flux_batch-0.0.11.dist-info → flux_batch-0.0.13.dist-info}/RECORD

@@ -2,7 +2,7 @@ flux_batch/__init__.py,sha256=35032OVyHkBiQIptg7NBY_6mdhthFu1hpqOCsREm5lQ,280
 flux_batch/jobspec.py,sha256=MUMI4Y_DgjCRssgzUDagTTFw8L3t4L_5az1E3tmT1FI,5464
 flux_batch/models.py,sha256=JjrFqi4Skrop_cyIWfgAHTdY53kotkiGD0JpTnVlByI,2200
 flux_batch/submit.py,sha256=tNJMDvnsxbAuXg_5TkB8HurzQ9I-Dot_gXXpIU5LtTA,2654
-flux_batch/version.py,sha256=h-6jDEwrQuFPdUK7HJbFYJISN7mt1MwBKK0UnnS1-cM,643
+flux_batch/version.py,sha256=W-9wI-nhKTdrBIA6HgtR7eb_HyV0qAzlIAHd9UibgX4,643
 flux_batch/logger/__init__.py,sha256=eDdpw_uppR5mPLHE39qT_haqMxu-2wniLlJZDigRC2k,52
 flux_batch/logger/generate.py,sha256=L9JyMY2oapp0ss7f7LGuihbLomzVJsMq7sByy9NhbZI,4017
 flux_batch/logger/logger.py,sha256=HKymVBNcoPdX87QWy69er5wUzHVeriiKp9p0bIYboUo,5927
@@ -11,18 +11,23 @@ flux_batch/script/save_logs.sh,sha256=HeapqvL0iR8aX7LtbwlcFTy19j5WxkQ-1M2J9epu-E
 flux_batch/service/__init__.py,sha256=pD7RYpdSLZvYU4qwShYXA6UcaJy191fKtzqJL3uttEc,2724
 flux_batch/service/scribe.py,sha256=dY6geiLvXYIRcIzuP_naZscKgzX4Y5dPzxoWf9Wywg0,253
 flux_batch/service/scribe/__init__.py,sha256=773-AzF_WRY6udG5nQSexf7Vga4K1YZLy1sfQAEd1uo,126
-flux_batch/service/scribe/__main__.py,sha256=3S0dyhkHk-bPT_Z0laNUg-HydrCFql4hPOV2ZNF5rO0,3777
-flux_batch/service/scribe/database.py,sha256=EB8OEMfNvfCplGaz-ZNMsfIpd305eP-mfCvSd-fg_k4,5626
-flux_batch/service/scribe/models.py,sha256=7lUrRosnQ2douFL_xD9GMYex4Z4lkN-CcBeWDhzmD8c,2668
+flux_batch/service/scribe/__main__.py,sha256=tyaETaimVptrg1qfWasgcavhh0AFj0kGAhFp2LKtwm4,4236
+flux_batch/service/scribe/database.py,sha256=0BImmobV8yzskcu4kagQCLqYDzUAtDyxUUJRlj-Yf2A,6343
+flux_batch/service/scribe/models.py,sha256=9eHYp_lO-oVYidY3G3khA1mDgm2AzmuPTpzPGEgxruA,3066
 flux_batch/service/scribe/template.py,sha256=yDsheid2FXeYr458loxB3HyZKSWpGQpM8iUQfnfOA-s,1336
+flux_batch/service/usernetes/__init__.py,sha256=BvrHIsjevkT-nFqUKcn9VKwvtUGA1G48jqk4z0O9xK4,129
+flux_batch/service/usernetes/__main__.py,sha256=xQHIxRd2pjGxpVcIyv2tq88ts3e2IsmhrQuMVG-wrOw,3851
+flux_batch/service/usernetes/database.py,sha256=kagh_YJFpKMtixJ5-Zs762vLFDGEU7Fq9lOYEgeKPmo,5668
+flux_batch/service/usernetes/models.py,sha256=wVHgX5X9PUpUSDtZtMaz1M_fGC1Vyv8JdUt58AoEA3c,2759
+flux_batch/service/usernetes/template.py,sha256=yDsheid2FXeYr458loxB3HyZKSWpGQpM8iUQfnfOA-s,1336
 flux_batch/utils/__init__.py,sha256=CqMhw_mBfR0HBcHwv7LtFITq0J7LBV413VQE9xrz8ks,42
 flux_batch/utils/fileio.py,sha256=Elz8WkNkJ9B6x7WmCwiIBW0GgsRSSFCcbuJh7aqu2z4,4879
 flux_batch/utils/text.py,sha256=Ci1BqHs2IbOSn2o60zhLkT4kIA7CSNuGj8mdiGaDIGk,606
 flux_batch/utils/timer.py,sha256=_Weec7Wd5hWQ1r4ZHjownG4YdoIowpVqilXhvYFmIgA,491
-flux_batch-0.0.11.dist-info/LICENSE,sha256=AlyLB1m_z0CENCx1ob0PedLTTohtH2VLZhs2kfygrfc,1108
-flux_batch-0.0.11.dist-info/METADATA,sha256=A0LLvVm-RKGxSM26HMfHlOKe5OxF22O7APLNWfvIBj0,5352
-flux_batch-0.0.11.dist-info/NOTICE,sha256=9CR93geVKl_4ZrJORbXN0fzkEM2y4DglWhY1hn9ZwQw,1167
-flux_batch-0.0.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-flux_batch-0.0.11.dist-info/entry_points.txt,sha256=ynoKpD82xn2V2sD-aZIQoq7NnfOu9VEKqW55Y1AoPGI,67
-flux_batch-0.0.11.dist-info/top_level.txt,sha256=jj8zAsZzMmbjiBISJL7lRtA37MSEAQYfObGLUncn9Lw,11
-flux_batch-0.0.11.dist-info/RECORD,,
+flux_batch-0.0.13.dist-info/LICENSE,sha256=AlyLB1m_z0CENCx1ob0PedLTTohtH2VLZhs2kfygrfc,1108
+flux_batch-0.0.13.dist-info/METADATA,sha256=Y0somwoZuJzlzyT1KmkwWliawzy9foVPGd4Y2UZt4J0,5641
+flux_batch-0.0.13.dist-info/NOTICE,sha256=9CR93geVKl_4ZrJORbXN0fzkEM2y4DglWhY1hn9ZwQw,1167
+flux_batch-0.0.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+flux_batch-0.0.13.dist-info/entry_points.txt,sha256=ynoKpD82xn2V2sD-aZIQoq7NnfOu9VEKqW55Y1AoPGI,67
+flux_batch-0.0.13.dist-info/top_level.txt,sha256=jj8zAsZzMmbjiBISJL7lRtA37MSEAQYfObGLUncn9Lw,11
+flux_batch-0.0.13.dist-info/RECORD,,