afterlink 2.0.0__tar.gz

afterlink-2.0.0/.gitignore

@@ -0,0 +1,31 @@
+node_modules/
+dist/
+.env
+*.log
+.DS_Store
+coverage/
+.agents/
+AfterLink-v1.1.0-Phase1-PRD.md
+
+# AI Assistant generated/binary data (large files not needed in source control)
+data/afterlink_index/
+data/feedback.json
+packages/ai-assistant/src/model-weights.json
+packages/ai-assistant/src/vocabulary.json
+
+# AI upgrade scratch work
+AI-upgrade/
+
+# Google site verification (auto-generated, not needed in source)
+googlee7e38f2aff23cac0.html
+
+# Throwaway test / scratch files
+test-proof.txt
+test-demos.js
+verify-features.js
+
+# AI agent internal lock file
+skills-lock.json
+
+# One-time publish utility (not needed by contributors)
+publish.ps1

afterlink-2.0.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: afterlink
+Version: 2.0.0
+Summary: AfterLink Protocol SDK - TCP client/server with routing, middleware, and pub/sub
+Author-email: Ajay Myth <ajaymyth@github.com>
+License-Expression: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: msgpack>=1.0.8
+Requires-Dist: pydantic>=2.0
+Provides-Extra: uvloop
+Requires-Dist: uvloop>=0.17.0; extra == 'uvloop'
+Description-Content-Type: text/markdown
+
+# AfterLink Python SDK
+
+Python Client and Server SDK for the binary AfterLink protocol.
+
+## Installation
+
+```bash
+pip install afterlink
+```
+
+## Usage
+
+### Server
+
+```python
+import asyncio
+from afterlink import Server
+
+server = Server(port=4000)
+
+@server.on("users/get")
+async def get_user(req):
+    return {"id": 1, "username": "ajay"}
+
+asyncio.run(server.listen())
+```
+
+### Client
+
+```python
+import asyncio
+from afterlink import Client
+
+async def main():
+    client = Client("tcp://localhost:4000")
+    await client.connect()
+    res = await client.request("users/get")
+    print(res)
+    await client.disconnect()
+
+asyncio.run(main())
+```

afterlink-2.0.0/README.md

@@ -0,0 +1,42 @@
+# AfterLink Python SDK
+
+Python Client and Server SDK for the binary AfterLink protocol.
+
+## Installation
+
+```bash
+pip install afterlink
+```
+
+## Usage
+
+### Server
+
+```python
+import asyncio
+from afterlink import Server
+
+server = Server(port=4000)
+
+@server.on("users/get")
+async def get_user(req):
+    return {"id": 1, "username": "ajay"}
+
+asyncio.run(server.listen())
+```
+
+### Client
+
+```python
+import asyncio
+from afterlink import Client
+
+async def main():
+    client = Client("tcp://localhost:4000")
+    await client.connect()
+    res = await client.request("users/get")
+    print(res)
+    await client.disconnect()
+
+asyncio.run(main())
+```

afterlink-2.0.0/afterlink/__init__.py

@@ -0,0 +1,6 @@
+from .client import Client
+from .server import Server
+from .errors import AfterLinkError
+from .sync import SyncClient
+
+__all__ = ["Client", "Server", "AfterLinkError", "SyncClient"]

afterlink-2.0.0/afterlink/client.py

