pyurt-pro 3.1.1__py3-none-any.whl

pyurt_pro/__init__.py

@@ -0,0 +1,23 @@
+"""
+PyURT Pro – расширенная версия с кластеризацией, очередями, RPC и JWT.
+"""
+
+from pyurt_pro.core.protocol import ExtendedProtocol, MessageTypes
+from pyurt_pro.cluster.node import ClusterNode, ClusterServer
+from pyurt_pro.mq.broker import RedisBroker
+from pyurt_pro.rpc.server import RPCServer, rpc_method
+from pyurt_pro.auth.jwt import JWTManager
+from pyurt_pro.config import load_config, get_config
+
+__all__ = [
+    "ExtendedProtocol",
+    "MessageTypes",
+    "ClusterNode",
+    "ClusterServer",
+    "RedisBroker",
+    "RPCServer",
+    "rpc_method",
+    "JWTManager",
+    "load_config",
+    "get_config",
+]

pyurt_pro/auth/jwt.py

@@ -0,0 +1,24 @@
+import jwt
+import time
+from typing import Optional
+from pyurt_pro.config import get_config
+
+class JWTManager:
+    @staticmethod
+    def get_secret_key() -> str:
+        return get_config()['auth']['secret_key']
+
+    @classmethod
+    def generate_token(cls, user_id: str, expires_in: int = None) -> str:
+        if expires_in is None:
+            expires_in = get_config()['auth'].get('expires_in', 3600)
+        payload = {"user_id": user_id, "exp": time.time() + expires_in}
+        return jwt.encode(payload, cls.get_secret_key(), algorithm="HS256")
+
+    @classmethod
+    def verify_token(cls, token: str) -> Optional[str]:
+        try:
+            payload = jwt.decode(token, cls.get_secret_key(), algorithms=["HS256"])
+            return payload.get("user_id")
+        except jwt.InvalidTokenError:
+            return None

pyurt_pro/cli.py

@@ -0,0 +1,20 @@
+import sys
+import argparse
+from pyurt_pro.config import load_config
+from pyurt_pro.cluster.node import ClusterNode
+
+def main():
+    parser = argparse.ArgumentParser(description="PyURT Pro Cluster Node")
+    parser.add_argument("-c", "--config", default="config.yaml", help="Path to YAML config")
+    args = parser.parse_args()
+
+    load_config(args.config)
+    node = ClusterNode()
+    try:
+        node.start()
+    except KeyboardInterrupt:
+        node.stop()
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

pyurt_pro/cluster/node.py

