socketflow 0.1.0__tar.gz → 0.1.2__tar.gz

{socketflow-0.1.0 → socketflow-0.1.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: socketflow
-Version: 0.1.0
-Summary: An asynchronous networking library for Python with advanced features
+Version: 0.1.2
+Summary: TCP networking for Python, without the boilerplate.
 Home-page: https://github.com/ayammaximilian/socketflow
 Author: SocketFlow Team
 Author-email: contact@socketflow.dev
@@ -9,7 +9,7 @@ License: MIT
 Project-URL: Bug Reports, https://github.com/ayammaximilian/socketflow/issues
 Project-URL: Source, https://github.com/ayammaximilian/socketflow
 Project-URL: Documentation, https://socketflow.dev
-Keywords: networking,tcp,socket,server,client,async,asyncio,real-time,messaging,clustering,ssl,tls,encryption,compression,middleware,events,blueprint,failover,load-balancing,redis,distributed
+Keywords: networking,tcp,socket,server,client,real-time,messaging,clustering,ssl,tls,encryption,compression,middleware,events,blueprint,failover,load-balancing,redis,distributed
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{socketflow-0.1.0 → socketflow-0.1.2}/setup.py

@@ -1,9 +1,6 @@
 #!/usr/bin/env python3
 """
-Setup script for SocketFlow - An asynchronous networking library for Python.
-
-SocketFlow provides both server and client functionality with advanced features like
-clustering, compression, middleware, event handling, SSL/TLS encryption, and more.
+TCP networking for Python, without the boilerplate.
 """
 
 from setuptools import setup, find_packages
@@ -32,7 +29,7 @@ setup(
     version=get_version(),
     author="SocketFlow Team",
     author_email="contact@socketflow.dev",
-    description="An asynchronous networking library for Python with advanced features",
+    description="TCP networking for Python, without the boilerplate.",
     long_description=read_readme(),
     long_description_content_type="text/markdown",
     url="https://github.com/ayammaximilian/socketflow",
@@ -71,8 +68,6 @@ setup(
         "socket",
         "server",
         "client",
-        "async",
-        "asyncio",
         "real-time",
         "messaging",
         "clustering",

{socketflow-0.1.0 → socketflow-0.1.2}/socketflow/__init__.py

@@ -20,7 +20,7 @@ from .global_side.exceptions import (
     ExceptionType,
 )
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 __all__ = [
     "TcpServer",
     "TcpClient",

{socketflow-0.1.0 → socketflow-0.1.2}/socketflow/client_side/client.py

@@ -12,7 +12,7 @@ from ..global_side.compression import MultiCompressor
 from ..global_side.message_manager import message_manager
 from ..global_side.message_handler import message_handler
 from ..global_side.exceptions import ExceptionType
-from typing import Optional, Union
+from typing import Any, Optional, Union
 import uuid
 import time
 import concurrent.futures
@@ -254,7 +254,7 @@ class TcpClient:
             self.dispatcher.emit(
                 EventType.Global.ERROR, ErrorData(error=e, context="client.connect")
             )
-            raise
+            raise ExceptionType.ConnectionError(f"Connection error: {str(e)}")
 
     def _receive_loop(self):
         """Main receive loop"""
@@ -278,7 +278,7 @@ class TcpClient:
 
     def send(
         self,
-        data: Union[bytes, str],
+        data: Any,
         data_id: Optional[str] = None,
         path: Optional[str] = None,
         wait_response: bool = False,

{socketflow-0.1.0 → socketflow-0.1.2}/socketflow/global_side/blueprint.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Callable, Optional
+from typing import Any, Dict, List, Callable, Optional
 from .exceptions import ExceptionType
 
 
@@ -74,7 +74,7 @@ class Blueprint:
 
     def send(
         self,
-        data: bytes,
+        data: Any,
         data_id: Optional[str] = None,
         path: Optional[str] = None,
         wait_response: bool = False,
@@ -90,7 +90,7 @@ class Blueprint:
     def send_client(
         self,
         client_addr: tuple,
-        data: bytes,
+        data: Any,
         data_id: Optional[str] = None,
         path: Optional[str] = None,
         wait_response: bool = False,

socketflow-0.1.2/socketflow/global_side/dispatcher.py

@@ -0,0 +1,216 @@
+from typing import Dict, List, Callable, Any, Tuple
+import re
+import threading
+
+
+class EventDispatcher:
+    def __init__(self):
+        self._event_handlers: Dict[str, List[Callable]] = {}
+        self._path_handlers: Dict[str, List[Callable]] = {}
+        self._path_middleware: Dict[str, List[Callable]] = {}
+        self._path_blocking: Dict[
+            str, bool
+        ] = {}
+        self._path_locks: Dict[
+            Tuple[str, Tuple], threading.Lock
+        ] = {}  
+        self._path_patterns: List[Tuple[str, re.Pattern, List[str]]] = [] 
+        self._path_pattern_handlers: Dict[str, List[Callable]] = {} 
+        self._path_pattern_middleware: Dict[str, List[Callable]] = {} 
+        self._path_pattern_blocking: Dict[str, bool] = {}  
+        self._server = None
+        self._client = None
+
+    def event(self, event_type: str):
+        """Decorator for event handlers"""
+
+        def decorator(func):
+            self.register_event(event_type, func)
+            return func
+
+        return decorator
+
+    def path(self, path: str, middleware=None, block: bool = False):
+        """Decorator for path handlers"""
+
+        def decorator(func):
+            self.register_path(path, func, middleware, block)
+            return func
+
+        return decorator
+
+    def register_event(self, event_type: str, handler: Callable):
+        """Register an event handler"""
+        if event_type not in self._event_handlers:
+            self._event_handlers[event_type] = []
+        self._event_handlers[event_type].append(handler)
+
+    def _path_to_regex(self, path: str):
+        """Convert a path with <param> placeholders to a regex pattern.
+
+        Example: /file-manager/<ID> -> (^/file-manager/(?P<ID>[^/]+)$), ['ID']
+        Returns (compiled_regex, param_names) or (None, []) if no placeholders.
+        """
+        param_names = re.findall(r"<(\w+)>", path)
+        if not param_names:
+            return None, []
+
+        # Escape everything except the <param> placeholders, then replace them
+        parts = re.split(r"(<\w+>)", path)
+        regex_parts = []
+        for part in parts:
+            m = re.match(r"<(\w+)>", part)
+            if m:
+                regex_parts.append(f"(?P<{m.group(1)}>[^/]+)")
+            else:
+                regex_parts.append(re.escape(part))
+
+        return re.compile("^" + "".join(regex_parts) + "$"), param_names
+
+    def register_path(
+        self, path: str, handler: Callable, middleware=None, block: bool = False
+    ):
+        """Register a path handler"""
+        regex, param_names = self._path_to_regex(path)
+        if regex is not None:
+            # This is a parameterized path pattern
+            # Register the pattern if not already known
+            if not any(p[0] == path for p in self._path_patterns):
+                self._path_patterns.append((path, regex, param_names))
+            # Store handler
+            if path not in self._path_pattern_handlers:
+                self._path_pattern_handlers[path] = []
+            self._path_pattern_handlers[path].append(handler)
+            # Store middleware
+            if middleware:
+                if path not in self._path_pattern_middleware:
+                    self._path_pattern_middleware[path] = []
+                if isinstance(middleware, list):
+                    self._path_pattern_middleware[path].extend(middleware)
+                else:
+                    self._path_pattern_middleware[path].append(middleware)
+            # Store blocking
+            if block:
+                self._path_pattern_blocking[path] = True
+        else:
+            # Exact path match
+            if path not in self._path_handlers:
+                self._path_handlers[path] = []
+            self._path_handlers[path].append(handler)
+
+            # Track if this path has blocking enabled
+            if block:
+                self._path_blocking[path] = True
+
+            # Register middleware separately if provided
+            if middleware:
+                if isinstance(middleware, list):
+                    for m in middleware:
+                        self.register_path_middleware(path, m)
+                else:
+                    self.register_path_middleware(path, middleware)
+
+    def register_path_middleware(self, path: str, middleware: Callable):
+        """Register path middleware"""
+        if path not in self._path_middleware:
+            self._path_middleware[path] = []
+        self._path_middleware[path].append(middleware)
+
+    def emit(self, event_type: str, data: Any):
+        """Emit event"""
+
+        def _run_handlers():
+            if event_type in self._event_handlers:
+                for handler in self._event_handlers[event_type]:
+                    try:
+                        handler(data)
+                    except Exception:
+                        pass
+
+        threading.Thread(target=_run_handlers, daemon=True).start()
+
+    def emit_path(self, path: str, data: Any):
+        """Emit path event"""
+
+        def _run_path_handlers():
+            # Extract client identifier for blocking
+            client_id = None
+            if hasattr(data, "client_addr") and data.client_addr:
+                client_id = data.client_addr
+            elif hasattr(data, "server_addr") and data.server_addr:
+                client_id = data.server_addr
+
+            # Try exact match first, then pattern matching
+            matched_pattern = None
+            params = {}
+
+            if path in self._path_handlers:
+                # Exact match found
+                handlers = self._path_handlers[path]
+                middleware_list = self._path_middleware.get(path, [])
+                is_blocking = self._path_blocking.get(path, False)
+            else:
+                # Try pattern matching
+                for pat_str, regex, param_names in self._path_patterns:
+                    m = regex.match(path)
+                    if m:
+                        matched_pattern = pat_str
+                        params = m.groupdict()
+                        handlers = self._path_pattern_handlers.get(pat_str, [])
+                        middleware_list = self._path_pattern_middleware.get(pat_str, [])
+                        is_blocking = self._path_pattern_blocking.get(pat_str, False)
+                        break
+                else:
+                    return  # No matching path or pattern
+
+            # Check if blocking is enabled for this path and we have a client ID
+            lock = None
+            if is_blocking and client_id:
+                lock_key = (path, client_id)
+                # Get or create lock for this client-path combination
+                if lock_key not in self._path_locks:
+                    self._path_locks[lock_key] = threading.Lock()
+                lock = self._path_locks[lock_key]
+                lock.acquire()
+
+            try:
+                # Run middleware first
+                current_data = data
+                for middleware_func in middleware_list:
+                    try:
+                        result = middleware_func(current_data)
+                        if result is False:  # Middleware rejected the request
+                            return
+                        elif result is not None:  # Middleware modified the data
+                            current_data = result
+                    except Exception:
+                        # Middleware failed, don't proceed to handlers
+                        return
+
+                # Run path handlers
+                for handler in handlers:
+                    try:
+                        if params:
+                            try:
+                                handler(current_data, **params)
+                            except TypeError:
+                                # Handler doesn't accept kwargs, pass without params
+                                handler(current_data)
+                        else:
+                            handler(current_data)
+                    except Exception:
+                        pass
+            finally:
+                # Release lock if we acquired one
+                if lock:
+                    lock.release()
+
+        threading.Thread(target=_run_path_handlers, daemon=True).start()
+
+    def register_blueprint(self, blueprint):
+        """Register a blueprint"""
+        blueprint.register_with_dispatcher(self)
+
+    def set_event_loop(self, loop):
+        """Compatibility method - not needed for sync version"""
+        pass

{socketflow-0.1.0 → socketflow-0.1.2}/socketflow/global_side/event.py

@@ -1,5 +1,5 @@
-from dataclasses import dataclass
-from typing import Any, Optional, Tuple
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional, Tuple
 
 
 @dataclass
@@ -32,6 +32,7 @@ class MessageReceivedData:
     client_addr: Optional[Tuple[str, int]] = None
     server_addr: Optional[Tuple[str, int]] = None
     data_id: Optional[str] = None
+    params: Dict[str, str] = field(default_factory=dict)
 
 
 @dataclass

{socketflow-0.1.0 → socketflow-0.1.2}/socketflow/global_side/exceptions.py

@@ -27,6 +27,12 @@ class ConnectionTimeout(SocketFlowException):
     pass
 
 
+class ConnectionError(SocketFlowException):
+    """Raised when connection error occurs"""
+
+    pass
+
+
 class KeepaliveTimeout(SocketFlowException):
     """Raised when keepalive timeout occurs"""
 
@@ -98,3 +104,4 @@ class ExceptionType:
     CompressionError = CompressionError
     MessageHandlerError = MessageHandlerError
     DispatcherError = DispatcherError
+    ConnectionError = ConnectionError

{socketflow-0.1.0 → socketflow-0.1.2}/socketflow/server_side/server.py

@@ -1,23 +1,24 @@
-import threading
+import concurrent.futures
 import socket as socket_module
+import threading
+import time
+import uuid
+from typing import Any, Optional
+
+from ..global_side.compression import MultiCompressor
+from ..global_side.dispatcher import EventDispatcher
 from ..global_side.event import (
-    EventType,
     ClientConnectData,
     ClientDisconnectData,
-    MessageReceivedData,
     ErrorData,
+    EventType,
+    MessageReceivedData,
     ServerStartData,
     ServerStopData,
 )
-from ..global_side.dispatcher import EventDispatcher
-from ..global_side.compression import MultiCompressor
-from ..global_side.message_manager import message_manager
-from ..global_side.message_handler import message_handler
 from ..global_side.exceptions import ExceptionType
-from typing import Optional
-import uuid
-import time
-import concurrent.futures
+from ..global_side.message_handler import message_handler
+from ..global_side.message_manager import message_manager
 
 
 class TcpServerProtocol:
@@ -291,7 +292,7 @@ class TcpServer:
     def send_client(
         self,
         client_addr: tuple,
-        data: bytes,
+        data: Any,
         data_id: Optional[str] = None,
         path: Optional[str] = None,
         wait_response: bool = False,

{socketflow-0.1.0 → socketflow-0.1.2}/socketflow.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: socketflow
-Version: 0.1.0
-Summary: An asynchronous networking library for Python with advanced features
+Version: 0.1.2
+Summary: TCP networking for Python, without the boilerplate.
 Home-page: https://github.com/ayammaximilian/socketflow
 Author: SocketFlow Team
 Author-email: contact@socketflow.dev
@@ -9,7 +9,7 @@ License: MIT
 Project-URL: Bug Reports, https://github.com/ayammaximilian/socketflow/issues
 Project-URL: Source, https://github.com/ayammaximilian/socketflow
 Project-URL: Documentation, https://socketflow.dev
-Keywords: networking,tcp,socket,server,client,async,asyncio,real-time,messaging,clustering,ssl,tls,encryption,compression,middleware,events,blueprint,failover,load-balancing,redis,distributed
+Keywords: networking,tcp,socket,server,client,real-time,messaging,clustering,ssl,tls,encryption,compression,middleware,events,blueprint,failover,load-balancing,redis,distributed
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

socketflow-0.1.0/socketflow/global_side/dispatcher.py

@@ -1,104 +0,0 @@
-from typing import Dict, List, Callable, Any
-import threading
-
-
-class EventDispatcher:
-    def __init__(self):
-        self._event_handlers: Dict[str, List[Callable]] = {}
-        self._path_handlers: Dict[str, List[Callable]] = {}
-        self._path_middleware: Dict[str, List[Callable]] = {}
-        self._server = None
-        self._client = None
-
-    def event(self, event_type: str):
-        """Decorator for event handlers"""
-
-        def decorator(func):
-            self.register_event(event_type, func)
-            return func
-
-        return decorator
-
-    def path(self, path: str, middleware=None):
-        """Decorator for path handlers"""
-
-        def decorator(func):
-            self.register_path(path, func, middleware)
-            return func
-
-        return decorator
-
-    def register_event(self, event_type: str, handler: Callable):
-        """Register an event handler"""
-        if event_type not in self._event_handlers:
-            self._event_handlers[event_type] = []
-        self._event_handlers[event_type].append(handler)
-
-    def register_path(self, path: str, handler: Callable, middleware=None):
-        """Register a path handler"""
-        if path not in self._path_handlers:
-            self._path_handlers[path] = []
-        self._path_handlers[path].append(handler)
-
-        # Register middleware separately if provided
-        if middleware:
-            if isinstance(middleware, list):
-                for m in middleware:
-                    self.register_path_middleware(path, m)
-            else:
-                self.register_path_middleware(path, middleware)
-
-    def register_path_middleware(self, path: str, middleware: Callable):
-        """Register path middleware"""
-        if path not in self._path_middleware:
-            self._path_middleware[path] = []
-        self._path_middleware[path].append(middleware)
-
-    def emit(self, event_type: str, data: Any):
-        """Emit event"""
-
-        def _run_handlers():
-            if event_type in self._event_handlers:
-                for handler in self._event_handlers[event_type]:
-                    try:
-                        handler(data)
-                    except Exception:
-                        pass
-
-        threading.Thread(target=_run_handlers, daemon=True).start()
-
-    def emit_path(self, path: str, data: Any):
-        """Emit path event"""
-
-        def _run_path_handlers():
-            # Run middleware first
-            current_data = data
-            if path in self._path_middleware:
-                for middleware_func in self._path_middleware[path]:
-                    try:
-                        result = middleware_func(current_data)
-                        if result is False:  # Middleware rejected the request
-                            return
-                        elif result is not None:  # Middleware modified the data
-                            current_data = result
-                    except Exception:
-                        # Middleware failed, don't proceed to handlers
-                        return
-
-            # Run path handlers
-            if path in self._path_handlers:
-                for handler in self._path_handlers[path]:
-                    try:
-                        handler(current_data)
-                    except Exception:
-                        pass
-
-        threading.Thread(target=_run_path_handlers, daemon=True).start()
-
-    def register_blueprint(self, blueprint):
-        """Register a blueprint"""
-        blueprint.register_with_dispatcher(self)
-
-    def set_event_loop(self, loop):
-        """Compatibility method - not needed for sync version"""
-        pass