scijob 0.1.0a1__tar.gz

scijob-0.1.0a1/.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+.env*
+.python-version
+/test*.py

scijob-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wjk376
+
+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.

scijob-0.1.0a1/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: scijob
+Version: 0.1.0a1
+Summary: SciJob platform SDK for Python
+Project-URL: Homepage, https://github.com/wjk376/scijob-sdk-python
+Author-email: Jiankun Wang <wangjiankun376@163.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pycryptodome>=3.23.0
+Requires-Dist: pydantic>=2.11.0
+Provides-Extra: dev
+Requires-Dist: dotenv>=0.9.9; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# SciJob SDK
+
+## Installation
+
+## Usages
+
+You may first initialize a SciJob client:
+
+```python
+from scijob import Client
+
+cli = Client(api_key="your api key", api_base_url="your api base url")
+```
+
+Or go with the async version:
+
+```python
+from scijob import AsyncClient
+
+cli = AsyncClient(api_key="your api key", api_base_url="your api base url")
+```
+
+### Register Functions
+
+You may register a new function which sources from GitLab and with VolcEngine specifications as below:
+
+```python
+from scijob.requests import *
+
+resp = cli.register_function(
+    request=RegisterFunctionRequestBuilder()
+        .identity(key="func_key", name="some_func", module="some_module", version="0.0.1")
+        .description("This is a test function...")
+        .repo_source("gitlab")
+        .gitlab_repo_info(...)
+        .envs([("SOME_ENVIRONMENT_VARIABLE", "hello world")])
+        .volcengine_specs(specs=VolcEngineSpecsBuilder()
+            .credentials(ak="your access key", sk="your secret key")
+            .region("cn-beijing")
+            .image(...)
+            .num_cpus(4) # use 'num_gpus' instead if the function requires GPU resource 
+            .vepfs(...)
+            .build()
+        )
+        .build()
+)
+print(resp.function_id)
+#> 6a1b48027b0e2e9c9d3ad8c7
+```
+
+### Call Functions
+
+Below shows an example of calling a registered function by its ID, using with statements:
+
+```python
+async with AsyncClient(api_key="your api key", api_base_url="your api base url") as cli:
+    job = await cli.call_function(
+        request=CallFunctionRequestBuilder()
+            .function_id("6a1b48027b0e2e9c9d3ad8c7")
+            .function_args(...)
+            .backend("volcengine_ml_platform")
+            .build()
+    )
+    res = await job.get_result()
+```

scijob-0.1.0a1/README.md

@@ -0,0 +1,65 @@
+# SciJob SDK
+
+## Installation
+
+## Usages
+
+You may first initialize a SciJob client:
+
+```python
+from scijob import Client
+
+cli = Client(api_key="your api key", api_base_url="your api base url")
+```
+
+Or go with the async version:
+
+```python
+from scijob import AsyncClient
+
+cli = AsyncClient(api_key="your api key", api_base_url="your api base url")
+```
+
+### Register Functions
+
+You may register a new function which sources from GitLab and with VolcEngine specifications as below:
+
+```python
+from scijob.requests import *
+
+resp = cli.register_function(
+    request=RegisterFunctionRequestBuilder()
+        .identity(key="func_key", name="some_func", module="some_module", version="0.0.1")
+        .description("This is a test function...")
+        .repo_source("gitlab")
+        .gitlab_repo_info(...)
+        .envs([("SOME_ENVIRONMENT_VARIABLE", "hello world")])
+        .volcengine_specs(specs=VolcEngineSpecsBuilder()
+            .credentials(ak="your access key", sk="your secret key")
+            .region("cn-beijing")
+            .image(...)
+            .num_cpus(4) # use 'num_gpus' instead if the function requires GPU resource 
+            .vepfs(...)
+            .build()
+        )
+        .build()
+)
+print(resp.function_id)
+#> 6a1b48027b0e2e9c9d3ad8c7
+```
+
+### Call Functions
+
+Below shows an example of calling a registered function by its ID, using with statements:
+
+```python
+async with AsyncClient(api_key="your api key", api_base_url="your api base url") as cli:
+    job = await cli.call_function(
+        request=CallFunctionRequestBuilder()
+            .function_id("6a1b48027b0e2e9c9d3ad8c7")
+            .function_args(...)
+            .backend("volcengine_ml_platform")
+            .build()
+    )
+    res = await job.get_result()
+```

