wisp-python 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

wisp/server/__main__.py

@@ -1,6 +1,5 @@
 import argparse
 import asyncio
-import logging
 import sys
 
 try:
@@ -9,37 +8,19 @@ try:
 except ImportError:
   use_uvloop = False
 
-import wisp
-import wisp.server.http
+from wisp.server import http 
+from wisp.server import common 
 
 if __name__ == "__main__":
-  parser = argparse.ArgumentParser(
-    prog="wisp-server-python",
-    description=f"A Wisp server implementation, written in Python (v{wisp.version})"
-  )
+  args = common.setup_main()
 
-  parser.add_argument("--host", default="127.0.0.1", help="The hostname the server will listen on.")
-  parser.add_argument("--port", default=6001, help="The TCP port the server will listen on.")
-  parser.add_argument("--static", help="Where static files are served from.")
-  parser.add_argument("--limits", action="store_true", help="Enable rate limits.")
-  parser.add_argument("--bandwidth", default=1000, help="Bandwidth limit per IP, in kilobytes per second.")
-  parser.add_argument("--connections", default=30, help="New connections limit per IP.")
-  parser.add_argument("--window", default=60, help="Fixed window length for rate limits, in seconds.")
-  parser.add_argument("--allow-loopback", action="store_true",help="Allow connections to loopback IP addresses.")
-  parser.add_argument("--allow-private", action="store_true", help="Allow connections to private IP addresses.")
-  parser.add_argument("--log-level", default="info", help="The log level (either debug, info, warning, error, or critical).")
-  args = parser.parse_args()
-
-  logging.basicConfig(
-    format="[%(asctime)s] %(levelname)-8s %(message)s",
-    level=getattr(logging, args.log_level.upper()),
-    datefmt="%Y/%m/%d - %H:%M:%S"
-  )
-
-  if use_uvloop:
-    uvloop.run(wisp.server.http.main(args))
-  else:
-    #uvloop doesn't support windows at all so we don't need to print the error
-    if not sys.platform in ("win32", "cygwin"):
-      logging.error("Importing uvloop failed. Falling back to asyncio, which is slower.")
-    asyncio.run(wisp.server.http.main(args))
+  try:
+    if use_uvloop:
+      uvloop.run(http.main(args))
+    else:
+      #uvloop doesn't support windows at all so we don't need to print the error
+      if not sys.platform in ("win32", "cygwin"):
+        logging.error("Importing uvloop failed. Falling back to asyncio, which is slower.")
+      asyncio.run(http.main(args))
+  except KeyboardInterrupt:
+    pass

wisp/server/common.py

@@ -0,0 +1,30 @@
+import argparse
+import logging
+
+import wisp
+
+def setup_main():
+  parser = argparse.ArgumentParser(
+    prog="wisp-server-python",
+    description=f"A Wisp server implementation, written in Python (v{wisp.version})"
+  )
+
+  parser.add_argument("--host", default="127.0.0.1", help="The hostname the server will listen on.")
+  parser.add_argument("--port", default=6001, help="The TCP port the server will listen on.")
+  parser.add_argument("--static", help="Where static files are served from.")
+  parser.add_argument("--limits", action="store_true", help="Enable rate limits.")
+  parser.add_argument("--bandwidth", default=1000, help="Bandwidth limit per IP, in kilobytes per second.")
+  parser.add_argument("--connections", default=30, help="New connections limit per IP.")
+  parser.add_argument("--window", default=60, help="Fixed window length for rate limits, in seconds.")
+  parser.add_argument("--allow-loopback", action="store_true",help="Allow connections to loopback IP addresses.")
+  parser.add_argument("--allow-private", action="store_true", help="Allow connections to private IP addresses.")
+  parser.add_argument("--log-level", default="info", help="The log level (either debug, info, warning, error, or critical).")
+  args = parser.parse_args()
+
+  logging.basicConfig(
+    format="[%(asctime)s] %(levelname)-8s %(message)s",
+    level=getattr(logging, args.log_level.upper()),
+    datefmt="%Y/%m/%d - %H:%M:%S"
+  )
+
+  return args

wisp/server/connection.py

@@ -46,7 +46,7 @@ class WSProxyConnection:
       await ratelimit.limit_client_bandwidth(self.client_ip, len(data), "ws")
       await self.conn.send(data)
     
