feory 0.1.0__tar.gz

feory-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: feory
+Version: 0.1.0
+Summary: Universal Python SDK for Feory Android App - Dynamic UI Builder & Bot Control Bridge
+Home-page: https://github.com/zizo0/feory
+Author: zizo0
+Author-email: zizo0 <zly30257@gmail.com>
+Project-URL: Homepage, https://github.com/zizo0/feory
+Project-URL: Bug Tracker, https://github.com/zizo0/feory/issues
+Keywords: feory,android,bot,ui-builder,automation,telegram,bridge
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Communications
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Feory Python SDK ⚡
+
+Universal Python SDK & Bridge for the **Feory Android App**.
+Create dynamic Bento-style Android UIs, manage bots, handle bi-directional events, and control servers remotely from your mobile device.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install feory
+```
+
+---
+
+## 🛠️ Quick Start
+
+```python
+import feory
+
+# 1. Initialize with your bot token from the Feory App
+client = feory.Client(
+    token="feory_tok_core_829a1b",
+    bot_name="My Awesome Python Bot",
+    port=8765
+)
+
+# 2. Register Dynamic UI Widgets
+client.register_button(
+    id="btn_start_scrape",
+    label="Start Data Pipeline",
+    category="general",
+    color_scheme="LILAC",
+    icon="play"
+)
+
+client.register_slider(
+    id="slider_threads",
+    label="Worker Threads",
+    min_value=1,
+    max_value=32,
+    default_value=8
+)
+
+client.register_metric_card(
+    id="stat_processed",
+    title="Items Processed",
+    value="12,450",
+    badge="+14% today",
+    accent_color="GREEN"
+)
+
+# 3. Handle Events from Feory Android App
+@client.on_action("btn_start_scrape")
+def handle_scrape(payload):
+    client.log("Starting scraping tasks...", "INFO")
+    # Your automation logic here
+    return {"status": "started", "items": 100}
+
+@client.on_value_change("slider_threads")
+def handle_thread_change(new_val):
+    client.log(f"Thread pool updated to: {new_val}", "INFO")
+
+# 4. Keep your bot server running
+if __name__ == "__main__":
+    client.run_forever()
+```
+
+---
+
+## 📖 Features
+
+- **Dynamic Android UI Generation**: Inject buttons, sliders, toggles, text inputs, dropdowns, and Bento metric cards on the fly without touching Kotlin code.
+- **Two-Way Event Bus**: Receive instant button clicks and slider callbacks directly in your Python functions.
+- **Real-Time Telemetry & Terminal Logs**: Stream live console logs directly to the Feory App terminal.
+- **Resource Lock & Collision Prevention**: Coordinate multiple bots accessing the same channels or resources with built-in Mutex locks.
+- **Zero-Dependency Core**: Uses Python standard library by default for maximum portability.
+
+---
+
+## 🔒 Authentication
+
+Every bot connects securely using its unique **Feory Token** (`feory_tok_...`). You can create, manage, and copy tokens directly inside the **Tokens** screen of the Feory Android App.
+
+---
+
+## 👤 Author
+
+Developed by **zizo0**  
+Email: `zly30257@gmail.com`

feory-0.1.0/README.md

@@ -0,0 +1,90 @@
+# Feory Python SDK ⚡
+
+Universal Python SDK & Bridge for the **Feory Android App**.
+Create dynamic Bento-style Android UIs, manage bots, handle bi-directional events, and control servers remotely from your mobile device.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install feory
+```
+
+---
+
+## 🛠️ Quick Start
+
+```python
+import feory
+
+# 1. Initialize with your bot token from the Feory App
+client = feory.Client(
+    token="feory_tok_core_829a1b",
+    bot_name="My Awesome Python Bot",
+    port=8765
+)
+
+# 2. Register Dynamic UI Widgets
+client.register_button(
+    id="btn_start_scrape",
+    label="Start Data Pipeline",
+    category="general",
+    color_scheme="LILAC",
+    icon="play"
+)
+
+client.register_slider(
+    id="slider_threads",
+    label="Worker Threads",
+    min_value=1,
+    max_value=32,
+    default_value=8
+)
+
+client.register_metric_card(
+    id="stat_processed",
+    title="Items Processed",
+    value="12,450",
+    badge="+14% today",
+    accent_color="GREEN"
+)
+
+# 3. Handle Events from Feory Android App
+@client.on_action("btn_start_scrape")
+def handle_scrape(payload):
+    client.log("Starting scraping tasks...", "INFO")
+    # Your automation logic here
+    return {"status": "started", "items": 100}
+
+@client.on_value_change("slider_threads")
+def handle_thread_change(new_val):
+    client.log(f"Thread pool updated to: {new_val}", "INFO")
+
+# 4. Keep your bot server running
+if __name__ == "__main__":
+    client.run_forever()
+```
+
+---
+
+## 📖 Features
+
+- **Dynamic Android UI Generation**: Inject buttons, sliders, toggles, text inputs, dropdowns, and Bento metric cards on the fly without touching Kotlin code.
+- **Two-Way Event Bus**: Receive instant button clicks and slider callbacks directly in your Python functions.
+- **Real-Time Telemetry & Terminal Logs**: Stream live console logs directly to the Feory App terminal.
+- **Resource Lock & Collision Prevention**: Coordinate multiple bots accessing the same channels or resources with built-in Mutex locks.
+- **Zero-Dependency Core**: Uses Python standard library by default for maximum portability.
+
+---
+
+## 🔒 Authentication
+
+Every bot connects securely using its unique **Feory Token** (`feory_tok_...`). You can create, manage, and copy tokens directly inside the **Tokens** screen of the Feory Android App.
+
+---
+
+## 👤 Author
+
+Developed by **zizo0**  
+Email: `zly30257@gmail.com`

