libosdp 3.0.8__tar.gz → 3.2.0__tar.gz

{libosdp-3.0.8/libosdp.egg-info → libosdp-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: libosdp
-Version: 3.0.8
+Version: 3.2.0
 Summary: Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)
 Home-page: https://github.com/goToMain/libosdp
 Author: Siddharth Chandrasekaran
@@ -10,6 +10,14 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
 
 # LibOSDP for Python
 
@@ -77,6 +85,18 @@ while True:
 
 see [examples/cp_app.py][2] for more details.
 
+Optional command completion callback:
+
+```python
+from osdp import CompletionStatus
+
+def on_command_complete(address, command, status):
+    if status == CompletionStatus.Ok:
+        print("command completed")
+
+cp.set_command_completion_handler(on_command_complete)
+```
+
 ### Peripheral Device mode:
 
 ```python
@@ -108,6 +128,18 @@ while True:
 
 see [examples/pd_app.py][3] for more details.
 
-[1]: https://libosdp.sidcha.dev/api/
+Optional event completion callback:
+
+```python
+from osdp import CompletionStatus
+
+def on_event_complete(event, status):
+    if status == CompletionStatus.Flushed:
+        print("event removed by flush")
+
+pd.set_event_completion_handler(on_event_complete)
+```
+
+[1]: https://doc.osdp.dev/api/
 [2]: https://github.com/goToMain/libosdp/blob/master/examples/python/cp_app.py
 [3]: https://github.com/goToMain/libosdp/blob/master/examples/python/pd_app.py

libosdp-3.0.8/PKG-INFO → libosdp-3.2.0/README.md

@@ -1,16 +1,3 @@
-Metadata-Version: 2.1
-Name: libosdp
-Version: 3.0.8
-Summary: Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)
-Home-page: https://github.com/goToMain/libosdp
-Author: Siddharth Chandrasekaran
-Author-email: sidcha.dev@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
 # LibOSDP for Python
 
 This package exposes the C/C++ library for OSDP devices to python to enable rapid
@@ -77,6 +64,18 @@ while True:
 
 see [examples/cp_app.py][2] for more details.
 
+Optional command completion callback:
+
+```python
+from osdp import CompletionStatus
+
+def on_command_complete(address, command, status):
+    if status == CompletionStatus.Ok:
+        print("command completed")
+
+cp.set_command_completion_handler(on_command_complete)
+```
+
 ### Peripheral Device mode:
 
 ```python
@@ -108,6 +107,18 @@ while True:
 
 see [examples/pd_app.py][3] for more details.
 
-[1]: https://libosdp.sidcha.dev/api/
+Optional event completion callback:
+
+```python
+from osdp import CompletionStatus
+
+def on_event_complete(event, status):
+    if status == CompletionStatus.Flushed:
+        print("event removed by flush")
+
+pd.set_event_completion_handler(on_event_complete)
+```
+
+[1]: https://doc.osdp.dev/api/
 [2]: https://github.com/goToMain/libosdp/blob/master/examples/python/cp_app.py
 [3]: https://github.com/goToMain/libosdp/blob/master/examples/python/pd_app.py

libosdp-3.0.8/README.md → libosdp-3.2.0/libosdp.egg-info/PKG-INFO

@@ -1,3 +1,24 @@
+Metadata-Version: 2.4
+Name: libosdp
+Version: 3.2.0
+Summary: Library implementation of IEC 60839-11-5 OSDP (Open Supervised Device Protocol)
+Home-page: https://github.com/goToMain/libosdp
+Author: Siddharth Chandrasekaran
+Author-email: sidcha.dev@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
 # LibOSDP for Python
 
 This package exposes the C/C++ library for OSDP devices to python to enable rapid
@@ -64,6 +85,18 @@ while True:
 
 see [examples/cp_app.py][2] for more details.
 
