collaboration.util module

binaryninja.collaboration.util.LazyT([ctor, ...])

Lazily loaded objects (but FFI) Pretend this class is templated, because the C++ version is

class LazyT(ctor: Callable[[], object] | None = None, handle=None)

Bases: object

Lazily loaded objects (but FFI) Pretend this class is templated, because the C++ version is

Parameters:

ctor (Callable[[], object] | None) –

get(expected_type=<class 'object'>)

Access the lazily loaded object. Will construct it if this is the first usage.

Parameters:

expected_type – Expected type of result, ctypes will try to cast to it

Returns:

Result object

nop(*args, **kwargs)

Function that just returns True, used as default for callbacks

Returns:

True

split_progress(progress_func: Callable[[int, int], bool] | None, subpart: int, subpart_weights: List[float]) → Callable[[int, int], bool]

Split a single progress function into equally sized subparts. This function takes the original progress function and returns a new function whose signature is the same but whose output is shortened to correspond to the specified subparts.

The length of a subpart is proportional to the sum of all the weights. E.g. If subpart = 1 and subpartWeights = { 0.25, 0.5, 0.25 }, this will return a function that calls progress_func and maps its progress to the range [0.25, 0.75]

Internally this works by calling progress_func with total = 1000000 and doing math on the current value

Parameters:

• progress_func (Callable[[int, int], bool] | None) – Original progress function (usually updates a UI)

• subpart (int) – Index of subpart whose function to return, from 0 to (subpartWeights.size() - 1)

• subpart_weights (List[float]) – Weights of subparts, described above

Returns:

A function that will call progress_func() within a modified progress region

Return type:

Callable[[int, int], bool]

wrap_conflict_handler(handler: Callable[[Dict[str, MergeConflict]], bool]) → ConflictHandler

Wraps a conflict handler function in a ConflictHandler object so you can be lazy and just use a lambda

Parameters:

handler (Callable[[Dict[str, MergeConflict]], bool]) – Python conflict handler function

Returns:

Wrapped ConflictHandler object

Return type:

ConflictHandler

wrap_name_changeset(name_changeset_func: Callable[[Changeset], bool])

Wraps a changeset naming function in a ctypes function for passing to the FFI

Parameters:

name_changeset_func (Callable[[Changeset], bool]) – Python changeset naming function

Returns:

Wrapped ctypes function

wrap_progress(progress_func: Callable[[int, int], bool])

Wraps a progress function in a ctypes function for passing to the FFI

Parameters:

progress_func (Callable[[int, int], bool]) – Python progress function

Returns:

Wrapped ctypes function