feory-0.1.0/feory/__init__.py

@@ -0,0 +1,47 @@
+"""
+Feory Python SDK - Universal Bridge for Android Dynamic UI & Bot Control
+Author: zizo0
+"""
+
+from .client import Client, FeoryClient
+from .widgets import (
+    Widget,
+    ButtonWidget,
+    SliderWidget,
+    ToggleWidget,
+    TextFieldWidget,
+    MetricWidget,
+    DropdownWidget,
+    CategorySection,
+    WidgetType,
+)
+from .server import FeoryServer
+from .exceptions import (
+    FeoryError,
+    FeoryAuthError,
+    FeoryConnectionError,
+    FeoryLockError,
+    FeorySchemaError,
+)
+
+__version__ = "0.1.0"
+__author__ = "zizo0"
+__all__ = [
+    "Client",
+    "FeoryClient",
+    "Widget",
+    "ButtonWidget",
+    "SliderWidget",
+    "ToggleWidget",
+    "TextFieldWidget",
+    "MetricWidget",
+    "DropdownWidget",
+    "CategorySection",
+    "WidgetType",
+    "FeoryServer",
+    "FeoryError",
+    "FeoryAuthError",
+    "FeoryConnectionError",
+    "FeoryLockError",
+    "FeorySchemaError",
+]

feory-0.1.0/feory/client.py

