Method register

src/benchmark/context.py:243–305

Register a benchmark class or instance.

(self, 
                       benchmark: Union[Benchmark, Type[Benchmark]],
                       benchmark_config_dict: Optional[Dict[str, Any]] = None,
                       override: bool = False,
                       version: Optional[str] = None)

        return benchmark_configs

    async def register(self, 
                       benchmark: Union[Benchmark, Type[Benchmark]],
                       benchmark_config_dict: Optional[Dict[str, Any]] = None,
                       override: bool = False,
                       version: Optional[str] = None) -> BenchmarkConfig:
        """Register a benchmark class or instance."""
        try:
            if isinstance(benchmark, Benchmark):
                benchmark_instance = benchmark
                benchmark_cls = type(benchmark)
                if benchmark_config_dict:
                    raise ValueError("Extra configuration not allowed when registering benchmark instances.")
                benchmark_config_dict = {}
            else:
                benchmark_cls = benchmark
                if benchmark_config_dict is None:
                    name_key = inflection.underscore(benchmark_cls.__name__)
                    benchmark_config_dict = config.get(name_key, {})
                
                try:
                    benchmark_instance = benchmark_cls(**benchmark_config_dict)
                except Exception as e:
                    raise ValueError(f"Failed to instantiate benchmark {benchmark_cls.__name__}: {e}")
            
            benchmark_name = benchmark_instance.name
            benchmark_description = benchmark_instance.description
            
            if not benchmark_name:
                raise ValueError("Benchmark.name cannot be empty.")
            
            if benchmark_name in self._benchmark_configs and not override:
                raise ValueError(f"Benchmark '{benchmark_name}' already registered. Use override=True.")
            
            if version is None:
                version = await version_manager.get_version("benchmark", benchmark_name)
                
            code = dynamic_manager.get_full_module_source(benchmark_cls)
            
            benchmark_config = BenchmarkConfig(
                name=benchmark_name,
                description=benchmark_description,
                version=version,
                cls=benchmark_cls,
                config=benchmark_config_dict,
                instance=benchmark_instance if isinstance(benchmark, Benchmark) else None,
                metadata=getattr(benchmark_instance, 'metadata', {}),
                code=code,
            )
            
            self._benchmark_configs[benchmark_name] = benchmark_config
            if benchmark_name not in self._benchmark_history_versions:
                self._benchmark_history_versions[benchmark_name] = {}
            self._benchmark_history_versions[benchmark_name][version] = benchmark_config
            
            await version_manager.register_version("benchmark", benchmark_name, version)
            await self.save_to_json()
            await self.save_contract()