From e61e5ea0cdc22e604c59b233ea5e058fb9202d22 Mon Sep 17 00:00:00 2001 From: Matteo Percivaldi Date: Fri, 22 Sep 2023 13:30:50 +0200 Subject: [PATCH] typing: Gio: Rerun generator --- src/gi-stubs/repository/Gio.pyi | 6873 ++++++++++++++++++++++++++++--- 1 file changed, 6221 insertions(+), 652 deletions(-) diff --git a/src/gi-stubs/repository/Gio.pyi b/src/gi-stubs/repository/Gio.pyi index eb7f61cc..31e46116 100644 --- a/src/gi-stubs/repository/Gio.pyi +++ b/src/gi-stubs/repository/Gio.pyi @@ -5,9 +5,14 @@ from typing import Optional from typing import Sequence from typing import Tuple from typing import Type +from typing import TypeVar from gi.repository import GLib from gi.repository import GObject +from typing_extensions import Concatenate +from typing_extensions import ParamSpec + +_VarArgs = ParamSpec("_VarArgs") DBUS_METHOD_INVOCATION_HANDLED: bool = True DBUS_METHOD_INVOCATION_UNHANDLED: bool = False @@ -76,8 +81,20 @@ FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET: str = "standard::symlink-target" FILE_ATTRIBUTE_STANDARD_TARGET_URI: str = "standard::target-uri" FILE_ATTRIBUTE_STANDARD_TYPE: str = "standard::type" FILE_ATTRIBUTE_THUMBNAILING_FAILED: str = "thumbnail::failed" +FILE_ATTRIBUTE_THUMBNAILING_FAILED_LARGE: str = "thumbnail::failed-large" +FILE_ATTRIBUTE_THUMBNAILING_FAILED_NORMAL: str = "thumbnail::failed-normal" +FILE_ATTRIBUTE_THUMBNAILING_FAILED_XLARGE: str = "thumbnail::failed-xlarge" +FILE_ATTRIBUTE_THUMBNAILING_FAILED_XXLARGE: str = "thumbnail::failed-xxlarge" FILE_ATTRIBUTE_THUMBNAIL_IS_VALID: str = "thumbnail::is-valid" +FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_LARGE: str = "thumbnail::is-valid-large" +FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_NORMAL: str = "thumbnail::is-valid-normal" +FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XLARGE: str = "thumbnail::is-valid-xlarge" +FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XXLARGE: str = "thumbnail::is-valid-xxlarge" FILE_ATTRIBUTE_THUMBNAIL_PATH: str = "thumbnail::path" +FILE_ATTRIBUTE_THUMBNAIL_PATH_LARGE: str = "thumbnail::path-large" +FILE_ATTRIBUTE_THUMBNAIL_PATH_NORMAL: str = "thumbnail::path-normal" +FILE_ATTRIBUTE_THUMBNAIL_PATH_XLARGE: str = "thumbnail::path-xlarge" +FILE_ATTRIBUTE_THUMBNAIL_PATH_XXLARGE: str = "thumbnail::path-xxlarge" FILE_ATTRIBUTE_TIME_ACCESS: str = "time::access" FILE_ATTRIBUTE_TIME_ACCESS_NSEC: str = "time::access-nsec" FILE_ATTRIBUTE_TIME_ACCESS_USEC: str = "time::access-usec" @@ -109,6 +126,7 @@ MENU_ATTRIBUTE_ACTION_NAMESPACE: str = "action-namespace" MENU_ATTRIBUTE_ICON: str = "icon" MENU_ATTRIBUTE_LABEL: str = "label" MENU_ATTRIBUTE_TARGET: str = "target" +MENU_EXPORTER_MAX_SECTION_SIZE: int = 1000 MENU_LINK_SECTION: str = "section" MENU_LINK_SUBMENU: str = "submenu" NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME: str = "gio-native-volume-monitor" @@ -153,7 +171,9 @@ def app_info_get_default_for_type_async( content_type: str, must_support_uris: bool, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def app_info_get_default_for_type_finish(result: AsyncResult) -> AppInfo: ... @@ -161,7 +181,9 @@ def app_info_get_default_for_uri_scheme(uri_scheme: str) -> Optional[AppInfo]: . def app_info_get_default_for_uri_scheme_async( uri_scheme: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def app_info_get_default_for_uri_scheme_finish(result: AsyncResult) -> AppInfo: ... @@ -174,7 +196,9 @@ def app_info_launch_default_for_uri_async( uri: str, context: Optional[AppLaunchContext] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def app_info_launch_default_for_uri_finish(result: AsyncResult) -> bool: ... @@ -185,13 +209,17 @@ def async_initable_newv_async( parameters: GObject.Parameter, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def bus_get( bus_type: BusType, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def bus_get_finish(res: AsyncResult) -> DBusConnection: ... @@ -254,7 +282,9 @@ def dbus_address_get_for_bus_sync( def dbus_address_get_stream( address: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def dbus_address_get_stream_finish(res: AsyncResult) -> Tuple[IOStream, str]: ... @@ -310,25 +340,27 @@ def file_new_tmp_async( tmpl: Optional[str], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def file_new_tmp_dir_async( tmpl: Optional[str], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def file_new_tmp_dir_finish(result: AsyncResult) -> File: ... def file_new_tmp_finish(result: AsyncResult) -> Tuple[File, FileIOStream]: ... def file_parse_name(parse_name: str) -> File: ... def icon_deserialize(value: GLib.Variant) -> Optional[Icon]: ... -def icon_hash(icon: None) -> int: ... def icon_new_for_string(str: str) -> Icon: ... def initable_newv( object_type: Type, - n_parameters: int, parameters: Sequence[GObject.Parameter], cancellable: Optional[Cancellable] = None, ) -> GObject.Object: ... @@ -350,10 +382,12 @@ def io_modules_scan_all_in_directory_with_scope( ) -> None: ... def io_scheduler_cancel_all_jobs() -> None: ... def io_scheduler_push_job( - job_func: Callable[..., bool], + job_func: Callable[ + Concatenate[IOSchedulerJob, Optional[Cancellable], _VarArgs], bool + ], + user_data: Optional[Any], io_priority: int, cancellable: Optional[Cancellable] = None, - *user_data: Any, ) -> None: ... def keyfile_settings_backend_new( filename: str, root_path: str, root_group: Optional[str] = None @@ -410,9 +444,11 @@ def resources_unregister(resource: Resource) -> None: ... def settings_schema_source_get_default() -> Optional[SettingsSchemaSource]: ... def simple_async_report_gerror_in_idle( object: Optional[GObject.Object], - callback: Optional[Callable[..., None]], + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ], + user_data: Optional[Any], error: GLib.Error, - *user_data: Any, ) -> None: ... def tls_backend_get_default() -> TlsBackend: ... def tls_channel_binding_error_quark() -> int: ... @@ -451,6 +487,13 @@ def unix_mounts_changed_since(time: int) -> bool: ... def unix_mounts_get() -> Tuple[list[UnixMountEntry], int]: ... class Action(GObject.GInterface): + """ + Interface GAction + + Signals from GObject: + notify (GParam) + """ + def activate(self, parameter: Optional[GLib.Variant] = None) -> None: ... def change_state(self, value: GLib.Variant) -> None: ... def get_enabled(self) -> bool: ... @@ -469,14 +512,31 @@ class Action(GObject.GInterface): ) -> str: ... class ActionEntry(GObject.GPointer): + """ + :Constructors: + + :: + + ActionEntry() + """ + name: str = ... - activate: Callable[..., None] = ... + activate: Callable[Concatenate[SimpleAction, GLib.Variant, _VarArgs], None] = ... parameter_type: str = ... state: str = ... - change_state: Callable[..., None] = ... + change_state: Callable[ + Concatenate[SimpleAction, GLib.Variant, _VarArgs], None + ] = ... padding: list[int] = ... class ActionGroup(GObject.GInterface): + """ + Interface GActionGroup + + Signals from GObject: + notify (GParam) + """ + def action_added(self, action_name: str) -> None: ... def action_enabled_changed(self, action_name: str, enabled: bool) -> None: ... def action_removed(self, action_name: str) -> None: ... @@ -501,6 +561,14 @@ class ActionGroup(GObject.GInterface): ]: ... class ActionGroupInterface(GObject.GPointer): + """ + :Constructors: + + :: + + ActionGroupInterface() + """ + g_iface: GObject.TypeInterface = ... has_action: Callable[[ActionGroup, str], bool] = ... list_actions: Callable[[ActionGroup], list[str]] = ... @@ -527,6 +595,14 @@ class ActionGroupInterface(GObject.GPointer): ] = ... class ActionInterface(GObject.GPointer): + """ + :Constructors: + + :: + + ActionInterface() + """ + g_iface: GObject.TypeInterface = ... get_name: Callable[[Action], str] = ... get_parameter_type: Callable[[Action], Optional[GLib.VariantType]] = ... @@ -538,18 +614,40 @@ class ActionInterface(GObject.GPointer): activate: Callable[[Action, Optional[GLib.Variant]], None] = ... class ActionMap(GObject.GInterface): + """ + Interface GActionMap + + Signals from GObject: + notify (GParam) + """ + def add_action(self, action: Action) -> None: ... def add_action_entries(self, entries, user_data=None): ... # FIXME Function def lookup_action(self, action_name: str) -> Optional[Action]: ... def remove_action(self, action_name: str) -> None: ... class ActionMapInterface(GObject.GPointer): + """ + :Constructors: + + :: + + ActionMapInterface() + """ + g_iface: GObject.TypeInterface = ... lookup_action: Callable[[ActionMap, str], Optional[Action]] = ... add_action: Callable[[ActionMap, Action], None] = ... remove_action: Callable[[ActionMap, str], None] = ... class AppInfo(GObject.GInterface): + """ + Interface GAppInfo + + Signals from GObject: + notify (GParam) + """ + def add_supports_type(self, content_type: str) -> bool: ... def can_delete(self) -> bool: ... def can_remove_supports_type(self) -> bool: ... @@ -574,7 +672,9 @@ class AppInfo(GObject.GInterface): content_type: str, must_support_uris: bool, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @staticmethod @@ -585,7 +685,9 @@ class AppInfo(GObject.GInterface): def get_default_for_uri_scheme_async( uri_scheme: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @staticmethod @@ -615,7 +717,9 @@ class AppInfo(GObject.GInterface): uri: str, context: Optional[AppLaunchContext] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @staticmethod @@ -630,7 +734,9 @@ class AppInfo(GObject.GInterface): uris: Optional[list[str]] = None, context: Optional[AppLaunchContext] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def launch_uris_finish(self, result: AsyncResult) -> bool: ... @@ -645,6 +751,14 @@ class AppInfo(GObject.GInterface): def supports_uris(self) -> bool: ... class AppInfoIface(GObject.GPointer): + """ + :Constructors: + + :: + + AppInfoIface() + """ + g_iface: GObject.TypeInterface = ... dup: Callable[[AppInfo], AppInfo] = ... equal: Callable[[AppInfo, AppInfo], bool] = ... @@ -673,14 +787,63 @@ class AppInfoIface(GObject.GPointer): get_display_name: Callable[[AppInfo], str] = ... set_as_last_used_for_type: Callable[[AppInfo, str], bool] = ... get_supported_types: Callable[[AppInfo], list[str]] = ... - launch_uris_async: Callable[..., None] = ... + launch_uris_async: Callable[ + Concatenate[ + AppInfo, + Optional[list[str]], + Optional[AppLaunchContext], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... launch_uris_finish: Callable[[AppInfo, AsyncResult], bool] = ... class AppInfoMonitor(GObject.Object): + """ + :Constructors: + + :: + + AppInfoMonitor(**properties) + + Object GAppInfoMonitor + + Signals from GAppInfoMonitor: + changed () + + Signals from GObject: + notify (GParam) + """ + @staticmethod def get() -> AppInfoMonitor: ... class AppLaunchContext(GObject.Object): + """ + :Constructors: + + :: + + AppLaunchContext(**properties) + new() -> Gio.AppLaunchContext + + Object GAppLaunchContext + + Signals from GAppLaunchContext: + launch-failed (gchararray) + launch-started (GAppInfo, GVariant) + launched (GAppInfo, GVariant) + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: AppLaunchContextPrivate = ... def do_get_display(self, info: AppInfo, files: list[File]) -> Optional[str]: ... @@ -702,6 +865,14 @@ class AppLaunchContext(GObject.Object): def unsetenv(self, variable: str) -> None: ... class AppLaunchContextClass(GObject.GPointer): + """ + :Constructors: + + :: + + AppLaunchContextClass() + """ + parent_class: GObject.ObjectClass = ... get_display: Callable[[AppLaunchContext, AppInfo, list[File]], Optional[str]] = ... get_startup_notify_id: Callable[ @@ -710,32 +881,79 @@ class AppLaunchContextClass(GObject.GPointer): launch_failed: Callable[[AppLaunchContext, str], None] = ... launched: Callable[[AppLaunchContext, AppInfo, GLib.Variant], None] = ... launch_started: Callable[[AppLaunchContext, AppInfo, GLib.Variant], None] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... class AppLaunchContextPrivate(GObject.GPointer): ... class Application(GObject.Object, ActionGroup, ActionMap): + """ + :Constructors: + + :: + + Application(**properties) + new(application_id:str=None, flags:Gio.ApplicationFlags) -> Gio.Application + + Object GApplication + + Signals from GApplication: + startup () + shutdown () + activate () + open (gpointer, gint, gchararray) + command-line (GApplicationCommandLine) -> gint + handle-local-options (GVariantDict) -> gint + name-lost () -> gboolean + + Properties from GApplication: + application-id -> gchararray: Application identifier + The unique identifier for the application + flags -> GApplicationFlags: Application flags + Flags specifying the behaviour of the application + resource-base-path -> gchararray: Resource base path + The base resource path for the application + is-registered -> gboolean: Is registered + If g_application_register() has been called + is-remote -> gboolean: Is remote + If this application instance is remote + inactivity-timeout -> guint: Inactivity timeout + Time (ms) to stay alive after becoming idle + action-group -> GActionGroup: Action group + The group of actions that the application exports + is-busy -> gboolean: Is busy + If this application is currently marked busy + + Signals from GActionGroup: + action-added (gchararray) + action-removed (gchararray) + action-enabled-changed (gchararray, gboolean) + action-state-changed (gchararray, GVariant) + + Signals from GObject: + notify (GParam) + """ + class Props: - action_group: ActionGroup - application_id: str + application_id: Optional[str] flags: ApplicationFlags inactivity_timeout: int is_busy: bool is_registered: bool is_remote: bool - resource_base_path: str + resource_base_path: Optional[str] + action_group: Optional[ActionGroup] props: Props = ... parent_instance: GObject.Object = ... priv: ApplicationPrivate = ... def __init__( self, - action_group: ActionGroup = ..., - application_id: str = ..., + action_group: Optional[ActionGroup] = ..., + application_id: Optional[str] = ..., flags: ApplicationFlags = ..., inactivity_timeout: int = ..., - resource_base_path: str = ..., + resource_base_path: Optional[str] = ..., ): ... def activate(self) -> None: ... def add_main_option( @@ -815,6 +1033,14 @@ class Application(GObject.Object, ActionGroup, ActionMap): def withdraw_notification(self, id: str) -> None: ... class ApplicationClass(GObject.GPointer): + """ + :Constructors: + + :: + + ApplicationClass() + """ + parent_class: GObject.ObjectClass = ... startup: Callable[[Application], None] = ... activate: Callable[[Application], None] = ... @@ -831,12 +1057,35 @@ class ApplicationClass(GObject.GPointer): dbus_unregister: Callable[[Application, DBusConnection, str], None] = ... handle_local_options: Callable[[Application, GLib.VariantDict], int] = ... name_lost: Callable[[Application], bool] = ... - padding: list[None] = ... + padding: list[Any] = ... class ApplicationCommandLine(GObject.Object): + """ + :Constructors: + + :: + + ApplicationCommandLine(**properties) + + Object GApplicationCommandLine + + Properties from GApplicationCommandLine: + arguments -> GVariant: Commandline arguments + The commandline that caused this ::command-line signal emission + options -> GVariant: Options + The options sent along with the commandline + platform-data -> GVariant: Platform data + Platform-specific data for the commandline + is-remote -> gboolean: Is remote + TRUE if this is a remote commandline + + Signals from GObject: + notify (GParam) + """ + class Props: - arguments: GLib.Variant is_remote: bool + arguments: GLib.Variant options: GLib.Variant platform_data: GLib.Variant props: Props = ... @@ -864,21 +1113,38 @@ class ApplicationCommandLine(GObject.Object): def set_exit_status(self, exit_status: int) -> None: ... class ApplicationCommandLineClass(GObject.GPointer): + """ + :Constructors: + + :: + + ApplicationCommandLineClass() + """ + parent_class: GObject.ObjectClass = ... print_literal: Callable[[ApplicationCommandLine, str], None] = ... printerr_literal: Callable[[ApplicationCommandLine, str], None] = ... get_stdin: Callable[[ApplicationCommandLine], Optional[InputStream]] = ... - padding: list[None] = ... + padding: list[Any] = ... class ApplicationCommandLinePrivate(GObject.GPointer): ... class ApplicationPrivate(GObject.GPointer): ... class AsyncInitable(GObject.GInterface): + """ + Interface GAsyncInitable + + Signals from GObject: + notify (GParam) + """ + def init_async( self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def init_finish(self, res: AsyncResult) -> bool: ... @@ -890,28 +1156,91 @@ class AsyncInitable(GObject.GInterface): parameters: GObject.Parameter, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... class AsyncInitableIface(GObject.GPointer): + """ + :Constructors: + + :: + + AsyncInitableIface() + """ + g_iface: GObject.TypeInterface = ... - init_async: Callable[..., None] = ... + init_async: Callable[ + Concatenate[ + AsyncInitable, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... init_finish: Callable[[AsyncInitable, AsyncResult], bool] = ... class AsyncResult(GObject.GInterface): + """ + Interface GAsyncResult + + Signals from GObject: + notify (GParam) + """ + def get_source_object(self) -> Optional[GObject.Object]: ... def get_user_data(self) -> None: ... - def is_tagged(self, source_tag: None) -> bool: ... + def is_tagged(self, source_tag: Optional[Any] = None) -> bool: ... def legacy_propagate_error(self) -> bool: ... class AsyncResultIface(GObject.GPointer): + """ + :Constructors: + + :: + + AsyncResultIface() + """ + g_iface: GObject.TypeInterface = ... get_user_data: Callable[[AsyncResult], None] = ... get_source_object: Callable[[AsyncResult], Optional[GObject.Object]] = ... - is_tagged: Callable[[AsyncResult, None], bool] = ... + is_tagged: Callable[[AsyncResult, Optional[Any]], bool] = ... class BufferedInputStream(FilterInputStream, Seekable): + """ + :Constructors: + + :: + + BufferedInputStream(**properties) + new(base_stream:Gio.InputStream) -> Gio.InputStream + new_sized(base_stream:Gio.InputStream, size:int) -> Gio.InputStream + + Object GBufferedInputStream + + Properties from GBufferedInputStream: + buffer-size -> guint: Buffer Size + The size of the backend buffer + + Properties from GFilterInputStream: + base-stream -> GInputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: buffer_size: int base_stream: InputStream @@ -931,7 +1260,9 @@ class BufferedInputStream(FilterInputStream, Seekable): count: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_fill_finish(self, result: AsyncResult) -> int: ... @@ -941,7 +1272,9 @@ class BufferedInputStream(FilterInputStream, Seekable): count: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def fill_finish(self, result: AsyncResult) -> int: ... @@ -957,19 +1290,68 @@ class BufferedInputStream(FilterInputStream, Seekable): def set_buffer_size(self, size: int) -> None: ... class BufferedInputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + BufferedInputStreamClass() + """ + parent_class: FilterInputStreamClass = ... fill: Callable[[BufferedInputStream, int, Optional[Cancellable]], int] = ... - fill_async: Callable[..., None] = ... + fill_async: Callable[ + Concatenate[ + BufferedInputStream, + int, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... fill_finish: Callable[[BufferedInputStream, AsyncResult], int] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class BufferedInputStreamPrivate(GObject.GPointer): ... class BufferedOutputStream(FilterOutputStream, Seekable): + """ + :Constructors: + + :: + + BufferedOutputStream(**properties) + new(base_stream:Gio.OutputStream) -> Gio.OutputStream + new_sized(base_stream:Gio.OutputStream, size:int) -> Gio.OutputStream + + Object GBufferedOutputStream + + Properties from GBufferedOutputStream: + buffer-size -> guint: Buffer Size + The size of the backend buffer + auto-grow -> gboolean: Auto-grow + Whether the buffer should automatically grow + + Properties from GFilterOutputStream: + base-stream -> GOutputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: auto_grow: bool buffer_size: int @@ -997,13 +1379,39 @@ class BufferedOutputStream(FilterOutputStream, Seekable): def set_buffer_size(self, size: int) -> None: ... class BufferedOutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + BufferedOutputStreamClass() + """ + parent_class: FilterOutputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... class BufferedOutputStreamPrivate(GObject.GPointer): ... class BytesIcon(GObject.Object, Icon, LoadableIcon): + """ + :Constructors: + + :: + + BytesIcon(**properties) + new(bytes:GLib.Bytes) -> Gio.BytesIcon + + Object GBytesIcon + + Properties from GBytesIcon: + bytes -> GBytes: bytes + The bytes containing the icon + + Signals from GObject: + notify (GParam) + """ + class Props: bytes: GLib.Bytes props: Props = ... @@ -1013,6 +1421,23 @@ class BytesIcon(GObject.Object, Icon, LoadableIcon): def new(cls, bytes: GLib.Bytes) -> BytesIcon: ... class Cancellable(GObject.Object): + """ + :Constructors: + + :: + + Cancellable(**properties) + new() -> Gio.Cancellable + + Object GCancellable + + Signals from GCancellable: + cancelled () + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: CancellablePrivate = ... def cancel(self) -> None: ... @@ -1034,17 +1459,47 @@ class Cancellable(GObject.Object): def source_new(self) -> GLib.Source: ... class CancellableClass(GObject.GPointer): + """ + :Constructors: + + :: + + CancellableClass() + """ + parent_class: GObject.ObjectClass = ... cancelled: Callable[[Optional[Cancellable]], None] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class CancellablePrivate(GObject.GPointer): ... class CharsetConverter(GObject.Object, Converter, Initable): + """ + :Constructors: + + :: + + CharsetConverter(**properties) + new(to_charset:str, from_charset:str) -> Gio.CharsetConverter + + Object GCharsetConverter + + Properties from GCharsetConverter: + from-charset -> gchararray: From Charset + The character encoding to convert from + to-charset -> gchararray: To Charset + The character encoding to convert to + use-fallback -> gboolean: Fallback enabled + Use fallback (of form \) for invalid bytes + + Signals from GObject: + notify (GParam) + """ + class Props: from_charset: str to_charset: str @@ -1060,23 +1515,70 @@ class CharsetConverter(GObject.Object, Converter, Initable): def set_use_fallback(self, use_fallback: bool) -> None: ... class CharsetConverterClass(GObject.GPointer): + """ + :Constructors: + + :: + + CharsetConverterClass() + """ + parent_class: GObject.ObjectClass = ... class Converter(GObject.GInterface): + """ + Interface GConverter + + Signals from GObject: + notify (GParam) + """ + def convert( self, inbuf: Sequence[int], outbuf: Sequence[int], flags: ConverterFlags ) -> Tuple[ConverterResult, int, int]: ... def reset(self) -> None: ... class ConverterIface(GObject.GPointer): + """ + :Constructors: + + :: + + ConverterIface() + """ + g_iface: GObject.TypeInterface = ... convert: Callable[ - [Converter, Optional[Sequence[int]], Optional[Sequence[int]], ConverterFlags], + [Converter, Optional[Sequence[int]], Sequence[int], ConverterFlags], Tuple[ConverterResult, int, int], ] = ... reset: Callable[[Converter], None] = ... class ConverterInputStream(FilterInputStream, PollableInputStream): + """ + :Constructors: + + :: + + ConverterInputStream(**properties) + new(base_stream:Gio.InputStream, converter:Gio.Converter) -> Gio.InputStream + + Object GConverterInputStream + + Properties from GConverterInputStream: + converter -> GConverter: Converter + The converter object + + Properties from GFilterInputStream: + base-stream -> GInputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: converter: Converter base_stream: InputStream @@ -1097,16 +1599,48 @@ class ConverterInputStream(FilterInputStream, PollableInputStream): ) -> ConverterInputStream: ... class ConverterInputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + ConverterInputStreamClass() + """ + parent_class: FilterInputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class ConverterInputStreamPrivate(GObject.GPointer): ... class ConverterOutputStream(FilterOutputStream, PollableOutputStream): + """ + :Constructors: + + :: + + ConverterOutputStream(**properties) + new(base_stream:Gio.OutputStream, converter:Gio.Converter) -> Gio.OutputStream + + Object GConverterOutputStream + + Properties from GConverterOutputStream: + converter -> GConverter: Converter + The converter object + + Properties from GFilterOutputStream: + base-stream -> GOutputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: converter: Converter base_stream: OutputStream @@ -1127,34 +1661,83 @@ class ConverterOutputStream(FilterOutputStream, PollableOutputStream): ) -> ConverterOutputStream: ... class ConverterOutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + ConverterOutputStreamClass() + """ + parent_class: FilterOutputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class ConverterOutputStreamPrivate(GObject.GPointer): ... class Credentials(GObject.Object): + """ + :Constructors: + + :: + + Credentials(**properties) + new() -> Gio.Credentials + + Object GCredentials + + Signals from GObject: + notify (GParam) + """ + def get_unix_pid(self) -> int: ... def get_unix_user(self) -> int: ... def is_same_user(self, other_credentials: Credentials) -> bool: ... @classmethod def new(cls) -> Credentials: ... - def set_native(self, native_type: CredentialsType, native: None) -> None: ... + def set_native(self, native_type: CredentialsType, native: Any) -> None: ... def set_unix_user(self, uid: int) -> bool: ... def to_string(self) -> str: ... class CredentialsClass(GObject.GPointer): ... class DBusActionGroup(GObject.Object, ActionGroup, RemoteActionGroup): + """ + :Constructors: + + :: + + DBusActionGroup(**properties) + + Object GDBusActionGroup + + Signals from GActionGroup: + action-added (gchararray) + action-removed (gchararray) + action-enabled-changed (gchararray, gboolean) + action-state-changed (gchararray, GVariant) + + Signals from GObject: + notify (GParam) + """ + @staticmethod def get( connection: DBusConnection, bus_name: Optional[str], object_path: str ) -> DBusActionGroup: ... class DBusAnnotationInfo(GObject.GBoxed): + """ + :Constructors: + + :: + + DBusAnnotationInfo() + """ + ref_count: int = ... key: str = ... value: str = ... @@ -1167,6 +1750,14 @@ class DBusAnnotationInfo(GObject.GBoxed): def unref(self) -> None: ... class DBusArgInfo(GObject.GBoxed): + """ + :Constructors: + + :: + + DBusArgInfo() + """ + ref_count: int = ... name: str = ... signature: str = ... @@ -1175,6 +1766,24 @@ class DBusArgInfo(GObject.GBoxed): def unref(self) -> None: ... class DBusAuthObserver(GObject.Object): + """ + :Constructors: + + :: + + DBusAuthObserver(**properties) + new() -> Gio.DBusAuthObserver + + Object GDBusAuthObserver + + Signals from GDBusAuthObserver: + authorize-authenticated-peer (GIOStream, GCredentials) -> gboolean + allow-mechanism (gchararray) -> gboolean + + Signals from GObject: + notify (GParam) + """ + def allow_mechanism(self, mechanism: str) -> bool: ... def authorize_authenticated_peer( self, stream: IOStream, credentials: Optional[Credentials] = None @@ -1183,16 +1792,56 @@ class DBusAuthObserver(GObject.Object): def new(cls) -> DBusAuthObserver: ... class DBusConnection(GObject.Object, AsyncInitable, Initable): + """ + :Constructors: + + :: + + DBusConnection(**properties) + new_finish(res:Gio.AsyncResult) -> Gio.DBusConnection + new_for_address_finish(res:Gio.AsyncResult) -> Gio.DBusConnection + new_for_address_sync(address:str, flags:Gio.DBusConnectionFlags, observer:Gio.DBusAuthObserver=None, cancellable:Gio.Cancellable=None) -> Gio.DBusConnection + new_sync(stream:Gio.IOStream, guid:str=None, flags:Gio.DBusConnectionFlags, observer:Gio.DBusAuthObserver=None, cancellable:Gio.Cancellable=None) -> Gio.DBusConnection + + Object GDBusConnection + + Signals from GDBusConnection: + closed (gboolean, GError) + + Properties from GDBusConnection: + stream -> GIOStream: IO Stream + The underlying streams used for I/O + address -> gchararray: Address + D-Bus address specifying potential socket endpoints + flags -> GDBusConnectionFlags: Flags + Flags + guid -> gchararray: GUID + GUID of the server peer + unique-name -> gchararray: unique-name + Unique name of bus connection + closed -> gboolean: Closed + Whether the connection is closed + exit-on-close -> gboolean: Exit on close + Whether the process is terminated when the connection is closed + capabilities -> GDBusCapabilityFlags: Capabilities + Capabilities + authentication-observer -> GDBusAuthObserver: Authentication Observer + Object used to assist in the authentication process + + Signals from GObject: + notify (GParam) + """ + class Props: - address: str - authentication_observer: DBusAuthObserver capabilities: DBusCapabilityFlags closed: bool exit_on_close: bool flags: DBusConnectionFlags guid: str stream: IOStream - unique_name: str + unique_name: Optional[str] + address: str + authentication_observer: DBusAuthObserver props: Props = ... def __init__( self, @@ -1204,7 +1853,12 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): stream: IOStream = ..., ): ... def add_filter( - self, filter_function: Callable[..., Optional[DBusMessage]], *user_data: Any + self, + filter_function: Callable[ + Concatenate[DBusConnection, DBusMessage, bool, _VarArgs], + Optional[DBusMessage], + ], + *user_data: Any, ) -> int: ... def call( self, @@ -1217,7 +1871,9 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): flags: DBusCallFlags, timeout_msec: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def call_finish(self, res: AsyncResult) -> GLib.Variant: ... @@ -1245,7 +1901,9 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): timeout_msec: int, fd_list: Optional[UnixFDList] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def call_with_unix_fd_list_finish( @@ -1267,7 +1925,9 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): def close( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def close_finish(self, res: AsyncResult) -> bool: ... @@ -1287,7 +1947,9 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): def flush( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def flush_finish(self, res: AsyncResult) -> bool: ... @@ -1308,7 +1970,9 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): flags: DBusConnectionFlags, observer: Optional[DBusAuthObserver] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @classmethod @@ -1319,7 +1983,9 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): flags: DBusConnectionFlags, observer: Optional[DBusAuthObserver] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @classmethod @@ -1354,8 +2020,8 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): object_path: str, vtable: DBusSubtreeVTable, flags: DBusSubtreeFlags, - user_data: None, - user_data_free_func: Callable[[None], None], + user_data: Optional[Any], + user_data_free_func: Callable[[Optional[Any]], None], ) -> int: ... def remove_filter(self, filter_id: int) -> None: ... def send_message( @@ -1367,7 +2033,9 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): flags: DBusSendMessageFlags, timeout_msec: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> int: ... def send_message_with_reply_finish(self, res: AsyncResult) -> DBusMessage: ... @@ -1387,7 +2055,12 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): object_path: Optional[str], arg0: Optional[str], flags: DBusSignalFlags, - callback: Callable[..., None], + callback: Callable[ + Concatenate[ + DBusConnection, Optional[str], str, str, str, GLib.Variant, _VarArgs + ], + None, + ], *user_data: Any, ) -> int: ... def signal_unsubscribe(self, subscription_id: int) -> None: ... @@ -1398,15 +2071,38 @@ class DBusConnection(GObject.Object, AsyncInitable, Initable): def unregister_subtree(self, registration_id: int) -> bool: ... class DBusErrorEntry(GObject.GPointer): + """ + :Constructors: + + :: + + DBusErrorEntry() + """ + error_code: int = ... dbus_error_name: str = ... class DBusInterface(GObject.GInterface): + """ + Interface GDBusInterface + + Signals from GObject: + notify (GParam) + """ + def get_info(self) -> DBusInterfaceInfo: ... def get_object(self) -> Optional[DBusObject]: ... def set_object(self, object: Optional[DBusObject] = None) -> None: ... class DBusInterfaceIface(GObject.GPointer): + """ + :Constructors: + + :: + + DBusInterfaceIface() + """ + parent_iface: GObject.TypeInterface = ... get_info: Callable[[DBusInterface], DBusInterfaceInfo] = ... get_object: Callable[[DBusInterface], Optional[DBusObject]] = ... @@ -1414,6 +2110,14 @@ class DBusInterfaceIface(GObject.GPointer): dup_object: Callable[[DBusInterface], Optional[DBusObject]] = ... class DBusInterfaceInfo(GObject.GBoxed): + """ + :Constructors: + + :: + + DBusInterfaceInfo() + """ + ref_count: int = ... name: str = ... methods: list[DBusMethodInfo] = ... @@ -1430,6 +2134,26 @@ class DBusInterfaceInfo(GObject.GBoxed): def unref(self) -> None: ... class DBusInterfaceSkeleton(GObject.Object, DBusInterface): + """ + :Constructors: + + :: + + DBusInterfaceSkeleton(**properties) + + Object GDBusInterfaceSkeleton + + Signals from GDBusInterfaceSkeleton: + g-authorize-method (GDBusMethodInvocation) -> gboolean + + Properties from GDBusInterfaceSkeleton: + g-flags -> GDBusInterfaceSkeletonFlags: g-flags + Flags for the interface skeleton + + Signals from GObject: + notify (GParam) + """ + class Props: g_flags: DBusInterfaceSkeletonFlags props: Props = ... @@ -1454,32 +2178,105 @@ class DBusInterfaceSkeleton(GObject.Object, DBusInterface): def unexport_from_connection(self, connection: DBusConnection) -> None: ... class DBusInterfaceSkeletonClass(GObject.GPointer): + """ + :Constructors: + + :: + + DBusInterfaceSkeletonClass() + """ + parent_class: GObject.ObjectClass = ... get_info: Callable[[DBusInterfaceSkeleton], DBusInterfaceInfo] = ... - get_vtable: None = ... + get_vtable: Any = ... get_properties: Callable[[DBusInterfaceSkeleton], GLib.Variant] = ... flush: Callable[[DBusInterfaceSkeleton], None] = ... - vfunc_padding: list[None] = ... + vfunc_padding: list[Any] = ... g_authorize_method: Callable[ [DBusInterfaceSkeleton, DBusMethodInvocation], bool ] = ... - signal_padding: list[None] = ... + signal_padding: list[Any] = ... class DBusInterfaceSkeletonPrivate(GObject.GPointer): ... class DBusInterfaceVTable(GObject.GPointer): - method_call: Callable[..., None] = ... - get_property: Callable[..., GLib.Variant] = ... - set_property: Callable[..., bool] = ... - padding: list[None] = ... + """ + :Constructors: + + :: + + DBusInterfaceVTable() + """ + + method_call: Callable[ + Concatenate[ + DBusConnection, + str, + str, + str, + str, + GLib.Variant, + DBusMethodInvocation, + _VarArgs, + ], + None, + ] = ... + get_property: Callable[ + Concatenate[DBusConnection, str, str, str, str, GLib.Error, _VarArgs], + GLib.Variant, + ] = ... + set_property: Callable[ + Concatenate[ + DBusConnection, str, str, str, str, GLib.Variant, GLib.Error, _VarArgs + ], + bool, + ] = ... + padding: list[Any] = ... class DBusMenuModel(MenuModel): + """ + :Constructors: + + :: + + DBusMenuModel(**properties) + + Object GDBusMenuModel + + Signals from GMenuModel: + items-changed (gint, gint, gint) + + Signals from GObject: + notify (GParam) + """ + @staticmethod def get( connection: DBusConnection, bus_name: Optional[str], object_path: str ) -> DBusMenuModel: ... class DBusMessage(GObject.Object): + """ + :Constructors: + + :: + + DBusMessage(**properties) + new() -> Gio.DBusMessage + new_from_blob(blob:list, capabilities:Gio.DBusCapabilityFlags) -> Gio.DBusMessage + new_method_call(name:str=None, path:str, interface_:str=None, method:str) -> Gio.DBusMessage + new_signal(path:str, interface_:str, signal:str) -> Gio.DBusMessage + + Object GDBusMessage + + Properties from GDBusMessage: + locked -> gboolean: Locked + Whether the message is locked + + Signals from GObject: + notify (GParam) + """ + class Props: locked: bool props: Props = ... @@ -1547,6 +2344,14 @@ class DBusMessage(GObject.Object): def to_gerror(self) -> bool: ... class DBusMethodInfo(GObject.GBoxed): + """ + :Constructors: + + :: + + DBusMethodInfo() + """ + ref_count: int = ... name: str = ... in_args: list[DBusArgInfo] = ... @@ -1556,6 +2361,19 @@ class DBusMethodInfo(GObject.GBoxed): def unref(self) -> None: ... class DBusMethodInvocation(GObject.Object): + """ + :Constructors: + + :: + + DBusMethodInvocation(**properties) + + Object GDBusMethodInvocation + + Signals from GObject: + notify (GParam) + """ + def get_connection(self) -> DBusConnection: ... def get_interface_name(self) -> str: ... def get_message(self) -> DBusMessage: ... @@ -1576,6 +2394,15 @@ class DBusMethodInvocation(GObject.Object): ) -> None: ... class DBusNodeInfo(GObject.GBoxed): + """ + :Constructors: + + :: + + DBusNodeInfo() + new_for_xml(xml_data:str) -> Gio.DBusNodeInfo + """ + ref_count: int = ... path: str = ... interfaces: list[DBusInterfaceInfo] = ... @@ -1589,11 +2416,26 @@ class DBusNodeInfo(GObject.GBoxed): def unref(self) -> None: ... class DBusObject(GObject.GInterface): + """ + Interface GDBusObject + + Signals from GObject: + notify (GParam) + """ + def get_interface(self, interface_name: str) -> Optional[DBusInterface]: ... def get_interfaces(self) -> list[DBusInterface]: ... def get_object_path(self) -> str: ... class DBusObjectIface(GObject.GPointer): + """ + :Constructors: + + :: + + DBusObjectIface() + """ + parent_iface: GObject.TypeInterface = ... get_object_path: Callable[[DBusObject], str] = ... get_interfaces: Callable[[DBusObject], list[DBusInterface]] = ... @@ -1602,6 +2444,13 @@ class DBusObjectIface(GObject.GPointer): interface_removed: Callable[[DBusObject, DBusInterface], None] = ... class DBusObjectManager(GObject.GInterface): + """ + Interface GDBusObjectManager + + Signals from GObject: + notify (GParam) + """ + def get_interface( self, object_path: str, interface_name: str ) -> Optional[DBusInterface]: ... @@ -1612,16 +2461,63 @@ class DBusObjectManager(GObject.GInterface): class DBusObjectManagerClient( GObject.Object, AsyncInitable, DBusObjectManager, Initable ): + """ + :Constructors: + + :: + + DBusObjectManagerClient(**properties) + new_finish(res:Gio.AsyncResult) -> Gio.DBusObjectManagerClient + new_for_bus_finish(res:Gio.AsyncResult) -> Gio.DBusObjectManagerClient + new_for_bus_sync(bus_type:Gio.BusType, flags:Gio.DBusObjectManagerClientFlags, name:str, object_path:str, get_proxy_type_func:Gio.DBusProxyTypeFunc=None, get_proxy_type_user_data=None, cancellable:Gio.Cancellable=None) -> Gio.DBusObjectManagerClient + new_sync(connection:Gio.DBusConnection, flags:Gio.DBusObjectManagerClientFlags, name:str=None, object_path:str, get_proxy_type_func:Gio.DBusProxyTypeFunc=None, get_proxy_type_user_data=None, cancellable:Gio.Cancellable=None) -> Gio.DBusObjectManagerClient + + Object GDBusObjectManagerClient + + Signals from GDBusObjectManagerClient: + interface-proxy-signal (GDBusObjectProxy, GDBusProxy, gchararray, gchararray, GVariant) + interface-proxy-properties-changed (GDBusObjectProxy, GDBusProxy, GVariant, GStrv) + + Properties from GDBusObjectManagerClient: + bus-type -> GBusType: Bus Type + The bus to connect to, if any + connection -> GDBusConnection: Connection + The connection to use + flags -> GDBusObjectManagerClientFlags: Flags + Flags for the proxy manager + object-path -> gchararray: Object Path + The object path of the control object + name -> gchararray: Name + Name that the manager is for + name-owner -> gchararray: Name Owner + The owner of the name we are watching + get-proxy-type-func -> gpointer: GDBusProxyTypeFunc Function Pointer + The GDBusProxyTypeFunc pointer to use + get-proxy-type-user-data -> gpointer: GDBusProxyTypeFunc User Data + The GDBusProxyTypeFunc user_data + get-proxy-type-destroy-notify -> gpointer: GDBusProxyTypeFunc user data free function + The GDBusProxyTypeFunc user data free function + + Signals from GDBusObjectManager: + object-added (GDBusObject) + object-removed (GDBusObject) + interface-added (GDBusObject, GDBusInterface) + interface-removed (GDBusObject, GDBusInterface) + + Signals from GObject: + notify (GParam) + """ + class Props: - bus_type: BusType connection: DBusConnection flags: DBusObjectManagerClientFlags - get_proxy_type_destroy_notify: None - get_proxy_type_func: None - get_proxy_type_user_data: None + get_proxy_type_destroy_notify: Any + get_proxy_type_func: Any + get_proxy_type_user_data: Any name: str - name_owner: str + name_owner: Optional[str] object_path: str + bus_type: BusType props: Props = ... parent_instance: GObject.Object = ... priv: DBusObjectManagerClientPrivate = ... @@ -1630,9 +2526,9 @@ class DBusObjectManagerClient( bus_type: BusType = ..., connection: DBusConnection = ..., flags: DBusObjectManagerClientFlags = ..., - get_proxy_type_destroy_notify: None = ..., - get_proxy_type_func: None = ..., - get_proxy_type_user_data: None = ..., + get_proxy_type_destroy_notify: Any = ..., + get_proxy_type_func: Any = ..., + get_proxy_type_user_data: Any = ..., name: str = ..., object_path: str = ..., ): ... @@ -1661,9 +2557,16 @@ class DBusObjectManagerClient( flags: DBusObjectManagerClientFlags, name: str, object_path: str, - get_proxy_type_func: Optional[Callable[..., Type]] = None, + get_proxy_type_func: Optional[ + Callable[ + Concatenate[DBusObjectManagerClient, str, Optional[str], _VarArgs], Type + ] + ] = None, + get_proxy_type_user_data: Optional[Any] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @classmethod @@ -1674,9 +2577,16 @@ class DBusObjectManagerClient( flags: DBusObjectManagerClientFlags, name: str, object_path: str, - get_proxy_type_func: Optional[Callable[..., Type]] = None, + get_proxy_type_func: Optional[ + Callable[ + Concatenate[DBusObjectManagerClient, str, Optional[str], _VarArgs], Type + ] + ] = None, + get_proxy_type_user_data: Optional[Any] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @classmethod @@ -1688,9 +2598,13 @@ class DBusObjectManagerClient( flags: DBusObjectManagerClientFlags, name: str, object_path: str, - get_proxy_type_func: Optional[Callable[..., Type]] = None, + get_proxy_type_func: Optional[ + Callable[ + Concatenate[DBusObjectManagerClient, str, Optional[str], _VarArgs], Type + ] + ] = None, + get_proxy_type_user_data: Optional[Any] = None, cancellable: Optional[Cancellable] = None, - *get_proxy_type_user_data: Any, ) -> DBusObjectManagerClient: ... @classmethod def new_sync( @@ -1699,12 +2613,24 @@ class DBusObjectManagerClient( flags: DBusObjectManagerClientFlags, name: Optional[str], object_path: str, - get_proxy_type_func: Optional[Callable[..., Type]] = None, + get_proxy_type_func: Optional[ + Callable[ + Concatenate[DBusObjectManagerClient, str, Optional[str], _VarArgs], Type + ] + ] = None, + get_proxy_type_user_data: Optional[Any] = None, cancellable: Optional[Cancellable] = None, - *get_proxy_type_user_data: Any, ) -> DBusObjectManagerClient: ... class DBusObjectManagerClientClass(GObject.GPointer): + """ + :Constructors: + + :: + + DBusObjectManagerClientClass() + """ + parent_class: GObject.ObjectClass = ... interface_proxy_signal: Callable[ [DBusObjectManagerClient, DBusObjectProxy, DBusProxy, str, str, GLib.Variant], @@ -1713,11 +2639,19 @@ class DBusObjectManagerClientClass(GObject.GPointer): interface_proxy_properties_changed: Callable[ [DBusObjectManagerClient, DBusObjectProxy, DBusProxy, GLib.Variant, str], None ] = ... - padding: list[None] = ... + padding: list[Any] = ... class DBusObjectManagerClientPrivate(GObject.GPointer): ... class DBusObjectManagerIface(GObject.GPointer): + """ + :Constructors: + + :: + + DBusObjectManagerIface() + """ + parent_iface: GObject.TypeInterface = ... get_object_path: Callable[[DBusObjectManager], str] = ... get_objects: Callable[[DBusObjectManager], list[DBusObject]] = ... @@ -1735,13 +2669,41 @@ class DBusObjectManagerIface(GObject.GPointer): ] = ... class DBusObjectManagerServer(GObject.Object, DBusObjectManager): + """ + :Constructors: + + :: + + DBusObjectManagerServer(**properties) + new(object_path:str) -> Gio.DBusObjectManagerServer + + Object GDBusObjectManagerServer + + Properties from GDBusObjectManagerServer: + connection -> GDBusConnection: Connection + The connection to export objects on + object-path -> gchararray: Object Path + The object path to register the manager object at + + Signals from GDBusObjectManager: + object-added (GDBusObject) + object-removed (GDBusObject) + interface-added (GDBusObject, GDBusInterface) + interface-removed (GDBusObject, GDBusInterface) + + Signals from GObject: + notify (GParam) + """ + class Props: - connection: DBusConnection + connection: Optional[DBusConnection] object_path: str props: Props = ... parent_instance: GObject.Object = ... priv: DBusObjectManagerServerPrivate = ... - def __init__(self, connection: DBusConnection = ..., object_path: str = ...): ... + def __init__( + self, connection: Optional[DBusConnection] = ..., object_path: str = ... + ): ... def export(self, object: DBusObjectSkeleton) -> None: ... def export_uniquely(self, object: DBusObjectSkeleton) -> None: ... def get_connection(self) -> Optional[DBusConnection]: ... @@ -1752,12 +2714,44 @@ class DBusObjectManagerServer(GObject.Object, DBusObjectManager): def unexport(self, object_path: str) -> bool: ... class DBusObjectManagerServerClass(GObject.GPointer): + """ + :Constructors: + + :: + + DBusObjectManagerServerClass() + """ + parent_class: GObject.ObjectClass = ... - padding: list[None] = ... + padding: list[Any] = ... class DBusObjectManagerServerPrivate(GObject.GPointer): ... class DBusObjectProxy(GObject.Object, DBusObject): + """ + :Constructors: + + :: + + DBusObjectProxy(**properties) + new(connection:Gio.DBusConnection, object_path:str) -> Gio.DBusObjectProxy + + Object GDBusObjectProxy + + Properties from GDBusObjectProxy: + g-object-path -> gchararray: Object Path + The object path of the proxy + g-connection -> GDBusConnection: Connection + The connection of the proxy + + Signals from GDBusObject: + interface-added (GDBusInterface) + interface-removed (GDBusInterface) + + Signals from GObject: + notify (GParam) + """ + class Props: g_connection: DBusConnection g_object_path: str @@ -1772,12 +2766,45 @@ class DBusObjectProxy(GObject.Object, DBusObject): def new(cls, connection: DBusConnection, object_path: str) -> DBusObjectProxy: ... class DBusObjectProxyClass(GObject.GPointer): + """ + :Constructors: + + :: + + DBusObjectProxyClass() + """ + parent_class: GObject.ObjectClass = ... - padding: list[None] = ... + padding: list[Any] = ... class DBusObjectProxyPrivate(GObject.GPointer): ... class DBusObjectSkeleton(GObject.Object, DBusObject): + """ + :Constructors: + + :: + + DBusObjectSkeleton(**properties) + new(object_path:str) -> Gio.DBusObjectSkeleton + + Object GDBusObjectSkeleton + + Signals from GDBusObjectSkeleton: + authorize-method (GDBusInterfaceSkeleton, GDBusMethodInvocation) -> gboolean + + Properties from GDBusObjectSkeleton: + g-object-path -> gchararray: Object Path + The object path where the object is exported + + Signals from GDBusObject: + interface-added (GDBusInterface) + interface-removed (GDBusInterface) + + Signals from GObject: + notify (GParam) + """ + class Props: g_object_path: str props: Props = ... @@ -1796,15 +2823,31 @@ class DBusObjectSkeleton(GObject.Object, DBusObject): def set_object_path(self, object_path: str) -> None: ... class DBusObjectSkeletonClass(GObject.GPointer): + """ + :Constructors: + + :: + + DBusObjectSkeletonClass() + """ + parent_class: GObject.ObjectClass = ... authorize_method: Callable[ [DBusObjectSkeleton, DBusInterfaceSkeleton, DBusMethodInvocation], bool ] = ... - padding: list[None] = ... + padding: list[Any] = ... class DBusObjectSkeletonPrivate(GObject.GPointer): ... class DBusPropertyInfo(GObject.GBoxed): + """ + :Constructors: + + :: + + DBusPropertyInfo() + """ + ref_count: int = ... name: str = ... signature: str = ... @@ -1814,8 +2857,127 @@ class DBusPropertyInfo(GObject.GBoxed): def unref(self) -> None: ... class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable): + """ + Provide comfortable and pythonic method calls. + + This marshalls the method arguments into a GVariant, invokes the + call_sync() method on the DBusProxy object, and unmarshalls the result + GVariant back into a Python tuple. + + The first argument always needs to be the D-Bus signature tuple of the + method call. Example: + + proxy = Gio.DBusProxy.new_sync(...) + result = proxy.MyMethod('(is)', 42, 'hello') + + The exception are methods which take no arguments, like + proxy.MyMethod('()'). For these you can omit the signature and just write + proxy.MyMethod(). + + Optional keyword arguments: + + - timeout: timeout for the call in milliseconds (default to D-Bus timeout) + + - flags: Combination of Gio.DBusCallFlags.* + + - result_handler: Do an asynchronous method call and invoke + result_handler(proxy_object, result, user_data) when it finishes. + + - error_handler: If the asynchronous call raises an exception, + error_handler(proxy_object, exception, user_data) is called when it + finishes. If error_handler is not given, result_handler is called with + the exception object as result instead. + + - user_data: Optional user data to pass to result_handler for + asynchronous calls. + + Example for asynchronous calls: + + def mymethod_done(proxy, result, user_data): + if isinstance(result, Exception): + # handle error + else: + # do something with result + + proxy.MyMethod('(is)', 42, 'hello', + result_handler=mymethod_done, user_data='data') + + Object GDBusProxy + + Provide comfortable and pythonic method calls. + + This marshalls the method arguments into a GVariant, invokes the + call_sync() method on the DBusProxy object, and unmarshalls the result + GVariant back into a Python tuple. + + The first argument always needs to be the D-Bus signature tuple of the + method call. Example: + + proxy = Gio.DBusProxy.new_sync(...) + result = proxy.MyMethod('(is)', 42, 'hello') + + The exception are methods which take no arguments, like + proxy.MyMethod('()'). For these you can omit the signature and just write + proxy.MyMethod(). + + Optional keyword arguments: + + - timeout: timeout for the call in milliseconds (default to D-Bus timeout) + + - flags: Combination of Gio.DBusCallFlags.* + + - result_handler: Do an asynchronous method call and invoke + result_handler(proxy_object, result, user_data) when it finishes. + + - error_handler: If the asynchronous call raises an exception, + error_handler(proxy_object, exception, user_data) is called when it + finishes. If error_handler is not given, result_handler is called with + the exception object as result instead. + + - user_data: Optional user data to pass to result_handler for + asynchronous calls. + + Example for asynchronous calls: + + def mymethod_done(proxy, result, user_data): + if isinstance(result, Exception): + # handle error + else: + # do something with result + + proxy.MyMethod('(is)', 42, 'hello', + result_handler=mymethod_done, user_data='data') + + + Signals from GDBusProxy: + g-properties-changed (GVariant, GStrv) + g-signal (gchararray, gchararray, GVariant) + + Properties from GDBusProxy: + g-connection -> GDBusConnection: g-connection + The connection the proxy is for + g-bus-type -> GBusType: Bus Type + The bus to connect to, if any + g-name -> gchararray: g-name + The well-known or unique name that the proxy is for + g-name-owner -> gchararray: g-name-owner + The unique name for the owner + g-flags -> GDBusProxyFlags: g-flags + Flags for the proxy + g-object-path -> gchararray: g-object-path + The object path the proxy is for + g-interface-name -> gchararray: g-interface-name + The D-Bus interface name the proxy is for + g-default-timeout -> gint: Default Timeout + Timeout for remote method invocation + g-interface-info -> GDBusInterfaceInfo: Interface Information + Interface Information + + Signals from GObject: + notify (GParam) + """ + class Props: - g_bus_type: BusType g_connection: DBusConnection g_default_timeout: int g_flags: DBusProxyFlags @@ -1824,6 +2986,7 @@ class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable): g_name: str g_name_owner: str g_object_path: str + g_bus_type: BusType props: Props = ... parent_instance: GObject.Object = ... priv: DBusProxyPrivate = ... @@ -1845,7 +3008,9 @@ class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable): flags: DBusCallFlags, timeout_msec: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def call_finish(self, res: AsyncResult) -> GLib.Variant: ... @@ -1865,7 +3030,9 @@ class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable): timeout_msec: int, fd_list: Optional[UnixFDList] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def call_with_unix_fd_list_finish( @@ -1905,7 +3072,9 @@ class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable): object_path: str, interface_name: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @classmethod @@ -1919,7 +3088,9 @@ class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable): object_path: str, interface_name: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @classmethod @@ -1953,14 +3124,53 @@ class DBusProxy(GObject.Object, AsyncInitable, DBusInterface, Initable): def set_interface_info(self, info: Optional[DBusInterfaceInfo] = None) -> None: ... class DBusProxyClass(GObject.GPointer): + """ + :Constructors: + + :: + + DBusProxyClass() + """ + parent_class: GObject.ObjectClass = ... g_properties_changed: Callable[[DBusProxy, GLib.Variant, str], None] = ... g_signal: Callable[[DBusProxy, str, str, GLib.Variant], None] = ... - padding: list[None] = ... + padding: list[Any] = ... class DBusProxyPrivate(GObject.GPointer): ... class DBusServer(GObject.Object, Initable): + """ + :Constructors: + + :: + + DBusServer(**properties) + new_sync(address:str, flags:Gio.DBusServerFlags, guid:str, observer:Gio.DBusAuthObserver=None, cancellable:Gio.Cancellable=None) -> Gio.DBusServer + + Object GDBusServer + + Signals from GDBusServer: + new-connection (GDBusConnection) -> gboolean + + Properties from GDBusServer: + address -> gchararray: Address + The address to listen on + client-address -> gchararray: Client Address + The address clients can use + flags -> GDBusServerFlags: Flags + Flags for the server + guid -> gchararray: GUID + The guid of the server + active -> gboolean: Active + Whether the server is currently active + authentication-observer -> GDBusAuthObserver: Authentication Observer + Object used to assist in the authentication process + + Signals from GObject: + notify (GParam) + """ + class Props: active: bool address: str @@ -1993,6 +3203,14 @@ class DBusServer(GObject.Object, Initable): def stop(self) -> None: ... class DBusSignalInfo(GObject.GBoxed): + """ + :Constructors: + + :: + + DBusSignalInfo() + """ + ref_count: int = ... name: str = ... args: list[DBusArgInfo] = ... @@ -2001,12 +3219,58 @@ class DBusSignalInfo(GObject.GBoxed): def unref(self) -> None: ... class DBusSubtreeVTable(GObject.GPointer): - enumerate: Callable[..., list[str]] = ... - introspect: Callable[..., Optional[list[DBusInterfaceInfo]]] = ... - dispatch: Callable[..., Optional[DBusInterfaceVTable]] = ... - padding: list[None] = ... + """ + :Constructors: + + :: + + DBusSubtreeVTable() + """ + + enumerate: Callable[ + Concatenate[DBusConnection, str, str, _VarArgs], list[str] + ] = ... + introspect: Callable[ + Concatenate[DBusConnection, str, str, str, _VarArgs], + Optional[list[DBusInterfaceInfo]], + ] = ... + dispatch: Callable[ + Concatenate[DBusConnection, str, str, str, str, Any, _VarArgs], + Optional[DBusInterfaceVTable], + ] = ... + padding: list[Any] = ... class DataInputStream(BufferedInputStream, Seekable): + """ + :Constructors: + + :: + + DataInputStream(**properties) + new(base_stream:Gio.InputStream) -> Gio.DataInputStream + + Object GDataInputStream + + Properties from GDataInputStream: + byte-order -> GDataStreamByteOrder: Byte order + The byte order + newline-type -> GDataStreamNewlineType: Newline type + The accepted types of line ending + + Properties from GBufferedInputStream: + buffer-size -> guint: Buffer Size + The size of the backend buffer + + Properties from GFilterInputStream: + base-stream -> GInputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: byte_order: DataStreamByteOrder newline_type: DataStreamNewlineType @@ -2039,7 +3303,9 @@ class DataInputStream(BufferedInputStream, Seekable): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def read_line_finish(self, result: AsyncResult) -> Tuple[Optional[bytes], int]: ... @@ -2060,7 +3326,9 @@ class DataInputStream(BufferedInputStream, Seekable): stop_chars: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def read_until_finish(self, result: AsyncResult) -> Tuple[str, int]: ... @@ -2076,7 +3344,9 @@ class DataInputStream(BufferedInputStream, Seekable): stop_chars_len: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def read_upto_finish(self, result: AsyncResult) -> Tuple[str, int]: ... @@ -2084,16 +3354,48 @@ class DataInputStream(BufferedInputStream, Seekable): def set_newline_type(self, type: DataStreamNewlineType) -> None: ... class DataInputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + DataInputStreamClass() + """ + parent_class: BufferedInputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class DataInputStreamPrivate(GObject.GPointer): ... class DataOutputStream(FilterOutputStream, Seekable): + """ + :Constructors: + + :: + + DataOutputStream(**properties) + new(base_stream:Gio.OutputStream) -> Gio.DataOutputStream + + Object GDataOutputStream + + Properties from GDataOutputStream: + byte-order -> GDataStreamByteOrder: Byte order + The byte order + + Properties from GFilterOutputStream: + base-stream -> GOutputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: byte_order: DataStreamByteOrder base_stream: OutputStream @@ -2137,16 +3439,31 @@ class DataOutputStream(FilterOutputStream, Seekable): def set_byte_order(self, order: DataStreamByteOrder) -> None: ... class DataOutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + DataOutputStreamClass() + """ + parent_class: FilterOutputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class DataOutputStreamPrivate(GObject.GPointer): ... class DatagramBased(GObject.GInterface): + """ + Interface GDatagramBased + + Signals from GObject: + notify (GParam) + """ + def condition_check(self, condition: GLib.IOCondition) -> GLib.IOCondition: ... def condition_wait( self, @@ -2173,6 +3490,14 @@ class DatagramBased(GObject.GInterface): ) -> int: ... class DatagramBasedInterface(GObject.GPointer): + """ + :Constructors: + + :: + + DatagramBasedInterface() + """ + g_iface: GObject.TypeInterface = ... receive_messages: Callable[ [DatagramBased, Sequence[InputMessage], int, int, Optional[Cancellable]], int @@ -2189,10 +3514,38 @@ class DatagramBasedInterface(GObject.GPointer): ] = ... class DebugController(GObject.GInterface): + """ + Interface GDebugController + + Signals from GObject: + notify (GParam) + """ + def get_debug_enabled(self) -> bool: ... def set_debug_enabled(self, debug_enabled: bool) -> None: ... class DebugControllerDBus(GObject.Object, DebugController, Initable): + """ + :Constructors: + + :: + + DebugControllerDBus(**properties) + new(connection:Gio.DBusConnection, cancellable:Gio.Cancellable=None) -> Gio.DebugControllerDBus or None + + Object GDebugControllerDBus + + Signals from GDebugControllerDBus: + authorize (GDBusMethodInvocation) -> gboolean + + Properties from GDebugControllerDBus: + connection -> GDBusConnection: D-Bus Connection + The D-Bus connection to expose the debugging interface on. + + Signals from GObject: + notify (GParam) + """ + class Props: connection: DBusConnection debug_enabled: bool @@ -2207,16 +3560,52 @@ class DebugControllerDBus(GObject.Object, DebugController, Initable): def stop(self) -> None: ... class DebugControllerDBusClass(GObject.GPointer): + """ + :Constructors: + + :: + + DebugControllerDBusClass() + """ + parent_class: GObject.ObjectClass = ... authorize: Callable[[DebugControllerDBus, DBusMethodInvocation], bool] = ... - padding: list[None] = ... + padding: list[Any] = ... class DebugControllerInterface(GObject.GPointer): + """ + :Constructors: + + :: + + DebugControllerInterface() + """ + g_iface: GObject.TypeInterface = ... class DesktopAppInfo(GObject.Object, AppInfo): + """ + :Constructors: + + :: + + DesktopAppInfo(**properties) + new(desktop_id:str) -> Gio.DesktopAppInfo or None + new_from_filename(filename:str) -> Gio.DesktopAppInfo or None + new_from_keyfile(key_file:GLib.KeyFile) -> Gio.DesktopAppInfo or None + + Object GDesktopAppInfo + + Properties from GDesktopAppInfo: + filename -> gchararray: Filename + + + Signals from GObject: + notify (GParam) + """ + class Props: - filename: str + filename: Optional[str] props: Props = ... def __init__(self, filename: str = ...): ... def get_action_name(self, action_name: str) -> str: ... @@ -2243,8 +3632,11 @@ class DesktopAppInfo(GObject.Object, AppInfo): uris: list[str], launch_context: Optional[AppLaunchContext], spawn_flags: GLib.SpawnFlags, - user_setup: Optional[Callable[..., None]] = None, - pid_callback: Optional[Callable[..., None]] = None, + user_setup: Optional[Callable[Concatenate[_VarArgs], None]] = None, + user_setup_data: Optional[Any] = None, + pid_callback: Optional[ + Callable[Concatenate[DesktopAppInfo, int, _VarArgs], None] + ] = None, *pid_callback_data: Any, ) -> bool: ... def launch_uris_as_manager_with_fds( @@ -2252,12 +3644,15 @@ class DesktopAppInfo(GObject.Object, AppInfo): uris: list[str], launch_context: Optional[AppLaunchContext], spawn_flags: GLib.SpawnFlags, - user_setup: Optional[Callable[..., None]], - pid_callback: Optional[Callable[..., None]], + user_setup: Optional[Callable[Concatenate[_VarArgs], None]], + user_setup_data: Optional[Any], + pid_callback: Optional[ + Callable[Concatenate[DesktopAppInfo, int, _VarArgs], None] + ], + pid_callback_data: Optional[Any], stdin_fd: int, stdout_fd: int, stderr_fd: int, - *pid_callback_data: Any, ) -> bool: ... def list_actions(self) -> list[str]: ... @classmethod @@ -2272,18 +3667,48 @@ class DesktopAppInfo(GObject.Object, AppInfo): def set_desktop_env(desktop_env: str) -> None: ... class DesktopAppInfoClass(GObject.GPointer): + """ + :Constructors: + + :: + + DesktopAppInfoClass() + """ + parent_class: GObject.ObjectClass = ... class DesktopAppInfoLookup(GObject.GInterface): + """ + Interface GDesktopAppInfoLookup + + Signals from GObject: + notify (GParam) + """ + def get_default_for_uri_scheme(self, uri_scheme: str) -> Optional[AppInfo]: ... class DesktopAppInfoLookupIface(GObject.GPointer): + """ + :Constructors: + + :: + + DesktopAppInfoLookupIface() + """ + g_iface: GObject.TypeInterface = ... get_default_for_uri_scheme: Callable[ [DesktopAppInfoLookup, str], Optional[AppInfo] ] = ... class Drive(GObject.GInterface): + """ + Interface GDrive + + Signals from GObject: + notify (GParam) + """ + def can_eject(self) -> bool: ... def can_poll_for_media(self) -> bool: ... def can_start(self) -> bool: ... @@ -2293,7 +3718,9 @@ class Drive(GObject.GInterface): self, flags: MountUnmountFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_finish(self, result: AsyncResult) -> bool: ... @@ -2302,7 +3729,9 @@ class Drive(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_with_operation_finish(self, result: AsyncResult) -> bool: ... @@ -2322,7 +3751,9 @@ class Drive(GObject.GInterface): def poll_for_media( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def poll_for_media_finish(self, result: AsyncResult) -> bool: ... @@ -2331,7 +3762,9 @@ class Drive(GObject.GInterface): flags: DriveStartFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def start_finish(self, result: AsyncResult) -> bool: ... @@ -2340,12 +3773,22 @@ class Drive(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def stop_finish(self, result: AsyncResult) -> bool: ... class DriveIface(GObject.GPointer): + """ + :Constructors: + + :: + + DriveIface() + """ + g_iface: GObject.TypeInterface = ... changed: Callable[[Drive], None] = ... disconnected: Callable[[Drive], None] = ... @@ -2359,28 +3802,102 @@ class DriveIface(GObject.GPointer): is_media_check_automatic: Callable[[Drive], bool] = ... can_eject: Callable[[Drive], bool] = ... can_poll_for_media: Callable[[Drive], bool] = ... - eject: Callable[..., None] = ... + eject: Callable[ + Concatenate[ + Drive, + MountUnmountFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_finish: Callable[[Drive, AsyncResult], bool] = ... - poll_for_media: Callable[..., None] = ... + poll_for_media: Callable[ + Concatenate[ + Drive, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... poll_for_media_finish: Callable[[Drive, AsyncResult], bool] = ... get_identifier: Callable[[Drive, str], Optional[str]] = ... enumerate_identifiers: Callable[[Drive], list[str]] = ... get_start_stop_type: Callable[[Drive], DriveStartStopType] = ... can_start: Callable[[Drive], bool] = ... can_start_degraded: Callable[[Drive], bool] = ... - start: Callable[..., None] = ... + start: Callable[ + Concatenate[ + Drive, + DriveStartFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... start_finish: Callable[[Drive, AsyncResult], bool] = ... can_stop: Callable[[Drive], bool] = ... - stop: Callable[..., None] = ... + stop: Callable[ + Concatenate[ + Drive, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... stop_finish: Callable[[Drive, AsyncResult], bool] = ... stop_button: Callable[[Drive], None] = ... - eject_with_operation: Callable[..., None] = ... + eject_with_operation: Callable[ + Concatenate[ + Drive, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_with_operation_finish: Callable[[Drive, AsyncResult], bool] = ... get_sort_key: Callable[[Drive], Optional[str]] = ... get_symbolic_icon: Callable[[Drive], Icon] = ... is_removable: Callable[[Drive], bool] = ... class DtlsClientConnection(GObject.GInterface): + """ + Interface GDtlsClientConnection + + Signals from GObject: + notify (GParam) + """ + def get_accepted_cas(self) -> list[Sequence[int]]: ... def get_server_identity(self) -> SocketConnectable: ... def get_validation_flags(self) -> TlsCertificateFlags: ... @@ -2392,15 +3909,32 @@ class DtlsClientConnection(GObject.GInterface): def set_validation_flags(self, flags: TlsCertificateFlags) -> None: ... class DtlsClientConnectionInterface(GObject.GPointer): + """ + :Constructors: + + :: + + DtlsClientConnectionInterface() + """ + g_iface: GObject.TypeInterface = ... class DtlsConnection(GObject.GInterface): + """ + Interface GDtlsConnection + + Signals from GObject: + notify (GParam) + """ + def close(self, cancellable: Optional[Cancellable] = None) -> bool: ... def close_async( self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def close_finish(self, result: AsyncResult) -> bool: ... @@ -2425,7 +3959,9 @@ class DtlsConnection(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def handshake_finish(self, result: AsyncResult) -> bool: ... @@ -2449,21 +3985,59 @@ class DtlsConnection(GObject.GInterface): shutdown_write: bool, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def shutdown_finish(self, result: AsyncResult) -> bool: ... class DtlsConnectionInterface(GObject.GPointer): + """ + :Constructors: + + :: + + DtlsConnectionInterface() + """ + g_iface: GObject.TypeInterface = ... accept_certificate: Callable[ [DtlsConnection, TlsCertificate, TlsCertificateFlags], bool ] = ... handshake: Callable[[DtlsConnection, Optional[Cancellable]], bool] = ... - handshake_async: Callable[..., None] = ... + handshake_async: Callable[ + Concatenate[ + DtlsConnection, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... handshake_finish: Callable[[DtlsConnection, AsyncResult], bool] = ... shutdown: Callable[[DtlsConnection, bool, bool, Optional[Cancellable]], bool] = ... - shutdown_async: Callable[..., None] = ... + shutdown_async: Callable[ + Concatenate[ + DtlsConnection, + bool, + bool, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... shutdown_finish: Callable[[DtlsConnection, AsyncResult], bool] = ... set_advertised_protocols: Callable[ [DtlsConnection, Optional[Sequence[str]]], None @@ -2474,15 +4048,51 @@ class DtlsConnectionInterface(GObject.GPointer): ] = ... class DtlsServerConnection(GObject.GInterface): + """ + Interface GDtlsServerConnection + + Signals from GObject: + notify (GParam) + """ + @staticmethod def new( base_socket: DatagramBased, certificate: Optional[TlsCertificate] = None ) -> DtlsServerConnection: ... class DtlsServerConnectionInterface(GObject.GPointer): + """ + :Constructors: + + :: + + DtlsServerConnectionInterface() + """ + g_iface: GObject.TypeInterface = ... class Emblem(GObject.Object, Icon): + """ + :Constructors: + + :: + + Emblem(**properties) + new(icon:Gio.Icon) -> Gio.Emblem + new_with_origin(icon:Gio.Icon, origin:Gio.EmblemOrigin) -> Gio.Emblem + + Object GEmblem + + Properties from GEmblem: + icon -> GObject: The icon of the emblem + The actual icon of the emblem + origin -> GEmblemOrigin: GEmblem’s origin + Tells which origin the emblem is derived from + + Signals from GObject: + notify (GParam) + """ + class Props: icon: GObject.Object origin: EmblemOrigin @@ -2498,6 +4108,24 @@ class Emblem(GObject.Object, Icon): class EmblemClass(GObject.GPointer): ... class EmblemedIcon(GObject.Object, Icon): + """ + :Constructors: + + :: + + EmblemedIcon(**properties) + new(icon:Gio.Icon, emblem:Gio.Emblem=None) -> Gio.EmblemedIcon + + Object GEmblemedIcon + + Properties from GEmblemedIcon: + gicon -> GIcon: The base GIcon + The GIcon to attach emblems to + + Signals from GObject: + notify (GParam) + """ + class Props: gicon: Icon props: Props = ... @@ -2512,11 +4140,26 @@ class EmblemedIcon(GObject.Object, Icon): def new(cls, icon: Icon, emblem: Optional[Emblem] = None) -> EmblemedIcon: ... class EmblemedIconClass(GObject.GPointer): + """ + :Constructors: + + :: + + EmblemedIconClass() + """ + parent_class: GObject.ObjectClass = ... class EmblemedIconPrivate(GObject.GPointer): ... class File(GObject.GInterface): + """ + Interface GFile + + Signals from GObject: + notify (GParam) + """ + def append_to( self, flags: FileCreateFlags, cancellable: Optional[Cancellable] = None ) -> FileOutputStream: ... @@ -2525,7 +4168,9 @@ class File(GObject.GInterface): flags: FileCreateFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def append_to_finish(self, res: AsyncResult) -> FileOutputStream: ... @@ -2537,7 +4182,9 @@ class File(GObject.GInterface): destination: File, flags: FileCopyFlags, cancellable: Optional[Cancellable] = None, - progress_callback: Optional[Callable[..., None]] = None, + progress_callback: Optional[ + Callable[Concatenate[int, int, _VarArgs], None] + ] = None, *progress_callback_data: Any, ) -> bool: ... def copy_async( @@ -2546,8 +4193,13 @@ class File(GObject.GInterface): flags: FileCopyFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - progress_callback: Optional[Callable[..., None]] = None, - callback: Optional[Callable[..., None]] = None, + progress_callback: Optional[ + Callable[Concatenate[int, int, _VarArgs], None] + ] = None, + progress_callback_data: Optional[Any] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def copy_attributes( @@ -2565,7 +4217,9 @@ class File(GObject.GInterface): flags: FileCreateFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def create_finish(self, res: AsyncResult) -> FileOutputStream: ... @@ -2577,7 +4231,9 @@ class File(GObject.GInterface): flags: FileCreateFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def create_readwrite_finish(self, res: AsyncResult) -> FileIOStream: ... @@ -2586,7 +4242,9 @@ class File(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def delete_finish(self, result: AsyncResult) -> bool: ... @@ -2595,7 +4253,9 @@ class File(GObject.GInterface): self, flags: MountUnmountFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_mountable_finish(self, result: AsyncResult) -> bool: ... @@ -2604,7 +4264,9 @@ class File(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_mountable_with_operation_finish(self, result: AsyncResult) -> bool: ... @@ -2620,7 +4282,9 @@ class File(GObject.GInterface): flags: FileQueryInfoFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def enumerate_children_finish(self, res: AsyncResult) -> FileEnumerator: ... @@ -2632,7 +4296,9 @@ class File(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def find_enclosing_mount_finish(self, res: AsyncResult) -> Mount: ... @@ -2656,7 +4322,9 @@ class File(GObject.GInterface): def load_bytes_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def load_bytes_finish(self, result: AsyncResult) -> Tuple[GLib.Bytes, str]: ... @@ -2666,7 +4334,9 @@ class File(GObject.GInterface): def load_contents_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def load_contents_finish(self, res: AsyncResult) -> Tuple[bool, bytes, str]: ... @@ -2678,7 +4348,9 @@ class File(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def make_directory_finish(self, result: AsyncResult) -> bool: ... @@ -2693,7 +4365,9 @@ class File(GObject.GInterface): symlink_value: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def make_symbolic_link_finish(self, result: AsyncResult) -> bool: ... @@ -2714,7 +4388,9 @@ class File(GObject.GInterface): flags: MountMountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def mount_enclosing_volume_finish(self, result: AsyncResult) -> bool: ... @@ -2723,7 +4399,9 @@ class File(GObject.GInterface): flags: MountMountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def mount_mountable_finish(self, result: AsyncResult) -> File: ... @@ -2732,7 +4410,9 @@ class File(GObject.GInterface): destination: File, flags: FileCopyFlags, cancellable: Optional[Cancellable] = None, - progress_callback: Optional[Callable[..., None]] = None, + progress_callback: Optional[ + Callable[Concatenate[int, int, _VarArgs], None] + ] = None, *progress_callback_data: Any, ) -> bool: ... def move_async( @@ -2741,8 +4421,13 @@ class File(GObject.GInterface): flags: FileCopyFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - progress_callback: Optional[Callable[..., None]] = None, - callback: Optional[Callable[..., None]] = None, + progress_callback: Optional[ + Callable[Concatenate[int, int, _VarArgs], None] + ] = None, + progress_callback_data: Optional[Any] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def move_finish(self, result: AsyncResult) -> bool: ... @@ -2761,7 +4446,9 @@ class File(GObject.GInterface): tmpl: Optional[str], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @staticmethod @@ -2769,7 +4456,9 @@ class File(GObject.GInterface): tmpl: Optional[str], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @staticmethod @@ -2783,7 +4472,9 @@ class File(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def open_readwrite_finish(self, res: AsyncResult) -> FileIOStream: ... @@ -2793,7 +4484,9 @@ class File(GObject.GInterface): def poll_mountable( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def poll_mountable_finish(self, result: AsyncResult) -> bool: ... @@ -2804,7 +4497,9 @@ class File(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def query_default_handler_finish(self, result: AsyncResult) -> AppInfo: ... @@ -2820,7 +4515,9 @@ class File(GObject.GInterface): attributes: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def query_filesystem_info_finish(self, res: AsyncResult) -> FileInfo: ... @@ -2836,7 +4533,9 @@ class File(GObject.GInterface): flags: FileQueryInfoFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def query_info_finish(self, res: AsyncResult) -> FileInfo: ... @@ -2851,7 +4550,9 @@ class File(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def read_finish(self, res: AsyncResult) -> FileInputStream: ... @@ -2869,7 +4570,9 @@ class File(GObject.GInterface): flags: FileCreateFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def replace_contents( @@ -2887,7 +4590,9 @@ class File(GObject.GInterface): make_backup: bool, flags: FileCreateFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def replace_contents_bytes_async( @@ -2897,7 +4602,9 @@ class File(GObject.GInterface): make_backup: bool, flags: FileCreateFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def replace_contents_finish(self, res: AsyncResult) -> Tuple[bool, str]: ... @@ -2916,7 +4623,9 @@ class File(GObject.GInterface): flags: FileCreateFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def replace_readwrite_finish(self, res: AsyncResult) -> FileIOStream: ... @@ -2925,7 +4634,7 @@ class File(GObject.GInterface): self, attribute: str, type: FileAttributeType, - value_p: None, + value_p: Optional[Any], flags: FileQueryInfoFlags, cancellable: Optional[Cancellable] = None, ) -> bool: ... @@ -2977,7 +4686,9 @@ class File(GObject.GInterface): flags: FileQueryInfoFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def set_attributes_finish(self, result: AsyncResult) -> Tuple[bool, FileInfo]: ... @@ -2995,7 +4706,9 @@ class File(GObject.GInterface): display_name: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def set_display_name_finish(self, res: AsyncResult) -> File: ... @@ -3004,7 +4717,9 @@ class File(GObject.GInterface): flags: DriveStartFlags, start_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def start_mountable_finish(self, result: AsyncResult) -> bool: ... @@ -3013,7 +4728,9 @@ class File(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def stop_mountable_finish(self, result: AsyncResult) -> bool: ... @@ -3023,7 +4740,9 @@ class File(GObject.GInterface): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def trash_finish(self, result: AsyncResult) -> bool: ... @@ -3031,7 +4750,9 @@ class File(GObject.GInterface): self, flags: MountUnmountFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def unmount_mountable_finish(self, result: AsyncResult) -> bool: ... @@ -3040,17 +4761,36 @@ class File(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def unmount_mountable_with_operation_finish(self, result: AsyncResult) -> bool: ... class FileAttributeInfo(GObject.GPointer): + """ + :Constructors: + + :: + + FileAttributeInfo() + """ + name: str = ... type: FileAttributeType = ... flags: FileAttributeInfoFlags = ... class FileAttributeInfoList(GObject.GBoxed): + """ + :Constructors: + + :: + + FileAttributeInfoList() + new() -> Gio.FileAttributeInfoList + """ + infos: FileAttributeInfo = ... n_infos: int = ... def add( @@ -3064,6 +4804,14 @@ class FileAttributeInfoList(GObject.GBoxed): def unref(self) -> None: ... class FileAttributeMatcher(GObject.GBoxed): + """ + :Constructors: + + :: + + new(attributes:str) -> Gio.FileAttributeMatcher + """ + def enumerate_namespace(self, ns: str) -> bool: ... def enumerate_next(self) -> Optional[str]: ... def matches(self, attribute: str) -> bool: ... @@ -3078,13 +4826,45 @@ class FileAttributeMatcher(GObject.GBoxed): def unref(self) -> None: ... class FileDescriptorBased(GObject.GInterface): + """ + Interface GFileDescriptorBased + + Signals from GObject: + notify (GParam) + """ + def get_fd(self) -> int: ... class FileDescriptorBasedIface(GObject.GPointer): + """ + :Constructors: + + :: + + FileDescriptorBasedIface() + """ + g_iface: GObject.TypeInterface = ... get_fd: Callable[[FileDescriptorBased], int] = ... class FileEnumerator(GObject.Object): + """ + :Constructors: + + :: + + FileEnumerator(**properties) + + Object GFileEnumerator + + Properties from GFileEnumerator: + container -> GFile: Container + The container that is being enumerated + + Signals from GObject: + notify (GParam) + """ + class Props: container: File props: Props = ... @@ -3096,7 +4876,9 @@ class FileEnumerator(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def close_finish(self, result: AsyncResult) -> bool: ... @@ -3104,7 +4886,9 @@ class FileEnumerator(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_close_finish(self, result: AsyncResult) -> bool: ... @@ -3117,7 +4901,9 @@ class FileEnumerator(GObject.Object): num_files: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_next_files_finish(self, result: AsyncResult) -> list[FileInfo]: ... @@ -3137,36 +4923,94 @@ class FileEnumerator(GObject.Object): num_files: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def next_files_finish(self, result: AsyncResult) -> list[FileInfo]: ... def set_pending(self, pending: bool) -> None: ... class FileEnumeratorClass(GObject.GPointer): + """ + :Constructors: + + :: + + FileEnumeratorClass() + """ + parent_class: GObject.ObjectClass = ... next_file: Callable[ [FileEnumerator, Optional[Cancellable]], Optional[FileInfo] ] = ... close_fn: Callable[[FileEnumerator, Optional[Cancellable]], bool] = ... - next_files_async: Callable[..., None] = ... + next_files_async: Callable[ + Concatenate[ + FileEnumerator, + int, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... next_files_finish: Callable[[FileEnumerator, AsyncResult], list[FileInfo]] = ... - close_async: Callable[..., None] = ... + close_async: Callable[ + Concatenate[ + FileEnumerator, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... close_finish: Callable[[FileEnumerator, AsyncResult], bool] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... - _g_reserved7: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... + _g_reserved7: Any = ... class FileEnumeratorPrivate(GObject.GPointer): ... class FileIOStream(IOStream, Seekable): - class Props: - closed: bool - input_stream: InputStream + """ + :Constructors: + + :: + + FileIOStream(**properties) + + Object GFileIOStream + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + + class Props: + closed: bool + input_stream: InputStream output_stream: OutputStream props: Props = ... parent_instance: IOStream = ... @@ -3182,7 +5026,9 @@ class FileIOStream(IOStream, Seekable): attributes: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_query_info_finish(self, result: AsyncResult) -> FileInfo: ... @@ -3205,12 +5051,22 @@ class FileIOStream(IOStream, Seekable): attributes: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def query_info_finish(self, result: AsyncResult) -> FileInfo: ... class FileIOStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + FileIOStreamClass() + """ + parent_class: IOStreamClass = ... tell: Callable[[FileIOStream], int] = ... can_seek: Callable[[FileIOStream], bool] = ... @@ -3220,18 +5076,50 @@ class FileIOStreamClass(GObject.GPointer): can_truncate: Callable[[FileIOStream], bool] = ... truncate_fn: Callable[[FileIOStream, int, Optional[Cancellable]], bool] = ... query_info: Callable[[FileIOStream, str, Optional[Cancellable]], FileInfo] = ... - query_info_async: Callable[..., None] = ... + query_info_async: Callable[ + Concatenate[ + FileIOStream, + str, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... query_info_finish: Callable[[FileIOStream, AsyncResult], FileInfo] = ... get_etag: Callable[[FileIOStream], Optional[str]] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class FileIOStreamPrivate(GObject.GPointer): ... class FileIcon(GObject.Object, Icon, LoadableIcon): + """ + :Constructors: + + :: + + FileIcon(**properties) + new(file:Gio.File) -> Gio.FileIcon + + Object GFileIcon + + Properties from GFileIcon: + file -> GFile: file + The file containing the icon + + Signals from GObject: + notify (GParam) + """ + class Props: file: File props: Props = ... @@ -3243,6 +5131,14 @@ class FileIcon(GObject.Object, Icon, LoadableIcon): class FileIconClass(GObject.GPointer): ... class FileIface(GObject.GPointer): + """ + :Constructors: + + :: + + FileIface() + """ + g_iface: GObject.TypeInterface = ... dup: Callable[[File], File] = ... hash: Callable[[File], int] = ... @@ -3262,85 +5158,396 @@ class FileIface(GObject.GPointer): enumerate_children: Callable[ [File, str, FileQueryInfoFlags, Optional[Cancellable]], FileEnumerator ] = ... - enumerate_children_async: Callable[..., None] = ... + enumerate_children_async: Callable[ + Concatenate[ + File, + str, + FileQueryInfoFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... enumerate_children_finish: Callable[[File, AsyncResult], FileEnumerator] = ... query_info: Callable[ [File, str, FileQueryInfoFlags, Optional[Cancellable]], FileInfo ] = ... - query_info_async: Callable[..., None] = ... + query_info_async: Callable[ + Concatenate[ + File, + str, + FileQueryInfoFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... query_info_finish: Callable[[File, AsyncResult], FileInfo] = ... query_filesystem_info: Callable[[File, str, Optional[Cancellable]], FileInfo] = ... - query_filesystem_info_async: Callable[..., None] = ... + query_filesystem_info_async: Callable[ + Concatenate[ + File, + str, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... query_filesystem_info_finish: Callable[[File, AsyncResult], FileInfo] = ... find_enclosing_mount: Callable[[File, Optional[Cancellable]], Mount] = ... - find_enclosing_mount_async: Callable[..., None] = ... + find_enclosing_mount_async: Callable[ + Concatenate[ + File, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... find_enclosing_mount_finish: Callable[[File, AsyncResult], Mount] = ... set_display_name: Callable[[File, str, Optional[Cancellable]], File] = ... - set_display_name_async: Callable[..., None] = ... + set_display_name_async: Callable[ + Concatenate[ + File, + str, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... set_display_name_finish: Callable[[File, AsyncResult], File] = ... query_settable_attributes: Callable[ [File, Optional[Cancellable]], FileAttributeInfoList ] = ... - _query_settable_attributes_async: None = ... - _query_settable_attributes_finish: None = ... + _query_settable_attributes_async: Any = ... + _query_settable_attributes_finish: Any = ... query_writable_namespaces: Callable[ [File, Optional[Cancellable]], FileAttributeInfoList ] = ... - _query_writable_namespaces_async: None = ... - _query_writable_namespaces_finish: None = ... + _query_writable_namespaces_async: Any = ... + _query_writable_namespaces_finish: Any = ... set_attribute: Callable[ - [File, str, FileAttributeType, None, FileQueryInfoFlags, Optional[Cancellable]], + [ + File, + str, + FileAttributeType, + Optional[Any], + FileQueryInfoFlags, + Optional[Cancellable], + ], bool, ] = ... set_attributes_from_info: Callable[ [File, FileInfo, FileQueryInfoFlags, Optional[Cancellable]], bool ] = ... - set_attributes_async: Callable[..., None] = ... + set_attributes_async: Callable[ + Concatenate[ + File, + FileInfo, + FileQueryInfoFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... set_attributes_finish: Callable[[File, AsyncResult], Tuple[bool, FileInfo]] = ... read_fn: Callable[[File, Optional[Cancellable]], FileInputStream] = ... - read_async: Callable[..., None] = ... + read_async: Callable[ + Concatenate[ + File, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... read_finish: Callable[[File, AsyncResult], FileInputStream] = ... append_to: Callable[ [File, FileCreateFlags, Optional[Cancellable]], FileOutputStream ] = ... - append_to_async: Callable[..., None] = ... + append_to_async: Callable[ + Concatenate[ + File, + FileCreateFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... append_to_finish: Callable[[File, AsyncResult], FileOutputStream] = ... create: Callable[ [File, FileCreateFlags, Optional[Cancellable]], FileOutputStream ] = ... - create_async: Callable[..., None] = ... + create_async: Callable[ + Concatenate[ + File, + FileCreateFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... create_finish: Callable[[File, AsyncResult], FileOutputStream] = ... replace: Callable[ [File, Optional[str], bool, FileCreateFlags, Optional[Cancellable]], FileOutputStream, ] = ... - replace_async: Callable[..., None] = ... + replace_async: Callable[ + Concatenate[ + File, + Optional[str], + bool, + FileCreateFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... replace_finish: Callable[[File, AsyncResult], FileOutputStream] = ... delete_file: Callable[[File, Optional[Cancellable]], bool] = ... - delete_file_async: Callable[..., None] = ... + delete_file_async: Callable[ + Concatenate[ + File, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... delete_file_finish: Callable[[File, AsyncResult], bool] = ... trash: Callable[[File, Optional[Cancellable]], bool] = ... - trash_async: Callable[..., None] = ... + trash_async: Callable[ + Concatenate[ + File, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... trash_finish: Callable[[File, AsyncResult], bool] = ... make_directory: Callable[[File, Optional[Cancellable]], bool] = ... - make_directory_async: Callable[..., None] = ... + make_directory_async: Callable[ + Concatenate[ + File, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... make_directory_finish: Callable[[File, AsyncResult], bool] = ... make_symbolic_link: Callable[[File, str, Optional[Cancellable]], bool] = ... - make_symbolic_link_async: Callable[..., None] = ... + make_symbolic_link_async: Callable[ + Concatenate[ + File, + str, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... make_symbolic_link_finish: Callable[[File, AsyncResult], bool] = ... - copy: Callable[..., bool] = ... - copy_async: Callable[..., None] = ... + copy: Callable[ + Concatenate[ + File, + File, + FileCopyFlags, + Optional[Cancellable], + Optional[Callable[Concatenate[int, int, _VarArgs], None]], + _VarArgs, + ], + bool, + ] = ... + copy_async: Callable[ + Concatenate[ + File, + File, + FileCopyFlags, + int, + Optional[Cancellable], + Optional[Callable[Concatenate[int, int, _VarArgs], None]], + Optional[Any], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... copy_finish: Callable[[File, AsyncResult], bool] = ... - move: Callable[..., bool] = ... - move_async: Callable[..., None] = ... + move: Callable[ + Concatenate[ + File, + File, + FileCopyFlags, + Optional[Cancellable], + Optional[Callable[Concatenate[int, int, _VarArgs], None]], + _VarArgs, + ], + bool, + ] = ... + move_async: Callable[ + Concatenate[ + File, + File, + FileCopyFlags, + int, + Optional[Cancellable], + Optional[Callable[Concatenate[int, int, _VarArgs], None]], + Optional[Any], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... move_finish: Callable[[File, AsyncResult], bool] = ... - mount_mountable: Callable[..., None] = ... + mount_mountable: Callable[ + Concatenate[ + File, + MountMountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... mount_mountable_finish: Callable[[File, AsyncResult], File] = ... - unmount_mountable: Callable[..., None] = ... + unmount_mountable: Callable[ + Concatenate[ + File, + MountUnmountFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... unmount_mountable_finish: Callable[[File, AsyncResult], bool] = ... - eject_mountable: Callable[..., None] = ... + eject_mountable: Callable[ + Concatenate[ + File, + MountUnmountFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_mountable_finish: Callable[[File, AsyncResult], bool] = ... - mount_enclosing_volume: Callable[..., None] = ... + mount_enclosing_volume: Callable[ + Concatenate[ + File, + MountMountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... mount_enclosing_volume_finish: Callable[[File, AsyncResult], bool] = ... monitor_dir: Callable[ [File, FileMonitorFlags, Optional[Cancellable]], FileMonitor @@ -3349,37 +5556,162 @@ class FileIface(GObject.GPointer): [File, FileMonitorFlags, Optional[Cancellable]], FileMonitor ] = ... open_readwrite: Callable[[File, Optional[Cancellable]], FileIOStream] = ... - open_readwrite_async: Callable[..., None] = ... + open_readwrite_async: Callable[ + Concatenate[ + File, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... open_readwrite_finish: Callable[[File, AsyncResult], FileIOStream] = ... create_readwrite: Callable[ [File, FileCreateFlags, Optional[Cancellable]], FileIOStream ] = ... - create_readwrite_async: Callable[..., None] = ... + create_readwrite_async: Callable[ + Concatenate[ + File, + FileCreateFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... create_readwrite_finish: Callable[[File, AsyncResult], FileIOStream] = ... replace_readwrite: Callable[ [File, Optional[str], bool, FileCreateFlags, Optional[Cancellable]], FileIOStream, ] = ... - replace_readwrite_async: Callable[..., None] = ... + replace_readwrite_async: Callable[ + Concatenate[ + File, + Optional[str], + bool, + FileCreateFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... replace_readwrite_finish: Callable[[File, AsyncResult], FileIOStream] = ... - start_mountable: Callable[..., None] = ... + start_mountable: Callable[ + Concatenate[ + File, + DriveStartFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... start_mountable_finish: Callable[[File, AsyncResult], bool] = ... - stop_mountable: Callable[..., None] = ... + stop_mountable: Callable[ + Concatenate[ + File, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... stop_mountable_finish: Callable[[File, AsyncResult], bool] = ... supports_thread_contexts: bool = ... - unmount_mountable_with_operation: Callable[..., None] = ... + unmount_mountable_with_operation: Callable[ + Concatenate[ + File, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... unmount_mountable_with_operation_finish: Callable[[File, AsyncResult], bool] = ... - eject_mountable_with_operation: Callable[..., None] = ... + eject_mountable_with_operation: Callable[ + Concatenate[ + File, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_mountable_with_operation_finish: Callable[[File, AsyncResult], bool] = ... - poll_mountable: Callable[..., None] = ... + poll_mountable: Callable[ + Concatenate[ + File, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... poll_mountable_finish: Callable[[File, AsyncResult], bool] = ... - measure_disk_usage: None = ... - measure_disk_usage_async: None = ... + measure_disk_usage: Any = ... + measure_disk_usage_async: Any = ... measure_disk_usage_finish: Callable[ [File, AsyncResult], Tuple[bool, int, int, int] ] = ... class FileInfo(GObject.Object): + """ + :Constructors: + + :: + + FileInfo(**properties) + new() -> Gio.FileInfo + + Object GFileInfo + + Signals from GObject: + notify (GParam) + """ + def clear_status(self) -> None: ... def copy_into(self, dest_info: FileInfo) -> None: ... def dup(self) -> FileInfo: ... @@ -3389,7 +5721,7 @@ class FileInfo(GObject.Object): def get_attribute_byte_string(self, attribute: str) -> Optional[str]: ... def get_attribute_data( self, attribute: str - ) -> Tuple[bool, FileAttributeType, None, FileAttributeStatus]: ... + ) -> Tuple[bool, FileAttributeType, Any, FileAttributeStatus]: ... def get_attribute_int32(self, attribute: str) -> int: ... def get_attribute_int64(self, attribute: str) -> int: ... def get_attribute_object(self, attribute: str) -> Optional[GObject.Object]: ... @@ -3427,7 +5759,7 @@ class FileInfo(GObject.Object): def remove_attribute(self, attribute: str) -> None: ... def set_access_date_time(self, atime: GLib.DateTime) -> None: ... def set_attribute( - self, attribute: str, type: FileAttributeType, value_p: None + self, attribute: str, type: FileAttributeType, value_p: Any ) -> None: ... def set_attribute_boolean(self, attribute: str, attr_value: bool) -> None: ... def set_attribute_byte_string(self, attribute: str, attr_value: str) -> None: ... @@ -3466,6 +5798,19 @@ class FileInfo(GObject.Object): class FileInfoClass(GObject.GPointer): ... class FileInputStream(InputStream, Seekable): + """ + :Constructors: + + :: + + FileInputStream(**properties) + + Object GFileInputStream + + Signals from GObject: + notify (GParam) + """ + parent_instance: InputStream = ... priv: FileInputStreamPrivate = ... def do_can_seek(self) -> bool: ... @@ -3477,7 +5822,9 @@ class FileInputStream(InputStream, Seekable): attributes: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_query_info_finish(self, result: AsyncResult) -> FileInfo: ... @@ -3496,12 +5843,22 @@ class FileInputStream(InputStream, Seekable): attributes: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def query_info_finish(self, result: AsyncResult) -> FileInfo: ... class FileInputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + FileInputStreamClass() + """ + parent_class: InputStreamClass = ... tell: Callable[[FileInputStream], int] = ... can_seek: Callable[[FileInputStream], bool] = ... @@ -3509,17 +5866,53 @@ class FileInputStreamClass(GObject.GPointer): [FileInputStream, int, GLib.SeekType, Optional[Cancellable]], bool ] = ... query_info: Callable[[FileInputStream, str, Optional[Cancellable]], FileInfo] = ... - query_info_async: Callable[..., None] = ... + query_info_async: Callable[ + Concatenate[ + FileInputStream, + str, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... query_info_finish: Callable[[FileInputStream, AsyncResult], FileInfo] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class FileInputStreamPrivate(GObject.GPointer): ... class FileMonitor(GObject.Object): + """ + :Constructors: + + :: + + FileMonitor(**properties) + + Object GFileMonitor + + Signals from GFileMonitor: + changed (GFile, GFile, GFileMonitorEvent) + + Properties from GFileMonitor: + rate-limit -> gint: Rate limit + The limit of the monitor to watch for changes, in milliseconds + cancelled -> gboolean: Cancelled + Whether the monitor has been cancelled + + Signals from GObject: + notify (GParam) + """ + class Props: cancelled: bool rate_limit: int @@ -3539,18 +5932,39 @@ class FileMonitor(GObject.Object): def set_rate_limit(self, limit_msecs: int) -> None: ... class FileMonitorClass(GObject.GPointer): + """ + :Constructors: + + :: + + FileMonitorClass() + """ + parent_class: GObject.ObjectClass = ... changed: Callable[[FileMonitor, File, File, FileMonitorEvent], None] = ... cancel: Callable[[FileMonitor], bool] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class FileMonitorPrivate(GObject.GPointer): ... class FileOutputStream(OutputStream, Seekable): + """ + :Constructors: + + :: + + FileOutputStream(**properties) + + Object GFileOutputStream + + Signals from GObject: + notify (GParam) + """ + parent_instance: OutputStream = ... priv: FileOutputStreamPrivate = ... def do_can_seek(self) -> bool: ... @@ -3564,7 +5978,9 @@ class FileOutputStream(OutputStream, Seekable): attributes: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_query_info_finish(self, result: AsyncResult) -> FileInfo: ... @@ -3587,12 +6003,22 @@ class FileOutputStream(OutputStream, Seekable): attributes: str, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def query_info_finish(self, result: AsyncResult) -> FileInfo: ... class FileOutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + FileOutputStreamClass() + """ + parent_class: OutputStreamClass = ... tell: Callable[[FileOutputStream], int] = ... can_seek: Callable[[FileOutputStream], bool] = ... @@ -3602,18 +6028,49 @@ class FileOutputStreamClass(GObject.GPointer): can_truncate: Callable[[FileOutputStream], bool] = ... truncate_fn: Callable[[FileOutputStream, int, Optional[Cancellable]], bool] = ... query_info: Callable[[FileOutputStream, str, Optional[Cancellable]], FileInfo] = ... - query_info_async: Callable[..., None] = ... + query_info_async: Callable[ + Concatenate[ + FileOutputStream, + str, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... query_info_finish: Callable[[FileOutputStream, AsyncResult], FileInfo] = ... get_etag: Callable[[FileOutputStream], Optional[str]] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class FileOutputStreamPrivate(GObject.GPointer): ... class FilenameCompleter(GObject.Object): + """ + :Constructors: + + :: + + FilenameCompleter(**properties) + new() -> Gio.FilenameCompleter + + Object GFilenameCompleter + + Signals from GFilenameCompleter: + got-completion-data () + + Signals from GObject: + notify (GParam) + """ + def do_got_completion_data(self) -> None: ... def get_completion_suffix(self, initial_text: str) -> Optional[str]: ... def get_completions(self, initial_text: str) -> list[str]: ... @@ -3622,13 +6079,40 @@ class FilenameCompleter(GObject.Object): def set_dirs_only(self, dirs_only: bool) -> None: ... class FilenameCompleterClass(GObject.GPointer): + """ + :Constructors: + + :: + + FilenameCompleterClass() + """ + parent_class: GObject.ObjectClass = ... got_completion_data: Callable[[FilenameCompleter], None] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... class FilterInputStream(InputStream): + """ + :Constructors: + + :: + + FilterInputStream(**properties) + + Object GFilterInputStream + + Properties from GFilterInputStream: + base-stream -> GInputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: base_stream: InputStream close_base_stream: bool @@ -3643,12 +6127,39 @@ class FilterInputStream(InputStream): def set_close_base_stream(self, close_base: bool) -> None: ... class FilterInputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + FilterInputStreamClass() + """ + parent_class: InputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... class FilterOutputStream(OutputStream): + """ + :Constructors: + + :: + + FilterOutputStream(**properties) + + Object GFilterOutputStream + + Properties from GFilterOutputStream: + base-stream -> GOutputStream: The Filter Base Stream + The underlying base stream on which the io ops will be done. + close-base-stream -> gboolean: Close Base Stream + If the base stream should be closed when the filter stream is closed. + + Signals from GObject: + notify (GParam) + """ + class Props: base_stream: OutputStream close_base_stream: bool @@ -3663,10 +6174,18 @@ class FilterOutputStream(OutputStream): def set_close_base_stream(self, close_base: bool) -> None: ... class FilterOutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + FilterOutputStreamClass() + """ + parent_class: OutputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... class IOExtension(GObject.GPointer): def get_name(self) -> str: ... @@ -3688,6 +6207,20 @@ class IOExtensionPoint(GObject.GPointer): def set_required_type(self, type: Type) -> None: ... class IOModule(GObject.TypeModule, GObject.TypePlugin): + """ + :Constructors: + + :: + + IOModule(**properties) + new(filename:str) -> Gio.IOModule + + Object GIOModule + + Signals from GObject: + notify (GParam) + """ + @classmethod def new(cls, filename: str) -> IOModule: ... @staticmethod @@ -3700,12 +6233,35 @@ class IOModuleScope(GObject.GPointer): def free(self) -> None: ... class IOSchedulerJob(GObject.GPointer): - def send_to_mainloop(self, func: Callable[..., bool], *user_data: Any) -> bool: ... + def send_to_mainloop( + self, func: Callable[Concatenate[_VarArgs], bool], *user_data: Any + ) -> bool: ... def send_to_mainloop_async( - self, func: Callable[..., bool], *user_data: Any + self, func: Callable[Concatenate[_VarArgs], bool], *user_data: Any ) -> None: ... class IOStream(GObject.Object): + """ + :Constructors: + + :: + + IOStream(**properties) + + Object GIOStream + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + class Props: closed: bool input_stream: InputStream @@ -3719,7 +6275,9 @@ class IOStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def close_finish(self, result: AsyncResult) -> bool: ... @@ -3727,7 +6285,9 @@ class IOStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_close_finish(self, result: AsyncResult) -> bool: ... @@ -3745,7 +6305,9 @@ class IOStream(GObject.Object): flags: IOStreamSpliceFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... @staticmethod @@ -3754,47 +6316,125 @@ class IOStream(GObject.Object): class IOStreamAdapter(GObject.GPointer): ... class IOStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + IOStreamClass() + """ + parent_class: GObject.ObjectClass = ... get_input_stream: Callable[[IOStream], InputStream] = ... get_output_stream: Callable[[IOStream], OutputStream] = ... close_fn: Callable[[IOStream, Optional[Cancellable]], bool] = ... - close_async: Callable[..., None] = ... + close_async: Callable[ + Concatenate[ + IOStream, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... close_finish: Callable[[IOStream, AsyncResult], bool] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... - _g_reserved7: None = ... - _g_reserved8: None = ... - _g_reserved9: None = ... - _g_reserved10: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... + _g_reserved7: Any = ... + _g_reserved8: Any = ... + _g_reserved9: Any = ... + _g_reserved10: Any = ... class IOStreamPrivate(GObject.GPointer): ... class Icon(GObject.GInterface): + """ + Interface GIcon + + Signals from GObject: + notify (GParam) + """ + @staticmethod def deserialize(value: GLib.Variant) -> Optional[Icon]: ... def equal(self, icon2: Optional[Icon] = None) -> bool: ... - @staticmethod - def hash(icon: None) -> int: ... + def hash(self) -> int: ... @staticmethod def new_for_string(str: str) -> Icon: ... def serialize(self) -> Optional[GLib.Variant]: ... def to_string(self) -> Optional[str]: ... class IconIface(GObject.GPointer): + """ + :Constructors: + + :: + + IconIface() + """ + g_iface: GObject.TypeInterface = ... hash: Callable[[Icon], int] = ... equal: Callable[[Optional[Icon], Optional[Icon]], bool] = ... - to_tokens: None = ... - from_tokens: None = ... + to_tokens: Callable[[Icon], Tuple[bool, list[str], int]] = ... + from_tokens: Any = ... serialize: Callable[[Icon], Optional[GLib.Variant]] = ... class InetAddress(GObject.Object): + """ + :Constructors: + + :: + + InetAddress(**properties) + new_any(family:Gio.SocketFamily) -> Gio.InetAddress + new_from_bytes(bytes:list, family:Gio.SocketFamily) -> Gio.InetAddress + new_from_string(string:str) -> Gio.InetAddress or None + new_loopback(family:Gio.SocketFamily) -> Gio.InetAddress + + Object GInetAddress + + Properties from GInetAddress: + family -> GSocketFamily: Address family + The address family (IPv4 or IPv6) + bytes -> gpointer: Bytes + The raw address data + is-any -> gboolean: Is any + Whether this is the "any" address for its family + is-loopback -> gboolean: Is loopback + Whether this is the loopback address for its family + is-link-local -> gboolean: Is link-local + Whether this is a link-local address + is-site-local -> gboolean: Is site-local + Whether this is a site-local address + is-multicast -> gboolean: Is multicast + Whether this is a multicast address + is-mc-global -> gboolean: Is multicast global + Whether this is a global multicast address + is-mc-link-local -> gboolean: Is multicast link-local + Whether this is a link-local multicast address + is-mc-node-local -> gboolean: Is multicast node-local + Whether this is a node-local multicast address + is-mc-org-local -> gboolean: Is multicast org-local + Whether this is an organization-local multicast address + is-mc-site-local -> gboolean: Is multicast site-local + Whether this is a site-local multicast address + + Signals from GObject: + notify (GParam) + """ + class Props: - bytes: None + bytes: Any family: SocketFamily is_any: bool is_link_local: bool @@ -3809,7 +6449,7 @@ class InetAddress(GObject.Object): props: Props = ... parent_instance: GObject.Object = ... priv: InetAddressPrivate = ... - def __init__(self, bytes: None = ..., family: SocketFamily = ...): ... + def __init__(self, bytes: Any = ..., family: SocketFamily = ...): ... def do_to_string(self) -> str: ... def equal(self, other_address: InetAddress) -> bool: ... def get_family(self) -> SocketFamily: ... @@ -3837,11 +6477,42 @@ class InetAddress(GObject.Object): def to_string(self) -> str: ... class InetAddressClass(GObject.GPointer): + """ + :Constructors: + + :: + + InetAddressClass() + """ + parent_class: GObject.ObjectClass = ... to_string: Callable[[InetAddress], str] = ... to_bytes: Callable[[InetAddress], int] = ... class InetAddressMask(GObject.Object, Initable): + """ + :Constructors: + + :: + + InetAddressMask(**properties) + new(addr:Gio.InetAddress, length:int) -> Gio.InetAddressMask + new_from_string(mask_string:str) -> Gio.InetAddressMask + + Object GInetAddressMask + + Properties from GInetAddressMask: + family -> GSocketFamily: Address family + The address family (IPv4 or IPv6) + address -> GInetAddress: Address + The base address + length -> guint: Length + The prefix length + + Signals from GObject: + notify (GParam) + """ + class Props: address: InetAddress family: SocketFamily @@ -3862,12 +6533,49 @@ class InetAddressMask(GObject.Object, Initable): def to_string(self) -> str: ... class InetAddressMaskClass(GObject.GPointer): + """ + :Constructors: + + :: + + InetAddressMaskClass() + """ + parent_class: GObject.ObjectClass = ... class InetAddressMaskPrivate(GObject.GPointer): ... class InetAddressPrivate(GObject.GPointer): ... class InetSocketAddress(SocketAddress, SocketConnectable): + """ + :Constructors: + + :: + + InetSocketAddress(**properties) + new(address:Gio.InetAddress, port:int) -> Gio.SocketAddress + new_from_string(address:str, port:int) -> Gio.SocketAddress or None + + Object GInetSocketAddress + + Properties from GInetSocketAddress: + address -> GInetAddress: Address + The address + port -> guint: Port + The port + flowinfo -> guint: Flow info + IPv6 flow info + scope-id -> guint: Scope ID + IPv6 scope ID + + Properties from GSocketAddress: + family -> GSocketFamily: Address family + The family of the socket address + + Signals from GObject: + notify (GParam) + """ + class Props: address: InetAddress flowinfo: int @@ -3894,25 +6602,55 @@ class InetSocketAddress(SocketAddress, SocketConnectable): def new_from_string(cls, address: str, port: int) -> InetSocketAddress: ... class InetSocketAddressClass(GObject.GPointer): + """ + :Constructors: + + :: + + InetSocketAddressClass() + """ + parent_class: SocketAddressClass = ... class InetSocketAddressPrivate(GObject.GPointer): ... class Initable(GObject.GInterface): + """ + Interface GInitable + + Signals from GObject: + notify (GParam) + """ + def init(self, cancellable: Optional[Cancellable] = None) -> bool: ... @staticmethod def newv( object_type: Type, - n_parameters: int, parameters: Sequence[GObject.Parameter], cancellable: Optional[Cancellable] = None, ) -> GObject.Object: ... class InitableIface(GObject.GPointer): + """ + :Constructors: + + :: + + InitableIface() + """ + g_iface: GObject.TypeInterface = ... init: Callable[[Initable, Optional[Cancellable]], bool] = ... class InputMessage(GObject.GPointer): + """ + :Constructors: + + :: + + InputMessage() + """ + address: SocketAddress = ... vectors: list[InputVector] = ... num_vectors: int = ... @@ -3922,6 +6660,19 @@ class InputMessage(GObject.GPointer): num_control_messages: int = ... class InputStream(GObject.Object): + """ + :Constructors: + + :: + + InputStream(**properties) + + Object GInputStream + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: InputStreamPrivate = ... def clear_pending(self) -> None: ... @@ -3930,7 +6681,9 @@ class InputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def close_finish(self, result: AsyncResult) -> bool: ... @@ -3938,7 +6691,9 @@ class InputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_close_finish(self, result: AsyncResult) -> bool: ... @@ -3947,12 +6702,17 @@ class InputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> bytes: ... def do_read_finish(self, result: AsyncResult) -> int: ... def do_read_fn( - self, buffer: None, count: int, cancellable: Optional[Cancellable] = None + self, + buffer: Optional[Any], + count: int, + cancellable: Optional[Cancellable] = None, ) -> int: ... def do_skip(self, count: int, cancellable: Optional[Cancellable] = None) -> int: ... def do_skip_async( @@ -3960,7 +6720,9 @@ class InputStream(GObject.Object): count: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_skip_finish(self, result: AsyncResult) -> int: ... @@ -3974,7 +6736,9 @@ class InputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> bytes: ... def read_all_finish(self, result: AsyncResult) -> Tuple[bool, int]: ... @@ -3982,7 +6746,9 @@ class InputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> bytes: ... def read_bytes( @@ -3993,7 +6759,9 @@ class InputStream(GObject.Object): count: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def read_bytes_finish(self, result: AsyncResult) -> GLib.Bytes: ... @@ -4005,47 +6773,145 @@ class InputStream(GObject.Object): count: int, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def skip_finish(self, result: AsyncResult) -> int: ... class InputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + InputStreamClass() + """ + parent_class: GObject.ObjectClass = ... - read_fn: Callable[[InputStream, None, int, Optional[Cancellable]], int] = ... + read_fn: Callable[ + [InputStream, Optional[Any], int, Optional[Cancellable]], int + ] = ... skip: Callable[[InputStream, int, Optional[Cancellable]], int] = ... close_fn: Callable[[InputStream, Optional[Cancellable]], bool] = ... - read_async: Callable[..., bytes] = ... + read_async: Callable[ + Concatenate[ + InputStream, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + bytes, + ] = ... read_finish: Callable[[InputStream, AsyncResult], int] = ... - skip_async: Callable[..., None] = ... + skip_async: Callable[ + Concatenate[ + InputStream, + int, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... skip_finish: Callable[[InputStream, AsyncResult], int] = ... - close_async: Callable[..., None] = ... + close_async: Callable[ + Concatenate[ + InputStream, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... close_finish: Callable[[InputStream, AsyncResult], bool] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class InputStreamPrivate(GObject.GPointer): ... class InputVector(GObject.GPointer): - buffer: None = ... + """ + :Constructors: + + :: + + InputVector() + """ + + buffer: Any = ... size: int = ... class ListModel(GObject.GInterface): + """ + Interface GListModel + + Signals from GObject: + notify (GParam) + """ + def get_item(self, position: int) -> Optional[GObject.Object]: ... def get_item_type(self) -> Type: ... def get_n_items(self) -> int: ... def items_changed(self, position: int, removed: int, added: int) -> None: ... class ListModelInterface(GObject.GPointer): + """ + :Constructors: + + :: + + ListModelInterface() + """ + g_iface: GObject.TypeInterface = ... get_item_type: Callable[[ListModel], Type] = ... get_n_items: Callable[[ListModel], int] = ... get_item: Callable[[ListModel, int], Optional[GObject.Object]] = ... class ListStore(GObject.Object, ListModel): + """ + :Constructors: + + :: + + ListStore(**properties) + new(item_type:GType) -> Gio.ListStore + + Object GListStore + + Properties from GListStore: + item-type -> GType: + + n-items -> guint: + + + Signals from GListModel: + items-changed (guint, guint, guint) + + Signals from GObject: + notify (GParam) + """ + class Props: item_type: Type n_items: int @@ -4054,10 +6920,15 @@ class ListStore(GObject.Object, ListModel): def append(self, item: GObject.Object) -> None: ... def find(self, item: GObject.Object) -> Tuple[bool, int]: ... def find_with_equal_func( - self, item: GObject.Object, equal_func: Callable[[None, None], bool] + self, + item: Optional[GObject.Object], + equal_func: Callable[[Optional[Any], Optional[Any]], bool], ) -> Tuple[bool, int]: ... def find_with_equal_func_full( - self, item: GObject.Object, equal_func: Callable[..., bool], *user_data: Any + self, + item: Optional[GObject.Object], + equal_func: Callable[Concatenate[Optional[Any], Optional[Any], _VarArgs], bool], + user_data: Optional[Any] = None, ) -> Tuple[bool, int]: ... def insert(self, position: int, item: GObject.Object) -> None: ... def insert_sorted(self, item, compare_func, *user_data): ... # FIXME Function @@ -4071,9 +6942,24 @@ class ListStore(GObject.Object, ListModel): ) -> None: ... class ListStoreClass(GObject.GPointer): + """ + :Constructors: + + :: + + ListStoreClass() + """ + parent_class: GObject.ObjectClass = ... class LoadableIcon(GObject.GInterface): + """ + Interface GLoadableIcon + + Signals from GObject: + notify (GParam) + """ + def load( self, size: int, cancellable: Optional[Cancellable] = None ) -> Tuple[InputStream, str]: ... @@ -4081,25 +6967,66 @@ class LoadableIcon(GObject.GInterface): self, size: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def load_finish(self, res: AsyncResult) -> Tuple[InputStream, str]: ... class LoadableIconIface(GObject.GPointer): + """ + :Constructors: + + :: + + LoadableIconIface() + """ + g_iface: GObject.TypeInterface = ... load: Callable[ [LoadableIcon, int, Optional[Cancellable]], Tuple[InputStream, str] ] = ... - load_async: Callable[..., None] = ... + load_async: Callable[ + Concatenate[ + LoadableIcon, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... load_finish: Callable[[LoadableIcon, AsyncResult], Tuple[InputStream, str]] = ... class MemoryInputStream(InputStream, PollableInputStream, Seekable): + """ + :Constructors: + + :: + + MemoryInputStream(**properties) + new() -> Gio.InputStream + new_from_bytes(bytes:GLib.Bytes) -> Gio.InputStream + new_from_data(data:list, destroy:GLib.DestroyNotify=None) -> Gio.InputStream + + Object GMemoryInputStream + + Signals from GObject: + notify (GParam) + """ + parent_instance: InputStream = ... priv: MemoryInputStreamPrivate = ... def add_bytes(self, bytes: GLib.Bytes) -> None: ... def add_data( - self, data: Sequence[int], destroy: Optional[Callable[[None], None]] = None + self, + data: Sequence[int], + destroy: Optional[Callable[[Optional[Any]], None]] = None, ) -> None: ... @classmethod def new(cls) -> MemoryInputStream: ... @@ -4107,36 +7034,87 @@ class MemoryInputStream(InputStream, PollableInputStream, Seekable): def new_from_bytes(cls, bytes: GLib.Bytes) -> MemoryInputStream: ... @classmethod def new_from_data( - cls, data: Sequence[int], destroy: Optional[Callable[[None], None]] = None + cls, + data: Sequence[int], + destroy: Optional[Callable[[Optional[Any]], None]] = None, ) -> MemoryInputStream: ... class MemoryInputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + MemoryInputStreamClass() + """ + parent_class: InputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class MemoryInputStreamPrivate(GObject.GPointer): ... class MemoryMonitor(GObject.GInterface): + """ + Interface GMemoryMonitor + + Signals from GObject: + notify (GParam) + """ + @staticmethod def dup_default() -> MemoryMonitor: ... class MemoryMonitorInterface(GObject.GPointer): + """ + :Constructors: + + :: + + MemoryMonitorInterface() + """ + g_iface: GObject.TypeInterface = ... low_memory_warning: Callable[[MemoryMonitor, MemoryMonitorWarningLevel], None] = ... class MemoryOutputStream(OutputStream, PollableOutputStream, Seekable): + """ + :Constructors: + + :: + + MemoryOutputStream(**properties) + new_resizable() -> Gio.OutputStream + + Object GMemoryOutputStream + + Properties from GMemoryOutputStream: + data -> gpointer: Data Buffer + Pointer to buffer where data will be written. + size -> gulong: Data Buffer Size + Current size of the data buffer. + data-size -> gulong: Data Size + Size of data written to the buffer. + realloc-function -> gpointer: Memory Reallocation Function + Function with realloc semantics called to enlarge the buffer. + destroy-function -> gpointer: Destroy Notification Function + Function called with the buffer as argument when the stream is destroyed. + + Signals from GObject: + notify (GParam) + """ + class Props: - data: None + data: Optional[Any] data_size: int size: int props: Props = ... parent_instance: OutputStream = ... priv: MemoryOutputStreamPrivate = ... - def __init__(self, data: None = ..., size: int = ...): ... + def __init__(self, data: Any = ..., size: int = ...): ... def get_data(self) -> None: ... def get_data_size(self) -> int: ... def get_size(self) -> int: ... @@ -4146,16 +7124,41 @@ class MemoryOutputStream(OutputStream, PollableOutputStream, Seekable): def steal_data(self) -> None: ... class MemoryOutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + MemoryOutputStreamClass() + """ + parent_class: OutputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class MemoryOutputStreamPrivate(GObject.GPointer): ... class Menu(MenuModel): + """ + :Constructors: + + :: + + Menu(**properties) + new() -> Gio.Menu + + Object GMenu + + Signals from GMenuModel: + items-changed (gint, gint, gint) + + Signals from GObject: + notify (GParam) + """ + def append( self, label: Optional[str] = None, detailed_action: Optional[str] = None ) -> None: ... @@ -4188,6 +7191,19 @@ class Menu(MenuModel): def remove_all(self) -> None: ... class MenuAttributeIter(GObject.Object): + """ + :Constructors: + + :: + + MenuAttributeIter(**properties) + + Object GMenuAttributeIter + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: MenuAttributeIterPrivate = ... def do_get_next(self) -> Tuple[bool, str, GLib.Variant]: ... @@ -4197,12 +7213,37 @@ class MenuAttributeIter(GObject.Object): def next(self) -> bool: ... class MenuAttributeIterClass(GObject.GPointer): + """ + :Constructors: + + :: + + MenuAttributeIterClass() + """ + parent_class: GObject.ObjectClass = ... get_next: Callable[[MenuAttributeIter], Tuple[bool, str, GLib.Variant]] = ... class MenuAttributeIterPrivate(GObject.GPointer): ... class MenuItem(GObject.Object): + """ + :Constructors: + + :: + + MenuItem(**properties) + new(label:str=None, detailed_action:str=None) -> Gio.MenuItem + new_from_model(model:Gio.MenuModel, item_index:int) -> Gio.MenuItem + new_section(label:str=None, section:Gio.MenuModel) -> Gio.MenuItem + new_submenu(label:str=None, submenu:Gio.MenuModel) -> Gio.MenuItem + + Object GMenuItem + + Signals from GObject: + notify (GParam) + """ + def get_attribute_value( self, attribute: str, expected_type: Optional[GLib.VariantType] = None ) -> Optional[GLib.Variant]: ... @@ -4233,6 +7274,19 @@ class MenuItem(GObject.Object): def set_submenu(self, submenu: Optional[MenuModel] = None) -> None: ... class MenuLinkIter(GObject.Object): + """ + :Constructors: + + :: + + MenuLinkIter(**properties) + + Object GMenuLinkIter + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: MenuLinkIterPrivate = ... def do_get_next(self) -> Tuple[bool, str, MenuModel]: ... @@ -4242,12 +7296,36 @@ class MenuLinkIter(GObject.Object): def next(self) -> bool: ... class MenuLinkIterClass(GObject.GPointer): + """ + :Constructors: + + :: + + MenuLinkIterClass() + """ + parent_class: GObject.ObjectClass = ... get_next: Callable[[MenuLinkIter], Tuple[bool, str, MenuModel]] = ... class MenuLinkIterPrivate(GObject.GPointer): ... class MenuModel(GObject.Object): + """ + :Constructors: + + :: + + MenuModel(**properties) + + Object GMenuModel + + Signals from GMenuModel: + items-changed (gint, gint, gint) + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: MenuModelPrivate = ... def do_get_item_attribute_value( @@ -4277,6 +7355,14 @@ class MenuModel(GObject.Object): def iterate_item_links(self, item_index: int) -> MenuLinkIter: ... class MenuModelClass(GObject.GPointer): + """ + :Constructors: + + :: + + MenuModelClass() + """ + parent_class: GObject.ObjectClass = ... is_mutable: Callable[[MenuModel], bool] = ... get_n_items: Callable[[MenuModel], int] = ... @@ -4292,13 +7378,22 @@ class MenuModelClass(GObject.GPointer): class MenuModelPrivate(GObject.GPointer): ... class Mount(GObject.GInterface): + """ + Interface GMount + + Signals from GObject: + notify (GParam) + """ + def can_eject(self) -> bool: ... def can_unmount(self) -> bool: ... def eject( self, flags: MountUnmountFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_finish(self, result: AsyncResult) -> bool: ... @@ -4307,7 +7402,9 @@ class Mount(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_with_operation_finish(self, result: AsyncResult) -> bool: ... @@ -4324,7 +7421,9 @@ class Mount(GObject.GInterface): self, force_rescan: bool, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def guess_content_type_finish(self, result: AsyncResult) -> list[str]: ... @@ -4337,7 +7436,9 @@ class Mount(GObject.GInterface): flags: MountMountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def remount_finish(self, result: AsyncResult) -> bool: ... @@ -4346,7 +7447,9 @@ class Mount(GObject.GInterface): self, flags: MountUnmountFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def unmount_finish(self, result: AsyncResult) -> bool: ... @@ -4355,13 +7458,23 @@ class Mount(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def unmount_with_operation_finish(self, result: AsyncResult) -> bool: ... def unshadow(self) -> None: ... class MountIface(GObject.GPointer): + """ + :Constructors: + + :: + + MountIface() + """ + g_iface: GObject.TypeInterface = ... changed: Callable[[Mount], None] = ... unmounted: Callable[[Mount], None] = ... @@ -4373,37 +7486,160 @@ class MountIface(GObject.GPointer): get_drive: Callable[[Mount], Optional[Drive]] = ... can_unmount: Callable[[Mount], bool] = ... can_eject: Callable[[Mount], bool] = ... - unmount: Callable[..., None] = ... + unmount: Callable[ + Concatenate[ + Mount, + MountUnmountFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... unmount_finish: Callable[[Mount, AsyncResult], bool] = ... - eject: Callable[..., None] = ... + eject: Callable[ + Concatenate[ + Mount, + MountUnmountFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_finish: Callable[[Mount, AsyncResult], bool] = ... - remount: Callable[..., None] = ... + remount: Callable[ + Concatenate[ + Mount, + MountMountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... remount_finish: Callable[[Mount, AsyncResult], bool] = ... - guess_content_type: Callable[..., None] = ... + guess_content_type: Callable[ + Concatenate[ + Mount, + bool, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... guess_content_type_finish: Callable[[Mount, AsyncResult], list[str]] = ... guess_content_type_sync: Callable[ [Mount, bool, Optional[Cancellable]], list[str] ] = ... pre_unmount: Callable[[Mount], None] = ... - unmount_with_operation: Callable[..., None] = ... + unmount_with_operation: Callable[ + Concatenate[ + Mount, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... unmount_with_operation_finish: Callable[[Mount, AsyncResult], bool] = ... - eject_with_operation: Callable[..., None] = ... + eject_with_operation: Callable[ + Concatenate[ + Mount, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_with_operation_finish: Callable[[Mount, AsyncResult], bool] = ... get_default_location: Callable[[Mount], File] = ... get_sort_key: Callable[[Mount], Optional[str]] = ... get_symbolic_icon: Callable[[Mount], Icon] = ... class MountOperation(GObject.Object): + """ + :Constructors: + + :: + + MountOperation(**properties) + new() -> Gio.MountOperation + + Object GMountOperation + + Signals from GMountOperation: + ask-password (gchararray, gchararray, gchararray, GAskPasswordFlags) + ask-question (gchararray, GStrv) + reply (GMountOperationResult) + aborted () + show-processes (gchararray, GArray, GStrv) + show-unmount-progress (gchararray, gint64, gint64) + + Properties from GMountOperation: + username -> gchararray: Username + The user name + password -> gchararray: Password + The password + anonymous -> gboolean: Anonymous + Whether to use an anonymous user + domain -> gchararray: Domain + The domain of the mount operation + password-save -> GPasswordSave: Password save + How passwords should be saved + choice -> gint: Choice + The users choice + is-tcrypt-hidden-volume -> gboolean: TCRYPT Hidden Volume + Whether to unlock a TCRYPT hidden volume. See https://www.veracrypt.fr/en/Hidden%20Volume.html. + is-tcrypt-system-volume -> gboolean: TCRYPT System Volume + Whether to unlock a TCRYPT system volume. Only supported for unlocking Windows system volumes. See https://www.veracrypt.fr/en/System%20Encryption.html. + pim -> guint: PIM + The VeraCrypt PIM value + + Signals from GObject: + notify (GParam) + """ + class Props: anonymous: bool choice: int - domain: str + domain: Optional[str] is_tcrypt_hidden_volume: bool is_tcrypt_system_volume: bool - password: str + password: Optional[str] password_save: PasswordSave pim: int - username: str + username: Optional[str] props: Props = ... parent_instance: GObject.Object = ... priv: MountOperationPrivate = ... @@ -4411,13 +7647,13 @@ class MountOperation(GObject.Object): self, anonymous: bool = ..., choice: int = ..., - domain: str = ..., + domain: Optional[str] = ..., is_tcrypt_hidden_volume: bool = ..., is_tcrypt_system_volume: bool = ..., - password: str = ..., + password: Optional[str] = ..., password_save: PasswordSave = ..., pim: int = ..., - username: str = ..., + username: Optional[str] = ..., ): ... def do_aborted(self) -> None: ... def do_ask_password( @@ -4458,6 +7694,14 @@ class MountOperation(GObject.Object): def set_username(self, username: Optional[str] = None) -> None: ... class MountOperationClass(GObject.GPointer): + """ + :Constructors: + + :: + + MountOperationClass() + """ + parent_class: GObject.ObjectClass = ... ask_password: Callable[ [MountOperation, str, str, str, AskPasswordFlags], None @@ -4469,44 +7713,128 @@ class MountOperationClass(GObject.GPointer): [MountOperation, str, Sequence[int], Sequence[str]], None ] = ... show_unmount_progress: Callable[[MountOperation, str, int, int], None] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... - _g_reserved7: None = ... - _g_reserved8: None = ... - _g_reserved9: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... + _g_reserved7: Any = ... + _g_reserved8: Any = ... + _g_reserved9: Any = ... class MountOperationPrivate(GObject.GPointer): ... class NativeSocketAddress(SocketAddress, SocketConnectable): + """ + :Constructors: + + :: + + NativeSocketAddress(**properties) + new(native=None, len:int) -> Gio.SocketAddress + + Object GNativeSocketAddress + + Properties from GSocketAddress: + family -> GSocketFamily: Address family + The family of the socket address + + Signals from GObject: + notify (GParam) + """ + class Props: family: SocketFamily props: Props = ... parent_instance: SocketAddress = ... priv: NativeSocketAddressPrivate = ... @classmethod - def new(cls, native: None, len: int) -> NativeSocketAddress: ... + def new(cls, native: Optional[Any], len: int) -> NativeSocketAddress: ... class NativeSocketAddressClass(GObject.GPointer): + """ + :Constructors: + + :: + + NativeSocketAddressClass() + """ + parent_class: SocketAddressClass = ... class NativeSocketAddressPrivate(GObject.GPointer): ... class NativeVolumeMonitor(VolumeMonitor): + """ + :Constructors: + + :: + + NativeVolumeMonitor(**properties) + + Object GNativeVolumeMonitor + + Signals from GVolumeMonitor: + volume-added (GVolume) + volume-removed (GVolume) + volume-changed (GVolume) + mount-added (GMount) + mount-removed (GMount) + mount-pre-unmount (GMount) + mount-changed (GMount) + drive-connected (GDrive) + drive-disconnected (GDrive) + drive-changed (GDrive) + drive-eject-button (GDrive) + drive-stop-button (GDrive) + + Signals from GObject: + notify (GParam) + """ + parent_instance: VolumeMonitor = ... class NativeVolumeMonitorClass(GObject.GPointer): + """ + :Constructors: + + :: + + NativeVolumeMonitorClass() + """ + parent_class: VolumeMonitorClass = ... - get_mount_for_mount_path: None = ... + get_mount_for_mount_path: Any = ... class NetworkAddress(GObject.Object, SocketConnectable): + """ + :Constructors: + + :: + + NetworkAddress(**properties) + new(hostname:str, port:int) -> Gio.NetworkAddress + new_loopback(port:int) -> Gio.NetworkAddress + + Object GNetworkAddress + + Properties from GNetworkAddress: + hostname -> gchararray: Hostname + Hostname to resolve + port -> guint: Port + Network port + scheme -> gchararray: Scheme + URI Scheme + + Signals from GObject: + notify (GParam) + """ + class Props: hostname: str port: int - scheme: str + scheme: Optional[str] props: Props = ... parent_instance: GObject.Object = ... priv: NetworkAddressPrivate = ... @@ -4524,11 +7852,26 @@ class NetworkAddress(GObject.Object, SocketConnectable): def parse_uri(uri: str, default_port: int) -> NetworkAddress: ... class NetworkAddressClass(GObject.GPointer): + """ + :Constructors: + + :: + + NetworkAddressClass() + """ + parent_class: GObject.ObjectClass = ... class NetworkAddressPrivate(GObject.GPointer): ... class NetworkMonitor(GObject.GInterface): + """ + Interface GNetworkMonitor + + Signals from GObject: + notify (GParam) + """ + def can_reach( self, connectable: SocketConnectable, cancellable: Optional[Cancellable] = None ) -> bool: ... @@ -4536,7 +7879,9 @@ class NetworkMonitor(GObject.GInterface): self, connectable: SocketConnectable, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def can_reach_finish(self, result: AsyncResult) -> bool: ... @@ -4547,15 +7892,60 @@ class NetworkMonitor(GObject.GInterface): def get_network_metered(self) -> bool: ... class NetworkMonitorInterface(GObject.GPointer): + """ + :Constructors: + + :: + + NetworkMonitorInterface() + """ + g_iface: GObject.TypeInterface = ... network_changed: Callable[[NetworkMonitor, bool], None] = ... can_reach: Callable[ [NetworkMonitor, SocketConnectable, Optional[Cancellable]], bool ] = ... - can_reach_async: Callable[..., None] = ... + can_reach_async: Callable[ + Concatenate[ + NetworkMonitor, + SocketConnectable, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... can_reach_finish: Callable[[NetworkMonitor, AsyncResult], bool] = ... class NetworkService(GObject.Object, SocketConnectable): + """ + :Constructors: + + :: + + NetworkService(**properties) + new(service:str, protocol:str, domain:str) -> Gio.NetworkService + + Object GNetworkService + + Properties from GNetworkService: + service -> gchararray: Service + Service name, eg "ldap" + protocol -> gchararray: Protocol + Network protocol, eg "tcp" + domain -> gchararray: Domain + Network domain, eg, "example.com" + scheme -> gchararray: Scheme + Network scheme (default is to use service) + + Signals from GObject: + notify (GParam) + """ + class Props: domain: str protocol: str @@ -4580,11 +7970,33 @@ class NetworkService(GObject.Object, SocketConnectable): def set_scheme(self, scheme: str) -> None: ... class NetworkServiceClass(GObject.GPointer): + """ + :Constructors: + + :: + + NetworkServiceClass() + """ + parent_class: GObject.ObjectClass = ... class NetworkServicePrivate(GObject.GPointer): ... class Notification(GObject.Object): + """ + :Constructors: + + :: + + Notification(**properties) + new(title:str) -> Gio.Notification + + Object GNotification + + Signals from GObject: + notify (GParam) + """ + def add_button(self, label: str, detailed_action: str) -> None: ... def add_button_with_target( self, label: str, action: str, target: Optional[GLib.Variant] = None @@ -4603,6 +8015,14 @@ class Notification(GObject.Object): def set_urgent(self, urgent: bool) -> None: ... class OutputMessage(GObject.GPointer): + """ + :Constructors: + + :: + + OutputMessage() + """ + address: SocketAddress = ... vectors: OutputVector = ... num_vectors: int = ... @@ -4611,6 +8031,19 @@ class OutputMessage(GObject.GPointer): num_control_messages: int = ... class OutputStream(GObject.Object): + """ + :Constructors: + + :: + + OutputStream(**properties) + + Object GOutputStream + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: OutputStreamPrivate = ... def clear_pending(self) -> None: ... @@ -4619,7 +8052,9 @@ class OutputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def close_finish(self, result: AsyncResult) -> bool: ... @@ -4627,7 +8062,9 @@ class OutputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_close_finish(self, result: AsyncResult) -> bool: ... @@ -4637,7 +8074,9 @@ class OutputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_flush_finish(self, result: AsyncResult) -> bool: ... @@ -4653,7 +8092,9 @@ class OutputStream(GObject.Object): flags: OutputStreamSpliceFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_splice_finish(self, result: AsyncResult) -> int: ... @@ -4662,7 +8103,9 @@ class OutputStream(GObject.Object): buffer: Optional[Sequence[int]], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_write_finish(self, result: AsyncResult) -> int: ... @@ -4676,7 +8119,9 @@ class OutputStream(GObject.Object): vectors: Sequence[OutputVector], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_writev_finish(self, result: AsyncResult) -> Tuple[bool, int]: ... @@ -4688,7 +8133,9 @@ class OutputStream(GObject.Object): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def flush_finish(self, result: AsyncResult) -> bool: ... @@ -4708,7 +8155,9 @@ class OutputStream(GObject.Object): flags: OutputStreamSpliceFlags, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def splice_finish(self, result: AsyncResult) -> int: ... @@ -4723,7 +8172,9 @@ class OutputStream(GObject.Object): buffer: Sequence[int], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def write_all_finish(self, result: AsyncResult) -> Tuple[bool, int]: ... @@ -4732,7 +8183,9 @@ class OutputStream(GObject.Object): buffer: Sequence[int], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def write_bytes( @@ -4743,7 +8196,9 @@ class OutputStream(GObject.Object): bytes: GLib.Bytes, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def write_bytes_finish(self, result: AsyncResult) -> int: ... @@ -4759,7 +8214,9 @@ class OutputStream(GObject.Object): vectors: Sequence[OutputVector], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def writev_all_finish(self, result: AsyncResult) -> Tuple[bool, int]: ... @@ -4768,12 +8225,22 @@ class OutputStream(GObject.Object): vectors: Sequence[OutputVector], io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def writev_finish(self, result: AsyncResult) -> Tuple[bool, int]: ... class OutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + OutputStreamClass() + """ + parent_class: GObject.ObjectClass = ... write_fn: Callable[ [OutputStream, Optional[Sequence[int]], Optional[Cancellable]], int @@ -4783,32 +8250,130 @@ class OutputStreamClass(GObject.GPointer): ] = ... flush: Callable[[OutputStream, Optional[Cancellable]], bool] = ... close_fn: Callable[[OutputStream, Optional[Cancellable]], bool] = ... - write_async: Callable[..., None] = ... + write_async: Callable[ + Concatenate[ + OutputStream, + Optional[Sequence[int]], + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... write_finish: Callable[[OutputStream, AsyncResult], int] = ... - splice_async: Callable[..., None] = ... + splice_async: Callable[ + Concatenate[ + OutputStream, + InputStream, + OutputStreamSpliceFlags, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... splice_finish: Callable[[OutputStream, AsyncResult], int] = ... - flush_async: Callable[..., None] = ... + flush_async: Callable[ + Concatenate[ + OutputStream, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... flush_finish: Callable[[OutputStream, AsyncResult], bool] = ... - close_async: Callable[..., None] = ... + close_async: Callable[ + Concatenate[ + OutputStream, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... close_finish: Callable[[OutputStream, AsyncResult], bool] = ... writev_fn: Callable[ [OutputStream, Sequence[OutputVector], Optional[Cancellable]], Tuple[bool, int] ] = ... - writev_async: Callable[..., None] = ... + writev_async: Callable[ + Concatenate[ + OutputStream, + Sequence[OutputVector], + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... writev_finish: Callable[[OutputStream, AsyncResult], Tuple[bool, int]] = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... - _g_reserved7: None = ... - _g_reserved8: None = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... + _g_reserved7: Any = ... + _g_reserved8: Any = ... class OutputStreamPrivate(GObject.GPointer): ... class OutputVector(GObject.GPointer): - buffer: None = ... + """ + :Constructors: + + :: + + OutputVector() + """ + + buffer: Any = ... size: int = ... class Permission(GObject.Object): + """ + :Constructors: + + :: + + Permission(**properties) + + Object GPermission + + Properties from GPermission: + allowed -> gboolean: Is allowed + If the caller is allowed to perform the action + can-acquire -> gboolean: Can acquire + If calling g_permission_acquire() makes sense + can-release -> gboolean: Can release + If calling g_permission_release() makes sense + + Signals from GObject: + notify (GParam) + """ + class Props: allowed: bool can_acquire: bool @@ -4820,7 +8385,9 @@ class Permission(GObject.Object): def acquire_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def acquire_finish(self, result: AsyncResult) -> bool: ... @@ -4828,7 +8395,9 @@ class Permission(GObject.Object): def do_acquire_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_acquire_finish(self, result: AsyncResult) -> bool: ... @@ -4836,7 +8405,9 @@ class Permission(GObject.Object): def do_release_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_release_finish(self, result: AsyncResult) -> bool: ... @@ -4850,24 +8421,65 @@ class Permission(GObject.Object): def release_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def release_finish(self, result: AsyncResult) -> bool: ... class PermissionClass(GObject.GPointer): + """ + :Constructors: + + :: + + PermissionClass() + """ + parent_class: GObject.ObjectClass = ... acquire: Callable[[Permission, Optional[Cancellable]], bool] = ... - acquire_async: Callable[..., None] = ... + acquire_async: Callable[ + Concatenate[ + Permission, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... acquire_finish: Callable[[Permission, AsyncResult], bool] = ... release: Callable[[Permission, Optional[Cancellable]], bool] = ... - release_async: Callable[..., None] = ... + release_async: Callable[ + Concatenate[ + Permission, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... release_finish: Callable[[Permission, AsyncResult], bool] = ... - reserved: list[None] = ... + reserved: list[Any] = ... class PermissionPrivate(GObject.GPointer): ... class PollableInputStream(GObject.GInterface): + """ + Interface GPollableInputStream + + Signals from GObject: + notify (GParam) + """ + def can_poll(self) -> bool: ... def create_source( self, cancellable: Optional[Cancellable] = None @@ -4878,6 +8490,14 @@ class PollableInputStream(GObject.GInterface): ) -> Tuple[int, bytes]: ... class PollableInputStreamInterface(GObject.GPointer): + """ + :Constructors: + + :: + + PollableInputStreamInterface() + """ + g_iface: GObject.TypeInterface = ... can_poll: Callable[[PollableInputStream], bool] = ... is_readable: Callable[[PollableInputStream], bool] = ... @@ -4887,6 +8507,13 @@ class PollableInputStreamInterface(GObject.GPointer): read_nonblocking: Callable[[PollableInputStream], Tuple[int, bytes]] = ... class PollableOutputStream(GObject.GInterface): + """ + Interface GPollableOutputStream + + Signals from GObject: + notify (GParam) + """ + def can_poll(self) -> bool: ... def create_source( self, cancellable: Optional[Cancellable] = None @@ -4900,6 +8527,14 @@ class PollableOutputStream(GObject.GInterface): ) -> Tuple[PollableReturn, int]: ... class PollableOutputStreamInterface(GObject.GPointer): + """ + :Constructors: + + :: + + PollableOutputStreamInterface() + """ + g_iface: GObject.TypeInterface = ... can_poll: Callable[[PollableOutputStream], bool] = ... is_writable: Callable[[PollableOutputStream], bool] = ... @@ -4914,23 +8549,70 @@ class PollableOutputStreamInterface(GObject.GPointer): ] = ... class PowerProfileMonitor(GObject.GInterface): + """ + Interface GPowerProfileMonitor + + Signals from GObject: + notify (GParam) + """ + @staticmethod def dup_default() -> PowerProfileMonitor: ... def get_power_saver_enabled(self) -> bool: ... class PowerProfileMonitorInterface(GObject.GPointer): + """ + :Constructors: + + :: + + PowerProfileMonitorInterface() + """ + g_iface: GObject.TypeInterface = ... class PropertyAction(GObject.Object, Action): + """ + :Constructors: + + :: + + PropertyAction(**properties) + new(name:str, object:GObject.Object, property_name:str) -> Gio.PropertyAction + + Object GPropertyAction + + Properties from GPropertyAction: + name -> gchararray: Action Name + The name used to invoke the action + parameter-type -> GVariantType: Parameter Type + The type of GVariant passed to activate() + enabled -> gboolean: Enabled + If the action can be activated + state-type -> GVariantType: State Type + The type of the state kept by the action + state -> GVariant: State + The state the action is in + object -> GObject: Object + The object with the property to wrap + property-name -> gchararray: Property name + The name of the property to wrap + invert-boolean -> gboolean: Invert boolean + Whether to invert the value of a boolean property + + Signals from GObject: + notify (GParam) + """ + class Props: enabled: bool invert_boolean: bool name: str - object: GObject.Object parameter_type: GLib.VariantType - property_name: str state: GLib.Variant state_type: GLib.VariantType + object: GObject.Object + property_name: str props: Props = ... def __init__( self, @@ -4945,6 +8627,13 @@ class PropertyAction(GObject.Object, Action): ) -> PropertyAction: ... class Proxy(GObject.GInterface): + """ + Interface GProxy + + Signals from GObject: + notify (GParam) + """ + def connect( self, connection: IOStream, @@ -4956,7 +8645,9 @@ class Proxy(GObject.GInterface): connection: IOStream, proxy_address: ProxyAddress, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def connect_finish(self, result: AsyncResult) -> IOStream: ... @@ -4965,14 +8656,58 @@ class Proxy(GObject.GInterface): def supports_hostname(self) -> bool: ... class ProxyAddress(InetSocketAddress, SocketConnectable): + """ + :Constructors: + + :: + + ProxyAddress(**properties) + new(inetaddr:Gio.InetAddress, port:int, protocol:str, dest_hostname:str, dest_port:int, username:str=None, password:str=None) -> Gio.SocketAddress + + Object GProxyAddress + + Properties from GProxyAddress: + protocol -> gchararray: Protocol + The proxy protocol + destination-protocol -> gchararray: Destination Protocol + The proxy destination protocol + destination-hostname -> gchararray: Destination Hostname + The proxy destination hostname + destination-port -> guint: Destination Port + The proxy destination port + username -> gchararray: Username + The proxy username + password -> gchararray: Password + The proxy password + uri -> gchararray: URI + The proxy’s URI + + Properties from GInetSocketAddress: + address -> GInetAddress: Address + The address + port -> guint: Port + The port + flowinfo -> guint: Flow info + IPv6 flow info + scope-id -> guint: Scope ID + IPv6 scope ID + + Properties from GSocketAddress: + family -> GSocketFamily: Address family + The family of the socket address + + Signals from GObject: + notify (GParam) + """ + class Props: destination_hostname: str destination_port: int destination_protocol: str - password: str + password: Optional[str] protocol: str - uri: str - username: str + uri: Optional[str] + username: Optional[str] address: InetAddress flowinfo: int port: int @@ -5015,9 +8750,40 @@ class ProxyAddress(InetSocketAddress, SocketConnectable): ) -> ProxyAddress: ... class ProxyAddressClass(GObject.GPointer): + """ + :Constructors: + + :: + + ProxyAddressClass() + """ + parent_class: InetSocketAddressClass = ... class ProxyAddressEnumerator(SocketAddressEnumerator): + """ + :Constructors: + + :: + + ProxyAddressEnumerator(**properties) + + Object GProxyAddressEnumerator + + Properties from GProxyAddressEnumerator: + uri -> gchararray: URI + The destination URI, use none:// for generic socket + default-port -> guint: Default port + The default port to use if uri does not specify one + connectable -> GSocketConnectable: Connectable + The connectable being enumerated. + proxy-resolver -> GProxyResolver: Proxy resolver + The proxy resolver to use. + + Signals from GObject: + notify (GParam) + """ + class Props: connectable: SocketConnectable default_port: int @@ -5035,28 +8801,65 @@ class ProxyAddressEnumerator(SocketAddressEnumerator): ): ... class ProxyAddressEnumeratorClass(GObject.GPointer): + """ + :Constructors: + + :: + + ProxyAddressEnumeratorClass() + """ + parent_class: SocketAddressEnumeratorClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... - _g_reserved7: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... + _g_reserved7: Any = ... class ProxyAddressEnumeratorPrivate(GObject.GPointer): ... class ProxyAddressPrivate(GObject.GPointer): ... class ProxyInterface(GObject.GPointer): + """ + :Constructors: + + :: + + ProxyInterface() + """ + g_iface: GObject.TypeInterface = ... connect: Callable[ [Proxy, IOStream, ProxyAddress, Optional[Cancellable]], IOStream ] = ... - connect_async: Callable[..., None] = ... + connect_async: Callable[ + Concatenate[ + Proxy, + IOStream, + ProxyAddress, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... connect_finish: Callable[[Proxy, AsyncResult], IOStream] = ... supports_hostname: Callable[[Proxy], bool] = ... class ProxyResolver(GObject.GInterface): + """ + Interface GProxyResolver + + Signals from GObject: + notify (GParam) + """ + @staticmethod def get_default() -> ProxyResolver: ... def is_supported(self) -> bool: ... @@ -5067,19 +8870,49 @@ class ProxyResolver(GObject.GInterface): self, uri: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_finish(self, result: AsyncResult) -> list[str]: ... class ProxyResolverInterface(GObject.GPointer): + """ + :Constructors: + + :: + + ProxyResolverInterface() + """ + g_iface: GObject.TypeInterface = ... is_supported: Callable[[ProxyResolver], bool] = ... lookup: Callable[[ProxyResolver, str, Optional[Cancellable]], list[str]] = ... - lookup_async: Callable[..., None] = ... + lookup_async: Callable[ + Concatenate[ + ProxyResolver, + str, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_finish: Callable[[ProxyResolver, AsyncResult], list[str]] = ... class RemoteActionGroup(GObject.GInterface): + """ + Interface GRemoteActionGroup + + Signals from GObject: + notify (GParam) + """ + def activate_action_full( self, action_name: str, @@ -5091,6 +8924,14 @@ class RemoteActionGroup(GObject.GInterface): ) -> None: ... class RemoteActionGroupInterface(GObject.GPointer): + """ + :Constructors: + + :: + + RemoteActionGroupInterface() + """ + g_iface: GObject.TypeInterface = ... activate_action_full: Callable[ [RemoteActionGroup, str, Optional[GLib.Variant], GLib.Variant], None @@ -5100,6 +8941,22 @@ class RemoteActionGroupInterface(GObject.GPointer): ] = ... class Resolver(GObject.Object): + """ + :Constructors: + + :: + + Resolver(**properties) + + Object GResolver + + Signals from GResolver: + reload () + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: ResolverPrivate = ... def do_lookup_by_address( @@ -5109,7 +8966,9 @@ class Resolver(GObject.Object): self, address: InetAddress, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_by_address_finish(self, result: AsyncResult) -> str: ... @@ -5120,7 +8979,9 @@ class Resolver(GObject.Object): self, hostname: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_by_name_finish(self, result: AsyncResult) -> list[InetAddress]: ... @@ -5135,7 +8996,9 @@ class Resolver(GObject.Object): hostname: str, flags: ResolverNameLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_by_name_with_flags_finish( @@ -5152,7 +9015,9 @@ class Resolver(GObject.Object): rrname: str, record_type: ResolverRecordType, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_records_finish(self, result: AsyncResult) -> list[GLib.Variant]: ... @@ -5160,7 +9025,9 @@ class Resolver(GObject.Object): self, rrname: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_service_finish(self, result: AsyncResult) -> list[SrvTarget]: ... @@ -5174,7 +9041,9 @@ class Resolver(GObject.Object): self, address: InetAddress, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_by_address_finish(self, result: AsyncResult) -> str: ... @@ -5185,7 +9054,9 @@ class Resolver(GObject.Object): self, hostname: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_by_name_finish(self, result: AsyncResult) -> list[InetAddress]: ... @@ -5200,7 +9071,9 @@ class Resolver(GObject.Object): hostname: str, flags: ResolverNameLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_by_name_with_flags_finish( @@ -5217,7 +9090,9 @@ class Resolver(GObject.Object): rrname: str, record_type: ResolverRecordType, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_records_finish(self, result: AsyncResult) -> list[GLib.Variant]: ... @@ -5234,34 +9109,111 @@ class Resolver(GObject.Object): protocol: str, domain: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_service_finish(self, result: AsyncResult) -> list[SrvTarget]: ... def set_default(self) -> None: ... class ResolverClass(GObject.GPointer): + """ + :Constructors: + + :: + + ResolverClass() + """ + parent_class: GObject.ObjectClass = ... reload: Callable[[Resolver], None] = ... lookup_by_name: Callable[ [Resolver, str, Optional[Cancellable]], list[InetAddress] ] = ... - lookup_by_name_async: Callable[..., None] = ... + lookup_by_name_async: Callable[ + Concatenate[ + Resolver, + str, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_by_name_finish: Callable[[Resolver, AsyncResult], list[InetAddress]] = ... lookup_by_address: Callable[ [Resolver, InetAddress, Optional[Cancellable]], str ] = ... - lookup_by_address_async: Callable[..., None] = ... + lookup_by_address_async: Callable[ + Concatenate[ + Resolver, + InetAddress, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_by_address_finish: Callable[[Resolver, AsyncResult], str] = ... - lookup_service: None = ... - lookup_service_async: Callable[..., None] = ... + lookup_service: Any = ... + lookup_service_async: Callable[ + Concatenate[ + Resolver, + str, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_service_finish: Callable[[Resolver, AsyncResult], list[SrvTarget]] = ... lookup_records: Callable[ [Resolver, str, ResolverRecordType, Optional[Cancellable]], list[GLib.Variant] ] = ... - lookup_records_async: Callable[..., None] = ... + lookup_records_async: Callable[ + Concatenate[ + Resolver, + str, + ResolverRecordType, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_records_finish: Callable[[Resolver, AsyncResult], list[GLib.Variant]] = ... - lookup_by_name_with_flags_async: Callable[..., None] = ... + lookup_by_name_with_flags_async: Callable[ + Concatenate[ + Resolver, + str, + ResolverNameLookupFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_by_name_with_flags_finish: Callable[ [Resolver, AsyncResult], list[InetAddress] ] = ... @@ -5273,6 +9225,14 @@ class ResolverClass(GObject.GPointer): class ResolverPrivate(GObject.GPointer): ... class Resource(GObject.GBoxed): + """ + :Constructors: + + :: + + new_from_data(data:GLib.Bytes) -> Gio.Resource + """ + def enumerate_children( self, path: str, lookup_flags: ResourceLookupFlags ) -> list[str]: ... @@ -5293,6 +9253,13 @@ class Resource(GObject.GBoxed): def unref(self) -> None: ... class Seekable(GObject.GInterface): + """ + Interface GSeekable + + Signals from GObject: + notify (GParam) + """ + def can_seek(self) -> bool: ... def can_truncate(self) -> bool: ... def seek( @@ -5307,6 +9274,14 @@ class Seekable(GObject.GInterface): ) -> bool: ... class SeekableIface(GObject.GPointer): + """ + :Constructors: + + :: + + SeekableIface() + """ + g_iface: GObject.TypeInterface = ... tell: Callable[[Seekable], int] = ... can_seek: Callable[[Seekable], bool] = ... @@ -5315,6 +9290,39 @@ class SeekableIface(GObject.GPointer): truncate_fn: Callable[[Seekable, int, Optional[Cancellable]], bool] = ... class Settings(GObject.Object): + """ + Provide dictionary-like access to GLib.Settings. + + Object GSettings + + Provide dictionary-like access to GLib.Settings. + + Signals from GSettings: + changed (gchararray) + change-event (gpointer, gint) -> gboolean + writable-changed (gchararray) + writable-change-event (guint) -> gboolean + + Properties from GSettings: + settings-schema -> GSettingsSchema: schema + The GSettingsSchema for this settings object + schema -> gchararray: Schema name + The name of the schema for this settings object + schema-id -> gchararray: Schema name + The name of the schema for this settings object + backend -> GSettingsBackend: GSettingsBackend + The GSettingsBackend for this settings object + path -> gchararray: Base path + The path within the backend where the settings are + has-unapplied -> gboolean: Has unapplied changes + TRUE if there are outstanding changes to apply() + delay-apply -> gboolean: Delay-apply mode + Whether this settings object is in “delay-apply” mode + + Signals from GObject: + notify (GParam) + """ + class Props: backend: SettingsBackend delay_apply: bool @@ -5357,7 +9365,10 @@ class Settings(GObject.Object): def get_int(self, key: str) -> int: ... def get_int64(self, key: str) -> int: ... def get_mapped( - self, key: str, mapping: Callable[..., Tuple[bool, None]], *user_data: Any + self, + key: str, + mapping: Callable[Concatenate[GLib.Variant, _VarArgs], Tuple[bool, Any]], + *user_data: Any, ) -> None: ... def get_range(self, key: str) -> GLib.Variant: ... def get_string(self, key: str) -> str: ... @@ -5411,10 +9422,25 @@ class Settings(GObject.Object): def unbind(object: GObject.Object, property: str) -> None: ... class SettingsBackend(GObject.Object): + """ + :Constructors: + + :: + + SettingsBackend(**properties) + + Object GSettingsBackend + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: SettingsBackendPrivate = ... - def changed(self, key: str, origin_tag: None) -> None: ... - def changed_tree(self, tree: GLib.Tree, origin_tag: None) -> None: ... + def changed(self, key: str, origin_tag: Optional[Any] = None) -> None: ... + def changed_tree( + self, tree: GLib.Tree, origin_tag: Optional[Any] = None + ) -> None: ... def do_get_writable(self, key: str) -> bool: ... def do_read( self, key: str, expected_type: GLib.VariantType, default_value: bool @@ -5422,48 +9448,68 @@ class SettingsBackend(GObject.Object): def do_read_user_value( self, key: str, expected_type: GLib.VariantType ) -> GLib.Variant: ... - def do_reset(self, key: str, origin_tag: None) -> None: ... + def do_reset(self, key: str, origin_tag: Optional[Any] = None) -> None: ... def do_subscribe(self, name: str) -> None: ... def do_sync(self) -> None: ... def do_unsubscribe(self, name: str) -> None: ... - def do_write(self, key: str, value: GLib.Variant, origin_tag: None) -> bool: ... - def do_write_tree(self, tree: GLib.Tree, origin_tag: None) -> bool: ... + def do_write( + self, key: str, value: GLib.Variant, origin_tag: Optional[Any] = None + ) -> bool: ... + def do_write_tree( + self, tree: GLib.Tree, origin_tag: Optional[Any] = None + ) -> bool: ... @staticmethod def flatten_tree(tree: GLib.Tree) -> Tuple[str, list[str], list[GLib.Variant]]: ... @staticmethod def get_default() -> SettingsBackend: ... def keys_changed( - self, path: str, items: Sequence[str], origin_tag: None + self, path: str, items: Sequence[str], origin_tag: Optional[Any] = None ) -> None: ... - def path_changed(self, path: str, origin_tag: None) -> None: ... + def path_changed(self, path: str, origin_tag: Optional[Any] = None) -> None: ... def path_writable_changed(self, path: str) -> None: ... def writable_changed(self, key: str) -> None: ... class SettingsBackendClass(GObject.GPointer): + """ + :Constructors: + + :: + + SettingsBackendClass() + """ + parent_class: GObject.ObjectClass = ... read: Callable[[SettingsBackend, str, GLib.VariantType, bool], GLib.Variant] = ... get_writable: Callable[[SettingsBackend, str], bool] = ... - write: Callable[[SettingsBackend, str, GLib.Variant, None], bool] = ... - write_tree: Callable[[SettingsBackend, GLib.Tree, None], bool] = ... - reset: Callable[[SettingsBackend, str, None], None] = ... + write: Callable[[SettingsBackend, str, GLib.Variant, Optional[Any]], bool] = ... + write_tree: Callable[[SettingsBackend, GLib.Tree, Optional[Any]], bool] = ... + reset: Callable[[SettingsBackend, str, Optional[Any]], None] = ... subscribe: Callable[[SettingsBackend, str], None] = ... unsubscribe: Callable[[SettingsBackend, str], None] = ... sync: Callable[[SettingsBackend], None] = ... - get_permission: None = ... + get_permission: Any = ... read_user_value: Callable[ [SettingsBackend, str, GLib.VariantType], GLib.Variant ] = ... - padding: list[None] = ... + padding: list[Any] = ... class SettingsBackendPrivate(GObject.GPointer): ... class SettingsClass(GObject.GPointer): + """ + :Constructors: + + :: + + SettingsClass() + """ + parent_class: GObject.ObjectClass = ... writable_changed: Callable[[Settings, str], None] = ... changed: Callable[[Settings, str], None] = ... writable_change_event: Callable[[Settings, int], bool] = ... change_event: Callable[[Settings, int, int], bool] = ... - padding: list[None] = ... + padding: list[Any] = ... class SettingsPrivate(GObject.GPointer): ... @@ -5489,6 +9535,14 @@ class SettingsSchemaKey(GObject.GBoxed): def unref(self) -> None: ... class SettingsSchemaSource(GObject.GBoxed): + """ + :Constructors: + + :: + + new_from_directory(directory:str, parent:Gio.SettingsSchemaSource=None, trusted:bool) -> Gio.SettingsSchemaSource + """ + @staticmethod def get_default() -> Optional[SettingsSchemaSource]: ... def list_schemas(self, recursive: bool) -> Tuple[list[str], list[str]]: ... @@ -5501,6 +9555,37 @@ class SettingsSchemaSource(GObject.GBoxed): def unref(self) -> None: ... class SimpleAction(GObject.Object, Action): + """ + :Constructors: + + :: + + SimpleAction(**properties) + new(name:str, parameter_type:GLib.VariantType=None) -> Gio.SimpleAction + new_stateful(name:str, parameter_type:GLib.VariantType=None, state:GLib.Variant) -> Gio.SimpleAction + + Object GSimpleAction + + Signals from GSimpleAction: + activate (GVariant) + change-state (GVariant) + + Properties from GSimpleAction: + name -> gchararray: Action Name + The name used to invoke the action + parameter-type -> GVariantType: Parameter Type + The type of GVariant passed to activate() + enabled -> gboolean: Enabled + If the action can be activated + state-type -> GVariantType: State Type + The type of the state kept by the action + state -> GVariant: State + The state the action is in + + Signals from GObject: + notify (GParam) + """ + class Props: enabled: bool name: str @@ -5528,9 +9613,31 @@ class SimpleAction(GObject.Object, Action): def set_state_hint(self, state_hint: Optional[GLib.Variant] = None) -> None: ... class SimpleActionGroup(GObject.Object, ActionGroup, ActionMap): + """ + :Constructors: + + :: + + SimpleActionGroup(**properties) + new() -> Gio.SimpleActionGroup + + Object GSimpleActionGroup + + Signals from GActionGroup: + action-added (gchararray) + action-removed (gchararray) + action-enabled-changed (gchararray, gboolean) + action-state-changed (gchararray, GVariant) + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: SimpleActionGroupPrivate = ... - def add_entries(self, entries: Sequence[ActionEntry], user_data: None) -> None: ... + def add_entries( + self, entries: Sequence[ActionEntry], user_data: Optional[Any] = None + ) -> None: ... def insert(self, action: Action) -> None: ... def lookup(self, action_name: str) -> Action: ... @classmethod @@ -5538,35 +9645,64 @@ class SimpleActionGroup(GObject.Object, ActionGroup, ActionMap): def remove(self, action_name: str) -> None: ... class SimpleActionGroupClass(GObject.GPointer): + """ + :Constructors: + + :: + + SimpleActionGroupClass() + """ + parent_class: GObject.ObjectClass = ... - padding: list[None] = ... + padding: list[Any] = ... class SimpleActionGroupPrivate(GObject.GPointer): ... class SimpleAsyncResult(GObject.Object, AsyncResult): + """ + :Constructors: + + :: + + SimpleAsyncResult(**properties) + new(source_object:GObject.Object=None, callback:Gio.AsyncReadyCallback=None, user_data=None, source_tag=None) -> Gio.SimpleAsyncResult + new_from_error(source_object:GObject.Object=None, callback:Gio.AsyncReadyCallback=None, user_data=None, error:error) -> Gio.SimpleAsyncResult + + Object GSimpleAsyncResult + + Signals from GObject: + notify (GParam) + """ + def complete(self) -> None: ... def complete_in_idle(self) -> None: ... def get_op_res_gboolean(self) -> bool: ... def get_op_res_gssize(self) -> int: ... @staticmethod def is_valid( - result: AsyncResult, source: Optional[GObject.Object], source_tag: None + result: AsyncResult, + source: Optional[GObject.Object] = None, + source_tag: Optional[Any] = None, ) -> bool: ... @classmethod def new( cls, - source_object: Optional[GObject.Object], - callback: Optional[Callable[..., None]], - source_tag: None, - *user_data: Any, + source_object: Optional[GObject.Object] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, + user_data: Optional[Any] = None, + source_tag: Optional[Any] = None, ) -> SimpleAsyncResult: ... @classmethod def new_from_error( cls, source_object: Optional[GObject.Object], - callback: Optional[Callable[..., None]], + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ], + user_data: Optional[Any], error: GLib.Error, - *user_data: Any, ) -> SimpleAsyncResult: ... def propagate_error(self) -> bool: ... def set_check_cancellable( @@ -5580,6 +9716,34 @@ class SimpleAsyncResult(GObject.Object, AsyncResult): class SimpleAsyncResultClass(GObject.GPointer): ... class SimpleIOStream(IOStream): + """ + :Constructors: + + :: + + SimpleIOStream(**properties) + new(input_stream:Gio.InputStream, output_stream:Gio.OutputStream) -> Gio.IOStream + + Object GSimpleIOStream + + Properties from GSimpleIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + class Props: input_stream: InputStream output_stream: OutputStream @@ -5594,6 +9758,28 @@ class SimpleIOStream(IOStream): ) -> SimpleIOStream: ... class SimplePermission(Permission): + """ + :Constructors: + + :: + + SimplePermission(**properties) + new(allowed:bool) -> Gio.Permission + + Object GSimplePermission + + Properties from GPermission: + allowed -> gboolean: Is allowed + If the caller is allowed to perform the action + can-acquire -> gboolean: Can acquire + If calling g_permission_acquire() makes sense + can-release -> gboolean: Can release + If calling g_permission_release() makes sense + + Signals from GObject: + notify (GParam) + """ + class Props: allowed: bool can_acquire: bool @@ -5603,13 +9789,34 @@ class SimplePermission(Permission): def new(cls, allowed: bool) -> SimplePermission: ... class SimpleProxyResolver(GObject.Object, ProxyResolver): + """ + :Constructors: + + :: + + SimpleProxyResolver(**properties) + + Object GSimpleProxyResolver + + Properties from GSimpleProxyResolver: + default-proxy -> gchararray: Default proxy + The default proxy URI + ignore-hosts -> GStrv: Ignore hosts + Hosts that will not use the proxy + + Signals from GObject: + notify (GParam) + """ + class Props: - default_proxy: str + default_proxy: Optional[str] ignore_hosts: list[str] props: Props = ... parent_instance: GObject.Object = ... priv: SimpleProxyResolverPrivate = ... - def __init__(self, default_proxy: str = ..., ignore_hosts: Sequence[str] = ...): ... + def __init__( + self, default_proxy: Optional[str] = ..., ignore_hosts: Sequence[str] = ... + ): ... @staticmethod def new( default_proxy: Optional[str] = None, @@ -5620,16 +9827,69 @@ class SimpleProxyResolver(GObject.Object, ProxyResolver): def set_uri_proxy(self, uri_scheme: str, proxy: str) -> None: ... class SimpleProxyResolverClass(GObject.GPointer): + """ + :Constructors: + + :: + + SimpleProxyResolverClass() + """ + parent_class: GObject.ObjectClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class SimpleProxyResolverPrivate(GObject.GPointer): ... class Socket(GObject.Object, DatagramBased, Initable): + """ + :Constructors: + + :: + + Socket(**properties) + new(family:Gio.SocketFamily, type:Gio.SocketType, protocol:Gio.SocketProtocol) -> Gio.Socket + new_from_fd(fd:int) -> Gio.Socket + + Object GSocket + + Properties from GSocket: + family -> GSocketFamily: Socket family + The sockets address family + type -> GSocketType: Socket type + The sockets type + protocol -> GSocketProtocol: Socket protocol + The id of the protocol to use, or -1 for unknown + fd -> gint: File descriptor + The sockets file descriptor + blocking -> gboolean: blocking + Whether or not I/O on this socket is blocking + listen-backlog -> gint: Listen backlog + Outstanding connections in the listen queue + keepalive -> gboolean: Keep connection alive + Keep connection alive by sending periodic pings + local-address -> GSocketAddress: Local address + The local address the socket is bound to + remote-address -> GSocketAddress: Remote address + The remote address the socket is connected to + timeout -> guint: Timeout + The timeout in seconds on socket I/O + ttl -> guint: TTL + Time-to-live of outgoing unicast packets + broadcast -> gboolean: Broadcast + Whether to allow sending to broadcast addresses + multicast-loopback -> gboolean: Multicast loopback + Whether outgoing multicast packets loop back to the local host + multicast-ttl -> guint: Multicast TTL + Time-to-live of outgoing multicast packets + + Signals from GObject: + notify (GParam) + """ + class Props: blocking: bool broadcast: bool @@ -5794,26 +10054,65 @@ class Socket(GObject.Object, DatagramBased, Initable): def speaks_ipv4(self) -> bool: ... class SocketAddress(GObject.Object, SocketConnectable): + """ + :Constructors: + + :: + + SocketAddress(**properties) + new_from_native(native, len:int) -> Gio.SocketAddress + + Object GSocketAddress + + Properties from GSocketAddress: + family -> GSocketFamily: Address family + The family of the socket address + + Signals from GObject: + notify (GParam) + """ + class Props: family: SocketFamily props: Props = ... parent_instance: GObject.Object = ... def do_get_family(self) -> SocketFamily: ... def do_get_native_size(self) -> int: ... - def do_to_native(self, dest: None, destlen: int) -> bool: ... + def do_to_native(self, dest: Optional[Any], destlen: int) -> bool: ... def get_family(self) -> SocketFamily: ... def get_native_size(self) -> int: ... @classmethod - def new_from_native(cls, native: None, len: int) -> SocketAddress: ... - def to_native(self, dest: None, destlen: int) -> bool: ... + def new_from_native(cls, native: Any, len: int) -> SocketAddress: ... + def to_native(self, dest: Optional[Any], destlen: int) -> bool: ... class SocketAddressClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketAddressClass() + """ + parent_class: GObject.ObjectClass = ... get_family: Callable[[SocketAddress], SocketFamily] = ... get_native_size: Callable[[SocketAddress], int] = ... - to_native: Callable[[SocketAddress, None, int], bool] = ... + to_native: Callable[[SocketAddress, Optional[Any], int], bool] = ... class SocketAddressEnumerator(GObject.Object): + """ + :Constructors: + + :: + + SocketAddressEnumerator(**properties) + + Object GSocketAddressEnumerator + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... def do_next( self, cancellable: Optional[Cancellable] = None @@ -5821,7 +10120,9 @@ class SocketAddressEnumerator(GObject.Object): def do_next_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_next_finish(self, result: AsyncResult) -> Optional[SocketAddress]: ... @@ -5831,39 +10132,106 @@ class SocketAddressEnumerator(GObject.Object): def next_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def next_finish(self, result: AsyncResult) -> Optional[SocketAddress]: ... class SocketAddressEnumeratorClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketAddressEnumeratorClass() + """ + parent_class: GObject.ObjectClass = ... next: Callable[ [SocketAddressEnumerator, Optional[Cancellable]], Optional[SocketAddress] ] = ... - next_async: Callable[..., None] = ... + next_async: Callable[ + Concatenate[ + SocketAddressEnumerator, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... next_finish: Callable[ [SocketAddressEnumerator, AsyncResult], Optional[SocketAddress] ] = ... class SocketClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketClass() + """ + parent_class: GObject.ObjectClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... - _g_reserved7: None = ... - _g_reserved8: None = ... - _g_reserved9: None = ... - _g_reserved10: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... + _g_reserved7: Any = ... + _g_reserved8: Any = ... + _g_reserved9: Any = ... + _g_reserved10: Any = ... class SocketClient(GObject.Object): + """ + :Constructors: + + :: + + SocketClient(**properties) + new() -> Gio.SocketClient + + Object GSocketClient + + Signals from GSocketClient: + event (GSocketClientEvent, GSocketConnectable, GIOStream) + + Properties from GSocketClient: + family -> GSocketFamily: Socket family + The sockets address family to use for socket construction + type -> GSocketType: Socket type + The sockets type to use for socket construction + protocol -> GSocketProtocol: Socket protocol + The protocol to use for socket construction, or 0 for default + local-address -> GSocketAddress: Local address + The local address constructed sockets will be bound to + timeout -> guint: Socket timeout + The I/O timeout for sockets, or 0 for none + enable-proxy -> gboolean: Enable proxy + Enable proxy support + tls -> gboolean: TLS + Whether to create TLS connections + tls-validation-flags -> GTlsCertificateFlags: TLS validation flags + TLS validation flags to use + proxy-resolver -> GProxyResolver: Proxy resolver + The proxy resolver to use + + Signals from GObject: + notify (GParam) + """ + class Props: enable_proxy: bool family: SocketFamily - local_address: SocketAddress + local_address: Optional[SocketAddress] protocol: SocketProtocol proxy_resolver: ProxyResolver timeout: int @@ -5877,9 +10245,9 @@ class SocketClient(GObject.Object): self, enable_proxy: bool = ..., family: SocketFamily = ..., - local_address: SocketAddress = ..., + local_address: Optional[SocketAddress] = ..., protocol: SocketProtocol = ..., - proxy_resolver: ProxyResolver = ..., + proxy_resolver: Optional[ProxyResolver] = ..., timeout: int = ..., tls: bool = ..., tls_validation_flags: TlsCertificateFlags = ..., @@ -5893,7 +10261,9 @@ class SocketClient(GObject.Object): self, connectable: SocketConnectable, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def connect_finish(self, result: AsyncResult) -> SocketConnection: ... @@ -5908,7 +10278,9 @@ class SocketClient(GObject.Object): host_and_port: str, default_port: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def connect_to_host_finish(self, result: AsyncResult) -> SocketConnection: ... @@ -5920,7 +10292,9 @@ class SocketClient(GObject.Object): domain: str, service: str, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def connect_to_service_finish(self, result: AsyncResult) -> SocketConnection: ... @@ -5932,7 +10306,9 @@ class SocketClient(GObject.Object): uri: str, default_port: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def connect_to_uri_finish(self, result: AsyncResult) -> SocketConnection: ... @@ -5966,29 +10342,77 @@ class SocketClient(GObject.Object): def set_tls_validation_flags(self, flags: TlsCertificateFlags) -> None: ... class SocketClientClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketClientClass() + """ + parent_class: GObject.ObjectClass = ... event: Callable[ [SocketClient, SocketClientEvent, SocketConnectable, IOStream], None ] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... class SocketClientPrivate(GObject.GPointer): ... class SocketConnectable(GObject.GInterface): + """ + Interface GSocketConnectable + + Signals from GObject: + notify (GParam) + """ + def enumerate(self) -> SocketAddressEnumerator: ... def proxy_enumerate(self) -> SocketAddressEnumerator: ... def to_string(self) -> str: ... class SocketConnectableIface(GObject.GPointer): + """ + :Constructors: + + :: + + SocketConnectableIface() + """ + g_iface: GObject.TypeInterface = ... enumerate: Callable[[SocketConnectable], SocketAddressEnumerator] = ... proxy_enumerate: Callable[[SocketConnectable], SocketAddressEnumerator] = ... to_string: Callable[[SocketConnectable], str] = ... class SocketConnection(IOStream): + """ + :Constructors: + + :: + + SocketConnection(**properties) + + Object GSocketConnection + + Properties from GSocketConnection: + socket -> GSocket: Socket + The underlying GSocket + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + class Props: socket: Socket closed: bool @@ -6005,7 +10429,9 @@ class SocketConnection(IOStream): self, address: SocketAddress, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def connect_finish(self, result: AsyncResult) -> bool: ... @@ -6023,48 +10449,98 @@ class SocketConnection(IOStream): def is_connected(self) -> bool: ... class SocketConnectionClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketConnectionClass() + """ + parent_class: IOStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... class SocketConnectionPrivate(GObject.GPointer): ... class SocketControlMessage(GObject.Object): + """ + :Constructors: + + :: + + SocketControlMessage(**properties) + + Object GSocketControlMessage + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: SocketControlMessagePrivate = ... @staticmethod def deserialize( - level: int, type: int, size: int, data: Sequence[int] - ) -> SocketControlMessage: ... + level: int, type: int, data: Sequence[int] + ) -> Optional[SocketControlMessage]: ... def do_get_level(self) -> int: ... def do_get_size(self) -> int: ... def do_get_type(self) -> int: ... - def do_serialize(self, data: None) -> None: ... + def do_serialize(self, data: Any) -> None: ... def get_level(self) -> int: ... def get_msg_type(self) -> int: ... def get_size(self) -> int: ... - def serialize(self, data: None) -> None: ... + def serialize(self, data: Any) -> None: ... class SocketControlMessageClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketControlMessageClass() + """ + parent_class: GObject.ObjectClass = ... get_size: Callable[[SocketControlMessage], int] = ... get_level: Callable[[SocketControlMessage], int] = ... get_type: Callable[[SocketControlMessage], int] = ... - serialize: Callable[[SocketControlMessage, None], None] = ... - deserialize: None = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + serialize: Callable[[SocketControlMessage, Any], None] = ... + deserialize: Any = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class SocketControlMessagePrivate(GObject.GPointer): ... class SocketListener(GObject.Object): + """ + :Constructors: + + :: + + SocketListener(**properties) + new() -> Gio.SocketListener + + Object GSocketListener + + Signals from GSocketListener: + event (GSocketListenerEvent, GSocket) + + Properties from GSocketListener: + listen-backlog -> gint: Listen backlog + outstanding connections in the listen queue + + Signals from GObject: + notify (GParam) + """ + class Props: listen_backlog: int props: Props = ... @@ -6077,7 +10553,9 @@ class SocketListener(GObject.Object): def accept_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def accept_finish( @@ -6089,7 +10567,9 @@ class SocketListener(GObject.Object): def accept_socket_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def accept_socket_finish( @@ -6119,19 +10599,55 @@ class SocketListener(GObject.Object): def set_backlog(self, listen_backlog: int) -> None: ... class SocketListenerClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketListenerClass() + """ + parent_class: GObject.ObjectClass = ... changed: Callable[[SocketListener], None] = ... event: Callable[[SocketListener, SocketListenerEvent, Socket], None] = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... class SocketListenerPrivate(GObject.GPointer): ... class SocketPrivate(GObject.GPointer): ... class SocketService(SocketListener): + """ + :Constructors: + + :: + + SocketService(**properties) + new() -> Gio.SocketService + + Object GSocketService + + Signals from GSocketService: + incoming (GSocketConnection, GObject) -> gboolean + + Properties from GSocketService: + active -> gboolean: Active + Whether the service is currently accepting connections + + Signals from GSocketListener: + event (GSocketListenerEvent, GSocket) + + Properties from GSocketListener: + listen-backlog -> gint: Listen backlog + outstanding connections in the listen queue + + Signals from GObject: + notify (GParam) + """ + class Props: active: bool listen_backlog: int @@ -6149,18 +10665,34 @@ class SocketService(SocketListener): def stop(self) -> None: ... class SocketServiceClass(GObject.GPointer): + """ + :Constructors: + + :: + + SocketServiceClass() + """ + parent_class: SocketListenerClass = ... incoming: Callable[[SocketService, SocketConnection, GObject.Object], bool] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... class SocketServicePrivate(GObject.GPointer): ... class SrvTarget(GObject.GBoxed): + """ + :Constructors: + + :: + + new(hostname:str, port:int, priority:int, weight:int) -> Gio.SrvTarget + """ + def copy(self) -> SrvTarget: ... def free(self) -> None: ... def get_hostname(self) -> str: ... @@ -6171,16 +10703,44 @@ class SrvTarget(GObject.GBoxed): def new(cls, hostname: str, port: int, priority: int, weight: int) -> SrvTarget: ... class StaticResource(GObject.GPointer): + """ + :Constructors: + + :: + + StaticResource() + """ + data: int = ... data_len: int = ... resource: Resource = ... next: StaticResource = ... - padding: None = ... + padding: Any = ... def fini(self) -> None: ... def get_resource(self) -> Resource: ... def init(self) -> None: ... class Subprocess(GObject.Object, Initable): + """ + :Constructors: + + :: + + Subprocess(**properties) + new(argv:list, flags:Gio.SubprocessFlags) -> Gio.Subprocess + + Object GSubprocess + + Properties from GSubprocess: + flags -> GSubprocessFlags: Flags + Subprocess flags + argv -> GStrv: Arguments + Argument vector + + Signals from GObject: + notify (GParam) + """ + class Props: argv: list[str] flags: SubprocessFlags @@ -6195,7 +10755,9 @@ class Subprocess(GObject.Object, Initable): self, stdin_buf: Optional[GLib.Bytes] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def communicate_finish( @@ -6208,7 +10770,9 @@ class Subprocess(GObject.Object, Initable): self, stdin_buf: Optional[str] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def communicate_utf8_finish(self, result: AsyncResult) -> Tuple[bool, str, str]: ... @@ -6230,20 +10794,42 @@ class Subprocess(GObject.Object, Initable): def wait_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def wait_check(self, cancellable: Optional[Cancellable] = None) -> bool: ... def wait_check_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def wait_check_finish(self, result: AsyncResult) -> bool: ... def wait_finish(self, result: AsyncResult) -> bool: ... class SubprocessLauncher(GObject.Object): + """ + :Constructors: + + :: + + SubprocessLauncher(**properties) + new(flags:Gio.SubprocessFlags) -> Gio.SubprocessLauncher + + Object GSubprocessLauncher + + Properties from GSubprocessLauncher: + flags -> GSubprocessFlags: Flags + GSubprocessFlags for launched processes + + Signals from GObject: + notify (GParam) + """ + class Props: flags: SubprocessFlags props: Props = ... @@ -6267,10 +10853,28 @@ class SubprocessLauncher(GObject.Object): def unsetenv(self, variable: str) -> None: ... class Task(GObject.Object, AsyncResult): + """ + :Constructors: + + :: + + Task(**properties) + new(source_object:GObject.Object=None, cancellable:Gio.Cancellable=None, callback:Gio.AsyncReadyCallback=None, callback_data=None) -> Gio.Task + + Object GTask + + Properties from GTask: + completed -> gboolean: Task completed + Whether the task has completed yet + + Signals from GObject: + notify (GParam) + """ + class Props: completed: bool props: Props = ... - def get_cancellable(self) -> Cancellable: ... + def get_cancellable(self) -> Optional[Cancellable]: ... def get_check_cancellable(self) -> bool: ... def get_completed(self) -> bool: ... def get_context(self) -> GLib.MainContext: ... @@ -6290,7 +10894,9 @@ class Task(GObject.Object, AsyncResult): cls, source_object: Optional[GObject.Object] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *callback_data: Any, ) -> Task: ... def propagate_boolean(self) -> bool: ... @@ -6300,41 +10906,79 @@ class Task(GObject.Object, AsyncResult): @staticmethod def report_error( source_object: Optional[GObject.Object], - callback: Optional[Callable[..., None]], - source_tag: None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ], + callback_data: Optional[Any], + source_tag: Optional[Any], error: GLib.Error, - *callback_data: Any, ) -> None: ... def return_boolean(self, result: bool) -> None: ... def return_error(self, error: GLib.Error) -> None: ... def return_error_if_cancelled(self) -> bool: ... def return_int(self, result: int) -> None: ... def return_pointer( - self, result: None, result_destroy: Optional[Callable[[None], None]] = None + self, + result: Optional[Any] = None, + result_destroy: Optional[Callable[[Optional[Any]], None]] = None, ) -> None: ... def return_value(self, result: Optional[Any] = None) -> None: ... def run_in_thread( self, - task_func: Callable[[Task, GObject.Object, None, Optional[Cancellable]], None], + task_func: Callable[ + [Task, GObject.Object, Optional[Any], Optional[Cancellable]], None + ], ) -> None: ... def run_in_thread_sync( self, - task_func: Callable[[Task, GObject.Object, None, Optional[Cancellable]], None], + task_func: Callable[ + [Task, GObject.Object, Optional[Any], Optional[Cancellable]], None + ], ) -> None: ... def set_check_cancellable(self, check_cancellable: bool) -> None: ... def set_name(self, name: Optional[str] = None) -> None: ... def set_priority(self, priority: int) -> None: ... def set_return_on_cancel(self, return_on_cancel: bool) -> bool: ... - def set_source_tag(self, source_tag: None) -> None: ... + def set_source_tag(self, source_tag: Optional[Any] = None) -> None: ... + def set_static_name(self, name: Optional[str] = None) -> None: ... def set_task_data( self, - task_data: None, - task_data_destroy: Optional[Callable[[None], None]] = None, + task_data: Optional[Any] = None, + task_data_destroy: Optional[Callable[[Optional[Any]], None]] = None, ) -> None: ... class TaskClass(GObject.GPointer): ... class TcpConnection(SocketConnection): + """ + :Constructors: + + :: + + TcpConnection(**properties) + + Object GTcpConnection + + Properties from GTcpConnection: + graceful-disconnect -> gboolean: Graceful Disconnect + Whether or not close does a graceful disconnect + + Properties from GSocketConnection: + socket -> GSocket: Socket + The underlying GSocket + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + class Props: graceful_disconnect: bool socket: Socket @@ -6349,11 +10993,53 @@ class TcpConnection(SocketConnection): def set_graceful_disconnect(self, graceful_disconnect: bool) -> None: ... class TcpConnectionClass(GObject.GPointer): + """ + :Constructors: + + :: + + TcpConnectionClass() + """ + parent_class: SocketConnectionClass = ... class TcpConnectionPrivate(GObject.GPointer): ... class TcpWrapperConnection(TcpConnection): + """ + :Constructors: + + :: + + TcpWrapperConnection(**properties) + new(base_io_stream:Gio.IOStream, socket:Gio.Socket) -> Gio.SocketConnection + + Object GTcpWrapperConnection + + Properties from GTcpWrapperConnection: + base-io-stream -> GIOStream: Base IO Stream + The wrapped GIOStream + + Properties from GTcpConnection: + graceful-disconnect -> gboolean: Graceful Disconnect + Whether or not close does a graceful disconnect + + Properties from GSocketConnection: + socket -> GSocket: Socket + The underlying GSocket + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + class Props: base_io_stream: IOStream graceful_disconnect: bool @@ -6375,11 +11061,37 @@ class TcpWrapperConnection(TcpConnection): def new(cls, base_io_stream: IOStream, socket: Socket) -> TcpWrapperConnection: ... class TcpWrapperConnectionClass(GObject.GPointer): + """ + :Constructors: + + :: + + TcpWrapperConnectionClass() + """ + parent_class: TcpConnectionClass = ... class TcpWrapperConnectionPrivate(GObject.GPointer): ... class TestDBus(GObject.Object): + """ + :Constructors: + + :: + + TestDBus(**properties) + new(flags:Gio.TestDBusFlags) -> Gio.TestDBus + + Object GTestDBus + + Properties from GTestDBus: + flags -> GTestDBusFlags: D-Bus session flags + Flags specifying the behaviour of the D-Bus session + + Signals from GObject: + notify (GParam) + """ + class Props: flags: TestDBusFlags props: Props = ... @@ -6396,10 +11108,34 @@ class TestDBus(GObject.Object): def up(self) -> None: ... class ThemedIcon(GObject.Object, Icon): + """ + :Constructors: + + :: + + ThemedIcon(**properties) + new(iconname:str) -> Gio.ThemedIcon + new_from_names(iconnames:list) -> Gio.ThemedIcon + new_with_default_fallbacks(iconname:str) -> Gio.ThemedIcon + + Object GThemedIcon + + Properties from GThemedIcon: + name -> gchararray: name + The name of the icon + names -> GStrv: names + An array containing the icon names + use-default-fallbacks -> gboolean: use default fallbacks + Whether to use default fallbacks found by shortening the name at “-” characters. Ignores names after the first if multiple names are given. + + Signals from GObject: + notify (GParam) + """ + class Props: - name: str names: list[str] use_default_fallbacks: bool + name: str props: Props = ... def __init__( self, @@ -6420,6 +11156,41 @@ class ThemedIcon(GObject.Object, Icon): class ThemedIconClass(GObject.GPointer): ... class ThreadedSocketService(SocketService): + """ + :Constructors: + + :: + + ThreadedSocketService(**properties) + new(max_threads:int) -> Gio.SocketService + + Object GThreadedSocketService + + Signals from GThreadedSocketService: + run (GSocketConnection, GObject) -> gboolean + + Properties from GThreadedSocketService: + max-threads -> gint: Max threads + The max number of threads handling clients for this service + + Signals from GSocketService: + incoming (GSocketConnection, GObject) -> gboolean + + Properties from GSocketService: + active -> gboolean: Active + Whether the service is currently accepting connections + + Signals from GSocketListener: + event (GSocketListenerEvent, GSocket) + + Properties from GSocketListener: + listen-backlog -> gint: Listen backlog + outstanding connections in the listen queue + + Signals from GObject: + notify (GParam) + """ + class Props: max_threads: int active: bool @@ -6437,17 +11208,32 @@ class ThreadedSocketService(SocketService): def new(cls, max_threads: int) -> ThreadedSocketService: ... class ThreadedSocketServiceClass(GObject.GPointer): + """ + :Constructors: + + :: + + ThreadedSocketServiceClass() + """ + parent_class: SocketServiceClass = ... run: Callable[[ThreadedSocketService, SocketConnection, GObject.Object], bool] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class ThreadedSocketServicePrivate(GObject.GPointer): ... class TlsBackend(GObject.GInterface): + """ + Interface GTlsBackend + + Signals from GObject: + notify (GParam) + """ + def get_certificate_type(self) -> Type: ... def get_client_connection_type(self) -> Type: ... @staticmethod @@ -6462,6 +11248,14 @@ class TlsBackend(GObject.GInterface): def supports_tls(self) -> bool: ... class TlsBackendInterface(GObject.GPointer): + """ + :Constructors: + + :: + + TlsBackendInterface() + """ + g_iface: GObject.TypeInterface = ... supports_tls: Callable[[TlsBackend], bool] = ... get_certificate_type: Callable[[], Type] = ... @@ -6474,22 +11268,73 @@ class TlsBackendInterface(GObject.GPointer): get_dtls_server_connection_type: Callable[[], Type] = ... class TlsCertificate(GObject.Object): + """ + :Constructors: + + :: + + TlsCertificate(**properties) + new_from_file(file:str) -> Gio.TlsCertificate + new_from_file_with_password(file:str, password:str) -> Gio.TlsCertificate + new_from_files(cert_file:str, key_file:str) -> Gio.TlsCertificate + new_from_pem(data:str, length:int) -> Gio.TlsCertificate + new_from_pkcs11_uris(pkcs11_uri:str, private_key_pkcs11_uri:str=None) -> Gio.TlsCertificate + new_from_pkcs12(data:list, password:str=None) -> Gio.TlsCertificate + + Object GTlsCertificate + + Properties from GTlsCertificate: + certificate -> GByteArray: Certificate + The DER representation of the certificate + certificate-pem -> gchararray: Certificate (PEM) + The PEM representation of the certificate + private-key -> GByteArray: Private key + The DER representation of the certificate’s private key + private-key-pem -> gchararray: Private key (PEM) + The PEM representation of the certificate’s private key + issuer -> GTlsCertificate: Issuer + The certificate for the issuing entity + pkcs11-uri -> gchararray: PKCS #11 URI + The PKCS #11 URI + private-key-pkcs11-uri -> gchararray: PKCS #11 URI + The PKCS #11 URI for a private key + not-valid-before -> GDateTime: Not Valid Before + Cert should not be considered valid before this time. + not-valid-after -> GDateTime: Not Valid after + Cert should not be considered valid after this time. + subject-name -> gchararray: Subject Name + The subject name from the certificate. + issuer-name -> gchararray: Issuer Name + The issuer from the certificate. + dns-names -> GPtrArray: DNS Names + DNS Names listed on the cert. + ip-addresses -> GPtrArray: IP Addresses + IP Addresses listed on the cert. + pkcs12-data -> GByteArray: PKCS #12 data + The PKCS #12 data used for construction + password -> gchararray: Password + Password used when constructing from bytes + + Signals from GObject: + notify (GParam) + """ + class Props: certificate: bytes certificate_pem: str - dns_names: list[None] - ip_addresses: list[None] - issuer: TlsCertificate - issuer_name: str - not_valid_after: GLib.DateTime - not_valid_before: GLib.DateTime - password: str + dns_names: Optional[list[Any]] + ip_addresses: Optional[list[Any]] + issuer: Optional[TlsCertificate] + issuer_name: Optional[str] + not_valid_after: Optional[GLib.DateTime] + not_valid_before: Optional[GLib.DateTime] pkcs11_uri: str - pkcs12_data: bytes private_key: bytes private_key_pem: str private_key_pkcs11_uri: str - subject_name: str + subject_name: Optional[str] + password: str + pkcs12_data: bytes props: Props = ... parent_instance: GObject.Object = ... priv: TlsCertificatePrivate = ... @@ -6545,16 +11390,31 @@ class TlsCertificate(GObject.Object): ) -> TlsCertificateFlags: ... class TlsCertificateClass(GObject.GPointer): + """ + :Constructors: + + :: + + TlsCertificateClass() + """ + parent_class: GObject.ObjectClass = ... verify: Callable[ [TlsCertificate, Optional[SocketConnectable], Optional[TlsCertificate]], TlsCertificateFlags, ] = ... - padding: list[None] = ... + padding: list[Any] = ... class TlsCertificatePrivate(GObject.GPointer): ... class TlsClientConnection(GObject.GInterface): + """ + Interface GTlsClientConnection + + Signals from GObject: + notify (GParam) + """ + def copy_session_state(self, source: TlsClientConnection) -> None: ... def get_accepted_cas(self) -> list[Sequence[int]]: ... def get_server_identity(self) -> Optional[SocketConnectable]: ... @@ -6569,19 +11429,79 @@ class TlsClientConnection(GObject.GInterface): def set_validation_flags(self, flags: TlsCertificateFlags) -> None: ... class TlsClientConnectionInterface(GObject.GPointer): + """ + :Constructors: + + :: + + TlsClientConnectionInterface() + """ + g_iface: GObject.TypeInterface = ... copy_session_state: Callable[[TlsClientConnection, TlsClientConnection], None] = ... class TlsConnection(IOStream): + """ + :Constructors: + + :: + + TlsConnection(**properties) + + Object GTlsConnection + + Signals from GTlsConnection: + accept-certificate (GTlsCertificate, GTlsCertificateFlags) -> gboolean + + Properties from GTlsConnection: + base-io-stream -> GIOStream: Base IOStream + The GIOStream that the connection wraps + require-close-notify -> gboolean: Require close notify + Whether to require proper TLS close notification + rehandshake-mode -> GTlsRehandshakeMode: Rehandshake mode + When to allow rehandshaking + use-system-certdb -> gboolean: Use system certificate database + Whether to verify peer certificates against the system certificate database + database -> GTlsDatabase: Database + Certificate database to use for looking up or verifying certificates + interaction -> GTlsInteraction: Interaction + Optional object for user interaction + certificate -> GTlsCertificate: Certificate + The connection’s certificate + peer-certificate -> GTlsCertificate: Peer Certificate + The connection’s peer’s certificate + peer-certificate-errors -> GTlsCertificateFlags: Peer Certificate Errors + Errors found with the peer’s certificate + advertised-protocols -> GStrv: Advertised Protocols + Application-layer protocols available on this connection + negotiated-protocol -> gchararray: Negotiated Protocol + Application-layer protocol negotiated for this connection + protocol-version -> GTlsProtocolVersion: Protocol Version + TLS protocol version negotiated for this connection + ciphersuite-name -> gchararray: Ciphersuite Name + Name of ciphersuite negotiated for this connection + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + class Props: - advertised_protocols: list[str] + advertised_protocols: Optional[list[str]] base_io_stream: IOStream - certificate: TlsCertificate - ciphersuite_name: str - database: TlsDatabase - interaction: TlsInteraction - negotiated_protocol: str - peer_certificate: TlsCertificate + certificate: Optional[TlsCertificate] + ciphersuite_name: Optional[str] + database: Optional[TlsDatabase] + interaction: Optional[TlsInteraction] + negotiated_protocol: Optional[str] + peer_certificate: Optional[TlsCertificate] peer_certificate_errors: TlsCertificateFlags protocol_version: TlsProtocolVersion rehandshake_mode: TlsRehandshakeMode @@ -6595,11 +11515,11 @@ class TlsConnection(IOStream): priv: TlsConnectionPrivate = ... def __init__( self, - advertised_protocols: Sequence[str] = ..., + advertised_protocols: Optional[Sequence[str]] = ..., base_io_stream: IOStream = ..., certificate: TlsCertificate = ..., - database: TlsDatabase = ..., - interaction: TlsInteraction = ..., + database: Optional[TlsDatabase] = ..., + interaction: Optional[TlsInteraction] = ..., rehandshake_mode: TlsRehandshakeMode = ..., require_close_notify: bool = ..., use_system_certdb: bool = ..., @@ -6616,7 +11536,9 @@ class TlsConnection(IOStream): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_handshake_finish(self, result: AsyncResult) -> bool: ... @@ -6642,7 +11564,9 @@ class TlsConnection(IOStream): self, io_priority: int, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def handshake_finish(self, result: AsyncResult) -> bool: ... @@ -6657,22 +11581,56 @@ class TlsConnection(IOStream): def set_use_system_certdb(self, use_system_certdb: bool) -> None: ... class TlsConnectionClass(GObject.GPointer): + """ + :Constructors: + + :: + + TlsConnectionClass() + """ + parent_class: IOStreamClass = ... accept_certificate: Callable[ [TlsConnection, TlsCertificate, TlsCertificateFlags], bool ] = ... handshake: Callable[[TlsConnection, Optional[Cancellable]], bool] = ... - handshake_async: Callable[..., None] = ... + handshake_async: Callable[ + Concatenate[ + TlsConnection, + int, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... handshake_finish: Callable[[TlsConnection, AsyncResult], bool] = ... get_binding_data: Callable[ [TlsConnection, TlsChannelBindingType, Sequence[int]], bool ] = ... get_negotiated_protocol: Callable[[TlsConnection], Optional[str]] = ... - padding: list[None] = ... + padding: list[Any] = ... class TlsConnectionPrivate(GObject.GPointer): ... class TlsDatabase(GObject.Object): + """ + :Constructors: + + :: + + TlsDatabase(**properties) + + Object GTlsDatabase + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: TlsDatabasePrivate = ... def create_certificate_handle( @@ -6694,7 +11652,9 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_certificate_for_handle_finish( @@ -6713,7 +11673,9 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_certificate_issuer_finish( @@ -6732,7 +11694,9 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_lookup_certificates_issued_by_finish( @@ -6755,7 +11719,9 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseVerifyFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_verify_chain_finish(self, result: AsyncResult) -> TlsCertificateFlags: ... @@ -6772,7 +11738,9 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_certificate_for_handle_finish( @@ -6791,7 +11759,9 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_certificate_issuer_finish( @@ -6810,7 +11780,9 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseLookupFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def lookup_certificates_issued_by_finish( @@ -6833,12 +11805,22 @@ class TlsDatabase(GObject.Object): interaction: Optional[TlsInteraction], flags: TlsDatabaseVerifyFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def verify_chain_finish(self, result: AsyncResult) -> TlsCertificateFlags: ... class TlsDatabaseClass(GObject.GPointer): + """ + :Constructors: + + :: + + TlsDatabaseClass() + """ + parent_class: GObject.ObjectClass = ... verify_chain: Callable[ [ @@ -6852,7 +11834,24 @@ class TlsDatabaseClass(GObject.GPointer): ], TlsCertificateFlags, ] = ... - verify_chain_async: Callable[..., None] = ... + verify_chain_async: Callable[ + Concatenate[ + TlsDatabase, + TlsCertificate, + str, + Optional[SocketConnectable], + Optional[TlsInteraction], + TlsDatabaseVerifyFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... verify_chain_finish: Callable[[TlsDatabase, AsyncResult], TlsCertificateFlags] = ... create_certificate_handle: Callable[ [TlsDatabase, TlsCertificate], Optional[str] @@ -6867,7 +11866,22 @@ class TlsDatabaseClass(GObject.GPointer): ], Optional[TlsCertificate], ] = ... - lookup_certificate_for_handle_async: Callable[..., None] = ... + lookup_certificate_for_handle_async: Callable[ + Concatenate[ + TlsDatabase, + str, + Optional[TlsInteraction], + TlsDatabaseLookupFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_certificate_for_handle_finish: Callable[ [TlsDatabase, AsyncResult], TlsCertificate ] = ... @@ -6881,7 +11895,22 @@ class TlsDatabaseClass(GObject.GPointer): ], TlsCertificate, ] = ... - lookup_certificate_issuer_async: Callable[..., None] = ... + lookup_certificate_issuer_async: Callable[ + Concatenate[ + TlsDatabase, + TlsCertificate, + Optional[TlsInteraction], + TlsDatabaseLookupFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_certificate_issuer_finish: Callable[ [TlsDatabase, AsyncResult], TlsCertificate ] = ... @@ -6895,23 +11924,66 @@ class TlsDatabaseClass(GObject.GPointer): ], list[TlsCertificate], ] = ... - lookup_certificates_issued_by_async: Callable[..., None] = ... + lookup_certificates_issued_by_async: Callable[ + Concatenate[ + TlsDatabase, + Sequence[int], + Optional[TlsInteraction], + TlsDatabaseLookupFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... lookup_certificates_issued_by_finish: Callable[ [TlsDatabase, AsyncResult], list[TlsCertificate] ] = ... - padding: list[None] = ... + padding: list[Any] = ... class TlsDatabasePrivate(GObject.GPointer): ... class TlsFileDatabase(GObject.GInterface): + """ + Interface GTlsFileDatabase + + Signals from GObject: + notify (GParam) + """ + @staticmethod def new(anchors: str) -> TlsFileDatabase: ... class TlsFileDatabaseInterface(GObject.GPointer): + """ + :Constructors: + + :: + + TlsFileDatabaseInterface() + """ + g_iface: GObject.TypeInterface = ... - padding: list[None] = ... + padding: list[Any] = ... class TlsInteraction(GObject.Object): + """ + :Constructors: + + :: + + TlsInteraction(**properties) + + Object GTlsInteraction + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: TlsInteractionPrivate = ... def ask_password( @@ -6921,7 +11993,9 @@ class TlsInteraction(GObject.Object): self, password: TlsPassword, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def ask_password_finish(self, result: AsyncResult) -> TlsInteractionResult: ... @@ -6932,7 +12006,9 @@ class TlsInteraction(GObject.Object): self, password: TlsPassword, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_ask_password_finish(self, result: AsyncResult) -> TlsInteractionResult: ... @@ -6947,7 +12023,9 @@ class TlsInteraction(GObject.Object): connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def do_request_certificate_finish( @@ -6973,7 +12051,9 @@ class TlsInteraction(GObject.Object): connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def request_certificate_finish( @@ -6981,11 +12061,32 @@ class TlsInteraction(GObject.Object): ) -> TlsInteractionResult: ... class TlsInteractionClass(GObject.GPointer): + """ + :Constructors: + + :: + + TlsInteractionClass() + """ + parent_class: GObject.ObjectClass = ... ask_password: Callable[ [TlsInteraction, TlsPassword, Optional[Cancellable]], TlsInteractionResult ] = ... - ask_password_async: Callable[..., None] = ... + ask_password_async: Callable[ + Concatenate[ + TlsInteraction, + TlsPassword, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... ask_password_finish: Callable[ [TlsInteraction, AsyncResult], TlsInteractionResult ] = ... @@ -6998,15 +12099,51 @@ class TlsInteractionClass(GObject.GPointer): ], TlsInteractionResult, ] = ... - request_certificate_async: Callable[..., None] = ... + request_certificate_async: Callable[ + Concatenate[ + TlsInteraction, + TlsConnection, + TlsCertificateRequestFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... request_certificate_finish: Callable[ [TlsInteraction, AsyncResult], TlsInteractionResult ] = ... - padding: list[None] = ... + padding: list[Any] = ... class TlsInteractionPrivate(GObject.GPointer): ... class TlsPassword(GObject.Object): + """ + :Constructors: + + :: + + TlsPassword(**properties) + new(flags:Gio.TlsPasswordFlags, description:str) -> Gio.TlsPassword + + Object GTlsPassword + + Properties from GTlsPassword: + flags -> GTlsPasswordFlags: Flags + Flags about the password + description -> gchararray: Description + Description of what the password is for + warning -> gchararray: Warning + Warning about the password + + Signals from GObject: + notify (GParam) + """ + class Props: description: str flags: TlsPasswordFlags @@ -7020,7 +12157,9 @@ class TlsPassword(GObject.Object): def do_get_default_warning(self) -> str: ... def do_get_value(self) -> bytes: ... def do_set_value( - self, value: Sequence[int], destroy: Optional[Callable[[None], None]] = None + self, + value: Sequence[int], + destroy: Optional[Callable[[Optional[Any]], None]] = None, ) -> None: ... def get_description(self) -> str: ... def get_flags(self) -> TlsPasswordFlags: ... @@ -7032,31 +12171,81 @@ class TlsPassword(GObject.Object): def set_flags(self, flags: TlsPasswordFlags) -> None: ... def set_value(self, value: Sequence[int]) -> None: ... def set_value_full( - self, value: Sequence[int], destroy: Optional[Callable[[None], None]] = None + self, + value: Sequence[int], + destroy: Optional[Callable[[Optional[Any]], None]] = None, ) -> None: ... def set_warning(self, warning: str) -> None: ... class TlsPasswordClass(GObject.GPointer): + """ + :Constructors: + + :: + + TlsPasswordClass() + """ + parent_class: GObject.ObjectClass = ... get_value: Callable[[TlsPassword], bytes] = ... set_value: Callable[ - [TlsPassword, Sequence[int], Optional[Callable[[None], None]]], None + [TlsPassword, Sequence[int], Optional[Callable[[Optional[Any]], None]]], None ] = ... get_default_warning: Callable[[TlsPassword], str] = ... - padding: list[None] = ... + padding: list[Any] = ... class TlsPasswordPrivate(GObject.GPointer): ... class TlsServerConnection(GObject.GInterface): + """ + Interface GTlsServerConnection + + Signals from GObject: + notify (GParam) + """ + @staticmethod def new( base_io_stream: IOStream, certificate: Optional[TlsCertificate] = None ) -> TlsServerConnection: ... class TlsServerConnectionInterface(GObject.GPointer): + """ + :Constructors: + + :: + + TlsServerConnectionInterface() + """ + g_iface: GObject.TypeInterface = ... class UnixConnection(SocketConnection): + """ + :Constructors: + + :: + + UnixConnection(**properties) + + Object GUnixConnection + + Properties from GSocketConnection: + socket -> GSocket: Socket + The underlying GSocket + + Properties from GIOStream: + input-stream -> GInputStream: Input stream + The GInputStream to read from + output-stream -> GOutputStream: Output stream + The GOutputStream to write to + closed -> gboolean: Closed + Is the stream closed + + Signals from GObject: + notify (GParam) + """ + class Props: socket: Socket closed: bool @@ -7072,7 +12261,9 @@ class UnixConnection(SocketConnection): def receive_credentials_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def receive_credentials_finish(self, result: AsyncResult) -> Credentials: ... @@ -7081,18 +12272,47 @@ class UnixConnection(SocketConnection): def send_credentials_async( self, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def send_credentials_finish(self, result: AsyncResult) -> bool: ... def send_fd(self, fd: int, cancellable: Optional[Cancellable] = None) -> bool: ... class UnixConnectionClass(GObject.GPointer): + """ + :Constructors: + + :: + + UnixConnectionClass() + """ + parent_class: SocketConnectionClass = ... class UnixConnectionPrivate(GObject.GPointer): ... class UnixCredentialsMessage(SocketControlMessage): + """ + :Constructors: + + :: + + UnixCredentialsMessage(**properties) + new() -> Gio.SocketControlMessage + new_with_credentials(credentials:Gio.Credentials) -> Gio.SocketControlMessage + + Object GUnixCredentialsMessage + + Properties from GUnixCredentialsMessage: + credentials -> GCredentials: Credentials + The credentials stored in the message + + Signals from GObject: + notify (GParam) + """ + class Props: credentials: Credentials props: Props = ... @@ -7110,13 +12330,36 @@ class UnixCredentialsMessage(SocketControlMessage): ) -> UnixCredentialsMessage: ... class UnixCredentialsMessageClass(GObject.GPointer): + """ + :Constructors: + + :: + + UnixCredentialsMessageClass() + """ + parent_class: SocketControlMessageClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... class UnixCredentialsMessagePrivate(GObject.GPointer): ... class UnixFDList(GObject.Object): + """ + :Constructors: + + :: + + UnixFDList(**properties) + new() -> Gio.UnixFDList + new_from_array(fds:list) -> Gio.UnixFDList + + Object GUnixFDList + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... priv: UnixFDListPrivate = ... def append(self, fd: int) -> int: ... @@ -7130,16 +12373,43 @@ class UnixFDList(GObject.Object): def steal_fds(self) -> list[int]: ... class UnixFDListClass(GObject.GPointer): + """ + :Constructors: + + :: + + UnixFDListClass() + """ + parent_class: GObject.ObjectClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class UnixFDListPrivate(GObject.GPointer): ... class UnixFDMessage(SocketControlMessage): + """ + :Constructors: + + :: + + UnixFDMessage(**properties) + new() -> Gio.SocketControlMessage + new_with_fd_list(fd_list:Gio.UnixFDList) -> Gio.SocketControlMessage + + Object GUnixFDMessage + + Properties from GUnixFDMessage: + fd-list -> GUnixFDList: file descriptor list + The GUnixFDList object to send with the message + + Signals from GObject: + notify (GParam) + """ + class Props: fd_list: UnixFDList props: Props = ... @@ -7155,13 +12425,41 @@ class UnixFDMessage(SocketControlMessage): def steal_fds(self) -> list[int]: ... class UnixFDMessageClass(GObject.GPointer): + """ + :Constructors: + + :: + + UnixFDMessageClass() + """ + parent_class: SocketControlMessageClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... class UnixFDMessagePrivate(GObject.GPointer): ... class UnixInputStream(InputStream, FileDescriptorBased, PollableInputStream): + """ + :Constructors: + + :: + + UnixInputStream(**properties) + new(fd:int, close_fd:bool) -> Gio.InputStream + + Object GUnixInputStream + + Properties from GUnixInputStream: + fd -> gint: File descriptor + The file descriptor to read from + close-fd -> gboolean: Close file descriptor + Whether to close the file descriptor when the stream is closed + + Signals from GObject: + notify (GParam) + """ + class Props: close_fd: bool fd: int @@ -7176,17 +12474,43 @@ class UnixInputStream(InputStream, FileDescriptorBased, PollableInputStream): def set_close_fd(self, close_fd: bool) -> None: ... class UnixInputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + UnixInputStreamClass() + """ + parent_class: InputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class UnixInputStreamPrivate(GObject.GPointer): ... class UnixMountEntry(GObject.GBoxed): ... class UnixMountMonitor(GObject.Object): + """ + :Constructors: + + :: + + UnixMountMonitor(**properties) + new() -> Gio.UnixMountMonitor + + Object GUnixMountMonitor + + Signals from GUnixMountMonitor: + mounts-changed () + mountpoints-changed () + + Signals from GObject: + notify (GParam) + """ + @staticmethod def get() -> UnixMountMonitor: ... @classmethod @@ -7214,6 +12538,26 @@ class UnixMountPoint(GObject.GBoxed): def is_user_mountable(self) -> bool: ... class UnixOutputStream(OutputStream, FileDescriptorBased, PollableOutputStream): + """ + :Constructors: + + :: + + UnixOutputStream(**properties) + new(fd:int, close_fd:bool) -> Gio.OutputStream + + Object GUnixOutputStream + + Properties from GUnixOutputStream: + fd -> gint: File descriptor + The file descriptor to write to + close-fd -> gboolean: Close file descriptor + Whether to close the file descriptor when the stream is closed + + Signals from GObject: + notify (GParam) + """ + class Props: close_fd: bool fd: int @@ -7228,16 +12572,54 @@ class UnixOutputStream(OutputStream, FileDescriptorBased, PollableOutputStream): def set_close_fd(self, close_fd: bool) -> None: ... class UnixOutputStreamClass(GObject.GPointer): + """ + :Constructors: + + :: + + UnixOutputStreamClass() + """ + parent_class: OutputStreamClass = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... class UnixOutputStreamPrivate(GObject.GPointer): ... class UnixSocketAddress(SocketAddress, SocketConnectable): + """ + :Constructors: + + :: + + UnixSocketAddress(**properties) + new(path:str) -> Gio.SocketAddress + new_abstract(path:list) -> Gio.SocketAddress + new_with_type(path:list, type:Gio.UnixSocketAddressType) -> Gio.SocketAddress + + Object GUnixSocketAddress + + Properties from GUnixSocketAddress: + path -> gchararray: Path + UNIX socket path + path-as-array -> GByteArray: Path array + UNIX socket path, as byte array + abstract -> gboolean: Abstract + Whether or not this is an abstract address + address-type -> GUnixSocketAddressType: Address type + The type of UNIX socket address + + Properties from GSocketAddress: + family -> GSocketFamily: Address family + The family of the socket address + + Signals from GObject: + notify (GParam) + """ + class Props: abstract: bool address_type: UnixSocketAddressType @@ -7270,11 +12652,32 @@ class UnixSocketAddress(SocketAddress, SocketConnectable): ) -> UnixSocketAddress: ... class UnixSocketAddressClass(GObject.GPointer): + """ + :Constructors: + + :: + + UnixSocketAddressClass() + """ + parent_class: SocketAddressClass = ... class UnixSocketAddressPrivate(GObject.GPointer): ... class Vfs(GObject.Object): + """ + :Constructors: + + :: + + Vfs(**properties) + + Object GVfs + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... def do_add_writable_namespaces(self, list: FileAttributeInfoList) -> None: ... def do_get_file_for_path(self, path: str) -> File: ... @@ -7288,8 +12691,8 @@ class Vfs(GObject.Object): attribute_matcher: FileAttributeMatcher, info: FileInfo, cancellable: Optional[Cancellable], - extra_data: None, - free_extra_data: Callable[[None], None], + extra_data: Optional[Any], + free_extra_data: Callable[[Optional[Any]], None], ) -> None: ... def do_local_file_moved(self, source: str, dest: str) -> None: ... def do_local_file_removed(self, filename: str) -> None: ... @@ -7313,13 +12716,24 @@ class Vfs(GObject.Object): def register_uri_scheme( self, scheme: str, - uri_func: Optional[Callable[..., File]] = None, - parse_name_func: Optional[Callable[..., File]] = None, + uri_func: Optional[Callable[Concatenate[Vfs, str, _VarArgs], File]] = None, + uri_data: Optional[Any] = None, + parse_name_func: Optional[ + Callable[Concatenate[Vfs, str, _VarArgs], File] + ] = None, *parse_name_data: Any, ) -> bool: ... def unregister_uri_scheme(self, scheme: str) -> bool: ... class VfsClass(GObject.GPointer): + """ + :Constructors: + + :: + + VfsClass() + """ + parent_class: GObject.ObjectClass = ... is_active: Callable[[Vfs], bool] = ... get_file_for_path: Callable[[Vfs, str], File] = ... @@ -7334,8 +12748,8 @@ class VfsClass(GObject.GPointer): FileAttributeMatcher, FileInfo, Optional[Cancellable], - None, - Callable[[None], None], + Optional[Any], + Callable[[Optional[Any]], None], ], None, ] = ... @@ -7345,22 +12759,31 @@ class VfsClass(GObject.GPointer): ] = ... local_file_removed: Callable[[Vfs, str], None] = ... local_file_moved: Callable[[Vfs, str, str], None] = ... - deserialize_icon: None = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... + deserialize_icon: Any = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... class Volume(GObject.GInterface): + """ + Interface GVolume + + Signals from GObject: + notify (GParam) + """ + def can_eject(self) -> bool: ... def can_mount(self) -> bool: ... def eject( self, flags: MountUnmountFlags, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_finish(self, result: AsyncResult) -> bool: ... @@ -7369,7 +12792,9 @@ class Volume(GObject.GInterface): flags: MountUnmountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def eject_with_operation_finish(self, result: AsyncResult) -> bool: ... @@ -7388,13 +12813,23 @@ class Volume(GObject.GInterface): flags: MountMountFlags, mount_operation: Optional[MountOperation] = None, cancellable: Optional[Cancellable] = None, - callback: Optional[Callable[..., None]] = None, + callback: Optional[ + Callable[Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None] + ] = None, *user_data: Any, ) -> None: ... def mount_finish(self, result: AsyncResult) -> bool: ... def should_automount(self) -> bool: ... class VolumeIface(GObject.GPointer): + """ + :Constructors: + + :: + + VolumeIface() + """ + g_iface: GObject.TypeInterface = ... changed: Callable[[Volume], None] = ... removed: Callable[[Volume], None] = ... @@ -7405,22 +12840,90 @@ class VolumeIface(GObject.GPointer): get_mount: Callable[[Volume], Optional[Mount]] = ... can_mount: Callable[[Volume], bool] = ... can_eject: Callable[[Volume], bool] = ... - mount_fn: Callable[..., None] = ... + mount_fn: Callable[ + Concatenate[ + Volume, + MountMountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... mount_finish: Callable[[Volume, AsyncResult], bool] = ... - eject: Callable[..., None] = ... + eject: Callable[ + Concatenate[ + Volume, + MountUnmountFlags, + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_finish: Callable[[Volume, AsyncResult], bool] = ... get_identifier: Callable[[Volume, str], Optional[str]] = ... enumerate_identifiers: Callable[[Volume], list[str]] = ... should_automount: Callable[[Volume], bool] = ... get_activation_root: Callable[[Volume], Optional[File]] = ... - eject_with_operation: Callable[..., None] = ... + eject_with_operation: Callable[ + Concatenate[ + Volume, + MountUnmountFlags, + Optional[MountOperation], + Optional[Cancellable], + Optional[ + Callable[ + Concatenate[Optional[GObject.Object], AsyncResult, _VarArgs], None + ] + ], + _VarArgs, + ], + None, + ] = ... eject_with_operation_finish: Callable[[Volume, AsyncResult], bool] = ... get_sort_key: Callable[[Volume], Optional[str]] = ... get_symbolic_icon: Callable[[Volume], Icon] = ... class VolumeMonitor(GObject.Object): + """ + :Constructors: + + :: + + VolumeMonitor(**properties) + + Object GVolumeMonitor + + Signals from GVolumeMonitor: + volume-added (GVolume) + volume-removed (GVolume) + volume-changed (GVolume) + mount-added (GMount) + mount-removed (GMount) + mount-pre-unmount (GMount) + mount-changed (GMount) + drive-connected (GDrive) + drive-disconnected (GDrive) + drive-changed (GDrive) + drive-eject-button (GDrive) + drive-stop-button (GDrive) + + Signals from GObject: + notify (GParam) + """ + parent_instance: GObject.Object = ... - priv: None = ... + priv: Any = ... @staticmethod def adopt_orphan_mount(mount: Mount) -> Volume: ... def do_drive_changed(self, drive: Drive) -> None: ... @@ -7449,6 +12952,14 @@ class VolumeMonitor(GObject.Object): def get_volumes(self) -> list[Volume]: ... class VolumeMonitorClass(GObject.GPointer): + """ + :Constructors: + + :: + + VolumeMonitorClass() + """ + parent_class: GObject.ObjectClass = ... volume_added: Callable[[VolumeMonitor, Volume], None] = ... volume_removed: Callable[[VolumeMonitor, Volume], None] = ... @@ -7466,25 +12977,47 @@ class VolumeMonitorClass(GObject.GPointer): get_mounts: Callable[[VolumeMonitor], list[Mount]] = ... get_volume_for_uuid: Callable[[VolumeMonitor, str], Optional[Volume]] = ... get_mount_for_uuid: Callable[[VolumeMonitor, str], Optional[Mount]] = ... - adopt_orphan_mount: None = ... + adopt_orphan_mount: Any = ... drive_eject_button: Callable[[VolumeMonitor, Drive], None] = ... drive_stop_button: Callable[[VolumeMonitor, Drive], None] = ... - _g_reserved1: None = ... - _g_reserved2: None = ... - _g_reserved3: None = ... - _g_reserved4: None = ... - _g_reserved5: None = ... - _g_reserved6: None = ... + _g_reserved1: Any = ... + _g_reserved2: Any = ... + _g_reserved3: Any = ... + _g_reserved4: Any = ... + _g_reserved5: Any = ... + _g_reserved6: Any = ... class ZlibCompressor(GObject.Object, Converter): + """ + :Constructors: + + :: + + ZlibCompressor(**properties) + new(format:Gio.ZlibCompressorFormat, level:int) -> Gio.ZlibCompressor + + Object GZlibCompressor + + Properties from GZlibCompressor: + format -> GZlibCompressorFormat: compression format + The format of the compressed data + level -> gint: compression level + The level of compression from 0 (no compression) to 9 (most compression), -1 for the default level + file-info -> GFileInfo: file info + File info + + Signals from GObject: + notify (GParam) + """ + class Props: - file_info: FileInfo + file_info: Optional[FileInfo] format: ZlibCompressorFormat level: int props: Props = ... def __init__( self, - file_info: FileInfo = ..., + file_info: Optional[FileInfo] = ..., format: ZlibCompressorFormat = ..., level: int = ..., ): ... @@ -7494,11 +13027,39 @@ class ZlibCompressor(GObject.Object, Converter): def set_file_info(self, file_info: Optional[FileInfo] = None) -> None: ... class ZlibCompressorClass(GObject.GPointer): + """ + :Constructors: + + :: + + ZlibCompressorClass() + """ + parent_class: GObject.ObjectClass = ... class ZlibDecompressor(GObject.Object, Converter): + """ + :Constructors: + + :: + + ZlibDecompressor(**properties) + new(format:Gio.ZlibCompressorFormat) -> Gio.ZlibDecompressor + + Object GZlibDecompressor + + Properties from GZlibDecompressor: + format -> GZlibCompressorFormat: compression format + The format of the compressed data + file-info -> GFileInfo: file info + File info + + Signals from GObject: + notify (GParam) + """ + class Props: - file_info: FileInfo + file_info: Optional[FileInfo] format: ZlibCompressorFormat props: Props = ... def __init__(self, format: ZlibCompressorFormat = ...): ... @@ -7507,6 +13068,14 @@ class ZlibDecompressor(GObject.Object, Converter): def new(cls, format: ZlibCompressorFormat) -> ZlibDecompressor: ... class ZlibDecompressorClass(GObject.GPointer): + """ + :Constructors: + + :: + + ZlibDecompressorClass() + """ + parent_class: GObject.ObjectClass = ... class AppInfoCreateFlags(GObject.GFlags):