intrada-alpr 7.7.0__tar.gz

intrada_alpr-7.7.0/LICENSE

@@ -0,0 +1,29 @@
+intrada-py
+
+Copyright 2026 by Q-Free Netherlands BV.
+
+All Rights Reserved
+
+All Q-Free Netherlands BV. source code software programs, object code software
+programs, documentation and copies thereof shall contain the copyright notice
+above and this permission notice. Q-Free Netherlands BV. BV. reserves all
+rights, title and interest with respect to copying, modification or the
+distribution of such software programs and associated documentation, except
+those rights specifically granted by Q-Free Netherlands BV. in a Product
+Software Program License or Source Code License between Q-Free Netherlands BV.
+and Licensee. Without this License, such software programs may not be used,
+copied, modified or distributed in source or object code form. Further, the
+copyright notice must appear on the media, the supporting documentation and
+packaging. A Source Code License does not grant any rights to use Q-Free
+Netherlands BV.'s name or trademarks in advertising or publicity, with respect
+to the distribution of the software programs without the specific prior written
+permission of Q-Free Netherlands BV.. Trademark agreements may be obtained in a
+separate Trademark License Agreement.
+
+Q-Free disclaims all warranties, express or implied, with respect to the
+Software Programs including the implied warranties of merchantability and
+fitness, for a particular purpose. In no event shall Q-Free Netherlands BV. be
+liable for any special, indirect or consequential damages or any damages
+whatsoever resulting from loss of use, data or profits whether in an action of
+contract or tort, arising out of or in connection with the use or performance of
+such software program.

