libosdp 3.1.0__tar.gz → 3.2.0__tar.gz

{libosdp-3.1.0 → libosdp-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libosdp
-Version: 3.1.0
+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
@@ -85,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
@@ -116,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.1.0 → libosdp-3.2.0}/README.md

@@ -64,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
@@ -95,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.1.0 → libosdp-3.2.0}/libosdp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libosdp
-Version: 3.1.0
+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
@@ -85,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
@@ -116,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.1.0 → libosdp-3.2.0}/libosdp.egg-info/SOURCES.txt

@@ -51,5 +51,4 @@ 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.1.0 → 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.1.0 → 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
 #
@@ -60,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.1.0 → 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 = []
@@ -27,11 +28,17 @@ class ControlPanel():
             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
@@ -39,15 +46,18 @@ 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]):
         """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 _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
@@ -63,6 +73,15 @@ class ControlPanel():
 
         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
@@ -73,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)
@@ -84,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(
@@ -100,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):
@@ -114,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)
@@ -133,10 +146,13 @@ class ControlPanel():
 
     def submit_command(self, address, cmd):
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.submit_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
@@ -145,52 +161,38 @@ class ControlPanel():
 
     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)
-        self.lock.acquire()
-        ret = self.ctx.disable_pd(pd)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.disable_pd(pd)
 
     def enable_pd(self, address: int) -> bool:
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.enable_pd(pd)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.enable_pd(pd)
 
     def is_pd_enabled(self, address: int) -> bool:
         pd = self.pd_addr.index(address)
-        self.lock.acquire()
-        ret = self.ctx.is_pd_enabled(pd)
-        self.lock.release()
-        return ret
+        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:

{libosdp-3.1.0 → 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.1.0 → 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.1.0 → 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,15 +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())
         # 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
@@ -32,9 +39,8 @@ 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 _internal_command_handler(self, command) -> Tuple[int, dict]:
@@ -56,6 +62,16 @@ class PeripheralDevice():
         """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
         try:
@@ -65,10 +81,8 @@ class PeripheralDevice():
         return cmd
 
     def submit_event(self, event):
-        self.lock.acquire()
-        ret = self.ctx.submit_event(event)
-        self.lock.release()
-        return ret
+        with self.lock:
+            return self.ctx.submit_event(event)
 
     def notify_event(self, event):
         from warnings import warn
@@ -76,10 +90,8 @@ class PeripheralDevice():
         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()
@@ -108,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:

{libosdp-3.1.0 → libosdp-3.2.0}/setup.py

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2020-2024 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
+#  Copyright (c) 2020-2026 Siddharth Chandrasekaran <sidcha.dev@gmail.com>
 #
 #  SPDX-License-Identifier: Apache-2.0
 #
@@ -11,7 +11,7 @@ import shutil
 import subprocess
 
 project_name = "libosdp"
-project_version = "3.1.0"
+project_version = "3.2.0"
 current_dir = os.path.dirname(os.path.realpath(__file__))
 repo_root = os.path.realpath(os.path.join(current_dir, ".."))
 
@@ -23,17 +23,47 @@ def add_prefix_to_path(src_list, path, check_files=True):
                 raise RuntimeError(f"Path '{path}' does not exist")
     return paths
 
-def exec_cmd(cmd):
-    r = subprocess.run(cmd, capture_output = True, text = True)
-    return r.stdout.strip()
+def exec_cmd(cmd, cwd=None):
+    r = subprocess.run(cmd, capture_output=True, text=True, cwd=cwd)
+    return r.returncode, r.stdout.strip()
 
 def get_git_info():
-    d = {}
-    d["branch"] = exec_cmd(["git", "rev-parse", "--abbrev-ref", "HEAD"])
-    d["tag"] = exec_cmd([ "git", "describe", "--exact-match", "--tags" ])
-    d["diff"] = exec_cmd([ "git", "diff", "--quiet", "--exit-code" ])
-    d["rev"] = exec_cmd(["git", "log", "--pretty=format:%h", "-n", "1"])
-    d["root"] = exec_cmd(["git", "rev-parse", "--show-toplevel"])
+    d = {
+        "branch": "None",
+        "tag": "",
+        "diff": "",
+        "rev": "",
+        "root": repo_root,
+    }
+
+    rc, _ = exec_cmd(["git", "rev-parse", "--is-inside-work-tree"], cwd=repo_root)
+    if rc != 0:
+        return d
+
+    rc, root = exec_cmd(["git", "rev-parse", "--show-toplevel"], cwd=repo_root)
+    if rc == 0 and root:
+        d["root"] = root
+
+    rc, branch = exec_cmd(["git", "symbolic-ref", "--short", "-q", "HEAD"], cwd=repo_root)
+    if rc == 0 and branch:
+        d["branch"] = branch
+    else:
+        d["branch"] = "detached"
+
+    rc, rev = exec_cmd(["git", "describe", "--tags", "--long", "--always", "--abbrev=7"], cwd=repo_root)
+    if rc == 0:
+        d["rev"] = rev
+
+    rc, tag = exec_cmd(["git", "describe", "--exact-match", "--tags", "HEAD"], cwd=repo_root)
+    if rc == 0 and tag:
+        d["tag"] = tag
+
+    rc, status = exec_cmd(["git", "status", "--porcelain", "--untracked-files=normal"], cwd=repo_root)
+    if rc == 0 and status:
+        d["diff"] = "+"
+        if d["tag"]:
+            d["tag"] = d["tag"] + "+"
+
     return d
 
 def configure_file(file, replacements):
@@ -78,7 +108,6 @@ def try_vendor_sources(src_dir, src_files, vendor_dir):
 utils_sources = [
     "utils/src/list.c",
     "utils/src/queue.c",
-    "utils/src/slab.c",
     "utils/src/utils.c",
     "utils/src/logger.c",
     "utils/src/disjoint_set.c",
@@ -138,6 +167,19 @@ other_files = [
     "utils/src/pcap_gen.c",
 ]
 
+definitions = [
+    "OPT_OSDP_PACKET_TRACE",
+    "OPT_OSDP_RX_ZERO_COPY",
+    # "OPT_OSDP_DATA_TRACE",
+    # "OPT_OSDP_SKIP_MARK_BYTE",
+]
+
+app_owned_queue_data = os.getenv("OPT_OSDP_APP_OWNED_QUEUE_DATA", "").lower()
+if app_owned_queue_data in ("0", "false", "no", "off"):
+    utils_sources.append("utils/src/slab.c")
+else:
+    definitions.append("OPT_OSDP_APP_OWNED_QUEUE_DATA")
+
 source_files = utils_sources + lib_sources + osdp_sys_sources
 
 try_vendor_sources(
@@ -146,12 +188,6 @@ try_vendor_sources(
     "vendor"
 )
 
-definitions = [
-    "OPT_OSDP_PACKET_TRACE",
-    # "OPT_OSDP_DATA_TRACE",
-    # "OPT_OSDP_SKIP_MARK_BYTE",
-]
-
 if ("OPT_OSDP_PACKET_TRACE" in definitions or
     "OPT_OSDP_DATA_TRACE" in definitions):
     source_files += [
@@ -171,7 +207,7 @@ include_dirs = [
 
 compile_args = (
     [ "-I" + path for path in include_dirs ] +
-    [ "-D" + define for define in definitions ]
+    [ "-D" + define + "=1" for define in definitions ]
 )
 
 if os.path.exists("README.md"):