py-easysync 0.1.0__tar.gz

py_easysync-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: py-easysync
+Version: 0.1.0
+Summary: Universal real-time state synchronization for Python.
+Home-page: https://github.com/GalTechDev/easysync
+Author: GalTechDev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# EasySync
+
+Universal real-time state synchronization for Python.
+
+![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)
+![License](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+Manipulate your Python objects as if the network didn't exist. EasySync intercepts attribute mutations through a transparent proxy and propagates them instantly to all machines connected to the server.
+
+## Installation
+
+```bash
+pip install easysync
+```
+
+## Quick Start
+
+**Server** (hosts the shared state):
+
+```python
+from easysync import SyncedObject, SyncServer, connect
+
+server = SyncServer(port=5000)
+server.start_thread()
+
+client = connect("127.0.0.1", 5000)
+
+@SyncedObject(client)
+class GameState:
+    def __init__(self):
+        self.score = 0
+        self.players = []
+
+state = GameState()
+state.score = 42           # propagated to all clients
+state.players.append("A")  # propagated too
+```
+
+**Client** (joins the server):
+
+```python
+from easysync import SyncedObject, connect
+
+client = connect("192.168.1.10", 5000)
+
+@SyncedObject(client)
+class GameState:
+    def __init__(self):
+        self.score = 0
+        self.players = []
+
+state = GameState()
+print(state.score)    # 42, updated in real time
+print(state.players)  # ['A']
+```
+
+## Architecture
+
+The server uses `asyncio` for non-blocking connection handling, allowing it to support a large number of simultaneous clients without CPU overhead. The client uses a dedicated receive thread to remain compatible with standard application loops (Pygame, Matplotlib, etc.).
+
+The wire protocol relies on binary Pickle serialization framed by a 4-byte header (payload size). This ensures measured latency under 20ms.
+
+## Features
+
+- **Zero configuration**: a single `@SyncedObject` decorator is all you need.
+- **Transparent proxy**: automatic interception of `__setattr__`, `__setitem__`, `append`, `pop`, etc.
+- **Asyncio server**: built on `asyncio.start_server` for maximum scalability.
+- **Binary serialization**: Pickle + TCP framing protocol, latency < 20ms.
+- **Zero dependencies**: only uses the Python standard library.
+- **Data Science ready**: optimized handling of NumPy, Pandas and Scikit-Learn objects via the copy-and-reassign pattern.
+
+## Examples
+
+The `examples/` folder contains several demos:
+
+| File | Description |
+|---|---|
+| `pygame_example.py` | Synchronized square between two Pygame windows |
+| `pygame_hanoi.py` | Collaborative Tower of Hanoi |
+| `numpy_matplotlib_example.py` | NumPy data streaming with Matplotlib chart |
+| `pandas_example.py` | Collaborative Pandas spreadsheet |
+| `sklearn_live_training.py` | Live Scikit-Learn training visualization |
+| `federated_learning_example.py` | Distributed federated learning |
+| `genetic_island_example.py` | Distributed genetic algorithm (island model) |
+| `tetris_ai_example.py` | Distributed Tetris AI via genetic algorithm |
+
+To run the examples, install the additional dependencies:
+
+```bash
+pip install -r requirements_examples.txt
+```
+
+Then launch a server and one or more clients:
+
+```bash
+python examples/pygame_example.py server    # Terminal 1
+python examples/pygame_example.py           # Terminal 2
+```
+
+## License
+
+MIT

py_easysync-0.1.0/README.md

@@ -0,0 +1,102 @@
+# EasySync
+
+Universal real-time state synchronization for Python.
+
+![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)
+![License](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+Manipulate your Python objects as if the network didn't exist. EasySync intercepts attribute mutations through a transparent proxy and propagates them instantly to all machines connected to the server.
+
+## Installation
+
+```bash
+pip install easysync
+```
+
+## Quick Start
+
+**Server** (hosts the shared state):
+
+```python
+from easysync import SyncedObject, SyncServer, connect
+
+server = SyncServer(port=5000)
+server.start_thread()
+
+client = connect("127.0.0.1", 5000)
+
+@SyncedObject(client)
+class GameState:
+    def __init__(self):
+        self.score = 0
+        self.players = []
+
+state = GameState()
+state.score = 42           # propagated to all clients
+state.players.append("A")  # propagated too
+```
+
+**Client** (joins the server):
+
+```python
+from easysync import SyncedObject, connect
+
+client = connect("192.168.1.10", 5000)
+
+@SyncedObject(client)
+class GameState:
+    def __init__(self):
+        self.score = 0
+        self.players = []
+
+state = GameState()
+print(state.score)    # 42, updated in real time
+print(state.players)  # ['A']
+```
+
+## Architecture
+
+The server uses `asyncio` for non-blocking connection handling, allowing it to support a large number of simultaneous clients without CPU overhead. The client uses a dedicated receive thread to remain compatible with standard application loops (Pygame, Matplotlib, etc.).
+
+The wire protocol relies on binary Pickle serialization framed by a 4-byte header (payload size). This ensures measured latency under 20ms.
+
+## Features
+
+- **Zero configuration**: a single `@SyncedObject` decorator is all you need.
+- **Transparent proxy**: automatic interception of `__setattr__`, `__setitem__`, `append`, `pop`, etc.
+- **Asyncio server**: built on `asyncio.start_server` for maximum scalability.
+- **Binary serialization**: Pickle + TCP framing protocol, latency < 20ms.
+- **Zero dependencies**: only uses the Python standard library.
+- **Data Science ready**: optimized handling of NumPy, Pandas and Scikit-Learn objects via the copy-and-reassign pattern.
+
+## Examples
+
+The `examples/` folder contains several demos:
+
+| File | Description |
+|---|---|
+| `pygame_example.py` | Synchronized square between two Pygame windows |
+| `pygame_hanoi.py` | Collaborative Tower of Hanoi |
+| `numpy_matplotlib_example.py` | NumPy data streaming with Matplotlib chart |
+| `pandas_example.py` | Collaborative Pandas spreadsheet |
+| `sklearn_live_training.py` | Live Scikit-Learn training visualization |
+| `federated_learning_example.py` | Distributed federated learning |
+| `genetic_island_example.py` | Distributed genetic algorithm (island model) |
+| `tetris_ai_example.py` | Distributed Tetris AI via genetic algorithm |
+
+To run the examples, install the additional dependencies:
+
+```bash
+pip install -r requirements_examples.txt
+```
+
+Then launch a server and one or more clients:
+
+```bash
+python examples/pygame_example.py server    # Terminal 1
+python examples/pygame_example.py           # Terminal 2
+```
+
+## License
+
+MIT

py_easysync-0.1.0/easysync/__init__.py

@@ -0,0 +1,10 @@
+from easysync.syncedobject import SyncedObject, SyncedVar, SyncedProxy, connect, get_client
+from easysync.syncserver import SyncServer
+from easysync.syncclient import SyncClient
+
+__version__ = "0.1.0"
+__all__ = [
+    "SyncedObject", "SyncedVar", "SyncedProxy",
+    "SyncServer", "SyncClient",
+    "connect", "get_client",
+]

py_easysync-0.1.0/easysync/syncclient.py

@@ -0,0 +1,103 @@
+import socket
+import threading
+import pickle
+import struct
+
+
+class SyncClient:
+    """TCP client that connects to a SyncServer to synchronize objects."""
+
+    def __init__(self, host="localhost", port=5000, auth_payload=None):
+        self.host = host
+        self.port = port
+        self.auth_payload = auth_payload
+        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.connected = False
+        self.callbacks = {}
+        self.on_sync_request_callback = None
+
+    def connect(self):
+        try:
+            self.client_socket.connect((self.host, self.port))
+
+            self._send_packet({"type": "auth", "payload": self.auth_payload})
+            resp = self._recv_packet()
+            if not resp:
+                print("[EasySync] Connection lost during authentication")
+                return
+
+            if resp.get("type") == "auth_reject":
+                print("[EasySync] Authentication rejected by server")
+                return
+
+            self.connected = True
+            print(f"[EasySync] Connected to {self.host}:{self.port}")
+            self._send_packet({"type": "request_sync"})
+
+            t = threading.Thread(target=self.receive_loop, daemon=True)
+            t.start()
+        except Exception as e:
+            print(f"[EasySync] Connection failed: {e}")
+
+    def _send_packet(self, data):
+        if self.client_socket:
+            raw = pickle.dumps(data)
+            self.client_socket.sendall(struct.pack(">I", len(raw)) + raw)
+
+    def _recv_n_bytes(self, n):
+        buf = bytearray()
+        while len(buf) < n:
+            chunk = self.client_socket.recv(n - len(buf))
+            if not chunk:
+                return None
+            buf.extend(chunk)
+        return bytes(buf)
+
+    def _recv_packet(self):
+        header = self._recv_n_bytes(4)
+        if not header:
+            return None
+        length = struct.unpack(">I", header)[0]
+        data = self._recv_n_bytes(length)
+        if not data:
+            return None
+        return pickle.loads(data)
+
+    def send_update(self, object_id, attr_name, value):
+        if not self.connected:
+            return
+        try:
+            self._send_packet({
+                "type": "update",
+                "object_id": object_id,
+                "attr_name": attr_name,
+                "value": value,
+            })
+        except Exception as e:
+            print(f"[EasySync] Send error: {e}")
+
+    def register_callback(self, object_id, callback):
+        self.callbacks[object_id] = callback
+
+    def receive_loop(self):
+        while self.connected:
+            try:
+                message = self._recv_packet()
+                if message is None:
+                    print("[EasySync] Disconnected from server")
+                    self.connected = False
+                    break
+
+                msg_type = message.get("type")
+                if msg_type == "update":
+                    oid = message.get("object_id")
+                    if oid and oid in self.callbacks:
+                        self.callbacks[oid](message)
+                elif msg_type == "request_sync":
+                    if self.on_sync_request_callback:
+                        self.on_sync_request_callback()
+
+            except Exception as e:
+                print(f"[EasySync] Network error: {e}")
+                self.connected = False
+                break

py_easysync-0.1.0/easysync/syncedobject.py

@@ -0,0 +1,303 @@
+import inspect
+import threading
+import time
+import weakref
+
+from easysync.syncclient import SyncClient
+
+_default_client = None
+
+
+class SyncedProxy:
+    """Transparent proxy that intercepts mutations and triggers the network callback."""
+
+    def __init__(self, target, callback):
+        object.__setattr__(self, "_target", target)
+        object.__setattr__(self, "_callback", callback)
+
+    def __getattribute__(self, name):
+        if name in ("_target", "_callback", "_trigger", "__class__",
+                     "__array__", "__array_struct__", "__array_interface__"):
+            if name in ("__array__", "__array_struct__", "__array_interface__"):
+                return getattr(object.__getattribute__(self, "_target"), name)
+            return object.__getattribute__(self, name)
+
+        target = object.__getattribute__(self, "_target")
+        attr = getattr(target, name)
+        callback = object.__getattribute__(self, "_callback")
+        return _deep_wrap(attr, callback)
+
+    def __call__(self, *args, **kwargs):
+        target = object.__getattribute__(self, "_target")
+        callback = object.__getattribute__(self, "_callback")
+        ret = target(*args, **kwargs)
+        object.__getattribute__(self, "_trigger")()
+        return _deep_wrap(ret, callback)
+
+    def __setattr__(self, name, value):
+        setattr(object.__getattribute__(self, "_target"), name, value)
+        object.__getattribute__(self, "_trigger")()
+
+    def _trigger(self):
+        cb = object.__getattribute__(self, "_callback")
+        if cb:
+            cb()
+
+    def __getitem__(self, key):
+        res = object.__getattribute__(self, "_target")[key]
+        return _deep_wrap(res, object.__getattribute__(self, "_callback"))
+
+    def __setitem__(self, key, value):
+        object.__getattribute__(self, "_target")[key] = value
+        object.__getattribute__(self, "_trigger")()
+
+    def __delitem__(self, key):
+        del object.__getattribute__(self, "_target")[key]
+        object.__getattribute__(self, "_trigger")()
+
+    def __iter__(self):
+        target = object.__getattribute__(self, "_target")
+        callback = object.__getattribute__(self, "_callback")
+        for item in target:
+            yield _deep_wrap(item, callback)
+
+    def __len__(self):
+        return len(object.__getattribute__(self, "_target"))
+
+    def __repr__(self):
+        return repr(object.__getattribute__(self, "_target"))
+
+    def __str__(self):
+        return str(object.__getattribute__(self, "_target"))
+
+    def __array__(self, *args, **kwargs):
+        target = object.__getattribute__(self, "_target")
+        if hasattr(target, "__array__"):
+            return target.__array__(*args, **kwargs)
+        return NotImplemented
+
+
+def _deep_wrap(value, callback):
+    """Recursively wraps an object in a SyncedProxy.
+    Immutable types and C-extensions (numpy, pandas) are excluded."""
+    import numbers
+    if value is None or isinstance(value, (numbers.Number, str, bool, tuple, bytes)):
+        return value
+    if type(value).__name__ in ("ndarray", "DataFrame", "Series"):
+        return value
+    if isinstance(value, SyncedProxy):
+        object.__setattr__(value, "_callback", callback)
+        return value
+    return SyncedProxy(value, callback)
+
+
+def _unproxy(value):
+    """Recursively strips proxy layers to get the raw object."""
+    if isinstance(value, SyncedProxy):
+        return _unproxy(object.__getattribute__(value, "_target"))
+    if type(value) is list:
+        return [_unproxy(x) for x in value]
+    if type(value) is dict:
+        return {k: _unproxy(v) for k, v in value.items()}
+    return value
+
+
+# ---------- Global registry and polling loop ----------
+
+_master_synced_vars = []
+_master_synced_objects = weakref.WeakSet()
+_master_poller_thread = None
+
+
+def _master_poller_loop():
+    """Single thread that watches for unintercepted local mutations."""
+    while True:
+        time.sleep(0.05)
+        for var in list(_master_synced_vars):
+            try:
+                if var._updating:
+                    continue
+                current_val = var.namespace.get(var.var_name)
+                if current_val != var.last_val:
+                    var.last_val = current_val
+                    if var._client:
+                        var._client.send_update(var.var_name, "value", current_val)
+            except Exception:
+                pass
+
+
+def _handle_sync_request():
+    """Responds to a resync request from a newly connected client."""
+    for var in _master_synced_vars:
+        if var._client:
+            var._client.send_update(var.var_name, "value", var.last_val)
+
+    for obj in list(_master_synced_objects):
+        try:
+            c = object.__getattribute__(obj, "_sync_client")
+            oid = object.__getattribute__(obj, "_sync_object_id")
+            if c:
+                import types
+                for attr_name in dir(obj):
+                    if not attr_name.startswith("_"):
+                        val = getattr(obj, attr_name)
+                        if not isinstance(val, types.MethodType):
+                            c.send_update(oid, attr_name, _unproxy(val))
+        except Exception:
+            pass
+
+
+# ---------- Public API ----------
+
+def connect(host="localhost", port=5000):
+    """Connect to a remote SyncServer and return the client instance."""
+    global _default_client
+    _default_client = SyncClient(host=host, port=port)
+    _default_client.on_sync_request_callback = _handle_sync_request
+    _default_client.connect()
+    return _default_client
+
+
+def get_client():
+    """Return the default client."""
+    return _default_client
+
+
+def SyncedObject(client=None):
+    """Class decorator: synchronizes public attributes over the network."""
+    def decorator(cls):
+        _object_id = cls.__qualname__
+        original_init = cls.__init__ if hasattr(cls, "__init__") else None
+
+        def new_init(self, *args, _sync_client=None, **kwargs):
+            resolved_client = _sync_client or client or _default_client
+            object.__setattr__(self, "_sync_client", resolved_client)
+            object.__setattr__(self, "_sync_object_id", _object_id)
+            object.__setattr__(self, "_sync_updating", False)
+
+            if resolved_client:
+                resolved_client.register_callback(
+                    _object_id, lambda msg, obj=self: _apply_update(obj, msg)
+                )
+
+            if original_init:
+                original_init(self, *args, **kwargs)
+
+            _master_synced_objects.add(self)
+
+        def new_setattr(self, name, value):
+            if name.startswith("_"):
+                object.__setattr__(self, name, value)
+                return
+
+            def trigger_sync():
+                try:
+                    if object.__getattribute__(self, "_sync_updating"):
+                        return
+                except AttributeError:
+                    pass
+                try:
+                    c = object.__getattribute__(self, "_sync_client")
+                    oid = object.__getattribute__(self, "_sync_object_id")
+                    if c:
+                        unproxied = _unproxy(object.__getattribute__(self, name))
+                        c.send_update(oid, name, unproxied)
+                except AttributeError:
+                    pass
+
+            wrapped_value = _deep_wrap(value, trigger_sync)
+            object.__setattr__(self, name, wrapped_value)
+            trigger_sync()
+
+        cls.__init__ = new_init
+        cls.__setattr__ = new_setattr
+        return cls
+    return decorator
+
+
+def _apply_update(obj, message):
+    """Apply a network update to the local object."""
+    attr_name = message.get("attr_name")
+    value = message.get("value")
+
+    if attr_name:
+        if attr_name.startswith("_"):
+            return
+        if not hasattr(obj, attr_name):
+            return
+
+        object.__setattr__(obj, "_sync_updating", True)
+        try:
+            setattr(obj, attr_name, value)
+        finally:
+            object.__setattr__(obj, "_sync_updating", False)
+
+
+class SyncedVar:
+    """Simple network-synchronized variable."""
+
+    def __init__(self, value=None, client=None):
+        global _master_poller_thread
+
+        self._client = client or _default_client
+        self.frame = inspect.currentframe().f_back
+        self.namespace = self.frame.f_globals
+        self.var_name = None
+
+        try:
+            import dis
+            instructions = list(dis.get_instructions(self.frame.f_code))
+            for i, inst in enumerate(instructions):
+                if inst.offset == self.frame.f_lasti:
+                    for j in range(i - 1, -1, -1):
+                        prev_inst = instructions[j]
+                        if prev_inst.opname in ("LOAD_FAST", "LOAD_NAME", "LOAD_GLOBAL", "LOAD_DEREF"):
+                            self.var_name = prev_inst.argval
+                            break
+                        elif prev_inst.opname.startswith("CALL") or prev_inst.opname.startswith("PRECALL"):
+                            break
+                    break
+        except Exception:
+            pass
+
+        if not self.var_name:
+            raise ValueError("Could not resolve variable name.")
+
+        self.last_val = self.namespace.get(self.var_name, value)
+        self._updating = False
+
+        if self._client:
+            self._client.register_callback(self.var_name, self._apply_net_update)
+
+        _master_synced_vars.append(self)
+
+        if _master_poller_thread is None:
+            _master_poller_thread = threading.Thread(target=_master_poller_loop, daemon=True)
+            _master_poller_thread.start()
+
+    def _apply_net_update(self, message):
+        val = message.get("value")
+        if val is not None:
+            self._updating = True
+            try:
+                self.namespace[self.var_name] = val
+                self.last_val = val
+            finally:
+                self._updating = False
+
+    def get(self):
+        return self.last_val
+
+    def set(self, value):
+        self.namespace[self.var_name] = value
+
+    def set_client(self, client):
+        self._client = client
+        if self._client:
+            self._client.register_callback(self.var_name, self._apply_net_update)
+
+    def __repr__(self):
+        return f"SyncedVar({self.var_name!r}, {self.last_val!r})"
+
+    def __str__(self):
+        return str(self.last_val)

py_easysync-0.1.0/easysync/syncserver.py

@@ -0,0 +1,119 @@
+import asyncio
+import pickle
+import struct
+
+
+class SyncServer:
+    """Async TCP server that relays state updates between all connected clients.
+
+    Uses asyncio.start_server for non-blocking connection handling.
+    Wire protocol is identical to the legacy threaded version.
+    """
+
+    def __init__(self, host="0.0.0.0", port=5000):
+        self.host = host
+        self.port = port
+        self.clients: list[asyncio.StreamWriter] = []
+        self.auth_handler = None
+        self._server = None
+
+    def on_auth(self, func):
+        self.auth_handler = func
+        return func
+
+    async def _send_packet(self, writer: asyncio.StreamWriter, data: dict):
+        raw = pickle.dumps(data)
+        writer.write(struct.pack(">I", len(raw)) + raw)
+        await writer.drain()
+
+    async def _recv_packet(self, reader: asyncio.StreamReader) -> dict | None:
+        header = await reader.readexactly(4)
+        length = struct.unpack(">I", header)[0]
+        raw = await reader.readexactly(length)
+        return pickle.loads(raw)
+
+    async def _broadcast(self, message: dict, sender: asyncio.StreamWriter = None):
+        raw = pickle.dumps(message)
+        frame = struct.pack(">I", len(raw)) + raw
+
+        dead = []
+        for client in self.clients:
+            if client is sender:
+                continue
+            try:
+                client.write(frame)
+                await client.drain()
+            except (ConnectionError, OSError):
+                dead.append(client)
+
+        for client in dead:
+            self.clients.remove(client)
+            client.close()
+
+    async def _handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
+        addr = writer.get_extra_info("peername")
+        print(f"[EasySync] New connection: {addr}")
+
+        try:
+            message = await self._recv_packet(reader)
+            if not message:
+                return
+
+            if message.get("type") == "auth":
+                if self.auth_handler:
+                    if not self.auth_handler(addr, message.get("payload")):
+                        await self._send_packet(writer, {"type": "auth_reject"})
+                        return
+                await self._send_packet(writer, {"type": "auth_ok"})
+            else:
+                if self.auth_handler:
+                    return
+                await self._broadcast(message, sender=writer)
+
+            self.clients.append(writer)
+
+            while True:
+                message = await self._recv_packet(reader)
+                if not message:
+                    break
+                await self._broadcast(message, sender=writer)
+
+        except (asyncio.IncompleteReadError, ConnectionError, OSError):
+            pass
+        except Exception as e:
+            print(f"[EasySync] Client error {addr}: {e}")
+        finally:
+            print(f"[EasySync] Disconnected: {addr}")
+            if writer in self.clients:
+                self.clients.remove(writer)
+            writer.close()
+
+    async def start(self):
+        self._server = await asyncio.start_server(
+            self._handle_client, self.host, self.port
+        )
+        print(f"[EasySync] Server started on {self.host}:{self.port}")
+        async with self._server:
+            await self._server.serve_forever()
+
+    def start_thread(self):
+        """Run the async server in a dedicated thread with its own event loop."""
+        import threading
+
+        def _run():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(self.start())
+
+        t = threading.Thread(target=_run, daemon=True)
+        t.start()
+
+    async def stop(self):
+        if self._server:
+            self._server.close()
+            await self._server.wait_closed()
+
+
+if __name__ == "__main__":
+    server = SyncServer()
+    asyncio.run(server.start())

py_easysync-0.1.0/py_easysync.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: py-easysync
+Version: 0.1.0
+Summary: Universal real-time state synchronization for Python.
+Home-page: https://github.com/GalTechDev/easysync
+Author: GalTechDev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# EasySync
+
+Universal real-time state synchronization for Python.
+
+![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)
+![License](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+Manipulate your Python objects as if the network didn't exist. EasySync intercepts attribute mutations through a transparent proxy and propagates them instantly to all machines connected to the server.
+
+## Installation
+
+```bash
+pip install easysync
+```
+
+## Quick Start
+
+**Server** (hosts the shared state):
+
+```python
+from easysync import SyncedObject, SyncServer, connect
+
+server = SyncServer(port=5000)
+server.start_thread()
+
+client = connect("127.0.0.1", 5000)
+
+@SyncedObject(client)
+class GameState:
+    def __init__(self):
+        self.score = 0
+        self.players = []
+
+state = GameState()
+state.score = 42           # propagated to all clients
+state.players.append("A")  # propagated too
+```
+
+**Client** (joins the server):
+
+```python
+from easysync import SyncedObject, connect
+
+client = connect("192.168.1.10", 5000)
+
+@SyncedObject(client)
+class GameState:
+    def __init__(self):
+        self.score = 0
+        self.players = []
+
+state = GameState()
+print(state.score)    # 42, updated in real time
+print(state.players)  # ['A']
+```
+
+## Architecture
+
+The server uses `asyncio` for non-blocking connection handling, allowing it to support a large number of simultaneous clients without CPU overhead. The client uses a dedicated receive thread to remain compatible with standard application loops (Pygame, Matplotlib, etc.).
+
+The wire protocol relies on binary Pickle serialization framed by a 4-byte header (payload size). This ensures measured latency under 20ms.
+
+## Features
+
+- **Zero configuration**: a single `@SyncedObject` decorator is all you need.
+- **Transparent proxy**: automatic interception of `__setattr__`, `__setitem__`, `append`, `pop`, etc.
+- **Asyncio server**: built on `asyncio.start_server` for maximum scalability.
+- **Binary serialization**: Pickle + TCP framing protocol, latency < 20ms.
+- **Zero dependencies**: only uses the Python standard library.
+- **Data Science ready**: optimized handling of NumPy, Pandas and Scikit-Learn objects via the copy-and-reassign pattern.
+
+## Examples
+
+The `examples/` folder contains several demos:
+
+| File | Description |
+|---|---|
+| `pygame_example.py` | Synchronized square between two Pygame windows |
+| `pygame_hanoi.py` | Collaborative Tower of Hanoi |
+| `numpy_matplotlib_example.py` | NumPy data streaming with Matplotlib chart |
+| `pandas_example.py` | Collaborative Pandas spreadsheet |
+| `sklearn_live_training.py` | Live Scikit-Learn training visualization |
+| `federated_learning_example.py` | Distributed federated learning |
+| `genetic_island_example.py` | Distributed genetic algorithm (island model) |
+| `tetris_ai_example.py` | Distributed Tetris AI via genetic algorithm |
+
+To run the examples, install the additional dependencies:
+
+```bash
+pip install -r requirements_examples.txt
+```
+
+Then launch a server and one or more clients:
+
+```bash
+python examples/pygame_example.py server    # Terminal 1
+python examples/pygame_example.py           # Terminal 2
+```
+
+## License
+
+MIT

py_easysync-0.1.0/py_easysync.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+easysync/__init__.py
+easysync/syncclient.py
+easysync/syncedobject.py
+easysync/syncserver.py
+py_easysync.egg-info/PKG-INFO
+py_easysync.egg-info/SOURCES.txt
+py_easysync.egg-info/dependency_links.txt
+py_easysync.egg-info/top_level.txt

py_easysync-0.1.0/py_easysync.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_easysync-0.1.0/py_easysync.egg-info/top_level.txt

@@ -0,0 +1 @@
+easysync

py_easysync-0.1.0/setup.cfg

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

py_easysync-0.1.0/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="py-easysync",
+    version="0.1.0",
+    author="GalTechDev",
+    description="Universal real-time state synchronization for Python.",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/GalTechDev/easysync",
+    packages=find_packages(),
+    python_requires=">=3.10",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: System :: Networking",
+        "Topic :: Software Development :: Libraries",
+    ],
+)