@@ -0,0 +1,80 @@
+import asyncio
+import json
+import threading
+import time
+import redis
+from typing import Any
+from pyurt import PyURTServer
+from pyurt_pro.core.protocol import ExtendedProtocol, MessageTypes
+from pyurt_pro.config import get_config
+
+class ClusterServer(PyURTServer):
+    def __init__(self, node: 'ClusterNode'):
+        super().__init__()
+        self.node = node
+
+    async def handle_client(self, reader, writer):
+        while True:
+            try:
+                msg_type, payload = await ExtendedProtocol.read(reader)
+                if msg_type == 0:
+                    break
+                if msg_type == MessageTypes.CLUSTER_JOIN:
+                    data = json.loads(payload)
+                    self.node.peers.add((data['host'], data['port']))
+                    writer.write(ExtendedProtocol.build(b'OK', MessageTypes.ACK))
+                    await writer.drain()
+                elif msg_type == MessageTypes.CLUSTER_PING:
+                    writer.write(ExtendedProtocol.build(b'PONG', MessageTypes.ACK))
+                    await writer.drain()
+                else:
+                    writer.write(ExtendedProtocol.build(b'NACK', MessageTypes.NACK))
+                    await writer.drain()
+            except Exception:
+                break
+        writer.close()
+        await writer.wait_closed()
+
+class ClusterNode:
+    def __init__(self):
+        config = get_config()['cluster']
+        self.host = config['host']
+        self.port = config['port']
+        self.seed_nodes = config['seed_nodes']
+        self.redis_url = config['redis_url']
+        self.max_size = config['max_size']
+        self.redis = redis.from_url(self.redis_url)
+        self.peers = set()
+        self.running = False
+        self.server = None
+        self._loop = None
+
+    def start(self):
+        self.running = True
+        self._register_node()
+        self.server = ClusterServer(self)
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_until_complete(self.server.run())
+
+    def _register_node(self):
+        self.redis.sadd("pyurt:cluster:nodes", f"{self.host}:{self.port}")
+        self.redis.expire("pyurt:cluster:nodes", 60)
+        threading.Thread(target=self._heartbeat_loop, daemon=True).start()
+
+    def _heartbeat_loop(self):
+        while self.running:
+            self.redis.sadd("pyurt:cluster:nodes", f"{self.host}:{self.port}")
+            self.redis.expire("pyurt:cluster:nodes", 30)
+            all_nodes = self.redis.smembers("pyurt:cluster:nodes")
+            self.peers = {node.decode() for node in all_nodes if node.decode() != f"{self.host}:{self.port}"}
+            time.sleep(10)
+
+    def broadcast(self, data: Any):
+        self.redis.publish("pyurt:cluster:broadcast", json.dumps(data))
+
+    def stop(self):
+        self.running = False
+        self.redis.srem("pyurt:cluster:nodes", f"{self.host}:{self.port}")
+        if self.server and self._loop:
+            asyncio.run_coroutine_threadsafe(self.server.close(), self._loop)

pyurt_pro/config.py

@@ -0,0 +1,56 @@
+import os
+import yaml
+from typing import Dict, Any
+
+DEFAULT_CONFIG = {
+    "cluster": {
+        "host": "0.0.0.0",
+        "port": 8888,
+        "seed_nodes": [],
+        "redis_url": "redis://localhost:6379/0",
+        "max_size": 1048576,
+    },
+    "mq": {
+        "persistent": True,
+        "max_messages": 1000,
+    },
+    "rpc": {
+        "enable_ssl": False,
+    },
+    "auth": {
+        "secret_key": "change-me-in-production",
+        "expires_in": 3600,
+    },
+}
+
+_config = None
+
+def load_config(config_path: str = None) -> Dict[str, Any]:
+    global _config
+    if _config is not None:
+        return _config
+    if config_path is None:
+        config_path = os.environ.get("PYURT_PRO_CONFIG", "config.yaml")
+    try:
+        with open(config_path, 'r') as f:
+            user_config = yaml.safe_load(f) or {}
+    except FileNotFoundError:
+        user_config = {}
+    merged = _deep_merge(DEFAULT_CONFIG, user_config)
+    _config = merged
+    return merged
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+def get_config() -> Dict[str, Any]:
+    global _config
+    if _config is None:
+        load_config()
+    return _config

pyurt_pro/core/protocol.py

