zyncedpy 1.0.3__tar.gz

zyncedpy-1.0.3/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: zyncedpy
+Version: 1.0.3
+Summary: ZyncedPy is a Python module that allows you to create bots for Zynced chat platform.
+Home-page: https://github.com/Emsa001/zyncedpy
+Author: Emanuel Scura
+License: MIT
+Keywords: sdk,bot,websocket,api,chat,zynced
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-socketio>=5.0.0
+Requires-Dist: python-engineio>=4.0.0
+Requires-Dist: dataclasses-json>=0.5.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ZyncedPy
+
+ZyncedPy is a Python module that allows you to create bots for Zynced chat platform.
+
+## Installation
+
+```bash
+pip install zyncedpy
+```
+
+## Usage
+
+```python
+from zyncedpy import Client
+
+client = Client("your_token_here")
+
+@client.on("ready")
+def on_ready(data):
+    print(f"Bot is ready! Logged in as {data['user'].username}")
+
+@client.on("messageCreate")
+def on_message(message):
+    if message.content == "!ping":
+        message.reply("Pong!")
+
+client.login()
+```
+
+## Features
+
+- WebSocket and REST API support
+- Event-driven architecture
+- Channel and guild management
+- Message handling
+- User management
+- Invite system
+
+## License
+
+MIT

zyncedpy-1.0.3/README.md

@@ -0,0 +1,41 @@
+# ZyncedPy
+
+ZyncedPy is a Python module that allows you to create bots for Zynced chat platform.
+
+## Installation
+
+```bash
+pip install zyncedpy
+```
+
+## Usage
+
+```python
+from zyncedpy import Client
+
+client = Client("your_token_here")
+
+@client.on("ready")
+def on_ready(data):
+    print(f"Bot is ready! Logged in as {data['user'].username}")
+
+@client.on("messageCreate")
+def on_message(message):
+    if message.content == "!ping":
+        message.reply("Pong!")
+
+client.login()
+```
+
+## Features
+
+- WebSocket and REST API support
+- Event-driven architecture
+- Channel and guild management
+- Message handling
+- User management
+- Invite system
+
+## License
+
+MIT

zyncedpy-1.0.3/setup.cfg

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

zyncedpy-1.0.3/setup.py

@@ -0,0 +1,36 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="zyncedpy",
+    version="1.0.3",
+    author="Emanuel Scura",
+    description="ZyncedPy is a Python module that allows you to create bots for Zynced chat platform.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Emsa001/zyncedpy",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "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",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "requests>=2.25.0",
+        "python-socketio>=5.0.0",
+        "python-engineio>=4.0.0",
+        "dataclasses-json>=0.5.0",
+    ],
+    keywords=["sdk", "bot", "websocket", "api", "chat", "zynced"],
+    license="MIT",
+)

zyncedpy-1.0.3/zyncedpy/__init__.py

@@ -0,0 +1,7 @@
+from .client import Client
+from .types import *
+
+__version__ = "1.0.3"
+__author__ = "Emanuel Scura"
+
+__all__ = ["Client"]

zyncedpy-1.0.3/zyncedpy/client/__init__.py

@@ -0,0 +1,6 @@
+from .base_client import BaseClient
+from .client import Client
+from .rest_client import RestClient
+from .websocket_client import WebSocketClient
+
+__all__ = ["BaseClient", "Client", "RestClient", "WebSocketClient"]

zyncedpy-1.0.3/zyncedpy/client/base_client.py

@@ -0,0 +1,25 @@
+from ..events import TypedEmitter
+from .rest_client import RestClient
+from .websocket_client import WebSocketClient
+from ..types import ClientOptions, ClientLogger
+from ..utils import resolve_logger
+from typing import Optional
+
+class BaseClient(TypedEmitter):
+    def __init__(self, token: str, options: Optional[ClientOptions] = None):
+        super().__init__()
+        if options is None:
+            options = ClientOptions()
+
+        self.logger: ClientLogger = resolve_logger(options.logger)
+        self._rest = RestClient(token, 'https://zynced.app/api', self.logger)
+        self._ws = WebSocketClient(token, self.logger)
+
+    def get_rest(self) -> RestClient:
+        return self._rest
+
+    def get_ws(self) -> WebSocketClient:
+        return self._ws
+
+    def destroy(self):
+        self._ws.disconnect()

zyncedpy-1.0.3/zyncedpy/client/client.py

