easyhttp-python 0.3.2__py3-none-any.whl

easyhttp/__init__.py

@@ -0,0 +1,9 @@
+from .core import EasyHTTPAsync
+from .wrapper import EasyHTTP
+
+__version__ = "0.3.2"
+__author__ = "slpuk"
+__all__ = [
+    "EasyHTTPAsync",
+    "EasyHTTP"
+]

easyhttp/core.py

@@ -0,0 +1,517 @@
+"""EasyHTTP - Simple HTTP-based P2P framework for IoT."""
+
+import os
+import secrets
+import time
+import logging
+import json
+from pathlib import Path
+from enum import Enum, auto
+from typing import Optional, Union, Dict, Any, Callable
+
+# API libraries
+import aiohttp
+import asyncio
+import socket
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+__version__ = "0.3.2"
+
+class EasyHTTPAsync:
+    """Simple asynchronous HTTP-based core of P2P framework for IoT."""
+    
+    class commands(Enum):
+        """Enumeration of available command types."""
+
+        PING = auto()   # Ping another device
+        PONG = auto()   # Anwser for PING
+        FETCH = auto()  # Request data from another device
+        DATA = auto()   # Response containing data
+        PUSH = auto()   # Send data to another device
+        ACK = auto()    # Acknowledge successful command
+        NACK = auto()   # Indicate an error occurred
+
+    def __init__(self, debug: bool = False, port: int = 5000, config_file=None):
+        """Initialize the EasyHTTPAsync instance.
+
+        Args:
+            debug: Enable debug output. Defaults to False.
+            port: Port to run the HTTP server on. Defaults to 5000.
+        """
+
+        self.debug = debug
+        self.port = port
+
+        if config_file:
+            self.config_file = config_file
+        else:
+            import sys
+            if getattr(sys, 'frozen', False):
+                base_dir = os.path.dirname(sys.executable)
+            else:
+                base_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+            self.config_file = os.path.join(base_dir, "easyhttp_device.json")
+
+        self.id = None
+        self.callbacks = {
+            'on_ping': None,
+            'on_pong': None,
+            'on_fetch': None,
+            'on_data': None,
+            'on_push': None
+        }
+        self.devices = {}
+        self.app = FastAPI(title="EasyHTTP API", docs_url=None, redoc_url=None)
+        self.app.post('/easyhttp/api')(self.api_handler)
+        self.server_task = None
+        self._load_config()
+
+    async def __aenter__(self):
+        """Enter the async context manager."""
+        await self.start()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit the async context manager."""
+        await self.stop()
+
+    def _load_config(self):
+        try:
+            if os.path.exists(self.config_file):
+                with open(self.config_file, 'r') as f:
+                    data = json.load(f)
+                    self.id = data.get('device_id')
+                    
+                if self.debug and self.id:
+                    print(f"\033[32mINFO\033[0m:\t Loaded ID: {self.id} from {self.config_file}")
+        except Exception as e:
+            if self.debug:
+                print(f"\033[31mERROR\033[0m:\t Error loading config: {e}")
+    
+    def _save_config(self):
+        try:
+            config = {
+                'device_id': self.id,
+                'port': self.port,
+                'version': __version__
+            }
+            
+            with open(self.config_file, 'w') as f:
+                json.dump(config, f, indent=2)
+            
+            if self.debug:
+                print(f"\033[32mINFO\033[0m:\t Saved ID to {self.config_file}")
+        except Exception as e:
+            if self.debug:
+                print(f"\033[31mERROR\033[0m:\t Error saving config: {e}")
+
+    def _get_local_ip(self):
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            s.connect(('8.8.8.8', 80))
+            local_ip = s.getsockname()[0]
+            s.close()
+            return local_ip
+        except:
+            try:
+                return socket.gethostbyname(socket.gethostname())
+            except:
+                return "127.0.0.1"
+
+    def _generate_id(self, length: int = 6) -> str:
+        """Generate a unique device ID with a custom alphabet.
+
+        Args:
+            length: Length of the generated ID.
+
+        Returns:
+            The generated unique ID.
+        """
+
+        alphabet = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"
+        self.id = ''.join(secrets.choice(alphabet) for _ in range(length))
+        self._save_config()
+
+    def on(self, event: str, callback_func: Callable) -> None:
+        """Register a callback function for a specific event.
+
+        Args:
+            event: Event name ('on_ping', 'on_fetch', etc.).
+            callback_func: Function to call when the event occurs.
+
+        Raises:
+            ValueError: If the event is unknown.
+        """
+
+        if event in self.callbacks:
+            self.callbacks[event] = callback_func
+        else:
+            raise ValueError(f"Unknown event: {event}")
+
+    def add(self, device_id: str, device_ip: str, device_port: int) -> None:
+        """Manually add a device to the local devices cache.
+
+        Args:
+            device_id: 6-character device identifier.
+            device_ip: IP address of the device.
+            device_port: Port number of the device.
+
+        Raises:
+            ValueError: If device_id is not 6 characters.
+        """
+
+        if len(device_id) != 6:
+            raise ValueError("Device ID must be 6 characters")
+    
+        if device_id not in self.devices:
+            self.devices[device_id] = {
+                'ip': device_ip,
+                'port': int(device_port),
+                'last_seen': time.time(),
+                'added_manually': True
+            }
+            if self.debug:
+                print(f"DEBUG:\t Added device {device_id}: {device_ip}:{device_port}")
+        else:
+            print(f"DEBUG:\t Device already exists")
+
+    async def start(self) -> None:
+        """Start the HTTP server and generate a device ID if not set."""
+
+        if not self.id:
+            self._generate_id()
+
+        try:
+            config = uvicorn.Config(
+                self.app, 
+                host="0.0.0.0", 
+                port=self.port,
+                log_level="warning",
+                lifespan="off"
+            )
+            
+            server = uvicorn.Server(config)
+            self.server_task = asyncio.create_task(server.serve())
+
+            logging.getLogger('werkzeug').disabled = True
+            logging.getLogger('uvicorn.error').propagate = False
+            logging.getLogger('uvicorn.access').propagate = False
+
+            await asyncio.sleep(2)  # Give server time to start
+
+            if self.debug:
+                print(f"\033[32mINFO\033[0m:\t \033[1;32mEasyHTTP \033[37m{__version__}\033[0m has been started!")
+                print(f"\033[32mINFO\033[0m:\t Device's ID: {self.id}")
+                print(f"\033[32mINFO\033[0m:\t EasyHTTP starting on port {self.port}")
+                print(f"\033[32mINFO\033[0m:\t API running on \033[1mhttp://{self._get_local_ip()}:{self.port}/easyhttp/api\033[0m")
+            
+        except Exception as e:
+            print(f"\033[31mERROR\033[0m:\t Failed to start server: {e}")
+            raise
+
+    async def stop(self) -> None:
+        """Gracefully stop the HTTP server and cancel the server task."""
+
+        if self.server_task:
+            self.server_task.cancel()
+            try:
+                await self.server_task
+            except asyncio.CancelledError:
+                pass
+
+    async def send(self, device_id: str, command_type: Union[int, 'commands'], data: Optional[Any] = None) -> Optional[dict]:
+        """Send a JSON-formatted command to another device.
+
+        Args:
+            device_id: ID of the target device (must be 6 characters).
+            command_type: Command type (commands enum member) or its integer value.
+            data: JSON-serializable data to send (dict, list, str, or None).
+
+        Returns:
+            Response JSON dict if successful, None otherwise.
+            Response typically contains 'type', 'header', and optionally 'data' fields.
+
+        Note:
+            The device must be added to the devices cache before sending.
+        """
+
+        if device_id not in self.devices:
+            if self.debug:
+                print(f"\033[31mERROR\033[0m:\t Device {device_id} not found in devices cache")
+            return None
+    
+        packet = {
+            "version": __version__,
+            "type": command_type if isinstance(command_type, self.commands) else command_type,
+            "header": {
+                "sender_id": self.id, 
+                "sender_port": self.port,
+                "recipient_id": device_id, 
+                "timestamp": int(time.time())
+            }
+        }
+    
+        if data:
+            packet['data'] = data
+    
+        recipient_url = f"http://{self.devices[device_id]['ip']}:{self.devices[device_id]['port']}/easyhttp/api"
+    
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(recipient_url, json=packet, timeout=3) as response:
+                    if response.status == 200:
+                        return await response.json()
+                    return None
+            
+        except Exception as e:
+            if self.debug:
+                print(f'\033[31mERROR\033[0m:\t Failed to send to {device_id}: {e}')
+            return None
+
+    async def ping(self, device_id: str) -> bool:
+        """Send a PING request to a device and check if it's online.
+
+        Args:
+            device_id: ID of the device to ping.
+
+        Returns:
+            True if device responded with PONG, False otherwise.
+        """
+
+        response = await self.send(device_id, self.commands.PING.value)
+    
+        if response and response.get('type') == self.commands.PONG.value:
+            if self.debug:
+                print(f"\033[32mPING\033[0m:\t {device_id} is online")
+            if device_id in self.devices:
+                self.devices[device_id]['last_seen'] = time.time()
+            return True
+        else:
+            if self.debug:
+                print(f"\033[31mPING\033[0m:\t {device_id} is offline or not responding")
+            return False
+
+    async def fetch(self, device_id: str, query: Optional[Any] = None) -> Optional[dict]:
+        """Send a FETCH request to another device and return the response.
+
+        Args:
+            device_id: ID of the target device.
+            query: Query data to send with the FETCH request.
+
+        Returns: 
+            Response data from the device, or None if failed.
+            The dict typically contains 'type', 'header', and 'data' fields.
+        """
+
+        response = await self.send(device_id, self.commands.FETCH.value, query)
+        return response
+
+    async def push(self, device_id: str, data: Optional[Any] = None) -> bool:
+        """Send data to another device using PUSH command.
+
+        Args:
+            device_id: ID of the target device.
+            data: JSON-serializable data to send.
+
+        Returns:
+            True if data was successfully sent and acknowledged, False otherwise.
+
+        Raises:
+            TypeError: If data is not JSON-serializable.
+        """
+
+        if data is not None and not isinstance(data, (dict, list, str)):
+            raise TypeError("Data must be JSON-serializable (dict, list, str)")
+        
+        response = await self.send(device_id, self.commands.PUSH, data)
+
+        if response and response.get('type') == self.commands.ACK.value:
+            if self.debug:
+                print(f"\033[32mPUSH\033[0m:\t Successfully wrote to {device_id}")
+            return True
+        else:
+            if self.debug:
+                print(f"\033[31mPUSH\033[0m:\t Error writing to {device_id}")
+            return False
+
+    async def api_handler(self, request: Request) -> JSONResponse:
+        """Handle incoming API requests and route commands to callbacks.
+
+        Args:
+            request: FastAPI request object.
+
+        Returns:
+            JSONResponse: Response to the client.
+        """
+        
+        try:
+            data = await request.json()
+        except:
+            return JSONResponse({"error": "Invalid JSON data"}, status_code=400)
+            
+        if not data:
+            return JSONResponse({"error": "No JSON data"}, status_code=400)
+            
+        command_type = data.get('type')
+        header = data.get('header', {})
+        sender_id = header.get('sender_id')
+        
+        client_ip = request.client.host if request.client else "0.0.0.0"
+
+        if sender_id and sender_id != self.id and sender_id not in self.devices:
+            self.devices[sender_id] = {
+                'ip': client_ip,
+                'port': header.get('sender_port', self.port),
+                'last_seen': int(time.time())
+            }
+
+        # Handle PING response
+        if command_type == self.commands.PING.value:
+            if self.callbacks['on_ping']:
+                callback = self.callbacks['on_ping']
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(
+                        sender_id=sender_id,
+                        timestamp=header.get('timestamp')
+                    )
+                else:
+                    callback(
+                        sender_id=sender_id,
+                        timestamp=header.get('timestamp')
+                    )
+                
+            return JSONResponse({
+                "version": __version__,
+                "type": self.commands.PONG.value,
+                "header": {
+                    "sender_id": self.id,
+                    "sender_port": self.port,
+                    "recipient_id": sender_id,
+                    "timestamp": int(time.time())
+                }
+            })
+
+        # Handle PONG answer
+        elif command_type == self.commands.PONG.value:
+            if self.callbacks['on_pong']:
+                callback = self.callbacks['on_pong']
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(
+                        sender_id=sender_id,
+                        timestamp=header.get('timestamp')
+                    )
+                else:
+                    callback(
+                        sender_id=sender_id,
+                        timestamp=header.get('timestamp')
+                    )
+
+            if self.debug:
+                print(f"\033[32mPONG\033[0m:\t Received from {sender_id}")
+            if sender_id in self.devices:
+                self.devices[sender_id]['last_seen'] = time.time()
+            return JSONResponse({"status": "pong_received"})
+
+        # Handle FETCH response
+        elif command_type == self.commands.FETCH.value:
+            if self.callbacks['on_fetch']:
+                callback = self.callbacks['on_fetch']
+                if asyncio.iscoroutinefunction(callback):
+                    response_data = await callback (
+                        sender_id=sender_id,
+                        query=data.get('data'),
+                        timestamp=header.get('timestamp')
+                    )
+                else:
+                    response_data = callback (
+                        sender_id=sender_id,
+                        query=data.get('data'),
+                        timestamp=header.get('timestamp')
+                    )
+                if response_data:
+                    return JSONResponse({
+                        "version": __version__,
+                        "type": self.commands.DATA.value,
+                        "header": {
+                            "sender_id": self.id,
+                            "sender_port": self.port,
+                            "recipient_id": sender_id,
+                            "timestamp": int(time.time())
+                        },
+                        "data": response_data
+                    })
+            return JSONResponse({"status": "fetch_handled"})
+
+        # Handle PUSH response
+        elif command_type == self.commands.PUSH.value:
+            if not self.callbacks['on_push']:
+                return JSONResponse({
+                    "version": __version__,
+                    "type": self.commands.NACK.value,
+                    "header": {
+                        "sender_id": self.id,
+                        "sender_port": self.port,
+                        "recipient_id": sender_id,
+                        "timestamp": int(time.time())
+                    },
+                }, status_code=400)
+
+            callback = self.callbacks['on_push']
+            if asyncio.iscoroutinefunction(callback):
+                success = await callback(
+                    sender_id=sender_id,
+                    data=data.get('data'),
+                    timestamp=header.get('timestamp')
+                )
+            else:
+                success = callback(
+                    sender_id=sender_id,
+                    data=data.get('data'),
+                    timestamp=header.get('timestamp')
+                )
+            
+            if success:
+                return JSONResponse({
+                    "version": __version__,
+                    "type": self.commands.ACK.value,
+                    "header": {
+                        "sender_id": self.id,
+                        "sender_port": self.port,
+                        "recipient_id": sender_id,
+                        "timestamp": int(time.time())
+                    }
+                })
+            else:
+                return JSONResponse({
+                    "version": __version__,
+                    "type": self.commands.NACK.value,
+                    "header": {
+                        "sender_id": self.id,
+                        "sender_port": self.port,
+                        "recipient_id": sender_id,
+                        "timestamp": int(time.time())
+                    }
+                })
+
+        # Handle DATA
+        elif command_type == self.commands.DATA.value:
+            if self.callbacks['on_data']:
+                callback = self.callbacks['on_data']
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(
+                        sender_id=sender_id,
+                        data=data.get('data'),
+                        timestamp=header.get('timestamp')
+                    )
+                else:
+                    callback(
+                        sender_id=sender_id,
+                        data=data.get('data'),
+                        timestamp=header.get('timestamp')
+                    )
+            return JSONResponse({"status": "data_received"})
+        
+        # Handle unknown command types
+        return JSONResponse({"error": "Unknown command type"}, status_code=400)

easyhttp/wrapper.py

@@ -0,0 +1,153 @@
+"""EasyHTTP - Simple HTTP-based P2P framework for IoT."""
+
+import asyncio
+from typing import Optional, Any, Callable
+from .core import EasyHTTPAsync, __version__
+
+class EasyHTTP:
+    """Simple HTTP-based P2P framework with asynchronous core for IoT."""
+    
+    def __init__(self, debug: bool = False, port: int = 5000, config_file: Optional[str] = None):
+        """Initialize the EasyHTTP instance.
+
+        Args:
+            debug: Enable debug output. Defaults to False.
+            port: Port to run the HTTP server on. Defaults to 5000.
+        """
+
+        self._core = EasyHTTPAsync(debug=debug, port=port, config_file=config_file)
+        self._loop = None
+        self._running = False
+        
+        self.commands = self._core.commands
+        self.__version__ = __version__
+        
+    def _ensure_loop(self):
+        """Ensure event loop is running."""
+        if not self._loop:
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+    
+    def on(self, event: str, callback_func: Callable) -> None:
+        """Register a callback function for a specific event.
+
+        Args:
+            event: Event name ('on_ping', 'on_fetch', etc.).
+            callback_func: Function to call when the event occurs.
+
+        Raises:
+            ValueError: If the event is unknown.
+        """
+        self._core.on(event, callback_func)
+    
+    def add(self, device_id: str, device_ip: str, device_port: int) -> None:
+        """Manually add a device to the local devices cache.
+
+        Args:
+            device_id: 6-character device identifier.
+            device_ip: IP address of the device.
+            device_port: Port number of the device.
+
+        Raises:
+            ValueError: If device_id is not 6 characters.
+        """
+        self._core.add(device_id, device_ip, device_port)
+
+    def start(self) -> None:
+        """Start the HTTP server and generate a device ID if not set."""
+        self._ensure_loop()
+        self._loop.run_until_complete(self._core.start())
+        self._running = True
+        
+    def stop(self) -> None:
+        """Gracefully stop the HTTP server and cancel the server task."""
+        if self._running:
+            self._loop.run_until_complete(self._core.stop())
+            self._running = False
+    
+    def send(self, device_id: str, command_type: Any, data: Optional[Any] = None) -> Optional[dict]:
+        """Send a JSON-formatted command to another device.
+
+        Args:
+            device_id: ID of the target device (must be 6 characters).
+            command_type: Command type (commands enum member) or its integer value.
+            data: JSON-serializable data to send (dict, list, str, or None).
+
+        Returns:
+            Response JSON dict if successful, None otherwise.
+            Response typically contains 'type', 'header', and optionally 'data' fields.
+
+        Note:
+            The device must be added to the devices cache before sending.
+        """
+        if not self._loop:
+            self._ensure_loop()
+        return self._loop.run_until_complete(
+            self._core.send(device_id, command_type, data)
+        )
+    
+    def ping(self, device_id: str) -> bool:
+        """Send a PING request to a device and check if it's online.
+
+        Args:
+            device_id: ID of the device to ping.
+
+        Returns:
+            True if device responded with PONG, False otherwise.
+        """
+        return self._loop.run_until_complete(
+            self._core.ping(device_id)
+        )
+    
+    def fetch(self, device_id: str, query: Optional[Any] = None) -> Optional[dict]:
+        """Send a FETCH request to another device and return the response.
+
+        Args:
+            device_id: ID of the target device.
+            query: Query data to send with the FETCH request.
+
+        Returns: 
+            Response data from the device, or None if failed.
+            The dict typically contains 'type', 'header', and 'data' fields.
+        """
+        return self._loop.run_until_complete(
+            self._core.fetch(device_id, query)
+        )
+    
+    def push(self, device_id: str, data: Optional[Any] = None) -> bool:
+        """Send data to another device using PUSH command.
+
+        Args:
+            device_id: ID of the target device.
+            data: JSON-serializable data to send.
+
+        Returns:
+            True if data was successfully sent and acknowledged, False otherwise.
+
+        Raises:
+            TypeError: If data is not JSON-serializable.
+        """
+        return self._loop.run_until_complete(
+            self._core.push(device_id, data)
+        )
+
+    # Context manager support
+    def __enter__(self):
+        """Enter the sync context manager."""
+        self.start()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the sync context manager."""
+        self.stop()
+    
+    # Property accessors
+    @property
+    def id(self) -> str:
+        """Get device ID."""
+        return self._core.id
+    
+    @property
+    def devices(self) -> dict:
+        """Get devices cache."""
+        return self._core.devices