-    self.tcp_writer.close()
+    self.conn.close()
   
   async def handle_tcp(self):
     while True:
@@ -128,7 +128,7 @@ class WispConnection:
 
       #send a CONTINUE packet periodically
       stream["packets_sent"] += 1
-      if stream["packets_sent"] % queue_size / 4 == 0:
+      if stream["packets_sent"] % (queue_size // 4) == 0:
         buffer_remaining = stream["queue"].maxsize - stream["queue"].qsize()
         continue_payload = struct.pack(continue_format, buffer_remaining)
         continue_packet = struct.pack(packet_format, 0x03, stream_id) + continue_payload

wisp/server/http.py

@@ -61,7 +61,7 @@ async def static_handler(path, request_headers):
 
 async def main(args):
   global static_path
-  logging.info(f"running wisp-server-python v{wisp.version}")
+  logging.info(f"running wisp-server-python v{wisp.version} (async)")
 
   if args.static:
     static_path = pathlib.Path(args.static).resolve()

wisp/server/ratelimit.py

@@ -52,3 +52,15 @@ async def reset_limits_timer():
   while True:
     active_clients = {}
     await asyncio.sleep(window_size)
+
+def limit_client_bandwidth_sync(client_ip, length, attr):
+  if not enabled: return
+  inc_client_attr(client_ip, attr, length)
+  while calculate_client_bandwidth(client_ip, attr) > bandwidth_limit:
+    time.sleep(0.01)
+
+def reset_limits_timer_sync():
+  global active_clients
+  while True:
+    active_clients = {}
+    time.sleep(window_size)

wisp/server/threading/__init__.py

@@ -0,0 +1,2 @@
+from wisp.server.threading.connection import WispConnection
+from wisp.server.threading.connection import WSProxyConnection

wisp/server/threading/__main__.py

@@ -0,0 +1,6 @@
+from wisp.server.threading import http 
+from wisp.server import common 
+
+if __name__ == "__main__":
+  args = common.setup_main()
+  http.main(args)

wisp/server/threading/connection.py

@@ -0,0 +1,219 @@
+import struct
+import os
+import logging
+import queue
+import threading
+
+from websockets.exceptions import ConnectionClosed, ConnectionClosedError
+
+from wisp.server import ratelimit
+from wisp.server.threading import netsync
+
+queue_size = 128
+static_path = None
+
+#wisp packet format definitions
+#see https://docs.python.org/3/library/struct.html for what these characters mean
+packet_format = "<BI"
+connect_format = "<BH"
+continue_format = "<I"
+close_format = "<B"
+
+class WSProxyConnection:
+  def __init__(self, ws, path, client_ip):
+    self.ws = ws
+    self.path = path
+    self.client_ip = client_ip
+
+  def setup_connection(self):
+    addr_str = self.path.split("/")[-1]
+    self.tcp_host, self.tcp_port = addr_str.split(":")
+    self.tcp_port = int(self.tcp_port)
+
+    try:
+      self.conn = netsync.TCPConnection(self.tcp_host, self.tcp_port)
+      self.conn.connect()
+    except Exception as e:
+      logging.info(f"Creating a WSProxy stream to {self.tcp_host}:{self.tcp_port} failed: {e}")
+      self.ws.close()
+
+  def handle_ws(self):
+    while True:
+      try:
+        data = self.ws.recv()
+      except (ConnectionClosed, ConnectionClosedError) as e:
+        break
+
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "ws")
+      self.conn.send(data)
+    
+    self.conn.close()
+  
+  def handle_tcp(self):
+    while True:
+      data = self.conn.recv()
+      if len(data) == 0:
+        break #socket closed
+
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "tcp")
+      self.ws.send(data)
+    
+    self.ws.close()
+
+class WispConnection:
+  def __init__(self, ws, path, client_ip, id=None):
+    self.ws = ws
+    self.path = path
+    self.active_streams = {}
+    self.client_ip = client_ip
+    self.id = id
+  
+  #send the initial CONTINUE packet
+  def setup(self):
+    continue_payload = struct.pack(continue_format, queue_size)
+    continue_packet = struct.pack(packet_format, 0x03, 0) + continue_payload
+    self.ws.send(continue_packet)
+  
+  def close(self):
+    #close all active streams when the websocket disconnects
+    for stream_id in list(self.active_streams.keys()):
+      self.close_stream(stream_id)
+    self.ws.close()
+
+  def new_stream(self, stream_id, payload):
+    stream_type, destination_port = struct.unpack(connect_format, payload[:3])
+    hostname = bytes(payload[3:]).decode()
+    logging.debug(f"({self.id}) Creating a new stream to {hostname}:{destination_port}")
+
+    #rate limited
+    stream_count = ratelimit.get_client_attr(self.client_ip, "streams")
+    if ratelimit.enabled and stream_count > ratelimit.connections_limit:
+      self.send_close_packet(stream_id, 0x49)
+      self.close_stream(stream_id)
+      return
+    
+    #info looks valid - try to open the connection now
+    try:
+      if stream_type == 0x01:
+        connection = netsync.TCPConnection(hostname, destination_port)
+      elif stream_type == 0x02: 
+        connection = netsync.UDPConnection(hostname, destination_port)
+      else:
+        raise Exception("Invalid stream type.")
+      self.active_streams[stream_id]["conn"] = connection
+      connection.connect()
+        
+    except Exception as e:
+      logging.warn(f"({self.id}) Creating a new stream to {hostname}:{destination_port} failed: {e}")
+      self.send_close_packet(stream_id, 0x42)
+      self.close_stream(stream_id)
+      return
+    
+    self.active_streams[stream_id]["type"] = stream_type
+    threading.Thread(target=self.stream_ws_to_tcp, args=(stream_id,), daemon=True).start()
+    threading.Thread(target=self.stream_tcp_to_ws, args=(stream_id,), daemon=True).start()
+    ratelimit.inc_client_attr(self.client_ip, "streams")
+  
+  def stream_ws_to_tcp(self, stream_id):
+    while True: 
+      stream = self.active_streams[stream_id]
+      data = stream["queue"].get()
+      if data is None:
+        break
+      try:
+        stream["conn"].send(data)
+      except:
+        break
+
+      #send a CONTINUE packet periodically
+      stream["packets_sent"] += 1
+      if stream["packets_sent"] % (queue_size // 4) == 0:
+        buffer_remaining = stream["queue"].maxsize - stream["queue"].qsize()
+        continue_payload = struct.pack(continue_format, buffer_remaining)
+        continue_packet = struct.pack(packet_format, 0x03, stream_id) + continue_payload
+        self.ws.send(continue_packet)
+  
+  def stream_tcp_to_ws(self, stream_id):
+    while True:
+      stream = self.active_streams[stream_id]
+      try:
+        data = stream["conn"].recv()
+      except Exception as e:
+        logging.warn(f"({self.id}) Receiving data from stream failed: {e}")
+        self.send_close_packet(stream_id, 0x03)
+        self.close_stream(stream_id)
+        return
+        
+      if len(data) == 0: #connection closed
+        break
+      data_header = struct.pack(packet_format, 0x02, stream_id)
+
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data_header)+len(data), "tcp")
+      try:
+        self.ws.send(data_header + data)
+      except (ConnectionClosed, ConnectionClosedError) as e:
+        return
+
+    self.send_close_packet(stream_id, 0x02)
+    self.close_stream(stream_id)
+  
+  def send_close_packet(self, stream_id, reason):
+    if not stream_id in self.active_streams:
+      return
+    close_payload = struct.pack(close_format, reason)
+    close_packet = struct.pack(packet_format, 0x04, stream_id) + close_payload
+    self.ws.send(close_packet)
+  
+  def close_stream(self, stream_id):
+    if not stream_id in self.active_streams:
+      return #stream already closed
+    stream = self.active_streams[stream_id]
+    if stream["conn"]:
+      stream["conn"].close()
+
+    #empty the queue and kill it
+    while not stream["queue"].empty():
+      stream["queue"].get()
+    stream["queue"].put(None)
+    del self.active_streams[stream_id]
+  
+  def handle_ws(self):
+    while True:
+      try:
+        data = self.ws.recv()
+      except (ConnectionClosed, ConnectionClosedError):
+        break
+      except Exception as e:
+        logging.warn(f"({self.id}) Receiving data from websocket failed: {e}")
+        break
+
+      if not isinstance(data, bytes): 
+        continue #ignore non binary frames
+      
+      #implement bandwidth limits
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "ws")
+      
+      #get basic packet info
+      payload = memoryview(data)[5:]
+      packet_type, stream_id = struct.unpack(packet_format, data[:5])
+
+      if packet_type == 0x01: #CONNECT packet
+        self.active_streams[stream_id] = {
+          "conn": None,
+          "type": None,
+          "queue": queue.Queue(queue_size),
+          "packets_sent": 0
+        }
+        threading.Thread(target=self.new_stream, args=(stream_id, payload), daemon=True).start()
+      
+      elif packet_type == 0x02: #DATA packet
+        stream = self.active_streams.get(stream_id)
+        if not stream:
+          continue
+        stream["queue"].put(payload)
+      
+      elif packet_type == 0x04: #CLOSE packet
+        reason = struct.unpack(close_format, payload)[0]
+        self.close_stream(stream_id)
+
+    self.close()