@@ -0,0 +1,327 @@
+import asyncio
+import logging
+import random
+from typing import Callable, Any, AsyncGenerator
+
+from .errors import AfterLinkError
+from .protocol import frame, codec, compression
+
+logger = logging.getLogger("afterlink.client")
+
+class Client:
+    def __init__(self, url: str, options: dict = None):
+        self.url = url
+        self.options = options or {}
+        
+        self.host = self.options.get("host", "localhost")
+        self.port = self.options.get("port", 4000)
+        self.auto_reconnect = self.options.get("auto_reconnect", True)
+        self.reconnect_attempts = self.options.get("reconnect_attempts", 5)
+        self.reconnect_delay = self.options.get("reconnect_delay", 1.0)
+        self.timeout = self.options.get("timeout", 10.0)
+        self.auth_token = self.options.get("auth")
+        self.protocol_version = self.options.get("protocol", 2) 
+
+        self.reader = None
+        self.writer = None
+        self.connected = False
+        self.session_id = None
+        self.version = 1 
+
+        self._message_id = 0
+        self._pending_requests = {}
+        self._subscriptions = {}
+        self._read_task = None
+        self._is_closing = False
+        
+        if "://" in url:
+            parts = url.split("://")[1].split(":")
+            self.host = parts[0]
+            if len(parts) > 1:
+                self.port = int(parts[1])
+
+    async def connect(self):
+        self._is_closing = False
+        logger.info(f"Connecting to AfterLink server at {self.host}:{self.port}")
+        
+        self.reader, self.writer = await asyncio.open_connection(self.host, self.port)
+        self._read_task = asyncio.create_task(self._read_loop())
+        
+        await self._handshake()
+        self.connected = True
+        logger.info(f"Connected successfully. Session ID: {self.session_id}, Protocol: v{self.version}")
+
+    async def _handshake(self):
+        hello_payload = {
+            "version": f"AL/{self.protocol_version}",
+            "capabilities": ["json", "msgpack"],
+            "auth": self.auth_token
+        }
+        
+        msg_id = self._next_message_id()
+        payload_bytes = codec.serialize(hello_payload)
+        
+        frame_bytes = frame.encode_v1(frame.HELLO, 0, msg_id, payload_bytes)
+        self.writer.write(frame_bytes)
+        await self.writer.drain()
+        
+        fut = asyncio.get_running_loop().create_future()
+        self._pending_requests[msg_id] = fut
+        
+        try:
+            ack_frame = await asyncio.wait_for(fut, timeout=self.timeout)
+            ack_data = codec.deserialize(ack_frame["payload"])
+            
+            if ack_frame["type"] == frame.ERROR:
+                raise AfterLinkError(ack_data.get("code", 1), ack_data.get("message", "Handshake failed"))
+                
+            self.session_id = ack_data.get("session_id")
+            accepted_proto = ack_data.get("accepted_protocol", "v1")
+            self.version = 2 if accepted_proto == "v2" else 1
+        except asyncio.TimeoutError:
+            raise AfterLinkError(AfterLinkError.CONNECTION_TIMEOUT, "Handshake timed out")
+        finally:
+            self._pending_requests.pop(msg_id, None)
+
+    def _next_message_id(self) -> int:
+        self._message_id = (self._message_id + 1) & 0xFFFFFFFF
+        return self._message_id
+
+    async def request(self, route: str, body: Any = None, *, routing_key: str = None, priority: int = None) -> Any:
+        if not self.connected:
+            raise AfterLinkError(AfterLinkError.CONNECTION_CLOSED, "Client not connected")
+            
+        req_payload = {
+            "route": route,
+            "body": body or {}
+        }
+        
+        msg_id = self._next_message_id()
+        payload_bytes = codec.serialize(req_payload)
+        
+        payload_bytes, compressed = compression.compress(payload_bytes)
+        flags = compression.FLAGS_COMPRESSED if compressed else 0
+        
+        if self.version == 2:
+            frame_bytes = frame.encode_v2(
+                frame.REQUEST, flags, msg_id, payload_bytes,
+                priority=priority if priority is not None else 3,
+                routing_key=routing_key or ''
+            )
+        else:
+            frame_bytes = frame.encode_v1(frame.REQUEST, flags, msg_id, payload_bytes)
+            
+        self.writer.write(frame_bytes)
+        await self.writer.drain()
+        
+        fut = asyncio.get_running_loop().create_future()
+        self._pending_requests[msg_id] = fut
+        
+        try:
+            res_frame = await asyncio.wait_for(fut, timeout=self.timeout)
+            
+            res_flags = res_frame["flags"]
+            res_payload = res_frame["payload"]
+            
+            if res_flags & compression.FLAGS_COMPRESSED:
+                res_payload = compression.decompress(res_payload)
+                
+            res_data = codec.deserialize(res_payload)
+            
+            if res_frame["type"] == frame.ERROR:
+                raise AfterLinkError(
+                    res_data.get("code", 10),
+                    res_data.get("message", "Request failed"),
+                    details=res_data.get("details"),
+                    retry_after=res_data.get("retry_after"),
+                    meta=res_data.get("meta")
+                )
+                
+            return res_data.get("body")
+        finally:
+            self._pending_requests.pop(msg_id, None)
+
+    async def subscribe(self, topic: str, callback: Callable[[Any], None]) -> Callable[[], None]:
+        if not self.connected:
+            raise AfterLinkError(AfterLinkError.CONNECTION_CLOSED, "Client not connected")
+            
+        await self.request("pubsub/subscribe", {"topic": topic})
+        
+        if topic not in self._subscriptions:
+            self._subscriptions[topic] = set()
+        self._subscriptions[topic].add(callback)
+        
+        async def unsubscribe():
+            if topic in self._subscriptions:
+                self._subscriptions[topic].discard(callback)
+                if len(self._subscriptions[topic]) == 0:
+                    del self._subscriptions[topic]
+                    try:
+                        await self.request("pubsub/unsubscribe", {"topic": topic})
+                    except Exception:
+                        pass
+        return unsubscribe
+
+    async def publish(self, topic: str, data: Any):
+        if not self.connected:
+            raise AfterLinkError(AfterLinkError.CONNECTION_CLOSED, "Client not connected")
+        await self.request("pubsub/publish", {"topic": topic, "data": data})
+
+    async def stream(self, route: str, body: Any = None) -> AsyncGenerator[Any, None]:
+        if not self.connected:
+            raise AfterLinkError(AfterLinkError.CONNECTION_CLOSED, "Client not connected")
+        
+        req_payload = {
+            "route": route,
+            "body": body or {}
+        }
+        msg_id = self._next_message_id()
+        payload_bytes = codec.serialize(req_payload)
+        
+        # STREAM_START
+        start_frame = frame.encode(
+            version=self.version,
+            frame_type=frame.STREAM_START,
+            flags=0,
+            message_id=msg_id,
+            payload_bytes=payload_bytes
+        )
+        self.writer.write(start_frame)
+        await self.writer.drain()
+        
+        queue = asyncio.Queue()
+        self._pending_requests[msg_id] = queue
+        
+        try:
+            while True:
+                item = await asyncio.wait_for(queue.get(), timeout=self.timeout)
+                if isinstance(item, Exception):
+                    raise item
+                
+                ftype = item["type"]
+                flags = item["flags"]
+                payload = item["payload"]
+                
+                if flags & compression.FLAGS_COMPRESSED:
+                    payload = compression.decompress(payload)
+                
+                data = codec.deserialize(payload)
+                
+                if ftype == frame.STREAM_DATA:
+                    yield data.get("body")
+                elif ftype == frame.STREAM_END:
+                    break
+                elif ftype == frame.ERROR:
+                    raise AfterLinkError(data.get("code", 10), data.get("message", "Stream error"))
+        finally:
+            self._pending_requests.pop(msg_id, None)
+
+    async def _read_loop(self):
+        buffer = bytearray()
+        try:
+            while not self._is_closing:
+                chunk = await self.reader.read(4096)
+                if not chunk:
+                    break
+                buffer.extend(chunk)
+                
+                while True:
+                    decoded = frame.decode_auto(bytes(buffer))
+                    if decoded is None:
+                        break
+                    
+                    del buffer[:decoded["totalSize"]]
+                    self._process_incoming_frame(decoded)
+        except asyncio.CancelledError:
+            pass
+        except Exception as err:
+            logger.error(f"Error in client read loop: {err}")
+        finally:
+            self.connected = False
+            self._cleanup_pending()
+            if not self._is_closing and self.auto_reconnect:
+                asyncio.create_task(self._reconnect_loop())
+
+    def _process_incoming_frame(self, f: dict):
+        ftype = f["type"]
+        msg_id = f["messageId"]
+        
+        if ftype in (frame.RESPONSE, frame.ERROR, frame.STREAM_DATA, frame.STREAM_END):
+            dest = self._pending_requests.get(msg_id)
+            if dest:
+                if isinstance(dest, asyncio.Future):
+                    if not dest.done():
+                        dest.set_result(f)
+                elif isinstance(dest, asyncio.Queue):
+                    dest.put_nowait(f)
+        elif ftype == frame.PING:
+            pong_bytes = frame.encode(version=self.version, frame_type=frame.PONG, flags=0, message_id=msg_id, payload_bytes=b'')
+            self.writer.write(pong_bytes)
+            asyncio.create_task(self.writer.drain())
+        elif ftype in (frame.PUBLISH, frame.BROADCAST):
+            try:
+                payload = f["payload"]
+                if f["flags"] & compression.FLAGS_COMPRESSED:
+                    payload = compression.decompress(payload)
+                data = codec.deserialize(payload)
+                topic = data.get("topic")
+                msg_data = data.get("data")
+                
+                if topic in self._subscriptions:
+                    for cb in self._subscriptions[topic]:
+                        try:
+                            cb(msg_data)
+                        except Exception as e:
+                            logger.error(f"Error in subscriber callback: {e}")
+            except Exception as err:
+                logger.error(f"Failed to process pubsub broadcast: {err}")
+
+    def _cleanup_pending(self):
+        for dest in list(self._pending_requests.values()):
+            if isinstance(dest, asyncio.Future) and not dest.done():
+                dest.set_exception(AfterLinkError(AfterLinkError.CONNECTION_CLOSED, "Connection closed"))
+            elif isinstance(dest, asyncio.Queue):
+                dest.put_nowait(AfterLinkError(AfterLinkError.CONNECTION_CLOSED, "Connection closed"))
+        self._pending_requests.clear()
+
+    async def _reconnect_loop(self):
+        attempt = 0
+        while not self._is_closing and not self.connected:
+            attempt += 1
+            if attempt > self.reconnect_attempts:
+                logger.error("Max reconnect attempts reached. Giving up.")
+                break
+            
+            delay = self.reconnect_delay * (2 ** attempt) + random.uniform(0, 0.5)
+            logger.info(f"Reconnecting in {delay:.2f} seconds (attempt {attempt})...")
+            await asyncio.sleep(delay)
+            
+            try:
+                await self.connect()
+                for topic in list(self._subscriptions.keys()):
+                    await self.request("pubsub/subscribe", {"topic": topic})
+                logger.info("Reconnection successful.")
+                break
+            except Exception as err:
+                logger.error(f"Reconnection attempt failed: {err}")
+
+    async def disconnect(self):
+        self._is_closing = True
+        self.connected = False
+        
+        if self._read_task:
+            self._read_task.cancel()
+            
+        if self.writer:
+            self.writer.close()
+            try:
+                await self.writer.wait_closed()
+            except Exception:
+                pass
+                
+        self._cleanup_pending()
+        logger.info("Client disconnected.")
+
+    async def reconnect(self, **kwargs):
+        await self.disconnect()
+        await self.connect()

