python-gammu 3.2.5__cp311-cp311-win_amd64.whl

gammu/exception.py

@@ -0,0 +1,41 @@
+# vim: expandtab sw=4 ts=4 sts=4:
+#
+# Copyright © 2003 - 2018 Michal Čihař <michal@cihar.com>
+#
+# This file is part of python-gammu <https://wammu.eu/python-gammu/>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+"""Gammu exceptions."""
+
+import gammu._gammu
+from gammu import GSMError
+
+__all__ = [
+    "GSMError",
+]
+
+# Import all exceptions
+for _name in dir(gammu._gammu):
+    if not _name.startswith("ERR_"):
+        continue
+    _temp = __import__("gammu._gammu", globals(), locals(), [_name], 0)
+    locals()[_name] = getattr(_temp, _name)
+    __all__.append(_name)  # noqa: PYI056
+
+# Cleanup
+del _name
+del _temp
+del gammu

gammu/smsd.py

@@ -0,0 +1,25 @@
+# vim: expandtab sw=4 ts=4 sts=4:
+#
+# Copyright © 2003 - 2018 Michal Čihař <michal@cihar.com>
+#
+# This file is part of python-gammu <https://wammu.eu/python-gammu/>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+"""SMSD wrapper layer."""
+
+from gammu import SMSD
+
+__all__ = ["SMSD"]

gammu/worker.py

