sdbus-modemmanager 1.0.2__py3-none-any.whl

sdbus_async/modemmanager/interfaces_sim.py

@@ -0,0 +1,130 @@
+from typing import List, Tuple
+
+from sdbus import DbusInterfaceCommonAsync, dbus_method_async, dbus_property_async
+
+
+class MMSimInterfaceAsync(DbusInterfaceCommonAsync, interface_name='org.freedesktop.ModemManager1.Sim'):
+	"""The SIM interface handles communication with SIM, USIM, and RUIM (CDMA SIM) cards."""
+
+	@dbus_method_async(input_signature='s')
+	async def send_pin(self, pin: str) -> None:
+		"""
+		Send the PIN to unlock the SIM card.
+
+		:param pin: A string containing the PIN code.
+		"""
+		raise NotImplementedError
+
+	@dbus_method_async(input_signature='ss')
+	async def send_puk(self, puk: str, pin: str) -> None:
+		"""
+		Send the PUK and a new PIN to unlock the SIM card.
+
+		:param puk: A string containing the PUK code.
+		:param pin: A string containing the PIN code.
+		"""
+		raise NotImplementedError
+
+	@dbus_method_async(input_signature='sb')
+	async def enable_pin(self, pin: str, enable: bool) -> None:
+		"""
+		Enable or disable the PIN checking.
+
+		:param pin: A string containing the PIN code.
+		:param enable: TRUE to enable PIN checking, FALSE otherwise.
+		"""
+		raise NotImplementedError
+
+	@dbus_method_async(input_signature='ss')
+	async def change_pin(self, old_pin: str, new_pin: str) -> None:
+		"""
+		Change the PIN code.
+
+		:param old_pin: A string containing the current PIN code.
+		:param new_pin: A string containing the new PIN code.
+		"""
+		raise NotImplementedError
+
+	@dbus_method_async(input_signature='a(su)')
+	async def set_preferred_networks(self, preferred_networks: List[Tuple[str, int]]) -> None:
+		"""
+		Stores the provided preferred network list to the SIM card.
+
+		Each entry contains an operator id string ("MCCMNC") consisting of 5 or 6 digits,
+		and an MMModemAccessTechnology mask to store to SIM card if supported.
+
+		:param preferred_networks: Operator id string and MMModemAccessTechnology mask.
+		"""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='b')
+	def active(self) -> bool:
+		"""Boolean indicating whether the SIM is currently active."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def sim_identifier(self) -> str:
+		"""
+		The ICCID of the SIM card.
+		This may be available before the PIN has been entered depending on the device itself.
+		"""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def imsi(self) -> str:
+		"""The IMSI of the SIM card, if any."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def eid(self) -> str:
+		"""The EID of the SIM card, if any."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def operator_identifier(self) -> str:
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def operator_name(self) -> str:
+		"""The name of the network operator, as given by the SIM card, if known."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='as')
+	def emergency_numbers(self) -> List[str]:
+		"""List of emergency numbers programmed in the SIM card."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='a(su)')
+	def preferred_networks(self) -> List[Tuple[str, int]]:
+		"""
+		List of preferred networks with access technologies configured in the SIM card.
+
+		Each entry contains an operator id string ("MCCMNC") consisting of 5 or 6 digits,
+		and an MMModemAccessTechnology mask to store to SIM card if supported.
+		"""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='ay')
+	def gid1(self) -> bytes:
+		"""Group identifier level 1."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='ay')
+	def gid2(self) -> bytes:
+		"""Group identifier level 2."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def sim_type(self) -> int:
+		"""Indicates whether the current primary SIM is a ESIM or a physical SIM, given as MMSimType value."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def esim_status(self) -> int:
+		"""If current SIM is ESIM then this indicates whether there is a profile or not, given as MMSimEsimStatus value."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def removability(self) -> int:
+		"""Indicates whether the current SIM is a removable SIM or not, given as a MMSimRemovability value."""
+		raise NotImplementedError

sdbus_async/modemmanager/interfaces_sms.py

@@ -0,0 +1,97 @@
+from typing import Any, Tuple
+
+from sdbus import DbusInterfaceCommonAsync, dbus_method_async, dbus_property_async
+
+
+class MMSmsInterfaceAsync(DbusInterfaceCommonAsync, interface_name='org.freedesktop.ModemManager1.Sms'):
+	"""The SMS interface defines operations and properties of a single SMS message."""
+
+	@dbus_method_async()
+	async def send(self) -> None:
+		"""If the message has not yet been sent, queue it for delivery."""
+		raise NotImplementedError
+
+	@dbus_method_async(input_signature='u')
+	async def store(self, storage: int) -> None:
+		"""Store the message in the device if not already done."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def state(self) -> int:
+		"""A MMSmsState value, describing the state of the message."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def pdu_type(self) -> int:
+		"""A MMSmsPduType value, describing the type of PDUs used in the SMS message."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def number(self) -> str:
+		"""Number to which the message is addressed."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def text(self) -> str:
+		"""Message text, in UTF-8."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='ay')
+	def data(self) -> bytes:
+		"""Message data."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def s_m_s_c(self) -> str:
+		"""Indicates the SMS service center number."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='(uv)')
+	def validity(self) -> Tuple[int, Tuple[str, Any]]:
+		"""Indicates when the SMS expires in the SMSC."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='i')
+	def Class(self) -> int:
+		"""3GPP message class (-1..3)."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def teleservice_id(self) -> int:
+		"""A MMSmsCdmaTeleserviceId value."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def service_category(self) -> int:
+		"""A MMSmsCdmaServiceCategory value."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='b')
+	def delivery_report_request(self) -> bool:
+		"""True if delivery report request is required, False otherwise."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def message_reference(self) -> int:
+		"""Message Reference of the last PDU sent/received within this SMS."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def timestamp(self) -> str:
+		"""Time when the first PDU of the SMS message arrived the SMSC, in ISO8601 format."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='s')
+	def discharge_timestamp(self) -> str:
+		"""Time when the first PDU of the SMS message left the SMSC, in ISO8601 format."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def delivery_state(self) -> int:
+		"""A MMSmsDeliveryState value, describing the state of the delivery reported in the Status Report message."""
+		raise NotImplementedError
+
+	@dbus_property_async(property_signature='u')
+	def storage(self) -> int:
+		"""A MMSmsStorage value, describing the storage where this message is kept."""
+		raise NotImplementedError