afterlink-2.0.0/afterlink/errors.py

@@ -0,0 +1,67 @@
+class AfterLinkError(Exception):
+    PROTOCOL_ERROR = 1
+    AUTH_REQUIRED = 2
+    AUTH_FAILED = 3
+    AUTH_EXPIRED = 4
+    ROUTE_NOT_FOUND = 5
+    VALIDATION_ERROR = 6
+    RATE_LIMITED = 7
+    CONNECTION_TIMEOUT = 8
+    CONNECTION_CLOSED = 9
+    INTERNAL_SERVER_ERROR = 10
+    MALFORMED_PAYLOAD = 11
+    UNKNOWN_FRAME_TYPE = 12
+    DECOMPRESSION_FAILED = 13
+    TLS_CERT_INVALID = 14
+    FRAME_TOO_LARGE = 15
+    COMPRESSION_ERROR = 16
+    INVALID_FRAME = 17
+    SERVER_CLOSING = 18
+    PROTOCOL_VERSION_MISMATCH = 19
+
+    ERROR_NAMES = {
+        1: "PROTOCOL_ERROR",
+        2: "AUTH_REQUIRED",
+        3: "AUTH_FAILED",
+        4: "AUTH_EXPIRED",
+        5: "ROUTE_NOT_FOUND",
+        6: "VALIDATION_ERROR",
+        7: "RATE_LIMITED",
+        8: "CONNECTION_TIMEOUT",
+        9: "CONNECTION_CLOSED",
+        10: "INTERNAL_SERVER_ERROR",
+        11: "MALFORMED_PAYLOAD",
+        12: "UNKNOWN_FRAME_TYPE",
+        13: "DECOMPRESSION_FAILED",
+        14: "TLS_CERT_INVALID",
+        15: "FRAME_TOO_LARGE",
+        16: "COMPRESSION_ERROR",
+        17: "INVALID_FRAME",
+        18: "SERVER_CLOSING",
+        19: "PROTOCOL_VERSION_MISMATCH"
+    }
+
+    def __init__(self, code: int, message: str, details=None, retry_after: int = None, meta: dict = None):
+        super().__init__(message)
+        self.code = code
+        self.name = self.ERROR_NAMES.get(code, "UNKNOWN")
+        self.message = message
+        self.details = details
+        self.retry_after = retry_after
+        self.meta = meta or {}
+
+    def __str__(self):
+        return f"{self.name} ({self.code}): {self.message}"
+
+    def to_dict(self):
+        res = {
+            "code": self.code,
+            "message": self.message
+        }
+        if self.details is not None:
+            res["details"] = self.details
+        if self.retry_after is not None:
+            res["retry_after"] = self.retry_after
+        if self.meta:
+            res["meta"] = self.meta
+        return res

