code: def column_duplicatable(columns_to_bind: str) -> Callable:
      """
      Decorator to prepend the feature_duplicator learner.
  
      Identifies the columns to be duplicated and applies duplicator.
  
      Parameters
      ----------
      columns_to_bind: str
          Sets feature_duplicator's "columns_to_duplicate" parameter equal to the
          `columns_to_bind` parameter from the decorated learner
      """
  
      def _decorator(child: toolz.curry) -> Callable:
          mixin = feature_duplicator
  
          def _init(
              *args: List[Any], **kwargs: Dict[str, Any]
          ) -> Union[Callable, LearnerReturnType]:
              mixin_spec = inspect.getfullargspec(mixin)
              mixin_named_args = set(mixin_spec.args) | set(
                  mixin_spec.kwonlyargs
              )
              mixin_kwargs = {
                  key: value
                  for key, value in kwargs.items()
                  if key in mixin_named_args
              }
  
              child_spec = inspect.getfullargspec(child)
              child_named_args = set(child_spec.args) | set(
                  child_spec.kwonlyargs
              )
              child_kwargs: Dict[str, Any] = {
                  key: value
                  for key, value in kwargs.items()
                  if key in child_named_args
              }
  
              child_arg_names = list(
                  inspect.signature(child).parameters.keys()
              )
              columns_to_bind_idx = child_arg_names.index(
                  columns_to_bind
              )
  
              curry_is_ready = not child._should_curry(
                  args, child_kwargs
              )
  
              if curry_is_ready:
                  columns_to_duplicate = (
                      kwargs[columns_to_bind]
                      if columns_to_bind in kwargs
                      else args[columns_to_bind_idx]
                  )
                  mixin_fn, mixin_df, mixin_log = mixin(
                      args[0],
                      **mixin_kwargs,
                      columns_to_duplicate=columns_to_duplicate,
                  )
                  child_fn, child_df, child_log = child(
                      mixin_df, *args[1:], **child_kwargs
                  )
  
                  return (
                      toolz.compose(child_fn, mixin_fn),
                      child_df,
                      {**mixin_log, **child_log},
                  )
  
              else:
                  return functools.update_wrapper(
                      functools.partial(_init, *args, **kwargs),
                      child(*args[1:], **child_kwargs),
                  )
  
          callable_fn = functools.update_wrapper(_init, child)
  
          return callable_fn
  
      return _decorator
  
file_path: fklearn/src/fklearn/preprocessing/schema.py
imports: import functools
  import inspect
  import pandas
  import toolz
  from typing import Any, Callable, Dict, List, Optional, Union
  from fklearn.types import LearnerLogType, LearnerReturnType
label_desc: Use image node_id 2 for calling a global function with example usage: column_duplicatable(columns_to_bind) and returns: _decorator, callable_fn, toolz,  child_df,  dict, functools