scijob-0.1.0a1/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "scijob"
+description = "SciJob platform SDK for Python"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    { name = "Jiankun Wang", email = "wangjiankun376@163.com" },
+]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Pydantic :: 2",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "httpx>=0.28.1",
+    "pycryptodome>=3.23.0",
+    "pydantic>=2.11.0",
+]
+dynamic = [
+    "version",
+]
+
+[project.optional-dependencies]
+dev = [
+    "dotenv>=0.9.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/wjk376/scijob-sdk-python"
+
+[tool.hatch.version]
+path = "scijob/__version__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["scijob"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/scijob"]
+
+[[tool.uv.index]]
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"

scijob-0.1.0a1/scijob/__init__.py

@@ -0,0 +1,20 @@
+from ._client import AsyncClient, Client
+from ._exceptions import *
+from .__version__ import __version__
+
+__all__ = [
+    "__version__",
+    "AsyncClient",
+    "Client",
+    "HttpRequestError",
+    "GetJobResultError",
+    "JobCancelledError",
+    "JobStateFailedError",
+    "JobStateMissingError",
+    "JobStateStoppedError",
+]
+
+__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "scijob")  # noqa

scijob-0.1.0a1/scijob/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0a1"

scijob-0.1.0a1/scijob/_client.py

@@ -0,0 +1,396 @@
+from types import TracebackType
+from typing import Any, Optional, Type
+
+import httpx
+
+from ._config import *
+from ._exceptions import *
+from ._proxy import AsyncJobProxy, JobProxy
+from ._logger import logger
+from ._models import *
+from ._types import Numeric, QueryFunctionsResponse
+from .requests import *
+
+__all__ = ["AsyncClient", "Client"]
+
+
+class _BaseClient:
+    def __init__(
+        self, 
+        *,
+        api_key: str, 
+        api_base_url: str,
+        poll_interval: Numeric = DEFAULT_POLL_INTERVAL,
+    ):
+        self._api_base_url = f"{api_base_url}/{API_VERSION}"
+        self._headers = {API_KEY_HEADER: api_key}
+        self._poll_interval = poll_interval
+
+
+class Client(_BaseClient):
+    def __init__(
+        self, 
+        *, 
+        api_key: str, 
+        api_base_url: str,
+        poll_interval: Numeric = DEFAULT_POLL_INTERVAL,
+    ):
+        super().__init__(
+            api_key=api_key, 
+            api_base_url=api_base_url, 
+            poll_interval=poll_interval,
+        )
+        self._cli = httpx.Client(base_url=self._api_base_url, headers=self._headers)
+        
+    def __del__(self):
+        self.close()
+        
+    def close(self):
+        self._cli.close()
+        
+    def __enter__(self):
+        return self
+    
+    def __exit__(
+        self, 
+        exc_type: Optional[Type[BaseException]], 
+        exc_value: Optional[BaseException], 
+        traceback: Optional[TracebackType],
+    ):
+        self.close()
+        
+    def _get(self, url: str):
+        resp = self._cli.get(url)
+        if not resp.is_success:
+            raise HttpRequestError(resp)
+        return resp
+    
+    def _post(self, url: str, json: Any):
+        resp = self._cli.post(url, json=json)
+        if not resp.is_success:
+            raise HttpRequestError(resp)
+        return resp
+        
+    def get_function(self, function_id: str):
+        """
+        Get function details by function ID.
+        """
+        resp = self._get(url=f"/function/{function_id}")
+        return Function.model_validate_json(resp.content, strict=True)
+    
+    def query_functions(self, request: QueryFunctionsRequest):
+        """
+        Query matched functions by identity information.
+        """
+        
+        # Fetch all matched functions by pagination
+        json = {**request.json(), "page": 1}
+        funcs = []
+        
+        while True:
+            resp = self._post(url=f"/function/query", json=json)
+            payload: QueryFunctionsResponse = resp.json()
+            funcs.extend(payload["functions"])
+            if payload["has_more"]:
+                json["page"] += 1
+            else:
+                break
+        
+        return [Function.model_validate(fn, strict=True) for fn in funcs]
+    
+    def register_function(self, request: RegisterFunctionRequest):
+        """
+        Register a new function to job platform.
+        """
+        resp = self._post(url=f"/function/register", json=request.json())
+        payload = RegisterFunctionResponse.model_validate_json(resp.content, strict=True)
+        logger.info(f"Registered function '{payload.function_id}'")
+        return payload
+    
+    def delete_job(self, job_id: str):
+        """
+        Delete job by job ID (for admin users only).
+        """
+        self._post(url=f"/job/delete", json={"job_id": job_id})
+    
+    def delete_function(self, function_id: str):
+        """
+        Delete function by function ID (for admin users only).
+        """
+        self._post(url=f"/function/delete", json={"id": function_id})
+        logger.info(f"Deleted function '{function_id}'")
+        
+    def call_function(
+        self, 
+        request: CallFunctionRequest, 
+        verbose: bool = True,
+    ):
+        """
+        Call function either by function ID or identity (key, name, module, version).
+        
+        Usage:
+        
+        ```python
+        >>> from scijob import SciJobClient
+        >>> from scijob.requests import CallFunctionRequestBuilder
+        >>> 
+        >>> client = SciJobClient(...)
+        >>> job = client.call_function(
+        >>>     request=CallFunctionRequestBuilder()
+        >>>         .function_id("your-function-id")
+        >>>         .function_args(...)
+        >>>         .backend(...)
+        >>>         .build()
+        >>> )
+        >>> result = job.get_result()
+        ```
+        """        
+        resp = self._post(url=request.api_url, json=request.json())
+        payload = CallFunctionResponse.model_validate_json(resp.content, strict=True)
+        
+        if verbose:
+            logger.info(
+                f"Created job '{payload.job_id}' | backend={request.backend} | "
+                f"function_id={payload.function_id}"
+            )
+        
+        return JobProxy(
+            id=payload.job_id,
+            backend=request.backend,
+            api_base_url=self._api_base_url,
+            headers=self._headers,
+            poll_interval=self._poll_interval,
+            verbose=verbose,
+        )
+    
+    def submit_volc_job(
+        self,
+        request: SubmitVolcJobRequest,
+        verbose: bool = True,
+    ):
+        """
+        Submit a job to VolcEngine.
+        """
+        resp = self._post(url=f"/job/volc/submit", json=request.json())
+        payload = SubmitVolcJobResponse.model_validate_json(resp.content, strict=True)
+        
+        if verbose:
+            logger.info(f"Submitted job '{payload.job_id}' | volc_job_id={payload.volc_job_id}")
+        
+        return JobProxy(
+            id=payload.job_id,
+            backend="volcengine_ml_platform",
+            api_base_url=self._api_base_url,
+            headers=self._headers,
+            poll_interval=self._poll_interval,
+            verbose=verbose,
+            ignore_result=True,
+        )
+        
+    def submit_volc_dry_run_job(
+        self, 
+        request: SubmitVolcDryRunJobRequest, 
+        verbose: bool = True,
+    ):
+        """
+        Submit a dry run job to VolcEngine.
+        """
+        resp = self._post(url=f"/job/volc/submit-dry-run", json=request.json())
+        payload = SubmitVolcJobResponse.model_validate_json(resp.content, strict=True)
+        
+        if verbose:
+            logger.info(
+                f"Submitted dry run job '{payload.job_id}' | volc_job_id={payload.volc_job_id}"
+            )
+        
+        return JobProxy(
+            id=payload.job_id,
+            backend="volcengine_ml_platform",
+            api_base_url=self._api_base_url,
+            headers=self._headers,
+            poll_interval=self._poll_interval,
+            verbose=verbose,
+        )
+
+
+class AsyncClient(_BaseClient):
+    def __init__(
+        self, 
+        *,
+        api_key: str, 
+        api_base_url: str,
+        poll_interval: Numeric = DEFAULT_POLL_INTERVAL,
+    ):
+        super().__init__(
+            api_key=api_key, 
+            api_base_url=api_base_url, 
+            poll_interval=poll_interval,
+        )
+        self._cli = httpx.AsyncClient(base_url=self._api_base_url, headers=self._headers)
+        
+    async def aclose(self):
+        await self._cli.aclose()
+        
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(
+        self, 
+        exc_type: Optional[Type[BaseException]], 
+        exc_value: Optional[BaseException], 
+        traceback: Optional[TracebackType],
+    ):
+        await self.aclose()
+        
+    async def _get(self, url: str):
+        resp = await self._cli.get(url)
+        if not resp.is_success:
+            raise HttpRequestError(resp)
+        return resp
+    
+    async def _post(self, url: str, json: Any):
+        resp = await self._cli.post(url, json=json)
+        if not resp.is_success:
+            raise HttpRequestError(resp)
+        return resp
+        
+    async def get_function(self, function_id: str):
+        """
+        Get function details by function ID.
+        """
+        resp = await self._get(url=f"/function/{function_id}")
+        return Function.model_validate_json(resp.content, strict=True)
+    
+    async def query_functions(self, request: QueryFunctionsRequest):
+        """
+        Query matched functions by identity information.
+        """
+        
+        # Fetch all matched functions by pagination
+        json = {**request.json(), "page": 1}
+        funcs = []
+        
+        while True:
+            resp = await self._post(url=f"/function/query", json=json)
+            payload: QueryFunctionsResponse = resp.json()
+            funcs.extend(payload["functions"])
+            if payload["has_more"]:
+                json["page"] += 1
+            else:
+                break
+        
+        return [Function.model_validate(fn, strict=True) for fn in funcs]
+    
+    async def register_function(self, request: RegisterFunctionRequest):
+        """
+        Register a new function to job platform.
+        """
+        resp = await self._post(url=f"/function/register", json=request.json())
+        payload = RegisterFunctionResponse.model_validate_json(resp.content, strict=True)
+        logger.info(f"Registered function '{payload.function_id}'")
+        return payload
+    
+    async def delete_function(self, function_id: str):
+        """
+        Delete function by function ID (for admin users only).
+        """
+        await self._post(url=f"/function/delete", json={"id": function_id})
+        logger.info(f"Deleted function '{function_id}'")
+        
+    async def delete_job(self, job_id: str):
+        """
+        Delete job by job ID (for admin users only).
+        """
+        await self._post(url=f"/job/delete", json={"job_id": job_id})
+    
+    async def call_function(
+        self, 
+        request: CallFunctionRequest, 
+        verbose: bool = True,
+    ):
+        """
+        Call function either by function ID or identity (key, name, module, version).
+        
+        Usage:
+        
+        ```python
+        >>> from scijob import AsyncSciJobClient
+        >>> from scijob.requests import CallFunctionRequestBuilder
+        >>> 
+        >>> client = AsyncSciJobClient(...)
+        >>> job = await client.call_function(
+        >>>     request=CallFunctionRequestBuilder()
+        >>>         .function_id("your-function-id")
+        >>>         .function_args(...)
+        >>>         .backend(...)
+        >>>         .build()
+        >>> )
+        >>> result = await job.get_result()
+        ```
+        """        
+        resp = await self._post(url=request.api_url, json=request.json())
+        payload = CallFunctionResponse.model_validate_json(resp.content, strict=True)
+        
+        if verbose:
+            logger.info(
+                f"Created job '{payload.job_id}' | backend={request.backend} | "
+                f"function_id={payload.function_id}"
+            )
+        
+        return AsyncJobProxy(
+            id=payload.job_id,
+            backend=request.backend,
+            api_base_url=self._api_base_url,
+            headers=self._headers,
+            poll_interval=self._poll_interval,
+            verbose=verbose,
+        )
+        
+    async def submit_volc_job(
+        self,
+        request: SubmitVolcJobRequest,
+        verbose: bool = True,
+    ):
+        """
+        Submit a job to VolcEngine.
+        """
+        resp = await self._post(url=f"/job/volc/submit", json=request.json())
+        payload = SubmitVolcJobResponse.model_validate_json(resp.content, strict=True)
+        
+        if verbose:
+            logger.info(f"Submitted job '{payload.job_id}' | volc_job_id={payload.volc_job_id}")
+        
+        return AsyncJobProxy(
+            id=payload.job_id,
+            backend="volcengine_ml_platform",
+            api_base_url=self._api_base_url,
+            headers=self._headers,
+            poll_interval=self._poll_interval,
+            verbose=verbose,
+            ignore_result=True,
+        )
+    
+    async def submit_volc_dry_run_job(
+        self, 
+        request: SubmitVolcDryRunJobRequest, 
+        verbose: bool = True,
+    ):
+        """
+        Submit a dry run job to VolcEngine.
+        """
+        resp = await self._post(url=f"/job/volc/submit-dry-run", json=request.json())
+        payload = SubmitVolcJobResponse.model_validate_json(resp.content, strict=True)
+        
+        if verbose:
+            logger.info(
+                f"Submitted dry run job '{payload.job_id}' | volc_job_id={payload.volc_job_id}"
+            )
+        
+        return AsyncJobProxy(
+            id=payload.job_id,
+            backend="volcengine_ml_platform",
+            api_base_url=self._api_base_url,
+            headers=self._headers,
+            poll_interval=self._poll_interval,
+            verbose=verbose,
+        )

scijob-0.1.0a1/scijob/_config.py

@@ -0,0 +1,3 @@
+API_KEY_HEADER = "X-SciJob-Plat-Api-Key"
+API_VERSION = "v1"
+DEFAULT_POLL_INTERVAL = 5