pfnc 0.1.0__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

dataspree/pfnc/genicam/data_types.pyi

@@ -0,0 +1,115 @@
+from .._internal.registry import MappingSnapshot as MappingSnapshot, Registry as Registry
+from .._internal.utils import all_implementations as all_implementations
+from _typeshed import Incomplete
+from abc import ABCMeta, abstractmethod
+from enum import Enum
+from typing import TypeGuard
+
+logger: Incomplete
+
+class DefaultDataType(Enum):
+    """Enumeration for default data types."""
+    UNSIGNED = ''
+    SIGNED = 's'
+    FLOAT = 'f'
+DataType = DefaultDataType | str
+
+class DataTypeRegistry(Registry[str, DataType]):
+    """Registry for data types with immutable defaults."""
+    def __init__(self) -> None:
+        """Initialize the registry and register default data types."""
+    def register(self, name: str, value: DataType | None = None) -> None:
+        """Register a custom single-letter data type."""
+    def restore(self, snap: MappingSnapshot[str, DataType]) -> None:
+        """Restore a snapshot."""
+    @classmethod
+    def default_snapshot(cls) -> MappingSnapshot[str, DataType]:
+        """Return a snapshot that is empty except for the default data types."""
+
+DATA_TYPE_REGISTRY: DataTypeRegistry
+
+def is_data_type(potential_data_type: object) -> TypeGuard[DataType]:
+    """Checks if the given object is a valid data type.
+
+    Args:
+        potential_data_type (Any): The object to check.
+
+    Returns:
+        bool: True if the object is a valid data type, False otherwise.
+    """
+def datatype_name(data_type: DataType, multiple_designators: bool = False) -> str:
+    """Returns the string representation of a data type.
+
+    Args:
+        data_type (DataType): The data type.
+        multiple_designators (bool): Whether to include the 'u' designator for unsigned.
+
+    Returns:
+        str: The string representation of the data type.
+    """
+
+class DataTypes(metaclass=ABCMeta):
+    """Abstract base class for data type designations."""
+    @abstractmethod
+    def designation(self) -> str:
+        """Returns the string representation of the data type."""
+    @abstractmethod
+    def __len__(self) -> int:
+        """Returns the number of elements in the data type."""
+    @abstractmethod
+    def __getitem__(self, item: int) -> DataType:
+        """Returns the element at the specified index."""
+    @staticmethod
+    def create(full_designation: str, number_of_channels: int) -> list[tuple['DataTypes', str]]:
+        """Creates instances of `DataTypes` based on a designation string.
+
+        Args:
+            full_designation (str): The full designation string.
+            number_of_channels (int): The number of channels.
+
+        Returns:
+            List[Tuple[DataTypes, str]]: A list of parsed `DataTypes` instances and remaining designations.
+        """
+    @staticmethod
+    def from_designation(full_designation: str, number_of_channels: int) -> list[tuple['DataTypes', str]]:
+        """Parses a designation string into `DataTypes` instances.
+
+        Args:
+            full_designation (str): The full designation string.
+            number_of_channels (int): The number of channels.
+
+        Returns:
+            List[Tuple[DataTypes, str]]: A list of parsed `DataTypes` instances and remaining designations.
+        """
+    def __eq__(self, other: object) -> bool:
+        """Returns `True` if `self` and `other` are equivalent."""
+
+class CompoundDataTypes(DataTypes):
+    """Represents a compound designation containing multiple data types."""
+    data_types: list[DataType]
+    def __init__(self, data_types: list[DataType]) -> None:
+        """Initializes a `CompoundDataTypes` instance.
+
+        Args:
+            data_types (List[DataType]): A list of data types in the compound designation.
+
+        Raises:
+            PixelFormatValueReject: If `data_types` is invalid.
+        """
+    def designation(self) -> str:
+        """Returns the designation string for the compound data types."""
+    def __len__(self) -> int:
+        """Returns the number of data types in the compound."""
+    def __getitem__(self, item: int) -> DataType:
+        """Returns the data type at the specified index."""
+    @staticmethod
+    def from_designation(full_designation: str, number_of_channels: int) -> list[tuple['DataTypes', str]]:
+        """Parses a compound data type designation.
+
+        Args:
+            full_designation (str): The full designation string.
+            number_of_channels (int): The number of channels.
+
+        Returns:
+            List[Tuple[DataTypes, str]]: A list of parsed `CompoundDataTypes` and remaining designations.
+        """

