nf-core 3.3.1__tar.gz → 3.3.2__tar.gz

{nf_core-3.3.1/nf_core.egg-info → nf_core-3.3.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: nf-core
-Version: 3.3.1
+Version: 3.3.2
 Summary: Helper tools for use with nf-core Nextflow pipelines.
 Home-page: https://github.com/nf-core/tools
 Author: Phil Ewels
 Author-email: phil.ewels@scilifelab.se
 License: MIT
 Keywords: nf-core,nextflow,bioinformatics,workflow,pipeline,biology,sequencing,NGS,next generation sequencing
-Requires-Python: >=3.8, <4
+Requires-Python: >=3.9, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click
@@ -32,7 +32,7 @@ Requires-Dist: rich>=13.3.1
 Requires-Dist: rocrate
 Requires-Dist: repo2rocrate
 Requires-Dist: tabulate
-Requires-Dist: textual==2.1.2
+Requires-Dist: textual==3.5.0
 Requires-Dist: trogon
 Requires-Dist: pdiff
 Requires-Dist: ruamel.yaml
@@ -85,7 +85,7 @@ conda install nf-core
 Alternatively, you can create a new environment with both nf-core/tools and nextflow:
 
 ```bash
-conda create --name nf-core python=3.12 nf-core nextflow
+conda create --name nf-core python=3.13 nf-core nextflow
 conda activate nf-core
 ```
 

{nf_core-3.3.1 → nf_core-3.3.2}/README.md

@@ -35,7 +35,7 @@ conda install nf-core
 Alternatively, you can create a new environment with both nf-core/tools and nextflow:
 
 ```bash
-conda create --name nf-core python=3.12 nf-core nextflow
+conda create --name nf-core python=3.13 nf-core nextflow
 conda activate nf-core
 ```
 

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/commands_test_datasets.py

@@ -1,4 +1,5 @@
 import logging
+from typing import Optional
 
 import click
 import rich
@@ -29,7 +30,7 @@ def test_datasets_list_remote(ctx: click.Context, branch: str, generate_nf_path:
 
 
 def test_datasets_search(
-    ctx: click.Context, branch: str, generate_nf_path: bool, generate_dl_url: bool, query: str
+    ctx: click.Context, branch: str, generate_nf_path: bool, generate_dl_url: bool, query: Optional[str]
 ) -> None:
     """
     Search all files on a given branch in the remote nf-core/testdatasets repository on github

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/components_command.py

@@ -3,7 +3,7 @@ import mmap
 import os
 import shutil
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import nf_core.utils
 from nf_core.modules.modules_json import ModulesJson
@@ -65,7 +65,7 @@ class ComponentCommand:
         self.default_subworkflows_path = Path("subworkflows", self.org)
         self.default_subworkflows_tests_path = Path("tests", "subworkflows", self.org)
 
-    def get_local_components(self) -> List[str]:
+    def get_local_components(self) -> list[str]:
         """
         Get the local modules/subworkflows in a pipeline
         """
@@ -78,7 +78,7 @@ class ComponentCommand:
             str(path.relative_to(local_component_dir)) for path in local_component_dir.iterdir() if path.suffix == ".nf"
         ]
 
-    def get_components_clone_modules(self) -> List[str]:
+    def get_components_clone_modules(self) -> list[str]:
         """
         Get the modules/subworkflows repository available in a clone of nf-core/modules
         """
@@ -142,7 +142,7 @@ class ComponentCommand:
             log.error(f"Could not remove {self.component_type[:-1]} {component_name}: {e}")
             return False
 
-    def components_from_repo(self, install_dir: str) -> List[str]:
+    def components_from_repo(self, install_dir: str) -> list[str]:
         """
         Gets the modules/subworkflows installed from a certain repository
 
@@ -200,7 +200,7 @@ class ComponentCommand:
             modules/nf-core/modules/TOOL/SUBTOOL
         """
         if self.repo_type == "pipeline":
-            wrong_location_modules: List[Path] = []
+            wrong_location_modules: list[Path] = []
             for directory, _, files in os.walk(Path(self.directory, "modules")):
                 if "main.nf" in files:
                     module_path = Path(directory).relative_to(Path(self.directory, "modules"))
@@ -263,7 +263,7 @@ class ComponentCommand:
                     ][module_name]["patch"] = str(patch_path.relative_to(self.directory.resolve()))
                 modules_json.dump()
 
-    def check_if_in_include_stmts(self, component_path: str) -> Dict[str, List[Dict[str, Union[int, str]]]]:
+    def check_if_in_include_stmts(self, component_path: str) -> dict[str, list[dict[str, Union[int, str]]]]:
         """
         Checks for include statements in the main.nf file of the pipeline and a list of line numbers where the component is included
         Args:
@@ -272,7 +272,7 @@ class ComponentCommand:
         Returns:
             (list): A list of dictionaries, with the workflow file and the line number where the component is included
         """
-        include_stmts: Dict[str, List[Dict[str, Union[int, str]]]] = {}
+        include_stmts: dict[str, list[dict[str, Union[int, str]]]] = {}
         if self.repo_type == "pipeline":
             workflow_files = Path(self.directory, "workflows").glob("*.nf")
             for workflow_file in workflow_files:

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/components_differ.py

@@ -4,7 +4,7 @@ import json
 import logging
 import os
 from pathlib import Path
-from typing import Dict, List, Union
+from typing import Union
 
 from rich import box
 from rich.console import Console, Group, RenderableType
@@ -308,7 +308,7 @@ class ComponentsDiffer:
             )
 
     @staticmethod
-    def per_file_patch(patch_fn: Union[str, Path]) -> Dict[str, List[str]]:
+    def per_file_patch(patch_fn: Union[str, Path]) -> dict[str, list[str]]:
         """
         Splits a patch file for several files into one patch per file.
 
@@ -324,7 +324,7 @@ class ComponentsDiffer:
 
         patches = {}
         i = 0
-        patch_lines: List[str] = []
+        patch_lines: list[str] = []
         key = "preamble"
         while i < len(lines):
             line = lines[i]
@@ -470,7 +470,7 @@ class ComponentsDiffer:
         patch_path: Union[str, Path],
         component_dir: Path,
         reverse: bool = False,
-    ) -> Dict[str, List[str]]:
+    ) -> dict[str, list[str]]:
         """
         Try applying a full patch file to a module or subworkflow
 

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/components_test.py

@@ -6,7 +6,7 @@ import logging
 import os
 import re
 from pathlib import Path
-from typing import List, Optional
+from typing import Optional
 
 import questionary
 from rich import print
@@ -79,7 +79,7 @@ class ComponentsTest(ComponentCommand):  # type: ignore[misc]
         self.component_name = component_name
         self.remote_url = remote_url
         self.branch = branch
-        self.errors: List[str] = []
+        self.errors: list[str] = []
         self.verbose = verbose
         self.obsolete_snapshots: bool = False
         self.update = update

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/components_utils.py

@@ -1,7 +1,7 @@
 import logging
 import re
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import questionary
 import requests
@@ -22,7 +22,7 @@ yaml.preserve_quotes = True
 yaml.indent(mapping=2, sequence=2, offset=0)
 
 
-def get_repo_info(directory: Path, use_prompt: Optional[bool] = True) -> Tuple[Path, Optional[str], str]:
+def get_repo_info(directory: Path, use_prompt: Optional[bool] = True) -> tuple[Path, Optional[str], str]:
     """
     Determine whether this is a pipeline repository or a clone of
     nf-core/modules
