Skip to main content

DBus library in Python 3

Project description


This DBus library is written in Python 3, based on GLib and inspired by pydbus. Find out more in the documentation.

The code used to be part of the Anaconda Installer project. It was based on the pydbus library, but we replaced it with our own solution because its upstream development stalled. The dasbus library is a result of this effort.

Build Status Documentation Status codecov


  • Python 3.6+
  • PyGObject 3

You can install PyGObject provided by your system or use PyPI. The system package is usually called python3-gi, python3-gobject or pygobject3. See the instructions for your platform (only for PyGObject, you don't need cairo or GTK).

The library is known to work with Python 3.8, PyGObject 3.34 and GLib 2.63, but these are not the required minimal versions.


Install the package from PyPI. Follow the instructions above to install the required dependencies.

pip3 install dasbus

Or install the RPM package on Fedora 31+.

sudo dnf install python3-dasbus


Show the current hostname.

from dasbus.connection import SystemMessageBus
bus = SystemMessageBus()

proxy = bus.get_proxy(


Send a notification to the notification server.

from dasbus.connection import SessionMessageBus
bus = SessionMessageBus()

proxy = bus.get_proxy(

id = proxy.Notify(
    "", 0, "face-smile", "Hello World!",
    "This notification can be ignored.",
    [], {}, 0

print("The notification {} was sent.".format(id))

Handle a closed notification.

from dasbus.loop import EventLoop
loop = EventLoop()

from dasbus.connection import SessionMessageBus
bus = SessionMessageBus()

proxy = bus.get_proxy(

def callback(id, reason):
    print("The notification {} was closed.".format(id))


Run the service org.example.HelloWorld.

from dasbus.loop import EventLoop
loop = EventLoop()

from dasbus.connection import SessionMessageBus
bus = SessionMessageBus()

class HelloWorld(object):
    __dbus_xml__ = """
        <interface name="org.example.HelloWorld">
            <method name="Hello">
                <arg direction="in" name="name" type="s" />
                <arg direction="out" name="return" type="s" />

    def Hello(self, name):
        return "Hello {}!".format(name)

bus.publish_object("/org/example/HelloWorld", HelloWorld())


Use constants to define DBus services and objects.

from dasbus.connection import SystemMessageBus
from dasbus.identifier import DBusServiceIdentifier

NETWORK_MANAGER = DBusServiceIdentifier(
    namespace=("org", "freedesktop", "NetworkManager"),

proxy = NETWORK_MANAGER.get_proxy()

Use exceptions to propagate and handle DBus errors. Create an error mapper and a decorator for mapping Python exception classes to DBus error names. The message bus will use the given error mapper to transform Python exceptions to DBus errors and back.

from dasbus.error import ErrorMapper, DBusError, get_error_decorator
error_mapper = ErrorMapper()
dbus_error = get_error_decorator(error_mapper)

from dasbus.connection import SessionMessageBus
bus = SessionMessageBus(error_mapper=error_mapper)

class InvalidArgs(DBusError):

Call DBus methods asynchronously.

from dasbus.loop import EventLoop
loop = EventLoop()

def callback(call):

proxy = NETWORK_MANAGER.get_proxy()

Generate XML specifications from Python classes.

from dasbus.server.interface import dbus_interface
from dasbus.typing import Str

class HelloWorld(object):

    def Hello(self, name: Str) -> Str:
        return "Hello {}!".format(name)


Represent DBus structures by Python objects.

from dasbus.structure import DBusData
from dasbus.typing import Str, get_variant

class UserData(DBusData):
    def __init__(self):
        self._name = ""

    def name(self) -> Str:
        return self._name

    def name(self, name):
        self._name = name

data = UserData() = "Alice"

    "name": get_variant(Str, "Bob")

Create Python objects that can be published on DBus.

from dasbus.server.interface import dbus_interface
from dasbus.server.template import InterfaceTemplate
from dasbus.server.publishable import Publishable
from dasbus.typing import Str

class ChatInterface(InterfaceTemplate):

    def Send(self, message: Str):
        return self.implementation.send()

class Chat(Publishable):

    def for_publication(self):
        return ChatInterface(self)

    def send(self, message):

Use DBus containers to publish dynamically created Python objects.

from dasbus.connection import SessionMessageBus
from dasbus.server.container import DBusContainer

container = DBusContainer(
    namespace=("org", "example", "Chat"),



Look at the complete examples or DBus services of the Anaconda Installer for more inspiration.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for dasbus, version 1.6
Filename, size File type Python version Upload date Hashes
Filename, size dasbus-1.6.tar.gz (73.0 kB) File type Source Python version None Upload date Hashes View
Filename, size dasbus-1.6-py3-none-any.whl (60.1 kB) File type Wheel Python version py3 Upload date Hashes View

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Huawei Huawei PSF Sponsor Microsoft Microsoft PSF Sponsor NVIDIA NVIDIA PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page