easyhttp_python-0.3.2.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: easyhttp-python
+Version: 0.3.2
+Summary: Simple HTTP-based P2P framework for IoT
+Author-email: slpuk <yarik6052@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/slpuk/easyhttp-python
+Project-URL: Documentation, https://github.com/slpuk/easyhttp-python#readme
+Project-URL: Repository, https://github.com/slpuk/easyhttp-python
+Project-URL: Issue Tracker, https://github.com/slpuk/easyhttp-python/issues
+Keywords: iot,p2p,http,framework
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Communications
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.103.2
+Requires-Dist: uvicorn[standard]>=0.22.0
+Requires-Dist: aiohttp>=3.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: license-file
+
+# EasyHTTP
+
+[![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/slpuk/easyhttp-python)
+![Protocol Version](https://img.shields.io/badge/version-0.3.2-blue?style=for-the-badge)
+![Development Status](https://img.shields.io/badge/status-beta-orange?style=for-the-badge)
+![License](https://img.shields.io/badge/license-MIT-green?style=for-the-badge)
+![Python](https://img.shields.io/badge/python-3.7+-blue?style=for-the-badge&logo=python&logoColor=white)
+
+> **A lightweight HTTP-based P2P framework for IoT and device-to-device communication**
+
+## 🛠️ Changelog
+- Added context managers support
+- Fixed some bugs
+
+## 📖 About
+
+**EasyHTTP** is a simple yet powerful framework with asynchronous core that enables P2P (peer-to-peer) communication between devices using plain HTTP.
+
+### Key Features:
+- **🔄 P2P Architecture** - No central server required
+- **🧩 Dual API:** `EasyHTTP` (synchronous) and `EasyHTTPAsync` (asynchronous) with the same methods
+- **📡 Event-Driven Communication** - Callback-based architecture
+- **🆔 Human-Readable Device IDs** - Base32 identifiers instead of IP addresses
+- **✅ Easy to Use** - Simple API with minimal setup
+- **🚀 Performance** - Asynchronous code and lightweight libraries(FastAPI/aiohttp)
+
+
+## 🏗️ Architecture
+
+### Device Identification
+Instead of using hard-to-remember IP addresses, each device in the EasyHTTP network has a unique 6-character identifier:
+
+- **Format**: 6 characters from Base32 alphabet (without ambiguous characters)
+- **Alphabet**: `23456789ABCDEFGHJKLMNPQRSTUVWXYZ`
+- **Examples**: `7H8G2K`, `AB3F9Z`, `X4R7T2`
+- **Generation**: Randomly generated on first boot, stored in device configuration
+
+### Command System
+EasyHTTP uses a simple JSON-based command system:
+
+| Command | Value | Description |
+|---------|-------|-------------|
+| `PING` | 1 | Check if another device is reachable |
+| `PONG` | 2 | Response to ping request |
+| `FETCH` | 3 | Request data from a device |
+| `DATA` | 4 | Send data or answer to FETCH |
+| `PUSH` | 5 | Request to write/execute on remote device |
+| `ACK` | 6 | Success/confirmation |
+| `NACK` | 7 | Error/reject |
+
+### Basic Example with Callbacks (synchronous)
+```python
+import time
+from easyhttp import EasyHTTP
+
+# Callback function
+def handle_data(sender_id, data, timestamp):
+    # Callback for incoming DATA responses
+    print(f"From {sender_id}: {data}")
+
+def handle_fetch(sender_id, query, timestamp):
+    # Callback for FETCH requests - returns data when someone requests it
+    print(f"FETCH request from {sender_id}")
+    return {
+        "temperature": 23.5,
+        "humidity": 45,
+        "status": "normal",
+        "timestamp": timestamp
+    }
+
+def handle_push(sender_id, data, timestamp):
+    # Callback for PUSH requests - handle control commands
+    print(f"Control from {sender_id}: {data}")
+    if data and data.get("command") == "led":
+        state = data.get("state", "off")
+        print(f"[CONTROL] Turning LED {state}")
+        # Here you can add real GPIO control
+        return True  # Successful → ACK
+    return False  # Error → NACK
+
+def main():
+    # Initializing EasyHTTP - sync wrapper of EasyHTTPAsync
+    easy = EasyHTTP(debug=True, port=5000)
+    
+    # Setting up callback functions
+    easy.on('on_ping', handle_ping)
+    easy.on('on_pong', handle_pong)
+    easy.on('on_fetch', handle_fetch)
+    easy.on('on_data', handle_data)
+    easy.on('on_push', handle_push)
+    
+    easy.start()  # Starting server
+    print(f"Device {easy.id} is running on port 5000!")
+    
+    # Adding device
+    easy.add("ABC123", "192.168.1.100", 5000)
+    print("Added device ABC123")
+    
+    # Monitoring device's status
+    try:
+        while True:
+            if easy.ping("ABC123"):
+                print("Device ABC123 is online")
+            else:
+                print("Device ABC123 is offline")
+            
+            time.sleep(5)
+    
+    except KeyboardInterrupt:
+        print("\nStopping device...")
+        easy.stop()  # Stopping server
+
+# Starting main process
+if __name__ == "__main__":
+    main()
+```
+**More examples available on [GitHub](https://github.com/slpuk/easyhttp-python)**

easyhttp_python-0.3.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+easyhttp/__init__.py,sha256=1MUoeXjG1dWEDDM_i8BrrpNwFu4EF3tos16LY6VAytc,163
+easyhttp/core.py,sha256=Dr1mnn6C4qiOVmDtJMtjA4AxyFr4oIg6hWa7yrS0of8,19132
+easyhttp/wrapper.py,sha256=2rA7I5eJR_x31YWfUIxzssqlfzE2egihsmw7PVwg0a0,5281
+easyhttp_python-0.3.2.dist-info/licenses/LICENSE,sha256=nkDB7rjnRVh38AZftJtY1IEwTNYqzt9-1csUHIRZqGI,1083
+easyhttp_python-0.3.2.dist-info/METADATA,sha256=e205jFToQrxJvMbtbqRUr78LxO4ylTefViFPyrTgeuU,5804
+easyhttp_python-0.3.2.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+easyhttp_python-0.3.2.dist-info/top_level.txt,sha256=hXtOmZbZY_T3tJWgX_q2py0BhG48txcA16eH6ZawTqE,9
+easyhttp_python-0.3.2.dist-info/RECORD,,

easyhttp_python-0.3.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

easyhttp_python-0.3.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 slpuk
+
+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.

easyhttp_python-0.3.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+easyhttp