intrada_alpr-7.7.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: intrada-alpr
+Version: 7.7.0
+Summary: A Python SDK for using Intrada 7
+Keywords: alpr,lpr,license plate recognition,computer vision,sdk
+Author: Q-Free Netherlands BV
+Author-email: Q-Free Netherlands BV <info.nl@q-free.com>
+License-Expression: LicenseRef-Proprietary
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: >=3.10
+Project-URL: Homepage, https://intrada.q-free.com
+Project-URL: Documentation, https://intrada.q-free.com/docs
+Description-Content-Type: text/markdown
+
+# intrada_alpr
+
+intrada_alpr is a Python library that provides functionality to use the
+[Intrada ALPR](https://intrada.q-free.com/) software in Python.
+
+More detailed documentation is available on the [Intrada documentation website](https://intrada.q-free.com/docs)
+(login is required).
+
+## Requirements
+
+To use this library, you need to have the following files present in the same
+directory as your application:
+
+1. The Intrada library:
+   `intrada.dll` for Windows or `libintrada.so` for Linux
+2. One or more country modules:
+   `intrada_cm_*.dll` for Windows or `libintrada_cm_*.so` for Linux
+3. The `intrada.lic` file
+
+If these files are in another directory, you can specify the path using the
+`IntradaOptions.path` option.
+
+## How to use
+
+### Single-threaded
+
+This example shows how to use the `intrada-alpr` library in a single-threaded
+environment.
+
+```python
+from intrada_alpr import IntradaAlpr, IntradaOptions
+
+# Initialize Intrada
+with IntradaAlpr.create(
+    IntradaOptions(
+        company_name="[Your company name]",
+        license_key="[Your company key]",
+    )
+) as intrada:
+    # Create a new processing context
+    with intrada.create_processing_context() as processing_context:
+        # Load an image
+        with intrada.load_image("path/to/image.jpg") as image:
+            # Process the image
+            result = processing_context.process(image)
+
+            print(
+                f"Registration number: "
+                f"{result.primary_plate.registration_number if result.primary_plate else 'Unknown'}"
+            )
+            print(
+                f"Jurisdiction: "
+                f"{result.primary_plate.jurisdiction if result.primary_plate else 'Unknown'}"
+            )
+```
+
+### Multithreaded
+
+This example shows how to use the `intrada-alpr` library in a multithreaded
+environment. It makes use of `ThreadedWorker` to efficiently process multiple
+images in parallel.
+
+```python
+import asyncio
+
+from intrada_alpr import IntradaAlpr, IntradaOptions
+
+
+async def main() -> None:
+    # Initialize Intrada
+    with IntradaAlpr.create(
+        IntradaOptions(
+            company_name="[Your company name]",
+            license_key="[Your company key]",
+        )
+    ) as intrada:
+        # Create a new threaded worker
+        with intrada.create_threaded_worker() as threaded_worker:
+            await threaded_worker.enqueue_async("path/to/image.jpg")
+            await threaded_worker.enqueue_async("path/to/image2.jpg")
+            # etc.
+
+            # Signal to the worker that no more tasks will be enqueued.
+            # This is not required, but by doing this, the worker will stop
+            # after all the tasks have been processed instead of waiting for
+            # more tasks to process.
+            threaded_worker.complete_enqueuing()
+
+            # Get the results
+            async for task_result in threaded_worker.get_results_async():
+                if not task_result.is_success:
+                    print(f"Error processing image: {task_result.exception}")
+                    continue
+
+                result = task_result.result
+                print(
+                    f"Registration number: "
+                    f"{result.primary_plate.registration_number if result and result.primary_plate else 'Unknown'}"
+                )
+                print(
+                    f"Jurisdiction: "
+                    f"{result.primary_plate.jurisdiction if result and result.primary_plate else 'Unknown'}"
+                )
+
+
+asyncio.run(main())
+```
+
+## Support
+
+If you have any questions or need help, please contact us at
+[info.nl@q-free.com](mailto:info.nl@q-free.com).
+
+## License
+Copyright 2026 by Q-Free Netherlands BV.
+
+All Rights Reserved
+
+All Q-Free Netherlands BV. source code software programs, object code software programs, documentation and copies 
+thereof shall contain the copyright notice above and this permission notice. Q-Free Netherlands BV. BV. reserves all 
+rights, title and interest with respect to copying, modification or the distribution of such software programs and
+associated documentation, except those rights specifically granted by Q-Free Netherlands BV. in a Product Software 
+Program License or Source Code License between Q-Free Netherlands BV. and Licensee. Without this License, such software 
+programs may not be used, copied, modified or distributed in source or object code form. Further, the copyright notice 
+must appear on the media, the supporting documentation and packaging. A Source Code License does not grant any rights 
+to use Q-Free Netherlands BV.'s name or trademarks in advertising or publicity, with respect to the distribution of the 
+software programs without the specific prior written permission of Q-Free Netherlands B.V. Trademark agreements may be 
+obtained in a separate Trademark License Agreement.
+
+Q-Free disclaims all warranties, express or implied, with respect to the Software Programs including the implied 
+warranties of merchantability and fitness, for a particular purpose. In no event shall Q-Free Netherlands BV. be 
+liable for any special, indirect or consequential damages or any damages whatsoever resulting from loss of use, data or
+profits whether in an action of contract or tort, arising out of or in connection with the use or performance of such 
+software program.

intrada_alpr-7.7.0/README.md

@@ -0,0 +1,134 @@
+# intrada_alpr
+
+intrada_alpr is a Python library that provides functionality to use the
+[Intrada ALPR](https://intrada.q-free.com/) software in Python.
+
+More detailed documentation is available on the [Intrada documentation website](https://intrada.q-free.com/docs)
+(login is required).
+
+## Requirements
+
+To use this library, you need to have the following files present in the same
+directory as your application:
+
+1. The Intrada library:
+   `intrada.dll` for Windows or `libintrada.so` for Linux
+2. One or more country modules:
+   `intrada_cm_*.dll` for Windows or `libintrada_cm_*.so` for Linux
+3. The `intrada.lic` file
+
+If these files are in another directory, you can specify the path using the
+`IntradaOptions.path` option.
+
+## How to use
+
+### Single-threaded
+
+This example shows how to use the `intrada-alpr` library in a single-threaded
+environment.
+
+```python
+from intrada_alpr import IntradaAlpr, IntradaOptions
+
+# Initialize Intrada
+with IntradaAlpr.create(
+    IntradaOptions(
+        company_name="[Your company name]",
+        license_key="[Your company key]",
+    )
+) as intrada:
+    # Create a new processing context
+    with intrada.create_processing_context() as processing_context:
+        # Load an image
+        with intrada.load_image("path/to/image.jpg") as image:
+            # Process the image
+            result = processing_context.process(image)
+
+            print(
+                f"Registration number: "
+                f"{result.primary_plate.registration_number if result.primary_plate else 'Unknown'}"
+            )
+            print(
+                f"Jurisdiction: "
+                f"{result.primary_plate.jurisdiction if result.primary_plate else 'Unknown'}"
+            )
+```
+
+### Multithreaded
+
+This example shows how to use the `intrada-alpr` library in a multithreaded
+environment. It makes use of `ThreadedWorker` to efficiently process multiple
+images in parallel.
+
+```python
+import asyncio
+
+from intrada_alpr import IntradaAlpr, IntradaOptions
+
+
+async def main() -> None:
+    # Initialize Intrada
+    with IntradaAlpr.create(
+        IntradaOptions(
+            company_name="[Your company name]",
+            license_key="[Your company key]",
+        )
+    ) as intrada:
+        # Create a new threaded worker
+        with intrada.create_threaded_worker() as threaded_worker:
+            await threaded_worker.enqueue_async("path/to/image.jpg")
+            await threaded_worker.enqueue_async("path/to/image2.jpg")
+            # etc.
+
+            # Signal to the worker that no more tasks will be enqueued.
+            # This is not required, but by doing this, the worker will stop
+            # after all the tasks have been processed instead of waiting for
+            # more tasks to process.
+            threaded_worker.complete_enqueuing()
+
+            # Get the results
+            async for task_result in threaded_worker.get_results_async():
+                if not task_result.is_success:
+                    print(f"Error processing image: {task_result.exception}")
+                    continue
+
+                result = task_result.result
+                print(
+                    f"Registration number: "
+                    f"{result.primary_plate.registration_number if result and result.primary_plate else 'Unknown'}"
+                )
+                print(
+                    f"Jurisdiction: "
+                    f"{result.primary_plate.jurisdiction if result and result.primary_plate else 'Unknown'}"
+                )
+
+
+asyncio.run(main())
+```
+
+## Support
+
+If you have any questions or need help, please contact us at
+[info.nl@q-free.com](mailto:info.nl@q-free.com).
+
+## License
+Copyright 2026 by Q-Free Netherlands BV.
+
+All Rights Reserved
+
+All Q-Free Netherlands BV. source code software programs, object code software programs, documentation and copies 
+thereof shall contain the copyright notice above and this permission notice. Q-Free Netherlands BV. BV. reserves all 
+rights, title and interest with respect to copying, modification or the distribution of such software programs and
+associated documentation, except those rights specifically granted by Q-Free Netherlands BV. in a Product Software 
+Program License or Source Code License between Q-Free Netherlands BV. and Licensee. Without this License, such software 
+programs may not be used, copied, modified or distributed in source or object code form. Further, the copyright notice 
+must appear on the media, the supporting documentation and packaging. A Source Code License does not grant any rights 
+to use Q-Free Netherlands BV.'s name or trademarks in advertising or publicity, with respect to the distribution of the 
+software programs without the specific prior written permission of Q-Free Netherlands B.V. Trademark agreements may be 
+obtained in a separate Trademark License Agreement.
+
+Q-Free disclaims all warranties, express or implied, with respect to the Software Programs including the implied 
+warranties of merchantability and fitness, for a particular purpose. In no event shall Q-Free Netherlands BV. be 
+liable for any special, indirect or consequential damages or any damages whatsoever resulting from loss of use, data or
+profits whether in an action of contract or tort, arising out of or in connection with the use or performance of such 
+software program.

intrada_alpr-7.7.0/pyproject.toml

@@ -0,0 +1,99 @@
+[build-system]
+requires = ["uv_build>=0.11.2,<0.12"]
+build-backend = "uv_build"
+
+[project]
+name = "intrada-alpr"
+version = "7.7.0"
+description = "A Python SDK for using Intrada 7"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "Q-Free Netherlands BV", email = "info.nl@q-free.com" }
+]
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+keywords = ["alpr", "lpr", "license plate recognition", "computer vision", "sdk"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+]
+ 
+[project.urls]
+"Homepage" = "https://intrada.q-free.com"
+"Documentation" = "https://intrada.q-free.com/docs"
+ 
+[dependency-groups]
+dev = [
+    "mypy>=1.14.1",
+    "pytest>=8.3.5",
+    "pytest-benchmark>=4.0.0",
+    "pytest-cov>=5.0.0",
+    "ruff>=0.14.0",
+    "junitparser>=5.0.0",
+    "pylint>=4.0.5"
+]
+ 
+[tool.pytest.ini_options]
+addopts = "--maxfail=1 --strict-markers --strict-config --cov=intrada_alpr --cov-report=term-missing"
+markers = [
+    "unit: Fast isolated tests that do not require real native resources.",
+    "integration: Tests that execute against a real Intrada runtime.",
+    "benchmark: Performance benchmark tests that require real Intrada runtime resources.",
+]
+ 
+[tool.ruff]
+target-version = "py310"
+fix = true
+line-length = 120
+ 
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "ANN", "TCH"]
+ 
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["ANN"]
+ 
+[tool.mypy]
+python_version = "3.10"
+strict = true
+ignore_missing_imports = true
+warn_unused_ignores = true
+warn_return_any = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+show_error_codes = true
+pretty = true
+exclude = "tests/.*"
+ 
+[tool.uv_build]
+include = [
+    "src/intrada_alpr",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+exclude = [
+    "tests/**",
+    "resources/**",
+    "output/**",
+    "demo.py",
+    "azure-pipelines.yml",
+    ".github/**",
+    ".gitignore",
+    "**/.DS_Store",
+    "**/__pycache__/**",
+    "**/*.py[cod]",
+]
+ 

intrada_alpr-7.7.0/src/intrada_alpr/__init__.py

@@ -0,0 +1,92 @@
+"""
+The Intrada ALPR library.
+
+The Intrada Automatic License Plate Recognition (ALPR) API provides robust
+tools for detecting, recognizing, and analyzing license plates in images.
+It is designed for flexibility and performance, supporting a variety of
+configurations and use cases, including traffic management, security
+systems, and more.
+
+The main workflow is:
+
+1. Create an Intrada ALPR instance
+2. Create a processing context.
+3. Load or create an image.
+4. Process the image.
+5. Inspect the returned result.
+
+It can also create a threaded worker for processing multiple images in
+parallel.
+
+Features include:
+- License Plate Recognition: Detect and recognize license plates in images.
+- Vehicle detection and classification: Detect vehicles and classify
+  them based on predefined categories.
+- Configurable parameters: Adjust settings like jurisdictions,
+  recognition tasks, and processing constraints.
+- Multi-threading support: Efficient context management for concurrent
+  processing.
+- Broad input support: Compatible with a variety of image formats and
+  resolutions.
+"""
+
+from __future__ import annotations
+
+from ._core.errors import IntradaException
+from ._core.intrada import IntradaAlpr
+from ._core.models import PlateResult, Result, SymbolResult, VehicleMakeModel, VehicleResult
+from ._core.options import IntradaOptions
+from ._core.result import INTRADA_UNKNOWN
+from ._core.threading import (
+    ProcessingContextCreatedEventArgs,
+    TaskFailedEventArgs,
+    TaskProcessedEventArgs,
+    TaskProcessingEventArgs,
+    TaskResult,
+    ThreadedTask,
+    ThreadedWorker,
+)
+from ._types.enums import (
+    CameraPosition,
+    DetectionMode,
+    ImageCaptureType,
+    ImageColorFilterArrayPattern,
+    ImageFormat,
+    ProcessingTask,
+    VehicleColor,
+    VehicleSide,
+    VehicleType,
+)
+from ._types.geometry import Point, Quadrangle, Rectangle, ReferenceFrame
+
+__all__ = [
+    "IntradaAlpr",
+    "IntradaOptions",
+    "Result",
+    "VehicleResult",
+    "VehicleMakeModel",
+    "PlateResult",
+    "SymbolResult",
+    "ThreadedWorker",
+    "ThreadedTask",
+    "TaskResult",
+    "ProcessingContextCreatedEventArgs",
+    "TaskProcessingEventArgs",
+    "TaskProcessedEventArgs",
+    "TaskFailedEventArgs",
+    "IntradaException",
+    "DetectionMode",
+    "ProcessingTask",
+    "ImageFormat",
+    "ImageCaptureType",
+    "ImageColorFilterArrayPattern",
+    "CameraPosition",
+    "VehicleType",
+    "VehicleColor",
+    "VehicleSide",
+    "Point",
+    "Rectangle",
+    "Quadrangle",
+    "ReferenceFrame",
+    "INTRADA_UNKNOWN",
+]

intrada_alpr-7.7.0/src/intrada_alpr/_core/__init__.py

@@ -0,0 +1,7 @@
+"""Core SDK implementation layer.
+
+This package contains lifecycle management, processing logic, result models,
+logging, and error mapping used by the public :mod:`intrada_alpr` API.
+"""
+
+from __future__ import annotations