dataspree/pfnc/genicam/interface_specifics.pyi

@@ -0,0 +1,102 @@
+from .._internal.utils import all_implementations as all_implementations
+from _typeshed import Incomplete
+from abc import ABCMeta, abstractmethod
+from dataspree.pfnc.genicam.components import Components as Components
+from dataspree.pfnc.genicam.number_of_bits import Size as Size
+from typing_extensions import Self
+
+logger: Incomplete
+
+class InterfaceSpecific(metaclass=ABCMeta):
+    """Abstract base class for interface-specific pixel format designations."""
+    @abstractmethod
+    def designation(self) -> str:
+        """Returns the designation of the interface-specific format."""
+    @staticmethod
+    def create(full_designation: str, components: Components, sizes: Size) -> list[tuple['InterfaceSpecific', str]]:
+        """Creates instances of `InterfaceSpecific` based on the designation.
+
+        Args:
+            full_designation (str): The full designation string.
+            components (Components): The pixel format components.
+            sizes (Size): The sizes of the components.
+
+        Returns:
+            List[Tuple[InterfaceSpecific, str]]: A list of tuples with `InterfaceSpecific` instances and remaining
+                                                designations.
+        """
+    @classmethod
+    @abstractmethod
+    def from_designation(cls, full_designation: str, components: Components, sizes: Size) -> list[tuple[Self, str]]:
+        """Parses the designation into specific interface format instances.
+
+        Args:
+            full_designation (str): The full designation string.
+            components (Components): The pixel format components.
+            sizes (Size): The sizes of the components.
+
+        Returns:
+            List[Tuple[InterfaceSpecific, str]]: A list of tuples with parsed instances and remaining designations.
+        """
+    def __eq__(self, other: object) -> bool:
+        """Checks equality with another object."""
+
+class Planar(InterfaceSpecific):
+    """Represents the planar interface-specific format."""
+    def designation(self) -> str:
+        """Returns the planar designation."""
+    @classmethod
+    def from_designation(cls, full_designation: str, components: Components, sizes: Size) -> list[tuple[Self, str]]:
+        """Parses planar-specific designations.
+
+        Args:
+            full_designation (str): The full designation string.
+            components (Components): The pixel format components.
+            sizes (Size): The sizes of the components.
+
+        Returns:
+            List[Tuple[InterfaceSpecific, str]]: A list with a `Planar` instance if matched.
+        """
+
+class SemiPlanar(InterfaceSpecific):
+    """Represents the semi-planar interface-specific format."""
+    def designation(self) -> str:
+        """Returns the semi-planar designation."""
+    @classmethod
+    def from_designation(cls, full_designation: str, components: Components, sizes: Size) -> list[tuple[Self, str]]:
+        """Parses semi-planar-specific designations.
+
+        Args:
+            full_designation (str): The full designation string.
+            components (Components): The pixel format components.
+            sizes (Size): The sizes of the components.
+
+        Returns:
+            List[Tuple[InterfaceSpecific, str]]: A list with a `SemiPlanar` instance if matched.
+        """
+
+class ComponentsSequencing(InterfaceSpecific):
+    """Represents an interface-specific format based on component sequencing."""
+    components: tuple[str, ...]
+    def __init__(self, components: tuple[str, ...]) -> None:
+        """Initializes a `ComponentsSequencing` instance.
+
+        Args:
+            components (Tuple[str, ...]): A tuple of component names.
+        """
+    def designation(self) -> str:
+        """Returns the component sequencing designation."""
+    @classmethod
+    def from_designation(cls, full_designation: str, components: Components, sizes: Size) -> list[tuple[Self, str]]:
+        """Parses component sequencing-specific designations.
+
+        Args:
+            full_designation (str): The full designation string.
+            components (Components): The pixel format components.
+            sizes (Size): The sizes of the components.
+
+        Returns:
+            List[Tuple[InterfaceSpecific, str]]: A list of parsed instances and remaining designations.
+        """
+    def __eq__(self, other: object) -> bool:
+        """Checks equality with another object."""

dataspree/pfnc/genicam/number_of_bits.pyi

@@ -0,0 +1,53 @@
+from dataclasses import dataclass
+
+@dataclass
+class Size:
+    """Represents the size of a pixel format.
+
+    Attributes:
+        sizes (list[int]): A list of sizes for each channel.
+    """
+    sizes: list[int]
+    def __post_init__(self) -> None:
+        """Check that the sizes are all coherent."""
+    def __len__(self) -> int:
+        """Returns the number of sizes.
+
+        Returns:
+            int: The number of sizes.
+        """
+    def __getitem__(self, item: int) -> int:
+        """Gets the size at the specified index.
+
+        Args:
+            item (int): The index of the size to retrieve.
+
+        Returns:
+            int: The size at the specified index.
+        """
+    def __eq__(self, other: object) -> bool:
+        """Checks if two Size instances are equal.
+
+        Args:
+            other: The other Size instance to compare.
+
+        Returns:
+            bool: True if the instances are equal, False otherwise.
+        """
+    def designation(self) -> str:
+        """Computes the designation string for the Size instance.
+
+        Returns:
+            str: The designation string.
+        """
+    @staticmethod
+    def from_designation(designation: str, number_of_channels: int) -> tuple['Size', str] | None:
+        """Creates a Size instance from a designation string.
+
+        Args:
+            designation (str): The designation string.
+            number_of_channels (int): The number of channels.
+
+        Returns:
+            Optional[tuple[Size, str]]: A tuple containing the Size instance and the remaining substring.
+        """

dataspree/pfnc/genicam/packing_types.pyi

@@ -0,0 +1,81 @@
+from .._internal.registry import MappingSnapshot as MappingSnapshot, Registry as Registry
+from .._internal.utils import join_designators as join_designators
+from _typeshed import Incomplete
+from enum import Enum
+
+logger: Incomplete
+
+class PaddingType(Enum):
+    """Enumeration of padding types for pixel formats."""
+    PACKED = 'p'
+    GROUPED = 'g'
+    UNPACKED = ''
+
+class PaddingTypeNameRegistry(Registry[str, PaddingType]):
+    """Registry for padding type names with immutable defaults."""
+    def __init__(self) -> None:
+        """Initialize the registry and register default padding type names."""
+    def register(self, name: str, value: PaddingType) -> None:
+        """Register a padding type name, rejecting changes to defaults."""
+    def restore(self, snap: MappingSnapshot[str, PaddingType]) -> None:
+        """Restore a snapshot, ensuring defaults are present and unchanged.
+
+        Raises:
+            ValueError: If the snapshot is missing defaults or changes their values.
+        """
+    @classmethod
+    def default_snapshot(cls) -> MappingSnapshot[str, PaddingType]:
+        """Return a snapshot that contains only the default padding type names."""
+
+PADDING_TYPE_NAME_REGISTRY: PaddingTypeNameRegistry
+
+class Packing:
+    """Represents the packing configuration for pixel formats.
+
+    Attributes:
+        padding_type_name (str): The name of the padding type.
+        lsb (bool): Indicates if the least significant bit is used.
+        alignment (Optional[int]): The alignment value.
+        cluster_marker (int): The cluster marker value.
+    """
+    padding_type_name: str
+    lsb: bool
+    alignment: int | None
+    cluster_marker: int
+    def __init__(self, padding_type: PaddingType | str | None = None, lsb: bool = True, alignment: int | None = None, cluster_marker: int = 0) -> None:
+        """Initializes a Packing instance.
+
+        Args:
+            padding_type (Optional[Union[PaddingType, str]]): The type of padding. Defaults to None.
+            lsb (bool): Indicates if the least significant bit is used. Defaults to True.
+            alignment (Optional[int]): The alignment value. Defaults to None.
+            cluster_marker (int): The cluster marker value. Defaults to 0.
+        """
+    @property
+    def padding_type(self) -> PaddingType:
+        """Return the padding type."""
+    def __eq__(self, other: object) -> bool:
+        """Checks if two Packing instances are equal.
+
+        Args:
+            other: The other Packing instance to compare.
+
+        Returns:
+            bool: True if the instances are equal, False otherwise.
+        """
+    def designation(self) -> str:
+        """Computes the designation string for the Packing instance.
+
+        Returns:
+            str: The designation string.
+        """
+    @staticmethod
+    def from_designation(full_designation: str) -> list[tuple['Packing', str]]:
+        """Creates a list of possible Packing instances from a designation string.
+
+        Args:
+            full_designation (str): The full designation string.
+
+        Returns:
+            list[tuple[Packing, str]]: A list of possible Packing instances and remaining substrings.
+        """

