ephaptic 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

ephaptic/__init__.py

@@ -1,11 +1,16 @@
 from .ephaptic import (
     Ephaptic,
-    active_user,
     expose,
     identity_loader,
     event,
 )
 
 from .client import (
-    connect
+    connect,
+)
+
+from .ctx import (
+    is_http,
+    is_rpc,
+    active_user,
 )

ephaptic/cli/__main__.py

@@ -1,13 +1,47 @@
-import sys, os, json, inspect, importlib, typing, typer, subprocess as sp
+import sys, os, subprocess as sp
+import json, re
+import inspect, importlib, typing
+from pathlib import Path
+
+import typer
 
 from pathlib import Path
 from pydantic import TypeAdapter
-from pydantic.json_schema import models_json_schema
 
 from ephaptic import Ephaptic
+from ephaptic.decorators import META_KEY
+
+from typing import *
 
 app = typer.Typer(help="Ephaptic CLI tool.")
 
+IDENTIFIER_REGEX = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*$')
+
+LOG: List[str] = []
+
+def log(*data):
+    global LOG
+    LOG.append(' '.join(data))
+
+def clear_log():
+    global LOG
+    LOG = []
+
+def key_name(key: str) -> str:
+    if IDENTIFIER_REGEX.match(key): return key
+    else: return json.dumps(key)
+
+def validate(name: str) -> str:
+    if IDENTIFIER_REGEX.match(name):
+        safe = re.sub(r'[^a-zA-Z0-9_$]', '_', name)
+        log(typer.style("[warning] '{name}' is not a valid identifier. sanitizing to '{safe}'", fg=typer.colors.YELLOW))
+        return safe
+    return name
+
+def load_schema(input_path: str | Path):
+    return json.loads(Path(input_path).read_text())
+    # errors can be handled by typer
+
 def load_ephaptic(import_name: str) -> Ephaptic:
     try:
         from dotenv import load_dotenv; load_dotenv()
@@ -16,30 +50,245 @@ def load_ephaptic(import_name: str) -> Ephaptic:
     sys.path.insert(0, os.getcwd())
 
     if ":" not in import_name:
-        typer.secho(f"Warning: Import name did not specify client name. Defaulting to `client`.", fg=typer.colors.YELLOW)
+        log(typer.style(f"Warning: Import name did not specify client name. Defaulting to `client`.", fg=typer.colors.YELLOW))
         import_name += ":client" # default: expect client to be named `client` inside the file
 
     module_name, var_name = import_name.split(":", 1)
 
     try:
-        typer.secho(f"Attempting to import `{var_name}` from `{module_name}`...")
+        log(typer.style(f"Attempting to import `{var_name}` from `{module_name}`..."))
         module = importlib.import_module(module_name)
     except ImportError as e:
-        typer.secho(f"Error: Can't import '{module_name}'.\n{e}", fg=typer.colors.RED)
+        typer.echo(typer.style(f"Error: Can't import '{module_name}'.\n{e}", fg=typer.colors.RED))
         raise typer.Exit(1)
     
     try:
         instance = getattr(module, var_name)
     except AttributeError:
-        typer.secho(f"Error: Variable '{var_name}' not found in module '{module_name}'.", fg=typer.colors.RED)
+        typer.echo(typer.style(f"Error: Variable '{var_name}' not found in module '{module_name}'.", fg=typer.colors.RED))
         raise typer.Exit(1)
     
     if not isinstance(instance, Ephaptic):
-        typer.secho(f"Error: '{var_name}' is not an Ephaptic client. It is type: {type(instance)}", fg=typer.colors.RED)
+        typer.echo(typer.style(f"Error: '{var_name}' is not an Ephaptic client. It is type: {type(instance)}", fg=typer.colors.RED))
         raise typer.Exit(1)
     
     return instance
 