+Optional command completion callback:
+
+```python
+from osdp import CompletionStatus
+
+def on_command_complete(address, command, status):
+    if status == CompletionStatus.Ok:
+        print("command completed")
+
+cp.set_command_completion_handler(on_command_complete)
+```
+
 ### Peripheral Device mode:
 
 ```python
@@ -95,6 +128,18 @@ while True:
 
 see [examples/pd_app.py][3] for more details.
 
-[1]: https://libosdp.sidcha.dev/api/
+Optional event completion callback:
+
+```python
+from osdp import CompletionStatus
+
+def on_event_complete(event, status):
+    if status == CompletionStatus.Flushed:
+        print("event removed by flush")
+
+pd.set_event_completion_handler(on_event_complete)
+```
+
+[1]: https://doc.osdp.dev/api/
 [2]: https://github.com/goToMain/libosdp/blob/master/examples/python/cp_app.py
 [3]: https://github.com/goToMain/libosdp/blob/master/examples/python/pd_app.py

{libosdp-3.0.8 → libosdp-3.2.0}/libosdp.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ osdp/helpers.py
 osdp/key_store.py
 osdp/peripheral_device.py
 vendor/include/osdp.h
+vendor/include/osdp_export.h
 vendor/python/osdp_sys/base.c
 vendor/python/osdp_sys/cp.c
 vendor/python/osdp_sys/data.c
@@ -27,7 +28,6 @@ vendor/src/osdp_config.h
 vendor/src/osdp_cp.c
 vendor/src/osdp_diag.c
 vendor/src/osdp_diag.h
-vendor/src/osdp_export.h
 vendor/src/osdp_file.c
 vendor/src/osdp_file.h
 vendor/src/osdp_pd.c
@@ -37,6 +37,7 @@ vendor/src/crypto/tinyaes.c
 vendor/src/crypto/tinyaes_src.c
 vendor/src/crypto/tinyaes_src.h
 vendor/utils/include/utils/assert.h
+vendor/utils/include/utils/crc16.h
 vendor/utils/include/utils/disjoint_set.h
 vendor/utils/include/utils/list.h
 vendor/utils/include/utils/logger.h
@@ -44,10 +45,10 @@ vendor/utils/include/utils/pcap_gen.h
 vendor/utils/include/utils/queue.h
 vendor/utils/include/utils/slab.h
 vendor/utils/include/utils/utils.h
+vendor/utils/src/crc16.c
 vendor/utils/src/disjoint_set.c
 vendor/utils/src/list.c
 vendor/utils/src/logger.c
 vendor/utils/src/pcap_gen.c
 vendor/utils/src/queue.c
-vendor/utils/src/slab.c
 vendor/utils/src/utils.c

{libosdp-3.0.8 → libosdp-3.2.0}/osdp/__init__.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2021-2024 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#  Copyright (c) 2021-2026 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
 #
 #  SPDX-License-Identifier: Apache-2.0
 #
@@ -9,7 +9,7 @@ from .peripheral_device import PeripheralDevice
 from .key_store import KeyStore
 from .constants import (
     LibFlag, Command, CommandLEDColor, CommandFileTxFlags, Event, EventNotification,
-    CardFormat, Capability, LogLevel, StatusReportType
+    CardFormat, Capability, LogLevel, StatusReportType, CompletionStatus
 )
 from .helpers import PdId, PDInfo, PDCapabilities
 from .channel import Channel

{libosdp-3.0.8 → libosdp-3.2.0}/osdp/constants.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2021-2024 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#  Copyright (c) 2021-2026 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
 #
 #  SPDX-License-Identifier: Apache-2.0
 #
@@ -35,6 +35,7 @@ class Command:
     Buzzer = osdp_sys.CMD_BUZZER
     LED = osdp_sys.CMD_LED
     Comset = osdp_sys.CMD_COMSET
+    ComsetDone = osdp_sys.CMD_COMSET_DONE
     Text = osdp_sys.CMD_TEXT
     Manufacturer = osdp_sys.CMD_MFG
     Keyset = osdp_sys.CMD_KEYSET
@@ -59,6 +60,12 @@ class EventNotification:
     SecureChannelStatus = osdp_sys.EVENT_NOTIFICATION_SC_STATUS
     PeripheralDeviceStatus = osdp_sys.EVENT_NOTIFICATION_PD_STATUS
 
+class CompletionStatus:
+    Ok = getattr(osdp_sys, "COMPLETION_OK", 0)
+    Failed = getattr(osdp_sys, "COMPLETION_FAILED", 1)
+    Flushed = getattr(osdp_sys, "COMPLETION_FLUSHED", 2)
+    Aborted = getattr(osdp_sys, "COMPLETION_ABORTED", 3)
+
 class Event:
     CardRead = osdp_sys.EVENT_CARDREAD
     KeyPress = osdp_sys.EVENT_KEYPRESS

{libosdp-3.0.8 → libosdp-3.2.0}/osdp/control_panel.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2021-2024 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#  Copyright (c) 2021-2026 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
 #
 #  SPDX-License-Identifier: Apache-2.0
 #
@@ -17,7 +17,8 @@ class ControlPanel():
             self,
             pd_info_list: list[PDInfo],
             log_level: LogLevel=LogLevel.Info,
-            event_handler: Callable[[int, dict], int]=None
+            event_handler: Callable[[int, dict], int]=None,
+            command_completion_handler: Callable[[int, dict, int], None]=None
         ) -> None:
         self.pd_addr = []
         info_list = []
@@ -26,9 +27,18 @@ class ControlPanel():
             self.pd_addr.append(pd_info.address)
             info_list.append(pd_info.get())
         self.event_queue = [ queue.Queue() for i in self.pd_addr ]
+        self.user_event_handler = None
+        self.user_command_completion_handler = None
         osdp_sys.set_loglevel(log_level)
         self.ctx = osdp_sys.ControlPanel(info_list)
+        # Always use our internal handler to ensure queue functionality
+        self.ctx.set_event_callback(self._internal_event_handler)
+        if hasattr(self.ctx, "set_command_completion_callback"):
+            self.ctx.set_command_completion_callback(
+                self._internal_command_completion_handler
+            )
         self.set_event_handler(event_handler)
+        self.set_command_completion_handler(command_completion_handler)
         self.event = None
         self.lock = None
         self.thread = None
@@ -36,21 +46,42 @@ class ControlPanel():
     @staticmethod
     def refresh(event, lock, ctx):
         while not event.is_set():
-            lock.acquire()
-            ctx.refresh()
-            lock.release()
+            with lock:
+                ctx.refresh()
             time.sleep(0.020) #sleep for 20ms
 
     def set_event_handler(self, handler: Callable[[int, dict], int]):
-        if handler:
-            self.ctx.set_event_callback(handler)
-        else:
-            self.ctx.set_event_callback(self.event_handler)
+        """Set user event handler while maintaining queue functionality"""
+        self.user_event_handler = handler
+
+    def set_command_completion_handler(
+            self, handler: Callable[[int, dict, int], None]):
+        self.user_command_completion_handler = handler
 
-    def event_handler(self, pd, event) -> int:
+    def _internal_event_handler(self, pd, event) -> int:
+        """Internal handler that manages both queue and user callback"""
+        # Always put event in queue for get_event() compatibility
         self.event_queue[pd].put(event)
+
+        # If user has set a custom handler, call it too
+        if self.user_event_handler:
+            try:
+                return self.user_event_handler(pd, event)
+            except Exception as e:
+                print(f"Error in user event handler: {e}")
+                return -1
+
         return 0
 
+    def _internal_command_completion_handler(self, pd, command, status) -> None:
+        if self.user_command_completion_handler:
+            try:
+                self.user_command_completion_handler(
+                    self.pd_addr[pd], command, status
+                )
+            except Exception as e:
+                print(f"Error in user command completion handler: {e}")
+
     def get_event(self, address, timeout: int=5):
         pd = self.pd_addr.index(address)
         block = timeout >= 0
@@ -61,10 +92,8 @@ class ControlPanel():
         return event
 
     def status(self):
-        self.lock.acquire()
-        bitmask = self.ctx.status()
-        self.lock.release()
-        return bitmask
+        with self.lock:
+            return self.ctx.status()
 
     def is_online(self, address):
         pd = self.pd_addr.index(address)
@@ -72,9 +101,8 @@ class ControlPanel():
 
     def get_pd_id(self, address: int) -> PdId:
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        pd_id_dict = self.ctx.get_pd_id(pd)
-        self.lock.release()
+        with self.lock:
+            pd_id_dict = self.ctx.get_pd_id(pd)
         if pd_id_dict:
             # version: int, model: int, vendor_code: int, serial_number: int, firmware_version: int
             pd_id = PdId(
@@ -88,9 +116,8 @@ class ControlPanel():
 
     def check_capability(self, address: int, cap: Capability) -> Tuple[int, int]:
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        compliance_level, num_items = self.ctx.check_capability(pd, cap)
-        self.lock.release()
+        with self.lock:
+            compliance_level, num_items = self.ctx.check_capability(pd, cap)
         return (compliance_level, num_items)
 
     def get_num_online(self):
@@ -102,10 +129,8 @@ class ControlPanel():
         return online
 
     def sc_status(self):
-        self.lock.acquire()
-        bitmask = self.ctx.sc_status()
-        self.lock.release()
-        return bitmask
+        with self.lock:
+            return self.ctx.sc_status()
 
     def is_sc_active(self, address):
         pd = self.pd_addr.index(address)
@@ -119,40 +144,55 @@ class ControlPanel():
                 sc_active += 1
         return sc_active
 
-    def send_command(self, address, cmd):
+    def submit_command(self, address, cmd):
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.send_command(pd, cmd)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.submit_command(pd, cmd)
+
+    def flush_commands(self, address):
+        pd = self.pd_addr.index(address)
+        with self.lock:
+            return self.ctx.flush_commands(pd)
+
+    def send_command(self, address, cmd):
+        from warnings import warn
+        warn("This method has been renamed to submit_command", DeprecationWarning, 2)
+        return self.submit_command(address, cmd)
 
     def set_flag(self, address, flag: LibFlag):
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.set_flag(pd, flag)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.set_flag(pd, flag)
 
     def clear_flag(self, address, flag: LibFlag):
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.clear_flag(pd, flag)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.clear_flag(pd, flag)
+
+    def disable_pd(self, address: int) -> bool:
+        pd = self.pd_addr.index(address)
+        with self.lock:
+            return self.ctx.disable_pd(pd)
+
+    def enable_pd(self, address: int) -> bool:
+        pd = self.pd_addr.index(address)
+        with self.lock:
+            return self.ctx.enable_pd(pd)
+
+    def is_pd_enabled(self, address: int) -> bool:
+        pd = self.pd_addr.index(address)
+        with self.lock:
+            return self.ctx.is_pd_enabled(pd)
 
     def register_file_ops(self, address, fops):
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.register_file_ops(pd, fops)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.register_file_ops(pd, fops)
 
     def get_file_tx_status(self, address):
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.get_file_tx_status(pd)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.get_file_tx_status(pd)
 
     def start(self):
         if self.thread:
@@ -197,8 +237,14 @@ class ControlPanel():
 
     def offline_wait(self, address, timeout=8):
         count = 0
-        time.sleep(timeout)
-        return self.is_online(address) == False
+        res = False
+        while count < timeout * 2:
+            time.sleep(0.5)
+            if not self.is_online(address):
+                res = True
+                break
+            count += 1
+        return res
 
     def sc_wait(self, address, timeout=5):
         count = 0

{libosdp-3.0.8 → libosdp-3.2.0}/osdp/helpers.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2021-2024 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#  Copyright (c) 2021-2026 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
 #
 #  SPDX-License-Identifier: Apache-2.0
 #

{libosdp-3.0.8 → libosdp-3.2.0}/osdp/key_store.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2021-2024 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#  Copyright (c) 2021-2026 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
 #
 #  SPDX-License-Identifier: Apache-2.0
 #

{libosdp-3.0.8 → libosdp-3.2.0}/osdp/peripheral_device.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2021-2024 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#  Copyright (c) 2021-2026 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
 #
 #  SPDX-License-Identifier: Apache-2.0
 #
@@ -16,16 +16,22 @@ from .constants import LogLevel
 class PeripheralDevice():
     def __init__(self, pd_info: PDInfo, pd_cap: PDCapabilities,
                  log_level: LogLevel=LogLevel.Info,
-                 command_handler: Callable[[dict], Tuple[int, dict]]=None):
+                 command_handler: Callable[[dict], Tuple[int, dict]]=None,
+                 event_completion_handler: Callable[[dict, int], None]=None):
         self.command_queue = queue.Queue()
         self.address = pd_info.address
+        self.user_command_handler = None
+        self.user_event_completion_handler = None
         osdp_sys.set_loglevel(log_level)
         self.ctx = osdp_sys.PeripheralDevice(pd_info.get(), capabilities=pd_cap.get())
-        if command_handler:
-            self.ctx.set_command_callback(command_handler)
-        else:
-            self.ctx.set_command_callback(self.command_handler)
+        # Always use our internal handler to ensure queue functionality
+        self.ctx.set_command_callback(self._internal_command_handler)
+        if hasattr(self.ctx, "set_event_completion_callback"):
+            self.ctx.set_event_completion_callback(
+                self._internal_event_completion_handler
+            )
         self.set_command_handler(command_handler)
+        self.set_event_completion_handler(event_completion_handler)
         self.event = None
         self.lock = None
         self.thread = None
@@ -33,20 +39,38 @@ class PeripheralDevice():
     @staticmethod
     def refresh(event, lock, ctx):
         while not event.is_set():
-            lock.acquire()
-            ctx.refresh()
-            lock.release()
+            with lock:
+                ctx.refresh()
             time.sleep(0.020) #sleep for 20ms
 
-    def command_handler(self, command) -> Tuple[int, dict]:
+    def _internal_command_handler(self, command) -> Tuple[int, dict]:
+        """Internal handler that manages both queue and user callback"""
+        # Always put command in queue for get_command() compatibility
         self.command_queue.put(command)
+
+        # If user has set a custom handler, call it too
+        if self.user_command_handler:
+            try:
+                return self.user_command_handler(command)
+            except Exception as e:
+                print(f"Error in user command handler: {e}")
+                return -1, None
+
         return 0, None
 
     def set_command_handler(self, handler: Callable[[dict], Tuple[int, dict]]):
-        if handler:
-            self.ctx.set_command_callback(handler)
-        else:
-            self.ctx.set_command_callback(self.command_handler)
+        """Set user command handler while maintaining queue functionality"""
+        self.user_command_handler = handler
+
+    def set_event_completion_handler(self, handler: Callable[[dict, int], None]):
+        self.user_event_completion_handler = handler
+
+    def _internal_event_completion_handler(self, event, status) -> None:
+        if self.user_event_completion_handler:
+            try:
+                self.user_event_completion_handler(event, status)
+            except Exception as e:
+                print(f"Error in user event completion handler: {e}")
 
     def get_command(self, timeout: int=5):
         block = timeout >= 0
@@ -56,17 +80,18 @@ class PeripheralDevice():
             return None
         return cmd
 
+    def submit_event(self, event):
+        with self.lock:
+            return self.ctx.submit_event(event)
+
     def notify_event(self, event):
-        self.lock.acquire()
-        ret = self.ctx.notify_event(event)
-        self.lock.release()
-        return ret
+        from warnings import warn
+        warn("This method has been renamed to submit_event", DeprecationWarning, 2)
+        return self.submit_event(event)
 
     def register_file_ops(self, fops):
-        self.lock.acquire()
-        ret = self.ctx.register_file_ops(0, fops)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.register_file_ops(0, fops)
 
     def is_sc_active(self):
         return self.ctx.is_sc_active()
@@ -95,10 +120,8 @@ class PeripheralDevice():
         self.thread.start()
 
     def get_file_tx_status(self):
-        self.lock.acquire()
-        ret = self.ctx.get_file_tx_status(0)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.get_file_tx_status(0)
 
     def stop(self):
         if not self.thread: