evalscope 0.16.0__py3-none-any.whl → 0.16.2__py3-none-any.whl

evalscope/perf/benchmark.py

@@ -1,11 +1,8 @@
 import asyncio
-import copy
 import json
 import numpy as np
-import os
 import platform
 import sqlite3
-import threading
 import time
 from http import HTTPStatus
 from tqdm import tqdm
@@ -17,7 +14,6 @@ from evalscope.perf.plugin.registry import ApiRegistry, DatasetRegistry
 from evalscope.perf.utils.benchmark_util import BenchmarkData, BenchmarkMetrics
 from evalscope.perf.utils.db_util import create_result_table, get_result_db_path, insert_benchmark_data, summary_result
 from evalscope.perf.utils.handler import add_signal_handlers, exception_handler
-from evalscope.perf.utils.local_server import start_app
 from evalscope.utils.logger import get_logger
 
 logger = get_logger()
@@ -45,14 +41,27 @@ async def get_requests(args: Arguments) -> AsyncGenerator[dict, None]:
         message_generator_class = DatasetRegistry(args.dataset)
         message_generator = message_generator_class(args)
 
+        dataset_messages = []
+        try:
+            for messages in message_generator:
+                dataset_messages.append(messages)
+        except StopIteration:
+            pass
+
+        if not dataset_messages:
+            raise Exception('Dataset is empty!')
+
         count = 0
-        for messages in message_generator:
+        dataset_index = 0
+
+        while count < args.number:
+            messages = dataset_messages[dataset_index]
             request = query_generator.build_request(messages, args)
             if request is not None:
                 yield request
                 count += 1
-                if args.number and count >= args.number:
-                    break
+
+            dataset_index = (dataset_index + 1) % len(dataset_messages)
 
     if args.prompt:
         prompt = load_prompt(args.prompt)