dataspree/pfnc/genicam/pixel_format.pyi

@@ -0,0 +1,95 @@
+import numpy as np
+from .._internal.utils import join_designators as join_designators
+from _typeshed import Incomplete
+from dataspree.pfnc.decoder_registry import PixelFormatDecoder
+from dataspree.pfnc.genicam.components import Components, SizedColorSpaceStandard
+from dataspree.pfnc.genicam.data_types import DataType as DataType, DataTypes
+from dataspree.pfnc.genicam.interface_specifics import InterfaceSpecific
+from dataspree.pfnc.genicam.number_of_bits import Size
+from dataspree.pfnc.genicam.packing_types import Packing
+from dataspree.pfnc.pixel_format import PixelFormat
+from typing import Any, TypeGuard, TypeVar
+
+logger: Incomplete
+PF = TypeVar('PF', bound=PixelFormat)
+
+class GenicamPixelFormat(PixelFormat):
+    '''Representation of a pixel format that complies with the genicam standard.
+
+    Detailed information about pixel formats can be found in the GenICam Pixel Format Naming Convention 2.1.
+    https://www.emva.org/wp-content/uploads/GenICam_PFNC_2_1.pdf.
+
+    The naming convention subdivides as it follows:
+    1. Components and Location (e.g., "RGB" / "Mono")
+    2. number of bits per component (e.g., "8")
+    3. [Optional] data type ("u" or "" for unsigned, "s" for signed, "f" for floating point)
+    4. [Optional] packing: @see Packing
+    5. [Optional] interface-specific
+
+    Consecutive fields must be separated by an underscore, iff (:= if, and only if) a pixel name
+    requires 2 numbers in its designation as part of consecutive fields.
+    Example: YCbCr709_422_8 for 8-bit per component Y’CbCr 4:2:2 using ITU-R BT.709.
+
+
+    Attributes:
+        component (Components): The components of the pixel format.
+        size (Size): The size of the pixel format.
+        data_type (DataTypes): The data type of the pixel format.
+        packing (Packing): The packing type of the pixel format.
+        interface_specific (Optional[InterfaceSpecific]): The interface-specific part of the pixel format.
+        sized_color_space_standard (Optional[SizedColorSpaceStandard]): The sized color space standard.
+    '''
+    component: Components
+    storage_units: int
+    size: Size
+    sized_color_space_standard: SizedColorSpaceStandard | None
+    data_type: DataTypes
+    packing: Packing
+    interface_specific: InterfaceSpecific | None
+    def __init__(self, component: Components, size: Size | int | list[int], data_type: DataTypes | list[DataType] | DataType | None = None, packing: Packing | None = None, interface_specific: InterfaceSpecific | None = None, sized_color_space_standard: SizedColorSpaceStandard | None = None, storage_units: int | None = None) -> None:
+        """Initializes a GenicamPixelFormat instance.
+
+        storage_units models how many storage elements per pixel the size/data_type vectors describe.
+        If omitted, it defaults to the number of logical channels (len(component)).
+        """
+    def designation(self) -> str:
+        """Compute designation."""
+    def __setattr__(self, key: str, value: Any) -> None:
+        """Sets an attribute and clears the cached designation if necessary.
+
+        Args:
+            key (str): The attribute name.
+            value: The attribute value.
+        """
+    @classmethod
+    def from_designation(cls, full_designation: str) -> list[GenicamPixelFormat]:
+        """Return list of compatible genicam pixel formats with the full designation."""
+    def __eq__(self, other: object) -> bool:
+        """Check if components are equal."""
+    def numpy_dtype(self) -> np.dtype[Any]:
+        """Return the numpy dtype for the unpacked storage representation."""
+
+class UnpackedInterleavedStorageDecoder(PixelFormatDecoder):
+    """Decode unpacked, interleaved storage layouts using the current GenicamPixelFormat logic."""
+    def __init__(self) -> None:
+        """Initialize."""
+    def is_applicable(self, pixel_format: PixelFormat) -> TypeGuard[GenicamPixelFormat]:
+        """Return True for unpacked interleaved layouts that the model says are supported."""
+    def decode(self, pixel_format: PixelFormat, buffer: bytes, *, width: int, height: int, stride: int, copy: bool = False) -> np.ndarray[Any, Any]:
+        """Decode unpacked interleaved buffers into numpy arrays.
+
+        Args:
+            pixel_format: Parsed GenICam pixel format instance.
+            buffer: Raw frame bytes (one image).
+            width: Image width in pixels.
+            height: Image height in pixels.
+            stride: Bytes per line (can be > width * bytes_per_pixel).
+            copy: If True, return a contiguous copy without line padding.
+
+        Returns:
+            np.ndarray: Array view or copy of shape (height, width) or (height, width, storage_units).
+
+        Raises:
+            ValueError: If buffer/stride/format are inconsistent.
+            NotImplementedError: If the storage layout is not supported by this decoder.
+        """