+def TS_resolve_type(schema: Dict[str, Any]) -> str:
+    if not schema: return 'any'
+    if schema.get('$ref'): return validate(schema['$ref'].split('/').pop() or 'any')
+    if schema.get('enum'): return ' | '.join([json.dumps(val) for val in schema['enum']])
+    if schema.get('anyOf'): return ' | '.join({TS_resolve_type(s) for s in schema['anyOf']})
+    if schema.get('type') == 'array': return f"{TS_resolve_type(schema['items']) if schema.get('items') else 'any'}[]"
+    if schema.get('type') in ('integer', 'number'): return 'number'
+    if schema.get('type') == 'boolean': return 'boolean'
+    if schema.get('type') == 'string': return 'string'
+    if schema.get('type') == 'null': return 'null'
+
+    if schema['type'] == 'object':
+        if not schema.get('properties'): return 'Record<string, any>'
+        props = [
+            f"{key_name(key)}{'' if key in schema.get('required', []) else '?'}: {TS_resolve_type(prop_schema)}"
+            for key, prop_schema in schema['properties'].items()
+        ]
+        return '{ ' + '; '.join(props) + ' }'
+    
+    return 'any'
+
+def TS_generate(data: dict):
+    lines: List[str] = []
+
+    lines.extend([
+        '/**',
+        ' * Auto-generated by ephaptic',
+        ' * Do not edit this file manually.',
+        ' * */',
+        '',
+        'import { type EphapticClientBase } from "@ephaptic/client";',
+        '',
+        'export type EphapticQuery<TArgs extends any[], TReturn> = { queryKey: [string, ...TArgs]; queryFn: () => Promise<TReturn>; }'
+        '',
+    ])
+
+    for name, schema in data.get('definitions', {}).items():
+        name = validate(name)
+        if schema['type'] == 'object':
+            lines.append(f'export interface {name} {{')
+            lines.extend([
+                f"  {validate(prop_name)}{'' if prop_name in schema.get('required', []) else '?'}: {TS_resolve_type(prop_schema)};"
+                for prop_name, prop_schema in schema['properties'].items()
+            ])
+            lines.append('}')
+            lines.append('')
+        else:
+            lines.append(f'export type {name} = {TS_resolve_type(schema)};')
+            lines.append('')
+
+    lines.append('export interface EphapticEvents {')
+    lines.extend([
+        f" {validate(event_name)}: {TS_resolve_type(event_schema)};"
+        for event_name, event_schema in data.get('events', {}).items()
+    ])
+    lines.append('}')
+    lines.append('')
+
+    lines.append('export interface EphapticService extends EphapticClientBase {')
+    lines.append('')
+
+    for method_name, method_data in data.get('methods', {}).items():
+        args: List[str] = []
+
+        args.extend([
+            f"{validate(arg_name)}{'' if arg_name in method_data.get('required', []) else '?'}: {TS_resolve_type(arg_schema)}"
+            for arg_name, arg_schema in method_data.get('args', {}).items()
+        ])
+        
+        return_type = TS_resolve_type(method_data['return']) if method_data.get('return') else 'void'
+
+        lines.append(f"  {validate(method_name)}({', '.join(args)}): Promise<{return_type}>;")
+
+    lines.append('')
+    lines.append('  queries: {')
+
+    for method_name, method_data in data.get('methods', {}).items():
+        args: List[str] = []
+
+        args.extend([
+            f"{validate(arg_name)}{'' if arg_name in method_data.get('required', {}) else '?'}: {TS_resolve_type(arg_schema)}"
+            for arg_name, arg_schema in method_data.get('args', {}).items()
+        ])
+
+        arg_types = [TS_resolve_type(arg_schema) for arg_schema in method_data.get('args', {}).values()]
+        
+        return_type = TS_resolve_type(method_data['return']) if method_data.get('return') else 'void'
+
+        lines.append(f"     {validate(method_name)}({', '.join(args)}): EphapticQuery<[{', '.join(arg_types)}], {return_type}>;")
+
+    lines.append('  };')
+
+    lines.append('')
+
+    lines.append('    on<K extends keyof EphapticEvents>(event: K, callback: (data: EphapticEvents[K]) => void): void;')
+    lines.append('    off<K extends keyof EphapticEvents>(event: K, callback: (data: EphapticEvents[K]) => void): void;')
+    lines.append('    once<K extends keyof EphapticEvents>(event: K, callback: (data: EphapticEvents[K]) => void): void;')
+
+    lines.append('}');
+    lines.append('');
+
+    lines.extend([
+        '/**',
+        ' * Usage:',
+        ' * import { connect } from "@ephaptic/client";',
+        ' * import { type EphapticService } from "./ephaptic";',
+        ' * ',
+        ' * const client = connect(...) as unknown as EphapticService;',
+        ' */',
+    ])
+
+    return lines
+
+def KT_resolve_type(schema: Dict[str, Any]) -> str:
+    if not schema: return 'Any?'
+    if schema.get('$ref'): return validate(schema['$ref'].split('/').pop() or 'Any')
+    if schema.get('enum') and len(schema['enum']) > 0:
+        first = schema['enum'][0]
+        if isinstance(first, str): return 'String'
+        if isinstance(first, int): return 'Int'
+        if isinstance(first, float): return 'Double'
+        if isinstance(first, bool): return 'Boolean'
+        return 'Any?'
+    if schema.get('anyOf'):
+        nonNull = [t for t in schema['anyOf'] if t['type'] != 'null']
+        if len(nonNull) == 1:
+            type = KT_resolve_type(nonNull[0])
+            if not type.endswith('?'): type += '?'
+            return type
+        return 'Any?'
+    if schema.get('type') == 'array': return f"List<{KT_resolve_type(schema['items']) if schema.get('items') else 'Any?'}>"
+    if schema.get('type') == 'integer': return 'Long'
+    if schema.get('type') == 'boolean': return 'Boolean'
+    if schema.get('type') == 'string': return 'String'
+    if schema.get('type') == 'null': return 'Nothing?'
+    if schema.get('type') == 'object': return 'Map<String, Any?>'
+    return 'Any?'
+
+def KT_generate(data: dict, package_name: str):
+    lines: List[str] = []
+
+    lines.extend([
+        '/**',
+        ' * Auto-generated by ephaptic',
+        ' * Do not edit this file manually.',
+        ' * */',
+        '',
+        f'package {package_name}',
+        '',
+        'import com.squareup.moshi.JsonClass',
+        'import com.ephaptic.android.EphapticClient',
+        'import com.ephaptic.android.EphapticException',
+        '',
+    ])
+
+    for name, schema in data.get('definitions', {}).items():
+        name = validate(name)
+        if schema['type'] == 'object':
+            lines.append('@JsonClass(generateAdapter = true)')
+            lines.append(f'data class {name}(')
+            
+            for prop_name, prop_schema in schema['properties'].items():
+                kt_type = KT_resolve_type(prop_schema)
+                
+                required = prop_name in schema.get('required', [])
+                explicit_null = prop_schema.get('type') == 'null'
+                union_null = any(t.get('type') == 'null' for t in prop_schema.get('anyOf', []))
+                
+                nullable = not required or explicit_null or union_null               
+                if nullable and not kt_type.endswith('?'): kt_type += '?'
+
+                lines.append(f"  val {validate(prop_name)}: {kt_type}{' = null' if nullable else ''},")
+                
+            lines.append(')')
+            lines.append('')
+        else:
+            lines.append(f'typealias {name} = {KT_resolve_type(schema)}')
+            lines.append('')
+
+    lines.append('sealed class EphapticEvent')
+    lines.extend([
+        f"  data class {validate(event_name)}(val data: {KT_resolve_type(event_schema)}): EphapticEvent()"
+        for event_name, event_schema in data.get('events', {}).items()
+    ])
+    lines.append('}')
+    lines.append('')
+
+    lines.append('class EphapticService(private val client: EphapticClient) {')
+    lines.append('')
+
+    for method_name, method_data in data.get('methods', {}).items():
+        args: List[str] = []
+        params: List[str] = []
+
+        for arg_name, arg_schema in method_data.get('args', {}).items():
+            is_req = arg_name in method_data.get('required', [])
+            kt_type = KT_resolve_type(arg_schema)
+
+            if not is_req and not kt_type.endswith('?'): kt_type += '?'
+
+            args.append(f"{validate(arg_name)}: {kt_type}")
+            params.append(validate(arg_name))
+
+        return_type = KT_resolve_type(method_data['return']) if method_data.get('return') else 'Any?'
+
+        lines.append(f" suspend fun {validate(method_name)}({', '.join(args)}): {return_type} {{")
+        lines.append(f'      return client.request<{return_type}>("{method_name}", {", ".join(params)})')
+        lines.append('  }')
+        lines.append('')
+
+    lines.append('}')
+    lines.append('')
+
+    return lines
+
 def create_schema(adapter: TypeAdapter, definitions: dict) -> dict:
     schema = adapter.json_schema(ref_template='#/definitions/{model}')
 
@@ -58,12 +307,69 @@ def run_subprocess():
     cmd += [arg for arg in sys.argv if arg not in {'--watch', '-w'}]
     sp.run(cmd)
 
