Transfer project

.bumpversion.cfg

@@ -0,0 +1,16 @@
+[bumpversion]
+current_version = 0.3.0
+commit = False
+tag = False
+
+[bumpversion:file:pyproject.toml]
+search = version = "{current_version}"
+replace = version = "{new_version}"
+
+[bumpversion:file:src/deep_barcode_reader/__init__.py]
+search = __version__ = "{current_version}"
+replace = __version__ = "{new_version}"
+
+[bumpversion:file:tests/test_deep_barcode_reader.py]
+search = __version__ == "{current_version}"
+replace = __version__ == "{new_version}"

.gitattributes

@@ -0,0 +1,3 @@
+src/deep_barcode_reader/models/sr.caffemodel filter=lfs diff=lfs merge=lfs -text
+src/deep_barcode_reader/models/sr.prototxt filter=lfs diff=lfs merge=lfs -text
+tests/test_data/sample.jpg filter=lfs diff=lfs merge=lfs -text

.github/workflows/main.yml

@@ -0,0 +1,25 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches:
+      - '**'
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Add remote
+        env:
+          HF: ${{ secrets.HG }}
+        run: git remote add space https://industoai:$HF@huggingface.co/spaces/industoai/Deep-Barcode-Reader
+      - name: Push to hub
+        env:
+          HF: ${{ secrets.HG }}
+        run: git push --force https://industoai:$HF@huggingface.co/spaces/industoai/Deep-Barcode-Reader ${{ github.ref }}:main

.gitignore

