roolink 1.0.0__tar.gz

roolink-1.0.0/LICENSE

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

roolink-1.0.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: roolink
+Version: 1.0.0
+Summary: Official Roolink SDK for Python
+Author: Roolink
+License: MIT
+Project-URL: Homepage, https://github.com/roolinkio/roolink-py
+Project-URL: Documentation, https://docs.roolink.io
+Project-URL: Source Code, https://github.com/roolinkio/roolink-py
+Project-URL: Bug Tracker, https://github.com/roolinkio/roolink-py/issues
+Keywords: roolink,akamai,sensor,sdk
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx[http2]>=0.27.0
+Dynamic: license-file
+
+<div align="center">
+
+# 🔗 Roolink Python SDK
+
+### Enterprise-grade Akamai sensor generation for Python
+
+[![PyPI](https://img.shields.io/badge/PyPI-1.0.0-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://pypi.org/project/roolink/)
+[![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-MIT-purple?style=for-the-badge)](LICENSE)
+
+**[📚 Documentation](https://docs.roolink.io/)** • **[💬 Discord](https://discord.gg/rooapi)**
+
+---
+
+</div>
+
+## 🚀 Overview
+
+Production-ready APIs for generating Akamai sensor data across web and mobile platforms. This SDK handles authentication, requests, and response parsing with full type hints.
+
+### 🎯 Supported Services
+
+| Service | Features |
+|---------|----------|
+| **🌐 Web API** | Sensor generation, pixel challenges, SBSD, sec-cpt solving |
+| **📱 BMP API** | iOS & Android mobile app sensor generation |
+
+---
+
+## 📦 Installation
+
+```bash
+pip install roolink
+```
+
+## ⚡ Quick Start
+
+```python
+from roolink import RoolinkClient
+
+client = RoolinkClient('your-api-key')
+sensor = client.generate_web_sensor(req)
+```
+
+---
+
+## 🌐 Web API
+
+```python
+# Sensor Generation
+client.generate_web_sensor(req)
+
+# Pixel Challenges
+client.generate_pixel(req)
+
+# Sec-Cpt Challenges
+client.solve_sec_cpt(req)
+
+# SBSD Challenges
+client.solve_sbsd(req)
+
+# Script Parsing
+client.parse_script(script_content)
+```
+
+---
+
+## 📱 BMP API
+
+```python
+# iOS Sensors (android=False)
+client.generate_bmp_sensor(BMPSensorRequest(
+    android=False,
+))
+
+# Android Sensors (android=True)
+client.generate_bmp_sensor(BMPSensorRequest(
+    android=True,
+))
+```
+
+---
+
+## 🆘 Error Handling
+
+```python
+try:
+    result = client.generate_web_sensor(req)
+except Exception as e:
+    # handle error
+    pass
+```
+
+---
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+<div align="center">
+
+**Built with 💜**
+
+</div>

roolink-1.0.0/README.md

@@ -0,0 +1,106 @@
+<div align="center">
+
+# 🔗 Roolink Python SDK
+
+### Enterprise-grade Akamai sensor generation for Python
+
+[![PyPI](https://img.shields.io/badge/PyPI-1.0.0-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://pypi.org/project/roolink/)
+[![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-MIT-purple?style=for-the-badge)](LICENSE)
+
+**[📚 Documentation](https://docs.roolink.io/)** • **[💬 Discord](https://discord.gg/rooapi)**
+
+---
+
+</div>
+
+## 🚀 Overview
+
+Production-ready APIs for generating Akamai sensor data across web and mobile platforms. This SDK handles authentication, requests, and response parsing with full type hints.
+
+### 🎯 Supported Services
+
+| Service | Features |
+|---------|----------|
+| **🌐 Web API** | Sensor generation, pixel challenges, SBSD, sec-cpt solving |
+| **📱 BMP API** | iOS & Android mobile app sensor generation |
+
+---
+
+## 📦 Installation
+
+```bash
+pip install roolink
+```
+
+## ⚡ Quick Start
+
+```python
+from roolink import RoolinkClient
+
+client = RoolinkClient('your-api-key')
+sensor = client.generate_web_sensor(req)
+```
+
+---
+
+## 🌐 Web API
+
+```python
+# Sensor Generation
+client.generate_web_sensor(req)
+
+# Pixel Challenges
+client.generate_pixel(req)
+
+# Sec-Cpt Challenges
+client.solve_sec_cpt(req)
+
+# SBSD Challenges
+client.solve_sbsd(req)
+
+# Script Parsing
+client.parse_script(script_content)
+```
+
+---
+
+## 📱 BMP API
+
+```python
+# iOS Sensors (android=False)
+client.generate_bmp_sensor(BMPSensorRequest(
+    android=False,
+))
+
+# Android Sensors (android=True)
+client.generate_bmp_sensor(BMPSensorRequest(
+    android=True,
+))
+```
+
+---
+
+## 🆘 Error Handling
+
+```python
+try:
+    result = client.generate_web_sensor(req)
+except Exception as e:
+    # handle error
+    pass
+```
+
+---
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+<div align="center">
+
+**Built with 💜**
+
+</div>

roolink-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "roolink"
+version = "1.0.0"
+description = "Official Roolink SDK for Python"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+keywords = ["roolink", "akamai", "sensor", "sdk"]
+authors = [
+    {name = "Roolink"}
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "httpx[http2]>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/roolinkio/roolink-py"
+Documentation = "https://docs.roolink.io"
+"Source Code" = "https://github.com/roolinkio/roolink-py"
+"Bug Tracker" = "https://github.com/roolinkio/roolink-py/issues"

roolink-1.0.0/roolink/__init__.py

@@ -0,0 +1,31 @@
+from .client import RoolinkClient
+from .types.bmp import BMPSensorRequest, BMPSensorResponse, Cookie
+from .types.web import (
+    WebSensorRequest,
+    WebSensorResponse,
+    PixelRequest,
+    PixelResponse,
+    SecCptRequest,
+    SecCptResponse,
+    SBSDRequest,
+    SBSDResponse,
+    ParseResponse,
+)
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "RoolinkClient",
+    "BMPSensorRequest",
+    "BMPSensorResponse",
+    "Cookie",
+    "WebSensorRequest",
+    "WebSensorResponse",
+    "PixelRequest",
+    "PixelResponse",
+    "SecCptRequest",
+    "SecCptResponse",
+    "SBSDRequest",
+    "SBSDResponse",
+    "ParseResponse",
+]

roolink-1.0.0/roolink/client.py

@@ -0,0 +1,99 @@
+from typing import Optional, Any, Dict, Union
+import httpx
+
+from .types.bmp import BMPSensorRequest, BMPSensorResponse
+from .types.web import (
+    WebSensorRequest,
+    WebSensorResponse,
+    PixelRequest,
+    PixelResponse,
+    SecCptRequest,
+    SecCptResponse,
+    SBSDRequest,
+    SBSDResponse,
+    ParseResponse,
+)
+
+BMP_BASE_URL = "https://bmp.roolink.io"
+WEB_BASE_URL = "https://web.roolink.io"
+DEFAULT_TIMEOUT = 30.0
+
+
+class RoolinkClient:
+    """Client for interacting with Roolink services."""
+
+    def __init__(self, api_key: str):
+        """
+        Initialize the Roolink client.
+
+        Args:
+            api_key: Your Roolink API key
+        """
+        self.api_key = api_key
+        self.timeout = DEFAULT_TIMEOUT
+
+        self.client = httpx.Client(
+            http2=True,
+            timeout=self.timeout,
+            headers={
+                "x-api-key": self.api_key,
+                "Content-Type": "application/json",
+                "Accept-Encoding": "gzip, deflate, br",
+            },
+        )
+
+    def _request(self, method: str, url: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an HTTP request."""
+        response = self.client.request(
+            method=method,
+            url=url,
+            json=data,
+        )
+
+        if response.status_code >= 400:
+            raise Exception(f"API error (status {response.status_code}): {response.text}")
+
+        return response.json()
+
+    def __del__(self):
+        """Clean up the HTTP client."""
+        if hasattr(self, 'client'):
+            self.client.close()
+
+    # BMP API Methods
+    def generate_bmp_sensor(self, req: BMPSensorRequest) -> BMPSensorResponse:
+        """Generate an Akamai BMP sensor for mobile apps."""
+        url = f"{BMP_BASE_URL}/api/v1/sensor"
+        data = self._request("POST", url, req.to_dict())
+        return BMPSensorResponse.from_dict(data)
+
+    # Web API Methods
+    def generate_web_sensor(self, req: WebSensorRequest) -> WebSensorResponse:
+        """Generate an Akamai web sensor."""
+        url = f"{WEB_BASE_URL}/api/v1/sensor"
+        data = self._request("POST", url, req.to_dict())
+        return WebSensorResponse.from_dict(data)
+
+    def generate_pixel(self, req: PixelRequest) -> PixelResponse:
+        """Generate pixel sensor data."""
+        url = f"{WEB_BASE_URL}/api/v1/pixel"
+        data = self._request("POST", url, req.to_dict())
+        return PixelResponse.from_dict(data)
+
+    def solve_sec_cpt(self, req: SecCptRequest) -> SecCptResponse:
+        """Solve a sec-cpt crypto challenge."""
+        url = f"{WEB_BASE_URL}/api/v1/sec-cpt"
+        data = self._request("POST", url, req.to_dict())
+        return SecCptResponse.from_dict(data)
+
+    def solve_sbsd(self, req: SBSDRequest) -> SBSDResponse:
+        """Solve an SBSD challenge."""
+        url = f"{WEB_BASE_URL}/api/v1/sbsd"
+        data = self._request("POST", url, req.to_dict())
+        return SBSDResponse.from_dict(data)
+
+    def parse_script(self, script_content: str) -> ParseResponse:
+        """Parse an Akamai script and return script data."""
+        url = f"{WEB_BASE_URL}/api/v1/parse"
+        data = self._request("POST", url, {"scriptContent": script_content})
+        return ParseResponse.from_dict(data)

roolink-1.0.0/roolink/types/__init__.py

@@ -0,0 +1 @@
+"""Type definitions for Roolink SDK."""

roolink-1.0.0/roolink/types/bmp.py

@@ -0,0 +1,85 @@
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass, field, asdict
+
+
+@dataclass
+class BMPSensorRequest:
+    """Request to generate an Akamai BMP sensor."""
+
+    app: str
+    proxy: str
+    language: Optional[str] = None
+    android: Optional[bool] = None
+    ipad: Optional[bool] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary, excluding None values."""
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+
+@dataclass
+class Cookie:
+    """Cookie returned from BMP sensor generation."""
+
+    name: str
+    value: str
+    domain: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Cookie":
+        return cls(
+            name=data["name"],
+            value=data["value"],
+            domain=data["domain"],
+        )
+
+
+@dataclass
+class BMPSensorResponse:
+    """Response from BMP sensor generation."""
+
+    sensor: str
+    platform: str
+    device_id: str
+    app_version: str
+    screen_height: int
+    screen_width: int
+    language: str
+
+    # iOS specific fields
+    ios: Optional[str] = None
+    kernel_os_release: Optional[str] = None
+    kernel_os_version: Optional[str] = None
+    machine_id: Optional[str] = None
+    cookies: Optional[List[Cookie]] = None
+
+    # Android specific fields
+    android: Optional[str] = None
+    device_model: Optional[str] = None
+    device_manufacturer: Optional[str] = None
+    sdk_version: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "BMPSensorResponse":
+        cookies = None
+        if "cookies" in data and data["cookies"]:
+            cookies = [Cookie.from_dict(c) for c in data["cookies"]]
+
+        return cls(
+            sensor=data["sensor"],
+            platform=data["platform"],
+            device_id=data["deviceId"],
+            app_version=data["appVersion"],
+            screen_height=data["screenHeight"],
+            screen_width=data["screenWidth"],
+            language=data["language"],
+            ios=data.get("ios"),
+            kernel_os_release=data.get("kernelOsRelease"),
+            kernel_os_version=data.get("kernelOsVersion"),
+            machine_id=data.get("machineId"),
+            cookies=cookies,
+            android=data.get("android"),
+            device_model=data.get("deviceModel"),
+            device_manufacturer=data.get("deviceManufacturer"),
+            sdk_version=data.get("sdkVersion"),
+        )

roolink-1.0.0/roolink/types/web.py

@@ -0,0 +1,196 @@
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, asdict
+
+# Type alias for parsed Akamai script configuration data
+ScriptData = Dict[str, Any]
+
+
+@dataclass
+class WebSensorRequest:
+    """Request to generate an Akamai web sensor."""
+
+    user_agent: str
+    url: str
+    flags: Optional[str] = None
+    abck: Optional[str] = None
+    bm_sz: Optional[str] = None
+    sec_cpt: Optional[bool] = None
+    index: Optional[int] = None
+    stepper: Optional[bool] = None
+    keyboard: Optional[bool] = None
+    count: Optional[bool] = None
+    language: Optional[str] = None
+    custom_sensor: Optional[bool] = None
+    script_data: Optional[ScriptData] = None
+    script_url: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary with correct JSON field names."""
+        result = {
+            "userAgent": self.user_agent,
+            "url": self.url,
+        }
+        if self.flags:
+            result["flags"] = self.flags
+        if self.abck:
+            result["_abck"] = self.abck
+        if self.bm_sz:
+            result["bm_sz"] = self.bm_sz
+        if self.sec_cpt is not None:
+            result["sec_cpt"] = self.sec_cpt
+        if self.index is not None:
+            result["index"] = self.index
+        if self.stepper is not None:
+            result["stepper"] = self.stepper
+        if self.keyboard is not None:
+            result["keyboard"] = self.keyboard
+        if self.count is not None:
+            result["count"] = self.count
+        if self.language:
+            result["language"] = self.language
+        if self.custom_sensor is not None:
+            result["customSensor"] = self.custom_sensor
+        if self.script_data:
+            result["scriptData"] = self.script_data
+        if self.script_url:
+            result["scriptUrl"] = self.script_url
+        return result
+
+
+@dataclass
+class WebSensorResponse:
+    """Response from web sensor generation."""
+
+    sensor: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WebSensorResponse":
+        return cls(sensor=data["sensor"])
+
+
+@dataclass
+class PixelRequest:
+    """Request to generate pixel data."""
+
+    user_agent: str
+    bazadebezolkohpepadr: int
+    hash: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "userAgent": self.user_agent,
+            "bazadebezolkohpepadr": self.bazadebezolkohpepadr,
+            "hash": self.hash,
+        }
+
+
+@dataclass
+class PixelResponse:
+    """Response from pixel generation."""
+
+    sensor: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "PixelResponse":
+        return cls(sensor=data["sensor"])
+
+
+@dataclass
+class SecCptRequest:
+    """Request to solve a sec-cpt challenge."""
+
+    token: str
+    timestamp: int
+    nonce: str
+    difficulty: int
+    cookie: str
+    sec_cp_challenge: Optional[str] = None
+    provider: Optional[str] = None
+    branding_url_content: Optional[str] = None
+    chlg_duration: Optional[int] = None
+    timeout: Optional[int] = None
+    cpu: Optional[bool] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "token": self.token,
+            "timestamp": self.timestamp,
+            "nonce": self.nonce,
+            "difficulty": self.difficulty,
+            "cookie": self.cookie,
+        }
+        if self.sec_cp_challenge:
+            result["sec-cp-challenge"] = self.sec_cp_challenge
+        if self.provider:
+            result["provider"] = self.provider
+        if self.branding_url_content:
+            result["branding_url_content"] = self.branding_url_content
+        if self.chlg_duration is not None:
+            result["chlg_duration"] = self.chlg_duration
+        if self.timeout is not None:
+            result["timeout"] = self.timeout
+        if self.cpu is not None:
+            result["cpu"] = self.cpu
+        return result
+
+
+@dataclass
+class SecCptResponse:
+    """Response from sec-cpt challenge."""
+
+    token: str
+    answers: List[str]
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SecCptResponse":
+        return cls(token=data["token"], answers=data["answers"])
+
+
+@dataclass
+class SBSDRequest:
+    """Request to solve SBSD challenge."""
+
+    vid: str
+    user_agent: str
+    bm_o: str
+    url: str
+    legacy: Optional[bool] = None
+    script_hash: Optional[str] = None
+    script_url: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "vid": self.vid,
+            "userAgent": self.user_agent,
+            "bm_o": self.bm_o,
+            "url": self.url,
+        }
+        if self.legacy is not None:
+            result["legacy"] = self.legacy
+        if self.script_hash:
+            result["script_hash"] = self.script_hash
+        if self.script_url:
+            result["script_url"] = self.script_url
+        return result
+
+
+@dataclass
+class SBSDResponse:
+    """Response from SBSD challenge."""
+
+    body: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SBSDResponse":
+        return cls(body=data["body"])
+
+
+@dataclass
+class ParseResponse:
+    """Response from script parsing."""
+
+    script_data: Dict[str, Any]
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ParseResponse":
+        return cls(script_data=data["scriptData"])

roolink-1.0.0/roolink.egg-info/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: roolink
+Version: 1.0.0
+Summary: Official Roolink SDK for Python
+Author: Roolink
+License: MIT
+Project-URL: Homepage, https://github.com/roolinkio/roolink-py
+Project-URL: Documentation, https://docs.roolink.io
+Project-URL: Source Code, https://github.com/roolinkio/roolink-py
+Project-URL: Bug Tracker, https://github.com/roolinkio/roolink-py/issues
+Keywords: roolink,akamai,sensor,sdk
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx[http2]>=0.27.0
+Dynamic: license-file
+
+<div align="center">
+
+# 🔗 Roolink Python SDK
+
+### Enterprise-grade Akamai sensor generation for Python
+
+[![PyPI](https://img.shields.io/badge/PyPI-1.0.0-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://pypi.org/project/roolink/)
+[![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-MIT-purple?style=for-the-badge)](LICENSE)
+
+**[📚 Documentation](https://docs.roolink.io/)** • **[💬 Discord](https://discord.gg/rooapi)**
+
+---
+
+</div>
+
+## 🚀 Overview
+
+Production-ready APIs for generating Akamai sensor data across web and mobile platforms. This SDK handles authentication, requests, and response parsing with full type hints.
+
+### 🎯 Supported Services
+
+| Service | Features |
+|---------|----------|
+| **🌐 Web API** | Sensor generation, pixel challenges, SBSD, sec-cpt solving |
+| **📱 BMP API** | iOS & Android mobile app sensor generation |
+
+---
+
+## 📦 Installation
+
+```bash
+pip install roolink
+```
+
+## ⚡ Quick Start
+
+```python
+from roolink import RoolinkClient
+
+client = RoolinkClient('your-api-key')
+sensor = client.generate_web_sensor(req)
+```
+
+---
+
+## 🌐 Web API
+
+```python
+# Sensor Generation
+client.generate_web_sensor(req)
+
+# Pixel Challenges
+client.generate_pixel(req)
+
+# Sec-Cpt Challenges
+client.solve_sec_cpt(req)
+
+# SBSD Challenges
+client.solve_sbsd(req)
+
+# Script Parsing
+client.parse_script(script_content)
+```
+
+---
+
+## 📱 BMP API
+
+```python
+# iOS Sensors (android=False)
+client.generate_bmp_sensor(BMPSensorRequest(
+    android=False,
+))
+
+# Android Sensors (android=True)
+client.generate_bmp_sensor(BMPSensorRequest(
+    android=True,
+))
+```
+
+---
+
+## 🆘 Error Handling
+
+```python
+try:
+    result = client.generate_web_sensor(req)
+except Exception as e:
+    # handle error
+    pass
+```
+
+---
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+<div align="center">
+
+**Built with 💜**
+
+</div>

roolink-1.0.0/roolink.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+roolink/__init__.py
+roolink/client.py
+roolink.egg-info/PKG-INFO
+roolink.egg-info/SOURCES.txt
+roolink.egg-info/dependency_links.txt
+roolink.egg-info/requires.txt
+roolink.egg-info/top_level.txt
+roolink/types/__init__.py
+roolink/types/bmp.py
+roolink/types/web.py

roolink-1.0.0/roolink.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

roolink-1.0.0/roolink.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx[http2]>=0.27.0

roolink-1.0.0/roolink.egg-info/top_level.txt

@@ -0,0 +1 @@
+roolink

roolink-1.0.0/setup.cfg

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