ACIL FM

Nama	Ukuran	Aksi
client	-	Open
server	-	Open
__pycache__	-	Open
connection.py	10.67 MB	View DL Edit
constants.py	1.34 MB	View DL Edit
error.py	8.59 MB	View DL Edit
identifier.py	6.37 MB	View DL Edit
loop.py	1.91 MB	View DL Edit
namespace.py	1.44 MB	View DL Edit
signal.py	2.11 MB	View DL Edit
specification.py	8.94 MB	View DL Edit
structure.py	12.55 MB	View DL Edit
typing.py	9.54 MB	View DL Edit
xml.py	4.9 MB	View DL Edit
__init__.py	0 B	View DL Edit

Edit file: /usr/lib/python3.9/site-packages/dasbus/specification.py

#
# Support for DBus XML specifications
#
# Copyright (C) 2019  Red Hat, Inc.  All rights reserved.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
# USA
#
# For more info about DBus specification see:
# https://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format
#
from collections import namedtuple

from dasbus.xml import XMLParser

__all__ = [
    "DBusSpecificationError",
    "DBusSpecification",
    "DBusSpecificationParser"
]

class DBusSpecificationError(Exception):
    """Exception for the DBus specification errors."""
    pass

class DBusSpecification(object):
    """DBus XML specification."""

DIRECTION_IN = "in"
    DIRECTION_OUT = "out"
    ACCESS_READ = "read"
    ACCESS_WRITE = "write"
    ACCESS_READWRITE = "readwrite"
    RETURN_PARAMETER = "return"

STANDARD_INTERFACES = """
    <node>
        <interface name="org.freedesktop.DBus.Introspectable">
            <method name="Introspect">
            <arg type="s" name="xml_data" direction="out"/>
            </method>
        </interface>
        <interface name="org.freedesktop.DBus.Peer">
            <method name="Ping"/>
            <method name="GetMachineId">
                <arg type="s" name="machine_uuid" direction="out"/>
            </method>
       </interface>
        <interface name="org.freedesktop.DBus.Properties">
            <method name="Get">
                <arg type="s" name="interface_name" direction="in"/>
                <arg type="s" name="property_name" direction="in"/>
                <arg type="v" name="value" direction="out"/>
            </method>
            <method name="GetAll">
                <arg type="s" name="interface_name" direction="in"/>
                <arg type="a{sv}" name="properties" direction="out"/>
            </method>
            <method name="Set">
                <arg type="s" name="interface_name" direction="in"/>
                <arg type="s" name="property_name" direction="in"/>
                <arg type="v" name="value" direction="in"/>
            </method>
            <signal name="PropertiesChanged">
                <arg type="s" name="interface_name"/>
                <arg type="a{sv}" name="changed_properties"/>
                <arg type="as" name="invalidated_properties"/>
            </signal>
        </interface>
    </node>
    """

# Representation of specification members.
    Signal = namedtuple("Signal", [
        "name",
        "interface_name",
        "type"
    ])

Method = namedtuple("Method", [
        "name",
        "interface_name",
        "in_type",
        "out_type"
    ])

Property = namedtuple("Property", [
        "name",
        "interface_name",
        "readable",
        "writable",
        "type"
    ])

# Specification data holders.
    __slots__ = ["_members"]

@classmethod
    def from_xml(cls, xml):
        """Return a DBus specification for the given XML."""
        return DBusSpecificationParser.parse_specification(xml, cls)

def __init__(self):
        """Create a new DBus specification."""
        self._members = {}

@property
    def interfaces(self):
        """Interfaces of the DBus specification."""
        return list(dict(self._members.keys()).keys())

@property
    def members(self):
        """Members of the DBus specification."""
        return list(self._members.values())

def add_member(self, member):
        """Add a member of a DBus interface."""
        self._members[(member.interface_name, member.name)] = member

