omnigenome 0.3.0a0__py3-none-any.whl

omnigenome/auto/auto_train/auto_train.py

@@ -0,0 +1,430 @@
+# -*- coding: utf-8 -*-
+# file: auto_bench.py
+# time: 11:54 14/04/2024
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# github: https://github.com/yangheng95
+# huggingface: https://huggingface.co/yangheng
+# google scholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# Copyright (C) 2019-2024. All Rights Reserved.
+
+import os
+import time
+import warnings
+
+import findfile
+import torch
+from metric_visualizer import MetricVisualizer
+from transformers import TrainingArguments, Trainer as HFTrainer
+
+from ...src.lora.lora_model import OmniLoraModel
+from ...src.abc.abstract_tokenizer import OmniTokenizer
+from ...src.misc.utils import (
+    seed_everything,
+    fprint,
+    load_module_from_path,
+    clean_temp_checkpoint,
+)
+from ...src.trainer.accelerate_trainer import AccelerateTrainer
+from ...src.trainer.trainer import Trainer
+
+autotrain_evaluations = "./autotrain_evaluations"
+
+
+class AutoTrain:
+    """
+    AutoTrain is a class for automatically training genomic foundation models on a given dataset.
+    
+    This class provides a comprehensive framework for training genomic models
+    on various datasets with minimal configuration. It handles dataset loading,
+    model initialization, training configuration, and result tracking.
+    
+    AutoTrain supports various training scenarios including:
+    - Single dataset training with multiple seeds
+    - Different trainer backends (native, accelerate, huggingface)
+    - Automatic metric visualization and result tracking
+    - Configurable training parameters
+    
+    Attributes:
+        dataset (str): The name or path of the dataset to use for training.
+        model_name_or_path (str): The name or path of the model to train.
+        tokenizer: The tokenizer to use for training.
+        autocast (str): The autocast precision to use ('fp16', 'bf16', etc.).
+        overwrite (bool): Whether to overwrite existing training results.
+        trainer (str): The trainer to use ('native', 'accelerate', 'hf_trainer').
+        mv_path (str): Path to the metric visualizer file.
+        mv (MetricVisualizer): The metric visualizer instance.
+    """
+
+    def __init__(
+        self,
+        dataset,
+        model_name_or_path,
+        tokenizer=None,
+        **kwargs,
+    ):
+        """
+        Initialize the AutoTrain instance.
+
+        Args:
+            dataset (str): The name or path of the dataset to use for training.
+            model_name_or_path (str): The name or path of the model to train.
+            tokenizer: The tokenizer to use. If None, it will be loaded from the model path.
+            **kwargs: Additional keyword arguments.
+                - autocast (str): The autocast precision to use ('fp16', 'bf16', etc.). 
+                  Defaults to 'fp16'.
+                - overwrite (bool): Whether to overwrite existing training results. 
+                  Defaults to False.
+                - trainer (str): The trainer to use ('native', 'accelerate', 'hf_trainer'). 
+                  Defaults to 'accelerate'.
+
+        Example:
+            >>> # Initialize with a dataset and model
+            >>> trainer = AutoTrain("dataset_name", "model_name")
+            
+            >>> # Initialize with custom settings
+            >>> trainer = AutoTrain("dataset_name", "model_name", 
+            ...                     autocast="bf16", trainer="accelerate")
+        """
+        self.dataset = dataset.rstrip("/")
+        self.autocast = kwargs.pop("autocast", "fp16")
+        self.overwrite = kwargs.pop("overwrite", False)
+        self.trainer = kwargs.pop("trainer", "accelerate")
+
+        self.model_name_or_path = model_name_or_path
+        self.tokenizer = tokenizer
+        if isinstance(self.model_name_or_path, str):
+            self.model_name_or_path = self.model_name_or_path.rstrip("/")
+            self.model_name = self.model_name_or_path.split("/")[-1]
+        else:
+            self.model_name = self.model_name_or_path.__class__.__name__
+        if isinstance(tokenizer, str):
+            self.tokenizer = tokenizer.rstrip("/")
+        os.makedirs(autotrain_evaluations, exist_ok=True)
+        time_str = time.strftime("%Y%m%d_%H%M%S", time.localtime())
+        mv_name = f"{dataset}-{self.model_name}"
+        self.mv_path = f"{autotrain_evaluations}/{mv_name}-{time_str}.mv"
+
+        mv_paths = findfile.find_files(
+            autotrain_evaluations,
+            [dataset, self.model_name, ".mv"],
+        )
+        if mv_paths and not self.overwrite:
+            self.mv = MetricVisualizer.load(mv_paths[-1])
+            self.mv.summary(round=4)
+        else:
+            self.mv = MetricVisualizer(self.mv_path)
+        self.bench_info()
+
+    def bench_info(self):
+        """
+        Print and return information about the current training setup.
+        
+        This method provides a comprehensive overview of the current
+        training configuration, including dataset details, model information,
+        and training settings.
+
+        Returns:
+            str: A string containing training setup information.
+
+        Example:
+            >>> info = trainer.bench_info()
+            >>> print(info)
+        """
+        info = f"Dataset Root: {self.dataset}\n"
+        info += f"Model Name or Path: {self.model_name}\n"
+        info += f"Tokenizer: {self.tokenizer}\n"
+        info += f"Metric Visualizer Path: {self.mv_path}\n"
+        fprint(info)
+        return info
+
+    def run(self, **kwargs):
+        """
+        Run the training process.
+        
+        This method loads the dataset configuration, initializes the model and
+        tokenizer, and runs training across multiple seeds. It supports various
+        training backends and automatic result tracking.
+
+        Args:
+            **kwargs: Additional keyword arguments that will override the default
+                     parameters in the dataset configuration.
+
+        Example:
+            >>> # Run training with default settings
+            >>> trainer.run()
+            
+            >>> # Run with custom parameters
+            >>> trainer.run(learning_rate=1e-4, batch_size=16)
+        """
+
+
+        clean_temp_checkpoint(1)  # clean temp checkpoint older than 1 day
+
+        _kwargs = kwargs.copy()
+        bench_config_path = findfile.find_file(
+            self.dataset, f"{self.dataset}.config".split(".")
+        )
+        config = load_module_from_path("config", bench_config_path)
+        bench_config = config.bench_config
+        fprint(f"Loaded config for {self.dataset} from {bench_config_path}")
+        fprint(bench_config)
+
+        # Init Tokenizer and Model
+        if not self.tokenizer:
+            tokenizer = OmniTokenizer.from_pretrained(
+                self.model_name_or_path, trust_remote_code=True
+            )
+        else:
+            tokenizer = self.tokenizer
+
+        if not isinstance(bench_config["seeds"], list):
+            bench_config["seeds"] = [bench_config["seeds"]]
+
+        random_seeds = bench_config["seeds"]
+        for seed in random_seeds:
+            for key, value in _kwargs.items():
+                if key in bench_config:
+                    fprint(
+                        "Override", key, "with", value, "according to the input kwargs"
+                    )
+                    bench_config.update({key: value})
+
+                else:
+                    warnings.warn(
+                        f"kwarg: {key} not found in bench_config while setting {key} = {value}"
+                    )
+                    bench_config.update({key: value})
+
+            for key, value in bench_config.items():
+                if key in bench_config and key in _kwargs:
+                    _kwargs.pop(key)
+
+            fprint(
+                f"AutoBench Config for {self.dataset}:",
+                "\n".join([f"{k}: {v}" for k, v in bench_config.items()]),
+            )
+            for key, value in _kwargs.items():
+                if key in bench_config:
+                    fprint(
+                        "Override", key, "with", value, "according to the input kwargs"
+                    )
+                    bench_config.update({key: value})
+
+                else:
+                    warnings.warn(
+                        f"kwarg: {key} not found in bench_config while setting {key} = {value}"
+                    )
+                    bench_config.update({key: value})
+
+            for key, value in bench_config.items():
+                if key in bench_config and key in _kwargs:
+                    _kwargs.pop(key)
+
+            fprint(
+                f"AutoBench Config for {self.dataset}:",
+                "\n".join([f"{k}: {v}" for k, v in bench_config.items()]),
+            )
+
+            batch_size = (
+                bench_config["batch_size"] if "batch_size" in bench_config else 8
+            )
+
+            record_name = f"{os.path.basename(self.dataset)}-{self.model_name}".split(
+                "/"
+            )[-1]
+            # check if the record exists
+            if record_name in self.mv.transpose() and len(
+                list(self.mv.transpose()[record_name].values())[0]
+            ) >= len(bench_config["seeds"]):
+                continue
+
+            seed_everything(seed)
+            if self.model_name_or_path:
+                model_cls = bench_config["model_cls"]
+                model = model_cls(
+                    self.model_name_or_path,
+                    tokenizer=tokenizer,
+                    label2id=bench_config.label2id,
+                    num_labels=bench_config["num_labels"],
+                    trust_remote_code=True,
+                    ignore_mismatched_sizes=True,
+                )
+            else:
+                raise ValueError(
+                    "model_name_or_path is not specified. Please provide a valid model name or path."
+                )
+
+            if kwargs.get("lora_config", None) is not None:
+                fprint("Applying LoRA to the model with config:", kwargs["lora_config"])
+                model = OmniLoraModel(model, **kwargs.get("lora_config", {}))
+
+            # Init Trainer
+            dataset_cls = bench_config["dataset_cls"]
+
+            if hasattr(model.config, "max_position_embeddings"):
+                max_length = min(
+                    bench_config["max_length"],
+                    model.config.max_position_embeddings,
+                )
+            else:
+                max_length = bench_config["max_length"]
+
+            train_set = dataset_cls(
+                data_source=bench_config["train_file"],
+                tokenizer=tokenizer,
+                label2id=bench_config["label2id"],
+                max_length=max_length,
+                structure_in=bench_config.get("structure_in", False),
+                max_examples=bench_config.get("max_examples", None),
+                shuffle=bench_config.get("shuffle", True),
+                drop_long_seq=bench_config.get("drop_long_seq", False),
+                **_kwargs,
+            )
+            test_set = dataset_cls(
+                data_source=bench_config["test_file"],
+                tokenizer=tokenizer,
+                label2id=bench_config["label2id"],
+                max_length=max_length,
+                structure_in=bench_config.get("structure_in", False),
+                max_examples=bench_config.get("max_examples", None),
+                shuffle=False,
+                drop_long_seq=bench_config.get("drop_long_seq", False),
+                **_kwargs,
+            )
+            valid_set = dataset_cls(
+                data_source=bench_config["valid_file"],
+                tokenizer=tokenizer,
+                label2id=bench_config["label2id"],
+                max_length=max_length,
+                structure_in=bench_config.get("structure_in", False),
+                max_examples=bench_config.get("max_examples", None),
+                shuffle=False,
+                drop_long_seq=bench_config.get("drop_long_seq", False),
+                **_kwargs,
+            )
+
+            if self.trainer == "hf_trainer":
+                # Set up HuggingFace Trainer
+                hf_kwargs = {
+                    k: v
+                    for k, v in kwargs.items()
+                    if hasattr(TrainingArguments, k) and k != "output_dir"
+                }
+                training_args = TrainingArguments(
+                    output_dir=f"./autotrain_evaluations/{self.model_name}",
+                    num_train_epochs=hf_kwargs.pop(
+                        "num_train_epochs", bench_config["epochs"]
+                    ),
+                    per_device_train_batch_size=hf_kwargs.pop("batch_size", batch_size),
+                    per_device_eval_batch_size=hf_kwargs.pop("batch_size", batch_size),
+                    gradient_accumulation_steps=hf_kwargs.pop(
+                        "gradient_accumulation_steps", 1
+                    ),
+                    learning_rate=hf_kwargs.pop("learning_rate", 2e-5),
+                    weight_decay=hf_kwargs.pop("weight_decay", 0),
+                    eval_strategy=hf_kwargs.pop("eval_strategy", "epoch"),
+                    save_strategy=hf_kwargs.pop("save_strategy", "epoch"),
+                    fp16=hf_kwargs.pop("fp16", True),
+                    remove_unused_columns=False,
+                    label_names=["labels"],
+                    **hf_kwargs,
+                )
+
+                valid_set = valid_set if len(valid_set) else test_set
+
+                if len(bench_config["compute_metrics"]) > 1:
+                    fprint(
+                        "Multiple metrics not supported by HFTrainer, using the first one metric only."
+                    )
+                trainer = HFTrainer(
+                    model=model,
+                    args=training_args,
+                    train_dataset=train_set,
+                    eval_dataset=valid_set,
+                    compute_metrics=(
+                        bench_config["compute_metrics"][0]
+                        if isinstance(bench_config["compute_metrics"], list)
+                        else bench_config["compute_metrics"]
+                    ),
+                )
+
+                # Train and evaluate
+                eval_result = trainer.evaluate(
+                    valid_set if len(valid_set) else test_set
+                )
+                print(eval_result)
+                train_result = trainer.train()
+                eval_result = trainer.evaluate()
+                test_result = trainer.evaluate(test_set if len(test_set) else valid_set)
+
+                metrics = {
+                    "train": train_result.metrics,
+                    "eval": eval_result,
+                    "test": test_result,
+                }
+                fprint(metrics)
+            else:
+                optimizer = torch.optim.AdamW(
+                    filter(lambda p: p.requires_grad, model.parameters()),
+                    lr=(
+                        bench_config["learning_rate"]
+                        if "learning_rate" in bench_config
+                        else 2e-5
+                    ),
+                    weight_decay=(
+                        bench_config["weight_decay"]
+                        if "weight_decay" in bench_config
+                        else 0
+                    ),
+                )
+                if self.trainer == "accelerate":
+                    trainer_cls = AccelerateTrainer
+                else:
+                    trainer_cls = Trainer
+                fprint(f"Using Trainer: {trainer_cls}")
+                trainer = trainer_cls(
+                    model=model,
+                    train_dataset=train_set,
+                    eval_dataset=valid_set,
+                    test_dataset=test_set,
+                    batch_size=batch_size,
+                    patience=(
+                        bench_config["patience"] if "patience" in bench_config else 3
+                    ),
+                    epochs=bench_config["epochs"],
+                    gradient_accumulation_steps=bench_config.get(
+                        "gradient_accumulation_steps", 1
+                    ),
+                    optimizer=optimizer,
+                    loss_fn=(
+                        bench_config["loss_fn"] if "loss_fn" in bench_config else None
+                    ),
+                    compute_metrics=bench_config["compute_metrics"],
+                    seed=seed,
+                    autocast=self.autocast,
+                    **_kwargs,
+                )
+                metrics = trainer.train()
+                save_path = os.path.join(
+                    autotrain_evaluations, self.dataset, self.model_name
+                )
+                trainer.save_model(save_path)
+
+                if metrics:
+                    for key, value in metrics["test"][-1].items():
+                        try:
+                            value = float(value)
+                        except:
+                            pass  # ignore non-float values
+                        self.mv.log(f"{record_name}", f"{key}", value)
+                    # for key, value in metrics['test'][-1].items():
+                    #     self.mv.log(f'{record_name}', f'test_{key}', value)
+                    # for i, valid_metrics in enumerate(metrics["valid"]):
+                    #     for key, value in valid_metrics.items():
+                    #         self.mv.log(f'{record_name}', f'valid_epoch_{i}_{key}', value)
+
+                    self.mv.summary(round=4)
+                    self.mv.dump(self.mv_path)
+                    self.mv.to_csv(self.mv_path.replace(".mv", ".csv"))
+                del model, trainer, optimizer
+                torch.cuda.empty_cache()

