smartx-rfid 0.4.0__py3-none-any.whl → 1.1.6__py3-none-any.whl

smartx_rfid/devices/RFID/R700_IOT/_main.py

@@ -13,6 +13,8 @@ from .reader_config_example import R700_IOT_config_example
 
 
 class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
+    """Impinj R700 RFID reader using HTTP REST API."""
+
     def __init__(
         self,
         # READER CONFIG
@@ -26,6 +28,18 @@ class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
         # Firmware Version
         firmware_version: str = "8.4.1",
     ):
+        """
+        Create R700 RFID reader.
+
+        Args:
+            reading_config: Configuration for tag reading
+            name: Device name
+            ip: IP address of reader
+            username: Login username
+            password: Login password
+            start_reading: Start reading tags automatically
+            firmware_version: Expected firmware version
+        """
         self.name = name
         self.device_type = "rfid"
 
@@ -62,6 +76,7 @@ class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
         self.on_event = on_event
 
     async def disconnect(self):
+        """Safely disconnect from reader and stop reading."""
         """Desconecta o reader de forma segura."""
         logging.info(f"{self.name} 🔌 Disconnecting reader")
         self._stop_connection = True
@@ -79,6 +94,7 @@ class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
         self.on_event(self.name, "connection", False)
 
     async def connect(self):
+        """Connect to R700 reader and start tag reading."""
         self._stop_connection = False
         while not self._stop_connection:
             async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=10.0) as session:
@@ -130,6 +146,7 @@ class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
                 await self.get_tag_list(session)
 
     async def clear_tags(self):
+        """Clear all stored tags from memory."""
         self.tags = {}
 
     async def write_gpo(
@@ -141,6 +158,15 @@ class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
         *args,
         **kwargs,
     ):
+        """
+        Control GPO (output) pins on reader.
+
+        Args:
+            pin: GPO pin number
+            state: Turn pin on (True) or off (False)
+            control: Control type (static or pulse)
+            time: Pulse duration in milliseconds
+        """
         gpo_command = await self.get_gpo_command(pin=pin, state=state, control=control, time=time)
         try:
             async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=10.0) as session:
@@ -149,6 +175,15 @@ class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
             logging.warning(f"{self.name} - Failed to set GPO: {e}")
 
     def write_epc(self, target_identifier: str | None, target_value: str | None, new_epc: str, password: str):
+        """
+        Write new EPC code to RFID tag.
+
+        Args:
+            target_identifier: How to find tag (epc, tid, user)
+            target_value: Current tag value to match
+            new_epc: New EPC code to write
+            password: Tag access password
+        """
         """
         Writes a new EPC (Electronic Product Code) to RFID tags.
         """

smartx_rfid/devices/RFID/R700_IOT/on_event.py

@@ -1,13 +1,22 @@
 class OnEvent:
+    """Handle R700 reader events."""
+
     async def on_start(self):
+        """Called when reader starts reading tags."""
         self.is_reading = True
         self.on_event(self.name, "reading", True)
 
     async def on_stop(self):
+        """Called when reader stops reading tags."""
         self.is_reading = False
         self.on_event(self.name, "reading", False)
 
     async def on_tag(self, tag):
