wnox 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

wnox/__init__.py

@@ -5,11 +5,22 @@ import logging
 from slixmpp import ClientXMPP 
 import ssl
 import json
-from bson import ObjectId  # If you need ObjectId validation
+from bson import ObjectId 
 import requests as r
 
+import random
+import string
+
 nest_asyncio.apply()
+eventdatax = {}
+eventsx = {}
 # logging.basicConfig(level=logging.DEBUG)
+
+def serial_generator(length: int) -> str:
+    chars = string.digits + string.ascii_uppercase + string.ascii_lowercase
+    random_string = ''.join(random.choice(chars) for _ in range(length))
+    return random_string
+
 class EventEmitter:
     def __init__(self):
         self._events = {}
@@ -31,43 +42,41 @@ class EventEmitter:
                     results.append(result)
             return results[0]
 
-class __WebSocketXMPP(ClientXMPP, EventEmitter):
-    def __init__(self, jid, password):
+class WSX(ClientXMPP, EventEmitter):
+    connected = False
+    def __init__(self, jid, password, app:str, uid:str, resource:str):
     
-                
         ClientXMPP.__init__(self, jid, password)
         EventEmitter.__init__(self)
-        print(f"connecting to {jid} - {password}")
-        # self.jid = jid
+        self.app = app
+        self.uid = uid
+        self._resource = resource
         self.password = password
-        # self.callback = callback  # Store the callback function
         self.add_event_handler("session_start", self.start)
         self.add_event_handler("failed_auth", self.on_failed_auth)
         self.add_event_handler("disconnected", self.on_disconnect)
-        self.add_event_handler("message", self.on_message)  # Add event handler for incoming messages
+        self.add_event_handler("message", self.on_message) 
 
     async def start(self, event):
         """Handle session start."""
         print("[bridge] connected.")
-        self.send_presence()
+        self.send_presence(ptype="presence")
         await self.get_roster()
+        await self.emit("connect",{})
+        self.connected = True
         
-        # Send a test message
-        self.send_message(mto="ethan@qepal.com", mbody="Hello via WebSocket!")
-        print("[📩] Message sent to ethan@qepal.com")
 
     def on_failed_auth(self, event):
         """Handle authentication failure."""
-        # print("[❌] Authentication failed. Check username/password.")
 
-    def on_disconnect(self, event):
+    async def on_disconnect(self, event):
         """Handle disconnection and attempt reconnection."""
-        # print("[❌] Disconnected from server. Attempting to reconnect...")
+        await self.emit("disconnect",{})
+        self.connected = False
         asyncio.create_task(self.reconnect())
 
     async def reconnect(self):
-        await asyncio.sleep(5)  # Wait before reconnecting
-        print("[🔄] Reconnecting...")
+        await asyncio.sleep(5) 
         self.connect(address=("direct.qepal.com", 5222), disable_starttls=False, force_starttls=True)
         self.process(forever=False)
 
@@ -78,14 +87,15 @@ class __WebSocketXMPP(ClientXMPP, EventEmitter):
             from_jid = str(stanza['from'])
             itsme = from_jid and f"{self.boundjid.bare.split('@')[0]}-{self.boundjid.bare.split('@')[1]}" in from_jid
             itsbro = not itsme and f"{self.boundjid.bare.split('@')[0]}-" in from_jid
+            
+            if "conference.qepal.com" in from_jid:
+                itsme = f"{self.app}-{self.uid}-{self._resource}" in from_jid
+                itsbro = not itsme and f"{self.app}-{self.uid}-" in from_jid
+                
             delayed = "urn:xmpp:delay" in str(stanza)
 
             if body and not delayed:
                 user_uid = from_jid.split('@')[0]
-                is_app = False
-                if len(user_uid) != 24 or not ObjectId.is_valid(user_uid):
-                    user_uid = user_uid.split("-")[-1]
-                    is_app = True
                     
                 if body.startswith("{"):
                     try:
@@ -103,43 +113,95 @@ class __WebSocketXMPP(ClientXMPP, EventEmitter):
                                     mbody=json.dumps({**result, "mid": json_data.get("mid")})
                                 )
                         else:
-                            await self.emit("message", {"from": from_jid, "body": body, "itsme": itsme, "itsbro": itsbro, "is_app":is_app})
+                            if "mid" in json_data:
+                                data = {key: val for key, val in json_data.items() if key != "mid"}
+                                eventdatax[json_data.get("mid")] = data
+                                if json_data.get("mid") in eventsx:
+                                    eventsx.get(json_data.get("mid")).set()
+                            else:
+                                await self.emit("message", {"from": from_jid, "body": body, "itsme": itsme, "itsbro": itsbro})
+                   
                     except json.JSONDecodeError:
                         pass
                 else:
-                    await self.emit("message", {"from": from_jid, "body": body, "itsme": itsme, "itsbro": itsbro, "is_app":is_app})
+                    await self.emit("message", {"from": from_jid, "body": body, "itsme": itsme, "itsbro": itsbro})
 
 
 
 class App:
+    
     def __init__(self, *, app:str, resource:str, securekey:str, image:str, public:bool=False):
         self.app = app