@@ -0,0 +1,63 @@
+from .base_client import BaseClient
+from ..managers import ChannelManager, GuildManager
+from ..structures import ClientUser, Channel
+from ..types import ClientOptions
+from ..events.handlers import (
+    handle_private_message_create, handle_message_create,
+    handle_member_joined, handle_member_left, handle_user_invite
+)
+
+class Client(BaseClient):
+    def __init__(self, token: str, options: ClientOptions = None):
+        super().__init__(token, options)
+
+        self.channels = ChannelManager(self)
+        self.guilds = GuildManager(self)
+        self.user = ClientUser(self)
+
+        self._setup_event_handlers()
+
+    def _setup_event_handlers(self):
+        self.get_ws().on('privateMessageCreate', lambda data: handle_private_message_create(self, data))
+        self.get_ws().on('messageCreate', lambda data: handle_message_create(self, data))
+        self.get_ws().on('memberJoined', lambda data: handle_member_joined(self, data))
+        self.get_ws().on('memberLeft', lambda data: handle_member_left(self, data))
+        self.get_ws().on('userInvite', lambda data: handle_user_invite(self, data))
+
+    async def login(self):
+        self.logger.info('Starting login flow')
+        await self.get_ws().connect()
+        
+        response = self.get_rest().get('/data')
+        data = response.json()
+        
+        self.user._patch(data['me'])
+
+        for raw_channel in data['userList']['channels']:
+            manager = self.channels if raw_channel['group_id'] else self.guilds
+            manager._add(raw_channel)
+
+        self.emit('ready', {
+            'user': self.user,
+            'channels': self.channels,
+            'guilds': self.guilds,
+        })
+
+        self.logger.info({
+            'channels': self.channels.size,
+            'guilds': self.guilds.size,
+            'userId': self.user.id,
+        }, 'Client ready')
+
+    def channel(self, id: str) -> Channel:
+        return self.channels.get(id)
+
+    async def join_guild(self, guild_id: str):
+        response = self.get_rest().post(f'/channels/join/{guild_id}')
+        return response.json()
+
+    async def accept_invite(self, from_user: str):
+        response = self.get_rest().post('/invite/accept', json={
+            'from_user': from_user,
+        })
+        return response.json()

zyncedpy-1.0.3/zyncedpy/client/rest_client.py

@@ -0,0 +1,90 @@
+import requests
+from typing import Optional, Dict, Any
+from ..types import ClientLogger
+
+class RestClient:
+    def __init__(self, cookies: str, base_url: Optional[str] = None, logger: Optional[ClientLogger] = None):
+        self.cookies = cookies
+        self.base_url = base_url or 'https://zynced.app/api'
+        self.logger = logger
+
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'ZyncedPy/1.0',
+            'Accept': '*/*',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Connection': 'keep-alive',
+            'Cookie': self.cookies,
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Pragma': 'no-cache',
+            'Cache-Control': 'no-cache',
+        })
+
+    def _log_request(self, method: str, url: str):
+        if self.logger:
+            self.logger.debug(f"REST request: {method} {url}")
+
+    def _log_response(self, method: str, url: str, status: int):
+        if self.logger:
+            self.logger.debug(f"REST response: {method} {url} {status}")
+
+    def _log_error(self, method: str, url: str, status: Optional[int], message: str):
+        if self.logger:
+            self.logger.error(f"REST request failed: {method} {url} {status} {message}")
+
+    def get(self, endpoint: str, **kwargs):
+        url = f"{self.base_url}{endpoint}"
+        self._log_request('GET', url)
+        try:
+            response = self.session.get(url, **kwargs)
+            self._log_response('GET', url, response.status_code)
+            return response
+        except Exception as e:
+            self._log_error('GET', url, None, str(e))
+            raise
+
+    def post(self, endpoint: str, data=None, json=None, **kwargs):
+        url = f"{self.base_url}{endpoint}"
+        self._log_request('POST', url)
+        try:
+            response = self.session.post(url, data=data, json=json, **kwargs)
+            self._log_response('POST', url, response.status_code)
+            return response
+        except Exception as e:
+            self._log_error('POST', url, None, str(e))
+            raise
+
+    def put(self, endpoint: str, data=None, json=None, **kwargs):
+        url = f"{self.base_url}{endpoint}"
+        self._log_request('PUT', url)
+        try:
+            response = self.session.put(url, data=data, json=json, **kwargs)
+            self._log_response('PUT', url, response.status_code)
+            return response
+        except Exception as e:
+            self._log_error('PUT', url, None, str(e))
+            raise
+
+    def patch(self, endpoint: str, data=None, json=None, **kwargs):
+        url = f"{self.base_url}{endpoint}"
+        self._log_request('PATCH', url)
+        try:
+            response = self.session.patch(url, data=data, json=json, **kwargs)
+            self._log_response('PATCH', url, response.status_code)
+            return response
+        except Exception as e:
+            self._log_error('PATCH', url, None, str(e))
+            raise
+
+    def delete(self, endpoint: str, **kwargs):
+        url = f"{self.base_url}{endpoint}"
+        self._log_request('DELETE', url)
+        try:
+            response = self.session.delete(url, **kwargs)
+            self._log_response('DELETE', url, response.status_code)
+            return response
+        except Exception as e:
+            self._log_error('DELETE', url, None, str(e))
+            raise

