bazis-cli 2.6.0__tar.gz → 2.6.1__tar.gz

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazis-cli
-Version: 2.6.0
+Version: 2.6.1
 Summary: The bazis command: creates, extends and audits Bazis products, backend and frontend, with Claude (Claude Agent SDK).
 Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
 Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/bazis/contrib/cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.6.0'
-__version_tuple__ = version_tuple = (2, 6, 0)
+__version__ = version = '2.6.1'
+__version_tuple__ = version_tuple = (2, 6, 1)
 
-__commit_id__ = commit_id = 'g04ed6b75d'
+__commit_id__ = commit_id = 'g27dcdfabb'

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazis-cli
-Version: 2.6.0
+Version: 2.6.1
 Summary: The bazis command: creates, extends and audits Bazis products, backend and frontend, with Claude (Claude Agent SDK).
 Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
 Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ docs/releases/2.4.0.md
 docs/releases/2.4.1.md
 docs/releases/2.5.0.md
 docs/releases/2.6.0.md
+docs/releases/2.6.1.md
 evals/__init__.py
 evals/grade.py
 evals/run.py

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/scm_file_list.json

@@ -17,6 +17,7 @@
     "docs/releases/2.4.1.md",
     "docs/releases/2.5.0.md",
     "docs/releases/2.6.0.md",
+    "docs/releases/2.6.1.md",
     "evals/__init__.py",
     "evals/grade.py",
     "evals/run.py",

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "2.6.0",
+  "tag": "2.6.1",
   "distance": 0,
-  "node": "g04ed6b75d74ecf9bbfacf5be0bd136fda8106bf7",
+  "node": "g27dcdfabbf66447ef51bf37bdeb01b5ad7ce85f9",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-18"

bazis_cli-2.6.1/docs/releases/2.6.1.md

@@ -0,0 +1,9 @@
+# bazis-cli 2.6.1
+
+## Changes
+
+- The evals grader keeps the settings of the machine (the database and GDAL) and creates
+  the database on the server of the project.
+- The check that the migrations apply does not pass silently: when the database server is
+  unknown or createdb is missing, the check fails.
+- The test of the requirements to the latest releases of bazis and bazis-mcp is restored.

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/evals/grade.py

@@ -51,6 +51,21 @@ BAZIS_CHECK_PREFIXES = (
     'async_request.', 'bg.', 'front.',
 )
 TIMEOUT = 900
+#: the settings of the machine that the agent was given and the project must keep when it is
+#: graded: the PostgreSQL and Redis servers and the GDAL and GEOS libraries. The other `BS_*`
+#: variables are those of the project (its `.env`), the name of the database is the grader's
+MACHINE_SETTINGS = (
+    'BS_DATABASES__DEFAULT__HOST', 'BS_DATABASES__DEFAULT__PORT', 'BS_DATABASES__DEFAULT__USER',
+    'BS_DATABASES__DEFAULT__PASSWORD', 'BS_CACHES__DEFAULT__LOCATION',
+    'BS_GDAL_LIBRARY_PATH', 'BS_GEOS_LIBRARY_PATH',
+)
+#: run by `manage.py shell` of the project: prints the server of its database as JSON
+DATABASE_SERVER = """\
+import json
+from django.conf import settings
+db = settings.DATABASES['default']
+print(json.dumps({key: db.get(key.upper()) or None for key in ('host', 'port', 'user', 'password')}))
+"""
 #: the TSX of `frontend/src/` that a product does not write: the generated screens and the
 #: template (its entry, its app and its login), besides the assets that bazis-front copied
 #: (the files of `assets` in its lock, among them the shadcn components of `components/ui/`)
@@ -132,13 +147,27 @@ def local_apps(project: Path) -> set[str]:
 
 def project_env(database: str) -> dict:
     """
-    The environment of the project: its own .env and project.env, a database of its own.
+    The environment of the project: its own .env and project.env and the settings of the
+    machine (`MACHINE_SETTINGS`), a database of its own.
     """