dataspree/pfnc/pixel_format.pyi

@@ -0,0 +1,40 @@
+import numpy as np
+from ._internal.utils import all_implementations as all_implementations
+from _typeshed import Incomplete
+from abc import ABCMeta, abstractmethod
+from typing import Any
+from typing_extensions import Self
+
+logger: Incomplete
+
+class PixelFormat(metaclass=ABCMeta):
+    """Abstraction for arbitrary pixel formats."""
+    @classmethod
+    def create(cls, full_designation: str) -> list[Self]:
+        """Return all existing pixel format that accord with the designation.
+
+        Args:
+            full_designation (str): the unique designation of the pixel format.
+        """
+    @classmethod
+    def from_name(cls, full_designation: str) -> Self:
+        """Return existing pixel format with the designation.
+
+        Args:
+            full_designation (str): the unique designation of the pixel format.
+
+        Raises:
+            DriverFeatureImplementationError if no corresponding pixel format was found / the
+                                             designation is not unique.
+        """
+    @abstractmethod
+    def designation(self) -> str:
+        """Compute unique string representation (designation)."""
+    @classmethod
+    @abstractmethod
+    def from_designation(cls, full_designation: str) -> list[Self]:
+        """Return list of compatible genicam pixel formats with the full designation."""
+    def decode(self, buffer: bytes, *, width: int, height: int, stride: int, copy: bool = False) -> np.ndarray[Any, Any]:
+        """Decode numpy image from buffer."""
+
+DEFAULT_DECODER_REGISTRY: Incomplete

