Service

class Signal (name: str | Callable[[Concatenate[G, P]], R], flags: Literal['run-last', 'run-first', 'run-cleanup', 'no-recurse', 'detailed', 'action', 'no-hooks', 'must-collect', 'deprecated', 'accumulator-first-run'] | SignalFlags = GObject.SignalFlags.RUN_FIRST, rtype: Any = None, arg_types: tuple = (), install: bool = True, **kwargs)

Bases: Generic[G, P, R]

attribute flags SignalFlags

attribute install bool

attribute func Callable[[Concatenate[G, P]], R] | None

attribute name str

attribute arg_types tuple

attribute rtype Any

def detail (detail_name)Signal[G, P, R]

def serialize ()dict[str, tuple[SignalFlags, Any, tuple[Any]]]

static installer (klass)

def Property (*_, **__)

class Builder (parent: G)

Bases: Generic[G]

attribute parent G

def unwrap ()G

class Service (**kwargs)

Bases: Object, Generic[P, T]

Base service class

Handles constructor connections, bindings and builders

Default service constructor (base constructor)

• Parameters: **kwargs —

  mapped to signal connections (e.g. on_clicked=lambda *_: … connects the given function to the signal “clicked”, notify_my_property=my_func connects the given function to the signal “notify::my-property”)

def build (callback: None = None, *args: typing.~P, **kwargs: typing.~P)fabric.core.service.Builder[Self]

def build (callback: collections.abc.Callable[[typing.Concatenate[typing.Self, fabric.core.service.Builder[typing.Self], ~P]], typing.Any] | collections.abc.Callable[[typing.Concatenate[typing.Self, ~P]], typing.Any] | collections.abc.Callable[[~P], typing.Any], *args: typing.~P, **kwargs: typing.~P)Self

def build (callback: ~collections.abc.Callable[[~typing.Concatenate[~typing.Self, ~fabric.core.service.Builder[~typing.Self], ~P]], ~typing.Any] | ~collections.abc.Callable[[~typing.Concatenate[~typing.Self, ~P]], ~typing.Any] | ~collections.abc.Callable[[~P], ~typing.Any] | None = None, *args: ~typing.~P, **kwargs: ~typing.~P)Builder[Self] | Self

Get an instance of a Builder that holds a reference to this service

Builders enable you of doing extra configuration after the initialization of a service with ease, it makes you able to either have a callback function that does all the extra setup or chain all your setup calls at once

Examples:

my_service = (
    MyService()
    .build()
    # beginning of method chaining
    .useful_method()
    .other_useful_method()
    .set_something("something")
    .unwrap() # unwrap self (the service) and get a reference to it
)

# when passing a setup function it returns self by default
my_service = MyService().build(lambda self, builder: self.do_something())
my_service = MyService().build(
    lambda self, builder: (
        builder.useful_method()
        .other_useful_method()
        .set_something("something")
        # no need to do `.unwrap()` since we don't really need the value of self
    )
)

• Parameters: callback (Optional *[*Callable *[*Concatenate *[*Self , Builder *[*Self ] , P ] , Any ] | Callable *[*Concatenate *[*Self , P ] , Any ] | Callable *[*P , Any ] ] , optional) — an optional callback to use instead of chaining method calls, defaults to None
• Returns: a newly created builder (or a cached one if found)
• Return type: Union[Builder[Self], Self]

def bind (source_property: str, target_property: str, target_object: Object, transform_to: Callable[[Binding, Any], Any] | None = None, transform_from: Callable[[Binding, Any], Any] | None = None, flags: Literal['default', 'bidirectional', 'sync-create', 'invert-boolean'] | BindingFlags = GObject.BindingFlags.DEFAULT)

def emit (signal_name: str, *args, **kwargs)None

def connect (signal_name: str, callback: Callable[[Concatenate[Self, P]], Any] | Callable, *args, ignore_missing: bool = True)int

static filter_kwargs (kwargs: dict[str, Any])dict[str, Any]

static get_connectables_for_kwargs (kwargs: dict[str, Any])Generator[tuple[str, Callable[[...], Any]], None, None]

def set_property (self, property_name: str, value: GObject.Value)

def get_property (self, property_name: str, value: GObject.Value)

def set_properties (*args, **kwargs)None

def get_signal_names ()list[str]

def get_signal_ids ()list[int]

def get_properties ()list[ParamSpec]

def notify (self, property_name: str)

def notify_all ()