afterlink-2.0.0/afterlink/protocol/__init__.py

@@ -0,0 +1 @@
+# AfterLink Protocol Module

afterlink-2.0.0/afterlink/protocol/codec.py

@@ -0,0 +1,13 @@
+import msgpack
+
+def serialize(data):
+    """
+    Serializes Python data structure to MessagePack bytes.
+    """
+    return msgpack.packb(data, use_bin_type=True)
+
+def deserialize(data):
+    """
+    Deserializes MessagePack bytes back to Python objects.
+    """
+    return msgpack.unpackb(data, raw=False)

afterlink-2.0.0/afterlink/protocol/compression.py

@@ -0,0 +1,22 @@
+import zlib
+
+FLAGS_COMPRESSED = 0x01
+
+def compress(payload: bytes, threshold: int = 1024) -> tuple[bytes, bool]:
+    """
+    Compresses payload with zlib if it exceeds the threshold.
+    """
+    if len(payload) >= threshold:
+        try:
+            compressed = zlib.compress(payload, level=6)
+            if len(compressed) < len(payload):
+                return compressed, True
+        except Exception:
+            pass
+    return payload, False
+
+def decompress(payload: bytes) -> bytes:
+    """
+    Decompresses payload with zlib.
+    """
+    return zlib.decompress(payload)