@@ -0,0 +1,313 @@
+"""
+Feory Python SDK Client - Main Interface
+Author: zizo0
+"""
+
+import json
+import time
+from typing import Callable, Dict, Any, List, Optional, Union
+from .widgets import (
+    Widget,
+    ButtonWidget,
+    SliderWidget,
+    ToggleWidget,
+    TextFieldWidget,
+    MetricWidget,
+    DropdownWidget,
+    CategorySection,
+    WidgetType,
+)
+from .server import FeoryServer
+from .exceptions import FeoryAuthError, FeoryLockError, FeorySchemaError
+
+class Client:
+    """
+    Feory Universal Client.
+    Connects your Python bot or server to Feory Android App.
+    """
+    def __init__(
+        self,
+        token: str,
+        bot_name: str = "Universal Python Bot",
+        category: str = "Automation",
+        description: str = "Universal Python Bot instance running on local server",
+        host: str = "0.0.0.0",
+        port: int = 8765,
+        auto_start_server: bool = True,
+    ):
+        if not token:
+            raise FeoryAuthError("A valid token must be provided to initialize Feory Client.")
+
+        self.token = token
+        self.bot_name = bot_name
+        self.category = category
+        self.description = description
+        self.status = "ONLINE"
+        
+        self.categories: Dict[str, CategorySection] = {
+            "general": CategorySection(id="general", title="التحكم العام", icon="tune"),
+            "metrics": CategorySection(id="metrics", title="الإحصائيات والأداء", icon="trending_up"),
+            "settings": CategorySection(id="settings", title="الإعدادات والتخصيص", icon="settings"),
+        }
+        self.widgets: Dict[str, Widget] = {}
+        self.action_handlers: Dict[str, Callable] = {}
+        self.value_handlers: Dict[str, Callable] = {}
+        self.active_locks: Dict[str, str] = {}
+
+        # Initialize embedded server
+        self.server = FeoryServer(client=self, host=host, port=port)
+        if auto_start_server:
+            self.server.start()
+
+    # --- UI Registration Methods ---
+
+    def register_category(self, id: str, title: str, description: Optional[str] = None, icon: Optional[str] = None) -> 'Client':
+        """Registers a custom category group."""
+        self.categories[id] = CategorySection(id=id, title=title, description=description, icon=icon)
+        return self
+
+    def register_button(
+        self,
+        id: str,
+        label: str,
+        category: str = "general",
+        action_id: Optional[str] = None,
+        color_scheme: str = "LILAC",
+        variant: str = "FILLED",
+        icon: Optional[str] = "play",
+        description: Optional[str] = None,
+        handler: Optional[Callable] = None,
+    ) -> ButtonWidget:
+        """Registers an interactive button in the Feory Android UI."""
+        btn = ButtonWidget(
+            id=id,
+            label=label,
+            category=category,
+            action_id=action_id or id,
+            color_scheme=color_scheme,
+            variant=variant,
+            icon=icon,
+            description=description,
+        )
+        self.widgets[id] = btn
+        if handler:
+            self.action_handlers[action_id or id] = handler
+        return btn
+
+    def register_slider(
+        self,
+        id: str,
+        label: str,
+        category: str = "general",
+        min_value: float = 0.0,
+        max_value: float = 100.0,
+        default_value: float = 50.0,
+        step: Optional[float] = 1.0,
+        unit: Optional[str] = None,
+        description: Optional[str] = None,
+        handler: Optional[Callable] = None,
+    ) -> SliderWidget:
+        """Registers a dynamic range slider widget."""
+        slider = SliderWidget(
+            id=id,
+            label=label,
+            category=category,
+            min_value=min_value,
+            max_value=max_value,
+            current_value=default_value,
+            step=step,
+            unit=unit,
+            description=description,
+        )
+        self.widgets[id] = slider
+        if handler:
+            self.value_handlers[id] = handler
+        return slider
+
+    def register_toggle(
+        self,
+        id: str,
+        label: str,
+        category: str = "general",
+        default_state: bool = False,
+        description: Optional[str] = None,
+        handler: Optional[Callable] = None,
+    ) -> ToggleWidget:
+        """Registers a switch toggle widget."""
+        toggle = ToggleWidget(
+            id=id,
+            label=label,
+            category=category,
+            is_checked=default_state,
+            description=description,
+        )
+        self.widgets[id] = toggle
+        if handler:
+            self.value_handlers[id] = handler
+        return toggle
+
+    def register_text_input(
+        self,
+        id: str,
+        label: str,
+        placeholder: str = "Enter value...",
+        default_value: str = "",
+        category: str = "general",
+        is_secret: bool = False,
+        description: Optional[str] = None,
+        handler: Optional[Callable] = None,
+    ) -> TextFieldWidget:
+        """Registers a text input field widget."""
+        field = TextFieldWidget(
+            id=id,
+            label=label,
+            category=category,
+            placeholder=placeholder,
+            current_value=default_value,
+            is_secret=is_secret,
+            description=description,
+        )
+        self.widgets[id] = field
+        if handler:
+            self.value_handlers[id] = handler
+        return field
+
+    def register_metric_card(
+        self,
+        id: str,
+        title: str,
+        value: Union[str, int, float],
+        subtitle: Optional[str] = None,
+        badge: Optional[str] = None,
+        category: str = "metrics",
+        accent_color: str = "LILAC",
+        icon: Optional[str] = "trending_up",
+    ) -> MetricWidget:
+        """Registers a styled Bento Stat / Metric card."""
+        metric = MetricWidget(
+            id=id,
+            title=title,
+            value=value,
+            subtitle=subtitle,
+            badge=badge,
+            category=category,
+            accent_color=accent_color,
+            icon=icon,
+        )
+        self.widgets[id] = metric
+        return metric
+
+    def register_dropdown(
+        self,
+        id: str,
+        label: str,
+        options: List[str],
+        default_option: Optional[str] = None,
+        category: str = "general",
+        description: Optional[str] = None,
+        handler: Optional[Callable] = None,
+    ) -> DropdownWidget:
+        """Registers a selection dropdown widget."""
+        dropdown = DropdownWidget(
+            id=id,
+            label=label,
+            options=options,
+            selected_option=default_option,
+            category=category,
+            description=description,
+        )
+        self.widgets[id] = dropdown
+        if handler:
+            self.value_handlers[id] = handler
+        return dropdown
+
+    # --- Decorators for Event Handlers ---
+
+    def on_action(self, action_id: str):
+        """Decorator to bind a Python function to a button click / action event."""
+        def decorator(func: Callable):
+            self.action_handlers[action_id] = func
+            return func
+        return decorator
+
+    def on_value_change(self, widget_id: str):
+        """Decorator to bind a Python function to a slider, toggle, or input field change."""
+        def decorator(func: Callable):
+            self.value_handlers[widget_id] = func
+            return func
+        return decorator
+
+    # --- State and Realtime Methods ---
+
+    def set_status(self, status: str):
+        """Updates the bot's status (ONLINE, IDLE, BUSY, OFFLINE)."""
+        self.status = status
+        self.log(f"[*] Bot status updated to: {status}", "INFO")
+
+    def log(self, message: str, level: str = "INFO"):
+        """Sends a log line to the Feory App Terminal."""
+        timestamp_str = time.strftime("%H:%M:%S")
+        print(f"[{timestamp_str}] [{level}] {message}")
+
+    def update_widget(self, widget_id: str, **kwargs):
+        """Updates properties of an existing widget dynamically."""
+        if widget_id in self.widgets:
+            widget = self.widgets[widget_id]
+            for key, val in kwargs.items():
+                if hasattr(widget, key):
+                    setattr(widget, key, val)
+
+    def acquire_lock(self, resource_key: str) -> bool:
+        """Acquires a resource lock to prevent collision with other bots."""
+        if resource_key in self.active_locks:
+            return False
+        self.active_locks[resource_key] = self.bot_name
+        self.log(f"[✓] Mutex lock acquired for '{resource_key}'", "INFO")
+        return True
+
+    def release_lock(self, resource_key: str):
+        """Releases a previously acquired mutex lock."""
+        if resource_key in self.active_locks:
+            del self.active_locks[resource_key]
+            self.log(f"[✓] Mutex lock released for '{resource_key}'", "INFO")
+
+    # --- Internal Dispatchers ---
+
+    def _dispatch_action(self, action_id: str, widget_id: str, payload: Dict[str, Any]):
+        handler = self.action_handlers.get(action_id) or self.action_handlers.get(widget_id)
+        if handler:
+            try:
+                self.log(f"[▶] Action invoked from App: {action_id}", "INFO")
+                return handler(payload)
+            except Exception as e:
+                self.log(f"[!] Error in action handler '{action_id}': {e}", "ERROR")
+                return {"error": str(e)}
+        return {"status": "unhandled"}
+
+    def get_schema_dict(self) -> Dict[str, Any]:
+        """Exports the full dynamic UI schema as JSON-serializable dictionary."""
+        return {
+            "version": "1.0.0",
+            "botName": self.bot_name,
+            "category": self.category,
+            "status": self.status,
+            "categories": [c.to_dict() for c in self.categories.values()],
+            "widgets": [w.to_dict() for w in self.widgets.values()],
+        }
+
+    def export_schema_json(self) -> str:
+        """Returns the schema as JSON string."""
+        return json.dumps(self.get_schema_dict(), ensure_ascii=False, indent=2)
+
+    def run_forever(self):
+        """Blocks main thread to keep bot service alive."""
+        self.log("[*] Feory Bot running. Press Ctrl+C to terminate.", "INFO")
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            self.log("[*] Shutting down Feory Bot...", "INFO")
+            self.server.stop()
+
+# Alias
+FeoryClient = Client