+def calculate_language(lang: str, output: Path):
+    if lang is None:
+        if not output or str(output) == '-': raise ValueError("You must specify a language or an output path.")
+        lang = os.path.splitext(output)[-1]
+    
+    map = {
+        'kotlin': 'kt',
+        'typescript': 'ts',
+    }
+
+    if lang in map: lang = map[lang]
+
+    if output is None:
+        match lang:
+            case 'ts':
+                output = Path('ephaptic.d.ts')
+            case 'kt':
+                output = Path('Ephaptic.kt')
+            case _:
+                output = Path('schema.json')
+
+    return lang, output
+
+class NothingToChange(Exception): ...
+
+def generate_output(lang, schema_output, package_name, output: Path):
+    content = None
+    match lang:
+        case 'json':
+            content = json.dumps(schema_output, indent=2)
+        case 'ts':
+            content = '\n'.join(TS_generate(schema_output))
+        case 'kt':
+            content = '\n'.join(KT_generate(schema_output, package_name))
+
+    if str(output) == '-':
+        print(content)
+        return
+
+    if output.exists():
+        if output.read_text() == content:
+            return
+        else:
+            output.write_text(content)
+
+    for line in LOG:
+        typer.echo(line)
+
+    clear_log()
+
+    typer.secho(f"Schema generated to `{output}`.", fg=typer.colors.GREEN, bold=True)
+
+
 @app.command()
 def generate(
-    client: str = typer.Argument('client:client', help="The import string for the Ephaptic client."),
-    output: Path = typer.Option('schema.json', '--output', '-o', help="Output path for the JSON schema."),
+    client: str = typer.Argument('app:client', help="The import string for the Ephaptic client."),
+    output: Path = typer.Option(None, '--output', '-o', help="Output path for the generated file (default: schema.json / ephaptic.d.ts / Ephaptic.kt)."),
     watch: bool = typer.Option(False, '--watch', '-w', help="Watch for changes in `.py` files and regenerate schema file automatically."),
+    lang: str = typer.Option(None, '--lang', '-l', help="Output language ('json', 'kotlin', 'kt', 'typescript', 'ts') (default: autodetected from output path)"),
+    package_name: str = typer.Option('com.example.app', '--package-name', '-p', help="Package name (required for Kotlin)")
 ):
+    lang, output = calculate_language(lang, output)
+
     if watch:
         import watchfiles
         