omnigenome/auto/auto_train/auto_train_cli.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+# file: auto_bench_cli.py
+# time: 19:18 05/02/2025
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# Homepage: https://yangheng95.github.io
+# github: https://github.com/yangheng95
+# huggingface: https://huggingface.co/yangheng
+# google scholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# Copyright (C) 2019-2025. All Rights Reserved.
+
+import argparse
+import os
+import platform
+import sys
+import time
+
+from typing import Optional
+from omnigenome import AutoTrain
+from omnigenome.src.misc.utils import fprint
+
+
+def train_command(args: Optional[list] = None):
+    """
+    Entry point for the OmniGenome auto-train command-line interface.
+
+    :param args: A list of command-line arguments. If None, `sys.argv` is used.
+    """
+
+    parser = create_parser()
+    parsed_args = parser.parse_args(args)
+
+    model_path = parsed_args.model
+    fprint(f"\n>> Starting evaluation for model: {model_path}")
+
+    # Special handling for multimolecule models
+    if "multimolecule" in model_path:
+        from multimolecule import RnaTokenizer, AutoModelForTokenPrediction
+
+        tokenizer = RnaTokenizer.from_pretrained(model_path)
+        model = AutoModelForTokenPrediction.from_pretrained(
+            model_path, trust_remote_code=True
+        ).base_model
+    else:
+        tokenizer = parsed_args.tokenizer
+        model = model_path
+
+    # Initialize AutoTraining
+    autobench = AutoTrain(
+        dataset=parsed_args.dataset,
+        model_name_or_path=model,
+        tokenizer=tokenizer,
+        overwrite=parsed_args.overwrite,
+        trainer=parsed_args.trainer,
+    )
+
+    # Run evaluation
+    autobench.run(**vars(parsed_args))
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """
+    Creates the argument parser for the auto-train CLI.
+
+    :return: An `argparse.ArgumentParser` instance.
+    """
+    parser = argparse.ArgumentParser(
+        description="Genomic Foundation Model Benchmark Suite (Single Model)",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    # Required argument
+    parser.add_argument(
+        "-d",
+        "--dataset",
+        type=str,
+        help="Path to the dataset and training configuration file.",
+    )
+    parser.add_argument(
+        "-t",
+        "--tokenizer",
+        type=str,
+        default=None,
+        help="Path to the tokenizer to use (HF tokenizer ID or local path).",
+    )
+
+    parser.add_argument(
+        "-m",
+        "--model",
+        type=str,
+        required=True,
+        help="Path to the model to evaluate (HF model ID or local path).",
+    )
+
+    # Optional arguments
+    parser.add_argument(
+        "--overwrite",
+        type=bool,
+        default=False,
+        help="Overwrite existing bench results, otherwise resume from training checkpoint.",
+    )
+    parser.add_argument(
+        "--bs_scale",
+        type=int,
+        default=1,
+        help="Batch size scale factor. To increase GPU memory utilization, set to 2 or 4, etc.",
+    )
+    parser.add_argument(
+        "--trainer",
+        type=str,
+        default="accelerate",
+        choices=["native", "accelerate", "hf_trainer"],
+        help="Trainer to use for training. \n"
+        "Use 'accelerate' for distributed training. Set to false to disable. "
+        "You can use 'accelerate config' to customize behavior.\n"
+        "Use 'hf_trainer' for Hugging Face Trainer. \n"
+        "Set to 'native' to use native PyTorch training loop.\n",
+    )
+    parser.add_argument(
+        "--autocast",
+        type=str,
+        default="fp16",
+        choices=["fp16", "fp32", "bf16", "fp8", "no"],
+        help="Automatic mixed precision training mode.",
+    )
+    return parser
+
+
+def run_train():
+    """
+    Wrapper function to run the auto-train command.
+    """
+
+    fprint("Running AutoTraining, this may take a while, please be patient...")
+    fprint("You can find the logs in the 'autobench_logs' directory.")
+    fprint("You can find the metrics in the 'autobench_evaluations' directory.")
+    fprint(
+        "If you don't intend to use accelerate, please add '--trainer native' to the command."
+    )
+    fprint(
+        "If you want to alter accelerate's behavior, please refer to 'accelerate config' command."
+    )
+    fprint("If you encounter any issues, please report them on the GitHub repository.")
+    os.makedirs("autobench_logs", exist_ok=True)
+    time_str = time.strftime("%Y-%m-%d-%H-%M-%S")
+    log_file = f"autobench_logs/AutoBench-{time_str}.log"
+    from pathlib import Path
+
+    try:
+        mixed_precision = sys.argv[sys.argv.index("--autocast") + 1].lower()
+    except ValueError:
+        mixed_precision = "fp16"
+    file_path = Path(__file__).resolve()
+    if (
+        "--trainer" in sys.argv
+        and sys.argv[sys.argv.index("--trainer") + 1].lower() == "native"
+    ):
+        cmd_base = f'python "{file_path}" ' + " ".join(sys.argv[1:])
+    else:
+        cmd_base = (
+            f'accelerate launch --mixed_precision "{mixed_precision}" "{file_path}" '
+            + " ".join(sys.argv[1:])
+        )
+
+    # Use platform-specific tee commands:
+    if platform.system() == "Windows":
+        # On Windows, use PowerShell's tee-object.
+        # The command below launches PowerShell and passes the tee-object command.
+        # try:
+        #     cmd = f"{cmd_base} 2>&1 | powershell -Command Get-Content {log_file} -Wait"
+        # except Exception as e:
+        #     fprint(f"The log file cannot be saved due to Error: {e}")
+        #     fprint(
+        #         "If commands not allowed in PowerShell, "
+        #         "please run 'Set-ExecutionPolicy RemoteSigned' in PowerShell with Admin."
+        #     )
+        cmd = f"{cmd_base} 2>&1"
+    else:
+        # On Unix-like systems, use the standard tee command.
+        cmd = f"{cmd_base} 2>&1 | tee '{log_file}'"
+
+    # Execute the command.
+    sys.exit(os.system(cmd))
+
+    # # 匹配tqdm进度条的正则表达式（根据实际输出调整）
+    # tqdm_pattern = re.compile(r'^.*\d+%\|.*\|\s+\d+/\d+\s+\[.*\]\s*$')
+    #
+    # last_tqdm_line = ''
+    #
+    # with open(log_file, 'w', encoding='utf-8') as log_file:
+    #     # 执行命令并捕获输出流
+    #     proc = subprocess.Popen(
+    #         cmd_base,
+    #         shell=True,
+    #         stdout=subprocess.PIPE,
+    #         stderr=subprocess.STDOUT,
+    #         bufsize=1,
+    #         universal_newlines=True
+    #     )
+    #
+    #     # 实时处理输出流
+    #     for line in proc.stdout:
+    #         line = line.rstrip()  # 移除行尾换行符
+    #         if tqdm_pattern.match(line):
+    #             # 更新最后一行tqdm输出
+    #             last_tqdm_line = line + '\n'  # 换行符需要手动添加
+    #             # 实时显示进度条（覆盖模式）
+    #             sys.stdout.write('\r' + line)
+    #             sys.stdout.flush()
+    #         else:
+    #             # 写入日志并正常打印
+    #             log_file.write(line + '\n')
+    #             print(line)
+    #
+    #     # 命令执行完毕后写入最后一个tqdm进度条
+    #     if last_tqdm_line:
+    #         log_file.write(last_tqdm_line)
+    #         sys.stdout.write('\n')  # 最后换行避免覆盖
+    #
+    # sys.exit(proc.returncode)
+
+
+if __name__ == "__main__":
+    train_command()

omnigenome/auto/bench_hub/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+# file: __init__.py
+# time: 18:28 11/04/2024
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# github: https://github.com/yangheng95
+# huggingface: https://huggingface.co/yangheng
+# google scholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# Copyright (C) 2019-2024. All Rights Reserved.
+"""
+This package contains modules for the benchmark hub.
+"""
+

omnigenome/auto/bench_hub/bench_hub.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# file: bench_hub.py
+# time: 11:53 14/04/2024
+# author: YANG, HENG <hy345@exeter.ac.uk> (杨恒)
+# github: https://github.com/yangheng95
+# huggingface: https://huggingface.co/yangheng
+# google scholar: https://scholar.google.com/citations?user=NPq5a_0AAAAJ&hl=en
+# Copyright (C) 2019-2024. All Rights Reserved.
+
+
+class BenchHub:
+    """
+    A hub for accessing and managing benchmarks.
+    
+    This class is intended to provide a centralized way to list, download,
+    and inspect available benchmarks for OmniGenome.
+    """
+
+    def __init__(self):
+        """Initializes the BenchHub."""
+        pass
+
+    def run(self):
+        """Placeholder for running functionality related to the benchmark hub."""
+        pass