pondsocket 0.0.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
pondsocket/hooks.py ADDED
@@ -0,0 +1,227 @@
1
+ from __future__ import annotations
2
+
3
+ import asyncio
4
+ import time
5
+ from collections.abc import Awaitable, Callable
6
+ from dataclasses import dataclass
7
+ from typing import TYPE_CHECKING, Protocol, TypeAlias, runtime_checkable
8
+
9
+ from .errors import too_many_requests
10
+ from .types import Event, MessageEvent, User
11
+
12
+ if TYPE_CHECKING:
13
+ from .channel import Channel
14
+ from .transport import Transport
15
+
16
+
17
+ @runtime_checkable
18
+ class RateLimiter(Protocol):
19
+ async def allow(self, key: str) -> bool: ...
20
+ async def reset(self, key: str) -> None: ...
21
+
22
+
23
+ @runtime_checkable
24
+ class MetricsCollector(Protocol):
25
+ def connection_opened(self, conn_id: str, endpoint: str) -> None: ...
26
+ def connection_closed(self, conn_id: str, duration_seconds: float) -> None: ...
27
+ def connection_error(self, conn_id: str, err: BaseException) -> None: ...
28
+ def message_received(
29
+ self, conn_id: str, channel: str, event: str, size: int
30
+ ) -> None: ...
31
+ def message_sent(
32
+ self, conn_id: str, channel: str, event: str, size: int
33
+ ) -> None: ...
34
+ def message_broadcast(
35
+ self, channel: str, event: str, recipient_count: int
36
+ ) -> None: ...
37
+ def channel_joined(self, user_id: str, channel: str) -> None: ...
38
+ def channel_left(self, user_id: str, channel: str) -> None: ...
39
+ def channel_created(self, channel: str) -> None: ...
40
+ def channel_destroyed(self, channel: str) -> None: ...
41
+ def handler_duration(self, handler: str, duration_seconds: float) -> None: ...
42
+ def queue_depth(self, queue: str, depth: int) -> None: ...
43
+ def error(self, component: str, err: BaseException) -> None: ...
44
+
45
+
46
+ class NoopMetrics:
47
+ __slots__ = ()
48
+
49
+ def connection_opened(self, conn_id: str, endpoint: str) -> None:
50
+ return
51
+
52
+ def connection_closed(self, conn_id: str, duration_seconds: float) -> None:
53
+ return
54
+
55
+ def connection_error(self, conn_id: str, err: BaseException) -> None:
56
+ return
57
+
58
+ def message_received(
59
+ self, conn_id: str, channel: str, event: str, size: int
60
+ ) -> None:
61
+ return
62
+
63
+ def message_sent(
64
+ self, conn_id: str, channel: str, event: str, size: int
65
+ ) -> None:
66
+ return
67
+
68
+ def message_broadcast(
69
+ self, channel: str, event: str, recipient_count: int
70
+ ) -> None:
71
+ return
72
+
73
+ def channel_joined(self, user_id: str, channel: str) -> None:
74
+ return
75
+
76
+ def channel_left(self, user_id: str, channel: str) -> None:
77
+ return
78
+
79
+ def channel_created(self, channel: str) -> None:
80
+ return
81
+
82
+ def channel_destroyed(self, channel: str) -> None:
83
+ return
84
+
85
+ def handler_duration(self, handler: str, duration_seconds: float) -> None:
86
+ return
87
+
88
+ def queue_depth(self, queue: str, depth: int) -> None:
89
+ return
90
+
91
+ def error(self, component: str, err: BaseException) -> None:
92
+ return
93
+
94
+
95
+ OnConnect: TypeAlias = Callable[["Transport"], Awaitable[None]]
96
+ OnDisconnect: TypeAlias = Callable[["Transport"], Awaitable[None]]
97
+ BeforeJoin: TypeAlias = Callable[[User, str], Awaitable[None]]
98
+ AfterJoin: TypeAlias = Callable[[User, str], Awaitable[None]]
99
+ BeforeMessage: TypeAlias = Callable[[Event], Awaitable[None]]
100
+ AfterMessage: TypeAlias = Callable[[Event, BaseException | None], Awaitable[None]]
101
+
102
+
103
+ @dataclass(slots=True)
104
+ class Hooks:
105
+ rate_limiter: RateLimiter | None = None
106
+ channel_rate_limiter: RateLimiter | None = None
107
+ metrics: MetricsCollector | None = None
108
+ on_connect: OnConnect | None = None
109
+ on_disconnect: OnDisconnect | None = None
110
+ before_join: BeforeJoin | None = None
111
+ after_join: AfterJoin | None = None
112
+ before_message: BeforeMessage | None = None
113
+ after_message: AfterMessage | None = None
114
+
115
+
116
+ @dataclass(slots=True)
117
+ class _Bucket:
118
+ tokens: float
119
+ last_refill: float
120
+
121
+
122
+ class TokenBucketRateLimiter:
123
+ __slots__ = ("_buckets", "_capacity", "_lock", "_rate")
124
+
125
+ def __init__(self, *, rate: float, capacity: float) -> None:
126
+ if rate <= 0:
127
+ raise ValueError("rate must be > 0")
128
+ if capacity <= 0:
129
+ raise ValueError("capacity must be > 0")
130
+ self._rate = rate
131
+ self._capacity = capacity
132
+ self._buckets: dict[str, _Bucket] = {}
133
+ self._lock = asyncio.Lock()
134
+
135
+ @property
136
+ def rate(self) -> float:
137
+ return self._rate
138
+
139
+ @property
140
+ def capacity(self) -> float:
141
+ return self._capacity
142
+
143
+ async def allow(self, key: str) -> bool:
144
+ async with self._lock:
145
+ now = time.monotonic()
146
+ bucket = self._buckets.get(key)
147
+ if bucket is None:
148
+ bucket = _Bucket(tokens=self._capacity, last_refill=now)
149
+ self._buckets[key] = bucket
150
+ elapsed = now - bucket.last_refill
151
+ bucket.tokens = min(self._capacity, bucket.tokens + elapsed * self._rate)
152
+ bucket.last_refill = now
153
+ if bucket.tokens >= 1.0:
154
+ bucket.tokens -= 1.0
155
+ return True
156
+ return False
157
+
158
+ async def reset(self, key: str) -> None:
159
+ async with self._lock:
160
+ self._buckets.pop(key, None)
161
+
162
+ async def reset_all(self) -> None:
163
+ async with self._lock:
164
+ self._buckets.clear()
165
+
166
+
167
+ def with_rate_limiter(
168
+ hooks: Hooks,
169
+ key_fn: Callable[[MessageEvent], str],
170
+ ) -> Callable[
171
+ [MessageEvent, Channel, Callable[[], Awaitable[None]]],
172
+ Awaitable[None],
173
+ ]:
174
+ async def middleware(
175
+ message: MessageEvent,
176
+ _channel: Channel,
177
+ nxt: Callable[[], Awaitable[None]],
178
+ ) -> None:
179
+ if hooks.rate_limiter is None:
180
+ await nxt()
181
+ return
182
+ key = key_fn(message)
183
+ allowed = await hooks.rate_limiter.allow(key)
184
+ if not allowed:
185
+ err = too_many_requests(
186
+ message.event.channel_name, "Rate limit exceeded"
187
+ )
188
+ if hooks.metrics is not None:
189
+ hooks.metrics.error("rate_limiter", err)
190
+ raise err
191
+ await nxt()
192
+
193
+ return middleware
194
+
195
+
196
+ def with_metrics(
197
+ hooks: Hooks,
198
+ ) -> Callable[
199
+ [MessageEvent, Channel, Callable[[], Awaitable[None]]],
200
+ Awaitable[None],
201
+ ]:
202
+ async def middleware(
203
+ message: MessageEvent,
204
+ _channel: Channel,
205
+ nxt: Callable[[], Awaitable[None]],
206
+ ) -> None:
207
+ if hooks.metrics is None:
208
+ await nxt()
209
+ return
210
+ metrics = hooks.metrics
211
+ start = time.monotonic()
212
+ try:
213
+ await nxt()
214
+ except Exception as e:
215
+ metrics.error("message_handler", e)
216
+ raise
217
+ finally:
218
+ duration = time.monotonic() - start
219
+ metrics.message_received(
220
+ message.user.id,
221
+ message.event.channel_name,
222
+ message.event.event,
223
+ 0,
224
+ )
225
+ metrics.handler_duration(message.event.event, duration)
226
+
227
+ return middleware
@@ -0,0 +1,112 @@
1
+ from __future__ import annotations
2
+
3
+ import asyncio
4
+ from typing import Any
5
+
6
+ from .errors import internal
7
+ from .transport import OnCloseCallback, OnMessageHandler
8
+ from .types import Event, TransportType
9
+
10
+
11
+ class InMemoryTransport:
12
+ __slots__ = (
13
+ "_active",
14
+ "_assigns",
15
+ "_close_callbacks",
16
+ "_id",
17
+ "_inbox",
18
+ "_lock",
19
+ "_message_handler",
20
+ "_outbox",
21
+ "_receive_task",
22
+ )
23
+
24
+ def __init__(self, id: str, *, assigns: dict[str, Any] | None = None) -> None:
25
+ self._id = id
26
+ self._assigns: dict[str, Any] = dict(assigns or {})
27
+ self._active = True
28
+ self._outbox: asyncio.Queue[Event] = asyncio.Queue()
29
+ self._inbox: asyncio.Queue[Event] = asyncio.Queue()
30
+ self._close_callbacks: list[OnCloseCallback] = []
31
+ self._message_handler: OnMessageHandler | None = None
32
+ self._receive_task: asyncio.Task[None] | None = None
33
+ self._lock = asyncio.Lock()
34
+
35
+ def get_id(self) -> str:
36
+ return self._id
37
+
38
+ async def send_event(self, event: Event) -> None:
39
+ if not self._active:
40
+ raise internal("", "Transport is closed")
41
+ await self._outbox.put(event)
42
+
43
+ def get_assign(self, key: str) -> Any:
44
+ return self._assigns.get(key)
45
+
46
+ def set_assign(self, key: str, value: Any) -> None:
47
+ self._assigns[key] = value
48
+
49
+ def clone_assigns(self) -> dict[str, Any]:
50
+ return dict(self._assigns)
51
+
52
+ def is_active(self) -> bool:
53
+ return self._active
54
+
55
+ async def close(self) -> None:
56
+ if not self._active:
57
+ return
58
+ self._active = False
59
+ if self._receive_task is not None and not self._receive_task.done():
60
+ self._receive_task.cancel()
61
+ for cb in list(self._close_callbacks):
62
+ try:
63
+ await cb(self)
64
+ except Exception:
65
+ continue
66
+
67
+ def on_close(self, callback: OnCloseCallback) -> None:
68
+ self._close_callbacks.append(callback)
69
+
70
+ def on_message(self, handler: OnMessageHandler) -> None:
71
+ self._message_handler = handler
72
+
73
+ async def handle_messages(self) -> None:
74
+ if self._message_handler is None:
75
+ raise RuntimeError("on_message must be set before handle_messages")
76
+ if self._receive_task is not None and not self._receive_task.done():
77
+ return
78
+ self._receive_task = asyncio.create_task(self._receive_loop())
79
+
80
+ async def _receive_loop(self) -> None:
81
+ assert self._message_handler is not None
82
+ while True:
83
+ try:
84
+ ev = await self._inbox.get()
85
+ except asyncio.CancelledError:
86
+ return
87
+ if not self._active:
88
+ return
89
+ try:
90
+ await self._message_handler(ev, self)
91
+ except Exception:
92
+ continue
93
+
94
+ def transport_type(self) -> TransportType:
95
+ return TransportType.WEBSOCKET
96
+
97
+ async def receive_sent(self, *, wait: float | None = 1.0) -> Event:
98
+ if wait is None:
99
+ return await self._outbox.get()
100
+ return await asyncio.wait_for(self._outbox.get(), wait)
101
+
102
+ async def push_inbound(self, event: Event) -> None:
103
+ await self._inbox.put(event)
104
+
105
+ def outbox_size(self) -> int:
106
+ return self._outbox.qsize()
107
+
108
+ async def drain_outbox(self) -> list[Event]:
109
+ events: list[Event] = []
110
+ while not self._outbox.empty():
111
+ events.append(self._outbox.get_nowait())
112
+ return events
pondsocket/lobby.py ADDED
@@ -0,0 +1,183 @@
1
+ from __future__ import annotations
2
+
3
+ import asyncio
4
+ from collections.abc import Awaitable, Callable
5
+ from typing import TypeAlias
6
+
7
+ from .channel import Channel, ChannelOptions, LeaveMiddlewareFn
8
+ from .contexts.event_context import EventContext
9
+ from .contexts.leave_context import LeaveContext
10
+ from .contexts.outgoing_context import OutgoingContext
11
+ from .errors import PondError
12
+ from .middleware import Middleware, execute_with_middleware
13
+ from .parser import parse
14
+ from .pubsub import PubSub
15
+ from .types import MessageEvent, Options
16
+
17
+ EventHandler: TypeAlias = Callable[[EventContext], Awaitable[None]]
18
+ LeaveHandler: TypeAlias = Callable[[LeaveContext], Awaitable[None]]
19
+ OutgoingHandler: TypeAlias = Callable[[OutgoingContext], Awaitable[None]]
20
+
21
+ EventMiddlewareFn: TypeAlias = Callable[
22
+ [EventContext, Callable[[], Awaitable[None]]], Awaitable[None]
23
+ ]
24
+ OutgoingMiddlewareFn: TypeAlias = Callable[
25
+ [OutgoingContext, Callable[[], Awaitable[None]]], Awaitable[None]
26
+ ]
27
+
28
+
29
+ class Lobby:
30
+ __slots__ = (
31
+ "_channels",
32
+ "_endpoint_path",
33
+ "_leave_handler",
34
+ "_leave_middlewares",
35
+ "_lock",
36
+ "_message_middleware",
37
+ "_options",
38
+ "_outgoing_middleware",
39
+ "_path",
40
+ "_pubsub",
41
+ )
42
+
43
+ def __init__(
44
+ self,
45
+ *,
46
+ path: str,
47
+ endpoint_path: str = "",
48
+ options: Options | None = None,
49
+ pubsub: PubSub | None = None,
50
+ ) -> None:
51
+ self._path = path
52
+ self._endpoint_path = endpoint_path
53
+ self._options = options or Options()
54
+ self._pubsub = pubsub
55
+ self._channels: dict[str, Channel] = {}
56
+ self._message_middleware: Middleware[MessageEvent, Channel] = Middleware()
57
+ self._outgoing_middleware: Middleware[OutgoingContext, None] = Middleware()
58
+ self._leave_handler: LeaveHandler | None = None
59
+ self._leave_middlewares: list[LeaveMiddlewareFn] = []
60
+ self._lock = asyncio.Lock()
61
+
62
+ @property
63
+ def path(self) -> str:
64
+ return self._path
65
+
66
+ @property
67
+ def options(self) -> Options:
68
+ return self._options
69
+
70
+ def on_message(
71
+ self,
72
+ event_pattern: str,
73
+ handler: EventHandler,
74
+ *middlewares: EventMiddlewareFn,
75
+ ) -> None:
76
+ chain = list(middlewares)
77
+
78
+ async def wrapper(
79
+ req: MessageEvent,
80
+ resp: Channel,
81
+ nxt: Callable[[], Awaitable[None]],
82
+ ) -> None:
83
+ try:
84
+ route = parse(event_pattern, req.event.event)
85
+ except PondError:
86
+ await nxt()
87
+ return
88
+ ctx = EventContext(channel=resp, message=req, route=route)
89
+ await execute_with_middleware(ctx, handler, chain)
90
+
91
+ self._message_middleware.use_sync(wrapper)
92
+
93
+ def on_leave(
94
+ self,
95
+ handler: LeaveHandler,
96
+ *middlewares: LeaveMiddlewareFn,
97
+ ) -> None:
98
+ self._leave_handler = handler
99
+ self._leave_middlewares = list(middlewares)
100
+
101
+ def on_outgoing(
102
+ self,
103
+ event_pattern: str,
104
+ handler: OutgoingHandler,
105
+ *middlewares: OutgoingMiddlewareFn,
106
+ ) -> None:
107
+ chain = list(middlewares)
108
+
109
+ async def wrapper(
110
+ req: OutgoingContext,
111
+ _resp: None,
112
+ nxt: Callable[[], Awaitable[None]],
113
+ ) -> None:
114
+ try:
115
+ route = parse(event_pattern, req.event.event)
116
+ except PondError:
117
+ await nxt()
118
+ return
119
+ req.route = route
120
+ await execute_with_middleware(req, handler, chain)
121
+
122
+ self._outgoing_middleware.use_sync(wrapper)
123
+
124
+ async def has_channel(self, name: str) -> bool:
125
+ async with self._lock:
126
+ return name in self._channels
127
+
128
+ async def get_channel(self, name: str) -> Channel | None:
129
+ async with self._lock:
130
+ return self._channels.get(name)
131
+
132
+ async def get_or_create_channel(self, name: str) -> Channel:
133
+ async with self._lock:
134
+ existing = self._channels.get(name)
135
+ if existing is not None:
136
+ return existing
137
+
138
+ candidate = self._build_channel(name)
139
+
140
+ async with self._lock:
141
+ existing = self._channels.get(name)
142
+ if existing is not None:
143
+ await candidate.close()
144
+ return existing
145
+ self._channels[name] = candidate
146
+
147
+ try:
148
+ await candidate.start()
149
+ except Exception:
150
+ async with self._lock:
151
+ if self._channels.get(name) is candidate:
152
+ self._channels.pop(name, None)
153
+ raise
154
+ return candidate
155
+
156
+ def _build_channel(self, name: str) -> Channel:
157
+ async def on_destroy() -> None:
158
+ async with self._lock:
159
+ self._channels.pop(name, None)
160
+
161
+ opts = ChannelOptions(
162
+ name=name,
163
+ options=self._options,
164
+ message_middleware=self._message_middleware,
165
+ outgoing_middleware=self._outgoing_middleware,
166
+ leave_handler=self._leave_handler,
167
+ leave_middlewares=self._leave_middlewares,
168
+ on_destroy=on_destroy,
169
+ endpoint_path=self._endpoint_path,
170
+ pubsub=self._pubsub,
171
+ )
172
+ return Channel(opts)
173
+
174
+ async def list_channels(self) -> list[Channel]:
175
+ async with self._lock:
176
+ return list(self._channels.values())
177
+
178
+ async def close(self) -> None:
179
+ async with self._lock:
180
+ channels = list(self._channels.values())
181
+ self._channels.clear()
182
+ for ch in channels:
183
+ await ch.close()
@@ -0,0 +1,100 @@
1
+ from __future__ import annotations
2
+
3
+ import asyncio
4
+ from collections.abc import Awaitable, Callable
5
+ from typing import Generic, TypeAlias, TypeVar
6
+
7
+ from .errors import PondError, wrap
8
+
9
+ Request = TypeVar("Request")
10
+ Response = TypeVar("Response")
11
+
12
+ NextFn: TypeAlias = Callable[[], Awaitable[None]]
13
+ HandlerFunc: TypeAlias = Callable[[Request, Response, NextFn], Awaitable[None]]
14
+ FinalHandlerFunc: TypeAlias = Callable[[Request, Response], Awaitable[None]]
15
+
16
+
17
+ class Middleware(Generic[Request, Response]):
18
+ __slots__ = ("_handlers", "_lock")
19
+
20
+ def __init__(self) -> None:
21
+ self._handlers: list[HandlerFunc[Request, Response]] = []
22
+ self._lock = asyncio.Lock()
23
+
24
+ async def use(self, *handlers: HandlerFunc[Request, Response]) -> None:
25
+ async with self._lock:
26
+ self._handlers.extend(handlers)
27
+
28
+ def use_sync(self, *handlers: HandlerFunc[Request, Response]) -> None:
29
+ self._handlers.extend(handlers)
30
+
31
+ async def compose(
32
+ self, *others: Middleware[Request, Response]
33
+ ) -> Middleware[Request, Response]:
34
+ result: Middleware[Request, Response] = Middleware()
35
+ async with self._lock:
36
+ result._handlers.extend(self._handlers)
37
+ for other in others:
38
+ async with other._lock:
39
+ result._handlers.extend(other._handlers)
40
+ return result
41
+
42
+ async def handle(
43
+ self,
44
+ request: Request,
45
+ response: Response,
46
+ final: FinalHandlerFunc[Request, Response],
47
+ ) -> None:
48
+ async with self._lock:
49
+ handlers = list(self._handlers)
50
+
51
+ if not handlers:
52
+ await final(request, response)
53
+ return
54
+
55
+ async def run(index: int) -> None:
56
+ if index >= len(handlers):
57
+ await final(request, response)
58
+ return
59
+
60
+ async def next_fn() -> None:
61
+ await run(index + 1)
62
+
63
+ await handlers[index](request, response, next_fn)
64
+
65
+ await run(0)
66
+
67
+ def __len__(self) -> int:
68
+ return len(self._handlers)
69
+
70
+
71
+ C = TypeVar("C")
72
+ PerHandlerMiddleware: TypeAlias = Callable[[C, NextFn], Awaitable[None]]
73
+
74
+
75
+ async def execute_with_middleware(
76
+ ctx: C,
77
+ handler: Callable[[C], Awaitable[None]],
78
+ middlewares: list[PerHandlerMiddleware[C]],
79
+ ) -> None:
80
+ if not middlewares:
81
+ await handler(ctx)
82
+ return
83
+
84
+ async def run(index: int) -> None:
85
+ if index >= len(middlewares):
86
+ await handler(ctx)
87
+ return
88
+
89
+ async def next_fn() -> None:
90
+ await run(index + 1)
91
+
92
+ await middlewares[index](ctx, next_fn)
93
+
94
+ await run(0)
95
+
96
+
97
+ def wrap_pond_error(err: BaseException, message: str) -> PondError:
98
+ if isinstance(err, PondError):
99
+ return wrap(err, message)
100
+ return wrap(err, message)
pondsocket/parser.py ADDED
@@ -0,0 +1,85 @@
1
+ from __future__ import annotations
2
+
3
+ from urllib.parse import parse_qs, unquote
4
+
5
+ from .errors import not_found
6
+ from .types import Route
7
+
8
+
9
+ def parse(route: str, current_path: str) -> Route:
10
+ query: dict[str, list[str]] = {}
11
+ params: dict[str, str] = {}
12
+ wildcard: str | None = None
13
+
14
+ if current_path == "":
15
+ current_path = "/"
16
+
17
+ if "?" in current_path:
18
+ path, _, query_string = current_path.partition("?")
19
+ query = parse_qs(query_string, keep_blank_values=True)
20
+ else:
21
+ path = current_path
22
+
23
+ route_segments = _split_path(route)
24
+ path_segments = _split_path(path)
25
+
26
+ wildcard_index = -1
27
+ for i, seg in enumerate(route_segments):
28
+ if seg == "*":
29
+ wildcard_index = i
30
+ break
31
+
32
+ matched = False
33
+ if wildcard_index >= 0:
34
+ if wildcard_index < len(path_segments):
35
+ remaining = "/".join(path_segments[wildcard_index:])
36
+ wildcard = unquote(remaining)
37
+ else:
38
+ wildcard = ""
39
+ route_match = route_segments[:wildcard_index]
40
+ path_match = path_segments[: min(wildcard_index, len(path_segments))]
41
+ matched = _match_segments(route_match, path_match, params)
42
+ else:
43
+ if len(route_segments) == len(path_segments):
44
+ matched = _match_segments(route_segments, path_segments, params)
45
+
46
+ if not matched:
47
+ raise not_found(route, f"route {route} does not match path {current_path}")
48
+
49
+ return Route(params=params, query=query, wildcard=wildcard)
50
+
51
+
52
+ def _match_segments(
53
+ route_segments: list[str],
54
+ path_segments: list[str],
55
+ params: dict[str, str],
56
+ ) -> bool:
57
+ if len(route_segments) > len(path_segments):
58
+ return False
59
+ for i, route_seg in enumerate(route_segments):
60
+ if i >= len(path_segments):
61
+ return False
62
+ path_seg = path_segments[i]
63
+ if route_seg.startswith(":"):
64
+ param_name = route_seg[1:]
65
+ params[param_name] = unquote(path_seg)
66
+ continue
67
+ if ":" in route_seg:
68
+ prefix, _, param_name = route_seg.partition(":")
69
+ if not path_seg.startswith(prefix):
70
+ return False
71
+ value = path_seg[len(prefix) :]
72
+ params[param_name] = unquote(value)
73
+ continue
74
+ if route_seg != path_seg:
75
+ return False
76
+ return True
77
+
78
+
79
+ def _split_path(path: str) -> list[str]:
80
+ path = path.strip("/")
81
+ while "//" in path:
82
+ path = path.replace("//", "/")
83
+ if path == "":
84
+ return []
85
+ return path.split("/")