-    env = {k: v for k, v in os.environ.items() if not k.startswith(('BS_', 'DJANGO_'))}
+    env = {
+        k: v for k, v in os.environ.items()
+        if k in MACHINE_SETTINGS or not k.startswith(('BS_', 'DJANGO_'))
+    }
     env['BS_DATABASES__DEFAULT__NAME'] = database
     return env
 
 
+def postgres_command(program: str, server: dict, *args: str) -> list[str]:
+    """
+    A PostgreSQL client command (`createdb`, `dropdb`) for the server of the project.
+    """
+    command = [program, '-h', server['host'] or 'localhost', '-U', server['user'] or 'postgres']
+    if server['port']:
+        command += ['-p', str(server['port'])]
+    return [*command, *args]
+
+
 def package_warnings(messages: list[dict]) -> list[str]:
     """
     The ids of the warnings of the Bazis packages among the messages of `bazis_doctor`; the
@@ -196,26 +225,7 @@ def grade(project: Path, task: dict) -> list[Check]:
 
     if task.get('frontend'):
         checks += frontend_checks(project, env, task.get('min_scenarios', 1))
-    if shutil.which('createdb'):
-        created = subprocess.run(
-            ['createdb', '-h', 'localhost', '-U', 'postgres', database],
-            env={**env, 'PGPASSWORD': 'postgres'}, capture_output=True, text=True,
-        )
-        try:
-            migrate = run(project, ['manage.py', 'migrate', '--noinput'], env)
-            migrated = created.returncode == 0 and migrate.returncode == 0
-            checks.append(Check(
-                'migrations apply', migrated, created.stderr.strip() or tail(migrate, 6),
-            ))
-            if task.get('frontend'):
-                checks += frontend_database_checks(project, env, migrated)
-        finally:
-            subprocess.run(
-                ['dropdb', '-h', 'localhost', '-U', 'postgres', '--if-exists', '--force', database],
-                env={**env, 'PGPASSWORD': 'postgres'}, capture_output=True,
-            )
-    elif task.get('frontend'):
-        checks += frontend_database_checks(project, env, False, 'no PostgreSQL (createdb)')
+    checks += database_checks(project, env, database, bool(task.get('frontend')))
 
     collected = run(project, ['-m', 'pytest', '--collect-only', '-q', '-p', 'no:cacheprovider'], env)
     count = re.search(r'(\d+) tests? collected', collected.stdout)
@@ -229,6 +239,44 @@ def grade(project: Path, task: dict) -> list[Check]:
     return checks
 
 
+def database_checks(project: Path, env: dict, database: str, frontend: bool) -> list[Check]:
+    """
+    The checks that need the database of the grading: the migrations apply to a database
+    created on the server of the project (dropped afterwards), then the checks of the
+    frontend on it. Without `createdb` or the server of the project they fail with the
+    reason instead of dropping out of the result.
+    """
+    server = None
+    if shutil.which('createdb'):
+        probe = run(project, ['manage.py', 'shell', '-c', DATABASE_SERVER], env)
+        server = mcp_project.parse_json(probe.stdout)
+        reason = 'server of the database: ' + (tail(probe, 6) or 'no output')
+    else:
+        reason = 'no PostgreSQL (createdb)'
+    if not server:
+        checks = [Check('migrations apply', False, reason)]
+        if frontend:
+            checks += frontend_database_checks(project, env, False, reason)
+        return checks
+    client_env = {**env, 'PGPASSWORD': server['password'] or ''}
+    created = subprocess.run(
+        postgres_command('createdb', server, database),
+        env=client_env, capture_output=True, text=True,
+    )
+    try:
+        migrate = run(project, ['manage.py', 'migrate', '--noinput'], env)
+        migrated = created.returncode == 0 and migrate.returncode == 0
+        checks = [Check('migrations apply', migrated, created.stderr.strip() or tail(migrate, 6))]
+        if frontend:
+            checks += frontend_database_checks(project, env, migrated)
+        return checks
+    finally:
+        subprocess.run(
+            postgres_command('dropdb', server, '--if-exists', '--force', database),
+            env=client_env, capture_output=True,
+        )
+
+
 def language_check(project: Path, info: dict, language: str, env: dict) -> Check:
     """
     The product is in the language of its description and in English (`LANGUAGES`), the

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/tests/test_cli.py