zyncedpy-1.0.3/zyncedpy/client/websocket_client.py

@@ -0,0 +1,83 @@
+import socketio
+from typing import Optional, Any
+from ..types import ClientLogger
+from ..events import TypedEmitter
+
+class WebSocketClient(TypedEmitter):
+    def __init__(self, cookies: str, logger: ClientLogger):
+        super().__init__()
+        self.cookies = cookies
+        self.logger = logger
+        self.socket: Optional[socketio.AsyncClient] = None
+        self._connected = False
+
+    async def connect(self):
+        self.socket = socketio.AsyncClient()
+
+        # Set up event handlers
+        @self.socket.on('connect')
+        async def on_connect():
+            self._connected = True
+            self.logger.info(f"WebSocket connected, socket ID: {self.socket.sid}")
+
+        @self.socket.on('disconnect')
+        async def on_disconnect():
+            self._connected = False
+            self.logger.info("WebSocket disconnected")
+
+        @self.socket.on('connect_error')
+        async def on_connect_error(err):
+            self.logger.error(f"WebSocket connection error: {err}")
+
+        @self.socket.on('*')
+        async def catch_all(event, data):
+            await self._handle_message(event, data)
+
+        # Connect with headers
+        await self.socket.connect(
+            'https://zynced.app',
+            transports=['websocket'],
+            headers={
+                'User-Agent': 'ZyncedPy/1.0',
+                'Accept': '*/*',
+                'Accept-Encoding': 'gzip, deflate, br, zstd',
+                'Origin': 'https://zynced.app',
+                'Connection': 'Upgrade',
+                'Cookie': self.cookies,
+                'Sec-Fetch-Dest': 'empty',
+                'Sec-Fetch-Mode': 'websocket',
+                'Sec-Fetch-Site': 'same-origin',
+                'Pragma': 'no-cache',
+                'Cache-Control': 'no-cache',
+                'Upgrade': 'websocket',
+            }
+        )
+
+    async def disconnect(self):
+        if self.socket:
+            await self.socket.disconnect()
+            self._connected = False
+
+    async def send(self, name: str, data: Any):
+        if self.socket and self._connected:
+            await self.socket.emit(name, data)
+            self.logger.info(f"WebSocket sent: {name} {data}")
+
+    async def _handle_message(self, event: str, payload: Any):
+        self.logger.info(f"WebSocket received: {event} {payload}")
+
+        if event == 'newMessage':
+            self.emit('privateMessageCreate', payload)
+        elif event == 'newChannelMessage':
+            self.emit('messageCreate', payload)
+        elif event == 'status-update':
+            if payload.get('type') == 'member_joined':
+                self.emit('memberJoined', payload)
+            elif payload.get('type') == 'member_left':
+                self.emit('memberLeft', payload)
+        elif event == 'invite-event':
+            if payload.get('type') == 'new_invite':
+                self.emit('userInvite', payload)
+        elif event == 'channelMessages':
+            # Internal event
+            self.emit('channelMessages', payload)

zyncedpy-1.0.3/zyncedpy/events/__init__.py

@@ -0,0 +1,3 @@
+from .event_emitter import TypedEmitter
+
+__all__ = ["TypedEmitter"]

zyncedpy-1.0.3/zyncedpy/events/event_emitter.py

