workers-runtime-sdk 1.6.13__tar.gz → 1.6.15__tar.gz

{workers_runtime_sdk-1.6.13 → workers_runtime_sdk-1.6.15}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v1.6.15 (2026-08-21)
+
+### Bug Fixes
+
+- Handle ASGI WebSocket close events and environment propagation
+  ([`47cc488`](https://github.com/cloudflare/workers-py/commit/47cc488e2bad1c9f3030a16d73301b80fca90f5c))
+
+
+## v1.6.14 (2026-08-19)
+
+### Bug Fixes
+
+- Fixes fastapi lifespan state not persisting
+  ([`fadd19b`](https://github.com/cloudflare/workers-py/commit/fadd19bcb6ca47518d5e42562879164dd62ab404))
+
+
 ## v1.6.13 (2026-08-12)
 
 ### Bug Fixes

{workers_runtime_sdk-1.6.13 → workers_runtime_sdk-1.6.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: workers-runtime-sdk
-Version: 1.6.13
+Version: 1.6.15
 Summary: Python SDK for Cloudflare Workers
 Project-URL: Homepage, https://github.com/cloudflare/workers-py
 Project-URL: Bug Tracker, https://github.com/cloudflare/workers-py/issues

{workers_runtime_sdk-1.6.13 → workers_runtime_sdk-1.6.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "workers-runtime-sdk"
-version = "1.6.13"
+version = "1.6.15"
 description = "Python SDK for Cloudflare Workers"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -64,6 +64,9 @@ lint.per-file-ignores."tests/web-frameworks-test/**" = ["C901", "PLR0911", "PLR0
 
 [tool.pytest.ini_options]
 addopts = ["--ignore=tests/workerd-test", "--ignore=tests/bindings-test", "--ignore=tests/web-frameworks-test"]
+markers = [
+  "hyperdrive: needs MySQL and PostgreSQL on localhost; skipped unless run with -m hyperdrive",
+]
 
 [tool.mypy]
 packages = ["workers_runtime_sdk"]

workers_runtime_sdk-1.6.15/src/asgi.py

@@ -0,0 +1,6 @@
+# Compatibility module for existing code that imports `asgi` directly.
+import sys
+
+from workers import asgi as _asgi
+
+sys.modules[__name__] = _asgi

{workers_runtime_sdk-1.6.13/src → workers_runtime_sdk-1.6.15/src/workers}/asgi.py

@@ -49,7 +49,7 @@ def acquire_js_buffer(pybuffer):
         buf.release()
 
 
-def request_to_scope(req, env, ws=False):
+def request_to_scope(req, env, ws=False, state=None):
     from js import URL
 
     # @app.get("/example")
@@ -74,7 +74,7 @@ def request_to_scope(req, env, ws=False):
         ty = "websocket"
     else:
         ty = "http"
-    return {
+    scope = {
         "asgi": ASGI,
         "headers": headers,
         "http_version": "1.1",
@@ -86,6 +86,10 @@ def request_to_scope(req, env, ws=False):
         "type": ty,
         "env": env,
     }
+    if state is not None:
+        # ASGI requires a shallow copy of lifespan state for each request.
+        scope["state"] = dict(state)
+    return scope
 
 
 async def start_application(app):
@@ -94,6 +98,7 @@ async def start_application(app):
     # don't implement it and fall back to serving requests without lifespan.
     # https://asgi.readthedocs.io/en/latest/specs/lifespan.html
     receive_queue = Queue()
+    state = {}
     await receive_queue.put({"type": "lifespan.startup"})
 
     # `startup` resolves True on `lifespan.startup.complete`, False when the app
@@ -141,7 +146,7 @@ async def start_application(app):
             await app(
                 {
                     "asgi": ASGI,
-                    "state": {},
+                    "state": state,
                     "type": "lifespan",
                 },
                 receive,
@@ -168,17 +173,18 @@ async def start_application(app):
     run_in_background(run_lifespan())
     supported = await startup
     if not supported:
-        return no_lifespan_shutdown
-    return shutdown
+        return no_lifespan_shutdown, state
+    return shutdown, state
 
 
-async def process_request(
+async def process_request(  # noqa: PLR0913
     app: Any,
     req: "Request | js.Request",
     env: Any,
     # added for waitUntil, but not used anymore
     # TODO(later): remove this parameter after unvendoring Python SDK from workerd
     ctx: Context | None,
+    state: dict[str, Any] | None = None,
 ) -> js.Response:
     from js import Response, TransformStream
     from pyodide.ffi import create_proxy
@@ -273,7 +279,7 @@ async def process_request(
     # Run the application in the background
     async def run_app():
         try:
-            await app(request_to_scope(req, env), receive, send)
+            await app(request_to_scope(req, env, state=state), receive, send)
 
             # If we get here and no response has been set yet, the app didn't generate a response
             if not result.done():
@@ -311,7 +317,9 @@ async def process_request(
         app_task.destroy()
 
 
-async def process_websocket(app: Any, req: "Request | js.Request") -> js.Response:
+async def process_websocket(
+    app: Any, req: "Request | js.Request", env: Any = None
+) -> js.Response:
     from js import Response, WebSocketPair
 
     client, server = WebSocketPair.new().object_values()
@@ -352,6 +360,10 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
     server.onmessage = onmessage
 
     async def ws_send(got):
+        if got["type"] == "websocket.accept":
+            # The Workers WebSocketPair is accepted before the upgrade response
+            # is returned, so there is no deferred accept operation here.
+            return
         if got["type"] == "websocket.send":
             b = got.get("bytes", None)
             s = got.get("text", None)
@@ -362,16 +374,23 @@ async def process_websocket(app: Any, req: "Request | js.Request") -> js.Respons
                     server.send(jsbytes)
             if s is not None:
                 server.send(s)
-
-        else:
-            logger.warning(" == Not implemented %s", got["type"])
+            return
+        if got["type"] == "websocket.close":
+            server.close(got.get("code", 1000), got.get("reason", ""))
+            return
+        logger.warning(" == Not implemented %s", got["type"])
 
     async def ws_receive():
         received = await queue.get()
         return received
 
-    env = {}
-    run_in_background(app(request_to_scope(req, env, ws=True), ws_receive, ws_send))
+    run_in_background(
+        app(
+            request_to_scope(req, env if env is not None else {}, ws=True),
+            ws_receive,
+            ws_send,
+        )
+    )
 
     return Response.new(None, status=101, webSocket=client)
 
@@ -380,9 +399,9 @@ async def fetch(
     app: Any, req: "Request | js.Request", env: Any, ctx: Context | None = None
 ) -> js.Response:
     logger.debug("ASGI request: %s %s", req.method, req.url)
-    shutdown = await start_application(app)
+    shutdown, state = await start_application(app)
     try:
-        result = await process_request(app, req, env, ctx)
+        result = await process_request(app, req, env, ctx, state=state)
     except Exception:
         logger.exception("ASGI request failed")
         raise
@@ -390,8 +409,10 @@ async def fetch(
     return result
 
 
-async def websocket(app: Any, req: "Request | js.Request") -> js.Response:
-    return await process_websocket(app, req)
+async def websocket(
+    app: Any, req: "Request | js.Request", env: Any = None
+) -> js.Response:
+    return await process_websocket(app, req, env)
 
 
 def __getattr__(name):

workers_runtime_sdk-1.6.15/tests/bindings-test/pyproject.toml

@@ -0,0 +1,5 @@
+[project]
+name = "bindings-test"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = ["pytest", "pytest-asyncio<1.2.0", "pg8000", "pymysql", "cryptography"]

{workers_runtime_sdk-1.6.13/tests/web-frameworks-test/fastapi-tests → workers_runtime_sdk-1.6.15/tests/bindings-test}/src/conftest.py

@@ -1,4 +1,5 @@
 # pyright: reportMissingImports=false
+import uuid
 
 import pytest
 
@@ -8,3 +9,8 @@ from workers import env as _env
 @pytest.fixture
 def env():
     return _env
+
+
+def unique_table_name() -> str:
+    """Unique per call"""
+    return f"test_{uuid.uuid4().hex[:10]}"

workers_runtime_sdk-1.6.15/tests/bindings-test/src/test_hyperdrive_mysql.py

@@ -0,0 +1,208 @@
+# pyright: reportMissingImports=false
+
+"""
+This test requires a MySQL server to be running on localhost.
+
+Run mysql with docker:
+
+docker run -d --name mysql \
+    -e MYSQL_ROOT_PASSWORD=rootpass \
+    -e MYSQL_USER=testuser \
+    -e MYSQL_PASSWORD=testpass \
+    -e MYSQL_DATABASE=testdb \
+    -p 3306:3306 \
+    --health-cmd="mysqladmin ping -h 127.0.0.1" \
+    --health-interval=10s \
+    --health-timeout=5s \
+    --health-retries=5 \
+    mysql:8.4
+
+Then run the test:
+
+uv run pytest tests/test_bindings.py -m hyperdrive -k mysql
+"""
+
+import sys
+
+import pymysql
+import pytest
+from conftest import unique_table_name
+
+
+@pytest.fixture(autouse=True)
+def skip_if_no_socket_support():
+    if sys.version_info.minor < 14:
+        pytest.skip("Socket support requires Python 3.14+")
+
+
+def _connect(env):
+    hd = env.HYPERDRIVE_MYSQL
+    return pymysql.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        database=hd.database,
+        unix_socket=False,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl_disabled=True,
+    )
+
+
+@pytest.mark.asyncio
+async def test_connect(env):
+    conn = _connect(env)
+    cur = conn.cursor()
+    cur.execute("SELECT 1")
+    assert cur.fetchone() == (1,)
+    conn.close()
+
+
+@pytest.mark.asyncio
+async def test_create_insert_select(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} "
+            "(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100), value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("beta", 2))
+        conn.commit()
+
+        cur.execute(f"SELECT name, value FROM {table} ORDER BY name")
+        assert cur.fetchall() == (("alpha", 1), ("beta", 2))
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_update(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} "
+            "(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100), value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        conn.commit()
+
+        cur.execute(
+            f"UPDATE {table} SET value = value + 10 WHERE name = %s", ("alpha",)
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT value FROM {table} WHERE name = %s", ("alpha",))
+        assert cur.fetchone() == (11,)
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_delete(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100))"
+        )
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("alpha",))
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("beta",))
+        conn.commit()
+
+        cur.execute(f"DELETE FROM {table} WHERE name = %s", ("alpha",))
+        conn.commit()
+
+        cur.execute(f"SELECT name FROM {table}")
+        assert cur.fetchall() == (("beta",),)
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_transaction_rollback(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} "
+            "(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100)) ENGINE=InnoDB"
+        )
+        conn.commit()
+
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("should_disappear",))
+        conn.rollback()
+
+        cur.execute(f"SELECT COUNT(*) FROM {table}")
+        assert cur.fetchone() == (0,)
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_multiple_data_types(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} ("
+            "id INT AUTO_INCREMENT PRIMARY KEY, "
+            "text_col VARCHAR(255), "
+            "int_col INT, "
+            "float_col DOUBLE, "
+            "bool_col BOOLEAN)"
+        )
+        cur.execute(
+            f"INSERT INTO {table} (text_col, int_col, float_col, bool_col) "
+            "VALUES (%s, %s, %s, %s)",
+            ("hello", 42, 3.14, True),
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT text_col, int_col, float_col, bool_col FROM {table}")
+        row = cur.fetchone()
+        assert row[0] == "hello"
+        assert row[1] == 42
+        assert abs(row[2] - 3.14) < 0.001
+        assert row[3] == 1
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_executemany(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100))"
+        )
+        cur.executemany(
+            f"INSERT INTO {table} (name) VALUES (%s)", [("a",), ("b",), ("c",)]
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT name FROM {table} ORDER BY name")
+        assert cur.fetchall() == (("a",), ("b",), ("c",))
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()

workers_runtime_sdk-1.6.15/tests/bindings-test/src/test_hyperdrive_postgresql.py

@@ -0,0 +1,182 @@
+# pyright: reportMissingImports=false
+
+"""
+This test requires a PostgreSQL server to be running on localhost.
+
+Run postgresql with docker:
+
+docker run -d --name postgres \
+    -e POSTGRES_USER=testuser \
+    -e POSTGRES_PASSWORD=testpass \
+    -e POSTGRES_DB=testdb \
+    -e POSTGRES_HOST_AUTH_METHOD=md5 \
+    -e POSTGRES_INITDB_ARGS="--auth-host=md5" \
+    -p 5432:5432 \
+    --health-cmd="pg_isready -U testuser -d testdb" \
+    --health-interval=10s \
+    --health-timeout=5s \
+    --health-retries=5 \
+    postgres:16
+
+Then run the test:
+
+uv run pytest tests/test_bindings.py -m hyperdrive -k postgresql
+
+Note: "POSTGRES_HOST_AUTH_METHOD=md5" is required for PostgreSQL to work with pg8000, since the
+      default `scram-sha-256` is not available in the pg8000 with Python workers (missing openssl)
+"""
+
+import sys
+
+import pg8000
+import pytest
+from conftest import unique_table_name
+
+
+@pytest.fixture(autouse=True)
+def skip_if_no_socket_support():
+    if sys.version_info.minor < 14:
+        pytest.skip("Socket support requires Python 3.14+")
+
+
+def _connect(env):
+    hd = env.HYPERDRIVE_PG
+    return pg8000.connect(
+        host=hd.host,
+        port=int(hd.port),
+        user=hd.user,
+        password=hd.password,
+        database=hd.database,
+        # Hyperdrive terminates TLS to the origin, so this hop is plaintext.
+        ssl_context=False,
+    )
+
+
+@pytest.mark.asyncio
+async def test_connect(env):
+    conn = _connect(env)
+    cur = conn.cursor()
+    cur.execute("SELECT 1")
+    assert cur.fetchone() == [1]
+    conn.close()
+
+
+@pytest.mark.asyncio
+async def test_create_insert_select(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT, value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("beta", 2))
+        conn.commit()
+
+        cur.execute(f"SELECT name, value FROM {table} ORDER BY name")
+        assert list(cur.fetchall()) == [["alpha", 1], ["beta", 2]]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_update(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT, value INT)"
+        )
+        cur.execute(f"INSERT INTO {table} (name, value) VALUES (%s, %s)", ("alpha", 1))
+        conn.commit()
+
+        cur.execute(
+            f"UPDATE {table} SET value = value + 10 WHERE name = %s", ("alpha",)
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT value FROM {table} WHERE name = %s", ("alpha",))
+        assert cur.fetchone() == [11]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_delete(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT)")
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("alpha",))
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("beta",))
+        conn.commit()
+
+        cur.execute(f"DELETE FROM {table} WHERE name = %s", ("alpha",))
+        conn.commit()
+
+        cur.execute(f"SELECT name FROM {table}")
+        assert list(cur.fetchall()) == [["beta"]]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_transaction_rollback(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(f"CREATE TABLE {table} (id SERIAL PRIMARY KEY, name TEXT)")
+        conn.commit()
+
+        cur.execute(f"INSERT INTO {table} (name) VALUES (%s)", ("should_disappear",))
+        conn.rollback()
+
+        cur.execute(f"SELECT COUNT(*) FROM {table}")
+        assert cur.fetchone() == [0]
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()
+
+
+@pytest.mark.asyncio
+async def test_multiple_data_types(env):
+    conn = _connect(env)
+    table = unique_table_name()
+    cur = conn.cursor()
+    try:
+        cur.execute(
+            f"CREATE TABLE {table} ("
+            "id SERIAL PRIMARY KEY, "
+            "text_col TEXT, "
+            "int_col INT, "
+            "float_col DOUBLE PRECISION, "
+            "bool_col BOOLEAN)"
+        )
+        cur.execute(
+            f"INSERT INTO {table} (text_col, int_col, float_col, bool_col) "
+            "VALUES (%s, %s, %s, %s)",
+            ("hello", 42, 3.14, True),
+        )
+        conn.commit()
+
+        cur.execute(f"SELECT text_col, int_col, float_col, bool_col FROM {table}")
+        row = cur.fetchone()
+        assert row[0] == "hello"
+        assert row[1] == 42
+        assert abs(row[2] - 3.14) < 0.001
+        assert row[3] is True
+    finally:
+        cur.execute(f"DROP TABLE IF EXISTS {table}")
+        conn.commit()
+        conn.close()

{workers_runtime_sdk-1.6.13 → workers_runtime_sdk-1.6.15}/tests/bindings-test/wrangler.jsonc

@@ -49,6 +49,18 @@
     "analytics_engine_datasets": [
         { "binding": "ANALYTICS", "dataset": "test-dataset" }
     ],
+    "hyperdrive": [
+        {
+            "binding": "HYPERDRIVE_PG",
+            "id": "00000000-0000-0000-0000-000000000001",
+            "localConnectionString": "postgres://testuser:testpass@127.0.0.1:5432/testdb"
+        },
+        {
+            "binding": "HYPERDRIVE_MYSQL",
+            "id": "00000000-0000-0000-0000-000000000002",
+            "localConnectionString": "mysql://testuser:testpass@127.0.0.1:3306/testdb"
+        }
+    ],
     "images": { "binding": "IMAGES" },
     "ratelimits": [
         { "name": "RATE_LIMITER", "namespace_id": "1001", "simple": { "period": 60, "limit": 100 } }

{workers_runtime_sdk-1.6.13 → workers_runtime_sdk-1.6.15}/tests/conftest.py

@@ -24,6 +24,22 @@ DEV_POLL_INTERVAL: float = 0.5
 SUITE_CONNECT_TIMEOUT: int = 10
 SUITE_READ_TIMEOUT: int = 300
 
+OPT_IN_MARKERS: tuple[str, ...] = ("hyperdrive",)
+
+
+def pytest_collection_modifyitems(
+    config: pytest.Config, items: list[pytest.Item]
+) -> None:
+    """Skip opt-in suites unless the run explicitly asks for them via ``-m``."""
+    markexpr: str = config.getoption("markexpr")
+    for marker in OPT_IN_MARKERS:
+        if marker in markexpr:
+            continue
+        skip = pytest.mark.skip(reason=f"needs local services; run with -m {marker}")
+        for item in items:
+            if marker in item.keywords:
+                item.add_marker(skip)
+
 
 @dataclass(frozen=True)
 class CompatConfig:
@@ -256,12 +272,19 @@ def discover_suites(src_dir: Path) -> dict[str, list[str]]:
     }
 
 
-def register_in_worker_suites(namespace: dict[str, Any], src_dir: Path) -> None:
+def register_in_worker_suites(
+    namespace: dict[str, Any],
+    src_dir: Path,
+    marks: dict[str, pytest.MarkDecorator] | None = None,
+) -> None:
     """Define a ``TestXxx`` class in `namespace` for every suite found in `src_dir`.
 
     Call with ``globals()`` from a test module so each in-worker test surfaces as
-    its own pytest case without manual registration.
+    its own pytest case without manual registration. `marks` applies a marker to
+    the class generated for the suite of the same name.
     """
     for suite, test_names in discover_suites(src_dir).items():
         suite_cls = make_suite_class(suite, test_names)
+        if marks and suite in marks:
+            suite_cls = marks[suite](suite_cls)
         namespace[suite_cls.__name__] = suite_cls