pynguin 0.41.0__tar.gz → 0.43.0__tar.gz

{pynguin-0.41.0 → pynguin-0.43.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: pynguin
-Version: 0.41.0
+Version: 0.43.0
 Summary: Pynguin is a tool for automated unit test generation for Python
 License: MIT
 Keywords: unit test,random testing,search based,test generation
 Author: Stephan Lukasczyk
 Author-email: stephan@pynguin.eu
-Requires-Python: >=3.10,<3.11
+Requires-Python: >=3.10,<3.14
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -18,13 +18,16 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Education :: Testing
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Software Development :: Testing :: Unit
 Classifier: Typing :: Typed
 Requires-Dist: Jinja2 (>=3.1.6,<4.0.0)
-Requires-Dist: Pygments (>=2.19.1,<3.0.0)
+Requires-Dist: Pygments (>=2.19.2,<3.0.0)
 Requires-Dist: asciitree (>=0.3.3,<0.4.0)
 Requires-Dist: astroid (>=3.3.9,<4.0.0)
 Requires-Dist: black (>=25.1.0,<26.0.0)
@@ -113,9 +116,7 @@ please report your experiences in using Pynguin to us.
 ## Prerequisites
 
 Before you begin, ensure you have met the following requirements:
-- You have installed Python 3.10 (we have not yet tested with Python
-  3.11, there might be some problems due to changed internals regarding the byte-code
-  instrumentation).
+- You have installed Python 3.10 (the support for 3.11, 3.12 and 3.13 is experimental).
 
   **Attention:** Pynguin now requires Python 3.10!  Older versions are no longer
   supported!

{pynguin-0.41.0 → pynguin-0.43.0}/README.md

@@ -66,9 +66,7 @@ please report your experiences in using Pynguin to us.
 ## Prerequisites
 
 Before you begin, ensure you have met the following requirements:
-- You have installed Python 3.10 (we have not yet tested with Python
-  3.11, there might be some problems due to changed internals regarding the byte-code
-  instrumentation).
+- You have installed Python 3.10 (the support for 3.11, 3.12 and 3.13 is experimental).
 
   **Attention:** Pynguin now requires Python 3.10!  Older versions are no longer
   supported!

{pynguin-0.41.0 → pynguin-0.43.0}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [tool.poetry]
 name = "pynguin"
-version = "0.41.0"
+version = "0.43.0"
 description = "Pynguin is a tool for automated unit test generation for Python"
 authors = [
   "Stephan Lukasczyk <stephan@pynguin.eu>",
@@ -32,6 +32,9 @@ classifiers = [
   "Operating System :: Microsoft :: Windows",
   "Operating System :: POSIX :: Linux",
   "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: Implementation :: CPython",
   "Topic :: Education :: Testing",
   "Topic :: Software Development :: Testing",
@@ -46,7 +49,7 @@ include = [
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.10, <3.11"
+python = ">=3.10, <3.14"
 astroid = "^3.3.9"
 black = "^25.1.0"
 bytecode = "^0.16.1"
@@ -55,7 +58,7 @@ Jinja2 = "^3.1.6"
 networkx = "^3.4"
 multiprocess = "^0.70.16"
 rich = "^14.0.0"
-Pygments = "^2.19.1"
+Pygments = "^2.19.2"
 pytest = "^8.3.5"
 simple-parsing = "^0.1.7"
 typing_inspect = "^0.9.0"
@@ -72,6 +75,7 @@ pre-commit = "^4.2.0"
 ruff = "^0.11"
 types-toml = "^0.10.8.20240310"
 types-pyyaml = "^6.0.12.20250516"
+types-networkx = "^3.4"
 
 [tool.poetry.group.docs.dependencies]
 sphinx = "^8.1.3"
@@ -106,6 +110,7 @@ pynguin = "pynguin.cli:main"
 branch = true
 source = ["src/pynguin", "tests"]
 omit = ["tests/fixtures/*"]
+relative_files = true
 
 [tool.coverage.report]
 exclude_lines = [
@@ -276,3 +281,18 @@ convention = "google"
   "S101", # Use of `assert` detected
   "SLF001", # Private member accessed
 ]
+
+[tool.tox]
+requires = ["tox~=4.28"]
+env_list = ["3.10", "3.11", "3.12", "3.13"]
+
+[tool.tox.env_run_base]
+skip_install = true
+allowlist_externals = ["make", "poetry"]
+commands_pre = [
+  ["poetry", "env", "use", "{env_name}"],
+  ["poetry", "install", "--with", "openai,numpy"],
+]
+commands = [
+  ["make", "check"],
+]

{pynguin-0.41.0 → pynguin-0.43.0}/src/pynguin/__version__.py

@@ -6,4 +6,4 @@
 #
 """Specifies the version of Pynguin."""
 
-__version__ = "0.41.0"
+__version__ = "0.43.0"

{pynguin-0.41.0 → pynguin-0.43.0}/src/pynguin/analyses/constants.py

@@ -288,8 +288,12 @@ def collect_static_constants(project_path: str | os.PathLike) -> ConstantPool:
             try:
                 tree = ast.parse(module_file.read())
                 collector.visit(tree)
-            except BaseException as exception:
-                logger.exception("Cannot collect constants: %s", exception)
+            except BaseException as exception:  # noqa: BLE001
+                logger.warning(
+                    "Could not collect constants from %s. Skipping constant collection (%s).",
+                    module,
+                    exception,
+                )
     return collector.constants
 
 

{pynguin-0.41.0 → pynguin-0.43.0}/src/pynguin/analyses/module.py

@@ -35,10 +35,13 @@ from typing import Any
 import astroid
 
 import pynguin.configuration as config
-import pynguin.utils.pynguinml.ml_testing_resources as tr
 import pynguin.utils.statistics.stats as stat
 import pynguin.utils.typetracing as tt
 
+
+if config.configuration.pynguinml.ml_testing_enabled or typing.TYPE_CHECKING:
+    import pynguin.utils.pynguinml.ml_testing_resources as tr
+
 from pynguin.analyses.modulecomplexity import mccabe_complexity
 from pynguin.analyses.syntaxtree import FunctionDescription
 from pynguin.analyses.syntaxtree import astroid_to_ast
@@ -58,10 +61,10 @@ from pynguin.analyses.typesystem import UnionType
 from pynguin.analyses.typesystem import Unsupported
 from pynguin.analyses.typesystem import is_primitive_type
 from pynguin.configuration import TypeInferenceStrategy
-from pynguin.instrumentation.instrumentation import CODE_OBJECT_ID_KEY
 from pynguin.utils import randomness
 from pynguin.utils.exceptions import ConstraintValidationError
 from pynguin.utils.exceptions import ConstructionFailedException
+from pynguin.utils.exceptions import CoroutineFoundException
 from pynguin.utils.generic.genericaccessibleobject import GenericAccessibleObject
 from pynguin.utils.generic.genericaccessibleobject import (
     GenericCallableAccessibleObject,
@@ -196,31 +199,199 @@ def _is_blacklisted(element: Any) -> bool:
     module_blacklist = set(MODULE_BLACKLIST).union(config.configuration.ignore_modules)
     method_blacklist = set(METHOD_BLACKLIST).union(config.configuration.ignore_methods)
 
-    if inspect.ismodule(element):
-        return element.__name__ in module_blacklist
-    if inspect.isclass(element):
-        if element.__module__ == "builtins" and (element in PRIMITIVES or element in COLLECTIONS):
-            # Allow some builtin types
-            return False
-        return element.__module__ in module_blacklist
-    if inspect.isfunction(element):
-        # Some modules can be run standalone using a main function or provide a small
-        # set of tests ('test'). We don't want to include those functions.
-        # Importing certain modules such as inspect, that use or import C-functions can
-        # lead to __module__ being None. We want to exclude these functions as well.
-        return (
-            element.__module__ is None
-            or element.__module__ in module_blacklist
-            or element.__qualname__.startswith((
-                "main",
-                "test",
-            ))
-            or f"{element.__module__}.{element.__qualname__}" in method_blacklist
+    try:
+        if inspect.ismodule(element):
+            return element.__name__ in module_blacklist
+        if inspect.isclass(element):
+            if element.__module__ == "builtins" and (
+                element in PRIMITIVES or element in COLLECTIONS
+            ):
+                # Allow some builtin types
+                return False
+            return element.__module__ in module_blacklist
+        if inspect.isfunction(element):
+            # Some modules can be run standalone using a main function or provide a small
+            # set of tests ('test'). We don't want to include those functions.
+            # Importing certain modules such as inspect, that use or import C-functions can
+            # lead to __module__ being None. We want to exclude these functions as well.
+            return (
+                element.__module__ is None
+                or element.__module__ in module_blacklist
+                or element.__qualname__.startswith((
+                    "main",
+                    "test",
+                ))
+                or f"{element.__module__}.{element.__qualname__}" in method_blacklist
+            )
+    except Exception:  # noqa: BLE001
+        LOGGER.warning(
+            "Could not check if %s is blacklisted. Assuming it is not.", element, exc_info=True
+        )
+    # Something that is not supported yet.
+    return False
+
+
+C_MODULE_WHITELIST = frozenset((
+    # === Basic C modules (interpreter startup) ===
+    "abc",
+    "ast",
+    "codecs",
+    "collections",
+    "enum",
+    "functools",
+    "imp",
+    "io",
+    "locale",
+    "operator",
+    "signal",
+    "sitebuiltins",
+    "stat",
+    "thread",
+    "tracemalloc",
+    "weakref",
+    "builtins",
+    "errno",
+    "marshal",
+    "sys",
+    "time",
+    "sre",
+    "symtable",
+    "warnings",
+    "string",
+    "re",
+    "inspect",
+    "tokenize",
+    # === Common Data Structures & Algorithms ===
+    "array",
+    "bisect",
+    "heapq",
+    "itertools",
+    # === Math & Random ===
+    "math",
+    "random",
+    "statistics",
+    # === Data Serialization & Formats ===
+    "csv",
+    "json",
+    "pickle",
+    "struct",
+    "elementtree",
+    "pyexpat",
+    "binascii",
+    # === Hashing & Cryptography ===
+    "hashlib",
+    "ssl",
+    "blake2",
+    "md5",
+    "sha3",
+    "unicodedata",
+    # === Compression ===
+    "zlib",
+    "bz2",
+    "lzma",
+    # === Concurrency & Interoperability ===
+    # "multiprocessing", # Explicitly not included
+    # "ctypes",  # Explicitly not included
+    # "asyncio",  # Explicitly not included
+    # === Networking ===
+    "socket",
+    "select",
+    # === Database ===
+    "sqlite3",
+    # === GUI ===
+    "tkinter",
+    # === Introspection & Debugging ===
+    "gc",
+    "faulthandler",
+    # === Platform: POSIX/Unix-like ===
+    "posix",
+    # "posixsubprocess", # Explicitly not included
+    "fcntl",
+    "grp",
+    "pwd",
+    "resource",
+    "termios",
+    # === Platform: Windows ===
+    "winapi",
+    "msvcrt",
+    # === Platform: macOS ===
+    "scproxy",
+    # === Platform: Cross-platform ===
+    "mmap",
+    # --- Other ---
+    "queue",
+    "decimal",
+    "uuid",
+    "datetime",
+    "zoneinfo",
+    "shlex",
+    "calendar",
+    "yaml",
+    "email",
+    "syslog",
+    "dataclasses",
+    "pprint",
+    "difflib",
+    "cmath",
+    "hmac",
+))
+
+
+def _c_is_whitelisted(element: ModuleType) -> bool:
+    """Checks if the given element belongs to the C module whitelist.
+
+    Args:
+        element: The element to check
+
+    Returns:
+        Is the element whitelisted?
+    """
+    c_module_whitelist = set(C_MODULE_WHITELIST)
+
+    try:
+        module_name = element.__name__
+        top_level = module_name.split(".")[0]
+        public_top_level = top_level.lstrip("_")
+        return public_top_level in c_module_whitelist
+    except Exception:  # noqa: BLE001
+        LOGGER.warning(
+            "Could not check if %s is whitelisted. Assuming it is not.", element, exc_info=True
         )
     # Something that is not supported yet.
     return False
 
 
+def _handle_c_modules(
+    c_extensions: set[str],
+) -> None:
+    """Handles the C extensions in the subject module.
+
+    Args:
+        c_extensions: The set of C extensions.
+    """
+    subprocess_mode_recommended = len(c_extensions) > 0
+    if config.configuration.subprocess_if_recommended:
+        config.configuration.subprocess = subprocess_mode_recommended
+        LOGGER.info(
+            "Subprocess mode is set to %s because the subject module uses "
+            "the following C extensions: %s. ",
+            config.configuration.subprocess,
+            ", ".join(sorted(c_extensions)),
+        )
+    elif not config.configuration.subprocess and subprocess_mode_recommended:
+        LOGGER.warning(
+            "You are using threaded execution mode, but the subject module "
+            "uses the following C extensions: %s. "
+            "This may lead to unexpected behavior, consider using "
+            "subprocess mode instead.",
+            ", ".join(sorted(c_extensions)),
+        )
+
+    # Store the discovered C extensions in the statistics
+    stat.track_output_variable(RuntimeVariable.CExtensionModules, str(sorted(c_extensions)))
+    stat.track_output_variable(RuntimeVariable.SubprocessMode, str(config.configuration.subprocess))
+
+
 @dataclasses.dataclass
 class _ModuleParseResult:
     """A data wrapper for an imported and parsed module."""
@@ -934,8 +1105,14 @@ class FilteredModuleTestCluster(TestCluster):  # noqa: PLR0904
     ) -> None:
         self.__delegate = delegate
         self.__subject_properties = subject_properties
-        self.__code_object_id_to_accessible_objects: dict[int, GenericCallableAccessibleObject] = {
-            json.loads(acc.callable.__code__.co_consts[0])[CODE_OBJECT_ID_KEY]: acc
+
+        existing_code_objects = {
+            metadata.code_object: code_object_id
+            for code_object_id, metadata in subject_properties.existing_code_objects.items()
+        }
+
+        self.__code_object_id_to_accessible_objects = {
+            existing_code_objects[acc.callable.__code__]: acc
             for acc in delegate.accessible_objects_under_test
             if isinstance(acc, GenericCallableAccessibleObject)
             and hasattr(acc.callable, "__code__")
@@ -1132,7 +1309,7 @@ def __analyse_function(
         return
     if inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction(func):
         if add_to_test:
-            raise ValueError("Pynguin cannot handle Coroutine in SUT. Stopping.")
+            raise CoroutineFoundException("Found coroutine in SUT: %s", func_name)
         # Coroutine outside the SUT are not problematic, just exclude them.
         LOGGER.debug("Skipping coroutine %s outside of SUT", func_name)
         return
@@ -1146,17 +1323,17 @@ def __analyse_function(
     description = get_function_description(func_ast)
     raised_exceptions = description.raises if description is not None else set()
     cyclomatic_complexity = __get_mccabe_complexity(func_ast)
-    if (
-        getattr(func, "__name__", None) == "<lambda>"
-        and (
-            lambda_assigned_name := _get_lambda_assigned_name(
-                module_tree, func.__code__.co_firstlineno
-            )
-        )
-        is not None
-    ):
-        func_name = lambda_assigned_name
-        func.__name__ = lambda_assigned_name
+    if getattr(func, "__name__", None) == "<lambda>":
+        if lambda_assigned_name := _get_lambda_assigned_name(
+            module_tree, func.__code__.co_firstlineno
+        ):
+            func_name = lambda_assigned_name
+            func.__name__ = lambda_assigned_name
+        else:
+            # If the lambda itself has no name, we must not add it to the test cluster
+            # or else it will cause an exception during test export.
+            return
+
     generic_function = GenericFunction(func, inferred_signature, raised_exceptions, func_name)
 
     if config.configuration.pynguinml.ml_testing_enabled and module_tree is not None:
@@ -1334,7 +1511,7 @@ def __analyse_method(
         return
     if inspect.iscoroutinefunction(method) or inspect.isasyncgenfunction(method):
         if add_to_test:
-            raise ValueError("Pynguin cannot handle Coroutine in SUT. Stopping.")
+            raise CoroutineFoundException("Found coroutine in SUT: %s", method_name)
         # Coroutine outside the SUT are not problematic, just exclude them.
         LOGGER.debug("Skipping coroutine %s outside of SUT", method_name)
         return
@@ -1402,6 +1579,9 @@ def __resolve_dependencies(
     seen_classes: set[Any] = set()
     seen_functions: set[Any] = set()
 
+    # Set of C-extension modules that are not whitelisted
+    dangerous_c_modules: set[str] = set()
+
     # Always analyse builtins
     __analyse_included_classes(
         module=builtins,
@@ -1426,6 +1606,13 @@ def __resolve_dependencies(
             # Don't include anything from the blacklist
             continue
 
+        # Check if the module contains c extensions that are not whitelisted
+        dangerous_c_modules.update(
+            __check_c_modules(
+                module=current_module,
+            )
+        )
+
         # Analyze all classes found in the current module
         __analyse_included_classes(
             module=current_module,
@@ -1458,6 +1645,7 @@ def __resolve_dependencies(
     LOGGER.info("Modules:   %5i", len(seen_modules))
     LOGGER.info("Functions: %5i", len(seen_functions))
     LOGGER.info("Classes:   %5i", len(seen_classes))
+    _handle_c_modules(dangerous_c_modules)
 
     test_cluster.type_system.push_attributes_down()
 
@@ -1555,6 +1743,41 @@ def __analyse_included_functions(
         )
 
 
+def __check_c_modules(
+    *,
+    module: ModuleType,
+) -> set[str]:
+    """Return the names of modules containing non-whitelisted C extensions.
+
+    Args:
+        module: The module to check
+
+    Returns:
+        A set of module names with non-whitelisted C code.
+    """
+    non_whitelisted_modules = set()
+
+    # If the whole module file looks like a binary extension:
+    module_file = getattr(module, "__file__", "")
+    if module_file and Path(module_file).suffix in {".so", ".pyd"}:
+        if not _c_is_whitelisted(module):
+            non_whitelisted_modules.add(module.__name__)
+        return non_whitelisted_modules
+
+    # If the module is Python, inspect its members too:
+    for element in vars(module).values():
+        if inspect.isfunction(element) or inspect.isclass(element):
+            try:
+                inspect.getsource(element)
+                # Source is available => likely pure Python.
+            except Exception:  # noqa: BLE001
+                # No source => likely compiled or builtin.
+                if not _c_is_whitelisted(module):
+                    non_whitelisted_modules.add(module.__name__)
+
+    return non_whitelisted_modules
+
+
 def analyse_module(
     parsed_module: _ModuleParseResult,
     type_inference_strategy: TypeInferenceStrategy = TypeInferenceStrategy.TYPE_HINTS,

{pynguin-0.41.0 → pynguin-0.43.0}/src/pynguin/analyses/seeding.py

@@ -104,8 +104,14 @@ class InitialPopulationProvider:
                 logger.debug("No suitable test module found.")
                 stat.track_output_variable(RuntimeVariable.SuitableTestModule, value=False)
                 return None
-        except BaseException as exception:
-            logger.exception("Cannot read module: %s", exception)
+        except BaseException as exception:  # noqa: BLE001
+            try:
+                logger.exception("Cannot read module: %s", exception)
+            except BaseException:  # noqa: BLE001
+                # Starting with Python 3.11, the exception method tries to parse the file
+                # using the ast.parse function which can fail.
+                logger.error("Cannot read module: %s", exception)
+
             stat.track_output_variable(RuntimeVariable.SuitableTestModule, value=False)
             return None