@@ -0,0 +1,21 @@
+# Pycharm files
+.idea/
+
+# poetry
+poetry.lock
+
+# Unit test files
+.coverage
+.coverage.*
+.cache
+.pytest_cache/
+src/*/__pycache__/*
+
+# mypy files
+.mypy_cache/
+
+# Probable environments files
+.env
+.venv
+env/
+venv/

.pre-commit-config.yaml

@@ -0,0 +1,74 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+default_language_version:
+    python: python3
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0  # the release, git tag, or commit you want to use
+    hooks:
+      - id: check-toml
+      - id: check-yaml
+      - id: check-json
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: no-commit-to-branch
+      - id: check-executables-have-shebangs
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: pretty-format-json
+        args:
+        - --autofix
+      - id: check-symlinks
+      - id: check-ast
+      - id: detect-private-key
+  - repo: https://github.com/psf/black
+    rev: 24.1.1
+    hooks:
+      - id: black
+        language: python
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.8.0
+    hooks:
+    - id: mypy
+      language: system
+      args: [--strict, --ignore-missing-imports]
+  - repo: https://github.com/pycqa/pylint
+    rev: v3.0.3
+    hooks:
+    - id: pylint
+      language: system
+  - repo: https://github.com/Lucas-C/pre-commit-hooks
+    rev: v1.5.4
+    hooks:
+    - id: forbid-crlf
+    - id: remove-crlf
+    - id: forbid-tabs
+    - id: remove-tabs
+  - repo: https://github.com/PyCQA/bandit
+    rev: 1.7.7
+    hooks:
+    - id: bandit
+      args: ["--skip=B101"]
+  - repo: https://github.com/Lucas-C/pre-commit-hooks-markup
+    rev: v1.0.1
+    hooks:
+    - id: rst-linter
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.4.0
+    hooks:
+    - id: detect-secrets
+      language: python
+      exclude: "poetry.lock"
+      # args: ['--baseline', '.secrets.baseline']
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.9.0.6
+    hooks:
+    - id: shellcheck
+      args: ["--external-sources"]
+  - repo: https://github.com/python-poetry/poetry
+    rev: '1.7.1'
+    hooks:
+    - id: poetry-check
+    - id: poetry-lock
+      args: ["--no-update"]

Dockerfile

@@ -0,0 +1,145 @@
+## syntax=docker/dockerfile:1.1.7-experimental
+
+################
+# Base builder #
+################
+FROM python:3.10-bookworm as base_build
+
+ENV \
+  # locale environment variables
+  LC_ALL=C.UTF-8 \
+  # python environemnt variables
+  PYTHONFAULTHANDLER=1 \
+  PYTHONUNBUFFERED=1 \
+  PYTHONHASHSEED=random \
+  # pip environmental variables
+  PIP_NO_CACHE_DIR=off \
+  PIP_DISABLE_PIP_VERSION_CHECK=on \
+  PIP_DEFAULT_TIMEOUT=100 \
+  # poetry version
+  POETRY_VERSION=1.5.0
+
+# Install requirements
+RUN apt-get update && apt-get install -y \
+        curl \
+        git \
+        bash \
+        build-essential \
+        libffi-dev \
+        libssl-dev \
+        tini \
+        openssh-client \
+        cargo \
+        musl-dev \
+        libzbar0 \
+    && apt-get autoremove -y \
+    && rm -rf /var/lib/apt/lists/* \
+    # github ssh key setting
+    && mkdir -p -m 0700 ~/.ssh && ssh-keyscan github.com | sort > ~/.ssh/known_hosts \
+    # Installing poetry and set the PATH
+    && curl -sSL https://install.python-poetry.org | python3 - \
+    && echo 'export PATH="/root/.local/bin:$PATH"' >>/root/.profile \
+    && export PATH="/root/.local/bin:$PATH" \
+    && true
+SHELL ["/bin/bash", "-lc"]
+
+# Copy poetry lock and pyproject config files to the container
+WORKDIR /pysetup
+COPY ./poetry.lock ./pyproject.toml /pysetup/
+# Install pip/wheel/virtualenv and build the wheels based on the poetry lock
+RUN --mount=type=ssh pip3 install wheel virtualenv poetry-plugin-export \
+    && poetry export -f requirements.txt --without-hashes -o /tmp/requirements.txt \
+    && pip3 wheel --wheel-dir=/tmp/wheelhouse --trusted-host 172.17.0.1 --find-links=http://172.17.0.1:3141/debian/ -r /tmp/requirements.txt \
+    && virtualenv /.venv && source /.venv/bin/activate && echo 'source /.venv/bin/activate' >>/root/.profile \
+    && pip3 install --no-deps --trusted-host 172.17.0.1 --find-links=http://172.17.0.1:3141/debian/ --find-links=/tmp/wheelhouse/ /tmp/wheelhouse/*.whl \
+    && true
+
+
+###########################
+# Production base builder #
+###########################
+FROM base_build as production_build
+# Copy entrypoint script to the container and src files to the app directory
+COPY ./docker/entrypoint.sh /docker-entrypoint.sh
+COPY . /app/
+WORKDIR /app
+# Build the wheel packages with poetry and add them to the wheelhouse
+RUN --mount=type=ssh source /.venv/bin/activate \
+    && poetry build -f wheel --no-interaction --no-ansi \
+    && cp dist/*.whl /tmp/wheelhouse \
+    && chmod a+x /docker-entrypoint.sh \
+    && true
+
+
+
+########################
+# Production Container #
+########################
+FROM python:3.10-bookworm as production
+COPY --from=production_build /tmp/wheelhouse /tmp/wheelhouse
+COPY --from=production_build /docker-entrypoint.sh /docker-entrypoint.sh
+WORKDIR /app
+# Install system level deps for running the package and install the wheels we built in the previous step.
+RUN --mount=type=ssh apt-get update && apt-get install -y \
+        bash \
+        libffi8 \
+        libgl1 \
+        tini \
+        libzbar0 \
+    && apt-get autoremove -y \
+    && rm -rf /var/lib/apt/lists/* \
+    && chmod a+x /docker-entrypoint.sh \
+    && WHEELFILE=`echo /tmp/wheelhouse/deep_barcode_reader-*.whl` \
+    && pip3 install --trusted-host 172.17.0.1 --find-links=http://172.17.0.1:3141/debian/ --find-links=/tmp/wheelhouse/ "$WHEELFILE"[all] \
+    && rm -rf /tmp/wheelhouse/ \
+    && true
+ENTRYPOINT ["/usr/bin/tini", "--", "/docker-entrypoint.sh"]
+
+
+
+############################
+# Development base builder #
+############################
+FROM base_build as development_build
+# Copy src to app directory
+COPY . /app
+WORKDIR /app
+# Install dependencies from poetry lock
+RUN --mount=type=ssh source /.venv/bin/activate \
+    && apt-get update && apt-get install -y libgl1 libzbar0 \
+    && export PIP_FIND_LINKS=http://172.17.0.1:3141/debian/ \
+    && export PIP_TRUSTED_HOST=172.17.0.1 \
+    && pip3 install nvidia-cublas-cu12 nvidia-cusparse-cu12 triton nvidia-nccl-cu12 nvidia-cudnn-cu12 nvidia-cufft-cu12 nvidia-cusolver-cu12 \
+    && poetry install --no-interaction --no-ansi \
+    && true
+
+
+
+###################
+# Tests Container #
+###################
+FROM development_build as test
+RUN --mount=type=ssh source /.venv/bin/activate \
+    && chmod a+x docker/*.sh \
+    && docker/pre_commit_init.sh \
+    && true
+ENTRYPOINT ["/usr/bin/tini", "--", "docker/entrypoint-test.sh"]
+
+
+#########################
+# Development Container #
+#########################
+FROM development_build as development
+RUN apt-get update && apt-get install -y zsh libzbar0 \
+    && sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" \
+    && echo "if [ \"\$NO_WHEELHOUSE\" = \"1\" ]" >>/root/.profile \
+    && echo "then" >>/root/.profile \
+    && echo "  echo \"Wheelhouse disabled\"" >>/root/.profile \
+    && echo "else">>/root/.profile \
+    && echo "  export PIP_TRUSTED_HOST=172.17.0.1" >>/root/.profile \
+    && echo "  export PIP_FIND_LINKS=http://172.17.0.1:3141/debian/" >>/root/.profile \
+    && echo "fi" >>/root/.profile \
+    && echo "source /root/.profile" >>/root/.zshrc \
+    && pip3 install git-up \
+    && true
+ENTRYPOINT ["/bin/zsh", "-l"]

README.md

@@ -0,0 +1,104 @@
+---
+title: Deep Barcode Reader
+emoji: 🔳
+colorFrom: gray
+colorTo: red
+sdk: streamlit
+sdk_version: 1.42.2
+app_file: app.py
+pinned: false
+---
+# Deep-Barcode-Reader
+This repository is used for reading different types of barcodes and QR codes from images.
+The code is written in Python and uses OpenCV, Pyzbar, and other libraries for reading barcodes and QR codes.
+
+
+## How to Use
+The library offers several functions for reading barcodes and QR codes from images.
+General options can be selected before applying the reader method. These options are:
+- `--data_path` is the path to the image file.
+- `--result_path` is the path to the output file.
+- `--verbose` is the verbosity level of the code.
+- `--method` is the method for reading the barcode or QR code.
+- `--model_size` is the size of the deep learning model.
+
+The available methods are as:
+- [Opencv Barcode Reader](#opencv-barcode-reader)
+- [Zbar Barcode Reader](#zbar-barcode-reader)
+- [QR Reader](#qr-reader)
+
+### Opencv Barcode Reader
+This method can only detect barcodes but NOT QR codes. It can detect and decode EAN-8, EAN-13, UPC-A and UPC-E
+barcode types. You can use the method by running the following command:
+```shell
+deep_barcode_reader -vv -d tests/test_data/sample.jpg -m opencv
+```
+This method can only detect specific types of barcodes. However, it is faster than the other methods.
+
+### Zbar Barcode Reader
+This method can detect and decode both barcodes and QR codes.
+It is very powerful to detect and decode different types of barcodes and QR codes.
+You can use the method by running the following command:
+```shell
+deep_barcode_reader -vv -d tests/test_data/sample.jpg -m zbar
+```
+
+### QR Reader
+This method can only detect and decode QR codes.
+Depending on the model size as `n` as nano, `s` as small, `m` as medium, or `l` as large,
+the detection and decoding process time and accuracy can be changed.
+```shell
+deep_barcode_reader -vv -d tests/test_data/sample.jpg -m zbar --model_size l
+```
+
+
+## How to Develop
+Do the following only once after creating your project:
+- Init the git repo with `git init`.
+- Add files with `git add .`.
+- Then `git commit -m 'initialize the project'`.
+- Add remote url with `git remote add origin REPO_URL`.
+- Then `git branch -M master`.
+- `git push origin main`.
+Then create a branch with `git checkout -b BRANCH_NAME` for further developments.
+- Install poetry if you do not have it in your system from [here](https://python-poetry.org/docs/#installing-with-pipx).
+- Create a virtual env preferably with virtualenv wrapper and `mkvirtualenv -p $(which python3.10) ENVNAME`.
+- Then `git add poetry.lock`.
+- Then `pre-commit install`.
+- For applying changes use `pre-commit run --all-files`.
+
+
+## Docker Container
+To run the docker with ssh, do the following first and then based on your need select ,test, development, or production containers:
+```shell
+export DOCKER_BUILDKIT=1
+export DOCKER_SSHAGENT="-v $SSH_AUTH_SOCK:$SSH_AUTH_SOCK -e SSH_AUTH_SOCK"
+```
+### Test Container
+This container is used for testing purposes while it runs the test
+```shell
+docker build --progress plain --ssh default --target test -t barcode_docker:test .
+docker run -it --rm -v "$(pwd):/app" $(echo $DOCKER_SSHAGENT) barcode_docker:test
+```
+
+### Development Container
+This container can be used for development purposes:
+```shell
+docker build --progress plain --ssh default --target development -t barcode_docker:development .
+docker run -it --rm -v "$(pwd):/app" -v /tmp:/tmp $(echo $DOCKER_SSHAGENT) barcode_docker:development
+```
+
+### Production Container
+This container can be used for production purposes:
+```shell
+docker build --progress plain --ssh default --target production -t barcode_docker:production .
+docker run -it --rm -v "$(pwd):/app" -v /tmp:/tmp $(echo $DOCKER_SSHAGENT) barcode_docker:production deep_barcode_reader -vv -d tests/test_data/sample.jpg -m zbar --model_size l
+```
+
+## Hugging Face Deployment
+The repository is also deployed in [hugging face](https://huggingface.co/spaces/afshin-dini/Deep-Barcode-Reader) in which one can upload images, select the appropriate method and its parameters and detect and decode the barcodes or QR codes.
+It is good to mention that you can also run the application locally by running the following command:
+```shell
+streamlit run app.py
+```
+and then open the browser and go to the address `http://localhost:8501`.

app.py

@@ -0,0 +1,85 @@
+"""This is a demo for running the barcode QR code reader usng streamlit library"""
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+import asyncio
+
+import streamlit as st
+from PIL import Image
+import numpy as np
+import pandas as pd
+
+from src.deep_barcode_reader.barcode import Wrapper
+
+
+@dataclass
+class DemoBarcodeReader:
+    """This is a demo class for barcode/qr code reader using different methods"""
+
+    image: Optional[Any] = field(init=False, default=None)
+    model_option: str = field(init=False, default="opencv")
+    model_size: str = field(init=False, default="n")
+
+    def upload_image(self) -> None:
+        """Upload an image from the streamlit page"""
+        uploaded_file = st.file_uploader(
+            "Choose an image...", type=["jpg", "png", "jpeg"]
+        )
+        if uploaded_file is not None:
+            self.image = Image.open(uploaded_file)
+        else:
+            self.image = Image.open("tests/test_data/sample.jpg")
+
+        st.image(
+            self.image, caption="Original/Uploaded Image", use_container_width=True
+        )
+
+    def select_model(self) -> None:
+        """Select a model for barcode/qr code reader"""
+        self.model_option = st.selectbox(
+            "Choose a reader/decoder model", ["zbar", "opencv", "qrreader"]
+        )
+        if self.model_option == "qrreader":
+            ml_size = st.selectbox(
+                "Choose a model size for QRReader method",
+                ["nano", "small", "medium", "large"],
+            )
+            self.model_size = (
+                "n"
+                if ml_size == "nano"
+                else "s" if ml_size == "small" else "m" if ml_size == "medium" else "l"
+            )
+
+    def process_image(self) -> None:
+        """Process the image for barcode/qr code reader"""
+        if st.button("Read/Decode Barcode/QR Code"):
+            reader = Wrapper(model_size=self.model_size, method=self.model_option)
+            detections, result_img = asyncio.run(
+                reader.method_selection(image=np.array(self.image), result_path="")
+            )
+            st.markdown("<h3>Detected Results</h3>", unsafe_allow_html=True)
+            st.image(result_img, caption="Decoded Result", use_container_width=True)
+            results = pd.DataFrame(
+                {
+                    "Barcode/QR Types": detections.decoded_types,
+                    "Data": detections.decoded_data,
+                    "Boundary Box": [str(bbx) for bbx in detections.bbox_data],
+                }
+            )
+            st.markdown('<div class="center-container">', unsafe_allow_html=True)
+            st.markdown(
+                "<h3>Detailed Information of Detections</h3>", unsafe_allow_html=True
+            )
+            st.table(results)
+            st.markdown("</div>", unsafe_allow_html=True)
+
+    def design_page(self) -> None:
+        """Design the streamlit page for barcode/qr code reader"""
+        st.title("Image Barcode/QR Code Reader and Detector")
+        self.upload_image()
+        self.select_model()
+        self.process_image()
+
+
+demo = DemoBarcodeReader()
+demo.design_page()

docker/entrypoint-test.sh

@@ -0,0 +1,15 @@
+#!/bin/bash -l
+set -e
+if [ "$#" -eq 0 ]; then
+  # Kill cache, pytest complains about it if running local and docker tests in mapped volume
+  find tests  -type d -name '__pycache__' -print0 | xargs -0 rm -rf {}
+  # Make sure the service itself is installed
+  poetry install
+  # Make sure pre-commit checks were not missed and run tests
+  git config --global --add safe.directory /app
+  poetry run pre-commit install
+  pre-commit run --all-files
+  pytest -v --junitxml=pytest.xml tests/
+else
+  exec "$@"
+fi

docker/entrypoint.sh

@@ -0,0 +1,7 @@
+#!/bin/bash -l
+set -e
+if [ "$#" -eq 0 ]; then
+  exec deep_barcode_reader --help
+else
+  exec "$@"
+fi

docker/pre_commit_init.sh

@@ -0,0 +1,10 @@
+#!/bin/bash -l
+if [ ! -d .git ]
+then
+  git init
+  git checkout -b precommit_init
+  git add .
+fi
+set -e
+poetry run pre-commit install
+SKIP="poetry-lock" poetry run pre-commit run --all-files

packages.txt

@@ -0,0 +1 @@
+libzbar0

pyproject.toml

@@ -0,0 +1,76 @@
+[tool.poetry]
+name = "deep_barcode_reader"
+version = "0.3.0"
+description = "It can read different types of barcodes"
+authors = ["Afshin Dini <Afshin Dini>"]
+readme = "README.md"
+packages = [{include = "deep_barcode_reader", from = "src"}]
+
+[tool.poetry.scripts]
+deep_barcode_reader = "deep_barcode_reader.main:deep_barcode_reader_cli"
+
+[tool.pylint.format]
+max-line-length=150     # This defines the maximum number of characters on a single line in pylint
+
+[tool.pylint.design]
+max-attributes=10
+max-positional-arguments=6
+max-args=6
+
+[tool.pylint.messages_control]
+disable=["fixme"]
+
+[tool.pylint.similarities]
+min-similarity-lines = 8    # Minimum lines number of a similarity.
+ignore-imports = true       # Ignore imports when computing similarities.
+
+[tool.pytest.ini_options]
+junit_family="xunit2"
+addopts="--cov=deep_barcode_reader --cov-fail-under=65 --cov-branch"
+asyncio_mode="strict"
+
+
+[tool.coverage.run]
+omit = ["tests/*"]
+branch = true
+
+[[tool.poetry.source]]
+name = "pytorch"
+url = "https://download.pytorch.org/whl/cu118"
+priority = "explicit"
+
+
+[tool.poetry.dependencies]
+python = "^3.10"
+click = "^8.1.7"
+ultralytics = "8.2.18"
+qreader = "3.12"
+pyzbar = "^0.1.9"
+opencv-python = "^4.9.0.80"
+torch = [
+    { version = "^2.1.2", source = "pytorch", platform = "!=darwin"},
+    { version = "^2.1.2", source = "pypi", platform = "darwin"},
+]
+torchvision = [
+    { version = "^0.16.0", source = "pytorch", platform = "!=darwin"},
+    { version = "^0.16.0", source = "pypi", platform = "darwin"},
+]
+numpy = "1.26.4"
+streamlit = "^1.42.2"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.3"
+coverage = "^7.6"
+pytest-cov = "^6.0"
+pylint = "^3.3.1"
+black = "^24.10.0"
+mypy = "^1.13.0"
+bump2version = "^1.0.1"
+bandit = "^1.7.10"
+pre-commit = "^4.0.1"
+detect-secrets = "^1.5"
+
+[build-system]
+requires = ["poetry-core>=1.5.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,72 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+
+altair==5.5.0 ; python_version >= "3.10" and python_version < "4.0"
+attrs==25.1.0 ; python_version >= "3.10" and python_version < "4.0"
+blinker==1.9.0 ; python_version >= "3.10" and python_version < "4.0"
+cachetools==5.5.2 ; python_version >= "3.10" and python_version < "4.0"
+certifi==2025.1.31 ; python_version >= "3.10" and python_version < "4.0"
+charset-normalizer==3.4.1 ; python_version >= "3.10" and python_version < "4.0"
+click==8.1.8 ; python_version >= "3.10" and python_version < "4.0"
+colorama==0.4.6 ; python_version >= "3.10" and python_version < "4.0" and platform_system == "Windows"
+contourpy==1.3.1 ; python_version >= "3.10" and python_version < "4.0"
+cycler==0.12.1 ; python_version >= "3.10" and python_version < "4.0"
+filelock==3.17.0 ; python_version >= "3.10" and python_version < "4.0"
+fonttools==4.56.0 ; python_version >= "3.10" and python_version < "4.0"
+fsspec==2025.2.0 ; python_version >= "3.10" and python_version < "4.0"
+gitdb==4.0.12 ; python_version >= "3.10" and python_version < "4.0"
+gitpython==3.1.44 ; python_version >= "3.10" and python_version < "4.0"
+idna==3.10 ; python_version >= "3.10" and python_version < "4.0"
+jinja2==3.1.5 ; python_version >= "3.10" and python_version < "4.0"
+jsonschema-specifications==2024.10.1 ; python_version >= "3.10" and python_version < "4.0"
+jsonschema==4.23.0 ; python_version >= "3.10" and python_version < "4.0"
+kiwisolver==1.4.8 ; python_version >= "3.10" and python_version < "4.0"
+markdown-it-py==3.0.0 ; python_version >= "3.10" and python_version < "4.0"
+markupsafe==3.0.2 ; python_version >= "3.10" and python_version < "4.0"
+matplotlib==3.10.0 ; python_version >= "3.10" and python_version < "4.0"
+mdurl==0.1.2 ; python_version >= "3.10" and python_version < "4.0"
+mpmath==1.3.0 ; python_version >= "3.10" and python_version < "4.0"
+narwhals==1.27.1 ; python_version >= "3.10" and python_version < "4.0"
+networkx==3.4.2 ; python_version >= "3.10" and python_version < "4.0"
+numpy==1.26.4 ; python_version >= "3.10" and python_version < "4.0"
+opencv-python==4.11.0.86 ; python_version >= "3.10" and python_version < "4.0"
+packaging==24.2 ; python_version >= "3.10" and python_version < "4.0"
+pandas==2.2.3 ; python_version >= "3.10" and python_version < "4.0"
+pillow==11.1.0 ; python_version >= "3.10" and python_version < "4.0"
+protobuf==5.29.3 ; python_version >= "3.10" and python_version < "4.0"
+psutil==7.0.0 ; python_version >= "3.10" and python_version < "4.0"
+py-cpuinfo==9.0.0 ; python_version >= "3.10" and python_version < "4.0"
+pyarrow==19.0.1 ; python_version >= "3.10" and python_version < "4.0"
+pydeck==0.9.1 ; python_version >= "3.10" and python_version < "4.0"
+pygments==2.19.1 ; python_version >= "3.10" and python_version < "4.0"
+pyparsing==3.2.1 ; python_version >= "3.10" and python_version < "4.0"
+python-dateutil==2.9.0.post0 ; python_version >= "3.10" and python_version < "4.0"
+pytz==2025.1 ; python_version >= "3.10" and python_version < "4.0"
+pyyaml==6.0.2 ; python_version >= "3.10" and python_version < "4.0"
+pyzbar==0.1.9 ; python_version >= "3.10" and python_version < "4.0"
+qrdet==2.5 ; python_version >= "3.10" and python_version < "4.0"
+qreader==3.12 ; python_version >= "3.10" and python_version < "4.0"
+quadrilateral-fitter==1.12 ; python_version >= "3.10" and python_version < "4.0"
+referencing==0.36.2 ; python_version >= "3.10" and python_version < "4.0"
+requests==2.32.3 ; python_version >= "3.10" and python_version < "4.0"
+rich==13.9.4 ; python_version >= "3.10" and python_version < "4.0"
+rpds-py==0.23.1 ; python_version >= "3.10" and python_version < "4.0"
+scipy==1.15.2 ; python_version >= "3.10" and python_version < "4.0"
+seaborn==0.13.2 ; python_version >= "3.10" and python_version < "4.0"
+shapely==2.0.7 ; python_version >= "3.10" and python_version < "4.0"
+six==1.17.0 ; python_version >= "3.10" and python_version < "4.0"
+smmap==5.0.2 ; python_version >= "3.10" and python_version < "4.0"
+streamlit==1.42.2 ; python_version >= "3.10" and python_version < "4.0"
+sympy==1.13.3 ; python_version >= "3.10" and python_version < "4.0"
+tenacity==9.0.0 ; python_version >= "3.10" and python_version < "4.0"
+thop==0.1.1.post2209072238 ; python_version >= "3.10" and python_version < "4.0"
+toml==0.10.2 ; python_version >= "3.10" and python_version < "4.0"
+torch==2.1.2+cu118 ; python_version >= "3.10" and python_version < "4.0"
+torchvision==0.16.2+cu118 ; python_version >= "3.10" and python_version < "4.0"
+tornado==6.4.2 ; python_version >= "3.10" and python_version < "4.0"
+tqdm==4.67.1 ; python_version >= "3.10" and python_version < "4.0"
+triton==2.1.0 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+typing-extensions==4.12.2 ; python_version >= "3.10" and python_version < "4.0"
+tzdata==2025.1 ; python_version >= "3.10" and python_version < "4.0"
+ultralytics==8.2.18 ; python_version >= "3.10" and python_version < "4.0"
+urllib3==2.3.0 ; python_version >= "3.10" and python_version < "4.0"
+watchdog==6.0.0 ; python_version >= "3.10" and python_version < "4.0" and platform_system != "Darwin"

src/deep_barcode_reader/__init__.py

@@ -0,0 +1,14 @@
+""" It can read different types of barcodes """
+
+__version__ = "0.3.0"
+
+from .barcode import Wrapper, QRreader, BarcodeOpencv, BarcodeQRZbar
+from .base import ReaderResults
+
+__all__ = [
+    "Wrapper",
+    "QRreader",
+    "BarcodeOpencv",
+    "BarcodeQRZbar",
+    "ReaderResults",
+]

src/deep_barcode_reader/barcode.py

@@ -0,0 +1,160 @@
+"""Barcode detector and reader models"""
+
+# pylint: disable=E1101
+import logging
+from typing import Any, Tuple
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import numpy as np
+import cv2
+
+from pyzbar.pyzbar import decode
+from qreader import QReader
+
+from .base import BarcodeBase, ReaderResults
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BarcodeOpencv(BarcodeBase):
+    """This a simple 1D barcode reader using OpenCV. It can be used with
+    EAN-8, EAN-13, UPC-A and UPC-E types of barcodes"""
+
+    proto_file: Path = field(
+        init=False, default=Path("./src/deep_barcode_reader/models/sr.prototxt")
+    )
+    model_file: Path = field(
+        init=False, default=Path("./src/deep_barcode_reader/models/sr.caffemodel")
+    )
+
+    def __post_init__(self) -> None:
+        """Post initialization of the barcode reader class"""
+        if not self.model_file.exists():
+            logger.error(
+                "The model file does not exist for the BarcodeOpencv model. Please check the path."
+            )
+        if not self.proto_file.exists():
+            logger.error(
+                "The proto file does not exist for the BarcodeOpencv model. Please check the path."
+            )
+
+    async def detect_decode(self, image: Any) -> ReaderResults:
+        """Detect and decode barcode method from an image"""
+        result = ReaderResults(image=image)
+        barcode_reader = cv2.barcode.BarcodeDetector(
+            str(self.proto_file), str(self.model_file)
+        )
+        retval, decoded_info, barcode_types, boundary_boxs = (
+            barcode_reader.detectAndDecodeWithType(image)
+        )
+        if retval:
+            for idx, barc_txt in enumerate(decoded_info):
+                if barc_txt:
+                    result.decoded_data.append(barc_txt)
+                    result.bbox_data.append(
+                        np.array(boundary_boxs[idx], dtype=np.int32)
+                    )
+                    result.decoded_types.append(barcode_types[idx])
+        if result.decoded_data:
+            logger.info(
+                "The barcode/qr code is detected and decoded successfully with BarcodeOpencv method."
+            )
+        else:
+            logger.warning(
+                "The barcode/qr code is not detected or decoded with BarcodeOpencv method."
+            )
+
+        return result
+
+
+@dataclass
+class BarcodeQRZbar(BarcodeBase):
+    """This is a QR code and barcode reader using Zbar library"""
+
+    async def detect_decode(self, image: Any) -> ReaderResults:
+        """Detect and decode barcode/qr method from an image"""
+        result = ReaderResults(image=image)
+        decoder = decode(image)
+        decoded_data = []
+        decoded_types = []
+        bbox_data = []
+        if decoder:
+            for decoded in decoder:
+                if decoded.data.decode("utf-8"):
+                    decoded_data.append(decoded.data.decode("utf-8"))
+                    decoded_types.append(decoded.type)
+                    bbox_data.append(np.array(decoded.polygon, np.int64))
+        result.decoded_data = decoded_data
+        result.decoded_types = decoded_types
+        result.bbox_data = bbox_data
+        if result.decoded_data:
+            logger.info(
+                "The barcode/qr code is detected and decoded successfully with BarcodeQRZbar method."
+            )
+        else:
+            logger.warning(
+                "The barcode/qr code is not detected or decoded with BarcodeQRZbar method."
+            )
+        return result
+
+
+@dataclass
+class QRreader(BarcodeBase):
+    """This is a QR code reader using Qreader library"""
+
+    model_size: str = field(default="l")
+
+    async def detect_decode(self, image: Any) -> ReaderResults:
+        """Detect and decode barcode/qr method from an image"""
+        result = ReaderResults(image=image)
+        qr_reader = QReader(model_size=self.model_size)
+        detections = qr_reader.detect(image=image)
+        decoded_data = []
+        decoded_types = []
+        bbox_data = []
+        if detections:
+            for detection in detections:
+                decoded_text = qr_reader.decode(image, detection)
+                if decoded_text:
+                    decoded_data.append(decoded_text)
+                    decoded_types.append("QR")
+                    bbox_data.append(np.array(detection["polygon_xy"], np.int64))
+            if decoded_data:
+                result.decoded_data = decoded_data
+                result.decoded_types = decoded_types
+                result.bbox_data = bbox_data
+                logger.info(
+                    "The barcode/qr code is detected and decoded successfully with QRreader method."
+                )
+            else:
+                logger.warning(
+                    "The barcode/qr code is not detected or decoded with QRreader method."
+                )
+        else:
+            logger.warning("The barcode/qr code is not detected with QRreader method.")
+
+        return result
+
+
+@dataclass
+class Wrapper:
+    """Wrapper class for barcode readers"""
+
+    method: str = field(default="opencv")
+    model_size: str = field(default="l")
+
+    async def method_selection(self, image: Any, result_path: str) -> Tuple[Any, Any]:
+        """Wrap the method selection for barcode reader"""
+        if self.method == "opencv":
+            barcode: Any = BarcodeOpencv()
+        elif self.method == "zbar":
+            barcode = BarcodeQRZbar()
+        elif self.method == "qrreader":
+            barcode = QRreader(model_size=self.model_size)
+        else:
+            barcode = BarcodeOpencv()
+        detections = await barcode.detect_decode(image)
+        result_image = await detections.visualize_results_async(result_path)
+        return detections, result_image

src/deep_barcode_reader/base.py

@@ -0,0 +1,70 @@
+"""This is the base class for implementing barcode reader and decoder models"""
+
+# pylint: disable=E1101
+import logging
+from typing import Any, List, Optional
+from pathlib import Path
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+
+import cv2
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BarcodeBase(ABC):
+    """This is the base class for implementing different methods of barcode/qr code reading and decoding"""
+
+    @abstractmethod
+    async def detect_decode(self, image: Any) -> Any:
+        """Detect and decode barcode/qr method from an image"""
+        raise NotImplementedError()
+
+
+@dataclass
+class ReaderResults:
+    """Dataclass for saving/visualizing barcode/qr code reader results"""
+
+    image: Any
+    decoded_data: List[str] = field(default_factory=list)
+    decoded_types: List[str] = field(default_factory=list)
+    bbox_data: List[Any] = field(default_factory=list)
+
+    def save_image(self, img: Any, file_name: str = "") -> None:
+        """Save the image to the output path for debugging"""
+        if file_name != "":
+            Path(file_name).parent.mkdir(parents=True, exist_ok=True)
+            cv2.imwrite(file_name, img)
+            logger.info("Image is saved to %s", file_name)
+
+    async def visualize_results_async(self, file_name: str) -> Optional[Any]:
+        """Visualize the results of the barcode/qr code reader"""
+        if self.image is None:
+            logger.error(
+                "The image is not provided as the image is not loaded properly or does not exist."
+            )
+            return None
+        img_bounding_box = self.image.copy()
+        if self.decoded_data is not None and self.bbox_data is not None:
+            for data, bbox in zip(self.decoded_data, self.bbox_data):
+                cv2.polylines(
+                    img_bounding_box,
+                    [bbox],
+                    isClosed=True,
+                    color=(0, 0, 255),
+                    thickness=1,
+                )
+                cv2.putText(
+                    img_bounding_box,
+                    str(data),
+                    (int(bbox[0][0]) - 10, int(bbox[0][1]) - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (0, 0, 255),
+                    1,
+                )
+
+        self.save_image(img_bounding_box, file_name)
+        return img_bounding_box

src/deep_barcode_reader/logging.py

@@ -0,0 +1,30 @@
+"""Logger initialization"""
+
+import logging
+import logging.config
+from typing import Any
+
+
+def config_logger(loglevel: int) -> Any:
+    """Initialize a custom logger"""
+    default_logging_config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "standard": {
+                "format": "%(asctime)s - [%(levelname)s] [%(name)s.%(funcName)s:%(lineno)d (%(process)d)] | %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+            },
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "formatter": "standard",
+            },
+        },
+        "root": {
+            "handlers": ["console"],
+            "level": loglevel,
+        },
+    }
+    logging.config.dictConfig(default_logging_config)

src/deep_barcode_reader/main.py

@@ -0,0 +1,72 @@
+"""Run the main code for Deep-Barcode-Reader"""
+
+# pylint: disable=E1101
+from pathlib import Path
+import logging
+import asyncio
+import click
+import cv2
+
+
+from deep_barcode_reader import __version__
+from deep_barcode_reader.logging import config_logger
+from deep_barcode_reader.barcode import Wrapper
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.version_option(version=__version__)
+@click.option(
+    "-v",
+    "--verbose",
+    count=True,
+    help="Shorthand for info/debug/warning/error loglevel (-v/-vv/-vvv/-vvvv)",
+)
+@click.option(
+    "-s",
+    "--result_path",
+    type=str,
+    default="output/test.png",
+    help="Path to save the result file.",
+)
+@click.option(
+    "-d",
+    "--data_path",
+    required=True,
+    type=click.Path(exists=True),
+    help="Path to data file.",
+)
+@click.option(
+    "-m",
+    "--method",
+    type=click.Choice(["opencv", "zbar", "qrreader"], case_sensitive=False),
+    default="opencv",
+    help="Path to data file.",
+)
+@click.option(
+    "--model_size",
+    type=click.Choice(["n", "s", "m", "l"], case_sensitive=False),
+    default="m",
+    help="Model size for the barcode reader.",
+)
+def deep_barcode_reader_cli(
+    verbose: int, result_path: str, data_path: Path, method: str, model_size: str
+) -> None:
+    """It can read different types of barcodes"""
+    if verbose == 1:
+        log_level = 10
+    elif verbose == 2:
+        log_level = 20
+    elif verbose == 3:
+        log_level = 30
+    else:
+        log_level = 40
+    config_logger(log_level)
+
+    reader = Wrapper(model_size=model_size, method=method)
+    _ = asyncio.get_event_loop().run_until_complete(
+        reader.method_selection(
+            image=cv2.imread(str(data_path)), result_path=result_path
+        )
+    )

src/deep_barcode_reader/models/sr.caffemodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5d36889d8e6ef2f1c1f515f807cec03979320ac81792cd8fb927c31fd658ae3
+size 23929

src/deep_barcode_reader/models/sr.prototxt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ae41acba97e8b4a8e741ee350481e49b8e01d787193f470a4c95ee1c02d5b61
+size 5984

tests/test_deep_barcode_reader.py

@@ -0,0 +1,8 @@
+"""Package level tests"""
+
+from deep_barcode_reader import __version__
+
+
+def test_version() -> None:
+    """Unit test for checking the version of the code"""
+    assert __version__ == "0.3.0"