dbos-enterprise 0.1.0a2__tar.gz

dbos_enterprise-0.1.0a2/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2026 DBOS, Inc. All rights reserved.
+
+This software is licensed under the DBOS Conductor Software License:
+
+    https://www.dbos.dev/conductor-license

dbos_enterprise-0.1.0a2/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: dbos-enterprise
+Version: 0.1.0a2
+Summary: Enterprise extension for DBOS Transact
+Author-Email: "DBOS, Inc." <contact@dbos.dev>
+License: DBOS Conductor Software License (https://www.dbos.dev/conductor-license)
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: dbos<3.3,>=3.2.0a0
+Requires-Dist: websockets>=14.0
+Description-Content-Type: text/markdown
+
+# DBOS Enterprise for Python
+
+Closed-source extension of [DBOS Transact](https://github.com/dbos-inc/dbos-transact-py).
+Requires a DBOS Conductor API key.
+
+```
+pip install dbos[enterprise]
+```
+
+See [DEVELOPING.md](./DEVELOPING.md) to work on this repo.

dbos_enterprise-0.1.0a2/README.md

@@ -0,0 +1,10 @@
+# DBOS Enterprise for Python
+
+Closed-source extension of [DBOS Transact](https://github.com/dbos-inc/dbos-transact-py).
+Requires a DBOS Conductor API key.
+
+```
+pip install dbos[enterprise]
+```
+
+See [DEVELOPING.md](./DEVELOPING.md) to work on this repo.

dbos_enterprise-0.1.0a2/dbos_enterprise/__init__.py

@@ -0,0 +1,7 @@
+from importlib.metadata import version
+
+from ._version import DBOSEnterpriseVersionError, check_core_version
+
+__version__ = version("dbos-enterprise")
+
+__all__ = ["DBOSEnterpriseVersionError", "check_core_version", "__version__"]

dbos_enterprise-0.1.0a2/dbos_enterprise/_scratch.py

@@ -0,0 +1,22 @@
+"""Scratch code proving the package can reach core internals. Delete when real code lands."""
+
+from typing import TypedDict
+
+from dbos._utils import GlobalParams
+
+
+class ExecutorInfo(TypedDict):
+    app_name: str | None
+    app_version: str
+    executor_id: str
+    dbos_version: str
+
+
+def describe_executor() -> ExecutorInfo:
+    """Report the identity core assigns this process at launch."""
+    return {
+        "app_name": GlobalParams.app_name,
+        "app_version": GlobalParams.app_version,
+        "executor_id": GlobalParams.executor_id,
+        "dbos_version": GlobalParams.dbos_version,
+    }

dbos_enterprise-0.1.0a2/dbos_enterprise/_version.py

@@ -0,0 +1,24 @@
+import re
+from importlib.metadata import version
+
+_MAJOR_MINOR = re.compile(r"^(\d+)\.(\d+)")
+
+
+class DBOSEnterpriseVersionError(Exception):
+    """dbos and dbos-enterprise are installed at different minor versions."""
+
+
+def _major_minor(package: str) -> tuple[int, int]:
+    match = _MAJOR_MINOR.match(version(package))
+    assert match is not None, f"unparseable version for {package}"
+    return int(match.group(1)), int(match.group(2))
+
+
+def check_core_version() -> None:
+    """Raise unless dbos and dbos-enterprise share a major.minor version."""
+    core, enterprise = _major_minor("dbos"), _major_minor("dbos-enterprise")
+    if core != enterprise:
+        raise DBOSEnterpriseVersionError(
+            f"dbos {version('dbos')} and dbos-enterprise {version('dbos-enterprise')} "
+            "must share a minor version; upgrade both with `pip install -U dbos[enterprise]`."
+        )

dbos_enterprise-0.1.0a2/pyproject.toml

@@ -0,0 +1,93 @@
+[project]
+name = "dbos-enterprise"
+dynamic = []
+description = "Enterprise extension for DBOS Transact"
+authors = [
+    { name = "DBOS, Inc.", email = "contact@dbos.dev" },
+]
+dependencies = [
+    "dbos>=3.2.0a0,<3.3",
+    "websockets>=14.0",
+]
+requires-python = ">=3.10"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Intended Audience :: Developers",
+    "License :: Other/Proprietary License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+version = "0.1.0a2"
+
+[project.license]
+text = "DBOS Conductor Software License (https://www.dbos.dev/conductor-license)"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.build]
+includes = [
+    "dbos_enterprise/",
+]
+source-includes = [
+    "tests/",
+    "version/",
+]
+
+[tool.pdm.version]
+source = "scm"
+version_format = "version:format_version"
+
+[tool.black]
+line-length = 88
+
+[tool.isort]
+profile = "black"
+filter_files = true
+atomic = true
+
+[tool.mypy]
+strict = true
+
+[tool.pytest.ini_options]
+addopts = "-s"
+log_cli_format = "%(asctime)s [%(levelname)8s] (%(name)s:%(filename)s:%(lineno)s) %(message)s"
+log_cli_level = "INFO"
+log_cli = true
+timeout = 120
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.3",
+    "mypy>=1.15.0",
+    "pytest-mock>=3.14.0",
+    "black>=24.10.0",
+    "pre-commit>=4.0.1",
+    "isort>=5.13.2",
+    "GitPython>=3.1.43",
+    "pdm-backend>=2.4.2",
+    "pytest-asyncio>=0.25.0",
+    "pyright>=1.1.398",
+    "pytest-timeout>=2.3.1",
+    "psycopg[binary]>=3.1",
+    "types-PyYAML>=6.0.12.20240808",
+    "types-python-dateutil>=2.9.0.20260518",
+]
+core = [
+    "-e file:///${PROJECT_ROOT}/../dbos-transact-py",
+]

dbos_enterprise-0.1.0a2/tests/conftest.py

@@ -0,0 +1,92 @@
+import os
+import sqlite3
+from pathlib import Path
+from typing import Any, Generator
+from urllib.parse import quote
+
+import pytest
+import sqlalchemy as sa
+from dbos import DBOS, DBOSConfig
+from dbos._utils import GlobalParams
+
+
+def using_sqlite() -> bool:
+    return os.environ.get("DBOS_DATABASE", None) == "SQLITE"
+
+
+@pytest.fixture()
+def skip_with_sqlite() -> None:
+    if using_sqlite():
+        pytest.skip("Skipping test when testing SQLite")
+
+
+def postgres_system_url() -> str:
+    password = quote(os.environ.get("PGPASSWORD", "dbos"), safe="")
+    return f"postgresql+psycopg://postgres:{password}@localhost:5432/dbosenterprise_test_dbos_sys"
+
+
+@pytest.fixture()
+def sqlite_path(tmp_path: Path) -> Path:
+    # WAL mode, so a committing writer never stalls the notification poller.
+    db_path = tmp_path / "test.sqlite"
+    connection = sqlite3.connect(db_path)
+    try:
+        connection.execute("PRAGMA journal_mode=WAL")
+    finally:
+        connection.close()
+    return db_path
+
+
+@pytest.fixture()
+def config(sqlite_path: Path) -> DBOSConfig:
+    return {
+        "name": "enterprise-test-app",
+        "system_database_url": (
+            f"sqlite:///{sqlite_path}" if using_sqlite() else postgres_system_url()
+        ),
+        "enable_otlp": False,
+        "notification_listener_polling_interval_sec": 0.01,
+    }
+
+
+def reset_global_params() -> None:
+    GlobalParams.app_version = os.environ.get("DBOS__APPVERSION", "")
+    GlobalParams.executor_id = os.environ.get("DBOS__VMID") or "local"
+    GlobalParams.app_name = None
+
+
+@pytest.fixture(autouse=True)
+def clean_process_identity() -> Generator[None, Any, None]:
+    yield
+    reset_global_params()
+
+
+def _drop_system_database() -> None:
+    # Each test migrates from scratch; the suite is small enough for that.
+    DBOS.destroy(destroy_registry=True)
+    for var in ("DBOS__VMID", "DBOS__APPVERSION", "DBOS__APPID"):
+        os.environ.pop(var, None)
+    reset_global_params()
+    if using_sqlite():
+        return
+    url = sa.make_url(postgres_system_url())
+    engine = sa.create_engine(
+        url.set(database="postgres"), connect_args={"connect_timeout": 30}
+    )
+    try:
+        with engine.connect() as connection:
+            connection.execution_options(isolation_level="AUTOCOMMIT")
+            connection.execute(
+                sa.text(f"DROP DATABASE IF EXISTS {url.database} WITH (FORCE)")
+            )
+    finally:
+        engine.dispose()
+
+
+@pytest.fixture()
+def dbos(config: DBOSConfig) -> Generator[DBOS, Any, None]:
+    _drop_system_database()
+    dbos = DBOS(config=config)
+    DBOS.launch()
+    yield dbos
+    DBOS.destroy(destroy_registry=True)

dbos_enterprise-0.1.0a2/tests/test_scratch.py

@@ -0,0 +1,24 @@
+from dbos import DBOS
+
+from dbos_enterprise._scratch import describe_executor
+
+
+def test_workflow_runs_against_core(dbos: DBOS) -> None:
+    @DBOS.step()
+    def greet_step(name: str) -> str:
+        return f"hello, {name}"
+
+    @DBOS.workflow()
+    def greet(name: str) -> str:
+        return greet_step(name)
+
+    assert greet("enterprise") == "hello, enterprise"
+    steps = DBOS.list_workflow_steps(DBOS.list_workflows()[0].workflow_id)
+    assert [s["function_name"] for s in steps] == [greet_step.__qualname__]
+
+
+def test_describe_executor(dbos: DBOS) -> None:
+    info = describe_executor()
+    assert info["app_name"] == "enterprise-test-app"
+    assert info["executor_id"] == "local"
+    assert info["dbos_version"]

dbos_enterprise-0.1.0a2/tests/test_version.py

@@ -0,0 +1,38 @@
+import pytest
+
+from dbos_enterprise import (
+    DBOSEnterpriseVersionError,
+    __version__,
+    _version,
+    check_core_version,
+)
+
+
+def _fake_version(versions: dict[str, str]) -> "type[object]":
+    def fake(package: str) -> str:
+        return versions[package]
+
+    return fake  # type: ignore[return-value]
+
+
+def test_matching_minor_passes(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        _version,
+        "version",
+        _fake_version({"dbos": "3.4.1", "dbos-enterprise": "3.4.0"}),
+    )
+    check_core_version()
+
+
+def test_mismatched_minor_raises(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        _version,
+        "version",
+        _fake_version({"dbos": "3.5.0", "dbos-enterprise": "3.4.0"}),
+    )
+    with pytest.raises(DBOSEnterpriseVersionError, match="share a minor version"):
+        check_core_version()
+
+
+def test_package_reports_a_version() -> None:
+    assert __version__

dbos_enterprise-0.1.0a2/version/__init__.py

@@ -0,0 +1,45 @@
+from pdm.backend.hooks.version import SCMVersion
+
+
+def format_version(git_version: SCMVersion) -> str:
+    """
+    Format version into string.
+
+    1. Release versions may only be published from release branches. Their version is a git tag.
+    2. Preview versions are published from main. They are PEP440 alpha releases whose version is the
+    next release version number followed by "a" followed by the number of commits since the last release.
+    If the last release was 1.2.3 and there have been ten commits since, the preview version is 1.2.3a10
+    3. Test versions are published from feature branches. They are PEP440 local versions tagged with a git hash.
+    """
+    assert git_version.branch is not None
+    is_release = "release" in git_version.branch
+    is_preview = git_version.branch == "main"
+
+    next_version = guess_next_version(str(git_version.version))
+
+    if git_version.distance is None:
+        if is_release:
+            version = str(git_version.version)
+        elif is_preview:
+            version = f"{next_version}a0"
+        else:
+            version = f"{next_version}a0+{git_version.node}"
+    else:
+        if is_release:
+            raise Exception(
+                f"Release branches may only publish tagged releases. Distance: {git_version.distance}"
+            )
+        elif is_preview:
+            version = f"{next_version}a{git_version.distance}"
+        else:
+            version = f"{next_version}a{git_version.distance}+{git_version.node}"
+
+    return version
+
+
+def guess_next_version(version_number: str) -> str:
+    # A repo with no release tag yet reports "0.0"; pad it to three parts.
+    parts = [int(part) for part in version_number.split(".")]
+    major, minor, patch = (parts + [0, 0, 0])[:3]
+    minor += 1
+    return f"{major}.{minor}.{patch}"