@@ -0,0 +1,51 @@
+import enum
+import struct
+import zlib
+import asyncio
+from typing import Tuple, Optional
+from pyurt import Protocol
+from pyurt_pro.config import get_config
+
+class MessageTypes(enum.IntEnum):
+    DATA = 1
+    ACK = 2
+    NACK = 3
+    RPC_REQUEST = 100
+    RPC_RESPONSE = 101
+    MQ_PUBLISH = 200
+    MQ_SUBSCRIBE = 201
+    MQ_UNSUBSCRIBE = 202
+    MQ_DELIVER = 203
+    CLUSTER_JOIN = 300
+    CLUSTER_LEAVE = 301
+    CLUSTER_SYNC = 302
+    CLUSTER_PING = 303
+    AUTH_TOKEN = 400
+    AUTH_CHALLENGE = 401
+    AUTH_RESPONSE = 402
+
+class ExtendedProtocol(Protocol):
+    HEADER_SIZE = 9
+
+    @staticmethod
+    def build(payload: bytes, msg_type: int = MessageTypes.DATA) -> bytes:
+        crc = zlib.crc32(payload) & 0xFFFFFFFF
+        header = struct.pack('!BII', msg_type, len(payload), crc)
+        return header + payload
+
+    @staticmethod
+    async def read(reader, timeout: float = 30.0) -> Tuple[int, Optional[bytes]]:
+        try:
+            raw_header = await asyncio.wait_for(reader.readexactly(ExtendedProtocol.HEADER_SIZE), timeout)
+        except asyncio.IncompleteReadError:
+            return 0, None
+        except asyncio.TimeoutError:
+            raise ValueError("Timeout reading header")
+        msg_type, length, crc = struct.unpack('!BII', raw_header)
+        max_size = get_config()['cluster']['max_size']
+        if length > max_size:
+            raise ValueError(f"Message too large: {length}")
+        payload = await asyncio.wait_for(reader.readexactly(length), timeout)
+        if zlib.crc32(payload) & 0xFFFFFFFF != crc:
+            raise ValueError("CRC mismatch")
+        return msg_type, payload

pyurt_pro/mq/broker.py

@@ -0,0 +1,38 @@
+import json
+import redis
+from typing import Any, Callable
+from pyurt_pro.config import get_config
+
+class RedisBroker:
+    def __init__(self):
+        config = get_config()['mq']
+        self.redis_url = get_config()['cluster']['redis_url']
+        self.redis = redis.from_url(self.redis_url)
+        self.pubsub = self.redis.pubsub()
+        self._subscriptions = {}
+        self.persistent = config.get('persistent', True)
+        self.max_messages = config.get('max_messages', 1000)
+
+    def publish(self, topic: str, message: Any, persistent: bool = None):
+        if persistent is None:
+            persistent = self.persistent
+        data = {"payload": message, "persistent": persistent}
+        self.redis.publish(f"pyurt:mq:{topic}", json.dumps(data))
+        if persistent:
+            self.redis.rpush(f"pyurt:mq:{topic}:history", json.dumps(message))
+            self.redis.ltrim(f"pyurt:mq:{topic}:history", -self.max_messages, -1)
+
+    def subscribe(self, topic: str, callback: Callable):
+        if topic not in self._subscriptions:
+            self.pubsub.subscribe(f"pyurt:mq:{topic}")
+            self._subscriptions[topic] = callback
+            import threading
+            def listener():
+                for msg in self.pubsub.listen():
+                    if msg['type'] == 'message':
+                        data = json.loads(msg['data'])
+                        callback(data['payload'])
+            threading.Thread(target=listener, daemon=True).start()
+
+    def get_history(self, topic: str, limit: int = 10) -> list:
+        return [json.loads(item) for item in self.redis.lrange(f"pyurt:mq:{topic}:history", -limit, -1)]

pyurt_pro/rpc/server.py

@@ -0,0 +1,43 @@
+import json
+from typing import Dict, Callable
+from pyurt import PyURTServer
+from pyurt_pro.core.protocol import ExtendedProtocol, MessageTypes
+
+class RPCServer(PyURTServer):
+    def __init__(self):
+        super().__init__()
+        self.methods: Dict[str, Callable] = {}
+
+    def register(self, name: str, func: Callable):
+        self.methods[name] = func
+
+    async def handle_client(self, reader, writer):
+        while True:
+            try:
+                msg_type, payload = await ExtendedProtocol.read(reader, timeout=30.0)
+                if msg_type == 0:
+                    break
+                if msg_type == MessageTypes.RPC_REQUEST:
+                    data = json.loads(payload)
+                    method_name = data.get("method")
+                    params = data.get("params", [])
+                    if method_name in self.methods:
+                        result = self.methods[method_name](*params)
+                        response = {"id": data.get("id"), "result": result, "error": None}
+                    else:
+                        response = {"id": data.get("id"), "result": None, "error": "Method not found"}
+                    writer.write(ExtendedProtocol.build(json.dumps(response).encode(), MessageTypes.RPC_RESPONSE))
+                    await writer.drain()
+                else:
+                    writer.write(ExtendedProtocol.build(b'NACK', MessageTypes.NACK))
+                    await writer.drain()
+            except Exception:
+                break
+        writer.close()
+        await writer.wait_closed()
+
+def rpc_method(name: str = None):
+    def decorator(func):
+        func._rpc_name = name or func.__name__
+        return func
+    return decorator