@@ -0,0 +1,44 @@
+from typing import Dict, List, Callable, Any, Optional
+
+class TypedEmitter:
+    def __init__(self):
+        self._listeners: Dict[str, List[Callable]] = {}
+
+    def on(self, event: str, listener: Callable) -> 'TypedEmitter':
+        if event not in self._listeners:
+            self._listeners[event] = []
+        self._listeners[event].append(listener)
+        return self
+
+    def once(self, event: str, listener: Callable) -> 'TypedEmitter':
+        def wrapper(*args, **kwargs):
+            self.off(event, wrapper)
+            listener(*args, **kwargs)
+
+        self.on(event, wrapper)
+        return self
+
+    def emit(self, event: str, *args, **kwargs) -> bool:
+        if event in self._listeners:
+            for listener in self._listeners[event]:
+                try:
+                    listener(*args, **kwargs)
+                except Exception as e:
+                    print(f"Error in event listener for {event}: {e}")
+            return True
+        return False
+
+    def off(self, event: str, listener: Callable) -> 'TypedEmitter':
+        if event in self._listeners:
+            try:
+                self._listeners[event].remove(listener)
+            except ValueError:
+                pass
+        return self
+
+    def remove_all_listeners(self, event: Optional[str] = None) -> 'TypedEmitter':
+        if event:
+            self._listeners.pop(event, None)
+        else:
+            self._listeners.clear()
+        return self

zyncedpy-1.0.3/zyncedpy/events/handlers/__init__.py

@@ -0,0 +1,10 @@
+from .message_create import handle_message_create
+from .member_joined import handle_member_joined
+from .member_left import handle_member_left
+from .user_invite import handle_user_invite
+from .private_message_create import handle_private_message_create
+
+__all__ = [
+    "handle_message_create", "handle_member_joined", 
+    "handle_member_left", "handle_user_invite", "handle_private_message_create"
+]

zyncedpy-1.0.3/zyncedpy/events/handlers/member_joined.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...client import Client
+from ...types import RawMemberAction
+
+def handle_member_joined(client: 'Client', data: RawMemberAction):
+    client.emit('memberJoined', data)

zyncedpy-1.0.3/zyncedpy/events/handlers/member_left.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...client import Client
+from ...types import RawMemberAction
+
+def handle_member_left(client: 'Client', data: RawMemberAction):
+    client.emit('memberLeft', data)

zyncedpy-1.0.3/zyncedpy/events/handlers/message_create.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...client import Client
+from ...structures import Message
+
+def handle_message_create(client: 'Client', data):
+    client.emit('messageCreate', Message(client, data))

zyncedpy-1.0.3/zyncedpy/events/handlers/private_message_create.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...client import Client
+from ...structures import PrivateMessage
+
+def handle_private_message_create(client: 'Client', data):
+    client.emit('privateMessageCreate', PrivateMessage(client, data))

zyncedpy-1.0.3/zyncedpy/events/handlers/user_invite.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...client import Client
+from ...types import RawUserInvite
+
+def handle_user_invite(client: 'Client', data: RawUserInvite):
+    client.emit('userInvite', data)

zyncedpy-1.0.3/zyncedpy/managers/__init__.py

@@ -0,0 +1,5 @@
+from .base_manager import BaseManager
+from .channel_manager import ChannelManager
+from .guild_manager import GuildManager
+
+__all__ = ["BaseManager", "ChannelManager", "GuildManager"]

zyncedpy-1.0.3/zyncedpy/managers/base_manager.py

@@ -0,0 +1,42 @@
+from typing import Dict, Iterator, List, Optional, TypeVar, Generic, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+T = TypeVar('T')
+
+class BaseManager(Generic[T]):
+    def __init__(self, client: 'Client'):
+        self.cache: Dict[str, T] = {}
+        self.client = client
+
+    def resolve(self, id: str) -> Optional[T]:
+        return self.cache.get(id)
+
+    def get(self, id: str) -> T:
+        entity = self.resolve(id)
+        if entity is None:
+            raise ValueError(f"Entity {id} not in cache")
+        return entity
+
+    def has(self, id: str) -> bool:
+        return id in self.cache
+
+    @property
+    def size(self) -> int:
+        return len(self.cache)
+
+    def values(self) -> Iterator[T]:
+        return iter(self.cache.values())
+
+    def find(self, fn) -> Optional[T]:
+        for entity in self.cache.values():
+            if fn(entity):
+                return entity
+        return None
+
+    def filter(self, fn) -> List[T]:
+        return [entity for entity in self.cache.values() if fn(entity)]
+
+    def _add(self, data) -> T:
+        raise NotImplementedError

