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.