pyurt_pro-3.1.1.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: pyurt-pro
+Version: 3.1.1
+Summary: PyURT Pro – расширенный протокол с кластеризацией, очередями, RPC и JWT
+Author: HioDev
+License: MIT
+Keywords: pyurt,cluster,mq,rpc,jwt
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: pyurt>=3.1.0
+Requires-Dist: redis>=4.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: pyjwt>=2.0.0
+
+# PyURT Pro – расширенный протокол
+
+Добавляет кластеризацию, очереди сообщений, RPC и JWT-аутентификацию.
+
+## Установка
+
+```bash
+pip install pyurt-pro
+## Запуск
+# УСТАНОВИТЕ И ЗАПУСТИТЕ redis
+pyurt-pro -c config.yaml # Запуск 
+
+
+## В коде 
+from pyurt_pro import ClusterNode, RedisBroker, RPCServer, rpc_method
+
+# Кластер
+node = ClusterNode()
+node.start()
+
+# Очереди
+broker = RedisBroker()
+broker.publish("chat", "Hello, world!")
+
+# RPC
+@rpc_method("add")
+def add(a, b):
+    return a + b
+
+## Для запуска

pyurt_pro-3.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+pyurt_pro/__init__.py,sha256=ey8i70sjvdy0UUz91AO2DmtWIHqg-v5r4zQuAv0W-d0,654
+pyurt_pro/cli.py,sha256=gPpzGOk0Q1HrlxpE-0JVZ2faQV-eChe9x7dFqDKUwx4,520
+pyurt_pro/config.py,sha256=p9SxaQiOXfANFknh7hpPHg9VWs9XyLUKS8rKTKbXkxg,1419
+pyurt_pro/auth/jwt.py,sha256=tJVpaVn268oEGejTvAi11sC8eAYNy1oNQiJKhGg28h0,826
+pyurt_pro/cluster/node.py,sha256=jTdX3tleHKzsgjmr7WWnf407Cv-OI9ggGs3EcWkQ8T0,3026
+pyurt_pro/core/protocol.py,sha256=T0cps4tnwQiadpBFslSg2wnC-gFD1ys5HPOLqmMrEtM,1623
+pyurt_pro/mq/broker.py,sha256=M1-wqkmYHNpXnaL_bJnDW3NXHPiUAB6BIu8q2S06b_w,1648
+pyurt_pro/rpc/server.py,sha256=0Gzvyvo2xRDM_7zr_hzd2qAU8wbcrhyLVK01kwfnJs4,1703
+pyurt_pro-3.1.1.dist-info/METADATA,sha256=0rbP3FDVvlFZuj_PBO6kfKPpq8yqaqD3O6bEsjVtoMc,1442
+pyurt_pro-3.1.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pyurt_pro-3.1.1.dist-info/entry_points.txt,sha256=K1ndqExjHITXrgsDRxUQc8DZKc-esCIMqr3FT5-YYAo,49
+pyurt_pro-3.1.1.dist-info/top_level.txt,sha256=Zbt566bE_5KUXhLoAxf_8LsPT584MayWb_rd0LObh68,10
+pyurt_pro-3.1.1.dist-info/RECORD,,

pyurt_pro-3.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyurt_pro-3.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyurt-pro = pyurt_pro.cli:main

pyurt_pro-3.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyurt_pro