spelliot 1.0.0__tar.gz

spelliot-1.0.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: spelliot
+Version: 1.0.0
+Summary: Spell IoT Cloud Library for Python and Raspberry Pi
+Author: Karthickraja (Petals Automation)
+Author-email: petalsautomationembedded@gmail.com
+Maintainer: Petals Automation
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Dist: websocket-client
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: maintainer
+Dynamic: requires-dist
+Dynamic: summary

spelliot-1.0.0/setup.cfg

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

spelliot-1.0.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup
+
+setup(
+    name='spelliot',
+    version='1.0.0',
+    description='Spell IoT Cloud Library for Python and Raspberry Pi',
+    author='Karthickraja (Petals Automation)',
+    maintainer='Petals Automation',
+    author_email='petalsautomationembedded@gmail.com', 
+    py_modules=['spell_iot'], # This tells pip to include spell_iot.py
+    install_requires=[
+        'websocket-client',
+        'requests'
+    ],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'Operating System :: OS Independent',
+    ],
+)

spelliot-1.0.0/spell_iot.py

@@ -0,0 +1,208 @@
+import websocket
+import json
+import time
+import threading
+import urllib.parse
+
+class Spell_IoT:
+    def __init__(self):
+        self.ssid = ""
+        self.password = ""
+        self.device_token = ""
+        self.callbacks = {}
+        self.last_values = {}
+        self.last_rgb = {}
+        self.ws = None
+        self.ws_url = "wss://api.spelliot.com:443/ws-mobile"
+        self._connected = False
+
+    def begin(self, token, ssid="", password=""):
+        # ssid and password are not strictly needed on Raspberry Pi 
+        # as it connects to the network via OS, but kept for compatibility with C++.
+        self.ssid = ssid
+        self.password = password
+        self.device_token = token
+        
+        # Start the status thread
+        self._status_thread = threading.Thread(target=self._status_thread_func)
+        self._status_thread.daemon = True
+        self._status_thread.start()
+        
+    def registerPin(self, pin, callback):
+        self.callbacks[pin.upper()] = callback
+
+    # --- READ FUNCTIONS ---
+    def read(self, pin):
+        return self.last_values.get(pin.upper(), "")
+
+    def readInt(self, pin):
+        val = self.read(pin)
+        try:
+            return int(val)
+        except ValueError:
+            return 0
+
+    def readBool(self, pin):
+        return self.read(pin) == "1"
+
+    def readRGB(self, pin):
+        # Returns a tuple (R, G, B)
+        return self.last_rgb.get(pin.upper(), (0, 0, 0))
+
+    # --- WRITE FUNCTIONS ---
+    def urlEncode(self, value):
+        return urllib.parse.quote(str(value))
+
+    def writeAck(self, pin, value):
+        if not self._connected or not self.ws:
+            return False
+        
+        pin = pin.upper()
+        encodedValue = self.urlEncode(value)
+        fm = "0.0.0" # Firmware version equivalent
+        msg = (
+            "SEND\n"
+            f"destination:/app/device/{self.device_token}\n\n"
+            f"{pin}={encodedValue}&version={fm}\0"
+        )
+        self.ws.send(msg)
+        print(msg)
+        print(f"Data Sent -> Pin: {pin} | Value: {value}")
+        return True
+
+    def write(self, pin, value):
+        # Wrapper for writeAck just like in C++
+        return self.writeAck(pin, value)
+
+    def writeInternal(self, pin, value):
+        return self.writeAck(pin, value)
+        
+    def writeRawWS(self, pin, value):
+        if self.ws and self._connected:
+            self.ws.send(str(value))
+
+    def Status(self):
+        return self._connected
+
+    def _status_thread_func(self):
+        while True:
+            if self._connected:
+                self.write("status", "Online")
+            time.sleep(10)
+
+    # --- SKYLINK DOCKER MEMORY (Stub for Pi) ---
+    def storeMemoryString(self, keyss, values):
+        print(f"[Docker Memory] Saving {keyss} = {values}")
+
+    def storeMemoryInt(self, keyss, values):
+        print(f"[Docker Memory] Saving {keyss} = {values}")
+
+    # --- OTA UPDATES (Stub for Pi) ---
+    def updates(self, url):
+        print(f"[SpellIoT Air Update] Update requested from URL: {url}")
+        print("Note: Air Updates (OTA) work differently on Raspberry Pi than ESP32.")
+        print("You can implement Python file downloading and script restarting here.")
+
+    # --- INTERNAL HELPERS ---
+    def _hex_to_rgb(self, hex_str):
+        hex_str = hex_str.lstrip('#')
+        if len(hex_str) != 6:
+            return (0, 0, 0)
+        try:
+            return tuple(int(hex_str[i:i+2], 16) for i in (0, 2, 4))
+        except:
+            return (0, 0, 0)
+
+    # --- WEBSOCKET EVENT HANDLERS ---
+    def _on_message(self, ws, message):
+        if message.startswith("CONNECTED"):
+            print("Spell-IoT Cloud CONNECTED")
+            self._connected = True
+            subscribe_frame = (
+                "SUBSCRIBE\n"
+                "id:sub-0\n"
+                "ack:auto\n"
+                f"destination:/topic/device/{self.device_token}\n\n\0"
+            )
+            ws.send(subscribe_frame)
+            
+        elif message.startswith("MESSAGE"):
+            try:
+                parts = message.split("\n\n")
+                if len(parts) > 1:
+                    body = parts[1].strip('\0')
+                    
+                    # Prevent JSON decode error on empty STOMP frames (like heartbeat responses)
+                    if not body.strip():
+                        return
+                        
+                    data = json.loads(body)
+                    pin = data.get("pin", "").strip().upper()
+                    val = data.get("value", "").strip()
+                    
+                    print(f"Data Received <- Pin: {pin} | Value: {val}")
+                    
+                    if pin == "AIR":
+                        print("SpellIoT Air Update!")
+                        self.updates(val)
+                    else:
+                        # Store cache
+                        self.last_values[pin] = val
+                        if val.startswith("#"):
+                            self.last_rgb[pin] = self._hex_to_rgb(val)
+                            
+                        # Call user callback if registered
+                        if pin in self.callbacks:
+                            self.callbacks[pin](val)
+                        
+            except Exception as e:
+                # Suppress the known empty body JSON error completely
+                if "Expecting value: line 1 column 1" not in str(e):
+                    print(f"WS Error parsing: {e}")
+
+    def _on_error(self, ws, error):
+        print(f"WS Error: {error}")
+
+    def _on_close(self, ws, close_status_code, close_msg):
+        print("WS Disconnected!")
+        self._connected = False
+
+    def _on_open(self, ws):
+        connect_frame = (
+            "CONNECT\n"
+            "accept-version:1.2\n"
+            "host:api.spelliot.com\n"
+            "heart-beat:10000,0000\n\n\0"
+        )
+        ws.send(connect_frame)
+
+    def _run_ws(self):
+        while True:
+            self.ws = websocket.WebSocketApp(self.ws_url,
+                                      on_open=self._on_open,
+                                      on_message=self._on_message,
+                                      on_error=self._on_error,
+                                      on_close=self._on_close)
+            self.ws.run_forever()
+            print("Reconnecting in 5 seconds...")
+            time.sleep(5) 
+
+    # --- LOOP FUNCTIONS ---
+    def autoRun(self):
+        """Starts the websocket client in a background thread (same as loop_start)"""
+        self.loop_start()
+
+    def loop_start(self):
+        """Starts the websocket client in a background thread"""
+        thread = threading.Thread(target=self._run_ws)
+        thread.daemon = True
+        thread.start()
+        
+    def loop_forever(self):
+        """Starts the websocket client and blocks forever"""
+        self._run_ws()
+        
+    def loop(self):
+        """Equivalent to C++ loop(), does nothing in Python since thread is already running"""
+        pass
+

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

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: spelliot
+Version: 1.0.0
+Summary: Spell IoT Cloud Library for Python and Raspberry Pi
+Author: Karthickraja (Petals Automation)
+Author-email: petalsautomationembedded@gmail.com
+Maintainer: Petals Automation
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Dist: websocket-client
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: maintainer
+Dynamic: requires-dist
+Dynamic: summary

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

@@ -0,0 +1,7 @@
+setup.py
+spell_iot.py
+spelliot.egg-info/PKG-INFO
+spelliot.egg-info/SOURCES.txt
+spelliot.egg-info/dependency_links.txt
+spelliot.egg-info/requires.txt
+spelliot.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+websocket-client
+requests

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

@@ -0,0 +1 @@
+spell_iot