🔍 Code Extractor

A parameterized class that continuously monitors a Neo4j database for barcode scans associated with a specific user, updating a reactive parameter when new barcodes are detected.

Purpose

This class provides real-time barcode monitoring functionality by periodically querying a Neo4j database for barcode values scanned by a specific user. It uses Panel's periodic callback mechanism to poll the database every 0.5 seconds and updates a reactive parameter that can be watched for changes. The class is designed for applications requiring barcode input tracking, such as inventory management, laboratory workflows, or access control systems where multiple users may be scanning barcodes simultaneously.

Source Code

class Barcode_checker(param.Parameterized):
    """
    Parameterized class to query the database for an update barcode. Requires a user UID as input.
    
    Example
    -------
    $    checker = Barcode_checker(user_UID)
    $    def callback(event): #two ways of printing the new barcode
    $        print(event.new)
    $        print(event.obj.barcode)
    $    watcher = checker.param.watch(callback, 'barcode')
    $    checker.start()
    
    Parameters
    ----------
    user_UID : str
        The UID linked to a user, to check only the specific user's barcode inputs
    cb : periodic_callback
        A periodic callback, calls method _update_barcode every 0.5 seconds
    
    Attributes
    ----------
    barcode : param.String 
        containing the barcode scanned by the current user, if there is any
    """

    barcode = param.String(default='')
    active = param.Boolean(False, doc="Whether the barcode checker is running")
    
    def __init__(self, user_UID, **kwargs):
        super().__init__(**kwargs)
        self.graph = Graph(config.CORE_DB_ADDR, auth=config.CORE_DB_AUTH, name=config.CORE_DB_NAME)
        self.user_UID = user_UID
        self.cb = pn.state.add_periodic_callback(self._update_barcode, start = False)
        logger.info(f"Barcode reader initialized for user {self.user_UID}")

    def _update_barcode(self):
        """
        Query the database to see if the current user scanned any barcodes
        Updates the barcode attribute
        """
        barcode = self.graph.run(f"MATCH (u:User {{UID:'{self.user_UID}'}}) return u.Scan_value").evaluate()
        if barcode and not barcode == self.barcode:
            logger.info(f"Scanned barcode:\t {barcode}")
            self.barcode=barcode
            
    def clear(self):
        """
        Clear current barcode value
        """
        self.barcode = ''
        self._clear_barcode()
        
    def _clear_barcode(self):
        """
        Clears the Scan_value field in the database for the current user
        """
        try:
            self.graph.run(f"MATCH (u:User {{UID:'{self.user_UID}'}}) REMOVE u.Scan_value")
            logger.info(f"Cleared barcode for user UID {self.user_UID}")
        except:
            pass
        
    def start(self):
        """
        First clears any barcode for the current user, then starts the periodic callback
        """
        self.active=True
        self._clear_barcode()
        self.cb.start()
        logger.info(f"Started barcode reader for user {self.user_UID}")
        
    def stop(self):
        """
        First stops the periodic callback, then clears any barcode for the current user
        """ 
        self.active=False
        self.cb.stop()
        self._clear_barcode()
        logger.info(f"Stopped barcode reader for user {self.user_UID}")

Parameters

Parameter Details

user_UID: A unique identifier string for the user whose barcode scans should be monitored. This UID is used to query the Neo4j database and filter barcode scans to only those associated with this specific user. Must match the UID stored in the User nodes in the database.

**kwargs: Additional keyword arguments passed to the parent param.Parameterized class for configuration of parameterized behavior.

Return Value

Instantiation returns a Barcode_checker object that monitors barcode scans for the specified user. The object maintains a 'barcode' attribute (param.String) that contains the most recently scanned barcode value, and an 'active' attribute (param.Boolean) indicating whether monitoring is currently running. Methods return None except for implicit returns from parameter updates.

Class Interface

Methods

Attributes

Dependencies

• neo4j
• panel
• param
• logging

Required Imports

from neo4j_driver import Graph
import panel as pn
import param
import config
import logging

Usage Example

import panel as pn
from barcode_checker import Barcode_checker
import config

# Initialize Panel (required for periodic callbacks)
pn.extension()

# Create barcode checker for a specific user
user_id = 'user_12345'
checker = Barcode_checker(user_id)

# Define callback to handle new barcodes
def on_barcode_scanned(event):
    print(f'New barcode detected: {event.new}')
    print(f'Current barcode value: {event.obj.barcode}')
    # Process the barcode...
    # Clear after processing
    event.obj.clear()

# Watch for barcode changes
watcher = checker.param.watch(on_barcode_scanned, 'barcode')

# Start monitoring
checker.start()

# ... application runs ...

# Stop monitoring when done
checker.stop()

Best Practices

• Always call start() method after instantiation to begin monitoring for barcodes
• Always call stop() method when done to clean up resources and prevent memory leaks from the periodic callback
• Use param.watch() to register callbacks that respond to barcode changes rather than polling the barcode attribute
• Call clear() after processing each barcode to reset the state and prepare for the next scan
• Ensure Panel server is initialized (pn.extension()) before creating instances
• The class maintains database connections through the Graph object; consider connection pooling for multiple users
• The periodic callback runs every 0.5 seconds by default; this may need adjustment based on performance requirements
• Database queries use string formatting which could be vulnerable to injection; ensure user_UID is validated
• The active attribute can be monitored to check if the checker is currently running
• Multiple Barcode_checker instances can run simultaneously for different users without interference

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• class Click_watcher 47.0% similar

  A wrapper class that adds click detection functionality to Panel objects by wrapping them in a clickable div element and tracking the number of clicks.

  From: /tf/active/vicechatdev/resources/py2html.py

• class Enter_watcher 45.3% similar

  A Panel ReactiveHTML wrapper class that monitors Enter key presses on wrapped panel objects (like text fields or buttons) and tracks the count of Enter key events.

  From: /tf/active/vicechatdev/resources/py2html.py

• class Cassette_Printer 44.2% similar

  A class that generates and saves cassette label images for printing by writing cassette information to a shared folder monitored by a Windows virtual PC.

  From: /tf/active/vicechatdev/resources/printers.py

• function count_user_notifications 43.0% similar

  Counts the total number of notifications for a specific user in a Neo4j graph database, with an option to filter for only unread notifications.

  From: /tf/active/vicechatdev/CDocs/utils/notifications.py

• class User 42.8% similar

  A user management class that handles authentication, authorization, user profiles, preferences, file management, and logging for a Panel-based web application with Neo4j backend.

  From: /tf/active/vicechatdev/userclass.py