+        self.channels = set()
         self.resource = resource
         self.securekey = securekey
         self.image = image
         self.public = public
         
-        json = r.post("https://qepal.com/api/bridge/worker/init", json={
+        _json = r.post("https://qepal.com/api/bridge/worker/init", json={
             "app":app, "resource":resource, "securekey":securekey, "image":image, "public":public}).json()
         
-        self.uid = json["uid"]
+        self.uid = _json["uid"]
         self.myjid = self.app + "-" + str(self.uid) + "@qepal.com/" + self.resource
-        self.password = json["password"]
-        self.xmpp = __WebSocketXMPP(self.myjid, self.password)
+        self.password = _json["password"]
+        self.xmpp = WSX(self.myjid, self.password, self.app, self.uid, self.resource)
 
     def on(self, api:str, cb:callable):
         self.xmpp.on(api, cb)
     
+    def sendtojid(self, jid:str, body:str):
+        self.xmpp.send_message(mto=jid, mbody=body)
+        
+    def connected(self):
+        return self.xmpp.connected
+        
+    async def api(self, app:str, cmd:str, body:dict, jid:str = None, prioritize_public:bool = False):
+        if jid == None:
+            res:dict = r.post("https://qepal.com/api/bridge/worker/findfreeresource", json={ "app":app, "securekey": self.securekey }).json()
+            jids = list(res.get("jids",[]))
+            if len(jids) > 0:
+                if prioritize_public:
+                    jid = jids[-1]
+                else:
+                    jid = jids[0]
+        if jid == None:
+            print("unable to send api (-1)")
+            return
+    
+        mid = serial_generator(10)
+        msg = {"mid":mid, "api":cmd, **body }  
+        eventsx[mid] = asyncio.Event()
+        self.sendtojid(jid, json.dumps(msg))
+        await eventsx[mid].wait()
+        data = eventdatax.get(mid)
+        return data
+        
+        
+            
+    def subscribe(self, channelname:str):
+        self.xmpp.send_presence(pto=channelname+ "@conference.qepal.com/"+ self.app + "-" + self.uid + "-" + self.resource , ptype="presence")
+        self.xmpp.get_roster()
+        self.channels.add(channelname)
+        
+    def unsubscribe(self, channelname:str):
+        self.xmpp.send_presence(pto=channelname+ "@conference.qepal.com" , ptype="unavailable")
+        self.xmpp.get_roster()
+        self.channels.remove(channelname)
+        
+    def sendtochannel(self, channelname:str, body:str):
+        if channelname not in self.channels:
+            self.subscribe(channelname)
+        self.xmpp.send_message(mto=f"{channelname}@conference.qepal.com", mbody=body, mtype='groupchat')
         
     async def loop(self):
-        # print("[🔄] Initializing connection...")
+
         ssl_ctx = ssl.create_default_context()
-        ssl_ctx.check_hostname = False  # Disable hostname verification
-        ssl_ctx.verify_mode = ssl.CERT_NONE  # Ignore SSL certificate validation
+        ssl_ctx.check_hostname = False 
+        ssl_ctx.verify_mode = ssl.CERT_NONE  
         self.xmpp.ssl_context = ssl_ctx
     
         self.xmpp.connect(address=("direct.qepal.com", 5222), disable_starttls=False, force_starttls=True)
-        self.xmpp.process(forever=True)  # Keep the connection alive
+        self.xmpp.process(forever=True)
 
 
 

{wnox-0.3.0.dist-info → wnox-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wnox
-Version: 0.3.0
+Version: 0.5.0
 Summary: A short description of your package
 Home-page: https://github.com/arminkardan/pywnox
 Author: Ethan (Armin) Cardan

wnox-0.5.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+wnox/__init__.py,sha256=_M92Wza8dl4QeQWdM0ckRtphgyfZs9g4DqwwvgSvOKI,8234
+wnox-0.5.0.dist-info/LICENSE.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wnox-0.5.0.dist-info/METADATA,sha256=JK1RXI-Ep2tmgbAmGiIkbCCwBMWwyjGrBZ6oXYWrfZE,670
+wnox-0.5.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+wnox-0.5.0.dist-info/top_level.txt,sha256=Xm9SC1bx_o6zjvo2FI-3QiZX2PZ_0UBQkGlvfYsnkwc,5
+wnox-0.5.0.dist-info/RECORD,,

wnox-0.3.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-wnox/__init__.py,sha256=j7NZA4FZiwhE4EAUumAR-8pWweC7Fw-Dt2QHbPCgJu4,6128
-wnox-0.3.0.dist-info/LICENSE.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wnox-0.3.0.dist-info/METADATA,sha256=4jzCO_HyB0cIHeSrEg4MvYuVibx0goO1S_Hgqk2yyJI,670
-wnox-0.3.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-wnox-0.3.0.dist-info/top_level.txt,sha256=Xm9SC1bx_o6zjvo2FI-3QiZX2PZ_0UBQkGlvfYsnkwc,5
-wnox-0.3.0.dist-info/RECORD,,