afterlink-2.0.0/afterlink/protocol/frame.py

@@ -0,0 +1,134 @@
+import struct
+
+V1_HEADER_SIZE = 10
+V2_HEADER_SIZE = 16
+MAX_PAYLOAD_SIZE = 16 * 1024 * 1024
+MAX_ROUTING_KEY = 255
+
+# Frame Types
+REQUEST = 0x01
+RESPONSE = 0x02
+STREAM_START = 0x03
+STREAM_DATA = 0x04
+STREAM_END = 0x05
+ERROR = 0x06
+PING = 0x07
+PONG = 0x08
+BROADCAST = 0x09
+SUBSCRIBE = 0x0A
+UNSUBSCRIBE = 0x0B
+PUBLISH = 0x0C
+CLOSE = 0x0D
+CLOSE_ACK = 0x0E
+HELLO = 0x0F
+HELLO_ACK = 0x10
+SERVER_CLOSING = 0x11
+ROUTE_REQUEST = 0x12
+PRIORITY_ACK = 0x13
+
+# Flags
+FLAGS_COMPRESSED = 0x01
+FLAGS_ENCRYPTED = 0x02
+FLAGS_PRIORITY_SET = 0x04
+FLAGS_HAS_ROUTING_KEY = 0x08
+
+def encode_v1(frame_type: int, flags: int, message_id: int, payload_bytes: bytes) -> bytes:
+    if len(payload_bytes) > MAX_PAYLOAD_SIZE:
+        raise ValueError(f"Payload size {len(payload_bytes)} exceeds maximum {MAX_PAYLOAD_SIZE}")
+    header = struct.pack('!BBII', frame_type, flags & 0xFF, message_id, len(payload_bytes))
+    return header + payload_bytes
+
+def decode_v1(buffer: bytes) -> dict | None:
+    if len(buffer) < V1_HEADER_SIZE:
+        return None
+    frame_type, flags, message_id, payload_len = struct.unpack('!BBII', buffer[:V1_HEADER_SIZE])
+    if payload_len > MAX_PAYLOAD_SIZE:
+        raise ValueError(f"Payload size {payload_len} exceeds maximum {MAX_PAYLOAD_SIZE}")
+    total_size = V1_HEADER_SIZE + payload_len
+    if len(buffer) < total_size:
+        return None
+    return {
+        "type": frame_type,
+        "flags": flags,
+        "messageId": message_id,
+        "payload": buffer[V1_HEADER_SIZE:total_size],
+        "totalSize": total_size
+    }
+
+def encode_v2(frame_type: int, flags: int, message_id: int, payload_bytes: bytes, priority: int = 3, routing_key: str = '') -> bytes:
+    if len(payload_bytes) > MAX_PAYLOAD_SIZE:
+        raise ValueError(f"Payload size {len(payload_bytes)} exceeds maximum {MAX_PAYLOAD_SIZE}")
+    
+    routing_key_bytes = routing_key.encode('utf-8')
+    if len(routing_key_bytes) > MAX_ROUTING_KEY:
+        raise ValueError(f"Routing key length {len(routing_key_bytes)} exceeds maximum {MAX_ROUTING_KEY}")
+
+    final_flags = flags & 0xFF
+    if priority != 3:
+        final_flags |= FLAGS_PRIORITY_SET
+    if len(routing_key_bytes) > 0:
+        final_flags |= FLAGS_HAS_ROUTING_KEY
+
+    header = struct.pack(
+        '!BBBBIHII',
+        frame_type,
+        final_flags,
+        0x02,  # version
+        priority,
+        message_id,
+        len(routing_key_bytes),
+        len(payload_bytes),
+        0  # reserved
+    )
+    return header + routing_key_bytes + payload_bytes
+
+def decode_v2(buffer: bytes) -> dict | None:
+    if len(buffer) < V2_HEADER_SIZE:
+        return None
+    
+    frame_type, flags, version, priority, message_id, routing_key_len, payload_len, _ = struct.unpack(
+        '!BBBBIHII',
+        buffer[:V2_HEADER_SIZE]
+    )
+
+    if payload_len > MAX_PAYLOAD_SIZE:
+        raise ValueError(f"Payload size {payload_len} exceeds maximum {MAX_PAYLOAD_SIZE}")
+    if routing_key_len > MAX_ROUTING_KEY:
+        raise ValueError(f"Routing key length {routing_key_len} exceeds maximum {MAX_ROUTING_KEY}")
+
+    total_size = V2_HEADER_SIZE + routing_key_len + payload_len
+    if len(buffer) < total_size:
+        return None
+
+    routing_key = buffer[V2_HEADER_SIZE:V2_HEADER_SIZE + routing_key_len].decode('utf-8')
+    payload = buffer[V2_HEADER_SIZE + routing_key_len:total_size]
+
+    return {
+        "type": frame_type,
+        "flags": flags,
+        "version": version,
+        "priority": priority,
+        "messageId": message_id,
+        "routingKeyLen": routing_key_len,
+        "routingKey": routing_key,
+        "payload": payload,
+        "totalSize": total_size
+    }
+
+def encode(version: int = 1, **kwargs) -> bytes:
+    if version == 2:
+        return encode_v2(**kwargs)
+    return encode_v1(**kwargs)
+
+def decode(buffer: bytes, version: int = 1) -> dict | None:
+    if version == 2:
+        return decode_v2(buffer)
+    return decode_v1(buffer)
+
+def decode_auto(buffer: bytes) -> dict | None:
+    if len(buffer) < 3:
+        return None
+    # Offset 2 is version byte in V2
+    if buffer[2] == 0x02:
+        return decode_v2(buffer)
+    return decode_v1(buffer)