@@ -147,12 +147,12 @@ def prompt_component_version_sha(
 
 def get_components_to_install(
     subworkflow_dir: Union[str, Path],
-) -> Tuple[List[Dict[str, str]], List[Dict[str, str]]]:
+) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
     """
     Parse the subworkflow main.nf file to retrieve all imported modules and subworkflows.
     """
-    modules: Dict[str, Dict[str, str]] = {}
-    subworkflows: Dict[str, Dict[str, str]] = {}
+    modules: dict[str, dict[str, str]] = {}
+    subworkflows: dict[str, dict[str, str]] = {}
 
     with open(Path(subworkflow_dir, "main.nf")) as fh:
         for line in fh:
@@ -165,7 +165,7 @@ def get_components_to_install(
                 if link.startswith("../../../"):
                     name_split = name.lower().split("_")
                     component_name = "/".join(name_split)
-                    component_dict: Dict[str, str] = {
+                    component_dict: dict[str, str] = {
                         "name": component_name,
                     }
                     modules[component_name] = component_dict
@@ -198,7 +198,7 @@ def get_components_to_install(
     return list(modules.values()), list(subworkflows.values())
 
 
-def get_biotools_response(tool_name: str) -> Optional[Dict]:
+def get_biotools_response(tool_name: str) -> Optional[dict]:
     """
     Try to get bio.tools information for 'tool'
     """
@@ -232,12 +232,12 @@ def get_biotools_id(data: dict, tool_name: str) -> str:
     return ""
 
 
-DictWithStrAndTuple = Dict[str, Tuple[List[str], List[str], List[str]]]
+DictWithStrAndTuple = dict[str, tuple[list[str], list[str], list[str]]]
 
 
 def get_channel_info_from_biotools(
     data: dict, tool_name: str
-) -> Optional[Tuple[DictWithStrAndTuple, DictWithStrAndTuple]]:
+) -> Optional[tuple[DictWithStrAndTuple, DictWithStrAndTuple]]:
     """
     Try to find input and output channels and the respective EDAM ontology terms
 

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/create.py

@@ -9,13 +9,13 @@ import re
 import shutil
 import subprocess
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Optional, Union
 
 import jinja2
 import questionary
 import rich
 import rich.prompt
-import yaml
+import ruamel.yaml
 from packaging.version import parse as parse_version
 
 import nf_core
@@ -26,6 +26,14 @@ from nf_core.pipelines.lint_utils import run_prettier_on_file
 
 log = logging.getLogger(__name__)
 
+# Set yaml options for meta.yml files
+ruamel.yaml.representer.RoundTripRepresenter.ignore_aliases = (
+    lambda x, y: True
+)  # Fix to not print aliases. https://stackoverflow.com/a/64717341
+yaml = ruamel.yaml.YAML()
+yaml.preserve_quotes = True
+yaml.indent(mapping=2, sequence=2, offset=0)
+
 
 class ComponentCreate(ComponentCommand):
     def __init__(
@@ -59,7 +67,7 @@ class ComponentCreate(ComponentCommand):
         self.bioconda = None
         self.singularity_container = None
         self.docker_container = None
-        self.file_paths: Dict[str, Path] = {}
+        self.file_paths: dict[str, Path] = {}
         self.not_empty_template = not empty_template
         self.migrate_pytest = migrate_pytest
         self.tool_identifier = ""
@@ -175,6 +183,10 @@ class ComponentCreate(ComponentCommand):
         assert self._render_template()
         log.info(f"Created component template: '{self.component_name}'")
 
+        if self.component_type == "modules":
+            # Generate meta.yml inputs and outputs
+            self.generate_meta_yml_file()
+
         if self.migrate_pytest:
             self._copy_old_files(component_old_path)
             log.info("Migrate pytest tests: Copied original module files to new module")
@@ -357,7 +369,7 @@ class ComponentCreate(ComponentCommand):
                 elif self.component_type == "subworkflows":
                     self.component = rich.prompt.Prompt.ask("[violet]Name of subworkflow").strip()
 
-    def _get_component_dirs(self) -> Dict[str, Path]:
+    def _get_component_dirs(self) -> dict[str, Path]:
         """Given a directory and a tool/subtool or subworkflow, set the file paths and check if they already exist
 
         Returns dict: keys are relative paths to template files, vals are target paths.
@@ -501,10 +513,184 @@ class ComponentCreate(ComponentCommand):
         # Delete tags from pytest_modules.yml
         modules_yml = Path(self.directory, "tests", "config", "pytest_modules.yml")
         with open(modules_yml) as fh:
-            yml_file = yaml.safe_load(fh)
+            yml_file = yaml.load(fh)
         yml_key = str(self.component_dir) if self.component_type == "modules" else f"subworkflows/{self.component_dir}"
         if yml_key in yml_file:
             del yml_file[yml_key]
         with open(modules_yml, "w") as fh:
             yaml.dump(yml_file, fh)
         run_prettier_on_file(modules_yml)
+
+    def generate_meta_yml_file(self) -> None:
+        """
+        Generate the meta.yml file.
+        """
+        # TODO: The meta.yml could be handled with a Pydantic model. The reason it is not implemented is because we want to maintain comments in the meta.yml file.
+        with open(self.file_paths["meta.yml"]) as fh:
+            meta_yml: ruamel.yaml.comments.CommentedMap = yaml.load(fh)
+
+        versions: dict[str, list[dict[str, dict]]] = {
+            "versions": [
+                {
+                    "versions.yml": {
+                        "type": "file",
+                        "description": "File containing software versions",
+                        "pattern": "versions.yml",
+                        "ontologies": [
+                            ruamel.yaml.comments.CommentedMap({"edam": "http://edamontology.org/format_3750"})
+                        ],
+                    }
+                }
+            ]
+        }
+        versions["versions"][0]["versions.yml"]["ontologies"][0].yaml_add_eol_comment("YAML", "edam")
+
+        if self.not_empty_template:
+            meta_yml.yaml_set_comment_before_after_key(
+                "name", before="# TODO nf-core: Add a description of the module and list keywords"
+            )
+            meta_yml["tools"][0].yaml_set_start_comment(
+                "## TODO nf-core: Add a description and other details for the software below"
+            )
+            meta_yml["input"].yaml_set_start_comment(
+                "### TODO nf-core: Add a description of all of the variables used as input", indent=2
+            )
+            meta_yml["output"].yaml_set_start_comment(
+                "### TODO nf-core: Add a description of all of the variables used as output", indent=2
+            )
+
+            if hasattr(self, "inputs"):
+                inputs_array: list[Union[dict, list[dict]]] = []
+                for i, (input_name, ontologies) in enumerate(self.inputs.items()):
+                    channel_entry: dict[str, dict] = {
+                        input_name: {
+                            "type": "file",
+                            "description": f"{input_name} file",
+                            "pattern": f"*.{{{','.join(ontologies[2])}}}",
+                            "ontologies": [
+                                ruamel.yaml.comments.CommentedMap({"edam": f"{ont_id}"}) for ont_id in ontologies[0]
+                            ],
+                        }
+                    }
+                    for j, ont_desc in enumerate(ontologies[1]):
+                        channel_entry[input_name]["ontologies"][j].yaml_add_eol_comment(ont_desc, "edam")
+                    if self.has_meta:
+                        meta_suffix = str(i + 1) if i > 0 else ""
+                        meta_entry: dict[str, dict] = {
+                            f"meta{meta_suffix}": {
+                                "type": "map",
+                                "description": "Groovy Map containing sample information. e.g. `[ id:'sample1' ]`",
+                            }
+                        }
+                        inputs_array.append([meta_entry, channel_entry])
+                    else:
+                        inputs_array.append(channel_entry)
+                meta_yml["input"] = ruamel.yaml.comments.CommentedSeq(inputs_array)
+                meta_yml["input"].yaml_set_start_comment(
+                    "# TODO nf-core: Update the information obtained from bio.tools and make sure that it is correct"
+                )
+            elif not self.has_meta:
+                meta_yml["input"] = [
+                    {
+                        "bam": {
+                            "type": "file",
+                            "description": "Sorted BAM/CRAM/SAM file",
+                            "pattern": "*.{bam,cram,sam}",
+                            "ontologies": [
+                                ruamel.yaml.comments.CommentedMap({"edam": "http://edamontology.org/format_2572"}),
+                                ruamel.yaml.comments.CommentedMap({"edam": "http://edamontology.org/format_2573"}),
+                                ruamel.yaml.comments.CommentedMap({"edam": "http://edamontology.org/format_3462"}),
+                            ],
+                        }
+                    }
+                ]
+                meta_yml["input"][0]["bam"]["ontologies"][0].yaml_add_eol_comment("BAM", "edam")
+                meta_yml["input"][0]["bam"]["ontologies"][1].yaml_add_eol_comment("CRAM", "edam")
+                meta_yml["input"][0]["bam"]["ontologies"][2].yaml_add_eol_comment("SAM", "edam")
+
+            if hasattr(self, "outputs"):
+                outputs_dict: dict[str, Union[list, dict]] = {}
+                for i, (output_name, ontologies) in enumerate(self.outputs.items()):
+                    channel_contents: list[Union[list[dict], dict]] = []
+                    if self.has_meta:
+                        channel_contents.append(
+                            [
+                                {
+                                    "meta": {
+                                        "type": "map",
+                                        "description": "Groovy Map containing sample information. e.g. `[ id:'sample1' ]`",
+                                    }
+                                }
+                            ]
+                        )
+                    pattern = f"*.{{{','.join(ontologies[2])}}}"
+                    file_entry: dict[str, dict] = {
+                        pattern: {
+                            "type": "file",
+                            "description": f"{output_name} file",
+                            "pattern": pattern,
+                            "ontologies": [
+                                ruamel.yaml.comments.CommentedMap({"edam": f"{ont_id}"}) for ont_id in ontologies[0]
+                            ],
+                        }
+                    }
+                    for j, ont_desc in enumerate(ontologies[1]):
+                        file_entry[pattern]["ontologies"][j].yaml_add_eol_comment(ont_desc, "edam")
+                    if self.has_meta:
+                        if isinstance(channel_contents[0], list):  # for mypy
+                            channel_contents[0].append(file_entry)
+                    else:
+                        channel_contents.append(file_entry)
+                    outputs_dict[output_name] = channel_contents
+                outputs_dict.update(versions)
+                meta_yml["output"] = ruamel.yaml.comments.CommentedMap(outputs_dict)
+                meta_yml["output"].yaml_set_start_comment(
+                    "# TODO nf-core: Update the information obtained from bio.tools and make sure that it is correct"
+                )
+            elif not self.has_meta:
+                meta_yml["output"] = {
+                    "bam": [
+                        {
+                            "*.bam": {
+                                "type": "file",
+                                "description": "Sorted BAM/CRAM/SAM file",
+                                "pattern": "*.{bam,cram,sam}",
+                                "ontologies": [
+                                    ruamel.yaml.comments.CommentedMap({"edam": "http://edamontology.org/format_2572"}),
+                                    ruamel.yaml.comments.CommentedMap({"edam": "http://edamontology.org/format_2573"}),
+                                    ruamel.yaml.comments.CommentedMap({"edam": "http://edamontology.org/format_3462"}),
+                                ],
+                            }
+                        }
+                    ]
+                }
+                meta_yml["output"]["bam"][0]["*.bam"]["ontologies"][0].yaml_add_eol_comment("BAM", "edam")
+                meta_yml["output"]["bam"][0]["*.bam"]["ontologies"][1].yaml_add_eol_comment("CRAM", "edam")
+                meta_yml["output"]["bam"][0]["*.bam"]["ontologies"][2].yaml_add_eol_comment("SAM", "edam")
+                meta_yml["output"].update(versions)
+
+        else:
+            input_entry: list[dict] = [
+                {"input": {"type": "file", "description": "", "pattern": "", "ontologies": [{"edam": ""}]}}
+            ]
+            output_entry: list[dict] = [
+                {"*": {"type": "file", "description": "", "pattern": "", "ontologies": [{"edam": ""}]}}
+            ]
+            if self.has_meta:
+                empty_meta_entry: list[dict] = [
+                    {
+                        "meta": {
+                            "type": "map",
+                            "description": "Groovy Map containing sample information. e.g. `[ id:'sample1' ]`",
+                        }
+                    }
+                ]
+                meta_yml["input"] = [empty_meta_entry + input_entry]
+                meta_yml["output"] = {"output": [empty_meta_entry + output_entry]}
+            else:
+                meta_yml["input"] = input_entry
+                meta_yml["output"] = {"output": output_entry}
+            meta_yml["output"].update(versions)
+
+        with open(self.file_paths["meta.yml"], "w") as fh:
+            yaml.dump(meta_yml, fh)

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/info.py

@@ -1,7 +1,7 @@
 import logging
 import os
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import questionary
 import yaml
@@ -66,7 +66,7 @@ class ComponentInfo(ComponentCommand):
         no_pull: bool = False,
     ):
         super().__init__(component_type, pipeline_dir, remote_url, branch, no_pull)
-        self.meta: Optional[Dict] = None
+        self.meta: Optional[dict] = None
         self.local_path: Optional[Path] = None
         self.remote_location: Optional[str] = None
         self.local: bool = False
@@ -106,7 +106,7 @@ class ComponentInfo(ComponentCommand):
                     components = self.get_components_clone_modules()
                 elif self.repo_type == "pipeline":
                     assert self.modules_json is not None  # mypy
-                    all_components: List[Tuple[str, str]] = self.modules_json.get_all_components(
+                    all_components: list[tuple[str, str]] = self.modules_json.get_all_components(
                         self.component_type
                     ).get(self.modules_repo.remote_url, [])
 
@@ -170,7 +170,7 @@ class ComponentInfo(ComponentCommand):
 
         return self.generate_component_info_help()
 
-    def get_local_yaml(self) -> Optional[Dict]:
+    def get_local_yaml(self) -> Optional[dict]:
         """Attempt to get the meta.yml file from a locally installed module/subworkflow.
 
         Returns:
@@ -213,7 +213,7 @@ class ComponentInfo(ComponentCommand):
 
         return {}
 
-    def get_remote_yaml(self) -> Optional[Dict]:
+    def get_remote_yaml(self) -> Optional[dict]:
         """Attempt to get the meta.yml file from a remote repo.
 
         Returns:
@@ -320,18 +320,27 @@ class ComponentInfo(ComponentCommand):
         # Outputs
         if self.meta.get("output"):
             outputs_table = self.generate_params_table("Outputs")
-            for output in self.meta["output"]:
-                if self.component_type == "modules":
-                    for ch_name, elements in output.items():
-                        outputs_table.add_row(f"{ch_name}", "", "")
-                        for element in elements:
+            if self.component_type == "modules":
+                for ch_name, elements in self.meta["output"].items():
+                    outputs_table.add_row(f"{ch_name}", "", "")
+                    for element in elements:
+                        if isinstance(element, list):
+                            for ch in element:
+                                for key, info in ch.items():
+                                    outputs_table.add_row(
+                                        f"[orange1 on black] {key} [/][dim i] ({info['type']})",
+                                        Markdown(info["description"] if info["description"] else ""),
+                                        info.get("pattern", ""),
+                                    )
+                        elif isinstance(element, dict):
                             for key, info in element.items():
                                 outputs_table.add_row(
                                     f"[orange1 on black] {key} [/][dim i] ({info['type']})",
                                     Markdown(info["description"] if info["description"] else ""),
                                     info.get("pattern", ""),
                                 )
-                elif self.component_type == "subworkflows":
+            elif self.component_type == "subworkflows":
+                for output in self.meta["output"]:
                     for key, info in output.items():
                         outputs_table.add_row(
                             f"[orange1 on black] {key} [/][dim i]",

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/install.py

@@ -1,7 +1,7 @@
 import logging
 import os
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import questionary
 from rich import print
@@ -38,7 +38,7 @@ class ComponentInstall(ComponentCommand):
         remote_url: Optional[str] = None,
         branch: Optional[str] = None,
         no_pull: bool = False,
-        installed_by: Optional[List[str]] = None,
+        installed_by: Optional[list[str]] = None,
     ):
         super().__init__(component_type, pipeline_dir, remote_url, branch, no_pull)
         self.current_remote = ModulesRepo(remote_url, branch)
@@ -52,7 +52,7 @@ class ComponentInstall(ComponentCommand):
         else:
             self.installed_by = [self.component_type]
 
-    def install(self, component: Union[str, Dict[str, str]], silent: bool = False) -> bool:
+    def install(self, component: Union[str, dict[str, str]], silent: bool = False) -> bool:
         if isinstance(component, dict):
             # Override modules_repo when the component to install is a dependency from a subworkflow.
             remote_url = component.get("git_remote", self.current_remote.remote_url)

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/lint/__init__.py

@@ -7,7 +7,7 @@ import logging
 import operator
 import os
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import rich.box
 import rich.console
@@ -75,10 +75,10 @@ class ComponentLint(ComponentCommand):
 
         self.fail_warned = fail_warned
         self.fix = fix
-        self.passed: List[LintResult] = []
-        self.warned: List[LintResult] = []
-        self.failed: List[LintResult] = []
-        self.all_local_components: List[NFCoreComponent] = []
+        self.passed: list[LintResult] = []
+        self.warned: list[LintResult] = []
+        self.failed: list[LintResult] = []
+        self.all_local_components: list[NFCoreComponent] = []
 
         self.lint_config: Optional[NFCoreYamlLintConfig] = None
         self.modules_json: Optional[ModulesJson] = None
@@ -96,7 +96,7 @@ class ComponentLint(ComponentCommand):
         if self.repo_type == "pipeline":
             modules_json = ModulesJson(self.directory)
             modules_json.check_up_to_date()
-            self.all_remote_components: List[NFCoreComponent] = []
+            self.all_remote_components: list[NFCoreComponent] = []
             for repo_url, components in modules_json.get_all_components(self.component_type).items():
                 if remote_url is not None and remote_url != repo_url:
                     continue

{nf_core-3.3.1 → nf_core-3.3.2}/nf_core/components/list.py

@@ -1,7 +1,7 @@
 import json
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Union, cast
+from typing import Optional, Union, cast
 
 import rich.table
 
@@ -35,7 +35,7 @@ class ComponentList(ComponentCommand):
         return super()._configure_repo_and_paths(nf_dir_req)
 
     def list_components(
-        self, keywords: Optional[List[str]] = None, print_json: bool = False
+        self, keywords: Optional[list[str]] = None, print_json: bool = False
     ) -> Union[rich.table.Table, str]:
         keywords = keywords or []
         """
@@ -48,9 +48,9 @@ class ComponentList(ComponentCommand):
         # Initialise rich table
         table: rich.table.Table = rich.table.Table()
         table.add_column(f"{self.component_type[:-1].capitalize()} Name")
-        components: List[str] = []
+        components: list[str] = []
 
-        def pattern_msg(keywords: List[str]) -> str:
+        def pattern_msg(keywords: list[str]) -> str:
             if len(keywords) == 0:
                 return ""
             if len(keywords) == 1:
@@ -122,7 +122,7 @@ class ComponentList(ComponentCommand):
             modules_json_file = modules_json.modules_json
 
             for repo_url, component_with_dir in sorted(repos_with_comps.items()):
-                repo_entry: Dict[str, Dict[str, Dict[str, ModulesJsonModuleEntry]]]
+                repo_entry: dict[str, dict[str, dict[str, ModulesJsonModuleEntry]]]
                 if modules_json_file is None:
                     log.warning(f"Modules JSON file '{modules_json.modules_json_path}' is missing. ")
                     continue