wisp/server/threading/http.py

@@ -0,0 +1,104 @@
+import threading
+import multiprocessing
+import pathlib
+import mimetypes
+import logging
+import random
+import sys
+
+from websockets.sync.server import serve
+from websockets.http11 import Response, Headers
+
+import wisp
+from wisp.server import ratelimit
+from wisp.server import net
+from wisp.server.threading import connection
+
+static_path = None
+connections = {}
+
+def connection_handler(websocket):
+  path = websocket.request.path
+  client_ip = websocket.remote_address[0]
+  if client_ip == "127.0.0.1" and "X-Real-IP" in websocket.request.headers:
+    client_ip = websocket.request.headers["X-Real-IP"]
+  origin = websocket.request.headers.get("Origin")
+
+  conn_id = "".join(random.choices("1234567890abcdef", k=8))
+  logging.info(f"({conn_id}) incoming connection on {path} from {client_ip} (origin: {origin})")
+  ratelimit.inc_client_attr(client_ip, "streams")
+
+  if path.endswith("/"):
+    wisp_conn = connection.WispConnection(websocket, path, client_ip, conn_id)
+    connections[websocket] = wisp_conn
+    wisp_conn.setup()
+    wisp_conn.handle_ws()
+    del connections[websocket]
+
+  else:
+    stream_count = ratelimit.get_client_attr(client_ip, "streams")
+    if ratelimit.enabled and stream_count > ratelimit.connections_limit:
+      return
+    wsproxy_conn = connection.WSProxyConnection(websocket, path, client_ip)
+    wsproxy_conn.setup_connection()
+    t1 = threading.Thread(target=wsproxy_conn.handle_ws, daemon=True)
+    t2 = threading.Thread(target=wsproxy_conn.handle_tcp, daemon=True)
+    t1.start(); t2.start()
+    t1.join(); t2.join()
+
+def static_handler(connection, request):
+  if "Upgrade" in request.headers:
+    return
+    
+  response_headers = Headers()
+  response_headers["Server"] = f"wisp-server-python v{wisp.version}"
+  if static_path is None:
+    return Response(204, None, response_headers, body=b"")
+
+  target_path = static_path / request.path[1:]
+
+  if target_path.is_dir():
+    target_path = target_path / "index.html"
+  if not target_path.is_relative_to(static_path):
+    return Response(403, None, response_headers, body="403 forbidden".encode())
+  if not target_path.exists():
+    return Response(404, None, response_headers, body="404 not found".encode())
+  
+  mimetype = mimetypes.guess_type(target_path.name)[0]
+  response_headers["Content-Type"] = mimetype
+
+  static_data = target_path.read_bytes()
+  return Response(200, None, response_headers, body=static_data)
+
+def main(args):
+  global static_path
+  logging.info(f"running wisp-server-python v{wisp.version} (threading)")
+
+  if args.static:
+    static_path = pathlib.Path(args.static).resolve()
+    mimetypes.init()
+    logging.info(f"serving static files from {static_path}")
+  
+  if args.limits:
+    logging.info("enabled rate limits")
+    ratelimit.enabled = True
+    ratelimit.connections_limit = int(args.connections)
+    ratelimit.bandwidth_limit = float(args.bandwidth)
+    ratelimit.window_size = float(args.window)
+
+  net.block_loopback = not args.allow_loopback
+  net.block_private = not args.allow_private
+      
+  threading.Thread(target=ratelimit.reset_limits_timer_sync, daemon=True).start()
+  logging.info(f"listening on {args.host}:{args.port}")
+
+  ws_logger = logging.getLogger("websockets")
+  ws_logger.setLevel(logging.WARN)
+
+  with serve(connection_handler, args.host, int(args.port), process_request=static_handler, compression=None) as server:
+    try:
+      server.serve_forever()
+    except KeyboardInterrupt:
+      for connection in connections.values():
+        connection.close()
+      server.shutdown()