zyncedpy-1.0.3/zyncedpy/managers/channel_manager.py

@@ -0,0 +1,18 @@
+from typing import Optional
+from .base_manager import BaseManager
+from ..structures import Channel, RawChannel
+
+class ChannelManager(BaseManager[Channel]):
+    def _add(self, data: RawChannel) -> Channel:
+        if self.has(data.id):
+            return self.cache[data.id]
+
+        channel = Channel(self.client, data)
+        self.cache[channel.id] = channel
+        return channel
+
+    def find_one_by_name(self, name: str) -> Optional[Channel]:
+        return self.find(lambda channel: channel.name == name)
+
+    def find_all_by_name(self, name: str) -> list[Channel]:
+        return self.filter(lambda channel: channel.name == name)

zyncedpy-1.0.3/zyncedpy/managers/guild_manager.py

@@ -0,0 +1,11 @@
+from .base_manager import BaseManager
+from ..structures import Guild, RawChannel
+
+class GuildManager(BaseManager[Guild]):
+    def _add(self, data: RawChannel) -> Guild:
+        if self.has(data.id):
+            return self.cache[data.id]
+
+        guild = Guild(self.client, data)
+        self.cache[guild.id] = guild
+        return guild

zyncedpy-1.0.3/zyncedpy/structures/__init__.py

@@ -0,0 +1,12 @@
+from .base import Base
+from .base_channel import BaseChannel, RawChannel
+from .channel import Channel
+from .client_user import ClientUser, RawClientUser
+from .guild import Guild
+from .message import Message
+from .private_message import PrivateMessage
+
+__all__ = [
+    "Base", "BaseChannel", "RawChannel", "Channel",
+    "ClientUser", "RawClientUser", "Guild", "Message", "PrivateMessage"
+]

zyncedpy-1.0.3/zyncedpy/structures/base.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+class Base:
+    def __init__(self, client: 'Client'):
+        self.client = client

zyncedpy-1.0.3/zyncedpy/structures/base_channel.py

@@ -0,0 +1,44 @@
+from typing import Optional, TYPE_CHECKING
+from dataclasses import dataclass
+from .base import Base
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+@dataclass
+class RawChannel:
+    id: str
+    name: str
+    description: str
+    group_id: Optional[str]
+    category_id: Optional[str]
+    position: Optional[int]
+    relative_to_category: Optional[str]
+    created_at: str
+    blocked: bool
+    avatar: str
+    accept_joins: bool
+    type: str  # 'text' | 'voice'
+    owner: str
+    user_joined_at: str
+    lastMessageAt: int
+
+class BaseChannel(Base):
+    def __init__(self, client: 'Client', data: RawChannel):
+        super().__init__(client)
+
+        self.id = data.id
+        self.name = data.name
+        self.group_id = data.group_id
+        self.description = data.description
+        self.category_id = data.category_id
+        self.position = data.position
+        self.relative_to_category = data.relative_to_category
+        self.created_at = data.created_at
+        self.blocked = data.blocked
+        self.avatar = data.avatar
+        self.accept_joins = data.accept_joins
+        self.type = data.type
+        self.owner = data.owner
+        self.user_joined_at = data.user_joined_at
+        self.last_message_at = data.lastMessageAt

zyncedpy-1.0.3/zyncedpy/structures/channel.py

