niwrap-freesurfer 0.6.3__py3-none-any.whl → 0.7.0__py3-none-any.whl

niwrap_freesurfer/freesurfer/mri_surfcluster.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 MRI_SURFCLUSTER_METADATA = Metadata(
-    id="a70520f8f1d486263670ae25cac56adca853556b.boutiques",
+    id="a026259ace10c47ec693dbcac84dd7e6a8a41cbe.boutiques",
     name="mri_surfcluster",
     package="freesurfer",
     container_image_tag="freesurfer/freesurfer:7.4.1",
@@ -14,7 +14,51 @@ MRI_SURFCLUSTER_METADATA = Metadata(
 
 
 MriSurfclusterParameters = typing.TypedDict('MriSurfclusterParameters', {
-    "__STYXTYPE__": typing.Literal["mri_surfcluster"],
+    "@type": typing.NotRequired[typing.Literal["freesurfer/mri_surfcluster"]],
+    "infile": InputPathType,
+    "thmin": typing.NotRequired[float | None],
+    "sign": typing.NotRequired[str | None],
+    "no_adjust_flag": bool,
+    "fdr": typing.NotRequired[float | None],
+    "subject": typing.NotRequired[str | None],
+    "hemi": typing.NotRequired[str | None],
+    "surf": typing.NotRequired[str | None],
+    "surfpath": typing.NotRequired[str | None],
+    "annot": typing.NotRequired[str | None],
+    "frame": typing.NotRequired[float | None],
+    "csd": typing.NotRequired[list[InputPathType] | None],
+    "vwsig": typing.NotRequired[str | None],
+    "cwsig": typing.NotRequired[str | None],
+    "maxcwpval": typing.NotRequired[str | None],
+    "bonferroni": typing.NotRequired[float | None],
+    "sig2p_max_flag": bool,
+    "bonferroni_max": typing.NotRequired[float | None],
+    "csdpdf": typing.NotRequired[str | None],
+    "csdpdf_only_flag": bool,
+    "csd_out": typing.NotRequired[InputPathType | None],
+    "cwpvalthresh": typing.NotRequired[float | None],
+    "fwhm": typing.NotRequired[float | None],
+    "fwhmdat": typing.NotRequired[str | None],
+    "clabel": typing.NotRequired[InputPathType | None],
+    "cortex_flag": bool,
+    "mask": typing.NotRequired[InputPathType | None],
+    "mask_inv_flag": bool,
+    "centroid_flag": bool,
+    "sum": typing.NotRequired[InputPathType | None],
+    "pointset": typing.NotRequired[InputPathType | None],
+    "maxareafile": typing.NotRequired[str | None],
+    "o": typing.NotRequired[str | None],
+    "ocn": typing.NotRequired[str | None],
+    "olab": typing.NotRequired[str | None],
+    "oannot": typing.NotRequired[str | None],
+    "minarea": typing.NotRequired[float | None],
+    "xfm": typing.NotRequired[InputPathType | None],
+    "no_fixmni_flag": bool,
+    "sd": typing.NotRequired[str | None],
+    "thmax": typing.NotRequired[float | None],
+})
+MriSurfclusterParametersTagged = typing.TypedDict('MriSurfclusterParametersTagged', {
+    "@type": typing.Literal["freesurfer/mri_surfcluster"],
     "infile": InputPathType,
     "thmin": typing.NotRequired[float | None],
     "sign": typing.NotRequired[str | None],
@@ -57,43 +101,11 @@ MriSurfclusterParameters = typing.TypedDict('MriSurfclusterParameters', {
     "sd": typing.NotRequired[str | None],
     "thmax": typing.NotRequired[float | None],
 })
-
-
-def dyn_cargs(
-    t: str,
-) -> typing.Any:
-    """
-    Get build cargs function by command type.
-    
-    Args:
-        t: Command type.
-    Returns:
-        Build cargs function.
-    """
-    return {
-        "mri_surfcluster": mri_surfcluster_cargs,
-    }.get(t)
-
-
-def dyn_outputs(
-    t: str,
-) -> typing.Any:
-    """
-    Get build outputs function by command type.
-    
-    Args:
-        t: Command type.
-    Returns:
-        Build outputs function.
-    """
-    return {
-        "mri_surfcluster": mri_surfcluster_outputs,
-    }.get(t)
 
 
 class MriSurfclusterOutputs(typing.NamedTuple):
     """
-    Output object returned when calling `mri_surfcluster(...)`.
+    Output object returned when calling `MriSurfclusterParameters(...)`.
     """
     root: OutputPathType
     """Output root folder. This is the root folder for all outputs."""
@@ -153,7 +165,7 @@ def mri_surfcluster_params(
     no_fixmni_flag: bool = False,
     sd: str | None = None,
     thmax: float | None = None,
-) -> MriSurfclusterParameters:
+) -> MriSurfclusterParametersTagged:
     """
     Build parameters.
     
@@ -203,7 +215,7 @@ def mri_surfcluster_params(
         Parameter dictionary
     """
     params = {
-        "__STYXTYPE__": "mri_surfcluster",
+        "@type": "freesurfer/mri_surfcluster",
         "infile": infile,
         "no_adjust_flag": no_adjust_flag,
         "sig2p_max_flag": sig2p_max_flag,
@@ -299,186 +311,186 @@ def mri_surfcluster_cargs(
     cargs.append("mri_surfcluster")
     cargs.extend([
         "--in",
-        execution.input_file(params.get("infile"))
+        execution.input_file(params.get("infile", None))
     ])
-    if params.get("thmin") is not None:
+    if params.get("thmin", None) is not None:
         cargs.extend([
             "--thmin",
-            str(params.get("thmin"))
+            str(params.get("thmin", None))
         ])
-    if params.get("sign") is not None:
+    if params.get("sign", None) is not None:
         cargs.extend([
             "--sign",
-            params.get("sign")
+            params.get("sign", None)
         ])
-    if params.get("no_adjust_flag"):
+    if params.get("no_adjust_flag", False):
         cargs.append("--no-adjust")
-    if params.get("fdr") is not None:
+    if params.get("fdr", None) is not None:
         cargs.extend([
             "--fdr",
-            str(params.get("fdr"))
+            str(params.get("fdr", None))
         ])
-    if params.get("subject") is not None:
+    if params.get("subject", None) is not None:
         cargs.extend([
             "--subject",
-            params.get("subject")
+            params.get("subject", None)
         ])
-    if params.get("hemi") is not None:
+    if params.get("hemi", None) is not None:
         cargs.extend([
             "--hemi",
-            params.get("hemi")
+            params.get("hemi", None)
         ])
-    if params.get("surf") is not None:
+    if params.get("surf", None) is not None:
         cargs.extend([
             "--surf",
-            params.get("surf")
+            params.get("surf", None)
         ])
-    if params.get("surfpath") is not None:
+    if params.get("surfpath", None) is not None:
         cargs.extend([
             "--surfpath",
-            params.get("surfpath")
+            params.get("surfpath", None)
         ])
-    if params.get("annot") is not None:
+    if params.get("annot", None) is not None:
         cargs.extend([
             "--annot",
-            params.get("annot")
+            params.get("annot", None)
         ])
-    if params.get("frame") is not None:
+    if params.get("frame", None) is not None:
         cargs.extend([
             "--frame",
-            str(params.get("frame"))
+            str(params.get("frame", None))
         ])
-    if params.get("csd") is not None:
+    if params.get("csd", None) is not None:
         cargs.extend([
             "--csd",
-            *[execution.input_file(f) for f in params.get("csd")]
+            *[execution.input_file(f) for f in params.get("csd", None)]
         ])
-    if params.get("vwsig") is not None:
+    if params.get("vwsig", None) is not None:
         cargs.extend([
             "--vwsig",
-            params.get("vwsig")
+            params.get("vwsig", None)
         ])
-    if params.get("cwsig") is not None:
+    if params.get("cwsig", None) is not None:
         cargs.extend([
             "--cwsig",
-            params.get("cwsig")
+            params.get("cwsig", None)
         ])
-    if params.get("maxcwpval") is not None:
+    if params.get("maxcwpval", None) is not None:
         cargs.extend([
             "--maxcwpval",
-            params.get("maxcwpval")
+            params.get("maxcwpval", None)
         ])
-    if params.get("bonferroni") is not None:
+    if params.get("bonferroni", None) is not None:
         cargs.extend([
             "--bonferroni",
-            str(params.get("bonferroni"))
+            str(params.get("bonferroni", None))
         ])
-    if params.get("sig2p_max_flag"):
+    if params.get("sig2p_max_flag", False):
         cargs.append("--sig2p-max")
-    if params.get("bonferroni_max") is not None:
+    if params.get("bonferroni_max", None) is not None:
         cargs.extend([
             "--bonferroni-max",
-            str(params.get("bonferroni_max"))
+            str(params.get("bonferroni_max", None))
         ])
-    if params.get("csdpdf") is not None:
+    if params.get("csdpdf", None) is not None:
         cargs.extend([
             "--csdpdf",
-            params.get("csdpdf")
+            params.get("csdpdf", None)
         ])
-    if params.get("csdpdf_only_flag"):
+    if params.get("csdpdf_only_flag", False):
         cargs.append("--csdpdf-only")
-    if params.get("csd_out") is not None:
+    if params.get("csd_out", None) is not None:
         cargs.extend([
             "--csd-out",
-            execution.input_file(params.get("csd_out"))
+            execution.input_file(params.get("csd_out", None))
         ])
-    if params.get("cwpvalthresh") is not None:
+    if params.get("cwpvalthresh", None) is not None:
         cargs.extend([
             "--cwpvalthresh",
-            str(params.get("cwpvalthresh"))
+            str(params.get("cwpvalthresh", None))
         ])
-    if params.get("fwhm") is not None:
+    if params.get("fwhm", None) is not None:
         cargs.extend([
             "--fwhm",
-            str(params.get("fwhm"))
+            str(params.get("fwhm", None))
         ])
-    if params.get("fwhmdat") is not None:
+    if params.get("fwhmdat", None) is not None:
         cargs.extend([
             "--fwhmdat",
-            params.get("fwhmdat")
+            params.get("fwhmdat", None)
         ])
-    if params.get("clabel") is not None:
+    if params.get("clabel", None) is not None:
         cargs.extend([
             "--clabel",
-            execution.input_file(params.get("clabel"))
+            execution.input_file(params.get("clabel", None))
         ])
-    if params.get("cortex_flag"):
+    if params.get("cortex_flag", False):
         cargs.append("--cortex")
-    if params.get("mask") is not None:
+    if params.get("mask", None) is not None:
         cargs.extend([
             "--mask",
-            execution.input_file(params.get("mask"))
+            execution.input_file(params.get("mask", None))
         ])
-    if params.get("mask_inv_flag"):
+    if params.get("mask_inv_flag", False):
         cargs.append("--mask-inv")
-    if params.get("centroid_flag"):
+    if params.get("centroid_flag", False):
         cargs.append("--centroid")
-    if params.get("sum") is not None:
+    if params.get("sum", None) is not None:
         cargs.extend([
             "--sum",
-            execution.input_file(params.get("sum"))
+            execution.input_file(params.get("sum", None))
         ])
-    if params.get("pointset") is not None:
+    if params.get("pointset", None) is not None:
         cargs.extend([
             "--pointset",
-            execution.input_file(params.get("pointset"))
+            execution.input_file(params.get("pointset", None))
         ])
-    if params.get("maxareafile") is not None:
+    if params.get("maxareafile", None) is not None:
         cargs.extend([
             "--maxareafile",
-            params.get("maxareafile")
+            params.get("maxareafile", None)
         ])
-    if params.get("o") is not None:
+    if params.get("o", None) is not None:
         cargs.extend([
             "--o",
-            params.get("o")
+            params.get("o", None)
         ])
-    if params.get("ocn") is not None:
+    if params.get("ocn", None) is not None:
         cargs.extend([
             "--ocn",
-            params.get("ocn")
+            params.get("ocn", None)
         ])
-    if params.get("olab") is not None:
+    if params.get("olab", None) is not None:
         cargs.extend([
             "--olab",
-            params.get("olab")
+            params.get("olab", None)
         ])
-    if params.get("oannot") is not None:
+    if params.get("oannot", None) is not None:
         cargs.extend([
             "--oannot",
-            params.get("oannot")
+            params.get("oannot", None)
         ])
-    if params.get("minarea") is not None:
+    if params.get("minarea", None) is not None:
         cargs.extend([
             "--minarea",
-            str(params.get("minarea"))
+            str(params.get("minarea", None))
         ])
-    if params.get("xfm") is not None:
+    if params.get("xfm", None) is not None:
         cargs.extend([
             "--xfm",
-            execution.input_file(params.get("xfm"))
+            execution.input_file(params.get("xfm", None))
         ])
-    if params.get("no_fixmni_flag"):
+    if params.get("no_fixmni_flag", False):
         cargs.append("--nofixmni")
-    if params.get("sd") is not None:
+    if params.get("sd", None) is not None:
         cargs.extend([
             "--sd",
-            params.get("sd")
+            params.get("sd", None)
         ])
-    if params.get("thmax") is not None:
+    if params.get("thmax", None) is not None:
         cargs.extend([
             "--thmax",
-            str(params.get("thmax"))
+            str(params.get("thmax", None))
         ])
     return cargs
 
@@ -498,22 +510,25 @@ def mri_surfcluster_outputs(
     """
     ret = MriSurfclusterOutputs(
         root=execution.output_file("."),
-        output_surface_file=execution.output_file(params.get("o")) if (params.get("o") is not None) else None,
-        output_cluster_number_file=execution.output_file(params.get("ocn")) if (params.get("ocn") is not None) else None,
-        output_labels=execution.output_file(params.get("olab") + "-*.label") if (params.get("olab") is not None) else None,
-        output_summary_file=execution.output_file(pathlib.Path(params.get("sum")).name) if (params.get("sum") is not None) else None,
-        output_pointset_file=execution.output_file(pathlib.Path(params.get("pointset")).name) if (params.get("pointset") is not None) else None,
-        output_max_area_file=execution.output_file(params.get("maxareafile")) if (params.get("maxareafile") is not None) else None,
+        output_surface_file=execution.output_file(params.get("o", None)) if (params.get("o") is not None) else None,
+        output_cluster_number_file=execution.output_file(params.get("ocn", None)) if (params.get("ocn") is not None) else None,
+        output_labels=execution.output_file(params.get("olab", None) + "-" + params.get("ocn", None) + ".label") if (params.get("olab") is not None and params.get("ocn") is not None) else None,
+        output_summary_file=execution.output_file(pathlib.Path(params.get("sum", None)).name) if (params.get("sum") is not None) else None,
+        output_pointset_file=execution.output_file(pathlib.Path(params.get("pointset", None)).name) if (params.get("pointset") is not None) else None,
+        output_max_area_file=execution.output_file(params.get("maxareafile", None)) if (params.get("maxareafile") is not None) else None,
     )
     return ret
 
 
 def mri_surfcluster_execute(
     params: MriSurfclusterParameters,
-    execution: Execution,
+    runner: Runner | None = None,
 ) -> MriSurfclusterOutputs:
     """
-    A tool for clustering vertices on a cortical surface based on intensity values.
+    mri_surfcluster
+    
+    A tool for clustering vertices on a cortical surface based on intensity
+    values.
     
     Author: FreeSurfer Developers
     
@@ -521,10 +536,12 @@ def mri_surfcluster_execute(
     
     Args:
         params: The parameters.
-        execution: The execution object.
+        runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `MriSurfclusterOutputs`).
     """
+    runner = runner or get_global_runner()
+    execution = runner.start_execution(MRI_SURFCLUSTER_METADATA)
     params = execution.params(params)
     cargs = mri_surfcluster_cargs(params, execution)
     ret = mri_surfcluster_outputs(params, execution)
@@ -577,7 +594,10 @@ def mri_surfcluster(
     runner: Runner | None = None,
 ) -> MriSurfclusterOutputs:
     """
-    A tool for clustering vertices on a cortical surface based on intensity values.
+    mri_surfcluster
+    
+    A tool for clustering vertices on a cortical surface based on intensity
+    values.
     
     Author: FreeSurfer Developers
     
@@ -629,8 +649,6 @@ def mri_surfcluster(
     Returns:
         NamedTuple of outputs (described in `MriSurfclusterOutputs`).
     """
-    runner = runner or get_global_runner()
-    execution = runner.start_execution(MRI_SURFCLUSTER_METADATA)
     params = mri_surfcluster_params(
         infile=infile,
         thmin=thmin,
@@ -674,13 +692,13 @@ def mri_surfcluster(
         sd=sd,
         thmax=thmax,
     )
-    return mri_surfcluster_execute(params, execution)
+    return mri_surfcluster_execute(params, runner)
 
 
 __all__ = [
     "MRI_SURFCLUSTER_METADATA",
     "MriSurfclusterOutputs",
-    "MriSurfclusterParameters",
     "mri_surfcluster",
+    "mri_surfcluster_execute",
     "mri_surfcluster_params",
 ]

niwrap_freesurfer/freesurfer/mri_synthesize.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 MRI_SYNTHESIZE_METADATA = Metadata(
-    id="56ff973d99ba2ebaf94ee5e56f8fa7a203776506.boutiques",
+    id="a769307e9148cec6cb318cbc086531f5ca267908.boutiques",
     name="mri_synthesize",
     package="freesurfer",
     container_image_tag="freesurfer/freesurfer:7.4.1",
@@ -14,7 +14,17 @@ MRI_SYNTHESIZE_METADATA = Metadata(
 
 
 MriSynthesizeParameters = typing.TypedDict('MriSynthesizeParameters', {
-    "__STYXTYPE__": typing.Literal["mri_synthesize"],
+    "@type": typing.NotRequired[typing.Literal["freesurfer/mri_synthesize"]],
+    "tr": float,
+    "alpha": float,
+    "te": float,
+    "t1_volume": InputPathType,
+    "pd_volume": InputPathType,
+    "output_volume": str,
+    "fixed_weight": bool,
+})
+MriSynthesizeParametersTagged = typing.TypedDict('MriSynthesizeParametersTagged', {
+    "@type": typing.Literal["freesurfer/mri_synthesize"],
     "tr": float,
     "alpha": float,
     "te": float,
@@ -23,43 +33,11 @@ MriSynthesizeParameters = typing.TypedDict('MriSynthesizeParameters', {
     "output_volume": str,
     "fixed_weight": bool,
 })
-
-
-def dyn_cargs(
-    t: str,
-) -> typing.Any:
-    """
-    Get build cargs function by command type.
-    
-    Args:
-        t: Command type.
-    Returns:
-        Build cargs function.
-    """
-    return {
-        "mri_synthesize": mri_synthesize_cargs,
-    }.get(t)
-
-
-def dyn_outputs(
-    t: str,
-) -> typing.Any:
-    """
-    Get build outputs function by command type.
-    
-    Args:
-        t: Command type.
-    Returns:
-        Build outputs function.
-    """
-    return {
-        "mri_synthesize": mri_synthesize_outputs,
-    }.get(t)
 
 
 class MriSynthesizeOutputs(typing.NamedTuple):
     """
-    Output object returned when calling `mri_synthesize(...)`.
+    Output object returned when calling `MriSynthesizeParameters(...)`.
     """
     root: OutputPathType
     """Output root folder. This is the root folder for all outputs."""
@@ -75,7 +53,7 @@ def mri_synthesize_params(
     pd_volume: InputPathType,
     output_volume: str,
     fixed_weight: bool = False,
-) -> MriSynthesizeParameters:
+) -> MriSynthesizeParametersTagged:
     """
     Build parameters.
     
@@ -92,7 +70,7 @@ def mri_synthesize_params(
         Parameter dictionary
     """
     params = {
-        "__STYXTYPE__": "mri_synthesize",
+        "@type": "freesurfer/mri_synthesize",
         "tr": tr,
         "alpha": alpha,
         "te": te,
@@ -119,13 +97,13 @@ def mri_synthesize_cargs(
     """
     cargs = []
     cargs.append("mri_synthesize")
-    cargs.append(str(params.get("tr")))
-    cargs.append(str(params.get("alpha")))
-    cargs.append(str(params.get("te")))
-    cargs.append(execution.input_file(params.get("t1_volume")))
-    cargs.append(execution.input_file(params.get("pd_volume")))
-    cargs.append(params.get("output_volume"))
-    if params.get("fixed_weight"):
+    cargs.append(str(params.get("tr", None)))
+    cargs.append(str(params.get("alpha", None)))
+    cargs.append(str(params.get("te", None)))
+    cargs.append(execution.input_file(params.get("t1_volume", None)))
+    cargs.append(execution.input_file(params.get("pd_volume", None)))
+    cargs.append(params.get("output_volume", None))
+    if params.get("fixed_weight", False):
         cargs.append("-w")
     return cargs
 
@@ -145,18 +123,20 @@ def mri_synthesize_outputs(
     """
     ret = MriSynthesizeOutputs(
         root=execution.output_file("."),
-        synthesized_output=execution.output_file(params.get("output_volume")),
+        synthesized_output=execution.output_file(params.get("output_volume", None)),
     )
     return ret
 
 
 def mri_synthesize_execute(
     params: MriSynthesizeParameters,
-    execution: Execution,
+    runner: Runner | None = None,
 ) -> MriSynthesizeOutputs:
     """
-    This program synthesizes a FLASH acquisition based on previously computed T1/PD
-    maps.
+    mri_synthesize
+    
+    This program synthesizes a FLASH acquisition based on previously computed
+    T1/PD maps.
     
     Author: FreeSurfer Developers
     
@@ -164,10 +144,12 @@ def mri_synthesize_execute(
     
     Args:
         params: The parameters.
-        execution: The execution object.
+        runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `MriSynthesizeOutputs`).
     """
+    runner = runner or get_global_runner()
+    execution = runner.start_execution(MRI_SYNTHESIZE_METADATA)
     params = execution.params(params)
     cargs = mri_synthesize_cargs(params, execution)
     ret = mri_synthesize_outputs(params, execution)
@@ -186,8 +168,10 @@ def mri_synthesize(
     runner: Runner | None = None,
 ) -> MriSynthesizeOutputs:
     """
-    This program synthesizes a FLASH acquisition based on previously computed T1/PD
-    maps.
+    mri_synthesize
+    
+    This program synthesizes a FLASH acquisition based on previously computed
+    T1/PD maps.
     
     Author: FreeSurfer Developers
     
@@ -206,8 +190,6 @@ def mri_synthesize(
     Returns:
         NamedTuple of outputs (described in `MriSynthesizeOutputs`).
     """
-    runner = runner or get_global_runner()
-    execution = runner.start_execution(MRI_SYNTHESIZE_METADATA)
     params = mri_synthesize_params(
         tr=tr,
         alpha=alpha,
@@ -217,13 +199,13 @@ def mri_synthesize(
         output_volume=output_volume,
         fixed_weight=fixed_weight,
     )
-    return mri_synthesize_execute(params, execution)
+    return mri_synthesize_execute(params, runner)
 
 
 __all__ = [
     "MRI_SYNTHESIZE_METADATA",
     "MriSynthesizeOutputs",
-    "MriSynthesizeParameters",
     "mri_synthesize",
+    "mri_synthesize_execute",
     "mri_synthesize_params",
 ]