@@ -0,0 +1,323 @@
+# vim: expandtab sw=4 ts=4 sts=4:
+#
+# Copyright © 2003 - 2018 Michal Čihař <michal@cihar.com>
+#
+# This file is part of python-gammu <https://wammu.eu/python-gammu/>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+"""
+Asynchronous communication to phone.
+
+Mostly you should use only L{GammuWorker} class, others are only helpers
+which are used by this class.
+"""
+
+import queue
+import threading
+
+import gammu
+
+
+class InvalidCommand(Exception):
+    """Exception indicating invalid command."""
+
+    def __init__(self, value) -> None:
+        """
+        Initializes exception.
+
+        @param value: Name of wrong command.
+        @type value: string
+        """
+        super().__init__()
+        self.value = value
+
+    def __str__(self) -> str:
+        """Returns textual representation of exception."""
+        return f'Invalid command: "{self.value}"'
+
+
+def check_worker_command(command) -> None:
+    """
+    Checks whether command is valid.
+
+    @param command: Name of command.
+    @type command: string
+    """
+    if hasattr(gammu.StateMachine, command):
+        return
+
+    raise InvalidCommand(command)
+
+
+class GammuCommand:
+    """Storage of single command for gammu."""
+
+    def __init__(self, command, params=None, percentage=100) -> None:
+        """Creates single command instance."""
+        check_worker_command(command)
+        self._command = command
+        self._params = params
+        self._percentage = percentage
+
+    def get_command(self):
+        """Returns command name."""
+        return self._command
+
+    def get_params(self):
+        """Returns command params."""
+        return self._params
+
+    def get_percentage(self):
+        """Returns percentage of current task."""
+        return self._percentage
+
+    def __str__(self) -> str:
+        """Returns textual representation."""
+        if self._params is not None:
+            return f"{self._command} {self._params}"
+        return f"{self._command} ()"
+
+
+class GammuTask:
+    """Storage of tasks for gammu."""
+
+    def __init__(self, name, commands) -> None:
+        """
+        Creates single command instance.
+
+        @param name: Name of task.
+        @type name: string
+        @param commands: List of commands to execute.
+        @type commands: list of tuples or strings
+        """
+        self._name = name
+        self._list = []
+        self._pointer = 0
+        for i in range(len(commands)):
+            if isinstance(commands[i], tuple):
+                cmd = commands[i][0]
+                try:
+                    params = commands[i][1]
+                except IndexError:
+                    params = None
+            else:
+                cmd = commands[i]
+                params = None
+            percents = round(100 * (i + 1) / len(commands))
+            self._list.append(GammuCommand(cmd, params, percents))
+
+    def get_next(self):
+        """Returns next command to be executed as L{GammuCommand}."""
+        result = self._list[self._pointer]
+        self._pointer += 1
+        return result
+
+    def get_name(self):
+        """Returns task name."""
+        return self._name
+
+
+def gammu_pull_device(state_machine) -> None:
+    state_machine.ReadDevice()
+
+
+class GammuThread(threading.Thread):
+    """Thread for phone communication."""
+
+    def __init__(self, queue, config, callback, pull_func=gammu_pull_device) -> None:
+        """
+        Initialises thread data.
+
+        @param queue: Queue with events.
+        @type queue: queue.Queue object.
+
+        @param config: Gammu configuration, same as
+        L{StateMachine.SetConfig} accepts.
+        @type config: hash
+
+        @param callback: Function which will be called upon operation
+        completing.
+        @type callback: Function, needs to accept four params: name of
+        completed operation, result of it, error code and percentage of
+        overall operation. This callback is called from different
+        thread, so please take care of various threading issues in other
+        modules you use.
+        """
+        super().__init__()
+        self._kill = False
+        self._terminate = False
+        self._sm = gammu.StateMachine()
+        self._callback = callback
+        self._queue = queue
+        self._sm.SetConfig(0, config)
+        self._pull_func = pull_func
+
+    def _do_command(self, name, cmd, params, percentage=100) -> None:
+        """Executes single command on phone."""
+        func = getattr(self._sm, cmd)
+        error = "ERR_NONE"
+        result = None
+        try:
+            if params is None:
+                result = func()
+            elif isinstance(params, dict):
+                result = func(**params)
+            else:
+                result = func(*params)
+        except gammu.GSMError as info:
+            errcode = info.args[0]["Code"]
+            error = gammu.ErrorNumbers[errcode]
+
+        self._callback(name, result, error, percentage)
+
+    def run(self) -> None:
+        """
+        Thread body, which handles phone communication.
+
+        This should not be used from outside.
+        """
+        start = True
+        while not self._kill:
+            try:
+                if start:
+                    task = GammuTask("Init", ["Init"])
+                    start = False
+                else:
+                    # Wait at most ten seconds for next command
+                    task = self._queue.get(True, 10)
+                try:
+                    while True:
+                        cmd = task.get_next()
+                        self._do_command(
+                            task.get_name(),
+                            cmd.get_command(),
+                            cmd.get_params(),
+                            cmd.get_percentage(),
+                        )
+                except IndexError:
+                    try:
+                        if task.get_name() != "Init":
+                            self._queue.task_done()
+                    except (AttributeError, ValueError):
+                        pass
+            except queue.Empty:
+                if self._terminate:
+                    break
+                # Read the device to catch possible incoming events
+                try:
+                    self._pull_func(self._sm)
+                except Exception as ex:  # noqa: BLE001
+                    self._callback("ReadDevice", None, ex, 0)
+
+    def kill(self) -> None:
+        """Forces thread end without emptying queue."""
+        self._kill = True
+
+    def join(self, timeout=None) -> None:
+        """Terminates thread and waits for it."""
+        self._terminate = True
+        super().join(timeout)
+
+
+class GammuWorker:
+    """
+    Wrapper class for asynchronous communication with Gammu.
+
+    It spawns own thread and then passes all commands to this thread. When task
+    is done, caller is notified via callback.
+    """
+
+    def __init__(self, callback, pull_func=gammu_pull_device) -> None:
+        """
+        Initializes worker class.
+
+        @param callback: See L{GammuThread.__init__} for description.
+        """
+        self._thread = None
+        self._callback = callback
+        self._config = {}
+        self._lock = threading.Lock()
+        self._queue = queue.Queue()
+        self._pull_func = pull_func
+
+    def enqueue_command(self, command, params) -> None:
+        """
+        Enqueues command.
+
+        @param command: Command(s) to execute. Each command is tuple
+        containing function name and it's parameters.
+        @type command: tuple of list of tuples
+        @param params: Parameters to command.
+        @type params: tuple or string
+        """
+        self._queue.put(GammuTask(command, [(command, params)]))
+
+    def enqueue_task(self, command, commands) -> None:
+        """
+        Enqueues task.
+
+        @param command: Command(s) to execute. Each command is tuple
+        containing function name and it's parameters.
+        @type command: tuple of list of tuples
+        @param commands: List of commands to execute.
+        @type commands: list of tuples or strings
+        """
+        self._queue.put(GammuTask(command, commands))
+
+    def enqueue(self, command, params=None, commands=None) -> None:
+        """
+        Enqueues command or task.
+
+        @param command: Command(s) to execute. Each command is tuple
+        containing function name and it's parameters.
+        @type command: tuple of list of tuples
+        @param params: Parameters to command.
+        @type params: tuple or string
+        @param commands: List of commands to execute. When this is not
+        none, params are ignored and command is taken as task name.
+        @type commands: list of tuples or strings
+        """
+        if commands is not None:
+            self.enqueue_task(command, commands)
+        else:
+            self.enqueue_command(command, params)
+
+    def configure(self, config) -> None:
+        """
+        Configures gammu instance according to config.
+
+        @param config: Gammu configuration, same as
+        L{StateMachine.SetConfig} accepts.
+        @type config: hash
+        """
+        self._config = config
+
+    def abort(self):
+        """Aborts any remaining operations."""
+        raise NotImplementedError
+
+    def initiate(self) -> None:
+        """Connects to phone."""
+        self._thread = GammuThread(
+            self._queue, self._config, self._callback, self._pull_func
+        )
+        self._thread.start()
+
+    def terminate(self, timeout=None) -> None:
+        """Terminates phone connection."""
+        self.enqueue("Terminate")
+        self._thread.join(timeout)
+        self._thread = None

python_gammu-3.2.5.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: python-gammu
+Version: 3.2.5
+Summary: Gammu bindings
+Author-email: Michal Čihař <michal@cihar.com>
+License-Expression: GPL-2.0-or-later
+Project-URL: Download, https://wammu.eu/download/python-gammu/
+Project-URL: Homepage, https://wammu.eu/python-gammu/
+Keywords: calendar,contact,gammu,mobile,phone,SMS,todo
+Platform: Linux
+Platform: Mac OSX
+Platform: Windows 95/98/ME
+Platform: Windows XP/2000/NT
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python
+Classifier: Topic :: Communications :: Telephony
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: COPYING
+License-File: AUTHORS
+Dynamic: license-file
+
+python-gammu
+============
+
+Python bindings for the `Gammu library <https://wammu.eu/gammu/>`_.
+
+.. image:: https://github.com/gammu/python-gammu/actions/workflows/test.yml/badge.svg
+    :target: https://github.com/gammu/python-gammu/actions/workflows/test.yml
+
+.. image:: https://img.shields.io/liberapay/receives/Gammu.svg
+    :alt: Liberapay
+    :target: https://liberapay.com/Gammu/donate
+
+.. image:: https://img.shields.io/pypi/v/python-gammu.svg
+    :alt: PyPI
+    :target: https://pypi.python.org/pypi/python-gammu/
+
+Homepage
+========
+
+<https://wammu.eu/python-gammu/>
+
+License
+=======
+
+Copyright (C) Michal Čihař <michal@cihar.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Installing
+==========
+
+Install it using pip installer::
+
+    pip install python-gammu
+
+Requirements
+============
+
+To compile python-gammu, you need Gammu development files (usually shipped as
+``libgammu-dev`` or ``gammu-devel`` in Linux distributions).
+
+The location of the libraries is discovered using ``pkg-config``,
+``GAMMU_PATH`` environment variable and falls back to generic locations. In
+case it does not work, either install ``pkg-config`` or set ``GAMMU_PATH``.
+
+On Linux something like this should work::
+
+    GAMMU_PATH=/opt/gammu python setup.py build
+
+On Windows::
+
+    SET GAMMU_PATH="C:\Gammu"
+    python setup.py build
+
+
+Documentation
+=============
+
+Please see included python documentation::
+
+    >>> import gammu
+    >>> help(gammu)
+
+Alternatively you can use Sphinx to generate browsable version, which is
+also available on-line at <https://wammu.eu/docs/manual/>.
+
+Feedback and bug reports
+========================
+
+Any feedback is welcome, see <https://wammu.eu/support/> for information
+how to contact developers.

python_gammu-3.2.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+gammu/__init__.py,sha256=Ps8k_ubKaLNnr5KyTTtDF4U9IOtDUX4vPndxKJMBRX0,1089
+gammu/_gammu.cp311-win_amd64.pyd,sha256=m6PxbB4-E8X45hAW9_aHk_ta7QS6ek7o2SQxAhdFv70,1456128
+gammu/asyncworker.py,sha256=xFf8DUb7Iee_zRmoIKyxeTRh_QA8afcxtgwdDt3_gLY,6455
+gammu/data.py,sha256=Rh64yN5hCghWJZWjzve3a4iVw-GOdP6lxCoUNfeb9Tc,8099
+gammu/exception.py,sha256=ZTr1CLwDmrr2ygd-qBHfOMoBfmzltwOzyoSuUFPCtik,1330
+gammu/smsd.py,sha256=Jf0KHvOzxJ1cfX-ch7my-GgeioDwZYkUSad0V23rbo8,971
+gammu/worker.py,sha256=Pz2iovO8RhLa_1xXXxlpsl0G4KblcDR0_7IsWz_-sSg,10527
+python_gammu-3.2.5.dist-info/licenses/AUTHORS,sha256=FW5xxPfFuJoST6r5YwP91QO-KyTcTDrHXPwOBmGu450,105
+python_gammu-3.2.5.dist-info/licenses/COPYING,sha256=GJsa-V1mEVHgVM6hDJGz11Tk3k0_7PsHTB-ylHb3Fns,18431
+python_gammu-3.2.5.dist-info/METADATA,sha256=sQ7MloyzGye_-4IY77-QyFcCPKG9khnSYmqoOFaXTOw,3897
+python_gammu-3.2.5.dist-info/WHEEL,sha256=bVDps4tOb0nHmbMU4uK7h9NZsZJmyTqcRbrvK3TZLY4,102
+python_gammu-3.2.5.dist-info/top_level.txt,sha256=DCkjQyKLL2Scv_sr-bcKLuYLvOBgT2TuYlP4CD2jvNw,6
+python_gammu-3.2.5.dist-info/RECORD,,

python_gammu-3.2.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

python_gammu-3.2.5.dist-info/licenses/AUTHORS

@@ -0,0 +1,3 @@
+Michal Čihař <michal@cihar.com>
+Marcin Wiącek <marcin@mwiacek.com>
+...and many other contributors.