@@ -164,11 +173,6 @@ async def statistic_benchmark_metric(benchmark_data_queue: asyncio.Queue, args:
 
 @exception_handler
 async def connect_test(args: Arguments) -> bool:
-    if args.api.startswith('local'):
-        #  start local server
-        server = threading.Thread(target=start_app, args=(copy.deepcopy(args), ), daemon=True)
-        server.start()
-
     if (not args.no_test_connection) and (not await test_connection(args)):
         raise TimeoutError('Test connection failed')
 

evalscope/perf/main.py

@@ -2,9 +2,11 @@ import asyncio
 import copy
 import os
 import platform
+import threading
 import time
 from argparse import Namespace
 
+from evalscope.perf.utils.local_server import start_app
 from evalscope.perf.utils.log_utils import init_swanlab, init_wandb
 from evalscope.utils.logger import configure_logging, get_logger
 from evalscope.utils.utils import seed_everything
@@ -82,6 +84,11 @@ def run_perf_benchmark(args):
     if args.swanlab_api_key:
         init_swanlab(args)
 
+    # Initialize local server if needed
+    if args.api.startswith('local'):
+        #  start local server
+        server = threading.Thread(target=start_app, args=(copy.deepcopy(args), ), daemon=True)
+        server.start()
     # Start benchmark
     if len(args.number) == 1:
         return run_one_benchmark(args, output_path=output_path)

evalscope/perf/plugin/api/openai_api.py

@@ -75,6 +75,8 @@ class OpenaiPlugin(ApiPluginBase):
             payload['min_tokens'] = param.min_tokens
         if param.frequency_penalty is not None:
             payload['frequency_penalty'] = param.frequency_penalty
+        if param.repetition_penalty is not None:
+            payload['repetition_penalty'] = param.repetition_penalty
         if param.logprobs is not None:
             payload['logprobs'] = param.logprobs
         if param.n_choices is not None:

evalscope/perf/plugin/datasets/custom.py

@@ -22,3 +22,18 @@ class CustomDatasetPlugin(DatasetPluginBase):
                     yield [{'role': 'user', 'content': prompt}]
                 else:
                     yield prompt
+
+
+if __name__ == '__main__':
+    from evalscope.perf.arguments import Arguments
+    from evalscope.perf.main import run_perf_benchmark
+
+    args = Arguments(
+        model='qwen2.5-7b-instruct',
+        url='https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions',
+        dataset_path='outputs/perf_data.txt',
+        api_key='EMPTY',
+        dataset='custom',
+    )
+
+    run_perf_benchmark(args)

evalscope/perf/utils/benchmark_util.py

@@ -38,7 +38,7 @@ class BenchmarkData:
             self.first_chunk_latency = self.query_latency
             self.n_chunks = 1
             self.n_chunks_time = self.query_latency
-        self.time_per_output_token = self.n_chunks_time / self.completion_tokens
+        self.time_per_output_token = self.n_chunks_time / self.n_chunks
 
     def _calculate_tokens(self, api_plugin):
         self.prompt_tokens, self.completion_tokens = \

evalscope/perf/utils/local_server.py

@@ -96,6 +96,7 @@ def create_app(model, attn_implementation=None) -> FastAPI:
 
 
 def start_app(args: Arguments):
+    logger.info('Starting local server, please wait...')
     if args.api == 'local':
         app = create_app(args.model, args.attn_implementation)
         uvicorn.run(app, host='0.0.0.0', port=args.port, workers=1)

evalscope/perf/utils/log_utils.py

@@ -34,8 +34,15 @@ def init_swanlab(args: Arguments) -> None:
     current_time = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
     name = args.name if args.name else f'{args.model_id}_{current_time}'
     swanlab.config.update({'framework': '📏evalscope'})
-    swanlab.init(
-        project=os.getenv('SWANLAB_PROJ_NAME', 'perf_benchmark'),
-        name=name,
-        config=args.to_dict(),
-        mode='local' if args.swanlab_api_key == 'local' else None)
+    init_kwargs = {
+        'project': os.getenv('SWANLAB_PROJ_NAME', 'perf_benchmark'),
+        'name': name,
+        'config': args.to_dict(),
+        'mode': 'local' if args.swanlab_api_key == 'local' else None
+    }
+
+    workspace = os.getenv('SWANLAB_WORKSPACE')
+    if workspace:
+        init_kwargs['workspace'] = workspace
+
+    swanlab.init(**init_kwargs)

evalscope/perf/utils/rich_display.py

@@ -92,7 +92,7 @@ def print_summary(all_results, model_name):
     basic_info.add_row('Model', model_name)
     basic_info.add_row('Total Generated', f'{total_tokens:,} tokens')
     basic_info.add_row('Total Test Time', f'{total_time:.2f} seconds')
-    basic_info.add_row('Avg Output Rate', f'{total_tokens/total_time:.2f} tokens/sec')
+    basic_info.add_row('Avg Output Rate', f'{total_tokens / total_time:.2f} tokens/sec')
 
     console.print('\nBasic Information:')
     console.print(basic_info)

evalscope/report/__init__.py

@@ -1,6 +1,38 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
+from typing import TYPE_CHECKING
 
-from evalscope.report.app_arguments import add_argument
-from evalscope.report.combinator import gen_table, get_data_frame, get_report_list
-from evalscope.report.generator import ReportGenerator
-from evalscope.report.utils import Category, Report, ReportKey, Subset
+from evalscope.utils.import_utils import _LazyModule
+
+if TYPE_CHECKING:
+    from .combinator import gen_report_table, gen_table, get_data_frame, get_report_list
+    from .generator import ReportGenerator
+    from .utils import Category, Report, ReportKey, Subset
+
+else:
+    _import_structure = {
+        'combinator': [
+            'gen_table',
+            'get_data_frame',
+            'get_report_list',
+            'gen_report_table',
+        ],
+        'generator': [
+            'ReportGenerator',
+        ],
+        'utils': [
+            'Category',
+            'Report',
+            'ReportKey',
+            'Subset',
+        ],
+    }
+
+    import sys
+
+    sys.modules[__name__] = _LazyModule(
+        __name__,
+        globals()['__file__'],
+        _import_structure,
+        module_spec=__spec__,
+        extra_objects={},
+    )

evalscope/report/combinator.py

@@ -34,17 +34,51 @@ def get_report_list(reports_path_list: List[str]) -> List[Report]:
 
 def get_data_frame(report_list: List[Report],
                    flatten_metrics: bool = True,
-                   flatten_categories: bool = True) -> pd.DataFrame:
+                   flatten_categories: bool = True,
+                   add_overall_metric: bool = False) -> pd.DataFrame:
     tables = []
     for report in report_list:
