nvflare.collab.api package

Submodules

• nvflare.collab.api.app module
  • App
    • App.add_collab_object()
    • App.backend
    • App.client_hierarchy
    • App.client_proxies
    • App.finalize()
    • App.find_collab_method()
    • App.find_method()
    • App.fqn
    • App.get_children()
    • App.get_collab_interface()
    • App.get_collab_objects()
    • App.get_leaf_clients()
    • App.get_prop()
    • App.get_props()
    • App.get_target_object_publish_interface()
    • App.has_children()
    • App.initialize()
    • App.my_site
    • App.new_context()
    • App.server_proxy
    • App.set_fqn()
    • App.set_prop()
    • App.setup()
    • App.update_props()
    • App.workspace
  • ClientApp
    • ClientApp.get_children()
    • ClientApp.has_children()
  • ServerApp
    • ServerApp.get_children()
    • ServerApp.has_children()
• nvflare.collab.api.call_opt module
  • CallOption
• nvflare.collab.api.call_utils module
  • check_call_args()
  • check_context_support()
  • check_optional_args()
  • get_collab_object_name()
• nvflare.collab.api.constants module
  • CollabMethodArgName
    • CollabMethodArgName.CONTEXT
  • ContextKey
    • ContextKey.RESULT
• nvflare.collab.api.context module
  • Context
    • Context.backend
    • Context.client_hierarchy
    • Context.clients
    • Context.get_prop()
    • Context.is_aborted()
    • Context.server
    • Context.set_prop()
    • Context.target_group_size
    • Context.workspace
  • get_call_context()
  • set_call_context()
• nvflare.collab.api.decorators module
  • adjust_kwargs()
  • classproperty
  • final()
  • get_object_final_funcs()
  • get_object_init_funcs()
  • get_object_main_funcs()
  • get_object_publish_interface()
  • get_param_names()
  • get_param_specs()
  • init()
  • is_publish()
  • main()
  • publish()
  • supports_context()
• nvflare.collab.api.exceptions module
  • CollabCallError
  • RunAborted
• nvflare.collab.api.facade module
  • Facade
    • Facade.call_info
    • Facade.callee
    • Facade.caller
    • Facade.child_clients
    • Facade.clients
    • Facade.context
    • Facade.final()
    • Facade.fl_ctx
    • Facade.get_app_prop()
    • Facade.get_clients()
    • Facade.get_prop()
    • Facade.get_result()
    • Facade.has_children
    • Facade.init()
    • Facade.is_aborted
    • Facade.leaf_clients
    • Facade.main()
    • Facade.other_clients
    • Facade.publish()
    • Facade.server
    • Facade.set_app_prop()
    • Facade.set_prop()
    • Facade.site_name
    • Facade.workspace
  • get_call_context()
• nvflare.collab.api.group module
  • Group
    • Group.members
    • Group.size
  • group()
• nvflare.collab.api.group_call_context module
  • GroupCallContext
    • GroupCallContext.add_partial_result()
    • GroupCallContext.call_completed()
    • GroupCallContext.set_completion_cb()
    • GroupCallContext.set_exception()
    • GroupCallContext.set_result()
  • ResultQueue
    • ResultQueue.append()
    • ResultQueue.append_failure()
  • ResultWaiter
    • ResultWaiter.add_partial_result()
    • ResultWaiter.dec_call_count()
    • ResultWaiter.inc_call_count()
    • ResultWaiter.set_failure()
    • ResultWaiter.set_result()
    • ResultWaiter.wait_for_call_permission()
    • ResultWaiter.wait_for_responses()
• nvflare.collab.api.module_wrapper module
  • ModuleWrapper
    • ModuleWrapper.module_name
  • get_caller_module()
  • get_importable_module_name()
  • resolve_server_client()
  • wrap_if_module()
• nvflare.collab.api.proxy module
  • Proxy
    • Proxy.add_child()
    • Proxy.adjust_func_args()
    • Proxy.call_func()
    • Proxy.get_child()
    • Proxy.name
• nvflare.collab.api.proxy_list module
  • ProxyList
• nvflare.collab.api.publish_interface module
  • MethodInterface
    • MethodInterface.bind()
    • MethodInterface.prepare_invocation()
    • MethodInterface.to_wire()
    • MethodInterface.validate_normalized()
  • MethodParameter
    • MethodParameter.from_wire()
    • MethodParameter.to_dict()
  • PublishInterface
    • PublishInterface.from_dict()
    • PublishInterface.get_method()
    • PublishInterface.to_dict()

Module contents

Public programming surface of the collab API layer.

User code should import these names from this package rather than from the implementation modules. Exports are resolved lazily (PEP 562).