+        """Process detected RFID tag data.
+
+        Args:
+            tag: Raw tag data from reader API
+        """
         current_tag = {
             "epc": tag.get("epcHex"),
             "tid": tag.get("tidHex"),

smartx_rfid/devices/RFID/R700_IOT/reader_helpers.py

@@ -6,7 +6,17 @@ import httpx
 
 
 class ReaderHelpers:
+    """Helper methods for R700 reader management."""
+
     async def check_firmware_version(self, session: httpx.AsyncClient | None = None):
+        """Check if reader firmware version is compatible.
+
+        Args:
+            session: HTTP session to use
+
+        Returns:
+            bool: True if firmware is compatible
+        """
         endpoint = self.check_version_endpoint
 
         try:

smartx_rfid/devices/RFID/R700_IOT/write_commands.py

@@ -4,7 +4,17 @@ import httpx
 
 
 class WriteCommands:
+    """RFID tag write commands for R700 reader."""
+
     async def get_write_cmd(self, tag):
+        """Generate write command for tag programming.
+
+        Args:
+            tag: Tag data with target and new EPC
+
+        Returns:
+            dict: Write command for R700 API
+        """
         identifier = tag.target_identifier
         target = tag.target_value
         epc = tag.new_epc

smartx_rfid/devices/RFID/X714/_main.py

@@ -21,6 +21,8 @@ ant_default_config = {
 
 
 class X714(SerialProtocol, OnReceive, RfidCommands, BLEProtocol, WriteCommands, TCPProtocol):
+    """RFID reader that supports SERIAL, TCP and BLE connections."""
+
     def __init__(
         self,
         name: str = "X714",
@@ -56,6 +58,37 @@ class X714(SerialProtocol, OnReceive, RfidCommands, BLEProtocol, WriteCommands,
         read_power: int = 22,
         read_rssi: int = -120,
     ):
+        """
+        Create X714 RFID reader.
+
+        Args:
+            name: Device name
+            connection_type: How to connect (SERIAL, TCP, BLE)
+            port: Serial port or AUTO to detect
+            baudrate: Serial speed
+            vid: USB vendor ID for auto-detect
+            pid: USB product ID for auto-detect
+            ip: IP address for TCP connection
+            tcp_port: TCP port number
+            ble_name: Bluetooth device name
+            buzzer: Make sound when reading tags
+            session: EPC session number (0-3)
+            start_reading: Start reading tags automatically
+            gpi_start: Use GPI input to start reading
+            ignore_read: Skip duplicate tags
+            always_send: Send all tag events
+            simple_send: Use simple tag format
+            keyboard: Act like keyboard input
+            decode_gtin: Decode GTIN barcodes
+            hotspot: Enable hotspot mode
+            reconnection_time: Seconds to wait before reconnect
+            prefix: Text to add before tag data
+            protected_inventory_password: Password for protected reading
+            ant_dict: Custom antenna settings
+            active_ant: Which antennas to use
+            read_power: TX power in dBm
+            read_rssi: RSSI threshold in dBm
+        """
         # Name
         self.name = name
         self.device_type = "rfid"
@@ -125,6 +158,12 @@ class X714(SerialProtocol, OnReceive, RfidCommands, BLEProtocol, WriteCommands,
         self.on_event: Callable = on_event
 
     def write(self, to_send, verbose=True):
+        """Send data to reader using current connection type.
+
+        Args:
+            to_send: Data to send
+            verbose: Show sent data in logs
+        """
         if self.connection_type == "SERIAL":
             self.write_serial(to_send, verbose)
         elif self.connection_type == "BLE":
@@ -133,6 +172,7 @@ class X714(SerialProtocol, OnReceive, RfidCommands, BLEProtocol, WriteCommands,
             asyncio.create_task(self.write_tcp(to_send, verbose))
 
     async def connect(self):
+        """Connect to reader using configured connection type."""
         if self.connection_type == "SERIAL":
             await self.connect_serial()
         elif self.connection_type == "BLE":
@@ -141,6 +181,6 @@ class X714(SerialProtocol, OnReceive, RfidCommands, BLEProtocol, WriteCommands,
             await self.connect_tcp(self.ip, self.tcp_port)
 
     def on_connected(self):
-        """Callback chamado quando a conexão é estabelecida."""
+        """Called when connection is established. Sets up reader."""
         self.config_reader()
         self.on_event(self.name, "connected", True)

smartx_rfid/devices/RFID/X714/on_receive.py

@@ -3,7 +3,15 @@ import logging
 
 
 class OnReceive:
+    """Handle incoming data from X714 reader."""
+
     def on_receive(self, data, verbose: bool = False):
+        """Process data received from reader.
+
+        Args:
+            data: Raw data from reader
+            verbose: Show received data in logs
+        """
         if not isinstance(data, str):
             data = data.decode(errors="ignore")
         data = data.replace("\r", "").replace("\n", "")
@@ -39,13 +47,25 @@ class OnReceive:
             self.on_event(self.name, "tags_cleared", True)
 
     def on_start(self):
+        """Called when reader starts reading tags."""
         self.clear_tags()
         self.on_event(self.name, "reading", True)
 
     def on_stop(self):
+        """Called when reader stops reading tags."""
         self.on_event(self.name, "reading", False)
 
     def on_tag(self, tag: dict):
+        """Process detected RFID tag data.
+
+        Args:
+            tag: Tag information dictionary
+        """
+        """Process detected RFID tag data.
+        
+        Args:
+            tag: Tag information dictionary
+        """
         try:
             tag_data = TagSchema(**tag)
             tag = tag_data.model_dump()

smartx_rfid/devices/RFID/X714/rfid.py

@@ -2,16 +2,22 @@ import asyncio
 
 
 class RfidCommands:
+    """RFID reader control commands for X714."""
+
     def start_inventory(self):
+        """Start reading RFID tags."""
         self.write("#READ:ON")
 
     def stop_inventory(self):
+        """Stop reading RFID tags."""
         self.write("#READ:OFF")
 
     def clear_tags(self):
+        """Clear all stored tags from memory."""
         self.write("#CLEAR")
 
     def config_reader(self):
+        """Configure reader settings like antennas, session, etc."""
         set_cmd = "#set_cmd:"
 
         # ANTENNAS
@@ -26,6 +32,8 @@ class RfidCommands:
 
         # START_READING
         set_cmd += f"|START_READING:{self.start_reading}"
+        if self.start_reading:
+            self.is_reading = True
 
         # GPI_START
         set_cmd += f"|GPI_START:{self.gpi_start}"

smartx_rfid/devices/RFID/X714/write_commands.py

@@ -3,7 +3,17 @@ from smartx_rfid.schemas.tag import WriteTagValidator
 
 
 class WriteCommands:
+    """RFID tag write commands for X714."""
+
     def write_epc(self, target_identifier: str | None, target_value: str | None, new_epc: str, password: str):
+        """Write new EPC code to RFID tag.
+
+        Args:
+            target_identifier: How to find tag (epc, tid, user)
+            target_value: Current tag value to match
+            new_epc: New EPC code to write
+            password: Tag access password
+        """
         try:
             validated_tag = WriteTagValidator(
                 target_identifier=target_identifier,

smartx_rfid/devices/generic/SERIAL/_main.py

@@ -137,13 +137,11 @@ class SERIAL(asyncio.Protocol):
 
     def write(self, to_send, verbose=True):
         """
-        Send data through the serial connection.
-
-        Automatically adds newline to strings and calculates CRC16 for bytes.
+        Send data through serial port.
 
         Args:
-                to_send: Data to send (str or bytes)
-                verbose: Enable logging of sent data
+            to_send: Data to send (string or bytes)
+            verbose: Show sent data in logs
         """
         if self.transport:
             if isinstance(to_send, str):
@@ -167,6 +165,7 @@ class SERIAL(asyncio.Protocol):
             logging.warning("❌ Send attempt failed: connection not established.")
 
     async def connect(self):
+        """Connect to serial port and keep connection alive."""
         """
         Establish and maintain serial connection with automatic reconnection.
 
@@ -216,6 +215,16 @@ class SERIAL(asyncio.Protocol):
             await asyncio.sleep(3)
 
     def crc16(self, data: bytes, poly=0x8408):
+        """
+        Calculate CRC16 checksum for data validation.
+
+        Args:
+            data: Input bytes to calculate checksum
+            poly: CRC polynomial value
+
+        Returns:
+            int: 16-bit checksum value
+        """
         """
         Calculate CRC-16/CCITT-FALSE checksum.
 

smartx_rfid/devices/generic/TCP/_main.py

@@ -7,12 +7,22 @@ from typing import Callable
 
 
 class TCP(Helpers):
+    """TCP connection handler for network communication."""
+
     def __init__(
         self,
         name: str = "GENERIC_TCP",
         ip: str = "192.168.1.101",
         port: int = 23,
     ):
+        """
+        Create TCP connection.
+
+        Args:
+            name: Device name
+            ip: IP address to connect
+            port: TCP port number
+        """
         self.name = name
         self.device_type = "generic"
 
@@ -26,6 +36,7 @@ class TCP(Helpers):
         self.on_event: Callable = on_event
 
     async def connect(self):
+        """Connect to TCP server and keep connection alive."""
         while True:
             try:
                 logging.info(f"Connecting: {self.name} - {self.ip}:{self.port}")
@@ -59,6 +70,13 @@ class TCP(Helpers):
             await asyncio.sleep(3)
 
     async def write(self, data: str, verbose=True):
+        """
+        Send data through TCP connection.
+
+        Args:
+            data: Text to send
+            verbose: Show sent data in logs
+        """
         if self.is_connected and self.writer:
             try:
                 data = data + "\n"

smartx_rfid/devices/generic/TCP/helpers.py

@@ -3,7 +3,10 @@ import logging
 
 
 class Helpers:
+    """Helper functions for TCP connection management."""
+
     async def monitor_connection(self):
+        """Check if TCP connection is still alive."""
         while self.is_connected:
             await asyncio.sleep(3)
             if (self.writer and self.writer.is_closing()) or (self.reader and self.reader.at_eof()):
@@ -14,6 +17,7 @@ class Helpers:
             await self.write("ping", verbose=False)
 
     async def receive_data(self):
+        """Receive and process incoming TCP data."""
         buffer = ""
         try:
             while True:

smartx_rfid/schemas/events.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+
+class EventSchema(BaseModel):
+    event_type: str = Field("event", description="Type of the event")
+    event_data = Field(None, description="Associated data with the event")

smartx_rfid/schemas/tag.py

@@ -5,9 +5,9 @@ from pydantic import BaseModel, Field, field_validator
 
 class TagSchema(BaseModel):
     epc: str = Field("000000000000000000000001")
-    tid: Optional[str | None] = Field("E28000000000000000000001")
-    ant: Optional[int | None] = 0
-    rssi: Optional[int | None] = 0
+    tid: Optional[str | None] = Field(None)
+    ant: Optional[int | None] = None
+    rssi: Optional[int | None] = None
 
     @field_validator("epc", "tid")
     def validate_epc_length_and_hex(cls, v, field):

smartx_rfid/utils/__init__.py

@@ -0,0 +1,2 @@
+from .tag_list import TagList
+from .logger_manager import LoggerManager

smartx_rfid/utils/logger_manager.py

@@ -0,0 +1,167 @@
+import logging
+import os
+import queue
+import threading
+import sys
+import asyncio
+from datetime import datetime, timezone
+
+
+class LoggerManager:
+    """
+    Simple plug-and-play daily rotating logger.
+
+    Usage:
+        logger_manager = LoggerManager("logs", "myapp", storage_days=7)
+        logging.info("App started")
+        # Exceptions, even uncaught, are automatically logged
+    """
+
+    def __init__(self, log_path: str, base_filename: str, storage_days: int = 7, use_utc: bool = False):
+        self.log_path = os.path.abspath(log_path)
+        self.base_filename = base_filename
+        self.storage_days = storage_days
+        self.use_utc = use_utc
+
+        os.makedirs(self.log_path, exist_ok=True)
+
+        # Queue and thread for async logging
+        self.log_queue: queue.Queue[str] = queue.Queue(maxsize=10_000)
+        self.stop_event = threading.Event()
+        self.current_date = None
+        self.filename = self._get_filename_for_date(self._now().date())
+
+        self.worker_thread = threading.Thread(target=self._worker, name="LogWriterThread", daemon=True)
+        self.worker_thread.start()
+
+        # Setup logging
+        self._setup_logging()
+
+        # Global exception handlers
+        sys.excepthook = self._handle_exception
+        try:
+            loop = asyncio.get_event_loop()
+            loop.set_exception_handler(self._asyncio_exception_handler)
+        except RuntimeError:
+            pass
+
+        logging.info(f"Logger initialized: {self.filename}")
+
+    # -------------------
+    # Date & filename
+    # -------------------
+    def _now(self):
+        return datetime.now(timezone.utc) if self.use_utc else datetime.now()
+
+    def _get_filename_for_date(self, date: datetime.date):
+        # Date before filename: YYYY-MM-DD_myapp.log
+        return os.path.join(self.log_path, f"{date:%Y-%m-%d}_{self.base_filename}.log")
+
+    # -------------------
+    # Worker
+    # -------------------
+    def _worker(self):
+        while not self.stop_event.is_set() or not self.log_queue.empty():
+            try:
+                msg = self.log_queue.get(timeout=0.5)
+                self._write(msg)
+            except queue.Empty:
+                continue
+
+    def _write(self, msg: str):
+        today = self._now().date()
+        if today != self.current_date:
+            self.current_date = today
+            self.filename = self._get_filename_for_date(today)
+            self._cleanup_old_logs()
+        with open(self.filename, "a", encoding="utf-8", errors="replace") as f:
+            f.write(msg)
+
+    # -------------------
+    # Cleanup old logs
+    # -------------------
+    def _cleanup_old_logs(self):
+        files = []
+        for f in os.listdir(self.log_path):
+            if f.endswith(".log") and f.startswith(f"{self.current_date:%Y-%m-%d}"):
+                # skip current file
+                continue
+            if f.startswith("_".join([self.base_filename, ""])):  # ignore wrongly named files
+                continue
+            if f.endswith(".log"):
+                try:
+                    date_str = f.split("_")[0]
+                    file_date = datetime.strptime(date_str, "%Y-%m-%d").date()
+                    files.append((file_date, os.path.join(self.log_path, f)))
+                except Exception:
+                    continue
+        files.sort(key=lambda x: x[0])
+        for _, old_file in files[: -self.storage_days]:
+            try:
+                os.remove(old_file)
+            except Exception:
+                pass
+
+    # -------------------
+    # Logging setup
+    # -------------------
+    def _setup_logging(self):
+        logger = logging.getLogger()
+        logger.setLevel(logging.INFO)
+
+        # Remove old handlers
+        for handler in logger.handlers[:]:
+            logger.removeHandler(handler)
+
+        # Console
+        ch = logging.StreamHandler()
+        ch.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        logger.addHandler(ch)
+
+        # File (async)
+        fh = logging.Handler()
+        fh.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        fh.emit = self._enqueue
+        logger.addHandler(fh)
+
+    # -------------------
+    # Enqueue log messages
+    # -------------------
+    def _enqueue(self, record: logging.LogRecord):
+        try:
+            # Include exception info if present
+            msg = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s").format(record)
+            if record.exc_info:
+                msg += "\n" + logging.Formatter().formatException(record.exc_info)
+            msg += "\n"
+            self.log_queue.put_nowait(msg)
+        except queue.Full:
+            pass
+        except Exception:
+            self.handleError(record)
+
+    # -------------------
+    # Exception hooks
+    # -------------------
+    @staticmethod
+    def _handle_exception(exc_type, exc_value, exc_traceback):
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+        logging.getLogger().error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
+
+    @staticmethod
+    def _asyncio_exception_handler(loop, context):
+        exception = context.get("exception")
+        logger = logging.getLogger()
+        if exception:
+            logger.error("Unhandled asyncio exception", exc_info=exception)
+        else:
+            logger.error("Unhandled asyncio error: %s", context.get("message"))
+
+    # -------------------
+    # Close
+    # -------------------
+    def close(self):
+        self.stop_event.set()
+        self.worker_thread.join(timeout=3)

smartx_rfid/utils/path.py

@@ -0,0 +1,117 @@
+import importlib
+import logging
+import sys
+from pathlib import Path
+
+
+def get_frozen_path(relative_path: str) -> Path:
+    """
+    Return the absolute path to a file or directory, taking into account
+    whether the application is running from source or as a frozen executable.
+
+    Args:
+        relative_path: Relative path to the file or directory.
+
+    Returns:
+        The resolved absolute path.
+    """
+    if getattr(sys, "frozen", False):
+        base_path = Path(sys._MEIPASS)
+    else:
+        base_path = Path(sys.argv[0]).resolve().parent
+
+    return base_path / relative_path
+
+
+def get_prefix_from_path(current_file: str, base_dir: str = "routers") -> str:
+    """
+    Automatically generate an API router prefix based on the folder structure
+    starting from the given base directory.
+
+    Args:
+        current_file: Usually __file__.
+        base_dir: Root directory name for routers.
+
+    Returns:
+        The router prefix (e.g. "/rfid/get").
+    """
+    path = Path(current_file).resolve()
+    parts = path.parts
+
+    if base_dir not in parts:
+        raise ValueError(f"'{base_dir}' not found in path: {path}")
+
+    base_index = parts.index(base_dir)
+    prefix_parts = parts[base_index + 1 :]
+    prefix_string = "/" + "/".join(prefix_parts)
+
+    return prefix_string.replace(".py", "")
+
+
+def include_all_routers(current_path: str, app) -> None:
+    """
+    Recursively discover and include all API routers found in the given path.
+    """
+    routes_path = get_frozen_path(current_path)
+
+    for entry in Path(routes_path).iterdir():
+        if entry.is_dir() and entry.name != "__pycache__":
+            include_all_routers(str(Path(current_path) / entry.name), app)
+
+        elif entry.is_file() and entry.suffix == ".py" and entry.name != "__init__.py":
+            module_name = entry.stem
+            file_path = entry
+
+            spec = importlib.util.spec_from_file_location(f"app.routers.{module_name}", str(file_path))
+            module = importlib.util.module_from_spec(spec)
+
+            try:
+                spec.loader.exec_module(module)
+
+                if hasattr(module, "router"):
+                    prefix = getattr(module.router, "prefix", "") or ""
+                    app.include_router(
+                        module.router,
+                        include_in_schema=prefix.startswith("/api"),
+                    )
+
+                    try:
+                        routers_dir = Path(routes_path).resolve()
+                        relative_path = file_path.resolve().relative_to(routers_dir.parent)
+                    except Exception:
+                        relative_path = file_path.name
+
+                    logging.info(f"✅ Route loaded: {relative_path}")
+
+                else:
+                    logging.warning(f"⚠️  File {current_path} does not define a 'router'")
+
+            except Exception as e:
+                logging.error(f"❌ Error loading {current_path}: {e}", exc_info=True)
+
+
+def load_file(file_path: str | Path) -> str:
+    """
+    Load the content of a file as a string.
+
+    Args:
+        file_path (str | Path): Path to the file.
+
+    Returns:
+        str: The content of the file, or a default message if loading fails.
+    """
+    file_path = Path(file_path)
+
+    if not file_path.exists():
+        logging.warning(f"File not found: {file_path}. Using default content.")
+        return "File not found."
+
+    if not file_path.is_file():
+        logging.warning(f"Path is not a file: {file_path}. Using default content.")
+        return "Invalid file path."
+
+    try:
+        return file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        logging.error(f"Error reading file {file_path}: {e}", exc_info=True)
+        return "Error loading file content."

smartx_rfid/utils/tag_list.py

@@ -0,0 +1,227 @@
+from typing import Literal, Dict, Any, Optional, Tuple
+from datetime import datetime
+from threading import Lock
+import logging
+from pyepc import SGTIN
+
+
+class TagList:
+    """
+    Thread-safe container for RFID tags.
+
+    Tags are stored as dictionaries to allow flexible schemas per client.
+    Each tag is uniquely identified by either EPC or TID.
+    """
+
+    def __init__(self, unique_identifier: Literal["epc", "tid"] = "epc"):
+        """
+        Initialize the tag list.
+
+        Args:
+            unique_identifier: Field used as the unique tag identifier ("epc" or "tid").
+        """
+        if unique_identifier not in ("epc", "tid"):
+            raise ValueError("unique_identifier must be 'epc' or 'tid'")
+
+        self.unique_identifier = unique_identifier
+        self._tags: Dict[str, Dict[str, Any]] = {}
+        self._lock = Lock()
+
+    def __len__(self) -> int:
+        """
+        Return the number of stored tags.
+        """
+        return len(self._tags)
+
+    def __contains__(self, identifier: str) -> bool:
+        """
+        Check if a tag identifier exists in the list.
+        """
+        return identifier in self._tags
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the stored tags.
+        """
+        return repr(self.get_all())
+
+    def add(self, tag: Dict[str, Any], device: str = "Unknown") -> Tuple[bool, Optional[Dict[str, Any]]]:
+        """
+        Add or update a tag.
+
+        Returns:
+            (True, tag_dict)   if the tag is new;
+            (False, tag_dict)  if the tag already exists;
+            (False, None)      if an error occurs;
+        """
+        try:
+            identifier_value = tag.get(self.unique_identifier)
+            if not identifier_value:
+                raise ValueError(f"Tag missing '{self.unique_identifier}'")
+
+            with self._lock:
+                if identifier_value not in self._tags:
+                    stored = self._new_tag(tag, device)
+                    return True, stored
+                else:
+                    stored = self._existing_tag(tag)
+                    return False, stored
+
+        except Exception as e:
+            logging.warning(f"[ TAG ERROR ] {e}")
+            return False, None
+
+    def _new_tag(self, tag: Dict[str, Any], device: str) -> Dict[str, Any]:
+        """
+        Create and store a new tag.
+
+        Args:
+            tag: Raw tag data.
+            device: Source device identifier.
+
+        Returns:
+            The stored tag dictionary.
+        """
+        now = datetime.now()
+
+        try:
+            gtin = SGTIN.decode(tag.get("epc")).gtin
+        except Exception:
+            gtin = None
+
+        stored_tag = {
+            **tag,
+            "device": device,
+            "timestamp": now,
+            "count": 1,
+            "gtin": gtin,
+        }
+
+        self._tags[tag[self.unique_identifier]] = stored_tag
+
+        return stored_tag
+
+    def _existing_tag(self, tag: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Update an existing tag.
+
+        Args:
+            tag: Incoming tag data.
+
+        Returns:
+            The updated stored tag.
+        """
+        current = self._tags[tag[self.unique_identifier]]
+
+        current["count"] += 1
+        current["timestamp"] = datetime.now()
+
+        new_rssi = tag.get("rssi")
+        if new_rssi is not None:
+            old_rssi = current.get("rssi")
+            if old_rssi is None or abs(new_rssi) < abs(old_rssi):
+                current["rssi"] = new_rssi
+                current["ant"] = tag.get("ant")
+
+        return current
+
+    def get_all(self) -> list[Dict[str, Any]]:
+        """
+        Retrieve all stored tags.
+
+        Returns:
+            A list of tag dictionaries.
+        """
+        with self._lock:
+            return list(self._tags.values())
+
+    def get_by_identifier(self, identifier_value: str, identifier_type: str = "epc") -> Optional[Dict[str, Any]]:
+        """
+        Retrieve a tag by its identifier.
+        Args:
+            identifier_value: The value of the identifier (EPC or TID).
+            identifier_type: The type of identifier ("epc" or "tid").
+        Returns:
+            The tag dictionary if found, otherwise None.
+        """
+        if identifier_type not in ("epc", "tid"):
+            identifier_type = "epc"
+
+        if self.unique_identifier == identifier_type:
+            return self._tags.get(identifier_value)
+        
+        for tag in self._tags.values():
+            if tag.get(identifier_type) == identifier_value:
+                return tag
+            
+        return None
+
+    def clear(self) -> None:
+        """
+        Remove all stored tags.
+        """
+        with self._lock:
+            self._tags.clear()
+
+    def remove_tags_before_timestamp(self, timestamp: datetime) -> None:
+        """
+        Remove tags older than a given timestamp.
+
+        Args:
+            timestamp: Minimum timestamp to keep.
+        """
+        with self._lock:
+            self._tags = {k: v for k, v in self._tags.items() if v.get("timestamp") and v["timestamp"] >= timestamp}
+
+    def remove_tags_by_device(self, device: str) -> None:
+        """
+        Remove all tags associated with a specific device.
+
+        Args:
+            device: Device identifier.
+        """
+        with self._lock:
+            self._tags = {k: v for k, v in self._tags.items() if v.get("device") != device}
+
+    def get_tid_from_epc(self, epc: str) -> Optional[str]:
+        """
+        Retrieve the TID associated with a given EPC.
+
+        Args:
+            epc: EPC value.
+
+        Returns:
+            The TID if found, otherwise None.
+        """
+        with self._lock:
+            tag = self._tags.get(epc)
+            if tag:
+                return tag.get("tid")
+            return None
+
+    def get_epcs(self) -> list[str]:
+        """
+        Retrieve a list of all stored EPCs.
+
+        Returns:
+            A list of EPC strings.
+        """
+        with self._lock:
+            return [tag["epc"] for tag in self._tags.values() if "epc" in tag]
+
+    def get_gtin_counts(self) -> Dict[str, int]:
+        """
+        Retrieve counts of tags grouped by GTIN.
+
+        Returns:
+            A dictionary mapping GTINs to their respective counts.
+        """
+        gtin_counts: Dict[str, int] = {}
+        with self._lock:
+            for tag in self._tags.values():
+                gtin = tag.get("gtin")
+                if gtin is None:
+                    gtin = "UNKNOWN"
+                gtin_counts[gtin] = gtin_counts.get(gtin, 0) + 1
+
+        return gtin_counts

{smartx_rfid-0.4.0.dist-info → smartx_rfid-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartx-rfid
-Version: 0.4.0
+Version: 1.1.6
 Summary: SmartX RFID library
 License: MIT
 License-File: LICENSE
@@ -23,7 +23,6 @@ Requires-Dist: pydantic (>=2.12.5,<3.0.0)
 Requires-Dist: pyepc (==0.5.0)
 Requires-Dist: pyserial (==3.5)
 Requires-Dist: pyserial-asyncio (==0.6)
-Requires-Dist: ruff (>=0.14.11,<0.15.0)
 Project-URL: Documentation, https://github.com/ghpascon/smartx_rfid#readme
 Project-URL: Homepage, https://github.com/ghpascon/smartx_rfid
 Project-URL: Repository, https://github.com/ghpascon/smartx_rfid

smartx_rfid-1.1.6.dist-info/RECORD

@@ -0,0 +1,28 @@
+smartx_rfid/__init__.py,sha256=XCdKdP8o5LT3VjJtWOuFHJzztc0FXt3Ms89qsx0p6sM,282
+smartx_rfid/devices/RFID/R700_IOT/_main.py,sha256=VL2yDBCXp8Avb3PXKZyBNwtBRhwlLQb5TSs3aTUeC6w,7458
+smartx_rfid/devices/RFID/R700_IOT/on_event.py,sha256=bG_33gY2ZHXquUbezXyMN0dyHO9SBwc36DPTc8iXc1U,799
+smartx_rfid/devices/RFID/R700_IOT/reader_config_example.py,sha256=oi4vg3_zjYFDUeq1Y_d5InUx_Rq5M2CB5RDVkK3WCgU,2264
+smartx_rfid/devices/RFID/R700_IOT/reader_helpers.py,sha256=8CvvYeKGplWqceVH5mEMN2_lA2Qgw7Wo1jpYuXLQlXo,5940
+smartx_rfid/devices/RFID/R700_IOT/write_commands.py,sha256=GMROeq_daTScj4NZygF45UM9t0Pr3E6ugmrb7OlF73w,2284
+smartx_rfid/devices/RFID/X714/_main.py,sha256=LP1X_w6Sy9m5kHLvbaRUNZbzQJU37fS8OIEWvOfrk7M,6371
+smartx_rfid/devices/RFID/X714/ble_protocol.py,sha256=M3Cs66WX6oa_EPdMTLEjD-IRxAjpfrKzGj4hn1vxlxQ,6951
+smartx_rfid/devices/RFID/X714/on_receive.py,sha256=Tr8KISrblB4fsLCgGTIi7TltXlyxMS8YMXLRhM9SVTg,2194
+smartx_rfid/devices/RFID/X714/rfid.py,sha256=XgHl2evlN3tGB6hhCUYzpEy_jw2dyplxUcDYsuPec2Q,2285
+smartx_rfid/devices/RFID/X714/serial_protocol.py,sha256=eOGM5sK35SxXfS9KjB8JQzYhR1qs4H3vw3-n3oPOjQQ,3681
+smartx_rfid/devices/RFID/X714/tcp_protocol.py,sha256=GthynyN6YMl6R16nrAnlrDK61QnuZAOhYhPqycBCwJA,4804
+smartx_rfid/devices/RFID/X714/write_commands.py,sha256=tKLTATb4vDkghpw5rQuJwcnPNkViT4753fwToNPfKh0,1304
+smartx_rfid/devices/__init__.py,sha256=EVhtb-IBLpits8dr-I1ZYYuWHw9ddqiu-98myg-iyFg,251
+smartx_rfid/devices/generic/SERIAL/_main.py,sha256=7rEgviwxfd4uWpWjVXsV0qnOAET-MxJux9PcTKiE8G8,8562
+smartx_rfid/devices/generic/TCP/_main.py,sha256=DY9c9m2ZchvUJ9n2TtPENL2GqCYS4hvdjkCAe6yGXxM,2770
+smartx_rfid/devices/generic/TCP/helpers.py,sha256=GQ_yIvmSlx_yZci6pVvZfdo1wyKcS5gtZh-VDwt3pGs,1552
+smartx_rfid/schemas/events.py,sha256=0rdXXww6v1B50pGksNsGt5QhavwKpe1Jb_5f8o_SaVk,215
+smartx_rfid/schemas/tag.py,sha256=iSQkWI4MhSSVEzWhezX6UG4KJJ-FUahrfj0Hnz-H_u0,2269
+smartx_rfid/utils/__init__.py,sha256=lJA0KqFIFVDtietXGH9WwnklKkiTNvhIG6YJdDd11vk,72
+smartx_rfid/utils/event.py,sha256=7QOdiSfiMscoAaTq4U3E3asYGSVnolr9OD3FSYGh6bg,469
+smartx_rfid/utils/logger_manager.py,sha256=61HJ40wgX0hVwG4xW66IQ2jdJp8CFM_S0eoGzx8-FwU,5653
+smartx_rfid/utils/path.py,sha256=7U619vOw4BXGAKbSVdA6ZIhpCN0f-dccVax9LCclbNc,3758
+smartx_rfid/utils/tag_list.py,sha256=b_qx0-ZkjhzKiAuCM6uuBo3QpzbmB2U1Z3CNdStCyxc,6570
+smartx_rfid-1.1.6.dist-info/METADATA,sha256=pFSEmk-GgfHWxJJ_68oIrl6xd3UfjeBwbG18n419K6M,2636
+smartx_rfid-1.1.6.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+smartx_rfid-1.1.6.dist-info/licenses/LICENSE,sha256=npGJO3HuHM3JdFNEXv1jRmP_wRYq9-ujkqJPmLxrtEw,1080
+smartx_rfid-1.1.6.dist-info/RECORD,,

smartx_rfid-0.4.0.dist-info/RECORD

@@ -1,24 +0,0 @@
-smartx_rfid/__init__.py,sha256=XCdKdP8o5LT3VjJtWOuFHJzztc0FXt3Ms89qsx0p6sM,282
-smartx_rfid/devices/RFID/R700_IOT/_main.py,sha256=xd9roD7ovnJAXLp6r7PtxYz98CgKO1t6gz3t4V0KIMU,6293
-smartx_rfid/devices/RFID/R700_IOT/on_event.py,sha256=JmJ6RcGgX34b2gkuqyZ4G1LSDliRRALg_DdvenHOZVk,538
-smartx_rfid/devices/RFID/R700_IOT/reader_config_example.py,sha256=oi4vg3_zjYFDUeq1Y_d5InUx_Rq5M2CB5RDVkK3WCgU,2264
-smartx_rfid/devices/RFID/R700_IOT/reader_helpers.py,sha256=UC4ozq9FmuQtCK5Nv8Mjg4tZyuFetjx1eMWiw5yb0XY,5692
-smartx_rfid/devices/RFID/R700_IOT/write_commands.py,sha256=d1GXBaBVaNqvPWitYNZ94uZJOy2wwbj-2uzCxWOflPo,2037
-smartx_rfid/devices/RFID/X714/_main.py,sha256=ERMeQnbLevGXtZ-8Roykb67jbt53yacawibPkCs4eGo,4753
-smartx_rfid/devices/RFID/X714/ble_protocol.py,sha256=M3Cs66WX6oa_EPdMTLEjD-IRxAjpfrKzGj4hn1vxlxQ,6951
-smartx_rfid/devices/RFID/X714/on_receive.py,sha256=yjkxWL1ZGzcZKZXKwQ85cvl33fsjhXATOwg9QQBk-GQ,1641
-smartx_rfid/devices/RFID/X714/rfid.py,sha256=W-8-ADYv9oYE9PHDEynQhHCXyVecDRfplWRIxb3cqts,1974
-smartx_rfid/devices/RFID/X714/serial_protocol.py,sha256=eOGM5sK35SxXfS9KjB8JQzYhR1qs4H3vw3-n3oPOjQQ,3681
-smartx_rfid/devices/RFID/X714/tcp_protocol.py,sha256=GthynyN6YMl6R16nrAnlrDK61QnuZAOhYhPqycBCwJA,4804
-smartx_rfid/devices/RFID/X714/write_commands.py,sha256=gkfsQ--bijZWw0e1FP8Wb0qtFtexM4hP6HJz6y5hvOM,987
-smartx_rfid/devices/__init__.py,sha256=EVhtb-IBLpits8dr-I1ZYYuWHw9ddqiu-98myg-iyFg,251
-smartx_rfid/devices/generic/SERIAL/_main.py,sha256=BB4b6t6NI7tQDZH1ZAl-ZqSG8WH_HmGJIrIs5hIxpS8,8356
-smartx_rfid/devices/generic/TCP/_main.py,sha256=BzpIiCxamtauQCa7GCldNlG_fhSLJoSxDs2lhGEc31M,2318
-smartx_rfid/devices/generic/TCP/helpers.py,sha256=5ySy0Wv6D3q9AEV8kVLw1aMbe3kMDm4lFxP3KLIMMWM,1386
-smartx_rfid/schemas/tag.py,sha256=gq38yKPqPBPaF-wx_0_lnhttz0neM_bob94puv-5Z7Y,2285
-smartx_rfid/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-smartx_rfid/utils/event.py,sha256=7QOdiSfiMscoAaTq4U3E3asYGSVnolr9OD3FSYGh6bg,469
-smartx_rfid-0.4.0.dist-info/METADATA,sha256=OPKyl9QnD1r2um-C9pwMXuKsMxEji8qv7xItz5T8MsQ,2676
-smartx_rfid-0.4.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-smartx_rfid-0.4.0.dist-info/licenses/LICENSE,sha256=npGJO3HuHM3JdFNEXv1jRmP_wRYq9-ujkqJPmLxrtEw,1080
-smartx_rfid-0.4.0.dist-info/RECORD,,