afterlink-2.0.0/afterlink/schema.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ValidationError
+from .errors import AfterLinkError
+
+def validate_with_pydantic(model_class, data):
+    """
+    Validates dictionary data against a Pydantic model class.
+    Raises AfterLinkError with VALIDATION_ERROR code on failure.
+    """
+    if not issubclass(model_class, BaseModel):
+        raise TypeError("model_class must be a subclass of pydantic.BaseModel")
+    try:
+        return model_class.model_validate(data)
+    except ValidationError as err:
+        details = {e["loc"][0]: e["msg"] for e in err.errors() if e["loc"]}
+        raise AfterLinkError(
+            code=AfterLinkError.VALIDATION_ERROR,
+            message="Validation failed",
+            details=details
+        )

afterlink-2.0.0/afterlink/server.py

@@ -0,0 +1,207 @@
+import asyncio
+import logging
+from typing import Callable, Any
+
+from .errors import AfterLinkError
+from .protocol import frame, codec, compression
+
+logger = logging.getLogger("afterlink.server")
+
+class Server:
+    def __init__(self, port: int = 4000, options: dict = None):
+        self.port = port
+        self.options = options or {}
+        self.host = self.options.get("host", "0.0.0.0")
+        
+        self.routes = {}
+        self.middlewares = []
+        self.connections = set()
+        
+        self._server = None
+        self._is_closing = False
+
+    def on(self, route: str, handler: Callable = None, *, schema: Any = None):
+        """
+        Decorator or direct method to register a route handler.
+        """
+        def decorator(f):
+            self.routes[route] = {"handler": f, "schema": schema}
+            return f
+        if handler is None:
+            return decorator
+        self.routes[route] = {"handler": handler, "schema": schema}
+        return handler
+
+    def use(self, middleware: Callable):
+        """
+        Register a middleware function.
+        """
+        self.middlewares.append(middleware)
+        return middleware
+
+    async def listen(self):
+        logger.info(f"Starting AfterLink server on {self.host}:{self.port}...")
+        self._server = await asyncio.start_server(
+            self._handle_incoming_connection,
+            self.host,
+            self.port
+        )
+        async with self._server:
+            await self._server.serve_forever()
+
+    async def _handle_incoming_connection(self, reader, writer):
+        addr = writer.get_extra_info('peername')
+        logger.info(f"New connection from {addr}")
+        
+        conn = ServerConnection(self, reader, writer)
+        self.connections.add(conn)
+        
+        try:
+            await conn.handle()
+        except Exception as err:
+            logger.error(f"Error handling connection from {addr}: {err}")
+        finally:
+            self.connections.discard(conn)
+            logger.info(f"Connection from {addr} closed")
+
+    async def close(self):
+        self._is_closing = True
+        if self._server:
+            self._server.close()
+            await self._server.wait_closed()
+            
+        for conn in list(self.connections):
+            await conn.close()
+
+
+class ServerConnection:
+    def __init__(self, server: Server, reader, writer):
+        self.server = server
+        self.reader = reader
+        self.writer = writer
+        self.session_id = f"sess_{id(self)}"
+        self.version = 1
+        self.authenticated = False
+
+    async def handle(self):
+        buffer = bytearray()
+        try:
+            while not self.server._is_closing:
+                chunk = await self.reader.read(4096)
+                if not chunk:
+                    break
+                buffer.extend(chunk)
+                
+                while True:
+                    decoded = frame.decode_auto(bytes(buffer))
+                    if decoded is None:
+                        break
+                    
+                    del buffer[:decoded["totalSize"]]
+                    await self._process_frame(decoded)
+        finally:
+            self.writer.close()
+            try:
+                await self.writer.wait_closed()
+            except Exception:
+                pass
+
+    async def _process_frame(self, f: dict):
+        ftype = f["type"]
+        msg_id = f["messageId"]
+        
+        if ftype == frame.HELLO:
+            hello_data = codec.deserialize(f["payload"])
+            requested_ver = hello_data.get("version", "AL/1")
+            
+            self.version = 2 if "AL/2" in requested_ver else 1
+            
+            ack_payload = {
+                "session_id": self.session_id,
+                "server_version": "2.0.0",
+                "accepted_protocol": "v2" if self.version == 2 else "v1"
+            }
+            payload_bytes = codec.serialize(ack_payload)
+            ack_bytes = frame.encode(version=1, frame_type=frame.HELLO_ACK, flags=0, message_id=msg_id, payload_bytes=payload_bytes)
+            self.writer.write(ack_bytes)
+            await self.writer.drain()
+            self.authenticated = True
+            
+        elif ftype == frame.REQUEST:
+            if not self.authenticated:
+                self.send_error(AfterLinkError.AUTH_REQUIRED, "Authentication required", msg_id)
+                return
+                
+            try:
+                payload = f["payload"]
+                if f["flags"] & compression.FLAGS_COMPRESSED:
+                    payload = compression.decompress(payload)
+                data = codec.deserialize(payload)
+            except Exception:
+                self.send_error(AfterLinkError.MALFORMED_PAYLOAD, "Malformed request payload", msg_id)
+                return
+                
+            route = data.get("route")
+            body = data.get("body", {})
+            
+            route_config = self.server.routes.get(route)
+            if not route_config:
+                self.send_error(AfterLinkError.ROUTE_NOT_FOUND, f"Route '{route}' not found", msg_id)
+                return
+                
+            if route_config["schema"]:
+                from .schema import validate_with_pydantic
+                try:
+                    validate_with_pydantic(route_config["schema"], body)
+                except AfterLinkError as err:
+                    self.send_error(err.code, err.message, msg_id, details=err.details)
+                    return
+            
+            req = {"body": body, "route": route, "connection": self}
+            
+            async def run_handler():
+                return await route_config["handler"](req)
+                
+            try:
+                result = await self._run_middlewares(req, run_handler)
+                
+                res_payload = {"status": "ok", "body": result}
+                payload_bytes = codec.serialize(res_payload)
+                
+                payload_bytes, compressed = compression.compress(payload_bytes)
+                flags = compression.FLAGS_COMPRESSED if compressed else 0
+                
+                res_bytes = frame.encode(version=self.version, frame_type=frame.RESPONSE, flags=flags, message_id=msg_id, payload_bytes=payload_bytes)
+                self.writer.write(res_bytes)
+                await self.writer.drain()
+            except AfterLinkError as err:
+                self.send_error(err.code, err.message, msg_id, details=err.details)
+            except Exception as err:
+                self.send_error(AfterLinkError.INTERNAL_SERVER_ERROR, str(err), msg_id)
+
+    async def _run_middlewares(self, req: dict, final_handler: Callable):
+        index = 0
+        async def run():
+            nonlocal index
+            if index >= len(self.server.middlewares):
+                return await final_handler()
+            m = self.server.middlewares[index]
+            index += 1
+            return await m(req, run)
+        return await run()
+
+    def send_error(self, code: int, message: str, message_id: int, details=None):
+        err_payload = {"code": code, "message": message}
+        if details is not None:
+            err_payload["details"] = details
+        payload_bytes = codec.serialize(err_payload)
+        err_bytes = frame.encode(version=self.version, frame_type=frame.ERROR, flags=0, message_id=message_id, payload_bytes=payload_bytes)
+        self.writer.write(err_bytes)
+        asyncio.create_task(self.writer.drain())
+
+    async def close(self):
+        self.writer.close()
+        try:
+            await self.writer.wait_closed()
+        except Exception:
+            pass