-        df = report.to_dataframe(flatten_metrics=flatten_metrics, flatten_categories=flatten_categories)
+        df = report.to_dataframe(
+            flatten_metrics=flatten_metrics,
+            flatten_categories=flatten_categories,
+            add_overall_metric=add_overall_metric)
         tables.append(df)
     return pd.concat(tables, ignore_index=True)
 
 
-def gen_table(reports_path_list: list) -> str:
-    report_list = get_report_list(reports_path_list)
-    table = get_data_frame(report_list)
+def gen_table(reports_path_list: list[str] = None,
+              report_list: list[Report] = None,
+              flatten_metrics: bool = True,
+              flatten_categories: bool = True,
+              add_overall_metric: bool = False) -> str:
+    """
+    Generates a formatted table from a list of report paths or Report objects.
+
+    Args:
+        reports_path_list (list[str], optional): List of file paths to report files.
+            Either this or `report_list` must be provided.
+        report_list (list[Report], optional): List of Report objects.
+            Either this or `reports_path_list` must be provided.
+        flatten_metrics (bool, optional): Whether to flatten the metrics in the output table. Defaults to True.
+        flatten_categories (bool, optional): Whether to flatten the categories in the output table. Defaults to True.
+        add_overall_metric (bool, optional): Whether to add an overall metric column to the table. Defaults to False.
+
+    Returns:
+        str: A string representation of the table in grid format.
+
+    Raises:
+        AssertionError: If neither `reports_path_list` nor `report_list` is provided.
+    """
+    assert (reports_path_list is not None) or (report_list is not None), \
+        'Either reports_path_list or report_list must be provided.'
+    if report_list is None:
+        report_list = get_report_list(reports_path_list)
+    # Generate a DataFrame from the report list
+    table = get_data_frame(
+        report_list,
+        flatten_metrics=flatten_metrics,
+        flatten_categories=flatten_categories,
+        add_overall_metric=add_overall_metric)
     return tabulate(table, headers=table.columns, tablefmt='grid', showindex=False)
 
 
@@ -60,7 +94,7 @@ if __name__ == '__main__':
     report_dir_1 = './outputs/20250117_151926'
     # report_dir_2 = './outputs/20250107_204445/reports'
 
-    report_table = gen_table([report_dir_1])
+    report_table = gen_table(reports_path_list=[report_dir_1])
     print(report_table)
 
     # ALL VALUES ONLY FOR EXAMPLE

evalscope/report/generator.py

@@ -1,24 +1,42 @@
 import pandas as pd
 from pandas import DataFrame
+from typing import TYPE_CHECKING
 
 from evalscope.constants import DataCollection
 from evalscope.report.utils import *
 
+if TYPE_CHECKING:
+    from evalscope.benchmarks import DataAdapter
+
 
 class ReportGenerator:
 
     @staticmethod
-    def gen_report(subset_score_map: dict, report_name: str, **kwargs) -> Report:
+    def gen_report(subset_score_map: dict, model_name: str, data_adapter: 'DataAdapter', **kwargs) -> Report:
         """
-        Generate report for specific dataset.
-        subset_score_map: e.g. {subset_name: [{'metric_name': 'AverageAccuracy', 'score': 0.3389, 'num': 100}, {'metric_name': 'WeightedAverageAccuracy', 'score': 0.3389, 'num': 100}]}
-        category_map: e.g. {'subset_name': ['category_name1', 'category_name2'], ...}
-        metric_list: e.g. [{'object': AverageAccuracy, 'name': 'AverageAccuracy'}, {'object': 'WeightedAverageAccuracy', 'name': 'WeightedAverageAccuracy'}]
+        Generate a report for a specific dataset based on provided subset scores.
+
+        Args:
+            subset_score_map (dict): A mapping from subset names to a list of score dictionaries.
+                    {
+                        'subset_name': [
+                            {'metric_name': 'AverageAccuracy', 'score': 0.3389, 'num': 100},
+                            {'metric_name': 'WeightedAverageAccuracy', 'score': 0.3389, 'num': 100}
+                        ],
+                        ...
+                    }
+            report_name (str): The name of the report to generate.
+            data_adapter (DataAdapter): An adapter object for data handling.
+
+        Returns:
+            Report: A structured report object containing metrics, categories, and subsets.
+
+            >>> report = gen_report(subset_score_map, "My Report", data_adapter, dataset_name="Dataset", model_name="Model")
         """  # noqa: E501
 
