pysnmp-sync-adapter 1.0.0__tar.gz

pysnmp_sync_adapter-1.0.0/LICENCE.txt

@@ -0,0 +1 @@
+EUROPEAN UNION PUBLIC LICENCE v. 1.2
                          Licensed under the EUPL
                                                         Appendix

pysnmp_sync_adapter-1.0.0/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: pysnmp_sync_adapter
+Version: 1.0.0
+Summary: Synchronous wrapper adapters for pysnmp v1arch asyncio HLAPI
+Author: Ircama
+License-Expression: EUPL-1.2
+Project-URL: Homepage, https://github.com/Ircama/pysnmp_sync_adapter
+Project-URL: Repository, https://github.com/Ircama/pysnmp_sync_adapter
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: pysnmp>=5.0.0
+Dynamic: license-file
+
+# pysnmp_sync_adapter
+
+[![PyPI](https://img.shields.io/pypi/v/pysnmp_sync_adapter.svg?maxAge=2592000)](https://pypi.org/project/pysnmp_sync_adapter/)
+[![PyPI download month](https://img.shields.io/pypi/dm/pysnmp_sync_adapter.svg)](https://pypi.python.org/pypi/pysnmp_sync_adapter/)
+
+**Lightweight Synchronous Adapter for PySNMP v1arch AsyncIO HLAPI**
+
+---
+
+This package provides lightweight, blocking wrappers around `pysnmp.hlapi.v1arch.asyncio`, enabling synchronous use of the SNMPv1 high-level API without requiring direct `asyncio` management.
+
+## Features
+
+* Drop-in synchronous alternatives: `get_cmd_sync`, `walk_cmd_sync`, `set_cmd_sync`, and others.
+* Reuses or creates a single shared event loop for efficiency.
+* Pre-creates and reuses `UdpTransportTarget` to minimize connection overhead.
+
+These adapters allow to call the familiar HLAPI functions in a purely synchronous style (e.g. in scripts, GUIs like Tkinter, or blocking contexts) without having to manage `asyncio` directly.
+
+This restores the synchronous experience familiar from earlier [PySNMP](https://github.com/lextudio/pysnmp) versions. Native sync HLAPI wrappers were [deprecated](https://github.com/lextudio/pysnmp/issues/104) in recent releases in favor of `asyncio`.
+
+### Provided Methods
+
+| Synchronous Function | AsyncIO Equivalent          |
+| -------------------- | --------------------------- |
+| `get_cmd_sync`       | `get_cmd`                   |
+| `next_cmd_sync`      | `next_cmd`                  |
+| `set_cmd_sync`       | `set_cmd`                   |
+| `bulk_cmd_sync`      | `bulk_cmd`                  |
+| `walk_cmd_sync`      | `walk_cmd` (async-gen)      |
+| `bulk_walk_cmd_sync` | `bulk_walk_cmd` (async-gen) |
+
+### Internal Utilities
+
+* `ensure_loop()` — retrieves or creates the event loop, ensuring one loop per process
+* `create_transport()` — pre-awaits `UdpTransportTarget.create()` once per host/port
+* `_sync_coro()` — runs a coroutine to completion synchronously
+* `_sync_agen()` — consumes async generators (e.g., for walk operations) into a list
+* `make_sync()` — decorator to convert HLAPI coroutines into sync functions
+
+By avoiding per-call event loop instantiation and by reusing transport targets, this implementation significantly reduces runtime overhead in tight polling or query loops.
+
+---
+
+## Installation
+
+```bash
+pip install pysnmp_sync_adapter
+```
+
+## Quick Start
+
+```python
+from pysnmp_sync_adapter import (
+    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
+    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
+)
+from pysnmp.hlapi.v1arch.asyncio import SnmpDispatcher, CommunityData, ObjectType, ObjectIdentity
+
+dispatcher = SnmpDispatcher()
+transport = create_transport('demo.pysnmp.com', 161)
+
+err, status, index, var_binds = get_cmd_sync(
+    dispatcher,
+    CommunityData('public', mpModel=0),
+    transport,
+    ObjectType(ObjectIdentity('1.3.6.1.2.1.1.1.0'))
+)
+
+for name, val in var_binds:
+    print(f'{name} = {val}')
+```
+
+## Usage
+
+```python
+import asyncio
+import platform
+from pysnmp.hlapi.v1arch.asyncio import *
+from pysnmp_sync_adapter import (
+    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
+    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
+)
+
+if platform.system()=='Windows':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+community = 'public'
+dispatcher = SnmpDispatcher()
+auth_data = CommunityData(community, mpModel=0)
+
+print("\n--> get_cmd_sync")
+error_indication, error_status, error_index, var_binds = get_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0))
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> set_cmd_sync")
+error_indication, error_status, error_index, var_binds = set_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0), 'Linux i386')
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> next_cmd_sync")
+error_indication, error_status, error_index, var_binds = next_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> bulk_cmd_sync")
+error_indication, error_status, error_index, var_binds = bulk_cmd_sync(
+    dispatcher,
+    CommunityData('public'),
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    0, 2,
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> walk_cmd_sync")
+objects = walk_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr'))
+)
+for error_indication, error_status, error_index, var_binds in objects:
+    for name, val in var_binds:
+        print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> bulk_walk_cmd_sync")
+objects = bulk_walk_cmd_sync(
+    dispatcher,
+    CommunityData('public'),
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    0, 25,
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr')))
+for error_indication, error_status, error_index, var_binds in objects:
+    for name, val in var_binds:
+        print(name.prettyPrint(), '=', val.prettyPrint())
+```
+
+## Limitations
+
+- These adapters block the calling thread until the SNMP operation completes.
+- If the host app already drives an asyncio loop, calling these wrappers on that same loop can error or deadlock unless isolated (e.g. in a separate thread).
+- The only way those calls give up on a slow or unresponsive SNMP peer is via the low-level socket own timeout; there’s no exposed mechanism to cancel the underlying asyncio task.
+
+## Contributing
+
+Contributions are welcome! Please follow standard guidelines:
+
+- Fork the repository
+- Create a feature branch
+- Submit a Pull Request
+
+## License
+
+EUPL-1.2 License - See [LICENSE](LICENSE.txt) for details.

pysnmp_sync_adapter-1.0.0/README.md

@@ -0,0 +1 @@
---
---
+# pysnmp_sync_adapter
    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
    dispatcher,
    CommunityData('public', mpModel=0),
    transport,
    ObjectType(ObjectIdentity('1.3.6.1.2.1.1.1.0'))
    print(f'{name} = {val}')
    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    dispatcher,
    auth_data,
    create_transport('demo.pysnmp.com', 161, timeout=2),
    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0))
    print(name.prettyPrint(), '=', val.prettyPrint())
    dispatcher,
    auth_data,
    create_transport('demo.pysnmp.com', 161, timeout=2),
    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0), 'Linux i386')
    print(name.prettyPrint(), '=', val.prettyPrint())
    dispatcher,
    auth_data,
    create_transport('demo.pysnmp.com', 161, timeout=2),
    ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
    print(name.prettyPrint(), '=', val.prettyPrint())
    dispatcher,
    CommunityData('public'),
    create_transport('demo.pysnmp.com', 161, timeout=2),
    0, 2,
    ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
    print(name.prettyPrint(), '=', val.prettyPrint())
    dispatcher,
    auth_data,
    create_transport('demo.pysnmp.com', 161, timeout=2),
    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr'))
    for name, val in var_binds:
        print(name.prettyPrint(), '=', val.prettyPrint())
    dispatcher,
    CommunityData('public'),
    create_transport('demo.pysnmp.com', 161, timeout=2),
    0, 25,
    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr')))
    for name, val in var_binds:
        print(name.prettyPrint(), '=', val.prettyPrint())
- These adapters block the calling thread until the SNMP operation completes.
- If the host app already drives an asyncio loop, calling these wrappers on that same loop can error or deadlock unless isolated (e.g. in a separate thread).
- The only way those calls give up on a slow or unresponsive SNMP peer is via the low-level socket own timeout; there’s no exposed mechanism to cancel the underlying asyncio task.
- Fork the repository
- Create a feature branch
- Submit a Pull Request

pysnmp_sync_adapter-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "pysnmp_sync_adapter"
+version = "1.0.0"
+description = "Synchronous wrapper adapters for pysnmp v1arch asyncio HLAPI"
+authors = [
+    { name="Ircama" }
+]
+license = "EUPL-1.2"
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+    "pysnmp>=5.0.0"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/Ircama/pysnmp_sync_adapter"
+"Repository" = "https://github.com/Ircama/pysnmp_sync_adapter"
+
+[build-system]
+requires = ["setuptools>=67.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["pysnmp_sync_adapter"]

pysnmp_sync_adapter-1.0.0/pysnmp_sync_adapter/__init__.py

@@ -0,0 +1,4 @@
+from .sync_adapters import (
+    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
+    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
+)

pysnmp_sync_adapter-1.0.0/pysnmp_sync_adapter/sync_adapters.py

@@ -0,0 +1,63 @@
+import asyncio
+import functools
+from pysnmp.hlapi.v1arch.asyncio import *
+
+def ensure_loop():
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    return loop
+
+def create_transport(host: str, port: int, timeout: float = 1.0):
+    """
+    Await the async factory to build UdpTransportTarget once,
+    using our shared loop.
+    """
+    loop = ensure_loop()
+    coro = UdpTransportTarget.create((host, port), timeout=timeout)
+    return loop.run_until_complete(coro)
+
+def _sync_coro(coro):
+    """
+    Run the given coroutine to completion on the shared loop,
+    scheduling if needed.
+    """
+    loop = ensure_loop()
+    if loop.is_running():
+        fut = asyncio.ensure_future(coro)
+        return loop.run_until_complete(fut)
+    return loop.run_until_complete(coro)
+
+def _sync_agen(agen):
+    """
+    Consume an async-generator into a list synchronously.
+    """
+    async def _collector():
+        items = []
+        async for item in agen:
+            items.append(item)
+        return items
+
+    return _sync_coro(_collector())
+
+def make_sync(fn):
+    """Turn any pysnmp async‐HLAPI fn into a sync wrapper."""
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        return _sync_coro(fn(*args, **kwargs))
+    return wrapper
+
+get_cmd_sync = make_sync(get_cmd)
+next_cmd_sync = make_sync(next_cmd)
+set_cmd_sync = make_sync(set_cmd)
+bulk_cmd_sync = make_sync(bulk_cmd)
+
+def walk_cmd_sync(*args, **kwargs):
+    """Sync wrapper for walk_cmd (async generator)."""
+    return _sync_agen(walk_cmd(*args, **kwargs))
+
+def bulk_walk_cmd_sync(*args, **kwargs):
+    """Sync wrapper for bulk_walk_cmd (async generator)."""
+    return _sync_agen(bulk_walk_cmd(*args, **kwargs))

pysnmp_sync_adapter-1.0.0/pysnmp_sync_adapter.egg-info/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: pysnmp_sync_adapter
+Version: 1.0.0
+Summary: Synchronous wrapper adapters for pysnmp v1arch asyncio HLAPI
+Author: Ircama
+License-Expression: EUPL-1.2
+Project-URL: Homepage, https://github.com/Ircama/pysnmp_sync_adapter
+Project-URL: Repository, https://github.com/Ircama/pysnmp_sync_adapter
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: pysnmp>=5.0.0
+Dynamic: license-file
+
+# pysnmp_sync_adapter
+
+[![PyPI](https://img.shields.io/pypi/v/pysnmp_sync_adapter.svg?maxAge=2592000)](https://pypi.org/project/pysnmp_sync_adapter/)
+[![PyPI download month](https://img.shields.io/pypi/dm/pysnmp_sync_adapter.svg)](https://pypi.python.org/pypi/pysnmp_sync_adapter/)
+
+**Lightweight Synchronous Adapter for PySNMP v1arch AsyncIO HLAPI**
+
+---
+
+This package provides lightweight, blocking wrappers around `pysnmp.hlapi.v1arch.asyncio`, enabling synchronous use of the SNMPv1 high-level API without requiring direct `asyncio` management.
+
+## Features
+
+* Drop-in synchronous alternatives: `get_cmd_sync`, `walk_cmd_sync`, `set_cmd_sync`, and others.
+* Reuses or creates a single shared event loop for efficiency.
+* Pre-creates and reuses `UdpTransportTarget` to minimize connection overhead.
+
+These adapters allow to call the familiar HLAPI functions in a purely synchronous style (e.g. in scripts, GUIs like Tkinter, or blocking contexts) without having to manage `asyncio` directly.
+
+This restores the synchronous experience familiar from earlier [PySNMP](https://github.com/lextudio/pysnmp) versions. Native sync HLAPI wrappers were [deprecated](https://github.com/lextudio/pysnmp/issues/104) in recent releases in favor of `asyncio`.
+
+### Provided Methods
+
+| Synchronous Function | AsyncIO Equivalent          |
+| -------------------- | --------------------------- |
+| `get_cmd_sync`       | `get_cmd`                   |
+| `next_cmd_sync`      | `next_cmd`                  |
+| `set_cmd_sync`       | `set_cmd`                   |
+| `bulk_cmd_sync`      | `bulk_cmd`                  |
+| `walk_cmd_sync`      | `walk_cmd` (async-gen)      |
+| `bulk_walk_cmd_sync` | `bulk_walk_cmd` (async-gen) |
+
+### Internal Utilities
+
+* `ensure_loop()` — retrieves or creates the event loop, ensuring one loop per process
+* `create_transport()` — pre-awaits `UdpTransportTarget.create()` once per host/port
+* `_sync_coro()` — runs a coroutine to completion synchronously
+* `_sync_agen()` — consumes async generators (e.g., for walk operations) into a list
+* `make_sync()` — decorator to convert HLAPI coroutines into sync functions
+
+By avoiding per-call event loop instantiation and by reusing transport targets, this implementation significantly reduces runtime overhead in tight polling or query loops.
+
+---
+
+## Installation
+
+```bash
+pip install pysnmp_sync_adapter
+```
+
+## Quick Start
+
+```python
+from pysnmp_sync_adapter import (
+    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
+    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
+)
+from pysnmp.hlapi.v1arch.asyncio import SnmpDispatcher, CommunityData, ObjectType, ObjectIdentity
+
+dispatcher = SnmpDispatcher()
+transport = create_transport('demo.pysnmp.com', 161)
+
+err, status, index, var_binds = get_cmd_sync(
+    dispatcher,
+    CommunityData('public', mpModel=0),
+    transport,
+    ObjectType(ObjectIdentity('1.3.6.1.2.1.1.1.0'))
+)
+
+for name, val in var_binds:
+    print(f'{name} = {val}')
+```
+
+## Usage
+
+```python
+import asyncio
+import platform
+from pysnmp.hlapi.v1arch.asyncio import *
+from pysnmp_sync_adapter import (
+    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
+    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
+)
+
+if platform.system()=='Windows':
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+community = 'public'
+dispatcher = SnmpDispatcher()
+auth_data = CommunityData(community, mpModel=0)
+
+print("\n--> get_cmd_sync")
+error_indication, error_status, error_index, var_binds = get_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0))
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> set_cmd_sync")
+error_indication, error_status, error_index, var_binds = set_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0), 'Linux i386')
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> next_cmd_sync")
+error_indication, error_status, error_index, var_binds = next_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> bulk_cmd_sync")
+error_indication, error_status, error_index, var_binds = bulk_cmd_sync(
+    dispatcher,
+    CommunityData('public'),
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    0, 2,
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
+)
+print(error_indication, error_status, error_index)
+for name, val in var_binds:
+    print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> walk_cmd_sync")
+objects = walk_cmd_sync(
+    dispatcher,
+    auth_data,
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr'))
+)
+for error_indication, error_status, error_index, var_binds in objects:
+    for name, val in var_binds:
+        print(name.prettyPrint(), '=', val.prettyPrint())
+
+print("\n--> bulk_walk_cmd_sync")
+objects = bulk_walk_cmd_sync(
+    dispatcher,
+    CommunityData('public'),
+    create_transport('demo.pysnmp.com', 161, timeout=2),
+    0, 25,
+    ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr')))
+for error_indication, error_status, error_index, var_binds in objects:
+    for name, val in var_binds:
+        print(name.prettyPrint(), '=', val.prettyPrint())
+```
+
+## Limitations
+
+- These adapters block the calling thread until the SNMP operation completes.
+- If the host app already drives an asyncio loop, calling these wrappers on that same loop can error or deadlock unless isolated (e.g. in a separate thread).
+- The only way those calls give up on a slow or unresponsive SNMP peer is via the low-level socket own timeout; there’s no exposed mechanism to cancel the underlying asyncio task.
+
+## Contributing
+
+Contributions are welcome! Please follow standard guidelines:
+
+- Fork the repository
+- Create a feature branch
+- Submit a Pull Request
+
+## License
+
+EUPL-1.2 License - See [LICENSE](LICENSE.txt) for details.

pysnmp_sync_adapter-1.0.0/pysnmp_sync_adapter.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENCE.txt
+README.md
+pyproject.toml
+pysnmp_sync_adapter/__init__.py
+pysnmp_sync_adapter/sync_adapters.py
+pysnmp_sync_adapter.egg-info/PKG-INFO
+pysnmp_sync_adapter.egg-info/SOURCES.txt
+pysnmp_sync_adapter.egg-info/dependency_links.txt
+pysnmp_sync_adapter.egg-info/requires.txt
+pysnmp_sync_adapter.egg-info/top_level.txt
+tests/test_pysnmp_sync.py

pysnmp_sync_adapter-1.0.0/pysnmp_sync_adapter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pysnmp_sync_adapter-1.0.0/pysnmp_sync_adapter.egg-info/requires.txt

@@ -0,0 +1 @@
+pysnmp>=5.0.0

pysnmp_sync_adapter-1.0.0/pysnmp_sync_adapter.egg-info/top_level.txt

@@ -0,0 +1 @@
+pysnmp_sync_adapter

pysnmp_sync_adapter-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pysnmp_sync_adapter-1.0.0/tests/test_pysnmp_sync.py

@@ -0,0 +1 @@
+import asyncio
    get_cmd_sync, next_cmd_sync, set_cmd_sync, bulk_cmd_sync,
    walk_cmd_sync, bulk_walk_cmd_sync, create_transport
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    err, status, index, binds = get_cmd_sync(
        dispatcher,
        auth_data,
        create_transport('demo.pysnmp.com', 161, timeout=2),
        ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0))
    )
    assert err is None
    assert not status
    assert binds
    assert len(binds) == 1
    assert len(list(binds[0])) == 2
    name, value = binds[0]
    assert name.prettyPrint() == "SNMPv2-MIB::sysDescr.0"
    assert value.prettyPrint() == "#SNMP Agent on .NET Standard"
    err, status, index, binds = set_cmd_sync(
        dispatcher,
        auth_data,
        create_transport('demo.pysnmp.com', 161, timeout=2),
        ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0))
    )
    assert err is None
    assert str(status) == 'noSuchName'
    assert binds
    assert len(binds) == 1
    assert len(list(binds[0])) == 2
    name, value = binds[0]
    assert name.prettyPrint() == "SNMPv2-MIB::sysDescr.0"
    assert value.prettyPrint() == ""
    err, status, index, binds = next_cmd_sync(
        dispatcher,
        auth_data,
        create_transport('demo.pysnmp.com', 161, timeout=2),
        ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0))
    )
    assert err is None
    assert str(status) == 'noError'
    assert binds
    assert len(binds) == 1
    assert len(list(binds[0])) == 2
    name, value = binds[0]
    assert name.prettyPrint() == "SNMPv2-MIB::sysObjectID.0"
    assert value.prettyPrint() == "SNMPv2-SMI::internet"
    err, status, index, binds = bulk_cmd_sync(
        dispatcher,
        CommunityData(community),
        create_transport('demo.pysnmp.com', 161, timeout=2),
        0, 2,
        ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
    )
    assert err is None
    assert str(status) == 'noError'
    assert binds
    assert len(binds) == 2
    assert len(list(binds[0])) == 2
    assert len(list(binds[1])) == 2
    name, value = binds[0]
    assert name.prettyPrint() == "SNMPv2-MIB::sysDescr.0"
    assert value.prettyPrint() == "#SNMP Agent on .NET Standard"
    name, value = binds[1]
    assert name.prettyPrint() == "SNMPv2-MIB::sysObjectID.0"
    assert value.prettyPrint() == "SNMPv2-SMI::internet"
    objects = walk_cmd_sync(
        dispatcher,
        auth_data,
        create_transport('demo.pysnmp.com', 161, timeout=2),
        ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
    )
    assert len(objects) == 69
    err, status, index, binds = objects[0]
    assert str(status) == 'noError'
    assert binds
    assert len(binds) == 1
    assert len(list(binds[0])) == 2
    name, value = binds[0]
    assert name.prettyPrint() == "SNMPv2-MIB::sysDescr.0"
    assert value.prettyPrint() == "#SNMP Agent on .NET Standard"
    objects = bulk_walk_cmd_sync(
        dispatcher,
        CommunityData(community),
        create_transport('demo.pysnmp.com', 161, timeout=2),
        0, 25,
        ObjectType(ObjectIdentity('SNMPv2-MIB', 'system'))
    )
    assert len(objects) == 3
    err, status, index, binds = objects[0]
    assert str(status) == 'noError'
    assert binds
    assert len(binds) == 25
    assert len(list(binds[0])) == 2
    name, value = binds[0]
    assert name.prettyPrint() == "SNMPv2-MIB::sysDescr.0"
    assert value.prettyPrint() == "#SNMP Agent on .NET Standard"