afterlink-2.0.0/afterlink/sync.py

@@ -0,0 +1,22 @@
+import asyncio
+from typing import Any
+
+from .client import Client
+
+class SyncClient:
+    """
+    Synchronous wrapper around the async AfterLink Client.
+    """
+    def __init__(self, url: str, options: dict = None):
+        self._loop = asyncio.new_event_loop()
+        self._client = Client(url, options)
+
+    def connect(self):
+        self._loop.run_until_complete(self._client.connect())
+
+    def request(self, route: str, body: Any = None) -> Any:
+        return self._loop.run_until_complete(self._client.request(route, body))
+
+    def disconnect(self):
+        self._loop.run_until_complete(self._client.disconnect())
+        self._loop.close()

afterlink-2.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "afterlink"
+version = "2.0.0"
+description = "AfterLink Protocol SDK - TCP client/server with routing, middleware, and pub/sub"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Ajay Myth", email = "ajaymyth@github.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "msgpack>=1.0.8",
+    "pydantic>=2.0"
+]
+
+[project.optional-dependencies]
+uvloop = ["uvloop>=0.17.0"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["afterlink"]

afterlink-2.0.0/tests/__init__.py

@@ -0,0 +1 @@
+# AfterLink Python SDK Tests

afterlink-2.0.0/tests/test_client.py

@@ -0,0 +1,29 @@
+import pytest
+import asyncio
+from afterlink import Server, Client
+
+@pytest.mark.asyncio
+async def test_client_server_integration():
+    server = Server(port=5005)
+    
+    @server.on("users/get")
+    async def get_user(req):
+        return {"id": 42, "username": "python-test"}
+        
+    server_task = asyncio.create_task(server.listen())
+    await asyncio.sleep(0.1) 
+    
+    client = Client("tcp://localhost:5005")
+    try:
+        await client.connect()
+        res = await client.request("users/get")
+        assert res["id"] == 42
+        assert res["username"] == "python-test"
+    finally:
+        await client.disconnect()
+        await server.close()
+        server_task.cancel()
+        try:
+            await server_task
+        except asyncio.CancelledError:
+            pass

afterlink-2.0.0/tests/test_errors.py

@@ -0,0 +1,17 @@
+from afterlink import AfterLinkError
+
+def test_error_instantiation():
+    err = AfterLinkError(AfterLinkError.ROUTE_NOT_FOUND, "Route not found", details="some-detail", retry_after=5)
+    assert err.code == 5
+    assert err.name == "ROUTE_NOT_FOUND"
+    assert err.message == "Route not found"
+    assert err.details == "some-detail"
+    assert err.retry_after == 5
+    assert str(err) == "ROUTE_NOT_FOUND (5): Route not found"
+
+def test_error_to_dict():
+    err = AfterLinkError(AfterLinkError.AUTH_FAILED, "Auth failed")
+    d = err.to_dict()
+    assert d["code"] == 3
+    assert d["message"] == "Auth failed"
+    assert "details" not in d

afterlink-2.0.0/tests/test_protocol.py

@@ -0,0 +1,69 @@
+import os
+import json
+from afterlink.protocol import frame
+
+def test_v1_encode_decode():
+    payload = b"hello"
+    encoded = frame.encode_v1(1, 0, 42, payload)
+    decoded = frame.decode_v1(encoded)
+    
+    assert decoded is not None
+    assert decoded["type"] == 1
+    assert decoded["flags"] == 0
+    assert decoded["messageId"] == 42
+    assert decoded["payload"] == payload
+
+def test_v2_encode_decode():
+    payload = b"hello"
+    encoded = frame.encode_v2(1, 0, 42, payload, priority=5, routing_key="route")
+    decoded = frame.decode_v2(encoded)
+    
+    assert decoded is not None
+    assert decoded["type"] == 1
+    assert decoded["flags"] == 12 
+    assert decoded["version"] == 2
+    assert decoded["priority"] == 5
+    assert decoded["messageId"] == 42
+    assert decoded["routingKey"] == "route"
+    assert decoded["payload"] == payload
+
+def test_vectors():
+    vectors_path = os.path.join(os.path.dirname(__file__), "../../test/protocol-vectors.json")
+    with open(vectors_path, "r") as f:
+        data = json.load(f)
+        
+    for vec in data["vectors"]:
+        payload = bytes.fromhex(vec["payloadHex"])
+        expected = bytes.fromhex(vec["expectedHex"])
+        
+        if vec["version"] == 1:
+            encoded = frame.encode(
+                version=1,
+                frame_type=vec["type"],
+                flags=vec["flags"],
+                message_id=vec["messageId"],
+                payload_bytes=payload
+            )
+        else:
+            encoded = frame.encode(
+                version=2,
+                frame_type=vec["type"],
+                flags=vec["flags"],
+                message_id=vec["messageId"],
+                payload_bytes=payload,
+                priority=vec.get("priority", 3),
+                routing_key=vec.get("routingKey", "")
+            )
+            
+        assert encoded == expected
+        
+        decoded = frame.decode_auto(expected)
+        assert decoded is not None
+        assert decoded["type"] == vec["type"]
+        assert decoded["flags"] == vec["flags"]
+        assert decoded["messageId"] == vec["messageId"]
+        
+        if vec["version"] == 2:
+            assert decoded["version"] == 2
+            assert decoded["priority"] == vec.get("priority", 3)
+            assert decoded["routingKey"] == vec.get("routingKey", "")