@@ -15,6 +15,8 @@
 import io
 import json
 import sys
+import tomllib
+from importlib import metadata
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -615,3 +617,23 @@ def test_change_without_a_terminal(tmp_path, fake_agent, monkeypatch, capsys):
     assert 'bazis change "..."' in capsys.readouterr().err
     assert fake_agent == []
 
+
+def test_requirements_are_the_latest_releases():
+    """
+    The CLI requires at least the releases that bazis-mcp describes: its catalog of the
+    released packages gives bazis, and the installed bazis-mcp is the release of that catalog.
+    """
+    from bazis.contrib.mcp import catalog
+
+    def version(text):
+        return tuple(int(part) for part in text.split('.')[:3])
+
+    installed = metadata.version('bazis-mcp')
+    if 'dev' in installed:
+        pytest.skip(f'bazis-mcp {installed} is not a release')
+    pyproject = tomllib.loads((Path(__file__).parent.parent / 'pyproject.toml').read_text())
+    released = {**{name: entry['version'] for name, entry in catalog.catalog().items()}, 'bazis-mcp': installed}
+    pins = dict(it.split('>=') for it in pyproject['project']['dependencies'] if it.startswith('bazis'))
+    assert pins.keys() == {'bazis', 'bazis-mcp'}
+    for name, minimum in pins.items():
+        assert version(minimum) >= version(released[name]), f'{name}>={minimum}, released {released[name]}'

{bazis_cli-2.6.0 → bazis_cli-2.6.1}/tests/test_evals.py

@@ -12,10 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import contextlib
+import io
 import json
 import os
 import subprocess
+import sys
 import time
+import types
 
 import pytest
 
@@ -98,11 +102,45 @@ def test_local_apps(tmp_path):
 def test_project_env_isolates_the_database(monkeypatch):
     monkeypatch.setenv('BS_DEBUG', 'false')
     monkeypatch.setenv('DJANGO_SETTINGS_MODULE', 'other.settings')
+    monkeypatch.setenv('BS_DATABASES__DEFAULT__NAME', 'other')
     env = grade.project_env('eval_x')
     assert env['BS_DATABASES__DEFAULT__NAME'] == 'eval_x'
     assert 'BS_DEBUG' not in env and 'DJANGO_SETTINGS_MODULE' not in env
 
 