feory-0.1.0/feory/exceptions.py

@@ -0,0 +1,23 @@
+"""
+Feory Custom Exception Classes
+"""
+
+class FeoryError(Exception):
+    """Base exception for Feory SDK."""
+    pass
+
+class FeoryAuthError(FeoryError):
+    """Raised when authentication with token fails."""
+    pass
+
+class FeoryConnectionError(FeoryError):
+    """Raised when connection to Feory App fails."""
+    pass
+
+class FeoryLockError(FeoryError):
+    """Raised when resource lock acquisition fails due to collision."""
+    pass
+
+class FeorySchemaError(FeoryError):
+    """Raised when UI schema registration contains invalid structure."""
+    pass

feory-0.1.0/feory/server.py

@@ -0,0 +1,127 @@
+"""
+Feory Lightweight Local Server Bridge
+Zero-dependency HTTP JSON-RPC / REST bridge for Feory Android App
+"""
+
+import json
+import threading
+import time
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from typing import Callable, Dict, Any, Optional
+
+class FeoryHTTPHandler(BaseHTTPRequestHandler):
+    client_instance = None
+
+    def _set_headers(self, status=200, content_type="application/json"):
+        self.send_response(status)
+        self.send_header("Content-Type", content_type)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type, Authorization")
+        self.end_headers()
+
+    def do_OPTIONS(self):
+        self._set_headers(204)
+
+    def do_GET(self):
+        if self.path == "/health" or self.path == "/":
+            self._set_headers(200)
+            res = {
+                "status": "ONLINE",
+                "service": "Feory Universal Bot Server",
+                "version": "0.1.0",
+                "timestamp": time.time(),
+            }
+            self.wfile.write(json.dumps(res).encode("utf-8"))
+            return
+
+        if self.path == "/schema":
+            self._set_headers(200)
+            schema = self.client_instance.get_schema_dict() if self.client_instance else {}
+            self.wfile.write(json.dumps(schema).encode("utf-8"))
+            return
+
+        self._set_headers(404)
+        self.wfile.write(json.dumps({"error": "Endpoint not found"}).encode("utf-8"))
+
+    def do_POST(self):
+        content_length = int(self.headers.get("Content-Length", 0))
+        post_data = self.rfile.read(content_length)
+
+        try:
+            payload = json.loads(post_data.decode("utf-8")) if post_data else {}
+        except Exception as e:
+            self._set_headers(400)
+            self.wfile.write(json.dumps({"error": f"Invalid JSON payload: {e}"}).encode("utf-8"))
+            return
+
+        # Authenticate Token
+        auth_header = self.headers.get("Authorization", "")
+        token = auth_header.replace("Bearer ", "").strip()
+        if not token and "token" in payload:
+            token = payload.get("token")
+
+        if self.client_instance and self.client_instance.token:
+            if token != self.client_instance.token:
+                self._set_headers(401)
+                self.wfile.write(json.dumps({"error": "Unauthorized: Invalid Bot Token"}).encode("utf-8"))
+                return
+
+        # Route Endpoints
+        if self.path == "/action" or self.path == "/events":
+            action_id = payload.get("actionId") or payload.get("action")
+            widget_id = payload.get("widgetId", "")
+            args = payload.get("payload", {})
+
+            if self.client_instance:
+                result = self.client_instance._dispatch_action(action_id, widget_id, args)
+                self._set_headers(200)
+                self.wfile.write(json.dumps({"success": True, "actionId": action_id, "result": result}).encode("utf-8"))
+                return
+
+        if self.path == "/handshake":
+            self._set_headers(200)
+            info = {
+                "success": True,
+                "botName": self.client_instance.bot_name if self.client_instance else "FeoryBot",
+                "status": self.client_instance.status if self.client_instance else "ONLINE",
+                "widgetsCount": len(self.client_instance.widgets) if self.client_instance else 0
+            }
+            self.wfile.write(json.dumps(info).encode("utf-8"))
+            return
+
+        self._set_headers(404)
+        self.wfile.write(json.dumps({"error": "Unknown POST route"}).encode("utf-8"))
+
+    def log_message(self, format, *args):
+        # Suppress noisy default logging
+        pass
+
+class FeoryServer:
+    """Embedded Zero-dependency HTTP Server for Feory Bot & App coordination."""
+    def __init__(self, client, host: str = "0.0.0.0", port: int = 8765):
+        self.client = client
+        self.host = host
+        self.port = port
+        self.server: Optional[HTTPServer] = None
+        self.thread: Optional[threading.Thread] = None
+        self.is_running = False
+
+    def start(self):
+        """Starts the server in a background daemon thread."""
+        if self.is_running:
+            return
+
+        FeoryHTTPHandler.client_instance = self.client
+        self.server = HTTPServer((self.host, self.port), FeoryHTTPHandler)
+        self.is_running = True
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+        self.client.log(f"[✓] Feory Server listening on http://{self.host}:{self.port}", "SUCCESS")
+
+    def stop(self):
+        """Stops the server."""
+        if self.server:
+            self.server.shutdown()
+            self.server.server_close()
+        self.is_running = False