def get_member(self, interface_name, member_name):
        """Get a member of a DBus interface."""
        try:
            return self._members[(interface_name, member_name)]
        except KeyError:
            pass

raise DBusSpecificationError(
            "DBus specification has no member '{}.{}'.".format(
                interface_name, member_name
            )
        )

class DBusSpecificationParser(object):
    """Class for parsing DBus XML specification."""

# The XML parser.
    xml_parser = XMLParser

@classmethod
    def parse_specification(cls, xml, factory=DBusSpecification):
        """Generate a representation of a DBus XML specification.

:param xml: the XML specification to parse
        :param factory: the DBus specification factory
        :return: a representation od the DBus specification
        """
        specification = factory()
        cls._parse_xml(specification, DBusSpecification.STANDARD_INTERFACES)
        cls._parse_xml(specification, xml)
        return specification

@classmethod
    def _parse_xml(cls, specification, xml):
        """Parse the given XML."""
        node = cls.xml_parser.xml_to_element(xml)

# Iterate over interfaces.
        for interface_element in node:
            if not cls.xml_parser.is_interface(interface_element):
                continue

# Parse the interface.
            cls._parse_interface(specification, interface_element)

@classmethod
    def _parse_interface(cls, specification, interface_element):
        """Parse the interface element from the DBus specification."""
        interface_name = cls.xml_parser.get_name(interface_element)

# Iterate over members.
        for member_element in interface_element:

if cls.xml_parser.is_property(member_element):
                member = cls._parse_property(interface_name, member_element)

elif cls.xml_parser.is_signal(member_element):
                member = cls._parse_signal(interface_name, member_element)

elif cls.xml_parser.is_method(member_element):
                member = cls._parse_method(interface_name, member_element)

else:
                continue

# Add the member specification to the mapping.
            specification.add_member(member)

return interface_name

@classmethod
    def _parse_property(cls, interface_name, property_element):
        """Parse the property element from the DBus specification."""
        property_name = cls.xml_parser.get_name(property_element)
        property_type = cls.xml_parser.get_type(property_element)
        property_access = cls.xml_parser.get_access(property_element)

readable = property_access in (
            DBusSpecification.ACCESS_READ,
            DBusSpecification.ACCESS_READWRITE
        )

writable = property_access in (
            DBusSpecification.ACCESS_WRITE,
            DBusSpecification.ACCESS_READWRITE
        )

return DBusSpecification.Property(
            name=property_name,
            interface_name=interface_name,
            readable=readable,
            writable=writable,
            type=property_type
        )

@classmethod
    def _parse_signal(cls, interface_name, signal_element):
        """Parse the signal element from the DBus specification."""
        signal_name = cls.xml_parser.get_name(signal_element)
        signal_type = []

for element in signal_element:
            if not cls.xml_parser.is_parameter(element):
                continue

element_type = cls.xml_parser.get_type(element)
            signal_type.append(element_type)

return DBusSpecification.Signal(
            name=signal_name,
            interface_name=interface_name,
            type=cls._get_type(signal_type)
        )

@classmethod
    def _parse_method(cls, interface_name, method_element):
        """Parse the method element from the DBus specification."""
        method_name = cls.xml_parser.get_name(method_element)
        in_types = []
        out_types = []

for element in method_element:
            if not cls.xml_parser.is_parameter(element):
                continue

direction = cls.xml_parser.get_direction(element)
            element_type = cls.xml_parser.get_type(element)

if direction == DBusSpecification.DIRECTION_IN:
                in_types.append(element_type)

elif direction == DBusSpecification.DIRECTION_OUT:
                out_types.append(element_type)

return DBusSpecification.Method(
            name=method_name,
            interface_name=interface_name,
            in_type=cls._get_type(in_types),
            out_type=cls._get_type(out_types)
        )

@classmethod
    def _get_type(cls, types):
        """Join types into one value."""
        if not types:
            return None

return "({})".format("".join(types))

Batal