scrapli 2.0.0a0__py3-none-macosx_11_0_arm64.whl

scrapli/ffi_types.py

@@ -0,0 +1,154 @@
+"""scrapli.ffi_types"""
+
+from ctypes import (
+    CFUNCTYPE,
+    POINTER,
+    Structure,
+    c_bool,
+    c_char_p,
+    c_int,
+    c_size_t,
+    c_uint,
+    c_uint8,
+    c_uint64,
+    c_void_p,
+    cast,
+)
+from typing import TypeAlias
+
+DriverPointer = c_void_p
+OperationId = c_uint
+
+# mypy seems to dislike the pointer bits, but these do accurately reflect the api surface,
+# so... we'll just tell mypy to chill out on these
+OperationIdPointer: TypeAlias = POINTER(OperationId)  # type: ignore[valid-type]
+CancelPointer: TypeAlias = POINTER(c_bool)  # type: ignore[valid-type]
+ZigSlicePointer: TypeAlias = POINTER("ZigSlice")  # type: ignore[valid-type, call-overload]
+StringPointer: TypeAlias = POINTER(c_char_p)  # type: ignore[valid-type]
+IntPointer: TypeAlias = POINTER(c_int)  # type: ignore[valid-type]
+U64Pointer: TypeAlias = POINTER(c_uint64)  # type: ignore[valid-type]
+BoolPointer: TypeAlias = POINTER(c_bool)  # type: ignore[valid-type]
+
+
+class ZigU64Slice(Structure):
+    """
+    A struct representing a slice of u64 in zig.
+
+    Args:
+        N/A
+
+    Returns:
+        None
+
+    Raises:
+        N/A
+
+    """
+
+    # fields must be declared this way to be c types compatible
+    _fields_ = [  # noqa: RUF012
+        ("ptr", POINTER(c_uint64)),
+        ("len", c_size_t),
+    ]
+
+    def __init__(self, size: c_int):
+        self.ptr = cast((c_uint64 * size.value)(), POINTER(c_uint64))
+        self.len = size.value
+
+        super().__init__()
+
+    def get_contents(self) -> list[int]:
+        """
+        Return the contents of the slice as a list of ints.
+
+        Args:
+            N/A
+
+        Returns:
+            list[int]: the slice contents
+
+        Raises:
+            N/A
+
+        """
+        return [self.ptr[i] for i in range(self.len)]
+
+
+class ZigSlice(Structure):
+    """
+    A struct representing a slice of u8 (a string) in zig.
+
+    Args:
+        N/A
+
+    Returns:
+        None
+
+    Raises:
+        N/A
+
+    """
+
+    _fields_ = [  # noqa: RUF012
+        ("ptr", POINTER(c_uint8)),
+        ("len", c_size_t),
+        ("value", c_char_p),
+    ]
+
+    def __init__(self, size: c_int):
+        self.ptr = cast((c_uint8 * size.value)(), POINTER(c_uint8))
+        self.len = size.value
+
+        super().__init__()
+
+    def get_contents(self) -> bytes:
+        """
+        Return the contents of the slice as bytes.
+
+        Args:
+            N/A
+
+        Returns:
+            bytes: the slice contents
+
+        Raises:
+            N/A
+
+        """
+        return bytes(cast(self.ptr, POINTER(c_uint8 * self.len)).contents)
+
+    def get_decoded_contents(self) -> str:
+        """
+        Return the contents of the slice as str.
+
+        Args:
+            N/A
+
+        Returns:
+            bytes: the slice contents
+
+        Raises:
+            N/A
+
+        """
+        return self.get_contents().decode()
+
+
+def to_c_string(s: str) -> c_char_p:
+    """
+    Accepts a string and converts it to a c_char_p.
+
+    Args:
+        s: the string-like thing to convert to a c_char_p
+
+    Returns:
+        c_char_p: the converted string
+
+    Raises:
+        N/A
+
+    """
+    return c_char_p(s.encode(encoding="utf-8"))
+
+
+LogFuncCallback: TypeAlias = CFUNCTYPE(None, c_uint8, POINTER(ZigSlice))  # type: ignore[valid-type]

scrapli/helper.py

@@ -0,0 +1,95 @@
+"""scrapli.helper"""
+
+from asyncio import get_event_loop
+from os import read
+from pathlib import Path
+from select import select
+
+from scrapli.exceptions import OperationException
+
+
+def resolve_file(file: str) -> str:
+    """
+    Resolve file from provided string
+
+    Args:
+        file: string path to file
+
+    Returns:
+        str: resolved/expanded (if applicable) string path to file
+
+    Raises:
+        OperationException: if file cannot be resolved
+
+    """
+    if Path(file).is_file():
+        return str(Path(file))
+    if Path(file).expanduser().is_file():
+        return str(Path(file).expanduser())
+
+    raise OperationException(f"path `{file}` could not be resolved")
+
+
+def wait_for_available_operation_result(fd: int) -> None:
+    """
+    Wait for the next operation to be complete.
+
+    Args:
+        fd: the fd to wait on
+
+    Returns:
+        None
+
+    Raises:
+        N/A
+
+    """
+    _, _, _ = select([fd], [], [])
+    read(fd, 1)
+
+
+async def _wait_for_fd_readable(fd: int) -> None:
+    """
+    Wait for fd to be readable.
+
+    Args:
+        fd: the fd to wait on
+
+    Returns:
+        None
+
+    Raises:
+        N/A
+
+    """
+    loop = get_event_loop()
+
+    fut = loop.create_future()
+
+    def on_ready() -> None:
+        loop.remove_reader(fd)
+
+        fut.set_result(None)
+
+    loop.add_reader(fd, on_ready)
+
+    await fut
+
+
+async def wait_for_available_operation_result_async(fd: int) -> None:
+    """
+    Wait for the next operation to be complete.
+
+    Args:
+        fd: the fd to wait on
+
+    Returns:
+        None
+
+    Raises:
+        N/A
+
+    """
+    await _wait_for_fd_readable(fd)
+
+    read(fd, 1)

scrapli/lib/__init__.py

@@ -0,0 +1 @@
+"""scrapli.lib"""