-        dataset_name = kwargs.get('dataset_name', None)
-        model_name = kwargs.get('model_name', None)
-        category_map = kwargs.get('category_map', {})
+        dataset_name = data_adapter.name
+        category_map = data_adapter.category_map
+        report_name = f'{model_name}@{dataset_name}'
 
         def flatten_subset() -> DataFrame:
             """
@@ -59,7 +77,13 @@ class ReportGenerator:
 
             metrics_list.append(Metric(name=metric_name, categories=categories))
 
-        report = Report(name=report_name, metrics=metrics_list, dataset_name=dataset_name, model_name=model_name)
+        report = Report(
+            name=report_name,
+            metrics=metrics_list,
+            dataset_name=dataset_name,
+            model_name=model_name,
+            dataset_description=data_adapter.description,
+            dataset_pretty_name=data_adapter.pretty_name)
         return report
 
     @staticmethod

evalscope/report/utils.py

@@ -1,4 +1,5 @@
 import json
+import os
 import pandas as pd
 from collections import defaultdict
 from dataclasses import asdict, dataclass, field
@@ -6,6 +7,9 @@ from typing import Any, Dict, List
 
 from evalscope.metrics import macro_mean, micro_mean
 from evalscope.utils import normalize_score
+from evalscope.utils.logger import get_logger
+
+logger = get_logger()
 
 
 @dataclass
@@ -70,13 +74,28 @@ class ReportKey:
     score = 'Score'
 
 
+ANALYSIS_PROMPT = """根据给出的json格式的模型评测结果，输出分析报告，要求如下：
+1. 报告分为 总体表现、关键指标分析、改进建议、结论 四部分
+2. 若模型有多种指标，将其分为低分、中分、高分三个部分，并列出markdown表格
+3. 只列出报告本身，不要有其他多余内容
+4. 输出报告语言为{language}
+
+```json
+{report_str}
+```
+"""
+
+
 @dataclass
 class Report:
     name: str = 'default_report'
     dataset_name: str = 'default_dataset'
+    dataset_pretty_name: str = ''
+    dataset_description: str = ''
     model_name: str = 'default_model'
     score: float = 0.0
     metrics: List[Metric] = field(default_factory=list)
+    analysis: str = 'N/A'
 
     def __post_init__(self):
         self.score = self.metrics[0].score  # NOTE: only use the first metric by default
@@ -84,15 +103,29 @@ class Report:
     def to_dict(self) -> Dict[str, Any]:
         return asdict(self)
 
+    def to_json_str(self) -> str:
+        return json.dumps(self.to_dict(), indent=4, ensure_ascii=False)
+
+    def to_json(self, json_file: str):
+        # ensure the directory exists
+        os.makedirs(os.path.dirname(json_file), exist_ok=True)
+        # write the report to a json file
+        with open(json_file, 'w', encoding='utf-8') as f:
+            json.dump(self.to_dict(), f, indent=4, ensure_ascii=False)
+
     @classmethod
     def from_dict(cls, data: dict):
         metrics = [Metric.from_dict(metric) for metric in data.get('metrics', [])]
         return cls(
             name=data['name'],
+            dataset_name=data['dataset_name'],
+            dataset_pretty_name=data.get('dataset_pretty_name'),
+            dataset_description=data.get('dataset_description'),
             score=data['score'],
+            model_name=data['model_name'],
             metrics=metrics,
-            dataset_name=data['dataset_name'],
-            model_name=data['model_name'])
+            analysis=data.get('analysis', 'N/A'),
+        )
 
     @classmethod
     def from_json(cls, json_file: str):
@@ -100,18 +133,41 @@ class Report:
             data = json.load(f)
         return cls.from_dict(data)
 
-    def to_dataframe(self, flatten_metrics: bool = True, flatten_categories: bool = True):
+    def to_dataframe(self,
+                     flatten_metrics: bool = True,
+                     flatten_categories: bool = True,
+                     add_overall_metric: bool = False) -> pd.DataFrame:
+        """
+        Convert the report to a pandas DataFrame.
+        Args:
+            flatten_metrics (bool): Whether to flatten the metrics to a single row.
+            flatten_categories (bool): Whether to flatten the categories to multiple rows.
+            add_overall_metric (bool): Whether to add an overall metric row.
+        Returns:
+            pd.DataFrame: The report as a pandas DataFrame.
+        """
         table = defaultdict(list)
         for metric in self.metrics:
+            metric_count = 0
             for category in metric.categories:
                 for subset in category.subsets:
+                    metric_count += 1
                     table[ReportKey.model_name].append(self.model_name)
                     table[ReportKey.dataset_name].append(self.dataset_name)
                     table[ReportKey.metric_name].append(metric.name)
                     table[ReportKey.category_name].append(category.name)
                     table[ReportKey.subset_name].append(subset.name)
                     table[ReportKey.num].append(subset.num)
-                    table[ReportKey.score].append(subset.score)  # TODO: convert to percentage
+                    table[ReportKey.score].append(subset.score)
+            # add overall metric when there are multiple subsets
+            if metric_count > 1 and add_overall_metric:
+                table[ReportKey.model_name].append(self.model_name)
+                table[ReportKey.dataset_name].append(self.dataset_name)
+                table[ReportKey.metric_name].append(metric.name)
+                table[ReportKey.category_name].append(('-', ))
+                table[ReportKey.subset_name].append('OVERALL')
+                table[ReportKey.num].append(metric.num)
+                table[ReportKey.score].append(metric.score)
             # NOTE: only flatten metrics if needed, use the first metric by default
             if not flatten_metrics:
                 break
@@ -131,3 +187,27 @@ class Report:
 
         df_categories.drop(columns=[ReportKey.category_name], inplace=True)
         return df_categories
+
+    def generate_analysis(self, judge_llm_config: dict) -> str:
+        import locale
+
+        from evalscope.metrics import LLMJudge
+
+        try:
+            # get the default locale
+            lang, _ = locale.getlocale()
+
+            if lang is None:
+                language = '中文'
+            else:
+                language = 'en' if lang.startswith('en') else '中文'
+
+            prompt = ANALYSIS_PROMPT.format(language=language, report_str=self.to_json_str())
+            judge_llm = LLMJudge(**judge_llm_config)
+            response = judge_llm(prompt)
+        except Exception as e:
+            logger.error(f'Error generating analysis: {e}')
+            response = 'N/A'
+
+        self.analysis = response
+        return response

evalscope/run.py

@@ -43,6 +43,9 @@ def run_single_task(task_cfg: TaskConfig, run_time: str) -> dict:
     else:
         result = evaluate_model(task_cfg, outputs)
 
+        logger.info(f'Finished evaluation for {task_cfg.model_id} on {task_cfg.datasets}')
+        logger.info(f'Output directory: {outputs.outputs_dir}')
+
     return result
 
 
@@ -109,6 +112,7 @@ def get_backend_manager_class(eval_backend: EvalBackend):
 def evaluate_model(task_cfg: TaskConfig, outputs: OutputsStructure) -> dict:
     """Evaluate the model based on the provided task configuration."""
     from evalscope.models import get_local_model
+    from evalscope.report import gen_table
 
     # Initialize evaluator
     eval_results = {}
@@ -122,10 +126,18 @@ def evaluate_model(task_cfg: TaskConfig, outputs: OutputsStructure) -> dict:
     task_cfg.dump_yaml(outputs.configs_dir)
     logger.info(task_cfg)
 
+    # Run evaluation for each evaluator
     for evaluator in evaluators:
         res_dict = evaluator.eval()
         eval_results[evaluator.dataset_name] = res_dict
 
+    # Make overall report
+    try:
+        report_table: str = gen_table(reports_path_list=[outputs.reports_dir], add_overall_metric=True)
+        logger.info(f'Overall report table: \n{report_table} \n')
+    except Exception:
+        logger.error('Failed to generate report table.')
+
     # Clean up
     if base_model is not None:
         import gc

evalscope/summarizer.py

@@ -30,7 +30,7 @@ class Summarizer:
             with open(report_file, 'r') as f:
                 res_list.append(json.load(f))
 
-        report_table: str = gen_table([reports_dir])
+        report_table: str = gen_table(reports_path_list=[reports_dir])
         logger.info(f'*** Report table ***\n{report_table}')
 
         return res_list

evalscope/utils/io_utils.py

@@ -1,3 +1,4 @@
+import csv
 import json
 import jsonlines as jsonl
 import os
@@ -112,8 +113,58 @@ def dump_jsonl_data(data_list, jsonl_file, dump_mode=DumpMode.OVERWRITE):
         writer.write_all(data_list)
 
 
-def jsonl_to_csv():
-    pass
+def jsonl_to_csv(jsonl_file, csv_file):
+    """
+    Convert jsonl file to csv file.
+
+    Args:
+        jsonl_file: jsonl file path.
+        csv_file: csv file path.
+    """
+    data = jsonl_to_list(jsonl_file)
+    if not data:
+        logger.warning(f'No data found in {jsonl_file}.')
+        return
+
+    with open(csv_file, 'w', newline='', encoding='utf-8') as f:
+        writer = csv.writer(f)
+        writer.writerow(data[0].keys())  # Write header
+        for item in data:
+            writer.writerow(item.values())
+
+
+def csv_to_list(csv_file) -> list:
+    """
+    Read csv file to list.
+
+    Args:
+        csv_file: csv file path.
+
+    Returns:
+        list: list of lines. Each line is a dict.
+    """
+    res_list = []
+    with open(csv_file, 'r', encoding='utf-8') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            res_list.append(row)
+    return res_list
+
+
+def csv_to_jsonl(csv_file, jsonl_file):
+    """
+    Convert csv file to jsonl file.
+
+    Args:
+        csv_file: csv file path.
+        jsonl_file: jsonl file path.
+    """
+    data = csv_to_list(csv_file)
+    if not data:
+        logger.warning(f'No data found in {csv_file}.')
+        return
+
+    dump_jsonl_data(data, jsonl_file, dump_mode=DumpMode.OVERWRITE)
 
 
 def yaml_to_dict(yaml_file) -> dict:
@@ -168,3 +219,9 @@ def dict_to_json(d: dict, json_file: str):
     """
     with open(json_file, 'w') as f:
         json.dump(d, f, indent=4, ensure_ascii=False)
