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

niwrap_freesurfer/freesurfer/mri_nlfilter.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 MRI_NLFILTER_METADATA = Metadata(
-    id="cd1ced10246857559467c066938c4cbc7f28bb86.boutiques",
+    id="23de2ae2399b79ac780aae37dab02ab79aba495e.boutiques",
     name="mri_nlfilter",
     package="freesurfer",
     container_image_tag="freesurfer/freesurfer:7.4.1",
@@ -14,7 +14,22 @@ MRI_NLFILTER_METADATA = Metadata(
 
 
 MriNlfilterParameters = typing.TypedDict('MriNlfilterParameters', {
-    "__STYXTYPE__": typing.Literal["mri_nlfilter"],
+    "@type": typing.NotRequired[typing.Literal["freesurfer/mri_nlfilter"]],
+    "input_image": InputPathType,
+    "output_image": str,
+    "blur_sigma": typing.NotRequired[float | None],
+    "gaussian_sigma": typing.NotRequired[float | None],
+    "mean_flag": bool,
+    "window_size": typing.NotRequired[float | None],
+    "cplov_flag": bool,
+    "minmax_flag": bool,
+    "no_offsets_flag": bool,
+    "no_crop_flag": bool,
+    "version_flag": bool,
+    "help_flag": bool,
+})
+MriNlfilterParametersTagged = typing.TypedDict('MriNlfilterParametersTagged', {
+    "@type": typing.Literal["freesurfer/mri_nlfilter"],
     "input_image": InputPathType,
     "output_image": str,
     "blur_sigma": typing.NotRequired[float | None],
@@ -28,43 +43,11 @@ MriNlfilterParameters = typing.TypedDict('MriNlfilterParameters', {
     "version_flag": bool,
     "help_flag": 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_nlfilter": mri_nlfilter_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_nlfilter": mri_nlfilter_outputs,
-    }.get(t)
 
 
 class MriNlfilterOutputs(typing.NamedTuple):
     """
-    Output object returned when calling `mri_nlfilter(...)`.
+    Output object returned when calling `MriNlfilterParameters(...)`.
     """
     root: OutputPathType
     """Output root folder. This is the root folder for all outputs."""
@@ -85,7 +68,7 @@ def mri_nlfilter_params(
     no_crop_flag: bool = False,
     version_flag: bool = False,
     help_flag: bool = False,
-) -> MriNlfilterParameters:
+) -> MriNlfilterParametersTagged:
     """
     Build parameters.
     
@@ -109,7 +92,7 @@ def mri_nlfilter_params(
         Parameter dictionary
     """
     params = {
-        "__STYXTYPE__": "mri_nlfilter",
+        "@type": "freesurfer/mri_nlfilter",
         "input_image": input_image,
         "output_image": output_image,
         "mean_flag": mean_flag,
@@ -144,36 +127,36 @@ def mri_nlfilter_cargs(
     """
     cargs = []
     cargs.append("mri_nlfilter")
-    cargs.append(execution.input_file(params.get("input_image")))
-    cargs.append(params.get("output_image"))
-    if params.get("blur_sigma") is not None:
+    cargs.append(execution.input_file(params.get("input_image", None)))
+    cargs.append(params.get("output_image", None))
+    if params.get("blur_sigma", None) is not None:
         cargs.extend([
             "-blur",
-            str(params.get("blur_sigma"))
+            str(params.get("blur_sigma", None))
         ])
-    if params.get("gaussian_sigma") is not None:
+    if params.get("gaussian_sigma", None) is not None:
         cargs.extend([
             "-gaussian",
-            str(params.get("gaussian_sigma"))
+            str(params.get("gaussian_sigma", None))
         ])
-    if params.get("mean_flag"):
+    if params.get("mean_flag", False):
         cargs.append("-mean")
-    if params.get("window_size") is not None:
+    if params.get("window_size", None) is not None:
         cargs.extend([
             "-w",
-            str(params.get("window_size"))
+            str(params.get("window_size", None))
         ])
-    if params.get("cplov_flag"):
+    if params.get("cplov_flag", False):
         cargs.append("-cplov")
-    if params.get("minmax_flag"):
+    if params.get("minmax_flag", False):
         cargs.append("-minmax")
-    if params.get("no_offsets_flag"):
+    if params.get("no_offsets_flag", False):
         cargs.append("-n")
-    if params.get("no_crop_flag"):
+    if params.get("no_crop_flag", False):
         cargs.append("-nc")
-    if params.get("version_flag"):
+    if params.get("version_flag", False):
         cargs.append("--version")
-    if params.get("help_flag"):
+    if params.get("help_flag", False):
         cargs.append("--help")
     return cargs
 
@@ -193,19 +176,21 @@ def mri_nlfilter_outputs(
     """
     ret = MriNlfilterOutputs(
         root=execution.output_file("."),
-        output_file=execution.output_file(params.get("output_image")),
+        output_file=execution.output_file(params.get("output_image", None)),
     )
     return ret
 
 
 def mri_nlfilter_execute(
     params: MriNlfilterParameters,
-    execution: Execution,
+    runner: Runner | None = None,
 ) -> MriNlfilterOutputs:
     """
-    This program processes an image using a nonlocal filter and writes the results
-    to an output file. It supports different filtering methods such as median,
-    Gaussian, and mean.
+    mri_nlfilter
+    
+    This program processes an image using a nonlocal filter and writes the
+    results to an output file. It supports different filtering methods such as
+    median, Gaussian, and mean.
     
     Author: FreeSurfer Developers
     
@@ -213,10 +198,12 @@ def mri_nlfilter_execute(
     
     Args:
         params: The parameters.
-        execution: The execution object.
+        runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `MriNlfilterOutputs`).
     """
+    runner = runner or get_global_runner()
+    execution = runner.start_execution(MRI_NLFILTER_METADATA)
     params = execution.params(params)
     cargs = mri_nlfilter_cargs(params, execution)
     ret = mri_nlfilter_outputs(params, execution)
@@ -240,9 +227,11 @@ def mri_nlfilter(
     runner: Runner | None = None,
 ) -> MriNlfilterOutputs:
     """
-    This program processes an image using a nonlocal filter and writes the results
-    to an output file. It supports different filtering methods such as median,
-    Gaussian, and mean.
+    mri_nlfilter
+    
+    This program processes an image using a nonlocal filter and writes the
+    results to an output file. It supports different filtering methods such as
+    median, Gaussian, and mean.
     
     Author: FreeSurfer Developers
     
@@ -268,8 +257,6 @@ def mri_nlfilter(
     Returns:
         NamedTuple of outputs (described in `MriNlfilterOutputs`).
     """
-    runner = runner or get_global_runner()
-    execution = runner.start_execution(MRI_NLFILTER_METADATA)
     params = mri_nlfilter_params(
         input_image=input_image,
         output_image=output_image,
@@ -284,13 +271,13 @@ def mri_nlfilter(
         version_flag=version_flag,
         help_flag=help_flag,
     )
-    return mri_nlfilter_execute(params, execution)
+    return mri_nlfilter_execute(params, runner)
 
 
 __all__ = [
     "MRI_NLFILTER_METADATA",
     "MriNlfilterOutputs",
-    "MriNlfilterParameters",
     "mri_nlfilter",
+    "mri_nlfilter_execute",
     "mri_nlfilter_params",
 ]

niwrap_freesurfer/freesurfer/mri_normalize.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 MRI_NORMALIZE_METADATA = Metadata(
-    id="b2271358abe9a80870f26f922619f2ec9097eaf2.boutiques",
+    id="f56b43eac4e79a9494c46feaac6f223c543d3741.boutiques",
     name="mri_normalize",
     package="freesurfer",
     container_image_tag="freesurfer/freesurfer:7.4.1",
@@ -14,7 +14,44 @@ MRI_NORMALIZE_METADATA = Metadata(
 
 
 MriNormalizeParameters = typing.TypedDict('MriNormalizeParameters', {
-    "__STYXTYPE__": typing.Literal["mri_normalize"],
+    "@type": typing.NotRequired[typing.Literal["freesurfer/mri_normalize"]],
+    "input_vol": InputPathType,
+    "output_vol": str,
+    "norm_iters": typing.NotRequired[float | None],
+    "disable_1d": bool,
+    "nonmax_suppress": typing.NotRequired[float | None],
+    "conform": bool,
+    "nonconform": bool,
+    "gentle": bool,
+    "control_points": typing.NotRequired[InputPathType | None],
+    "fonly_control_points": typing.NotRequired[InputPathType | None],
+    "lonly_labels": typing.NotRequired[InputPathType | None],
+    "labels": typing.NotRequired[InputPathType | None],
+    "write_volumes": typing.NotRequired[str | None],
+    "intensity_above": typing.NotRequired[float | None],
+    "intensity_below": typing.NotRequired[float | None],
+    "intensity_gradient": typing.NotRequired[float | None],
+    "prune": bool,
+    "no_gentle_cp": bool,
+    "mask_file": typing.NotRequired[InputPathType | None],
+    "atlas_transform": typing.NotRequired[str | None],
+    "noskull": bool,
+    "monkey": bool,
+    "nosnr": bool,
+    "sigma_smooth": typing.NotRequired[float | None],
+    "aseg_file": typing.NotRequired[InputPathType | None],
+    "debug_v": typing.NotRequired[str | None],
+    "debug_d": typing.NotRequired[str | None],
+    "renorm_vol": typing.NotRequired[InputPathType | None],
+    "checknorm_vol": typing.NotRequired[str | None],
+    "load_read_cp": typing.NotRequired[str | None],
+    "cp_output_vol": typing.NotRequired[InputPathType | None],
+    "surface_transform": typing.NotRequired[str | None],
+    "seed_value": typing.NotRequired[float | None],
+    "print_help": bool,
+})
+MriNormalizeParametersTagged = typing.TypedDict('MriNormalizeParametersTagged', {
+    "@type": typing.Literal["freesurfer/mri_normalize"],
     "input_vol": InputPathType,
     "output_vol": str,
     "norm_iters": typing.NotRequired[float | None],
@@ -50,43 +87,11 @@ MriNormalizeParameters = typing.TypedDict('MriNormalizeParameters', {
     "seed_value": typing.NotRequired[float | None],
     "print_help": 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_normalize": mri_normalize_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_normalize": mri_normalize_outputs,
-    }.get(t)
 
 
 class MriNormalizeOutputs(typing.NamedTuple):
     """
-    Output object returned when calling `mri_normalize(...)`.
+    Output object returned when calling `MriNormalizeParameters(...)`.
     """
     root: OutputPathType
     """Output root folder. This is the root folder for all outputs."""
@@ -131,7 +136,7 @@ def mri_normalize_params(
     surface_transform: str | None = None,
     seed_value: float | None = None,
     print_help: bool = False,
-) -> MriNormalizeParameters:
+) -> MriNormalizeParametersTagged:
     """
     Build parameters.
     
@@ -182,7 +187,7 @@ def mri_normalize_params(
         Parameter dictionary
     """
     params = {
-        "__STYXTYPE__": "mri_normalize",
+        "@type": "freesurfer/mri_normalize",
         "input_vol": input_vol,
         "output_vol": output_vol,
         "disable_1d": disable_1d,
@@ -258,137 +263,137 @@ def mri_normalize_cargs(
     """
     cargs = []
     cargs.append("mri_normalize")
-    cargs.append(execution.input_file(params.get("input_vol")))
-    cargs.append(params.get("output_vol"))
-    if params.get("norm_iters") is not None:
+    cargs.append(execution.input_file(params.get("input_vol", None)))
+    cargs.append(params.get("output_vol", None))
+    if params.get("norm_iters", None) is not None:
         cargs.extend([
             "-n",
-            str(params.get("norm_iters"))
+            str(params.get("norm_iters", None))
         ])
-    if params.get("disable_1d"):
+    if params.get("disable_1d", False):
         cargs.append("-no1d")
-    if params.get("nonmax_suppress") is not None:
+    if params.get("nonmax_suppress", None) is not None:
         cargs.extend([
             "-nonmax_suppress",
-            str(params.get("nonmax_suppress"))
+            str(params.get("nonmax_suppress", None))
         ])
-    if params.get("conform"):
+    if params.get("conform", False):
         cargs.append("-conform")
-    if params.get("nonconform"):
+    if params.get("nonconform", False):
         cargs.append("-noconform")
-    if params.get("gentle"):
+    if params.get("gentle", False):
         cargs.append("-gentle")
-    if params.get("control_points") is not None:
+    if params.get("control_points", None) is not None:
         cargs.extend([
             "-f",
-            execution.input_file(params.get("control_points"))
+            execution.input_file(params.get("control_points", None))
         ])
-    if params.get("fonly_control_points") is not None:
+    if params.get("fonly_control_points", None) is not None:
         cargs.extend([
             "-fonly",
-            execution.input_file(params.get("fonly_control_points"))
+            execution.input_file(params.get("fonly_control_points", None))
         ])
-    if params.get("lonly_labels") is not None:
+    if params.get("lonly_labels", None) is not None:
         cargs.extend([
             "-lonly",
-            execution.input_file(params.get("lonly_labels"))
+            execution.input_file(params.get("lonly_labels", None))
         ])
-    if params.get("labels") is not None:
+    if params.get("labels", None) is not None:
         cargs.extend([
             "-label",
-            execution.input_file(params.get("labels"))
+            execution.input_file(params.get("labels", None))
         ])
-    if params.get("write_volumes") is not None:
+    if params.get("write_volumes", None) is not None:
         cargs.extend([
             "-w",
-            params.get("write_volumes")
+            params.get("write_volumes", None)
         ])
-    if params.get("intensity_above") is not None:
+    if params.get("intensity_above", None) is not None:
         cargs.extend([
             "-a",
-            str(params.get("intensity_above"))
+            str(params.get("intensity_above", None))
         ])
-    if params.get("intensity_below") is not None:
+    if params.get("intensity_below", None) is not None:
         cargs.extend([
             "-b",
-            str(params.get("intensity_below"))
+            str(params.get("intensity_below", None))
         ])
-    if params.get("intensity_gradient") is not None:
+    if params.get("intensity_gradient", None) is not None:
         cargs.extend([
             "-g",
-            str(params.get("intensity_gradient"))
+            str(params.get("intensity_gradient", None))
         ])
-    if params.get("prune"):
+    if params.get("prune", False):
         cargs.append("-prune")
-    if params.get("no_gentle_cp"):
+    if params.get("no_gentle_cp", False):
         cargs.append("-no-gentle-cp")
-    if params.get("mask_file") is not None:
+    if params.get("mask_file", None) is not None:
         cargs.extend([
             "-MASK",
-            execution.input_file(params.get("mask_file"))
+            execution.input_file(params.get("mask_file", None))
         ])
-    if params.get("atlas_transform") is not None:
+    if params.get("atlas_transform", None) is not None:
         cargs.extend([
             "-atlas",
-            params.get("atlas_transform")
+            params.get("atlas_transform", None)
         ])
-    if params.get("noskull"):
+    if params.get("noskull", False):
         cargs.append("-noskull")
-    if params.get("monkey"):
+    if params.get("monkey", False):
         cargs.append("-monkey")
-    if params.get("nosnr"):
+    if params.get("nosnr", False):
         cargs.append("-nosnr")
-    if params.get("sigma_smooth") is not None:
+    if params.get("sigma_smooth", None) is not None:
         cargs.extend([
             "-sigma",
-            str(params.get("sigma_smooth"))
+            str(params.get("sigma_smooth", None))
         ])
-    if params.get("aseg_file") is not None:
+    if params.get("aseg_file", None) is not None:
         cargs.extend([
             "-aseg",
-            execution.input_file(params.get("aseg_file"))
+            execution.input_file(params.get("aseg_file", None))
         ])
-    if params.get("debug_v") is not None:
+    if params.get("debug_v", None) is not None:
         cargs.extend([
             "-v",
-            params.get("debug_v")
+            params.get("debug_v", None)
         ])
-    if params.get("debug_d") is not None:
+    if params.get("debug_d", None) is not None:
         cargs.extend([
             "-d",
-            params.get("debug_d")
+            params.get("debug_d", None)
         ])
-    if params.get("renorm_vol") is not None:
+    if params.get("renorm_vol", None) is not None:
         cargs.extend([
             "-renorm",
-            execution.input_file(params.get("renorm_vol"))
+            execution.input_file(params.get("renorm_vol", None))
         ])
-    if params.get("checknorm_vol") is not None:
+    if params.get("checknorm_vol", None) is not None:
         cargs.extend([
             "-checknorm",
-            params.get("checknorm_vol")
+            params.get("checknorm_vol", None)
         ])
-    if params.get("load_read_cp") is not None:
+    if params.get("load_read_cp", None) is not None:
         cargs.extend([
             "-r",
-            params.get("load_read_cp")
+            params.get("load_read_cp", None)
         ])
-    if params.get("cp_output_vol") is not None:
+    if params.get("cp_output_vol", None) is not None:
         cargs.extend([
             "-c",
-            execution.input_file(params.get("cp_output_vol"))
+            execution.input_file(params.get("cp_output_vol", None))
         ])
-    if params.get("surface_transform") is not None:
+    if params.get("surface_transform", None) is not None:
         cargs.extend([
             "-surface",
-            params.get("surface_transform")
+            params.get("surface_transform", None)
         ])
-    if params.get("seed_value") is not None:
+    if params.get("seed_value", None) is not None:
         cargs.extend([
             "-seed",
-            str(params.get("seed_value"))
+            str(params.get("seed_value", None))
         ])
-    if params.get("print_help"):
+    if params.get("print_help", False):
         cargs.append("-u")
     return cargs
 
@@ -408,7 +413,7 @@ def mri_normalize_outputs(
     """
     ret = MriNormalizeOutputs(
         root=execution.output_file("."),
-        output_volume=execution.output_file(params.get("output_vol")),
+        output_volume=execution.output_file(params.get("output_vol", None)),
         controlpoints_output=execution.output_file("controlpoints_volume.nii.gz"),
     )
     return ret
@@ -416,12 +421,14 @@ def mri_normalize_outputs(
 
 def mri_normalize_execute(
     params: MriNormalizeParameters,
-    execution: Execution,
+    runner: Runner | None = None,
 ) -> MriNormalizeOutputs:
     """
-    Normalize the white-matter, optionally based on control points. The input volume
-    is converted into a new volume where white matter image values all range around
-    110.
+    mri_normalize
+    
+    Normalize the white-matter, optionally based on control points. The input
+    volume is converted into a new volume where white matter image values all
+    range around 110.
     
     Author: FreeSurfer Developers
     
@@ -429,10 +436,12 @@ def mri_normalize_execute(
     
     Args:
         params: The parameters.
-        execution: The execution object.
+        runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `MriNormalizeOutputs`).
     """
+    runner = runner or get_global_runner()
+    execution = runner.start_execution(MRI_NORMALIZE_METADATA)
     params = execution.params(params)
     cargs = mri_normalize_cargs(params, execution)
     ret = mri_normalize_outputs(params, execution)
@@ -478,9 +487,11 @@ def mri_normalize(
     runner: Runner | None = None,
 ) -> MriNormalizeOutputs:
     """
-    Normalize the white-matter, optionally based on control points. The input volume
-    is converted into a new volume where white matter image values all range around
-    110.
+    mri_normalize
+    
+    Normalize the white-matter, optionally based on control points. The input
+    volume is converted into a new volume where white matter image values all
+    range around 110.
     
     Author: FreeSurfer Developers
     
@@ -533,8 +544,6 @@ def mri_normalize(
     Returns:
         NamedTuple of outputs (described in `MriNormalizeOutputs`).
     """
-    runner = runner or get_global_runner()
-    execution = runner.start_execution(MRI_NORMALIZE_METADATA)
     params = mri_normalize_params(
         input_vol=input_vol,
         output_vol=output_vol,
@@ -571,13 +580,13 @@ def mri_normalize(
         seed_value=seed_value,
         print_help=print_help,
     )
-    return mri_normalize_execute(params, execution)
+    return mri_normalize_execute(params, runner)
 
 
 __all__ = [
     "MRI_NORMALIZE_METADATA",
     "MriNormalizeOutputs",
-    "MriNormalizeParameters",
     "mri_normalize",
+    "mri_normalize_execute",
     "mri_normalize_params",
 ]