smartx-rfid 1.0.0__tar.gz

smartx_rfid-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gabriel Henrique Pascon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smartx_rfid-1.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: smartx-rfid
+Version: 1.0.0
+Summary: SmartX RFID library
+License: MIT
+License-File: LICENSE
+Keywords: python,library,RFID,smartx,packaging
+Author: Gabriel Henrique Pascon
+Author-email: gh.pascon@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: bleak (>=1.1.1,<2.0.0)
+Requires-Dist: httpx (==0.28.1)
+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)
+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
+Description-Content-Type: text/markdown
+
+# SmartX RFID
+
+The official SmartX RFID Python library for seamless integration with RFID systems and devices.
+
+## Overview
+
+SmartX RFID is a comprehensive Python package designed to provide easy-to-use interfaces for RFID operations and device management. This library serves as the foundation for building robust RFID applications.
+
+## Features (Current & Planned)
+
+- **Device Communication**: Asynchronous serial communication with RFID devices
+- **Auto-Detection**: Automatic port detection for USB devices by VID/PID
+- **Connection Management**: Automatic reconnection and error handling
+- **External Device Support**: Interface with various RFID readers and writers *(coming soon)*
+- **Tag Operations**: Read, write, and manage RFID tags *(coming soon)*
+- **Protocol Support**: Multiple RFID protocols and standards *(coming soon)*
+
+## Installation
+
+```bash
+pip install smartx-rfid
+```
+
+## Quick Start
+
+```python
+from smartx_rfid.devices import SERIAL
+import asyncio
+
+async def main():
+    device = SERIAL(name="MyRFIDDevice")
+    await device.connect()
+
+asyncio.run(main())
+```
+
+## Development Status
+
+This library is actively under development. Current focus areas include:
+
+- Core device communication protocols
+- External device integration
+- Enhanced error handling
+- Comprehensive documentation
+
+## License
+
+MIT License
+
+## Support
+
+For issues and support, please visit our [GitHub repository](https://github.com/ghpascon/smartx_rfid).
+

smartx_rfid-1.0.0/README.md

@@ -0,0 +1,52 @@
+# SmartX RFID
+
+The official SmartX RFID Python library for seamless integration with RFID systems and devices.
+
+## Overview
+
+SmartX RFID is a comprehensive Python package designed to provide easy-to-use interfaces for RFID operations and device management. This library serves as the foundation for building robust RFID applications.
+
+## Features (Current & Planned)
+
+- **Device Communication**: Asynchronous serial communication with RFID devices
+- **Auto-Detection**: Automatic port detection for USB devices by VID/PID
+- **Connection Management**: Automatic reconnection and error handling
+- **External Device Support**: Interface with various RFID readers and writers *(coming soon)*
+- **Tag Operations**: Read, write, and manage RFID tags *(coming soon)*
+- **Protocol Support**: Multiple RFID protocols and standards *(coming soon)*
+
+## Installation
+
+```bash
+pip install smartx-rfid
+```
+
+## Quick Start
+
+```python
+from smartx_rfid.devices import SERIAL
+import asyncio
+
+async def main():
+    device = SERIAL(name="MyRFIDDevice")
+    await device.connect()
+
+asyncio.run(main())
+```
+
+## Development Status
+
+This library is actively under development. Current focus areas include:
+
+- Core device communication protocols
+- External device integration
+- Enhanced error handling
+- Comprehensive documentation
+
+## License
+
+MIT License
+
+## Support
+
+For issues and support, please visit our [GitHub repository](https://github.com/ghpascon/smartx_rfid).

smartx_rfid-1.0.0/pyproject.toml

@@ -0,0 +1,67 @@
+[tool.poetry]
+name = "smartx-rfid"
+version = "1.0.0"
+description = "SmartX RFID library"
+authors = ["Gabriel Henrique Pascon <gh.pascon@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/ghpascon/smartx_rfid"
+repository = "https://github.com/ghpascon/smartx_rfid"
+documentation = "https://github.com/ghpascon/smartx_rfid#readme"
+keywords = ["python", "library", "RFID", "smartx", "packaging"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+packages = [{include = "smartx_rfid", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pyserial-asyncio = "0.6"
+pyserial = "3.5"
+pyepc = "0.5.0"
+httpx = "0.28.1"
+bleak = "^1.1.1"
+pydantic = "^2.12.5"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0"
+pytest-asyncio = "^0.21.0"
+twine = "^4.0.0"
+ruff = "^0.14.11"
+
+[tool.poetry.group.build.dependencies]
+build = "^1.0.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+exclude = ["build", "dist", ".venv", "__pycache__"]  # pastas a ignorar
+
+# Por arquivo
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]  # permite imports não usados em __init__.py para re-exportações
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "--strict-markers",
+    "--strict-config",
+    "--verbose",
+]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "integration: marks tests as integration tests",
+    "asyncio: marks tests as asyncio tests",
+]

smartx_rfid-1.0.0/src/smartx_rfid/__init__.py

@@ -0,0 +1,9 @@
+"""publish_lib_ghp - A simple Python library demonstrating how to publish packages to PyPI."""
+
+from importlib.metadata import version
+
+try:
+    __version__ = version("publish-lib-example")
+except Exception:
+    # Fallback for development environments
+    __version__ = "0.0.0-dev"

smartx_rfid-1.0.0/src/smartx_rfid/devices/RFID/R700_IOT/_main.py

@@ -0,0 +1,202 @@
+import asyncio
+import logging
+
+import httpx
+
+from smartx_rfid.schemas.tag import WriteTagValidator
+from smartx_rfid.utils.event import on_event
+
+from .on_event import OnEvent
+from .reader_helpers import ReaderHelpers
+from .write_commands import WriteCommands
+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
+        reading_config: dict,
+        name: str = "R700",
+        # CONNECTION
+        ip: str = "192.168.1.101",  # Example hotsname: impinj-14-46-36
+        username: str = "root",
+        password: str = "impinj",
+        start_reading: bool = False,
+        # 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"
+
+        self.ip = ip
+        self.username = username
+        self.password = password
+
+        self.start_reading = start_reading
+
+        # URL AND ENDPOINTS
+        self.urlBase = f"https://{self.ip}/api/v1"
+        self.endpoint_interface = f"{self.urlBase}/system/rfid/interface"
+        self.check_version_endpoint = f"{self.urlBase}/system/image"
+        self.endpoint_start = f"{self.urlBase}/profiles/inventory/start"
+        self.endpoint_stop = f"{self.urlBase}/profiles/stop"
+        self.endpointDataStream = f"{self.urlBase}/data/stream"
+        self.endpoint_gpo = f"{self.urlBase}/device/gpos"
+        self.endpoint_write = f"{self.urlBase}/profiles/inventory/tag-access"
+
+        self.interface_config = {"rfidInterface": "rest"}
+        self.auth = httpx.BasicAuth(self.username, self.password)
+
+        self.tags_to_write = {}
+
+        self.is_connected = False
+        self.is_reading = False
+        self._stop_connection = False
+
+        self.firmware_version = firmware_version
+
+        self.reading_config = reading_config
+        self.config_example = R700_IOT_config_example
+
+        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
+
+        if self.is_reading:
+            try:
+                async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=5.0) as session:
+                    await self.stop_inventory(session)
+            except Exception as e:
+                logging.warning(f"{self.name} ⚠️ Error stopping inventory during disconnect: {e}")
+
+        self.is_connected = False
+        self.is_reading = False
+        self.on_event(self.name, "reading", False)
+        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:
+                if self.is_connected:
+                    self.on_event(self.name, "connection", False)
+
+                self.is_connected = False
+                self.is_reading = False
+
+                # Configure interface
+                success = await self.configure_interface(session)
+                if not success:
+                    logging.warning(f"{self.name} - Failed to configure interface")
+                    await asyncio.sleep(1)
+                    continue
+
+                # Check firmware version
+                success = await self.check_firmware_version(session)
+                if not success:
+                    logging.warning(
+                        f"{self.name} - Incompatible firmware version. Update R700 firmware to {self.firmware_version}."
+                    )
+                    await asyncio.sleep(5)
+                    continue
+
+                # Stop any ongoing profiles
+                success = await self.stop_inventory(session)
+                if not success:
+                    logging.warning(f"{self.name} - Failed to stop profiles")
+                    await asyncio.sleep(1)
+                    continue
+
+                if self.start_reading or self.reading_config.get("startTriggers"):
+                    success = await self.start_inventory(session)
+                    if not success:
+                        logging.warning(f"{self.name} - Failed to start inventory")
+                        await asyncio.sleep(1)
+                        continue
+                if self.start_reading:
+                    self.is_reading = True
+                    self.on_event(self.name, "reading", True)
+
+                # Clear GPO states
+                for i in range(1, 4):
+                    asyncio.create_task(self.write_gpo(pin=i, state=False))
+
+                self.is_connected = True
+                self.on_event(self.name, "connection", True)
+                await self.get_tag_list(session)
+
+    async def clear_tags(self):
+        """Clear all stored tags from memory."""
+        self.tags = {}
+
+    async def write_gpo(
+        self,
+        pin: int = 1,
+        state: bool | str = True,
+        control: str = "static",
+        time: int = 1000,
+        *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:
+                await self.post_to_reader(session, self.endpoint_gpo, payload=gpo_command, method="put")
+        except Exception as e:
+            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.
+        """
+        try:
+            validated_tag = WriteTagValidator(
+                target_identifier=target_identifier,
+                target_value=target_value,
+                new_epc=new_epc,
+                password=password,
+            )
+            logging.info(
+                f"{self.name} - Writing EPC: {validated_tag.new_epc} (Current: {validated_tag.target_identifier}={validated_tag.target_value})"
+            )
+            asyncio.create_task(self.send_write_command(validated_tag.model_dump()))
+        except Exception as e:
+            logging.warning(f"{self.name} - Write validation error: {e}")

smartx_rfid-1.0.0/src/smartx_rfid/devices/RFID/R700_IOT/on_event.py

@@ -0,0 +1,26 @@
+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"),
+            "ant": tag.get("antennaPort"),
+            "rssi": int(tag.get("peakRssiCdbm", 0) / 100),
+        }
+        self.on_event(self.name, "tag", current_tag)

smartx_rfid-1.0.0/src/smartx_rfid/devices/RFID/R700_IOT/reader_config_example.py

@@ -0,0 +1,69 @@
+R700_IOT_config_example = {
+    "antennaConfigs": [
+        {
+            "antennaPort": 1,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+        {
+            "antennaPort": 2,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+        {
+            "antennaPort": 3,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+        {
+            "antennaPort": 4,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+    ],
+    "startTriggers": [{"gpiTransitionEvent": {"gpi": 1, "transition": "high-to-low"}}],
+    "stopTriggers": [{"gpiTransitionEvent": {"gpi": 1, "transition": "low-to-high"}}],
+    "eventConfig": {
+        "common": {"hostname": "disabled"},
+        "tagInventory": {
+            "epc": "disabled",
+            "epcHex": "enabled",
+            "xpcHex": "disabled",
+            "tid": "disabled",
+            "tidHex": "enabled",
+            "antennaPort": "enabled",
+            "transmitPowerCdbm": "disabled",
+            "peakRssiCdbm": "enabled",
+            "frequency": "disabled",
+            "pc": "disabled",
+            "lastSeenTime": "disabled",
+            "phaseAngle": "disabled",
+            "tagReporting": {
+                "reportingIntervalSeconds": 1,
+                "tagCacheSize": 2048,
+                "antennaIdentifier": "antennaPort",
+                "tagIdentifier": "epc",
+            },
+        },
+    },
+}

smartx_rfid-1.0.0/src/smartx_rfid/devices/RFID/R700_IOT/reader_helpers.py

@@ -0,0 +1,146 @@
+import asyncio
+import json
+import logging
+
+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:
+            if session is None:
+                async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=5.0) as client:
+                    response = await client.get(endpoint)
+            else:
+                response = await session.get(endpoint)
+
+            if response.status_code != 200:
+                logging.warning(f"{self.name} - Failed to get firmware version: {response.status_code}")
+                return False
+
+            version_info = response.json()
+            firmware_version = version_info.get("primaryFirmware", "Unknown")
+            return firmware_version.startswith(self.firmware_version)
+
+        except Exception as e:
+            logging.warning(f"{self.name} - Error GET {endpoint}: {e}")
+            return False
+
+    async def configure_interface(self, session):
+        return await self.post_to_reader(
+            session,
+            self.endpoint_interface,
+            payload=self.interface_config,
+            method="put",
+        )
+
+    async def stop_inventory(self, session=None):
+        return await self.post_to_reader(session, self.endpoint_stop)
+
+    async def start_inventory(self, session=None):
+        return await self.post_to_reader(session, self.endpoint_start, payload=self.reading_config)
+
+    async def post_to_reader(self, session, endpoint, payload=None, method="post", timeout=3):
+        try:
+            if session is None:
+                async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=timeout) as client:
+                    return await self.post_to_reader(client, endpoint, payload, method, timeout)
+
+            if method == "post":
+                response = await session.post(endpoint, json=payload, timeout=timeout)
+                if response.status_code != 204:
+                    logging.warning(f"{self.name} - POST {endpoint} failed: {response.status_code}")
+
+            elif method == "put":
+                response = await session.put(endpoint, json=payload, timeout=timeout)
+                if response.status_code != 204:
+                    logging.warning(f"{self.name} - PUT {endpoint} failed: {response.status_code}")
+
+            return response.status_code == 204
+
+        except Exception as e:
+            logging.warning(f"{self.name} - Error posting to {endpoint}: {e}")
+            return False
+
+    async def get_tag_list(self, session):
+        try:
+            async with session.stream("GET", self.endpointDataStream, timeout=None) as response:
+                if response.status_code != 200:
+                    logging.warning(f"{self.name} - Failed to connect to data stream: {response.status_code}")
+                    return
+
+                logging.info(f"{self.name} - Connected to data stream.")
+
+                async for line in response.aiter_lines():
+                    try:
+                        string = line.strip()
+                        if not string:
+                            continue
+                        jsonEvent = json.loads(string)
+
+                        if "inventoryStatusEvent" in jsonEvent:
+                            status = jsonEvent["inventoryStatusEvent"]["inventoryStatus"]
+                            if status == "running":
+                                asyncio.create_task(self.on_start())
+                            else:
+                                asyncio.create_task(self.on_stop())
+                        elif "tagInventoryEvent" in jsonEvent:
+                            tagEvent = jsonEvent["tagInventoryEvent"]
+                            asyncio.create_task(self.on_tag(tagEvent))
+
+                    except (json.JSONDecodeError, UnicodeDecodeError) as parse_error:
+                        logging.warning(f"{self.name} - Failed to parse event: {parse_error}")
+        except Exception as e:
+            logging.warning(f"{self.name} - Unexpected error: {e}")
+
+    async def get_gpo_command(
+        self, pin: int = 1, state: bool | str = True, control: str = "static", time: int = 1000
+    ) -> dict:
+        """
+        Gera o payload de configuração de GPO para o leitor RFID.
+
+        Args:
+            pin (int): Número do pino GPO a ser configurado. Default é 1.
+            state (bool | str): Estado do pino. Pode ser:
+                - True ou "high" → alto
+                - False ou "low" → baixo
+            control ("static" | "pulsed"): Tipo de controle do pino.
+                - "static": mantém o estado
+                - "pulsed": envia pulso por tempo definido
+            time (int): Duração do pulso em milissegundos. Apenas usado se control="pulsed". Default 1000ms.
+
+        Returns:
+            dict: Payload compatível com a API do leitor RFID para configurar GPO.
+
+        Example:
+            gpo_cmd = await self.get_gpo_command(pin=2, state=True, control="pulsed", time=500)
+        """
+        # Normaliza o estado
+        state = "high" if state is True else "low" if state is False else str(state)
+
+        if control == "static":
+            gpo_command = {"gpoConfigurations": [{"gpo": pin, "state": state, "control": control}]}
+        elif control == "pulsed":
+            gpo_command = {
+                "gpoConfigurations": [
+                    {
+                        "gpo": pin,
+                        "state": state,
+                        "pulseDurationMilliseconds": time,
+                        "control": control,
+                    }
+                ]
+            }
+        return gpo_command