@@ -0,0 +1,123 @@
+import base64
+import mimetypes
+import os
+from typing import List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import Client
+    from ..types import MessageAttachment
+
+from .base_channel import BaseChannel, RawChannel
+from .message import Message
+
+class Channel(BaseChannel):
+    def __init__(self, client: 'Client', data: RawChannel):
+        super().__init__(client, data)
+        self.messages: List[Message] = []
+
+    def _set_messages(self, raw_messages: list):
+        self.messages.clear()
+        for msg in raw_messages:
+            self.messages.append(Message(self.client, msg))
+
+    def _add_message(self, message: Message) -> int:
+        self.messages.append(message)
+        return len(self.messages)
+
+    async def subscribe(self):
+        await self.client.get_ws().send('syncChannelRooms', [self.id])
+
+        def handler(data):
+            if data.get('channelId') != self.id:
+                return
+
+            self.client.get_ws().off('channelMessages', handler)
+            self._set_messages(data.get('messages', []))
+
+        self.client.get_ws().on('channelMessages', handler)
+        await self.client.get_ws().send('getChannelMessages', [self.id, {
+            "channelId": self.id,
+            "_t": int(__import__('time').time() * 1000)
+        }])
+
+    async def send(self, message: str, attachments: Optional[List] = None):
+        if attachments is None:
+            attachments = []
+
+        if message:
+            await self.client.get_ws().send('sendChannelMessage', {
+                "channelId": self.id,
+                "message": {
+                    "text": message,
+                    "from": self.client.user.username if self.client.user else None,
+                },
+            })
+
+        for attachment in attachments:
+            if attachment.type == 'gif':
+                await self._send_gif(attachment.url)
+            else:
+                await self._send_file(attachment.url)
+
+        return self
+
+    async def reply(self, message: str, attachments: Optional[List], reply_to_index: int, reply_author: str, reply_text: str):
+        if attachments is None:
+            attachments = []
+
+        await self.client.get_ws().send('sendChannelMessage', {
+            "channelId": self.id,
+            "message": {
+                "text": message,
+                "from": self.client.user.username if self.client.user else None,
+                "reply_to_index": reply_to_index,
+                "reply_author": reply_author,
+                "reply_text": reply_text
+            },
+        })
+
+        for attachment in attachments:
+            if attachment.type == 'gif':
+                await self._send_gif(attachment.url)
+            else:
+                await self._send_file(attachment.url)
+
+        return self
+
+    async def _send_gif(self, url: str):
+        await self.client.get_ws().send('sendChannelMessage', {
+            "channelId": self.id,
+            "message": {
+                "text": __import__('json').dumps({
+                    "text": '',
+                    "messageType": 'gif-link',
+                    "gifUrl": url,
+                    "sender": self.client.user.username if self.client.user else None,
+                }),
+                "from": self.client.user.username if self.client.user else None,
+            },
+        })
+        return self
+
+    async def _send_file(self, file_path: str):
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        file_name = os.path.basename(file_path)
+
+        with open(file_path, 'rb') as f:
+            file_buffer = f.read()
+
+        file_base64 = base64.b64encode(file_buffer).decode('utf-8')
+        mime_type = mimetypes.guess_type(file_path)[0] or 'application/octet-stream'
+
+        data = {
+            "channelId": self.id,
+            "text": '',
+            "fileName": file_name,
+            "mimeType": mime_type,
+            "fileBase64": file_base64,
+        }
+
+        await self.client.get_ws().send('uploadChannelMessageFile', data)
+        return self

zyncedpy-1.0.3/zyncedpy/structures/client_user.py

@@ -0,0 +1,51 @@
+from typing import Optional, TYPE_CHECKING
+from dataclasses import dataclass
+from .base import Base
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+@dataclass
+class RawClientUser:
+    userId: str
+    username: str
+    avatar: str
+    status: str
+    bannerUrl: str
+    onlineStatus: str
+    isPremium: bool
+
+class ClientUser(Base):
+    def __init__(self, client: 'Client', data: Optional[RawClientUser] = None):
+        super().__init__(client)
+        self.id = data.userId if data else ''
+        self.username = data.username if data else ''
+        self.avatar = data.avatar if data else ''
+        self.status = data.status if data else ''
+        self.banner_url = data.bannerUrl if data else ''
+        self.online_status = data.onlineStatus if data else ''
+        self.is_premium = data.isPremium if data else False
+
+    def _patch(self, data: dict):
+        if 'userId' in data:
+            self.id = data['userId']
+        if 'username' in data:
+            self.username = data['username']
+        if 'avatar' in data:
+            self.avatar = data['avatar']
+        if 'status' in data:
+            self.status = data['status']
+        if 'bannerUrl' in data:
+            self.banner_url = data['bannerUrl']
+        if 'onlineStatus' in data:
+            self.online_status = data['onlineStatus']
+        if 'isPremium' in data:
+            self.is_premium = data['isPremium']
+        return self
+
+    async def set_status(self, status: str):
+        await self.client.get_ws().send('updateProfileStatus', {'status': status})
+        self.status = status
+
+    def __str__(self):
+        return f"{self.username}#{self.id}"

zyncedpy-1.0.3/zyncedpy/structures/guild.py