pfnc-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: pfnc
+Version: 0.1.0
+Summary: Parse and model GenICam PFNC pixel format designations and decode image buffers via extensible decoders.
+Project-URL: Homepage, https://www.data-spree.com/
+Project-URL: Documentation, https://github.com/dataspree/pfnc.git
+Project-URL: Repository, https://github.com/dataspree/pfnc.git
+Author-email: Data Spree GmbH <info@data-spree.com>
+License: MIT License
+        
+        Copyright (c) 2026 Data Spree GmbH
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE.txt
+Keywords: binary-format,buffer-decoding,camera,dataspree,genicam,gig-e-vision,image-decoding,industrial-camera,machine-vision,numpy,parsing,pfnc,pixel-format
+Requires-Python: >=3.10
+Requires-Dist: numpy<3,>=1.24
+Requires-Dist: typing-extensions>=4
+Description-Content-Type: text/markdown
+
+# Data Spree PFNC Pixel Format
+
+Parse and model GenICam PFNC pixel format designations and decode image buffers via extensible decoders.
+We follow semantic versioning; breaking changes only occur in major versions.
+Every public symbol defined under `pfnc.*` is stable.
+
+![CI/CD](https://github.com/dataspree/dataspree-inspection/actions/workflows/ci.yml/badge.svg)
+[![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm.fming.dev)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
+
+## Introduction
+
+This library provides a structured representation of GenICam PFNC pixel format designations and a
+pluggable system for decoding image buffers into numpy arrays.
+
+It is intended for industrial camera and machine vision use cases where pixel formats are specified
+using PFNC strings (e.g. `RGB8`, `Mono12Packed`, `BayerRG10`) and need to be parsed, inspected, or decoded
+outside of a vendor-specific SDK.
+
+The focus of this project is:
+- correct parsing of PFNC designations
+- explicit modeling of pixel format properties
+- extensibility via registries (decoders, data types, components, packing, interface specifics)
+
+This is not a general-purpose image processing library.
+
+
+## Getting Started
+
+### Installation
+
+```bash
+pip install pfnc
+```
+or, when using pdm:
+```
+pdm add pfnc
+```
+
+
+### Basic Usage
+
+```python
+from dataspree.pfnc import PixelFormat
+
+pf = PixelFormat.from_designation("RGB8")
+
+image = pf.decode(
+    buffer,
+    width=256,
+    height=256,
+    copy=False,
+)
+```
+
+### Extending the library
+
+The library is designed to be extensible. You can register custom decoders or extend parsing behavior
+for additional PFNC variants.
+
+#### Registering a custom decoder
+
+```python
+from dataspree.pfnc import register_decoder, PixelFormatDecoder
+
+class MyDecoder(PixelFormatDecoder):
+    priority = 10
+
+    def supports(self, pixel_format) -> bool:
+        ...
+
+    def decode(self, data, width, height, *, copy=False):
+        ...
+
+register_decoder(MyDecoder)
+```
+
+
+#### Advanced extensions
+
+Advanced users may extend:
+
+- data types
+- components
+- packing rules
+- interface specifics
+
+These extension points are intentionally exposed.
+
+## Scope and limitations
+
+Parsing support covers common PFNC designations.
+
+Decoding support depends on available decoders.
+
+Not all packed or planar formats may be decodable out of the box.
+
+See the documentation for details on supported formats.

pfnc-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+dataspree/pfnc/__about__.py,sha256=QMhOwNxON07egeyLGb5oy7jITHWH4oCZ9fi9gxX9iRA,47
+dataspree/pfnc/__init__.py,sha256=qutwoTS63yEQIJDGE8D1J_vl_1NsBhY4r3hP7bTJuz8,3231
+dataspree/pfnc/decoder_registry.cpython-311-x86_64-linux-gnu.so,sha256=9l-9BKULsW1yrb19mtH01V4JDaqGGZK7izP9iRvJnF8,733416
+dataspree/pfnc/decoder_registry.pyi,sha256=euwSAQE1XOs1pa3heiA9UQzaS9C43Wc4pEPInfIBXxs,2941
+dataspree/pfnc/exceptions.cpython-311-x86_64-linux-gnu.so,sha256=MVcSxDN1zLGq-S15hC9Wngycz_9q-fqQF_lmxy2iy1Y,143784
+dataspree/pfnc/exceptions.pyi,sha256=xo7I0D3rvE6kCm4joktO9T3SHQXTQzxFcZmTimzMQn8,1590
+dataspree/pfnc/pixel_format.cpython-311-x86_64-linux-gnu.so,sha256=Voske6zvZuXqXRII5N-v9a_sDrO3MtjiwrBtuMf9SdM,561952
+dataspree/pfnc/pixel_format.pyi,sha256=W_VV4brua0eXogkjVF-RQw5DEDLUJi8k-EPVCPdyVfw,1536
+dataspree/pfnc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataspree/pfnc/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataspree/pfnc/_internal/registry.cpython-311-x86_64-linux-gnu.so,sha256=J0hfdVM8il8kIUJL3DYAsh-h3-q72vbj5MaW3JgUFtY,569584
+dataspree/pfnc/_internal/registry.pyi,sha256=xRbKZTmYj2cLWbJJqMUUmEW23T3AYxQIVbrbfL5__78,1340
+dataspree/pfnc/_internal/utils.cpython-311-x86_64-linux-gnu.so,sha256=0ZHx6nEaugJoUZt_tCm5il-dxYbPNNWTl_44ytBuaHA,408272
+dataspree/pfnc/_internal/utils.pyi,sha256=0r1OUqzRZeYOvBHK06OIDRTZ-k3fgs-zregPoJz_fZQ,319
+dataspree/pfnc/genicam/__init__.py,sha256=A_weat-t9EL9vPZsi1zvwvZXrJiRaZNNGu5auFhdfHc,22
+dataspree/pfnc/genicam/components.cpython-311-x86_64-linux-gnu.so,sha256=47l6Eu3IHmmo7Op7QwFNc2cQoFJ8G-U2sCGs0ZpRU0w,5762008
+dataspree/pfnc/genicam/components.pyi,sha256=i8au1yfrWHphcsX2T8Jw3Gtp6f8_4EZUHVw7Ieg-JNY,39636
+dataspree/pfnc/genicam/data_types.cpython-311-x86_64-linux-gnu.so,sha256=ROw8tN_kIQQnxEJeAGtSYkDNBIDihDQ5m3tLtzigCFw,1545360
+dataspree/pfnc/genicam/data_types.pyi,sha256=32ucyWm3Ws4tyH1kfWRjWvNNWuJXNkJw_CnwxNYZL6c,4501
+dataspree/pfnc/genicam/interface_specifics.cpython-311-x86_64-linux-gnu.so,sha256=FtvPtBWJeRZPVivBh-7DOLAzIl6-ASO3oRB15TW16XM,1037360
+dataspree/pfnc/genicam/interface_specifics.pyi,sha256=J1l5sHxQC3Si1UdknQeVJ-naiITbIpGX1LhfGrt6aCA,4359
+dataspree/pfnc/genicam/number_of_bits.cpython-311-x86_64-linux-gnu.so,sha256=LHBCRsglgGSyNG1JmXnpbsRF0UFQZyv6FtOkor1fdGQ,843816
+dataspree/pfnc/genicam/number_of_bits.pyi,sha256=otqgOXw9OueBvMvYubSmuCeNS_pJZOEDTJMT8_9NaWA,1568
+dataspree/pfnc/genicam/packing_types.cpython-311-x86_64-linux-gnu.so,sha256=BwKPoF9r-Hg3enpoa3OXVJFsiCPDLOcS29gpfxac7pE,1436616
+dataspree/pfnc/genicam/packing_types.pyi,sha256=Wl4P2-8gtHlPcqZXa2PJVvsjcbxCXxXg5dsXZf6In3I,3165
+dataspree/pfnc/genicam/pixel_format.cpython-311-x86_64-linux-gnu.so,sha256=t0-Xbd5Y7mc1GQKZS0Md_MryrneftEjlXXB9OeQfLfA,1762864
+dataspree/pfnc/genicam/pixel_format.pyi,sha256=16Lb8OQCX0LM8EEgHvzqGh3-pr1ECE_IOPlZkYkmoGs,4851
+pfnc-0.1.0.dist-info/METADATA,sha256=tqDlX3c7uNBUPd3SEC86aSZsvMrrQKa1_sS9e-fcXdU,4450
+pfnc-0.1.0.dist-info/WHEEL,sha256=daP0MqGb5HgGG_e6YTHW1PKAHkmj2eMeFTxTkd_dPBg,148
+pfnc-0.1.0.dist-info/RECORD,,
+pfnc-0.1.0.dist-info/licenses/LICENSE.txt,sha256=zO7pALKLzkW8wkrMHQ1kJI6Bz9kEH5bxt4XB9i-YcsA,1072