sdbus_async/modemmanager/objects.py

@@ -0,0 +1,204 @@
+from typing import Dict, List, Optional
+
+from sdbus.sd_bus_internals import SdBus
+
+from .enums import MMCallDirection, MMCallState, MMCallStateReason
+from .interfaces_bearer import MMBearerInterfaceAsync
+from .interfaces_call import MMCallInterfaceAsync
+from .interfaces_modem import MMModemInterfaceAsync, MMModemMessagingInterfaceAsync, MMModemSimpleInterfaceAsync, MMModemSignalInterfaceAsync, MMModemsInterfaceAsync, MMModemVoiceInterfaceAsync
+from .interfaces_root import MMInterfaceAsync
+from .interfaces_sim import MMSimInterfaceAsync
+from .interfaces_sms import MMSmsInterfaceAsync
+
+MODEM_MANAGER_SERVICE_NAME = 'org.freedesktop.ModemManager1'
+
+
+class MM(MMInterfaceAsync):
+	"""Modem Manger main object
+
+	Implements :py:class:`ModemManagerInterfaceAsync`
+
+	Service name ``'org.freedesktop.ModemManager1'``
+	and object path ``/org/freedesktop/ModemManager1`` is predetermined.
+	"""
+
+	def __init__(self, bus: Optional[SdBus] = None) -> None:
+		"""
+		:param bus: You probably want to set default bus to system bus \
+			or pass system bus directly.
+		"""
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, '/org/freedesktop/ModemManager1', bus)
+
+
+class MMSms(MMSmsInterfaceAsync):
+
+	def __init__(
+		self,
+		object_path: str,
+		bus: Optional[SdBus] = None,
+	) -> None:
+		"""
+		:param bus: You probably want to set default bus to system bus \
+			or pass system bus directly.
+		"""
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+
+class MMModemMessaging(MMModemMessagingInterfaceAsync):
+
+	def __init__(self, object_path: str, bus: Optional[SdBus] = None) -> None:
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+	async def create_sms(self, number: str, text: str = None, data: bytes = None) -> MMSms:
+		"""Creates a new message object."""
+		args = {"number": ("s", number)}
+		if text:
+			args["text"] = ("s", text)
+		elif data:
+			args["data"] = ("ay", data)
+
+		return MMSms(self.create(properties=args))
+
+	async def delete_sms(self, sms: MMSms) -> None:
+		"""Delete an SMS message."""
+		self.delete(sms._remote_object_path)
+
+
+class MMModemSignal(MMModemSignalInterfaceAsync):
+
+	def __init__(self, object_path: str, bus: Optional[SdBus] = None) -> None:
+		"""
+		:param bus: You probably want to set default bus to system bus \
+			or pass system bus directly.
+		"""
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+
+class MMModemSimple(MMModemSimpleInterfaceAsync):
+
+	def __init__(self, object_path: str, bus: Optional[SdBus] = None) -> None:
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+
+class MMModemVoice(MMModemVoiceInterfaceAsync):
+
+	def __init__(self, object_path: str, bus: Optional[SdBus] = None) -> None:
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+	async def get_calls(self):
+		return [MMCall(path) for path in self.call_object_paths]
+
+
+class MMModem(MMModemInterfaceAsync):
+
+	def __init__(
+		self,
+		object_path: str,
+		bus: Optional[SdBus] = None,
+	) -> None:
+		"""
+		:param bus: You probably want to set default bus to system bus \
+			or pass system bus directly.
+		"""
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+		self.messaging = MMModemMessaging(object_path=object_path, bus=bus)
+		self.simple = MMModemSimple(object_path=object_path, bus=bus)
+		self.signal = MMModemSignal(object_path=object_path, bus=bus)
+		self.voice = MMModemVoice(object_path=object_path, bus=bus)
+		self.sim: Optional[MMSim] = None
+		self.bearers: List[MMBearer] = []
+
+	async def set_sim(self, object_path: str):
+		self.sim = MMSim(object_path=object_path)
+
+	async def set_bearers(self, object_paths: List[str]):
+		for p in object_paths:
+			b = MMBearer(p)
+			self.bearers.append(b)
+
+
+class MMModems(MMModemsInterfaceAsync):
+	modems: List[MMModem] = []
+
+	def __init__(self, bus: Optional[SdBus] = None) -> None:
+		super().__init__()
+		self._connect(service_name=MODEM_MANAGER_SERVICE_NAME, object_path='/org/freedesktop/ModemManager1', bus=bus)
+
+	async def get_modems(self) -> List[MMModem]:
+		objects = await self.get_managed_objects()
+		for k, v in objects.items():
+			m: MMModem = MMModem(object_path=k)
+			self.modems.append(m)
+		return self.modems
+
+	async def get_first(self) -> Optional[MMModem]:
+		if len(self.modems) <= 0:
+			await self.get_modems()
+		return self.modems[0] if len(self.modems) >= 1 else None
+
+
+class MMSim(MMSimInterfaceAsync):
+
+	def __init__(
+		self,
+		object_path: str,
+		bus: Optional[SdBus] = None,
+	) -> None:
+		"""
+		:param bus: You probably want to set default bus to system bus \
+			or pass system bus directly.
+		"""
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+
+class MMBearer(MMBearerInterfaceAsync):
+
+	def __init__(
+		self,
+		object_path: str,
+		bus: Optional[SdBus] = None,
+	) -> None:
+		"""
+		:param bus: You probably want to set default bus to system bus \
+			or pass system bus directly.
+		"""
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+
+class MMCall(MMCallInterfaceAsync):
+
+	def __init__(
+		self,
+		object_path: str,
+		bus: Optional[SdBus] = None,
+	) -> None:
+		"""
+		:param bus: You probably want to set default bus to system bus \
+			or pass system bus directly.
+		"""
+		super().__init__()
+		self._connect(MODEM_MANAGER_SERVICE_NAME, object_path, bus)
+
+	@property
+	def state_text(self) -> str:
+		"""A MMCallState name, describing the state of the call."""
+		return MMCallState(self.state).name
+
+	@property
+	def state_reason_text(self) -> str:
+		"""A MMCallStateReason name, describing why the state is changed."""
+		return MMCallStateReason(self.state_reason).name
+
+	@property
+	def direction_text(self) -> str:
+		"""A MMCallDirection name, describing the direction of the call."""
+		return MMCallDirection(self.direction).name