+
+
+if __name__ == '__main__':
+    csv_file = 'custom_eval/text/mcq/example_val.csv'
+    jsonl_file = 'custom_eval/text/mcq/example_val.jsonl'
+    csv_to_jsonl(csv_file, jsonl_file)

evalscope/utils/logger.py

@@ -10,7 +10,7 @@ simple_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 
 detailed_formatter = logging.Formatter(detailed_format)
 simple_formatter = logging.Formatter(simple_format)
-DEFAULT_LEVEL = logging.DEBUG if os.getenv('LOG_LEVEL', 'INFO') == 'DEBUG' else logging.INFO
+DEFAULT_LEVEL = logging.DEBUG if os.getenv('EVALSCOPE_LOG_LEVEL', 'INFO') == 'DEBUG' else logging.INFO
 
 logging.basicConfig(format=simple_format, level=DEFAULT_LEVEL, force=True)
 

evalscope/utils/utils.py

@@ -10,6 +10,7 @@ import os
 import random
 import re
 import torch
+from inspect import signature
 from typing import Any, Dict, List, Tuple, Union
 
 from evalscope.utils.logger import get_logger
@@ -313,6 +314,17 @@ def seed_everything(seed: int):
         torch.backends.cudnn.deterministic = True
         torch.backends.cudnn.benchmark = False
 
+def get_supported_params(func):
+    """Get the supported parameters of a function."""
+    sig = signature(func)
+    return list(sig.parameters.keys())
+
+def parse_int_or_float(num):
+    number = float(num)
+    if number.is_integer():
+        return int(number)
+    return number
+
 if __name__ == '__main__':
     options = ['A', 'B', 'C', 'D']
     answers = ['Context .... ANSWER: A', 'answer: A']

evalscope/version.py

@@ -1,4 +1,4 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
-__version__ = '0.16.0'
-__release_datetime__ = '2025-05-19 18:00:00'
+__version__ = '0.16.2'
+__release_datetime__ = '2025-06-23 20:00:00'