add supported builtin modules with integration test

Author: DevTGHa

CONTRIBUTING.md

@@ -31,14 +31,19 @@ Thank you for your interest in contributing to designer-plugin! This document pr
 
 ### Running Tests
 
-Run the full test suite:
+Run unit tests (default):
 ```bash
 uv run pytest
 ```
 
-Run tests with verbose output:
+Run integration tests (requires a running d3 instance):
 ```bash
-uv run pytest -v
+uv run pytest -m integration
+```
+
+Run all tests:
+```bash
+uv run pytest -m ""
 ```
 
 Run specific test file:

pyproject.toml

@@ -109,6 +109,11 @@ python_classes = ["Test*"]
 python_functions = ["test_*"]
 addopts = [
     "-v",
+    "-m", "not integration",
     "--strict-markers",
     "--strict-config",
 ]
+markers = [
+    "integration: tests that require a running d3 instance",
+]
+

src/designer_plugin/d3sdk/ast_utils.py

@@ -13,6 +13,8 @@
 
 from pydantic import BaseModel, Field
 
+from designer_plugin.d3sdk.builtin_modules import SUPPORTED_MODULES
+
 
 ###############################################################################
 # Package info models
@@ -22,7 +24,9 @@ class ImportAlias(BaseModel):
     Mirrors the structure of ast.alias for Pydantic compatibility.
     """
 
-    name: str = Field(description="The imported name (e.g., 'Path' in 'from pathlib import Path')")
+    name: str = Field(
+        description="The imported name (e.g., 'Path' in 'from pathlib import Path')"
+    )
     asname: str | None = Field(
         default=None,
         description="The alias (e.g., 'np' in 'import numpy as np')",
@@ -54,15 +58,11 @@ def to_import_statement(self) -> str:
         if self.methods:
             node = ast.ImportFrom(
                 module=self.package,
-                names=[
-                    ast.alias(name=m.name, asname=m.asname) for m in self.methods
-                ],
+                names=[ast.alias(name=m.name, asname=m.asname) for m in self.methods],
                 level=0,
             )
         else:
-            node = ast.Import(
-                names=[ast.alias(name=self.package, asname=self.alias)]
-            )
+            node = ast.Import(names=[ast.alias(name=self.package, asname=self.alias)])
         return ast.unparse(node)
 
 
@@ -453,21 +453,17 @@ def _collect_used_names(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> se
     return names
 
 
-# Shared exclusion constants
-_EXCLUDED_PACKAGES: set[str] = {"d3blobgen", "typing"}
-
-
 def _is_type_checking_block(node: ast.If) -> bool:
     """Check if an if statement is ``if TYPE_CHECKING:``."""
     return isinstance(node.test, ast.Name) and node.test.id == "TYPE_CHECKING"
 
 
-def _is_excluded_package(module_name: str) -> bool:
-    """Check if a module name matches any excluded package."""
-    return any(excluded in module_name for excluded in _EXCLUDED_PACKAGES)
+def _is_builtin_package(module_name: str) -> bool:
+    """Check if a module name matches python builtin package."""
+    return module_name in SUPPORTED_MODULES
 
 
-@functools.lru_cache(maxsize=None)
+@functools.cache
 def _get_module_ast(module: types.ModuleType) -> ast.Module | None:
     """Return the parsed AST for *module*, cached by module identity."""
     try:
@@ -526,8 +522,9 @@ def find_imports_for_function(func: Callable[..., Any]) -> list[PackageInfo]:
 
         if isinstance(node, ast.Import):
             for alias in node.names:
-                if _is_excluded_package(alias.name):
+                if not _is_builtin_package(alias.name):
                     continue
+
                 # The name used in code is the alias if present, otherwise the module name
                 effective_name = alias.asname if alias.asname else alias.name
                 if effective_name in used_names:
@@ -541,7 +538,7 @@ def find_imports_for_function(func: Callable[..., Any]) -> list[PackageInfo]:
         elif isinstance(node, ast.ImportFrom):
             if not node.module:
                 continue
-            if _is_excluded_package(node.module):
+            if not _is_builtin_package(node.module):
                 continue
 
             # Filter to only methods actually used by the function

src/designer_plugin/d3sdk/builtin_modules.py

@@ -0,0 +1,220 @@
+SUPPORTED_MODULES: frozenset[str] = frozenset(
+    [
+        "Bastion",
+        "ConfigParser",
+        "Cookie",
+        "HTMLParser",
+        "SocketServer",
+        "StringIO",
+        "UserDict",
+        "UserList",
+        "_winreg",
+        "abc",
+        "aifc",
+        "anydbm",
+        "array",
+        "ast",
+        "atexit",
+        "audioop",
+        "base64",
+        "binascii",
+        "bisect",
+        "bz2",
+        "cPickle",
+        "cStringIO",
+        "chunk",
+        "cmath",
+        "cmd",
+        "codecs",
+        "codeop",
+        "collections",
+        "copy",
+        "copy_reg",
+        "csv",
+        "ctypes",
+        "datetime",
+        "difflib",
+        "dircache",
+        "dis",
+        "dumbdbm",
+        "dummy_thread",
+        "errno",
+        "filecmp",
+        "fnmatch",
+        "functools",
+        "future_builtins",
+        "gc",
+        "getopt",
+        "hashlib",
+        "heapq",
+        "hmac",
+        "htmlentitydefs",
+        "imghdr",
+        "imp",
+        "importlib",
+        "inspect",
+        "io",
+        "itertools",
+        "json",
+        "keyword",
+        "linecache",
+        "locale",
+        "logging",
+        "mailcap",
+        "marshal",
+        "math",
+        "mmap",
+        "msvcrt",
+        "mutex",
+        "netrc",
+        "new",
+        "nntplib",
+        "numbers",
+        "operator",
+        "os",
+        "parser",
+        "pkgutil",
+        "plistlib",
+        "poplib",
+        "pprint",
+        "quopri",
+        "random",
+        "re",
+        "repr",
+        "rfc822",
+        "rlcompleter",
+        "sched",
+        "select",
+        "sets",
+        "sgmllib",
+        "sha",
+        "shelve",
+        "shlex",
+        "shutil",
+        "signal",
+        "site",
+        "sndhdr",
+        "socket",
+        "sqlite3",
+        "stat",
+        "statvfs",
+        "string",
+        "stringprep",
+        "struct",
+        "subprocess",
+        "sunau",
+        "symbol",
+        "symtable",
+        "sysconfig",
+        "tempfile",
+        "textwrap",
+        "thread",
+        "time",
+        "token",
+        "tokenize",
+        "traceback",
+        "types",
+        "unicodedata",
+        "unittest",
+        "urlparse",
+        "uuid",
+        "warnings",
+        "weakref",
+        "webbrowser",
+        "winsound",
+        "wsgiref",
+        "xdrlib",
+        "xml",
+        "zipfile",
+        "zipimport",
+        "zlib",
+    ]
+)
+
+NOT_SUPPORTED_MODULES: frozenset[str] = frozenset(
+    [
+        "BaseHTTPServer",
+        "CGIHTTPServer",
+        "DocXMLRPCServer",
+        "Queue",
+        "ScrolledText",
+        "SimpleHTTPServer",
+        "SimpleXMLRPCServer",
+        "Tix",
+        "Tkinter",
+        "UserString",
+        "argparse",
+        "asynchat",
+        "asyncore",
+        "bdb",
+        "binhex",
+        "bsddb",
+        "calendar",
+        "cgi",
+        "cgitb",
+        "code",
+        "colorsys",
+        "compileall",
+        "compiler",
+        "contextlib",
+        "cookielib",
+        "dbhash",
+        "dbm",
+        "decimal",
+        "distutils",
+        "doctest",
+        "dummy_threading",
+        "email",
+        "ensurepip",
+        "fileinput",
+        "formatter",
+        "fractions",
+        "ftplib",
+        "getpass",
+        "gettext",
+        "glob",
+        "gzip",
+        "htmllib",
+        "httplib",
+        "imaplib",
+        "mailbox",
+        "mhlib",
+        "mimetools",
+        "mimetypes",
+        "mimify",
+        "modulefinder",
+        "msilib",
+        "multiprocessing",
+        "optparse",
+        "pdb",
+        "pickle",
+        "pickletools",
+        "platform",
+        "popen2",
+        "profile",
+        "py_compile",
+        "pyclbr",
+        "pydoc",
+        "robotparser",
+        "runpy",
+        "smtpd",
+        "smtplib",
+        "ssl",
+        "sys",
+        "tabnanny",
+        "tarfile",
+        "telnetlib",
+        "test",
+        "threading",
+        "timeit",
+        "trace",
+        "ttk",
+        "turtle",
+        "urllib",
+        "urllib2",
+        "uu",
+        "wave",
+        "whichdb",
+        "xmlrpclib",
+    ]
+)

tests/test_supported_modules.py

@@ -0,0 +1,49 @@
+from designer_plugin.d3sdk import d3function, D3AsyncSession
+from designer_plugin.d3sdk.builtin_modules import SUPPORTED_MODULES, NOT_SUPPORTED_MODULES
+
+import pytest
+import asyncio
+
+@d3function('test_supported_modules')
+def check_import(module_str) -> bool:
+    try:
+        module = __import__(module_str)
+        return True
+    except ImportError as e:
+        return False
+
+class TestSupportedModules:
+    """
+    Test if supported and not supported modules are handled properly on Deisgner side.
+    This is integration test so Designer must be running to pass the test.
+    """
+
+    @pytest.mark.integration
+    def test_supported_modules(self):
+        """Test if all supported modules are able to be imported on Designer side."""
+        async def run():
+            failed = []
+            async with D3AsyncSession("localhost", 80) as session:
+                for module_str in SUPPORTED_MODULES:
+                    import_success: bool = await session.rpc(
+                        check_import.payload(module_str)
+                    )
+                    if not import_success:
+                        failed.append(module_str)
+            assert not failed, f"Failed to import: {failed}"
+        asyncio.run(run())
+
+    @pytest.mark.integration
+    def test_not_supported_modules(self):
+        """Test if all not supported modules are not importable on Designer side."""
+        async def run():
+            failed = []
+            async with D3AsyncSession("localhost", 80) as session:
+                for module_str in NOT_SUPPORTED_MODULES:
+                    import_success: bool = await session.rpc(
+                        check_import.payload(module_str)
+                    )
+                    if import_success:
+                        failed.append(module_str)
+            assert not failed, f"Unexpectedly imported: {failed}"
+        asyncio.run(run())