sdbus_block/modemmanager/__init__.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from .enums import MMModemState, MMModemMode, MMModemPowerState, MMCallDirection, MMCallState, MMCallStateReason
+from .interfaces_bearer import MMBearerInterface
+from .interfaces_call import MMCallInterface
+from .interfaces_modem import MMModemInterface, MMModemMessagingInterface, MMModemSimpleInterface, MMModemSignalInterface, MMModemsInterface, MMModemVoiceInterface
+from .interfaces_root import MMInterface
+from .interfaces_sim import MMSimInterface
+from .interfaces_sms import MMSmsInterface
+from .objects import MM, MMBearer, MMCall, MMModem, MMModems, MMModemMessaging, MMModemSignal, MMModemSimple, MMModemVoice, MMSim, MMSms
+
+__all__ = (
+	# .enums
+	'MMModemState',
+	'MMModemMode',
+	'MMModemPowerState',
+	'MMCallDirection',
+	'MMCallState',
+	'MMCallStateReason',
+	# .interfaces_bearer
+	' MMBearerInterface',
+	# .interfaces_call
+	'MMCallInterface',
+	# .interfaces_modem
+	'MMModemInterface',
+	'MMModemMessagingInterface',
+	'MMModemSimpleInterface',
+	'MMModemSignalInterface',
+	'MMModemsInterface',
+	'MMModemVoiceInterface',
+	# .interfaces_root
+	'MMInterface',
+	# .interfaces_sim
+	'MMSimInterface',
+	# .interfaces_sms
+	'MMSmsInterface',
+	# .objects
+	'MM',
+	'MMModems',
+	'MMModem',
+	'MMModemMessaging',
+	'MMModemSimple',
+	'MMModemSignal',
+	'MMModemVoice',
+	'MMSim',
+	'MMSms',
+	'MMBearer',
+	'MMCall',
+)