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

niwrap_afni/afni/surf_smooth.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 SURF_SMOOTH_METADATA = Metadata(
-    id="cbedd0f1ab74c263499adcf137b9c374257feae6.boutiques",
+    id="d0ac15b4d6012045723c7c4f0af6a5d57c2f0583.boutiques",
     name="SurfSmooth",
     package="afni",
     container_image_tag="afni/afni_make_build:AFNI_24.2.06",
@@ -14,7 +14,26 @@ SURF_SMOOTH_METADATA = Metadata(
 
 
 SurfSmoothParameters = typing.TypedDict('SurfSmoothParameters', {
-    "__STYXTYPE__": typing.Literal["SurfSmooth"],
+    "@type": typing.NotRequired[typing.Literal["afni/SurfSmooth"]],
+    "surface": str,
+    "method": str,
+    "input_data": typing.NotRequired[InputPathType | None],
+    "target_fwhm": typing.NotRequired[float | None],
+    "fwhm": typing.NotRequired[float | None],
+    "number_iterations": typing.NotRequired[float | None],
+    "output_file": typing.NotRequired[str | None],
+    "band_pass_frequency": typing.NotRequired[float | None],
+    "lambda_mu": typing.NotRequired[str | None],
+    "interp_weights": typing.NotRequired[str | None],
+    "node_mask": typing.NotRequired[InputPathType | None],
+    "surface_output": typing.NotRequired[InputPathType | None],
+    "dbg_node": typing.NotRequired[float | None],
+    "use_neighbors_outside_mask": bool,
+    "talk_suma": bool,
+    "refresh_rate": typing.NotRequired[float | None],
+})
+SurfSmoothParametersTagged = typing.TypedDict('SurfSmoothParametersTagged', {
+    "@type": typing.Literal["afni/SurfSmooth"],
     "surface": str,
     "method": str,
     "input_data": typing.NotRequired[InputPathType | None],
@@ -32,43 +51,11 @@ SurfSmoothParameters = typing.TypedDict('SurfSmoothParameters', {
     "talk_suma": bool,
     "refresh_rate": 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 {
-        "SurfSmooth": surf_smooth_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 {
-        "SurfSmooth": surf_smooth_outputs,
-    }.get(t)
 
 
 class SurfSmoothOutputs(typing.NamedTuple):
     """
-    Output object returned when calling `surf_smooth(...)`.
+    Output object returned when calling `SurfSmoothParameters(...)`.
     """
     root: OutputPathType
     """Output root folder. This is the root folder for all outputs."""
@@ -93,7 +80,7 @@ def surf_smooth_params(
     use_neighbors_outside_mask: bool = False,
     talk_suma: bool = False,
     refresh_rate: float | None = None,
-) -> SurfSmoothParameters:
+) -> SurfSmoothParametersTagged:
     """
     Build parameters.
     
@@ -130,7 +117,7 @@ def surf_smooth_params(
         Parameter dictionary
     """
     params = {
-        "__STYXTYPE__": "SurfSmooth",
+        "@type": "afni/SurfSmooth",
         "surface": surface,
         "method": method,
         "use_neighbors_outside_mask": use_neighbors_outside_mask,
@@ -180,75 +167,75 @@ def surf_smooth_cargs(
     cargs.append("SurfSmooth")
     cargs.extend([
         "-SURF_1",
-        params.get("surface")
+        params.get("surface", None)
     ])
     cargs.extend([
         "-met",
-        params.get("method")
+        params.get("method", None)
     ])
-    if params.get("input_data") is not None:
+    if params.get("input_data", None) is not None:
         cargs.extend([
             "-input",
-            execution.input_file(params.get("input_data"))
+            execution.input_file(params.get("input_data", None))
         ])
-    if params.get("target_fwhm") is not None:
+    if params.get("target_fwhm", None) is not None:
         cargs.extend([
             "-target_fwhm",
-            str(params.get("target_fwhm"))
+            str(params.get("target_fwhm", 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("number_iterations") is not None:
+    if params.get("number_iterations", None) is not None:
         cargs.extend([
             "-Niter",
-            str(params.get("number_iterations"))
+            str(params.get("number_iterations", None))
         ])
-    if params.get("output_file") is not None:
+    if params.get("output_file", None) is not None:
         cargs.extend([
             "-output",
-            params.get("output_file")
+            params.get("output_file", None)
         ])
-    if params.get("band_pass_frequency") is not None:
+    if params.get("band_pass_frequency", None) is not None:
         cargs.extend([
             "-kpb",
-            str(params.get("band_pass_frequency"))
+            str(params.get("band_pass_frequency", None))
         ])
-    if params.get("lambda_mu") is not None:
+    if params.get("lambda_mu", None) is not None:
         cargs.extend([
             "-lm",
-            params.get("lambda_mu")
+            params.get("lambda_mu", None)
         ])
-    if params.get("interp_weights") is not None:
+    if params.get("interp_weights", None) is not None:
         cargs.extend([
             "-iw",
-            params.get("interp_weights")
+            params.get("interp_weights", None)
         ])
-    if params.get("node_mask") is not None:
+    if params.get("node_mask", None) is not None:
         cargs.extend([
             "-MASK",
-            execution.input_file(params.get("node_mask"))
+            execution.input_file(params.get("node_mask", None))
         ])
-    if params.get("surface_output") is not None:
+    if params.get("surface_output", None) is not None:
         cargs.extend([
             "-surf_out",
-            execution.input_file(params.get("surface_output"))
+            execution.input_file(params.get("surface_output", None))
         ])
-    if params.get("dbg_node") is not None:
+    if params.get("dbg_node", None) is not None:
         cargs.extend([
             "-dbg_n",
-            str(params.get("dbg_node"))
+            str(params.get("dbg_node", None))
         ])
-    if params.get("use_neighbors_outside_mask"):
+    if params.get("use_neighbors_outside_mask", False):
         cargs.append("-use_neighbors_outside_mask")
-    if params.get("talk_suma"):
+    if params.get("talk_suma", False):
         cargs.append("-talk_suma")
-    if params.get("refresh_rate") is not None:
+    if params.get("refresh_rate", None) is not None:
         cargs.extend([
             "-refresh_rate",
-            str(params.get("refresh_rate"))
+            str(params.get("refresh_rate", None))
         ])
     return cargs
 
@@ -268,16 +255,18 @@ def surf_smooth_outputs(
     """
     ret = SurfSmoothOutputs(
         root=execution.output_file("."),
-        out_file=execution.output_file(params.get("output_file")) if (params.get("output_file") is not None) else None,
+        out_file=execution.output_file(params.get("output_file", None)) if (params.get("output_file") is not None) else None,
     )
     return ret
 
 
 def surf_smooth_execute(
     params: SurfSmoothParameters,
-    execution: Execution,
+    runner: Runner | None = None,
 ) -> SurfSmoothOutputs:
     """
+    SurfSmooth
+    
     Tool for smoothing data on surfaces using various methods.
     
     Author: AFNI Developers
@@ -286,10 +275,12 @@ def surf_smooth_execute(
     
     Args:
         params: The parameters.
-        execution: The execution object.
+        runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `SurfSmoothOutputs`).
     """
+    runner = runner or get_global_runner()
+    execution = runner.start_execution(SURF_SMOOTH_METADATA)
     params = execution.params(params)
     cargs = surf_smooth_cargs(params, execution)
     ret = surf_smooth_outputs(params, execution)
@@ -317,6 +308,8 @@ def surf_smooth(
     runner: Runner | None = None,
 ) -> SurfSmoothOutputs:
     """
+    SurfSmooth
+    
     Tool for smoothing data on surfaces using various methods.
     
     Author: AFNI Developers
@@ -356,8 +349,6 @@ def surf_smooth(
     Returns:
         NamedTuple of outputs (described in `SurfSmoothOutputs`).
     """
-    runner = runner or get_global_runner()
-    execution = runner.start_execution(SURF_SMOOTH_METADATA)
     params = surf_smooth_params(
         surface=surface,
         method=method,
@@ -376,13 +367,13 @@ def surf_smooth(
         talk_suma=talk_suma,
         refresh_rate=refresh_rate,
     )
-    return surf_smooth_execute(params, execution)
+    return surf_smooth_execute(params, runner)
 
 
 __all__ = [
     "SURF_SMOOTH_METADATA",
     "SurfSmoothOutputs",
-    "SurfSmoothParameters",
     "surf_smooth",
+    "surf_smooth_execute",
     "surf_smooth_params",
 ]

niwrap_afni/afni/surf_to_surf.py

@@ -6,7 +6,7 @@ import pathlib
 from styxdefs import *
 
 SURF_TO_SURF_METADATA = Metadata(
-    id="af80d3026cea586c9cddcde8e039ab19779b80fa.boutiques",
+    id="30606794951a6ad0374602d13eac56a3bd04e87b.boutiques",
     name="SurfToSurf",
     package="afni",
     container_image_tag="afni/afni_make_build:AFNI_24.2.06",
@@ -14,7 +14,23 @@ SURF_TO_SURF_METADATA = Metadata(
 
 
 SurfToSurfParameters = typing.TypedDict('SurfToSurfParameters', {
-    "__STYXTYPE__": typing.Literal["SurfToSurf"],
+    "@type": typing.NotRequired[typing.Literal["afni/SurfToSurf"]],
+    "input_surface_1": InputPathType,
+    "input_surface_2": InputPathType,
+    "surface_volume": typing.NotRequired[InputPathType | None],
+    "prefix": typing.NotRequired[str | None],
+    "output_params": typing.NotRequired[str | None],
+    "node_indices": typing.NotRequired[InputPathType | None],
+    "proj_dir": typing.NotRequired[InputPathType | None],
+    "data": typing.NotRequired[InputPathType | None],
+    "node_debug": typing.NotRequired[float | None],
+    "debug_level": typing.NotRequired[float | None],
+    "make_consistent": bool,
+    "dset": typing.NotRequired[InputPathType | None],
+    "mapfile": typing.NotRequired[InputPathType | None],
+})
+SurfToSurfParametersTagged = typing.TypedDict('SurfToSurfParametersTagged', {
+    "@type": typing.Literal["afni/SurfToSurf"],
     "input_surface_1": InputPathType,
     "input_surface_2": InputPathType,
     "surface_volume": typing.NotRequired[InputPathType | None],
@@ -29,43 +45,11 @@ SurfToSurfParameters = typing.TypedDict('SurfToSurfParameters', {
     "dset": typing.NotRequired[InputPathType | None],
     "mapfile": typing.NotRequired[InputPathType | None],
 })
-
-
-def dyn_cargs(
-    t: str,
-) -> typing.Any:
-    """
-    Get build cargs function by command type.
-    
-    Args:
-        t: Command type.
-    Returns:
-        Build cargs function.
-    """
-    return {
-        "SurfToSurf": surf_to_surf_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 {
-        "SurfToSurf": surf_to_surf_outputs,
-    }.get(t)
 
 
 class SurfToSurfOutputs(typing.NamedTuple):
     """
-    Output object returned when calling `surf_to_surf(...)`.
+    Output object returned when calling `SurfToSurfParameters(...)`.
     """
     root: OutputPathType
     """Output root folder. This is the root folder for all outputs."""
@@ -87,7 +71,7 @@ def surf_to_surf_params(
     make_consistent: bool = False,
     dset: InputPathType | None = None,
     mapfile: InputPathType | None = None,
-) -> SurfToSurfParameters:
+) -> SurfToSurfParametersTagged:
     """
     Build parameters.
     
@@ -111,7 +95,7 @@ def surf_to_surf_params(
         Parameter dictionary
     """
     params = {
-        "__STYXTYPE__": "SurfToSurf",
+        "@type": "afni/SurfToSurf",
         "input_surface_1": input_surface_1,
         "input_surface_2": input_surface_2,
         "make_consistent": make_consistent,
@@ -154,59 +138,59 @@ def surf_to_surf_cargs(
     """
     cargs = []
     cargs.append("SurfToSurf")
-    cargs.append(execution.input_file(params.get("input_surface_1")))
-    cargs.append(execution.input_file(params.get("input_surface_2")))
-    if params.get("surface_volume") is not None:
+    cargs.append(execution.input_file(params.get("input_surface_1", None)))
+    cargs.append(execution.input_file(params.get("input_surface_2", None)))
+    if params.get("surface_volume", None) is not None:
         cargs.extend([
             "-sv",
-            execution.input_file(params.get("surface_volume"))
+            execution.input_file(params.get("surface_volume", None))
         ])
-    if params.get("prefix") is not None:
+    if params.get("prefix", None) is not None:
         cargs.extend([
             "-prefix",
-            params.get("prefix")
+            params.get("prefix", None)
         ])
-    if params.get("output_params") is not None:
+    if params.get("output_params", None) is not None:
         cargs.extend([
             "-output_params",
-            params.get("output_params")
+            params.get("output_params", None)
         ])
-    if params.get("node_indices") is not None:
+    if params.get("node_indices", None) is not None:
         cargs.extend([
             "-node_indices",
-            execution.input_file(params.get("node_indices"))
+            execution.input_file(params.get("node_indices", None))
         ])
-    if params.get("proj_dir") is not None:
+    if params.get("proj_dir", None) is not None:
         cargs.extend([
             "-proj_dir",
-            execution.input_file(params.get("proj_dir"))
+            execution.input_file(params.get("proj_dir", None))
         ])
-    if params.get("data") is not None:
+    if params.get("data", None) is not None:
         cargs.extend([
             "-data",
-            execution.input_file(params.get("data"))
+            execution.input_file(params.get("data", None))
         ])
-    if params.get("node_debug") is not None:
+    if params.get("node_debug", None) is not None:
         cargs.extend([
             "-node_debug",
-            str(params.get("node_debug"))
+            str(params.get("node_debug", None))
         ])
-    if params.get("debug_level") is not None:
+    if params.get("debug_level", None) is not None:
         cargs.extend([
             "-debug",
-            str(params.get("debug_level"))
+            str(params.get("debug_level", None))
         ])
-    if params.get("make_consistent"):
+    if params.get("make_consistent", False):
         cargs.append("-make_consistent")
-    if params.get("dset") is not None:
+    if params.get("dset", None) is not None:
         cargs.extend([
             "-dset",
-            execution.input_file(params.get("dset"))
+            execution.input_file(params.get("dset", None))
         ])
-    if params.get("mapfile") is not None:
+    if params.get("mapfile", None) is not None:
         cargs.extend([
             "-mapfile",
-            execution.input_file(params.get("mapfile"))
+            execution.input_file(params.get("mapfile", None))
         ])
     return cargs
 
@@ -226,16 +210,18 @@ def surf_to_surf_outputs(
     """
     ret = SurfToSurfOutputs(
         root=execution.output_file("."),
-        output_file=execution.output_file(params.get("prefix") + ".1D") if (params.get("prefix") is not None) else None,
+        output_file=execution.output_file(params.get("prefix", None) + ".1D") if (params.get("prefix") is not None) else None,
     )
     return ret
 
 
 def surf_to_surf_execute(
     params: SurfToSurfParameters,
-    execution: Execution,
+    runner: Runner | None = None,
 ) -> SurfToSurfOutputs:
     """
+    SurfToSurf
+    
     Interpolate data from one surface to another.
     
     Author: AFNI Developers
@@ -244,10 +230,12 @@ def surf_to_surf_execute(
     
     Args:
         params: The parameters.
-        execution: The execution object.
+        runner: Command runner.
     Returns:
         NamedTuple of outputs (described in `SurfToSurfOutputs`).
     """
+    runner = runner or get_global_runner()
+    execution = runner.start_execution(SURF_TO_SURF_METADATA)
     params = execution.params(params)
     cargs = surf_to_surf_cargs(params, execution)
     ret = surf_to_surf_outputs(params, execution)
@@ -272,6 +260,8 @@ def surf_to_surf(
     runner: Runner | None = None,
 ) -> SurfToSurfOutputs:
     """
+    SurfToSurf
+    
     Interpolate data from one surface to another.
     
     Author: AFNI Developers
@@ -298,8 +288,6 @@ def surf_to_surf(
     Returns:
         NamedTuple of outputs (described in `SurfToSurfOutputs`).
     """
-    runner = runner or get_global_runner()
-    execution = runner.start_execution(SURF_TO_SURF_METADATA)
     params = surf_to_surf_params(
         input_surface_1=input_surface_1,
         input_surface_2=input_surface_2,
@@ -315,13 +303,13 @@ def surf_to_surf(
         dset=dset,
         mapfile=mapfile,
     )
-    return surf_to_surf_execute(params, execution)
+    return surf_to_surf_execute(params, runner)
 
 
 __all__ = [
     "SURF_TO_SURF_METADATA",
     "SurfToSurfOutputs",
-    "SurfToSurfParameters",
     "surf_to_surf",
+    "surf_to_surf_execute",
     "surf_to_surf_params",
 ]