@@ -0,0 +1,6 @@
+from .base_channel import BaseChannel
+
+class Guild(BaseChannel):
+    async def leave(self, id: str):
+        res = await self.client.get_rest().post(f'/channels/leave/{id}')
+        return res.json()

zyncedpy-1.0.3/zyncedpy/structures/message.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+from typing import Optional, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import Client
+    from ..types import MessageAttachment
+
+class Message:
+    def __init__(self, client: 'Client', data: dict):
+        self._client = client
+
+        channel = self._client.channel(data['channelId'])
+        self.id = channel._add_message(self)
+        self.guild_id = data.get('groupId')
+        self.channel_id = data['channelId']
+        self.content = data['message']['text']
+        self.author = data['message']['from']
+        self.date = datetime.fromisoformat(data['message']['date'].replace('Z', '+00:00'))
+        self.is_reply = bool(data['message'].get('reply_to_index'))
+
+    def reply(self, content: str, attachments: Optional[List] = None):
+        if attachments is None:
+            attachments = []
+        channel = self._client.channel(self.channel_id)
+        if channel:
+            channel.reply(content, attachments, self.id, self.author, self.content)

zyncedpy-1.0.3/zyncedpy/structures/private_message.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import Client
+
+class PrivateMessage:
+    def __init__(self, client: 'Client', data: dict):
+        self._client = client
+
+        self.chatmode = data['message']['chatmode']
+        self.content = data['message']['text']
+        self.author = data['from']
+        self.date = datetime.fromisoformat(data['message']['timestamp'].replace('Z', '+00:00'))

zyncedpy-1.0.3/zyncedpy/types.py

@@ -0,0 +1,55 @@
+from typing import Optional, Union, Dict, Any, Protocol
+import logging
+
+class ClientLogger(Protocol):
+    def debug(self, message: str, *args, **kwargs) -> None: ...
+    def info(self, message: str, *args, **kwargs) -> None: ...
+    def warn(self, message: str, *args, **kwargs) -> None: ...
+    def error(self, message: str, *args, **kwargs) -> None: ...
+
+ClientLoggerOption = Union[bool, ClientLogger, Dict[str, Any]]
+
+class ClientOptions:
+    def __init__(self, logger: Optional[ClientLoggerOption] = None):
+        self.logger = logger
+
+# Event types
+class RawMemberAction:
+    def __init__(self, username: str, channelId: str):
+        self.username = username
+        self.channel_id = channelId
+
+class RawSfuCapabilities:
+    def __init__(self, codecs: list, headerExtensions: list):
+        self.codecs = codecs
+        self.header_extensions = headerExtensions
+
+class RawUserInvite:
+    def __init__(self, type: str, inviteId: str, channelId: str, inviterUsername: str):
+        self.type = type
+        self.invite_id = inviteId
+        self.channel_id = channelId
+        self.inviter_username = inviterUsername
+
+# Message attachment types
+MessageType = str  # 'gif' | 'file'
+
+class MessageAttachment:
+    def __init__(self, type: MessageType, url: str, name: Optional[str] = None):
+        self.type = type
+        self.url = url
+        self.name = name
+
+# Event data types
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .structures import ClientUser, Message, PrivateMessage
+    from .managers import ChannelManager, GuildManager
+
+class ClientEvents:
+    ready: Dict[str, Any]  # {'user': ClientUser, 'channels': ChannelManager, 'guilds': GuildManager}
+    messageCreate: 'Message'
+    privateMessageCreate: 'PrivateMessage'
+    memberJoined: RawMemberAction
+    memberLeft: RawMemberAction
+    userInvite: RawUserInvite

zyncedpy-1.0.3/zyncedpy/utils/__init__.py

@@ -0,0 +1,3 @@
+from .logger import resolve_logger
+
+__all__ = ["resolve_logger"]

zyncedpy-1.0.3/zyncedpy/utils/logger.py

