93 lines
4.4 KiB
Python
93 lines
4.4 KiB
Python
"""Baseline and launcher checks requiring only Python's standard library."""
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import sys
|
|
import tempfile
|
|
from types import ModuleType, SimpleNamespace
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
|
|
|
|
def load(name, relative):
|
|
spec = importlib.util.spec_from_file_location(name, ROOT / relative)
|
|
module = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(module)
|
|
return module
|
|
|
|
|
|
baseline = load('parser_baseline_check', 'scripts/check_parser_baseline.py')
|
|
launcher = load('parser_launch_check', 'scripts/run_parser.py')
|
|
|
|
|
|
class ParserBaselineTests(unittest.TestCase):
|
|
def test_entire_kernel_matches_the_official_271_package(self):
|
|
self.assertEqual(baseline.check(), {'version': '2.7.1', 'official_files': 187, 'kernel_modifications': 0})
|
|
|
|
def test_modified_or_extra_source_is_rejected(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
root = Path(folder)
|
|
shutil.copytree(ROOT / 'mineru', root / 'mineru', ignore=shutil.ignore_patterns('__pycache__', '*.pyc'))
|
|
(root / 'docs/mineru-migration').mkdir(parents=True)
|
|
shutil.copyfile(ROOT / 'docs/mineru-migration/2.7.1-baseline.json', root / 'docs/mineru-migration/2.7.1-baseline.json')
|
|
source = root / 'mineru/version.py'
|
|
original = source.read_bytes()
|
|
source.write_bytes(original + b'\n# custom patch\n')
|
|
with self.assertRaisesRegex(ValueError, 'source differs'):
|
|
baseline.check(root)
|
|
source.write_bytes(original)
|
|
(root / 'mineru/retired_custom_api.py').write_text('')
|
|
with self.assertRaisesRegex(ValueError, 'file set differs'):
|
|
baseline.check(root)
|
|
|
|
def launch(self, version='2.7.1', path=None, args=None, memory='0.5'):
|
|
package = ModuleType('mineru'); package.__file__ = str(path or ROOT / 'mineru/__init__.py')
|
|
release = ModuleType('mineru.version'); release.__version__ = version
|
|
api = ModuleType('mineru.cli.fast_api'); api.app = SimpleNamespace(state=SimpleNamespace())
|
|
cli = ModuleType('mineru.utils.cli_parser')
|
|
cli.arg_parse = lambda ctx: {ctx.args[i][2:].replace('-', '_'): ctx.args[i + 1] for i in range(0, len(ctx.args), 2)}
|
|
server = ModuleType('uvicorn')
|
|
captured = {}
|
|
def run(app, **kwargs):
|
|
captured.update(config=app.state.config, server=kwargs,
|
|
concurrency=os.environ['MINERU_API_MAX_CONCURRENT_REQUESTS'])
|
|
server.run = run
|
|
with patch.dict(sys.modules, {'mineru': package, 'mineru.version': release, 'mineru.cli.fast_api': api,
|
|
'mineru.utils.cli_parser': cli, 'uvicorn': server}), \
|
|
patch.dict(os.environ, {'MINERU_GPU_MEMORY_UTILIZATION': memory, 'MINERU_API_MAX_CONCURRENT_REQUESTS': '1'}, clear=True), \
|
|
patch.object(sys, 'argv', ['run_parser.py', *(args or [])]):
|
|
launcher.main()
|
|
return captured
|
|
|
|
def test_deployment_options_are_forwarded_without_kernel_patches(self):
|
|
args = self.launch()
|
|
self.assertEqual(args['concurrency'], '1')
|
|
self.assertEqual(args['config'], {'gpu_memory_utilization': 0.5})
|
|
explicit = self.launch(args=['--gpu-memory-utilization=0.4'])
|
|
self.assertEqual(explicit['config'], {'gpu_memory_utilization': 0.4})
|
|
|
|
def test_api_flags_never_leak_into_vllm_engine_arguments(self):
|
|
result = self.launch(args=['--host', '0.0.0.0', '--port', '8100',
|
|
'--mineru-api-max-concurrent-requests=2', '--tensor-parallel-size=2'])
|
|
self.assertEqual(result['server'], {'host': '0.0.0.0', 'port': 8100})
|
|
self.assertEqual(result['concurrency'], '2')
|
|
self.assertEqual(result['config'], {'tensor_parallel_size': '2', 'gpu_memory_utilization': 0.5})
|
|
|
|
def test_wrong_version_or_import_path_is_rejected(self):
|
|
for kwargs in ({'version': '2.7.4'}, {'path': ROOT / 'other/mineru/__init__.py'}):
|
|
with self.subTest(kwargs=kwargs), self.assertRaises(RuntimeError):
|
|
self.launch(**kwargs)
|
|
|
|
def test_invalid_memory_limit_is_rejected(self):
|
|
for value in ('0', '1', 'invalid'):
|
|
with self.subTest(value=value), self.assertRaises(ValueError):
|
|
self.launch(memory=value)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|