feory-0.1.0/feory/widgets.py

@@ -0,0 +1,259 @@
+"""
+Feory Dynamic UI Widget Definitions
+"""
+
+import json
+from enum import Enum
+from typing import Dict, Any, List, Optional, Union
+
+class WidgetType(str, Enum):
+    BUTTON = "BUTTON"
+    SLIDER = "SLIDER"
+    TOGGLE = "TOGGLE"
+    TEXT_INPUT = "TEXT_INPUT"
+    METRIC_CARD = "METRIC_CARD"
+    DROPDOWN = "DROPDOWN"
+    HEADER = "HEADER"
+
+class Widget:
+    """Base class for all dynamic UI elements rendered in Feory Android app."""
+    def __init__(
+        self,
+        id: str,
+        type: WidgetType,
+        label: str,
+        category: str = "general",
+        description: Optional[str] = None,
+        is_enabled: bool = True,
+        is_visible: bool = True,
+        icon: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+    ):
+        self.id = id
+        self.type = type
+        self.label = label
+        self.category = category
+        self.description = description
+        self.is_enabled = is_enabled
+        self.is_visible = is_visible
+        self.icon = icon
+        self.style = style or {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = {
+            "id": self.id,
+            "type": self.type.value if isinstance(self.type, WidgetType) else str(self.type),
+            "label": self.label,
+            "category": self.category,
+            "isEnabled": self.is_enabled,
+            "isVisible": self.is_visible,
+        }
+        if self.description:
+            data["description"] = self.description
+        if self.icon:
+            data["icon"] = self.icon
+        if self.style:
+            data["style"] = self.style
+        return data
+
+class ButtonWidget(Widget):
+    """Interactive Button Widget."""
+    def __init__(
+        self,
+        id: str,
+        label: str,
+        category: str = "general",
+        action_id: Optional[str] = None,
+        color_scheme: str = "LILAC",  # LILAC, GREEN, AMBER, ROSE, BLUE
+        variant: str = "FILLED",      # FILLED, OUTLINED, TONAL
+        icon: Optional[str] = "play",
+        description: Optional[str] = None,
+    ):
+        super().__init__(
+            id=id,
+            type=WidgetType.BUTTON,
+            label=label,
+            category=category,
+            description=description,
+            icon=icon,
+            style={"colorScheme": color_scheme, "variant": variant}
+        )
+        self.action_id = action_id or id
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        d["actionId"] = self.action_id
+        return d
+
+class SliderWidget(Widget):
+    """Continuous or Discrete Range Slider Widget."""
+    def __init__(
+        self,
+        id: str,
+        label: str,
+        category: str = "general",
+        min_value: float = 0.0,
+        max_value: float = 100.0,
+        current_value: float = 50.0,
+        step: Optional[float] = None,
+        unit: Optional[str] = None,
+        description: Optional[str] = None,
+    ):
+        super().__init__(
+            id=id,
+            type=WidgetType.SLIDER,
+            label=label,
+            category=category,
+            description=description,
+            icon="tune"
+        )
+        self.min_value = min_value
+        self.max_value = max_value
+        self.current_value = current_value
+        self.step = step
+        self.unit = unit
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        d["minValue"] = self.min_value
+        d["maxValue"] = self.max_value
+        d["currentValue"] = self.current_value
+        if self.step is not None:
+            d["step"] = self.step
+        if self.unit:
+            d["unit"] = self.unit
+        return d
+
+class ToggleWidget(Widget):
+    """Switch Toggle Widget."""
+    def __init__(
+        self,
+        id: str,
+        label: str,
+        category: str = "general",
+        is_checked: bool = False,
+        description: Optional[str] = None,
+    ):
+        super().__init__(
+            id=id,
+            type=WidgetType.TOGGLE,
+            label=label,
+            category=category,
+            description=description,
+            icon="toggle_on"
+        )
+        self.is_checked = is_checked
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        d["isChecked"] = self.is_checked
+        return d
+
+class TextFieldWidget(Widget):
+    """Text Input Field Widget."""
+    def __init__(
+        self,
+        id: str,
+        label: str,
+        category: str = "general",
+        placeholder: str = "",
+        current_value: str = "",
+        is_secret: bool = False,
+        description: Optional[str] = None,
+    ):
+        super().__init__(
+            id=id,
+            type=WidgetType.TEXT_INPUT,
+            label=label,
+            category=category,
+            description=description,
+            icon="edit"
+        )
+        self.placeholder = placeholder
+        self.current_value = current_value
+        self.is_secret = is_secret
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        d["placeholder"] = self.placeholder
+        d["currentValue"] = self.current_value
+        d["isSecret"] = self.is_secret
+        return d
+
+class MetricWidget(Widget):
+    """Bento-style Metric / Stat Card Widget."""
+    def __init__(
+        self,
+        id: str,
+        title: str,
+        value: Union[str, int, float],
+        subtitle: Optional[str] = None,
+        category: str = "metrics",
+        badge: Optional[str] = None,
+        accent_color: str = "LILAC",
+        icon: Optional[str] = "trending_up",
+    ):
+        super().__init__(
+            id=id,
+            type=WidgetType.METRIC_CARD,
+            label=title,
+            category=category,
+            icon=icon,
+            style={"accentColor": accent_color}
+        )
+        self.value = str(value)
+        self.subtitle = subtitle
+        self.badge = badge
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        d["metricValue"] = self.value
+        if self.subtitle:
+            d["subtitle"] = self.subtitle
+        if self.badge:
+            d["badge"] = self.badge
+        return d
+
+class DropdownWidget(Widget):
+    """Selection Dropdown Widget."""
+    def __init__(
+        self,
+        id: str,
+        label: str,
+        options: List[str],
+        selected_option: Optional[str] = None,
+        category: str = "general",
+        description: Optional[str] = None,
+    ):
+        super().__init__(
+            id=id,
+            type=WidgetType.DROPDOWN,
+            label=label,
+            category=category,
+            description=description,
+            icon="list"
+        )
+        self.options = options
+        self.selected_option = selected_option or (options[0] if options else "")
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = super().to_dict()
+        d["options"] = self.options
+        d["selectedOption"] = self.selected_option
+        return d
+
+class CategorySection:
+    """Logical grouping of widgets in Feory App."""
+    def __init__(self, id: str, title: str, description: Optional[str] = None, icon: Optional[str] = None):
+        self.id = id
+        self.title = title
+        self.description = description
+        self.icon = icon
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = {"id": self.id, "title": self.title}
+        if self.description:
+            d["description"] = self.description
+        if self.icon:
+            d["icon"] = self.icon
+        return d

feory-0.1.0/feory.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: feory
+Version: 0.1.0
+Summary: Universal Python SDK for Feory Android App - Dynamic UI Builder & Bot Control Bridge
+Home-page: https://github.com/zizo0/feory
+Author: zizo0
+Author-email: zizo0 <zly30257@gmail.com>
+Project-URL: Homepage, https://github.com/zizo0/feory
+Project-URL: Bug Tracker, https://github.com/zizo0/feory/issues
+Keywords: feory,android,bot,ui-builder,automation,telegram,bridge
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Communications
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Feory Python SDK ⚡
+
+Universal Python SDK & Bridge for the **Feory Android App**.
+Create dynamic Bento-style Android UIs, manage bots, handle bi-directional events, and control servers remotely from your mobile device.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install feory
+```
+
+---
+
+## 🛠️ Quick Start
+
+```python
+import feory
+
+# 1. Initialize with your bot token from the Feory App
+client = feory.Client(
+    token="feory_tok_core_829a1b",
+    bot_name="My Awesome Python Bot",
+    port=8765
+)
+
+# 2. Register Dynamic UI Widgets
+client.register_button(
+    id="btn_start_scrape",
+    label="Start Data Pipeline",
+    category="general",
+    color_scheme="LILAC",
+    icon="play"
+)
+
+client.register_slider(
+    id="slider_threads",
+    label="Worker Threads",
+    min_value=1,
+    max_value=32,
+    default_value=8
+)
+
+client.register_metric_card(
+    id="stat_processed",
+    title="Items Processed",
+    value="12,450",
+    badge="+14% today",
+    accent_color="GREEN"
+)
+
+# 3. Handle Events from Feory Android App
+@client.on_action("btn_start_scrape")
+def handle_scrape(payload):
+    client.log("Starting scraping tasks...", "INFO")
+    # Your automation logic here
+    return {"status": "started", "items": 100}
+
+@client.on_value_change("slider_threads")
+def handle_thread_change(new_val):
+    client.log(f"Thread pool updated to: {new_val}", "INFO")
+
+# 4. Keep your bot server running
+if __name__ == "__main__":
+    client.run_forever()
+```
+
+---
+
+## 📖 Features
+
+- **Dynamic Android UI Generation**: Inject buttons, sliders, toggles, text inputs, dropdowns, and Bento metric cards on the fly without touching Kotlin code.
+- **Two-Way Event Bus**: Receive instant button clicks and slider callbacks directly in your Python functions.
+- **Real-Time Telemetry & Terminal Logs**: Stream live console logs directly to the Feory App terminal.
+- **Resource Lock & Collision Prevention**: Coordinate multiple bots accessing the same channels or resources with built-in Mutex locks.
+- **Zero-Dependency Core**: Uses Python standard library by default for maximum portability.
+
+---
+
+## 🔒 Authentication
+
+Every bot connects securely using its unique **Feory Token** (`feory_tok_...`). You can create, manage, and copy tokens directly inside the **Tokens** screen of the Feory Android App.
+
+---
+
+## 👤 Author
+
+Developed by **zizo0**  
+Email: `zly30257@gmail.com`

feory-0.1.0/feory.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+setup.py
+feory/__init__.py
+feory/client.py
+feory/exceptions.py
+feory/server.py
+feory/widgets.py
+feory.egg-info/PKG-INFO
+feory.egg-info/SOURCES.txt
+feory.egg-info/dependency_links.txt
+feory.egg-info/top_level.txt

feory-0.1.0/feory.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

feory-0.1.0/feory.egg-info/top_level.txt

@@ -0,0 +1 @@
+feory

feory-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "feory"
+version = "0.1.0"
+authors = [
+  { name="zizo0", email="zly30257@gmail.com" },
+]
+description = "Universal Python SDK for Feory Android App - Dynamic UI Builder & Bot Control Bridge"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: User Interfaces",
+    "Topic :: Communications",
+]
+keywords = ["feory", "android", "bot", "ui-builder", "automation", "telegram", "bridge"]
+
+[project.urls]
+"Homepage" = "https://github.com/zizo0/feory"
+"Bug Tracker" = "https://github.com/zizo0/feory/issues"

feory-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

feory-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="feory",
+    version="0.1.0",
+    author="zizo0",
+    author_email="zly30257@gmail.com",
+    description="Universal Python SDK for Feory Android App - Dynamic UI Builder & Bot Control Bridge",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/zizo0/feory",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+)