wisp/server/threading/netsync.py

@@ -0,0 +1,58 @@
+import socket
+import ipaddress
+
+#various network utilities and wrappers - synchronous version
+
+from wisp.server import net
+
+def validate_hostname(host, port, stream_type):
+  addr_str = net.get_ip(host, port, stream_type)
+  net.validate_ip(addr_str)
+  return addr_str
+
+class TCPConnection:
+  def __init__(self, hostname, port):
+    self.hostname = hostname
+    self.port = port
+    self.socket = None
+  
+  def connect(self):
+    addr_str = validate_hostname(self.hostname, self.port, 0x01)
+    self.socket = socket.socket()
+    self.socket.connect((self.hostname, self.port))
+  
+  def recv(self):
+    return self.socket.recv(net.tcp_size)
+  
+  def send(self, data):
+    self.socket.send(data)
+  
+  def close(self):
+    if self.socket is None:
+      return
+    self.socket.shutdown(socket.SHUT_RDWR)
+    self.socket.close()
+
+class UDPConnection:
+  def __init__(self, hostname, port):
+    self.hostname = hostname
+    self.port = port
+    self.socket = None
+  
+  def connect(self):
+    addr_str = validate_hostname(self.hostname, self.port, 0x02)
+    self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    self.socket.bind((self.hostname, self.port))
+  
+  def recv(self):
+    data, addr = self.socket.recvfrom(net.tcp_size)
+    return data
+  
+  def send(self, data):
+    self.socket.sendto(data, (self.hostname, self.port))
+  
+  def close(self):
+    if self.socket is None:
+      return
+    self.socket.shutdown(socket.SHUT_RDWR)
+    self.socket.close()

