collaboration.util module¶

Class	Description
`binaryninja.collaboration.util.LazyT`	Lazily loaded objects (but FFI)

class LazyT[source]

Bases: object

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

__init__(ctor: Callable[[], object] | None = None, handle=None)[source]

Create a new LazyT that will be initialized with the result of the given function, when it is first needed.

Parameters:

ctor (Callable[[], object] | None) – Function to construct object
handle – FFI handle for internal use

get(expected_type=<class 'object'>)[source]

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)[source]

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][source]

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)[source]

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] | ConflictHandler) – Python conflict handler function
Returns:: Wrapped ConflictHandler object

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

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])[source]

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

LazyT¶

class LazyT[source]¶

Bases: object

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

__init__(ctor: Callable[[], object] | None = None, handle=None)[source]¶

Create a new LazyT that will be initialized with the result of the given function, when it is first needed.

Parameters:

ctor (Callable[[], object] | None) – Function to construct object
handle – FFI handle for internal use

get(expected_type=<class 'object'>)[source]¶

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