class App(obj, name: str)

Bases: object

add_collab_object(name: str, obj)

property backend

property client_hierarchy

property client_proxies

finalize(context: Context)

find_collab_method(target_obj, method_name)

find_method(target_obj, method_name)

property fqn

get_children()

get_collab_interface() → dict[str, dict[str, list[str]]]

get_collab_objects()

get_leaf_clients()

get_prop(name: str, default=None)

get_props()

get_target_object_publish_interface(target_name: str)

has_children()

initialize(context: Context)

property my_site: Proxy

new_context(caller: str, callee: str, target_group=None, set_call_ctx=True)

property server_proxy

set_fqn(fqn)

set_prop(name: str, value)

setup(workspace: Workspace, server: Proxy, clients: list[Proxy], abort_signal)

update_props(props: dict)

property workspace

class CallOption(expect_result: bool = True, blocking: bool = True, timeout: float = 60.0, secure: bool = False, optional: bool = False, target=None, parallel=0)

Bases: object

CallOption defines behavior of a collab call.

Parameters:

• expect_result – whether result is expected from the remote object.

• blocking – whether the call is blocking. Only for group calls.

• timeout – when expecting result, the max number of secs to wait for result.

• secure – whether to use P2P secure messaging.

• optional – whether the call is optional.

• target – name of the collab object to be called.

• parallel – maximum number of calls that may remain in flight at once.

class ClientApp(obj, name: str = 'client')

Bases: App

get_children()

has_children()

exception CollabCallError(site: str, func_name: str, cause, cause_type: str | None = None, remote_traceback: str | None = None)

Bases: Exception

Raised when a call to a Collab function fails.

class Context(app, caller: str, callee: str, abort_signal: Signal, target_group=None)

Bases: object

property backend

property client_hierarchy

property clients

get_prop(name: str, default=None)

is_aborted()

property server

set_prop(name: str, value)

property target_group_size

property workspace

class ContextKey

Bases: object

RESULT = 'result'

class GroupCallContext(app, target_name: str, call_opt: CallOption, func_name: str, process_cb, cb_kwargs, context: Context, waiter: ResultWaiter)

Bases: object

GroupCallContext contains contextual information about a group call to a target.

Parameters:

• app – the calling app.

• target_name – name of the target to be called in the remote app.

• call_opt – call options.

• func_name – name of the function to be called in the remote app.

• process_cb – the callback function to be called to process response from the remote app.

• cb_kwargs – kwargs passed to the callback function.

• context – call context.

• waiter – the waiter to wait for result

add_partial_result(partial_result)

call_completed()

set_completion_cb(cb, **cb_kwargs)

set_exception(ex)

This is called by the backend to set the exception received from the remote app. The process_cb will NOT be called.

Parameters:

ex – the exception received from the remote app.

Returns:

set_result(result)

This is called by the backend to set the result received from the remote app. If process_cb is available, it will be called with the result from the remote app.

Parameters:

result – the result received from the remote app.

Returns: None

class ModuleWrapper(module: ModuleType | str | None = None)

Bases: object

Wrap a module’s publish, main, init, and final functions for Collab.

Collab creates this wrapper automatically whenever a module is supplied as a primary or named app object. This allows callers to pass modules containing standalone functions anywhere they could pass class instances:

# my_module.py from nvflare.collab import collab

@collab.publish def train(weights=None):

…

@collab.main def fed_avg():

…

# main.py import my_module

recipe = CollabRecipe(server=my_module, client=my_module, …)

For a distributed deployment, the module must be importable on all client machines (i.e., part of the installed package or included in job resources).

Initialize wrapper with a module containing @collab.publish/@collab.main functions.

Parameters:

module – A Python module object OR a fully qualified module name string. When a string is passed, the module will be imported. When no argument is passed (None), the wrapper is in an uninitialized state and will be set up by __setstate__ during unpickling.

Note

For job config serialization, we store the module name as self._module which matches the ‘module’ parameter. FLARE’s _get_args() looks for param or _param in __dict__, so _module matches ‘module’.

When running as __main__, we convert to an importable module path so that remote processes can import the same module.

property module_name: str

Get the module name.

class PublishInterface(methods: Mapping[str, Sequence] | None = None)

Bases: Mapping[str, MethodInterface]

Immutable description of an object’s published Collab methods.

classmethod from_dict(methods: Mapping[str, Sequence] | None) → PublishInterface

get_method(method_name: str) → MethodInterface | None

Return a method interface, preserving an empty interface for zero-argument methods.

to_dict() → dict

Return the plain-dict representation used for synchronization.

class ServerApp(obj, name: str = 'server')

Bases: App

get_children()

has_children()