@@ -0,0 +1,52 @@
+import logging
+from typing import Optional, Union, Dict, Any
+from ..types import ClientLogger, ClientLoggerOption
+
+def noop(*args, **kwargs):
+    pass
+
+silent_logger = type('SilentLogger', (), {
+    'debug': noop,
+    'info': noop,
+    'warn': noop,
+    'error': noop,
+})()
+
+def is_logger_like(value: Any) -> bool:
+    return (
+        hasattr(value, 'debug') and callable(getattr(value, 'debug')) and
+        hasattr(value, 'info') and callable(getattr(value, 'info')) and
+        hasattr(value, 'warn') and callable(getattr(value, 'warn')) and
+        hasattr(value, 'error') and callable(getattr(value, 'error'))
+    )
+
+def resolve_logger(logger: Optional[ClientLoggerOption] = None) -> ClientLogger:
+    if logger is False or logger is None:
+        return silent_logger
+
+    if logger is True:
+        logger_instance = logging.getLogger('zyncedpy')
+        logger_instance.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
+        handler.setFormatter(formatter)
+        logger_instance.addHandler(handler)
+        return logger_instance
+
+    if is_logger_like(logger):
+        return logger
+
+    # If it's a dict, assume it's logging config
+    if isinstance(logger, dict):
+        logger_instance = logging.getLogger('zyncedpy')
+        logger_instance.setLevel(logger.get('level', logging.DEBUG))
+        handler = logging.StreamHandler()
+        if 'format' in logger:
+            formatter = logging.Formatter(logger['format'])
+        else:
+            formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
+        handler.setFormatter(formatter)
+        logger_instance.addHandler(handler)
+        return logger_instance
+
+    return silent_logger

zyncedpy-1.0.3/zyncedpy.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: zyncedpy
+Version: 1.0.3
+Summary: ZyncedPy is a Python module that allows you to create bots for Zynced chat platform.
+Home-page: https://github.com/Emsa001/zyncedpy
+Author: Emanuel Scura
+License: MIT
+Keywords: sdk,bot,websocket,api,chat,zynced
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-socketio>=5.0.0
+Requires-Dist: python-engineio>=4.0.0
+Requires-Dist: dataclasses-json>=0.5.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ZyncedPy
+
+ZyncedPy is a Python module that allows you to create bots for Zynced chat platform.
+
+## Installation
+
+```bash
+pip install zyncedpy
+```
+
+## Usage
+
+```python
+from zyncedpy import Client
+
+client = Client("your_token_here")
+
+@client.on("ready")
+def on_ready(data):
+    print(f"Bot is ready! Logged in as {data['user'].username}")
+
+@client.on("messageCreate")
+def on_message(message):
+    if message.content == "!ping":
+        message.reply("Pong!")
+
+client.login()
+```
+
+## Features
+
+- WebSocket and REST API support
+- Event-driven architecture
+- Channel and guild management
+- Message handling
+- User management
+- Invite system
+
+## License
+
+MIT

zyncedpy-1.0.3/zyncedpy.egg-info/SOURCES.txt

@@ -0,0 +1,36 @@
+README.md
+setup.py
+zyncedpy/__init__.py
+zyncedpy/types.py
+zyncedpy.egg-info/PKG-INFO
+zyncedpy.egg-info/SOURCES.txt
+zyncedpy.egg-info/dependency_links.txt
+zyncedpy.egg-info/requires.txt
+zyncedpy.egg-info/top_level.txt
+zyncedpy/client/__init__.py
+zyncedpy/client/base_client.py
+zyncedpy/client/client.py
+zyncedpy/client/rest_client.py
+zyncedpy/client/websocket_client.py
+zyncedpy/events/__init__.py
+zyncedpy/events/event_emitter.py
+zyncedpy/events/handlers/__init__.py
+zyncedpy/events/handlers/member_joined.py
+zyncedpy/events/handlers/member_left.py
+zyncedpy/events/handlers/message_create.py
+zyncedpy/events/handlers/private_message_create.py
+zyncedpy/events/handlers/user_invite.py
+zyncedpy/managers/__init__.py
+zyncedpy/managers/base_manager.py
+zyncedpy/managers/channel_manager.py
+zyncedpy/managers/guild_manager.py
+zyncedpy/structures/__init__.py
+zyncedpy/structures/base.py
+zyncedpy/structures/base_channel.py
+zyncedpy/structures/channel.py
+zyncedpy/structures/client_user.py
+zyncedpy/structures/guild.py
+zyncedpy/structures/message.py
+zyncedpy/structures/private_message.py
+zyncedpy/utils/__init__.py
+zyncedpy/utils/logger.py

zyncedpy-1.0.3/zyncedpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zyncedpy-1.0.3/zyncedpy.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests>=2.25.0
+python-socketio>=5.0.0
+python-engineio>=4.0.0
+dataclasses-json>=0.5.0

zyncedpy-1.0.3/zyncedpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+zyncedpy