@@ -77,6 +383,8 @@ def generate(
                 typer.secho("Detected changes, regenerating...")
                 run_subprocess()
 
+        return
+
     ephaptic = load_ephaptic(client)
 
     schema_output = {
@@ -85,13 +393,15 @@ def generate(
         "definitions": {},
     }
 
-    typer.secho(f"Found {len(ephaptic._exposed_functions)} functions.", fg=typer.colors.GREEN)
+    log(typer.style("--- Functions ---"))
 
     for name, func in ephaptic._exposed_functions.items():
-        typer.secho(f"  - {name}")
+        log(typer.style(f"  - {name}"))
+
+        meta = getattr(func, META_KEY, {})
 
-        hints = typing.get_type_hints(func)
-        sig = inspect.signature(func)
+        hints = meta.get('hints') or typing.get_type_hints(func)
+        sig = meta.get('sig') or inspect.signature(func)
 
         method_schema = {
             "args": {},
@@ -108,6 +418,8 @@ def generate(
                 schema_output["definitions"],
             )
 
+            log(typer.style(f"    - {param_name}: {hint} = {param.default}"))
+
             if param.default == inspect.Parameter.empty:
                 method_schema["required"].append(param_name)
             else:
@@ -115,8 +427,8 @@ def generate(
 
             
 
-        return_hint = hints.get("return", typing.Any)
-        if return_hint is not type(None):
+        return_hint = meta.get('response_model') or hints.get("return", typing.Any)
+        if return_hint and return_hint is not type(None):
             adapter = TypeAdapter(return_hint)
             method_schema["return"] = create_schema(
                 adapter,
@@ -125,10 +437,11 @@ def generate(
 
         schema_output["methods"][name] = method_schema
 
-    typer.secho(f"Found {len(ephaptic._exposed_events)} events.", fg=typer.colors.GREEN)
+    log(typer.style("--- Events ---"))
+
 
     for name, model in ephaptic._exposed_events.items():
-        typer.secho(f"  - {name}")
+        log(typer.style(f"  - {name}"))
         adapter = TypeAdapter(model)
 
         schema_output["events"][name] = create_schema(
@@ -136,17 +449,38 @@ def generate(
             schema_output["definitions"],
         )
 
-    new = json.dumps(schema_output, indent=2)
+    generate_output(lang, schema_output, package_name, output)
 
-    if output.exists():
-        old = output.read_text()
-        if old == new:
-            return
+@app.command()
+def from_schema(
+    schema_path: Path = typer.Option('schema.json', help="Path to the schema file."),
+    output: Path = typer.Option(None, '--output', '-o', help="Output path for the generated file (default: ephaptic.d.ts / Ephaptic.kt)."),
+    watch: bool = typer.Option(False, '--watch', '-w', help="Watch for changes in `.py` files and regenerate schema file automatically."),
+    lang: str = typer.Option(None, '--lang', '-l', help="Output language ('kotlin', 'kt', 'typescript', 'ts') (default: autodetected from output path)"),
+    package_name: str = typer.Option('com.example.app', '--package-name', '-p', help="Package name (required for Kotlin)")
+):
+    lang, output = calculate_language(lang, output)
 
-    with open(output, "w") as f:
-        f.write(new)
 
-    typer.secho(f"Schema generated to `{output}`.", fg=typer.colors.GREEN, bold=True)
+    if watch:
+        import watchfiles
+        
+        typer.secho(f"Watching for changes ({schema_path})...",  fg=typer.colors.GREEN)
+
+        run_subprocess()
+
+        for changes in watchfiles.watch(schema_path):
+            if any(Path(f).name == schema_path.name for _, f in changes):
+                typer.secho("Detected changes, regenerating...")
+                run_subprocess()
+
+        return
+    
+    schema_output = json.loads(schema_path.read_text())
+
+    generate_output(lang, schema_output, package_name, output)
+
+click = typer.main.get_command(app)
 
 if __name__ == "__main__":
-    app()
+    app()

ephaptic/ctx.py

@@ -0,0 +1,10 @@
+from contextvars import ContextVar
+
+_scope_ctx = ContextVar('ephaptic_scope', default='rpc')
+_active_transport_ctx = ContextVar('active_transport', default=None)
+_active_user_ctx = ContextVar('active_user', default=None)
+
+def is_http() -> bool: return _scope_ctx.get() == 'http'
+def is_rpc()  -> bool: return _scope_ctx.get() == 'rpc'
+
+def active_user(): return _active_user_ctx.get()

ephaptic/decorators.py

@@ -0,0 +1,87 @@
+from typing import *
+import inspect
+import pydantic
+from .utils import parse_limit
+
+F = TypeVar('F', bound=Callable[..., Any])
+M = TypeVar('M', bound=Type[pydantic.BaseModel])
+
+META_KEY = '_ephaptic_metadata'
+
+class Expose:
+    def __init__(self, registry: Dict[str, Callable]):
+        self.registry = registry
+
+    @overload
+    def __call__(self, func: F) -> F:
+        ...
+
+    @overload
+    def __call__(
+        self,
+        *,
+        name: Optional[str] = None,
+        response_model: Optional[type] = None,
+        rate_limit: Optional[str] = None,
+        hints: Optional[dict[str, Any]] = None,
+        sig: Optional[inspect.Signature] = None,
+    ):
+        ...
+
+    def __call__(self, func=None, **kwargs):
+        def inject(f: F) -> F:
+            self.registry[kwargs.get('name') or f.__name__] = f
+
+            if kwargs.get('rate_limit'): kwargs['rate_limit'] = parse_limit(kwargs['rate_limit'])
+
+            meta = getattr(f, META_KEY, {})
+            meta.update(kwargs)
+            setattr(f, META_KEY, meta)
+
+            return f
+        
+        if func is not None and callable(func):
+            return inject(func)
+        
+        return inject
+    
+class Event:
+    def __init__(self, registry: Dict[str, Type[pydantic.BaseModel]]):
+        self.registry = registry
+
+
+    @overload
+    def __call__(self, model: M) -> M:
+        ...
+
+    @overload
+    def __call__(
+        self,
+        *,
+        name: Optional[str] = None,
+    ) -> Callable[[M], M]:
+        ...
+
+    def __call__(self, model=None, **kwargs):
+        def inject(m: M) -> M:
+            self.registry[kwargs.get('name') or m.__name__] = m
+
+            meta = getattr(m, META_KEY, {})
+            meta.update(kwargs)
+            setattr(m, META_KEY, meta)
+
+            return m
+        
+        if model is not None and isinstance(model, type) and issubclass(model, pydantic.BaseModel):
+            return inject(model)
+        
+        return inject
+
+
+class IdentityLoader:
+    def __init__(self, setter: Callable[[Callable], None]):
+        self.setter = setter
+
+    def __call__(self, func: F) -> F:
+        self.setter(func)
+        return func

ephaptic/ephaptic.py

@@ -1,25 +1,27 @@
 import asyncio
-from warnings import deprecated
+import warnings
 import msgpack
 import redis.asyncio as redis
 import pydantic
+import time
 
 from contextvars import ContextVar
 from .localproxy import LocalProxy
 
 from .transports import Transport
 
+from .decorators import META_KEY, Expose, Event, IdentityLoader
+
+from .ctx import _scope_ctx, _active_transport_ctx, _active_user_ctx
+
 import typing
 from typing import Optional, Callable, Any, List, Set, Dict
 import inspect
 
-_active_transport_ctx = ContextVar('active_transport', default=None)
-_active_user_ctx = ContextVar('active_user', default=None)
-
-active_user = LocalProxy(_active_user_ctx.get)
-
 CHANNEL_NAME = "ephaptic:broadcast"
 
+F = typing.TypeVar('F', bound=Callable[..., Any])
+
 class ConnectionManager:
     def __init__(self):
         self.active: Dict[str, Set[Transport]] = {} # Map[user_id, Set[Transport]]
@@ -74,6 +76,19 @@ manager = ConnectionManager()
 _EXPOSED_FUNCTIONS = {}
 _EXPOSED_EVENTS = {}
 _IDENTITY_LOADER: Optional[Callable] = None
+_HTTP_IDENTITY_LOADER: Optional[Callable] = None
+
+_LOCAL_RATELIMIT_CACHE: Dict[str, List] = {} # [hits, expire_at]
+# if redis isn't set up, assume that this is the only instance [no 'multiple nodes'] so ratelimits can be stored in memory.
+# only used when Redis isn't set.
+_LAST_CACHE_CLEANUP = time.time() # for manual cleaning up of the cache
+
+class RatelimitExceededException(Exception):
+    retry_after: int
+
+    def __init__(self, message: str, retry_after: int):
+        super().__init__(message)
+        self.retry_after = retry_after
 
 class EphapticTarget:
     def __init__(self, user_ids: list[str]):
@@ -94,25 +109,29 @@ class EphapticTarget:
             await manager.broadcast(self.user_ids, name, list(args), dict(kwargs))
         return emitter
     
-def expose(func: Callable):
-    global _EXPOSED_FUNCTIONS
-    _EXPOSED_FUNCTIONS[func.__name__] = func
-    return func
-    
-def identity_loader(func: Callable):
+def _set_identity_loader(f):
     global _IDENTITY_LOADER
-    _IDENTITY_LOADER = func
-    return func
+    _IDENTITY_LOADER = f
+
+def _set_http_identity_loader(f):
+    global _HTTP_IDENTITY_LOADER
+    _HTTP_IDENTITY_LOADER = f
 
-def event(model: typing.Type[pydantic.BaseModel]):
-    global _EXPOSED_EVENTS
-    _EXPOSED_EVENTS[model.__name__] = model
-    return model
+expose = Expose(_EXPOSED_FUNCTIONS)
+event = Event(_EXPOSED_EVENTS)
+identity_loader = IdentityLoader(_set_identity_loader)
+http_identity_loader = IdentityLoader(_set_http_identity_loader)
 
 class Ephaptic:
     _exposed_functions: Dict[str, Callable] = {}
     _exposed_events: Dict[str, typing.Type[pydantic.BaseModel]]
     _identity_loader: Optional[Callable] = None
+    _http_identity_loader: Optional[Callable] = None
+
+    expose: Expose
+    event: Event
+    identity_loader: IdentityLoader
+    http_identity_loader: IdentityLoader
 
     def _async(self, func: Callable):
         async def wrapper(*args, **kwargs) -> Any:
@@ -137,10 +156,10 @@ class Ephaptic:
 
         match module:
             case "quart":
-                from .adapters.quart_ import QuartAdapter
+                from .ext.quart.adapter import QuartAdapter
                 adapter = QuartAdapter(instance, app, path, manager)
             case "fastapi":
-                from .adapters.fastapi_ import FastAPIAdapter
+                from .ext.fastapi.adapter import FastAPIAdapter
                 adapter = FastAPIAdapter(instance, app, path, manager)
             case _:
                 raise TypeError(f"Unsupported app type: {module}")
@@ -148,21 +167,50 @@ class Ephaptic:
         instance._exposed_functions = _EXPOSED_FUNCTIONS.copy()
         instance._exposed_events = _EXPOSED_EVENTS.copy()
         instance._identity_loader = _IDENTITY_LOADER
+        instance._http_identity_loader = _HTTP_IDENTITY_LOADER
 
-        return instance
+        instance.expose = Expose(instance._exposed_functions)
+        instance.event = Event(instance._exposed_events)
+        instance.identity_loader = IdentityLoader(lambda f: setattr(instance, '_identity_loader', f))
+        instance.http_identity_loader = IdentityLoader(lambda f: setattr(instance, '_http_identity_loader', f))
 
-            
-    def expose(self, func: Callable):
-        self._exposed_functions[func.__name__] = func
-        return func
-    
-    def event(self, model: typing.Type[pydantic.BaseModel]):
-        self._exposed_events[model.__name__] = model
-        return model
+        return instance
     
-    def identity_loader(self, func: Callable):
-        self._identity_loader = func
-        return func
+    async def _check_ratelimit(self, func_name: str, limit: tuple[int, int], uid: str = None, ip: str = None):
+        max_reqs, window = limit
+        identifier = f'u:{uid}' if uid else f'ip:{ip}'
+        now = time.time()
+        current_window = int(now // window)
+        reset = (current_window + 1) * window
+        key = f'ephaptic:rl:{func_name}:{identifier}:{current_window}'
+
+        if manager.redis:
+            pipe = manager.redis.pipeline()
+            pipe.incr(key)
+            pipe.expire(key, window + 1)
+            results = await pipe.execute()
+            hits = results[0]
+        else:
+            global _LAST_CACHE_CLEANUP
+            if (now - _LAST_CACHE_CLEANUP) > 60:
+                for k in [
+                    k for k, v in _LOCAL_RATELIMIT_CACHE.items()
+                    if v[1] < now
+                ]: del _LOCAL_RATELIMIT_CACHE[k]
+                _LAST_CACHE_CLEANUP = now
+
+            entry = _LOCAL_RATELIMIT_CACHE.get(key)
+            if not entry:
+                entry = [0, reset]
+                _LOCAL_RATELIMIT_CACHE[key] = entry
+
+            entry[0] += 1
+            hits = entry[0]
+
+        if hits > max_reqs:
+            retry_after = max(1, int(reset - now))
+            raise RatelimitExceededException(f'Rate Limit exceeded. Try again in {retry_after} seconds.', retry_after=retry_after)
+
     
     def to(self, *args):
         targets = []
@@ -170,25 +218,7 @@ class Ephaptic:
             if isinstance(arg, list): targets.extend(arg)
             else: targets.append(arg)
         return EphapticTarget(targets)
-    
-    def __getattr__(self, name: str):
-        @deprecated("Use `emit` and the new (typed) event system instead.")
-        async def emitter(*args, **kwargs):
-            transport: Transport = _active_transport_ctx.get()
-            if not transport:
-                raise RuntimeError(
-                    f".{name}() called outside RPC context."
-                    f"Use .to(...).{name}() to broadcast from background tasks, to specific user(s)."
-                )
-            
-            await transport.send(msgpack.dumps({
-                "type": "event",
-                "name": name,
-                "payload": {"args": list(args), "kwargs": dict(kwargs)},
-            }))
-        
-        return emitter
-    
+       
     async def emit(self, event_instance: pydantic.BaseModel):
         event_name = event_instance.__class__.__name__
         payload = event_instance.model_dump(mode='json')
@@ -239,7 +269,31 @@ class Ephaptic:
 
                     if func_name in self._exposed_functions:
                         target_func = self._exposed_functions[func_name]
-                        sig = inspect.signature(target_func)                      
+                        meta = getattr(target_func, META_KEY, {})
+
+                        if meta.get('rate_limit'):
+                            try:
+                                await self._check_ratelimit(
+                                    func_name,
+                                    meta.get('rate_limit'),
+                                    uid=current_uid,
+                                    ip=transport.remote_addr,
+                                )
+                            except RatelimitExceededException as e:
+                                await transport.send(msgpack.dumps({
+                                    "id": call_id,
+                                    "error": {
+                                        "code": "RATELIMIT",
+                                        "message": str(e),
+                                        "data": { "retry_after": e.retry_after },
+                                    },
+                                }))
+                                continue
+
+
+                        hints = meta.get('hints') or typing.get_type_hints(target_func)
+                        sig = meta.get('sig') or inspect.signature(target_func)                      
+                        
                         try:
                             bound = sig.bind(*args, **kwargs)
                             bound.apply_defaults()
@@ -247,66 +301,76 @@ class Ephaptic:
                             await transport.send(msgpack.dumps({"id": call_id, "error": str(e)}))
                             continue
 
-                        hints = typing.get_type_hints(target_func)
-
-                        return_type = hints.get("return", typing.Any)
+                        fields = {}
+                        for name, param in sig.parameters.items():
+                            if name in hints:
+                                fields[name] = (hints[name], param.default if param.default is not inspect.Parameter.empty else ...)
+                            else:
+                                fields[name] = (Any, param.default if param.default is not inspect.Parameter.empty else ...)
 
-                        errors = []
+                        DynamicInputModel = pydantic.create_model(f'DynamicInputModel_{func_name}', **fields)
 
-                        for name, val in bound.arguments.items():
-                            hint = hints.get(name)
-
-                            if hint and inspect.isclass(hint) and issubclass(hint, pydantic.BaseModel):
-                                try:
-                                    bound.arguments[name] = hint.model_validate(val)
-                                except pydantic.ValidationError as e:
-                                    errors.extend(e.errors())
-
-                        if errors:
+                        try:
+                            validated_data = DynamicInputModel(**bound.arguments)
+                            final_arguments = validated_data.model_dump()
+                        except pydantic.ValidationError as e:
                             await transport.send(msgpack.dumps({
                                 "id": call_id,
                                 "error": {
                                     "code": "VALIDATION_ERROR",
-                                    "message": "Validation failed.",
-                                    "data": errors,
+                                    "message": "Input validation failed.",
+                                    "data": e.errors(),
                                 },
                             }))
                             continue
-
+                        
                         token_transport = _active_transport_ctx.set(transport)
                         token_user = _active_user_ctx.set(current_uid)
+                        token_scope = _scope_ctx.set('rpc')
 
                         try:
-                            result = await self._async(target_func)(**bound.arguments)
+                            result = await self._async(target_func)(**final_arguments)
 
-                            if return_type is not inspect.Signature.empty:
+                            return_type = meta.get('response_model') or hints.get("return", typing.Any)
+                            if return_type and return_type is not inspect.Signature.empty and return_type is not typing.Any:
                                 try:
                                     adapter = pydantic.TypeAdapter(return_type)
                                     validated = adapter.validate_python(result, from_attributes=True)
                                     result = adapter.dump_python(validated, mode='json')
-                                except: ...
+                                except Exception as e:
+                                    # Should we really treat this separately?
+                                    # For input it's understandable, but for server responses it feels like a server issue.
+                                    # Let's just return a RETURN_VALIDATION_ERROR and print the traceback.
+                                    import traceback
+                                    traceback.print_exc()
+                                    await transport.send(msgpack.dumps({
+                                        "id": call_id,
+                                        "error": {
+                                            "code": "RETURN_VALIDATION_ERROR",
+                                            "message": f"Server returned invalid type: {e}",
+                                            "data": None,
+                                        },
+                                    }))
+                                    continue
                             elif isinstance(result, pydantic.BaseModel):
                                 result = result.model_dump(mode='json')
 
                             await transport.send(msgpack.dumps({"id": call_id, "result": result}))
-                        # except pydantic.ValidationError as e:
-                            # Should we really treat this separately?
-                            # For input it's understandable, but for server responses it feels like a server issue.
-                            # Ok, let's treat this like any other server error.
                         except Exception as e:
                             await transport.send(msgpack.dumps({"id": call_id, "error": str(e)}))
                         finally:
                             _active_transport_ctx.reset(token_transport)
                             _active_user_ctx.reset(token_user)
+                            _scope_ctx.reset(token_scope)
                     else:
                         await transport.send(msgpack.dumps({
                             "id": call_id, 
                             "error": f"Function '{func_name}' not found."
                         }))
-        except asyncio.CancelledError:
+        except (asyncio.CancelledError, Transport.ConnectionClosed):
             ...
         except Exception:
             import traceback
             traceback.print_exc()
         finally:
-            if current_uid: manager.remove(current_uid, transport)
+            if current_uid: manager.remove(current_uid, transport)

ephaptic/ext/fastapi/__init__.py

@@ -0,0 +1 @@
+from .router import Router

ephaptic/{adapters/fastapi_.py → ext/fastapi/adapter.py}

@@ -1,10 +1,13 @@
 from fastapi import FastAPI, WebSocket
-from ..transports.fastapi_ws import FastAPIWebSocketTransport
+from ...transports.fastapi_ws import FastAPIWebSocketTransport
+from .middleware import CtxMiddleware
 
 class FastAPIAdapter:
     def __init__(self, ephaptic, app: FastAPI, path, manager):
         self.ephaptic = ephaptic
 
+        app.add_middleware(CtxMiddleware, ephaptic=ephaptic)
+
         @app.websocket(path)
         async def ephaptic_ws(websocket: WebSocket):
             await websocket.accept()

ephaptic/ext/fastapi/middleware.py

@@ -0,0 +1,24 @@
+from starlette.middleware.base import BaseHTTPMiddleware
+from ...ctx import _scope_ctx
+from ...ephaptic import Ephaptic, _active_user_ctx
+
+class CtxMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, ephaptic: Ephaptic):
+        super().__init__(app)
+        self.ephaptic = ephaptic
+
+
+    async def dispatch(self, request, call_next):
+        token = _scope_ctx.set('http')
+        user_token = None
+
+        if self.ephaptic._http_identity_loader:
+            user = await self.ephaptic._async(self.ephaptic._http_identity_loader)(request)
+            if user:
+                user_token = _active_user_ctx.set(user)
+
+        try:
+            return await call_next(request)
+        finally:
+            _scope_ctx.reset(token)
+            if user_token: _active_user_ctx.reset(user_token)

ephaptic/ext/fastapi/router.py

@@ -0,0 +1,82 @@
+from typing import *
+from functools import wraps
+import inspect
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from ...ephaptic import Ephaptic, RatelimitExceededException
+from ...ctx import is_http, is_rpc, active_user
+from ...utils import parse_limit
+
+class Router(APIRouter):
+    ephaptic: Ephaptic
+
+    def __init__(self, ephaptic: Ephaptic, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.ephaptic = ephaptic
+
+    def _register(
+        self,
+        func: Callable,
+        methods: List[str],
+        path: str,
+        limit: Optional[str] = None,
+        auth: bool = False,
+        **kwargs,
+    ):
+        limit_config = parse_limit(limit) if limit else None
+
+        async def http_rl_dep(req: Request):
+            if limit_config:
+                try:
+                    await self.ephaptic._check_ratelimit(
+                        func.__name__,
+                        limit_config,
+                        ip=req.client.host
+                    )
+                except RatelimitExceededException as e:
+                    raise HTTPException(status_code=429, detail=str(e), headers={'X-Retry-After': e.retry_after})
+
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            if auth and active_user() is None:
+                raise Exception('Unauthorized') if is_rpc() else HTTPException(status_code=401, detail='Unauthorized')
+            
+            return await self.ephaptic._async(func)(*args, **kwargs)
+        
+        deps = kwargs.pop('dependencies', [])
+        if limit: deps.append(Depends(http_rl_dep))
+
+        self.add_api_route(
+            path,
+            wrapper,
+            methods=methods,
+            dependencies=deps,
+            **kwargs,
+        )
+
+        self.ephaptic.expose(
+            name=func.__name__,
+            rate_limit=limit,
+            hints=get_type_hints(func),
+            sig=inspect.signature(func), # for bypassing the @wraps
+        )(wrapper)
+
+    def get    (self, path, limit=None, requires_login=False):
+        def decorator(func): return self._register(func=func, methods=["GET"],    path=path, limit=limit, auth=requires_login)
+        return decorator
+    
+    def post   (self, path, limit=None, requires_login=False):
+        def decorator(func): return self._register(func=func, methods=["POST"],   path=path, limit=limit, auth=requires_login)
+        return decorator
+
+    def put    (self, path, limit=None, requires_login=False):
+        def decorator(func): return self._register(func=func, methods=["PUT"],    path=path, limit=limit, auth=requires_login)
+        return decorator
+
+    def delete (self, path, limit=None, requires_login=False):
+        def decorator(func): return self._register(func=func, methods=["DELETE"], path=path, limit=limit, auth=requires_login)
+        return decorator
+    
+    def patch  (self, path, limit=None, requires_login=False):
+        def decorator(func): return self._register(func=func, methods=["PATCH"],  path=path, limit=limit, auth=requires_login)
+        return decorator

ephaptic/{adapters/quart_.py → ext/quart/adapter.py}

@@ -1,5 +1,5 @@
 from quart import websocket, Quart
-from ..transports.websocket import WebSocketTransport
+from ...transports.websocket import WebSocketTransport
 
 class QuartAdapter:
     def __init__(self, ephaptic, app: Quart, path, manager):

ephaptic/transports/__init__.py

@@ -1,5 +1,10 @@
-from typing import Coroutine
+from typing import Optional
 
 class Transport:
-    async def send(data: bytes): raise NotImplementedError()
-    async def receive() -> bytes: raise NotImplementedError()
+    remote_addr: Optional[str] = None # usually, IP address (for most common transport types, like websocket, tcp/udp, etc.)
+
+    class ConnectionClosed(Exception):
+        pass
+
+    async def send(self, data: bytes): raise NotImplementedError()
+    async def receive(self) -> bytes: raise NotImplementedError()

ephaptic/transports/fastapi_ws.py

@@ -1,8 +1,17 @@
 from .websocket import WebSocketTransport
+from . import Transport
+from starlette.websockets import WebSocket, WebSocketDisconnect
 
 class FastAPIWebSocketTransport(WebSocketTransport):
+    def __init__(self, ws: WebSocket):
+        super().__init__(ws)
+        self.remote_addr = ws.client.host if ws.client else 'unknown'
+
     async def send(self, data: bytes):
         await self.ws.send_bytes(data)
 
     async def receive(self) -> bytes:
-        return await self.ws.receive_bytes()
+        try:
+            return await self.ws.receive_bytes()
+        except WebSocketDisconnect:
+            raise Transport.ConnectionClosed from None

ephaptic/transports/websocket.py

@@ -3,6 +3,7 @@ from . import Transport
 class WebSocketTransport(Transport):
     def __init__(self, ws):
         self.ws = ws
+        self.remote_addr = getattr(ws, 'remote_addr', None)
 
     async def send(self, data: bytes):
         await self.ws.send(data)

ephaptic/utils.py

@@ -0,0 +1,21 @@
+import re
+
+def parse_limit(limit: str) -> tuple[int, int]:
+    count, period = limit.replace(' per ', '/').split('/')
+    count = int(count)
+
+    match = re.fullmatch(r'(\d+)?\s*([smhd])', period.lower())
+    if not match:
+        raise ValueError(f"Invalid rate limit period: {period}")
+
+    multiplier = int(match.group(1) or 1)
+    unit = match.group(2)
+
+    s = {
+        's': 1,
+        'm': 60,
+        'h': 3600,
+        'd': 86400,
+    }[unit]
+
+    return count, multiplier * s

{ephaptic-0.2.7.dist-info → ephaptic-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ephaptic
-Version: 0.2.7
+Version: 0.3.0
 Summary: The Python client/server package for ephaptic.
 Author-email: uukelele <robustrobot11@gmail.com>
 License: MIT License
@@ -37,8 +37,13 @@ Requires-Dist: pydantic>=2.0
 Requires-Dist: typer[standard]>=0.20.0
 Requires-Dist: python-dotenv
 Requires-Dist: watchfiles
-Provides-Extra: server
-Requires-Dist: redis; extra == "server"
+Requires-Dist: redis
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: fastapi; extra == "test"
+Requires-Dist: uvicorn; extra == "test"
+Requires-Dist: httpx; extra == "test"
 Dynamic: license-file
 
 <div align="center">
@@ -51,15 +56,7 @@ Dynamic: license-file
 <br>
 <h1>ephaptic</h1>
 <br>
-<a href="https://github.com/ephaptic/ephaptic/blob/main/LICENSE"><img alt="GitHub License" src="https://img.shields.io/github/license/ephaptic/ephaptic?style=for-the-badge&labelColor=%23222222"></a> <img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/ephaptic/ephaptic/publish-js.yml?style=for-the-badge&label=NPM%20Build%20Status&labelColor=%23222222"> <img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/ephaptic/ephaptic/publish-python.yml?style=for-the-badge&label=PyPI%20Build%20Status&labelColor=%23222222"> <a href="https://pypi.org/project/ephaptic/">
-  <img alt="PyPI - Version"
-       src="https://img.shields.io/pypi/v/ephaptic?style=for-the-badge&labelColor=%23222222">
-</a>
-
-<a href="https://www.npmjs.com/package/@ephaptic/client">
-  <img alt="NPM - Version"
-       src="https://img.shields.io/npm/v/%40ephaptic%2Fclient?style=for-the-badge&labelColor=%23222222">
-</a>
+<a href="https://github.com/ephaptic/ephaptic/blob/main/LICENSE"><img alt="GitHub License" src="https://img.shields.io/github/license/ephaptic/ephaptic?style=for-the-badge&labelColor=%23222222" /></a> <img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/ephaptic/ephaptic/publish-js.yml?style=for-the-badge&label=NPM%20Build%20Status&labelColor=%23222222" /> <img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/ephaptic/ephaptic/publish-python.yml?style=for-the-badge&label=PyPI%20Build%20Status&labelColor=%23222222" /> <img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/ephaptic/ephaptic/tests.yml?style=for-the-badge&label=tests&labelColor=%23222222" /> <a href="https://pypi.org/project/ephaptic/"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/ephaptic?style=for-the-badge&labelColor=%23222222" /></a> <a href="https://www.npmjs.com/package/@ephaptic/client"><img alt="NPM - Version" src="https://img.shields.io/npm/v/%40ephaptic%2Fclient?style=for-the-badge&labelColor=%23222222" /></a>
 
 
 </div>
@@ -92,18 +89,10 @@ What are you waiting for? **Let's go.**
 <details>
     <summary>Python</summary>
     
-<h4>Client:</h4>
-
 ```
 $ pip install ephaptic
 ```
 
-<h4>Server:</h4>
-
-```
-$ pip install ephaptic[server]
-```
-
 ```python
 from fastapi import FastAPI # or `from quart import Quart`
 from ephaptic import Ephaptic
@@ -142,13 +131,19 @@ But what if your code throws an error? No sweat, it just throws up on the fronte
 And, want to say something to the frontend?
 
 ```python
-await ephaptic.to(user1, user2).notification("Hello, world!", priority="high")
+class Notification(BaseModel):
+    message: str
+    priority: Literal["high", "low", "default"]
+
+await ephaptic.to(user1, user2).emit(Notification(message="Hello, world!", priority="high"))
 ```
 
 To create a schema of your RPC endpoints:
 
 ```
-$ ephaptic src.app:app -o schema.json # --watch to run in background and auto-reload on file change.
+$ ephaptic generate src.app:app -o schema.json # --watch to run in background and auto-reload on file change.
+$ # Or:
+$ ephaptic generate src.app:app -o ephaptic.d.ts # converts directly to typescript
 ```
 
 Pydantic is entirely supported. It's validated for arguments, it's auto-serialized when you return a pydantic model, and your models receive type definitions in the schema.
@@ -166,7 +161,7 @@ async def load_identity(auth): # You can use synchronous functions here too.
     return user_id
 ```
 
-From here, you can use <code>ephaptic.active_user</code> within any exposed function, and it will give you the current active user ID / whatever else your identity loading function returns. (This is also how <code>ephaptic.to</code> works.)
+From here, you can use <code>ephaptic.active_user()</code> within any exposed function, and it will give you the current active user ID / whatever else your identity loading function returns. (This is also how <code>ephaptic.to</code> works.)
 
 </details>
 
@@ -206,8 +201,7 @@ const client = connect({ url: '...', auth: { token: window.localStorage.getItem(
 And you can load types, too.
 
 ```
-$ npm i --save-dev @ephaptic/type-gen
-$ npx @ephaptic/type-gen ./schema.json -o schema.d.ts # --watch to auto-reload upon changes
+$ ephaptic from-schema ./schema.json -o schema.d.ts # --watch to auto-reload upon changes
 ```
 
 ```typescript

ephaptic-0.3.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+ephaptic/__init__.py,sha256=G0C6_5AiQKVK9478VoBFnS3SxxQEdJeA9u9cN8j0dnU,185
+ephaptic/ctx.py,sha256=9nIAqQHO_hMxymex2DVmXElP2Tw3IX6OrqO5M21K0iQ,384
+ephaptic/decorators.py,sha256=H7FrsMjXTZOFaR4ITzESDfo4hH-AHlYsOBfrfZ7kEQQ,2146
+ephaptic/ephaptic.py,sha256=h85nkJTGHjwgAo1Qi5P3mahr1E5ieIGU9qmbQrdwZWA,15605
+ephaptic/localproxy.py,sha256=fJaaskkiD6C2zaOod0F0HNWIbdKs_JMuHFwd0-sdLIM,19477
+ephaptic/utils.py,sha256=D5Q09ec9Usbdel0-KlyDdXrC5OCuPs3KdUysUtSF--I,485
+ephaptic/cli/__init__.py,sha256=p_mYumuQLr3HZa-6I4QKut6khZv3WQjEX-B-aa4cdEE,44
+ephaptic/cli/__main__.py,sha256=p74lW4sgdeOliMDuZRMszvRf_7CRoisT5z46k3GHUn0,17260
+ephaptic/client/__init__.py,sha256=NeaPIzTFeozP54wlDYHIg_adHP3Z3LWVujsRUlpn4_U,35
+ephaptic/client/client.py,sha256=YYAlzA40xBvWsiDu0Gsd1EBJaqivLR-bSszepWdNODs,4181
+ephaptic/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ephaptic/ext/fastapi/__init__.py,sha256=oh4VtyCyqfAh2SkajR9Fd4tkRudOc43Wq7t_YosxYLM,26
+ephaptic/ext/fastapi/adapter.py,sha256=r6yYy7OBVt2nc1EoaD2lQduBrDwphDHIt5XEqAYi7Yo,1108
+ephaptic/ext/fastapi/middleware.py,sha256=rmicoPdBZW2CSACHy3DjKp6uPTkWyE7ylGAREEmJJK8,799
+ephaptic/ext/fastapi/router.py,sha256=H3ZhPS9XxW3pMWoQVCezyVZEoeglpbgol0tD8npsLQ8,3066
+ephaptic/ext/quart/adapter.py,sha256=j3QXuSGEbnRIvsGa_22x6tJOExdC2vyOW433ORC7McE,538
+ephaptic/transports/__init__.py,sha256=F971utXKI_Cl6qoX3R3IkBM0-oojGhNzHgtmzN9Gk2g,357
+ephaptic/transports/fastapi_ws.py,sha256=lM8ZdRtDZU1WAWi8xKg5Zem_oGF2DzI2b_aVHAJ-JNY,593
+ephaptic/transports/websocket.py,sha256=atb9rztq2_ph9YHbv9gzFh596n59dWX97oU3ym8fG1M,321
+ephaptic-0.3.0.dist-info/licenses/LICENSE,sha256=kMpJjLKMj6zsAhf4uHApO4q0r31Ye1VyfBOl9cFW13M,1065
+ephaptic-0.3.0.dist-info/METADATA,sha256=k386hGPd4DAPkHO8npRg0gOLKxXx_2d50U-l3K9Il3k,8986
+ephaptic-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ephaptic-0.3.0.dist-info/entry_points.txt,sha256=lis9vIDIrMVJM43r9ooFkb07KhrX4946duvYru3VfT4,46
+ephaptic-0.3.0.dist-info/top_level.txt,sha256=nNhdhcz2o_IuwZ9I2uWQuLZrRmSW0dQVU3qwGrb35Io,9
+ephaptic-0.3.0.dist-info/RECORD,,

{ephaptic-0.2.7.dist-info → ephaptic-0.3.0.dist-info}/WHEEL

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

ephaptic-0.2.7.dist-info/RECORD

@@ -1,19 +0,0 @@
-ephaptic/__init__.py,sha256=QIEfepOHMtM6Lrxg4AwZ28gEj0D5TY2UP8MGlrAb-DI,137
-ephaptic/ephaptic.py,sha256=2Yd1gXrzXWjUiMm0yubt84JUC4PesUrRWnql_rbbfTU,11989
-ephaptic/localproxy.py,sha256=fJaaskkiD6C2zaOod0F0HNWIbdKs_JMuHFwd0-sdLIM,19477
-ephaptic/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ephaptic/adapters/fastapi_.py,sha256=yfSbJuA7Tgeh9EhZkfIve0Uj-cOZmTBljlBsCRKh2EE,1007
-ephaptic/adapters/quart_.py,sha256=MBo9g6h_zI63mL4aGdrvV5yEXsHaOd0Iv5J8SAPHBoA,537
-ephaptic/cli/__init__.py,sha256=p_mYumuQLr3HZa-6I4QKut6khZv3WQjEX-B-aa4cdEE,44
-ephaptic/cli/__main__.py,sha256=MNzOfPK4DMwlnplJzT3NWBJdMnR0UFgcDl_8VvwO_QA,4866
-ephaptic/client/__init__.py,sha256=NeaPIzTFeozP54wlDYHIg_adHP3Z3LWVujsRUlpn4_U,35
-ephaptic/client/client.py,sha256=YYAlzA40xBvWsiDu0Gsd1EBJaqivLR-bSszepWdNODs,4181
-ephaptic/transports/__init__.py,sha256=kSAlgvm8sV9nHHu61LTjjTpv4bweah90xvFrwQMDQtQ,169
-ephaptic/transports/fastapi_ws.py,sha256=X0PMRcwM-KDpKA-zXShGTFhD1kHMSqrx3PBBKZtQ1W0,258
-ephaptic/transports/websocket.py,sha256=jwgclSDSq0lQCvgwjwUXe9MzPk7NH0FdmsLhWxYBh-4,261
-ephaptic-0.2.7.dist-info/licenses/LICENSE,sha256=kMpJjLKMj6zsAhf4uHApO4q0r31Ye1VyfBOl9cFW13M,1065
-ephaptic-0.2.7.dist-info/METADATA,sha256=ej7C_HcS0ONyL_bs85XZjl8yu7egeNya-Q7DeTbqMS4,8533
-ephaptic-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ephaptic-0.2.7.dist-info/entry_points.txt,sha256=lis9vIDIrMVJM43r9ooFkb07KhrX4946duvYru3VfT4,46
-ephaptic-0.2.7.dist-info/top_level.txt,sha256=nNhdhcz2o_IuwZ9I2uWQuLZrRmSW0dQVU3qwGrb35Io,9
-ephaptic-0.2.7.dist-info/RECORD,,