{wisp_python-0.5.2.dist-info → wisp_python-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: wisp-python
-Version: 0.5.2
+Version: 0.6.1
 Summary: An implementation of a Wisp proxy server in Python
 Author: ading2210
 Project-URL: Homepage, https://github.com/MercuryWorkshop/wisp-server-python
@@ -13,7 +13,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: websockets
 Requires-Dist: asyncudp
-Requires-Dist: uvloop ; sys_platform != "win32" and sys_platform != "cygwin"
+Requires-Dist: uvloop; sys_platform != "win32" and sys_platform != "cygwin"
+Dynamic: license-file
 
 # Python Wisp Server
 
@@ -35,7 +36,13 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-To start the server, run `python3 -m wisp.server`. The program accepts the following arguments:
+There are two different versions of the server:
+- Async (`wisp.server`) - The default, based on asyncio. It is more stable, but slower.
+- Threading (`wisp.server.threading`) - An faster alternative based on threading. It is about 40-80% faster, but possibly unstable. If you use Python's experimental [free threading](https://docs.python.org/3/howto/free-threading-python.html) builds, performance will scale linearly with your available CPU cores.
+
+For the best performance use [CPython](https://github.com/python/cpython) 3.11 or newer. [PyPy](https://github.com/pypy/pypy) is not recommended as it is a lot slower than CPython here. 
+
+To start the server, run `python3 -m wisp.server` (or `python3 -m wisp.server.threading`). The program accepts the following arguments:
 ```
 usage: wisp-server-python [-h] [--host HOST] [--port PORT] [--static STATIC] [--limits] [--bandwidth BANDWIDTH] [--connections CONNECTIONS] [--window WINDOW] [--allow-loopback] [--allow-private]
                           [--log-level LOG_LEVEL]
@@ -64,6 +71,7 @@ options:
 - JSON based config files
 - ~~UDP support~~
 - ~~Ability to block local addresses~~
+- Wisp v2 support
 
 ## Copyright:
 This repository is licensed under the GNU AGPL v3.

wisp_python-0.6.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+wisp/__init__.py,sha256=02Fv0s_jJG8U4y5B6AzKPIOzxAuqJyY_So8Guz5bdTk,75
+wisp/util.py,sha256=AU7si8VwJqS8Dwc1PT2pu_f_9Y32GQxivRYwJ3-U0YQ,144
+wisp/server/__init__.py,sha256=LmgQ1nTlnqcTPqRJVc1NGapV9qVR-BK8iPVUMSJ74Qs,102
+wisp/server/__main__.py,sha256=oEDuHOpC7DaHTFIX-9HViwOmWJqdIyktA8whRTmGesk,610
+wisp/server/common.py,sha256=0NheE8nJeUmAMPt-DomesnkqCvB8gITi-dsT7VBRJCw,1442
+wisp/server/connection.py,sha256=V_Skmmsvn30lQKY5w9x2rJQFR_FsA3lngNDpaYOfX6U,7669
+wisp/server/http.py,sha256=YL-N3ajptgcAq5P50V6b8KlSJlVo6fRPnz65El9ZUQY,3145
+wisp/server/net.py,sha256=3EL5FzM9BAF2VW6ysTFX1vyJG4xMvrcu_YMlxTYqhI8,2265
+wisp/server/ratelimit.py,sha256=cic_rlBaM-tp6kJaSz4ITGvUbsX4JLSGSUgF5cPO0FY,1926
+wisp/server/threading/__init__.py,sha256=_34ZRPKommA9uazP9UBw59EByf6m9-VGNqc7hAjaJkc,122
+wisp/server/threading/__main__.py,sha256=xM65KttaBDFg3FS5H5msEkx3p-mPfP7grpGslqKG4uY,146
+wisp/server/threading/connection.py,sha256=2bMEPBxMl28OAVehNS3sk4C33dECZCHKBZSHTkEzZoM,7044
+wisp/server/threading/http.py,sha256=0pzsHVrJoP4QZ9yNPPZYGStah9g3pJZvNMGbzVBRk5w,3521
+wisp/server/threading/netsync.py,sha256=7RBlLhEtrF1fsWUIt6aGeoD_lUui2Q83FJdEhi5gnTY,1462
+wisp_python-0.6.1.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+wisp_python-0.6.1.dist-info/METADATA,sha256=YE9Ent8HbMHBW95GSgF8irmLlOxRWEDpMcyCCS7r3Fg,4083
+wisp_python-0.6.1.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+wisp_python-0.6.1.dist-info/top_level.txt,sha256=sv0LDAu8cHUc3_VTsCKfXU-6B9HdV4dW22ubeW8KPVs,5
+wisp_python-0.6.1.dist-info/RECORD,,

{wisp_python-0.5.2.dist-info → wisp_python-0.6.1.dist-info}/WHEEL

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

wisp_python-0.5.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-wisp/__init__.py,sha256=02Fv0s_jJG8U4y5B6AzKPIOzxAuqJyY_So8Guz5bdTk,75
-wisp/util.py,sha256=AU7si8VwJqS8Dwc1PT2pu_f_9Y32GQxivRYwJ3-U0YQ,144
-wisp/server/__init__.py,sha256=LmgQ1nTlnqcTPqRJVc1NGapV9qVR-BK8iPVUMSJ74Qs,102
-wisp/server/__main__.py,sha256=-3NhgpGpWkeJh-vnbk2pKzoxv-1AguHxHkCc8VwewJg,1901
-wisp/server/connection.py,sha256=Eon78eD1FDki_jQX46EK9CVtXKzOWJJEWvfykbRCAb4,7672
-wisp/server/http.py,sha256=6i2r97H9DGc2ijLLsCUxXkByaGON6fdqqXCElU_eJNQ,3137
-wisp/server/net.py,sha256=3EL5FzM9BAF2VW6ysTFX1vyJG4xMvrcu_YMlxTYqhI8,2265
-wisp/server/ratelimit.py,sha256=zT_ya_3_ZocSxU0IOVWJ68L4-JSwKsBfqdwp_IvUWhQ,1585
-wisp_python-0.5.2.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-wisp_python-0.5.2.dist-info/METADATA,sha256=b_l9xpLCmt-AyII7z1UDOOk3SAEdglK4vdD49jSQRS4,3366
-wisp_python-0.5.2.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-wisp_python-0.5.2.dist-info/top_level.txt,sha256=sv0LDAu8cHUc3_VTsCKfXU-6B9HdV4dW22ubeW8KPVs,5
-wisp_python-0.5.2.dist-info/RECORD,,