+def test_project_env_keeps_the_settings_of_the_machine(monkeypatch):
+    machine = {
+        'BS_DATABASES__DEFAULT__PORT': '55910', 'BS_GDAL_LIBRARY_PATH': '/opt/lib/libgdal.dylib',
+        'BS_GEOS_LIBRARY_PATH': '/opt/lib/libgeos_c.dylib', 'PGHOST': 'db', 'DYLD_LIBRARY_PATH': '/opt/lib',
+    }
+    for key, value in machine.items():
+        monkeypatch.setenv(key, value)
+    assert machine.items() <= grade.project_env('eval_x').items()
+
+
+def test_database_server_of_the_project(monkeypatch):
+    settings = types.SimpleNamespace(DATABASES={'default': {
+        'HOST': 'db', 'PORT': '55910', 'USER': 'owner', 'PASSWORD': 'secret', 'NAME': 'x',
+    }})
+    monkeypatch.setitem(sys.modules, 'django', types.ModuleType('django'))
+    monkeypatch.setitem(sys.modules, 'django.conf', types.SimpleNamespace(settings=settings))
+    output = io.StringIO()
+    with contextlib.redirect_stdout(output):
+        exec(grade.DATABASE_SERVER, {})
+    server = json.loads(output.getvalue())
+    assert server == {'host': 'db', 'port': '55910', 'user': 'owner', 'password': 'secret'}
+    assert grade.postgres_command('createdb', server, 'eval_x') == [
+        'createdb', '-h', 'db', '-U', 'owner', '-p', '55910', 'eval_x',
+    ]
+
+
+def test_postgres_command_defaults():
+    server = {'host': None, 'port': None, 'user': None, 'password': None}
+    assert grade.postgres_command('dropdb', server, '--force', 'x') == [
+        'dropdb', '-h', 'localhost', '-U', 'postgres', '--force', 'x',
+    ]
+
+
 def test_summary(tmp_path):
     checks = [grade.Check('project loads', True), grade.Check('tests pass', False, 'boom\n1 failed')]
     result = {'task': 'tracker', 'seconds': 120, 'cost_usd': 1.5, 'turns': 30,
@@ -247,6 +285,50 @@ def test_frontend_database_checks_without_a_database(tmp_path):
     ]
 
 
+def probe_stub(monkeypatch, output: str, returncode: int = 0):
+    monkeypatch.setattr(grade.shutil, 'which', lambda name: '/usr/bin/createdb')
+    monkeypatch.setattr(grade, 'run', lambda project, args, env: done(returncode, output))
+
+
+@pytest.mark.parametrize('frontend', [False, True])
+@pytest.mark.parametrize('output', ['Traceback: no module', 'not json'])
+def test_database_checks_fail_when_the_server_is_unknown(tmp_path, monkeypatch, frontend, output):
+    probe_stub(monkeypatch, output, 1)
+    project = product(tmp_path, 1)
+    checks = grade.database_checks(project, {}, 'eval_x', frontend)
+    reason = 'server of the database: ' + output
+    expected = [('migrations apply', False, reason)]
+    if frontend:
+        expected += [('contract fresh', False, reason), ('end-to-end tests pass', False, reason)]
+    assert [(c.name, c.passed, c.detail) for c in checks] == expected
+
+
+@pytest.mark.parametrize('frontend', [False, True])
+def test_database_checks_without_createdb(tmp_path, monkeypatch, frontend):
+    monkeypatch.setattr(grade.shutil, 'which', lambda name: None)
+    monkeypatch.setattr(grade, 'run', lambda *a: pytest.fail('the server must not be probed'))
+    checks = grade.database_checks(product(tmp_path, 1), {}, 'eval_x', frontend)
+    assert [(c.name, c.passed, c.detail) for c in checks][0] == (
+        'migrations apply', False, 'no PostgreSQL (createdb)',
+    )
+    assert len(checks) == (3 if frontend else 1)
+
+
+def test_database_checks_create_migrate_and_drop(tmp_path, monkeypatch):
+    server = {'host': 'db', 'port': None, 'user': 'owner', 'password': 'secret'}
+    probe_stub(monkeypatch, json.dumps(server))
+    commands = []
+
+    def fake_subprocess(command, **kwargs):
+        commands.append(command[0])
+        return subprocess.CompletedProcess(command, 0, '', '')
+
+    monkeypatch.setattr(grade.subprocess, 'run', fake_subprocess)
+    checks = grade.database_checks(tmp_path, {}, 'eval_x', False)
+    assert [(c.name, c.passed) for c in checks] == [('migrations apply', True)]
+    assert commands == ['createdb', 'dropdb']
+
+
 def test_end_to_end_needs_the_test_data(tmp_path, monkeypatch):
     monkeypatch.setattr(grade, 'run', lambda project, args, env: done(1, 'Unknown command: e2e_data'))
     check = grade.end_to_end(product(tmp_path, 1), {})