0.1.dev2192+g7c539c3.d20250403

flytekit.core.tracker

Class	Description
`InstanceTrackingMeta`	Please see the original class :py:class`flytekit.
`TrackedInstance`	Please see the notes for the metaclass above first.

Method	Description
`extract_task_module()`	Returns the task-name, absolute module and the string name of the callable.
`get_full_module_path()`
`import_module_from_file()`
`is_functools_wrapped_module_level()`	Returns true if the function is a functools.
`is_ipython_or_pickle_exists()`	Returns true if the code is running in an IPython notebook or if a pickle file exists.
`isnested()`	Returns true if a function is local to another function and is not accessible through a module.
`istestfunction()`	Return true if the function is defined in a test module.

Methods

extract_task_module()

        
    
def extract_task_module(
    f: typing.Union[typing.Callable, flytekit.core.tracker.TrackedInstance],
) -> n: [name to use: str, module_name: str, function_name: str, full_path: str]

Returns the task-name, absolute module and the string name of the callable.

Parameter	Type
`f`	`typing.Union[typing.Callable, flytekit.core.tracker.TrackedInstance]`

get_full_module_path()

        
    
def get_full_module_path(
    mod: module,
    mod_name: str,
) -> str

Parameter	Type
`mod`	`module`
`mod_name`	`str`

import_module_from_file()

        
    
def import_module_from_file(
    module_name,
    file,
)

Parameter	Type
`module_name`
`file`

is_functools_wrapped_module_level()

        
    
def is_functools_wrapped_module_level(
    func: typing.Callable,
) -> bool

Returns true if the function is a functools.wraps-updated function that is defined in the module-level scope.

        
    
import functools

def decorator(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        return fn(*arks, **kwargs)

    return wrapper

@decorator
def foo():
    ...

def define_inner_wrapped_fn():

    @decorator
    def foo_inner(*args, **kwargs):
        return fn(*arks, **kwargs)

    return foo_inner

bar = define_inner_wrapped_fn()

is_functools_wrapped_module_level(foo)  # True
is_functools_wrapped_module_level(bar)  # False

In this case, applying this function to foo returns true because foo was defined in the module-level scope. Applying this function to bar returns false because it’s being assigned to foo_inner, which is a functools-wrapped function but is actually defined in the local scope of define_inner_wrapped_fn.

This works because functools.wraps updates the name and qualname attributes of the wrapper to match the wrapped function. Since define_inner_wrapped_fn doesn’t update the qualname of foo_inner, the inner function’s qualname won’t match its name.

Parameter	Type
`func`	`typing.Callable`

is_ipython_or_pickle_exists()

def is_ipython_or_pickle_exists()

Returns true if the code is running in an IPython notebook or if a pickle file exists.

We skip module path resolution in both cases due to the following reasons:

In an IPython notebook, we cannot resolve the module path in the local file system.
When the code is serialized (pickled) and executed in a remote environment, only the pickled file exists at PICKLE_FILE_PATH. The remote environment won’t have the plain python file and module path resolution will fail.

This check ensures we avoid attempting module path resolution in both environments.

isnested()

        
    
def isnested(
    func: typing.Callable,
) -> bool

Returns true if a function is local to another function and is not accessible through a module

This would essentially be any function with a .<local>. (defined within a function) e.g.

        
    
def foo():
    def foo_inner():
        pass
    pass

In the above example foo_inner is the local function or a nested function.

Parameter	Type
`func`	`typing.Callable`

istestfunction()

        
    
def istestfunction(
    func,
) -> bool

Return true if the function is defined in a test module.

A test module has to have test_ as the prefix or _test as the suffix. False in all other cases.

Parameter	Type
`func`