locust-cloud 1.25.2.dev3__tar.gz → 1.25.3.dev5__tar.gz

{locust_cloud-1.25.2.dev3 → locust_cloud-1.25.3.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: locust-cloud
-Version: 1.25.2.dev3
+Version: 1.25.3.dev5
 Summary: Locust Cloud
 Project-URL: homepage, https://locust.cloud
 Project-URL: repository, https://github.com/locustcloud/locust-cloud

{locust_cloud-1.25.2.dev3 → locust_cloud-1.25.3.dev5}/locust_cloud/args.py

@@ -10,6 +10,7 @@ import tempfile
 
 from locust_cloud.actions import delete
 from locust_cloud.apisession import ApiSession
+from locust_cloud.common import CWD
 from locust_cloud.web_login import logout, web_login
 
 if sys.version_info >= (3, 11):
@@ -25,8 +26,6 @@ from zipfile import ZipFile
 
 import configargparse
 
-CWD = pathlib.Path.cwd()
-
 
 class LocustTomlConfigParser(configargparse.TomlConfigParser):
     def parse(self, stream: IO[str]) -> OrderedDict[str, Any]:

{locust_cloud-1.25.2.dev3 → locust_cloud-1.25.3.dev5}/locust_cloud/cloud.py

@@ -15,6 +15,7 @@ from locust_cloud.args import (
     zip_project_paths,
 )
 from locust_cloud.common import __version__
+from locust_cloud.import_finder import get_imported_files
 from locust_cloud.input_events import input_listener
 from locust_cloud.websocket import SessionMismatchError, Websocket, WebsocketTimeout
 
@@ -55,11 +56,18 @@ def main(locustfiles: list[str] | None = None):
         logger.error(e)
         return
 
-    project_data = zip_project_paths(set(relative_locustfiles + (options.extra_files or [])))
-
     session = ApiSession(options.non_interactive)
     websocket = Websocket()
 
+    auto_extra_files = set()
+    for lf in relative_locustfiles:
+        auto_extra_files.update(get_imported_files(lf))
+
+    project_files = set(relative_locustfiles + (options.extra_files or []) + list(auto_extra_files))
+    logger.debug(f"Project files: {project_files}")
+
+    project_data = zip_project_paths(project_files)
+
     try:
         logger.info(f"Deploying ({session.region}, locust-cloud {__version__})")
         locust_env_variables = [
@@ -147,10 +155,9 @@ def main(locustfiles: list[str] | None = None):
 
         log_ws_url = js["log_ws_url"]
         session_id = js["session_id"]
-        webui_url = log_ws_url.replace("/socket-logs", "")
 
         def open_ui():
-            webbrowser.open_new_tab(webui_url)
+            webbrowser.open_new_tab("https://auth.locust.cloud/load-test")
 
         Thread(target=input_listener({"\r": open_ui, "\n": open_ui}), daemon=True).start()
 

{locust_cloud-1.25.2.dev3 → locust_cloud-1.25.3.dev5}/locust_cloud/common.py

@@ -8,6 +8,8 @@ import platformdirs
 
 __version__ = importlib.metadata.version("locust-cloud")
 
+CWD = pathlib.Path.cwd()
+
 
 VALID_REGIONS = ["us-east-1", "eu-north-1"]
 CLOUD_CONF_FILE = pathlib.Path(platformdirs.user_config_dir(appname="locust-cloud")) / "config"

locust_cloud-1.25.3.dev5/locust_cloud/import_finder.py

@@ -0,0 +1,63 @@
+import ast
+import importlib.util
+import logging
+import site
+from pathlib import Path
+
+from locust_cloud.common import CWD
+
+logger = logging.getLogger(__name__)
+
+SITE_PACKAGES_PATHS = [Path(p) for p in [site.getusersitepackages(), *site.getsitepackages()]]
+
+
+def imported_modules(tree):
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                yield alias.name.split(".")[0]
+        if isinstance(node, ast.ImportFrom):
+            if node.level:  # relative import
+                continue
+            if node.module:
+                yield node.module.split(".")[0]
+
+
+def get_imported_files(file_path: Path) -> set[Path]:
+    """
+    Get a list of path that are imported from the given python script
+    They are returned as relative paths to CWD
+    """
+    paths_queue: list[Path] = [Path(file_path).resolve()]
+    paths_seen: set[Path] = set()
+    imports: set[Path] = set()
+
+    while paths_queue:
+        current = paths_queue.pop()
+        if current in paths_seen:
+            continue
+
+        tree = ast.parse(current.read_text())
+        for mod in imported_modules(tree):
+            spec = importlib.util.find_spec(mod)
+            if spec and spec.origin:
+                p = Path(spec.origin).resolve()
+                if (
+                    p != current
+                    and p.is_relative_to(CWD)
+                    and all(parent not in SITE_PACKAGES_PATHS for parent in p.parents)
+                    and all(parent not in imports for parent in p.parents)
+                    and not "site-packages" in str(p)
+                ):
+                    # add the whole package directory if __init__.py, else the file
+                    if p.name == "__init__.py":
+                        pkg_dir = p.parent
+                        paths_queue.extend([p for p in pkg_dir.rglob("*.py") if p.is_file()])
+                        imports.add(p.parent)
+                    else:
+                        paths_queue.append(p)
+                        imports.add(p)
+            else:
+                logger.debug(f"Unable to find spec for module: {mod}")
+
+    return set([i.relative_to(CWD) for i in imports])

locust_cloud-1.25.3.dev5/tests/import_finder_test.py

@@ -0,0 +1,145 @@
+import shutil
+import tempfile
+import textwrap
+from contextlib import contextmanager
+from pathlib import Path
+
+from locust_cloud.import_finder import CWD, get_imported_files
+
+
+@contextmanager
+def temporary_file(content, dir=CWD, suffix=".py"):
+    with tempfile.NamedTemporaryFile(dir=dir, suffix=suffix) as f:
+        f.write(content.encode())
+        f.seek(0)
+        yield f.name
+
+
+def import_name(path):
+    return str(Path(path).relative_to(CWD)).removesuffix(".py")
+
+
+def test_ignore_external_packages_imports():
+    with temporary_file("import requests") as f:
+        assert len(get_imported_files(Path(f))) == 0
+
+
+def test_import_file():
+    with temporary_file(
+        textwrap.dedent(
+            """
+                def foo():
+                    return "bar"
+            """
+        )
+    ) as to_import:
+        with temporary_file(f"import {import_name(to_import)}\n") as f:
+            imports = get_imported_files(Path(f))
+            assert imports == {Path(to_import).relative_to(CWD)}
+
+
+def test_from_import_file():
+    with temporary_file(
+        textwrap.dedent(
+            """
+                def foo():
+                    return "bar"
+            """
+        )
+    ) as to_import:
+        with temporary_file(f"from {import_name(to_import)} import foo") as f:
+            assert get_imported_files(Path(f)) == {Path(to_import).relative_to(CWD)}
+
+
+def test_all_imports():
+    with temporary_file(
+        textwrap.dedent(
+            """
+                def foo():
+                    return "bar"
+            """
+        )
+    ) as to_import:
+        with temporary_file(
+            textwrap.dedent(
+                f"""
+                    import requests
+                    import {import_name(to_import)}
+                """
+            )
+        ) as f:
+            assert get_imported_files(Path(f)) == {Path(to_import).relative_to(CWD)}
+
+
+def test_second_level_imports():
+    with temporary_file(
+        textwrap.dedent(
+            """
+                def foo():
+                    return "bar"
+            """
+        )
+    ) as to_import:
+        with temporary_file(
+            textwrap.dedent(
+                f"""
+                    def bar():
+                        import {import_name(to_import)}
+                """
+            )
+        ) as f:
+            assert get_imported_files(Path(f)) == {Path(to_import).relative_to(CWD)}
+
+
+def test_recursive_imports():
+    with temporary_file(
+        textwrap.dedent(
+            """
+                def foo():
+                    return "bar"
+            """
+        )
+    ) as to_import_1:
+        with temporary_file(f"import {import_name(to_import_1)}") as to_import:
+            with temporary_file(f"import {import_name(to_import)}") as f:
+                assert get_imported_files(Path(f)) == {
+                    Path(to_import).relative_to(CWD),
+                    Path(to_import_1).relative_to(CWD),
+                }
+
+
+def test_package_imports():
+    test_package = CWD / "test_package"
+    test_package.mkdir()
+
+    (test_package / "__init__.py").write_text(
+        textwrap.dedent(
+            """
+                from test import bar
+                def foo():
+                    return "bar"
+            """
+        )
+    )
+    (test_package / "test.py").write_text(
+        textwrap.dedent(
+            """
+                def bar():
+                    return "baz"
+            """
+        )
+    )
+    try:
+        with temporary_file("import test_package") as f:
+            assert get_imported_files(Path(f)) == {test_package.relative_to(CWD)}
+
+        with temporary_file("import test_package.test") as f:
+            assert get_imported_files(Path(f)) == {test_package.relative_to(CWD)}
+
+        with temporary_file("from test_package import bar") as f:
+            assert get_imported_files(Path(f)) == {test_package.relative_to(CWD)}
+
+        with temporary_file("from test_package.test import bar") as f:
+            assert get_imported_files(Path(f)) == {test_package.relative_to(CWD)}
+    finally:
+        shutil.rmtree(test_package, ignore_errors=True)