pynguin 0.46.0__tar.gz → 0.47.0__tar.gz

{pynguin-0.46.0 → pynguin-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pynguin
-Version: 0.46.0
+Version: 0.47.0
 Summary: Pynguin is a tool for automated unit test generation for Python
 License: MIT
 Keywords: unit test,random testing,search based,test generation
@@ -33,8 +33,6 @@ Provides-Extra: openai
 Provides-Extra: typing
 Requires-Dist: Jinja2 (>=3.1.6,<4.0.0)
 Requires-Dist: Pygments (>=2.19.2,<3.0.0)
-Requires-Dist: asciitree (>=0.3.3,<0.4.0)
-Requires-Dist: astroid (>=4.0.1,<5.0.0)
 Requires-Dist: black (>=25.1.0,<26.0.0)
 Requires-Dist: bytecode (==0.17.0)
 Requires-Dist: dill (>=0.4.0,<0.5.0)
@@ -49,14 +47,14 @@ Requires-Dist: openai (>=1.72.0,<2.0.0) ; extra == "openai"
 Requires-Dist: psutil (>=7.1.1,<8.0.0)
 Requires-Dist: pytest (>=8.3.5,<9.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0) ; extra == "openai"
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0) ; extra == "openai"
 Requires-Dist: rich (>=14.0.0,<15.0.0)
 Requires-Dist: rstr (>=3.2.2,<4.0.0)
 Requires-Dist: setuptools (>=80.9.0,<81.0.0)
 Requires-Dist: simple-parsing (>=0.1.7,<0.2.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: typeshed-client (>=2.13.0,<3.0.0)
 Requires-Dist: typing-extensions (>=4.12.2,<5.0.0) ; extra == "typing"
-Requires-Dist: typing_inspect (>=0.9.0,<0.10.0)
-Requires-Dist: xmltodict (>=0.14.2,<0.15.0) ; extra == "fandango-faker"
 Project-URL: Documentation, https://pynguin.readthedocs.io
 Project-URL: Homepage, https://www.pynguin.eu
 Project-URL: Repository, https://github.com/se2p/pynguin
@@ -233,5 +231,5 @@ its license was changed with version 0.30.0.
 
 ## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=se2p/pynguin&type=Date)](https://star-history.com/#se2p/pynguin)
+[![Star History Chart](https://star-history.dera.page/svg?repos=se2p/pynguin&type=Date)](https://star-history.dera.page/#se2p/pynguin)
 

{pynguin-0.46.0 → pynguin-0.47.0}/README.md

@@ -169,4 +169,4 @@ its license was changed with version 0.30.0.
 
 ## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=se2p/pynguin&type=Date)](https://star-history.com/#se2p/pynguin)
+[![Star History Chart](https://star-history.dera.page/svg?repos=se2p/pynguin&type=Date)](https://star-history.dera.page/#se2p/pynguin)

{pynguin-0.46.0 → pynguin-0.47.0}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [tool.poetry]
 name = "pynguin"
-version = "0.46.0"
+version = "0.47.0"
 description = "Pynguin is a tool for automated unit test generation for Python"
 authors = [
   "Stephan Lukasczyk <stephan@pynguin.eu>",
@@ -51,7 +51,6 @@ include = [
 
 [tool.poetry.dependencies]
 python = ">=3.10, <3.15"
-astroid = "^4.0.1"
 black = "^25.1.0"
 bytecode = "0.17.0"
 dill = "^0.4.0"
@@ -62,21 +61,20 @@ rich = "^14.0.0"
 Pygments = "^2.19.2"
 pytest = "^8.3.5"
 simple-parsing = "^0.1.7"
-typing_inspect = "^0.9.0"
-asciitree = "^0.3.3"
 libcst = "^1.7.0"
 setuptools = "^80.9.0"
 toml = "^0.10.2"
 psutil = "^7.1.1"
 rstr = "^3.2.2"
 openai = { version = "^1.72.0", optional = true }
+pyyaml = { version = "^6.0.2", optional = true }
 python-dotenv = { version = "^1.0.0", optional = true }
 numpy = { version = "^1.26.4", optional = true }
 mypy = { version = "^1.15.0", optional = true }
 typing-extensions = { version = "^4.12.2", optional = true }
 faker = { version = "^37.3.0", optional = true }
 fandango-fuzzer = { version = "^0.8.2", optional = true }
-xmltodict = { version = "^0.14.2", optional = true }
+typeshed-client = "^2.13.0"
 
 [tool.poetry.group.dev.dependencies]
 mypy = "^1.15.0"
@@ -102,10 +100,10 @@ pytest-sugar = "^1.0.0"
 pytest-xdist = "^3.6.0"
 
 [tool.poetry.extras]
-openai = [ "openai", "python-dotenv" ]
+openai = [ "openai", "python-dotenv", "pyyaml" ]
 numpy = [ "numpy" ]
 typing = [ "mypy", "typing-extensions" ]
-fandango-faker = [ "faker", "fandango-fuzzer", "xmltodict" ]
+fandango-faker = [ "faker", "fandango-fuzzer" ]
 
 [tool.poetry.scripts]
 pynguin = "pynguin.cli:main"
@@ -149,6 +147,24 @@ warn_unused_ignores = true
 warn_redundant_casts = true
 warn_unused_configs = true
 
+# The following modules belong to subsystems that were disabled (kept on disk but
+# inert) during the libcst test-case representation migration. They still use the
+# old per-statement representation API and are excluded from type checking until
+# they are migrated. See TC_REPRESENTATION_PLAN.md.
+[[tool.mypy.overrides]]
+module = [
+  "pynguin.testcase.localsearch",
+  "pynguin.testcase.localsearchstatement",
+  "pynguin.testcase.llmlocalsearch",
+  "pynguin.analyses.seeding",
+  "pynguin.slicer.statementslicingobserver",
+  "pynguin.assertion.llmassertiongenerator",
+  "pynguin.large_language_model.parsing.deserializer",
+  "pynguin.large_language_model.parsing.helpers",
+  "pynguin.large_language_model.helpers.testcasereferencecopier",
+]
+ignore_errors = true
+
 [tool.pytest.ini_options]
 testpaths = [
   "tests",
@@ -267,6 +283,11 @@ max-complexity = 10
 convention = "google"
 
 [tool.ruff.lint.per-file-ignores]
+# The exported test-suite license header embeds the repo's SPDX copyright text,
+# which uses an EN DASH in the year range (2019–2026).
+"src/pynguin/testcase/export.py" = [
+  "RUF001", # String contains ambiguous EN DASH (part of the SPDX license header)
+]
 "tests/**/*.py" = [
   "D100", # Missing docstring in public module
   "D101", # Missing docstring in public class

{pynguin-0.46.0 → pynguin-0.47.0}/src/pynguin/__version__.py

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

pynguin-0.47.0/src/pynguin/analyses/ast_utils.py

@@ -0,0 +1,171 @@
+#  This file is part of Pynguin.
+#
+#  SPDX-FileCopyrightText: 2019–2026 Pynguin Contributors
+#
+#  SPDX-License-Identifier: MIT
+#
+
+"""Utility functions for standard library ast nodes."""
+
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING, TypeVar, cast
+
+_T = TypeVar("_T", bound=ast.AST)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+def _is_dataclass(class_node: ast.ClassDef) -> bool:
+    """Whether the class carries a ``@dataclass`` decorator.
+
+    Recognises ``@dataclass``, ``@dataclasses.dataclass`` and their called
+    forms (e.g. ``@dataclass(frozen=True)``).
+    """
+    for decorator in class_node.decorator_list:
+        target = decorator.func if isinstance(decorator, ast.Call) else decorator
+        if isinstance(target, ast.Name) and target.id == "dataclass":
+            return True
+        if isinstance(target, ast.Attribute) and target.attr == "dataclass":
+            return True
+    return False
+
+
+def _is_class_var(annotation: ast.expr) -> bool:
+    """Whether an annotation is ``ClassVar`` / ``ClassVar[...]`` (any import form)."""
+    if isinstance(annotation, ast.Subscript):
+        annotation = annotation.value
+    if isinstance(annotation, ast.Name):
+        return annotation.id == "ClassVar"
+    if isinstance(annotation, ast.Attribute):
+        return annotation.attr == "ClassVar"
+    return False
+
+
+def _flatten_target(target: ast.expr) -> list[ast.expr]:
+    """Flatten tuple/list assignment targets into their leaf expressions."""
+    if isinstance(target, (ast.Tuple, ast.List)):
+        leaves: list[ast.expr] = []
+        for element in target.elts:
+            leaves.extend(_flatten_target(element))
+        return leaves
+    return [target]
+
+
+def _self_assigned_names(class_node: ast.ClassDef) -> Iterator[str]:
+    """Yield names assigned to ``self.<attr>`` in the class's own methods."""
+    for item in class_node.body:
+        if not isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        for node in ast.walk(item):
+            targets: list[ast.expr] = []
+            if isinstance(node, ast.Assign):
+                targets = list(node.targets)
+            elif isinstance(node, (ast.AnnAssign, ast.AugAssign)):
+                targets = [node.target]
+            for target in (leaf for tgt in targets for leaf in _flatten_target(tgt)):
+                if (
+                    isinstance(target, ast.Attribute)
+                    and isinstance(target.value, ast.Name)
+                    and target.value.id == "self"
+                ):
+                    yield target.attr
+
+
+def _dataclass_field_names(class_node: ast.ClassDef) -> Iterator[str]:
+    """Yield annotated ``@dataclass`` field names (excluding ``ClassVar`` fields)."""
+    if not _is_dataclass(class_node):
+        return
+    for item in class_node.body:
+        if (
+            isinstance(item, ast.AnnAssign)
+            and isinstance(item.target, ast.Name)
+            and not _is_class_var(item.annotation)
+        ):
+            yield item.target.id
+
+
+def instance_attributes(class_node: ast.ClassDef) -> tuple[str, ...]:
+    """Names assigned to ``self.<attr>`` in the class's own methods.
+
+    Mirrors ``astroid.ClassDef.instance_attrs`` (own class only, not inherited),
+    preserving first-seen order. For ``@dataclass`` classes the class-level
+    annotated fields are included as well (excluding ``ClassVar`` fields), since
+    astroid's dataclass support synthesises the corresponding ``__init__``
+    assignments.
+
+    Args:
+        class_node: The ClassDef AST node.
+
+    Returns:
+        A tuple of instance attribute names.
+    """
+    names: dict[str, None] = {}
+    for name in (*_dataclass_field_names(class_node), *_self_assigned_names(class_node)):
+        names.setdefault(name, None)
+    return tuple(names)
+
+
+def nodes_of_class(tree: ast.AST, types: type[_T] | tuple[type[_T], ...]) -> Iterator[_T]:
+    """Yield all nodes (recursively, preorder DFS) that are instances of ``types``.
+
+    Args:
+        tree: The AST tree root.
+        types: Type or tuple of types to match.
+
+    Yields:
+        Nodes matching types.
+    """
+    stack = [tree]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, types):
+            yield cast("_T", node)
+        # Push children in reverse order to visit them left-to-right
+        stack.extend(reversed(list(ast.iter_child_nodes(node))))
+
+
+def scope_line_range(node: ast.AST) -> tuple[int, int]:
+    """Uniformly retrieve (lineno, end_lineno) for a node.
+
+    Args:
+        node: The AST node.
+
+    Returns:
+        A tuple of start and end line numbers.
+    """
+    if isinstance(node, ast.Module):
+        # A module's line number is 0 in the AST (matching astroid's
+        # ``Module.fromlineno`` and the ``<module>`` code object convention used
+        # by the instrumentation transformer), even though its body starts at 1.
+        if node.body:
+            return 0, node.body[-1].end_lineno or 0
+        return 0, 0
+    if isinstance(node, ast.match_case):
+        start = node.pattern.lineno
+        end = node.body[-1].end_lineno or start
+        return start, end
+    start = getattr(node, "lineno", 1)
+    end = getattr(node, "end_lineno", start) or start
+    return start, end
+
+
+def scope_name(node: ast.AST) -> str:
+    """Retrieve name of a ScopeNode, matching astroid behavior.
+
+    Args:
+        node: The AST node representing the scope.
+
+    Returns:
+        The name of the scope.
+    """
+    if isinstance(node, ast.Module):
+        return ""
+    if isinstance(node, ast.Lambda):
+        return "<lambda>"
+    if isinstance(node, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
+        lineno = getattr(node, "lineno", 1)
+        return f"<generator-{lineno}>"
+    return getattr(node, "name", "")

{pynguin-0.46.0 → pynguin-0.47.0}/src/pynguin/analyses/constants.py

@@ -140,6 +140,22 @@ class ConstantProvider(abc.ABC):
             A constant or None, if there is no constant  # noqa: DAR202
         """
 
+    def get_all_constants_for(self, tp_: type[T]) -> OrderedSet[T]:
+        """Provide every constant value of the given type this provider knows.
+
+        Unlike :meth:`get_constant_for`, this ignores any per-provider selection
+        probability; it reports the full vocabulary reachable through this
+        provider.  Used by generation strategies that need to inspect the pool
+        itself, e.g. to pick a plausible separator between seeded tokens.
+
+        Args:
+            tp_: The type to retrieve
+
+        Returns:
+            All constants of the given type; empty when there are none.
+        """
+        return OrderedSet()
+
 
 class EmptyConstantProvider(ConstantProvider):
     """Empty provider."""
@@ -169,6 +185,14 @@ class DelegatingConstantProvider(ConstantProvider, ABC):
             return self._pool.get_constant_for(tp_)
         return self._delegate.get_constant_for(tp_)
 
+    def get_all_constants_for(self, tp_: type[T]) -> OrderedSet[T]:  # noqa: D102
+        delegated = self._delegate.get_all_constants_for(tp_)
+        if not delegated:
+            return self._pool.get_all_constants_for(tp_)
+        constants: OrderedSet[T] = OrderedSet(self._pool.get_all_constants_for(tp_))
+        constants.update(delegated)
+        return constants
+
 
 class DynamicConstantProvider(DelegatingConstantProvider):
     """Provide values collected during runtime."""
@@ -298,8 +322,16 @@ def collect_static_constants(
                     exception,
                 )
 
-    # Check all modules discovered via packages
+    # Scope discovery to the top-level package(s) of the module(s) under test, so a
+    # project_path broader than the SUT (shared site-packages, monorepo, vendored deps)
+    # does not drown the SUT's constants in those of unrelated packages. With no module
+    # names known, fall back to all packages.
+    top_level_packages = {name.split(".")[0] for name in (module_names or ())}
+
+    # Check modules discovered via packages, scoped to the project when known
     for module in _find_modules_with_constants(project_path):
+        if top_level_packages and module.split("/")[0] not in top_level_packages:
+            continue
         _parse_file(path / module)
 
     # Check all modules explicitly specified

{pynguin-0.46.0 → pynguin-0.47.0}/src/pynguin/analyses/generator.py

@@ -14,7 +14,14 @@ from abc import abstractmethod
 from collections import defaultdict
 
 import pynguin.configuration as config
-from pynguin.analyses.typesystem import AnyType, NoneType, ProperType, TypeSystem, is_primitive_type
+from pynguin.analyses.typesystem import (
+    AnyType,
+    NoneType,
+    ProperType,
+    TupleType,
+    TypeSystem,
+    is_primitive_type,
+)
 from pynguin.ga.operators.selection import Selectable, SelectionFunction
 from pynguin.utils.generic.genericaccessibleobject import (
     GenericAccessibleObject,
@@ -157,7 +164,18 @@ class HeuristicGeneratorFitnessFunction(GeneratorFitnessFunction):
         """
         return_type = generator.inferred_signature.return_type
         assert return_type is not None, "Return type must not be None for a type generator"
-        return self._type_system.subtype_distance(to_generate, return_type)
+        dist = self._type_system.subtype_distance(to_generate, return_type)
+        if dist is not None:
+            return dist
+        if isinstance(return_type, TupleType) and not return_type.unknown_size:
+            min_dist: int | None = None
+            for elem_type in return_type.args:
+                d = self._type_system.subtype_distance(to_generate, elem_type)
+                if d is not None and (min_dist is None or d < min_dist):
+                    min_dist = d
+            if min_dist is not None:
+                return min_dist + 1
+        return None
 
     def is_maximisation_function(self) -> bool:  # noqa: D102
         return False
@@ -260,6 +278,23 @@ class GeneratorProvider:
         if isinstance(generated_type, NoneType) or generated_type.accept(is_primitive_type):
             return
         self._generators[generated_type].add(generator)
+        if isinstance(generated_type, TupleType) and not generated_type.unknown_size:
+            for elem_type in generated_type.args:
+                if isinstance(elem_type, NoneType) or elem_type.accept(is_primitive_type):
+                    continue
+                self._generators[elem_type].add(generator)
+
+    def remove_generator(self, generator: GenericAccessibleObject) -> None:
+        """Remove a generator from all types it generates.
+
+        Args:
+            generator: The generator to remove.
+        """
+        for typ in list(self._generators.keys()):
+            gens = self._generators[typ]
+            gens.discard(generator)
+            if not gens:
+                del self._generators[typ]
 
     def get_all(self) -> dict[ProperType, OrderedSet[GenericAccessibleObject]]:
         """Get all generators."""
@@ -280,13 +315,18 @@ class GeneratorProvider:
         """
         return self._generators.get(proper_type, OrderedSet())
 
-    def remove_all_generators_for(self, proper_type: ProperType) -> None:
-        """Remove all generators for a specific type.
+    def get_generators_for(self, typ: ProperType) -> OrderedSet[GenericAccessibleObject]:
+        """Get all generators for a specific type including compatible subtypes.
 
         Args:
-            proper_type: The type to remove the generators for.
+            typ: The type to get the generators for.
+
+        Returns:
+            The generators for the given type.
         """
-        del self._generators[proper_type]
+        type_generators = self._get_generators_for(typ)
+        sorted_generators = self._sorted_generators(type_generators.freeze())
+        return OrderedSet(gen.generator for gen in sorted_generators)
 
     def add_for_type(
         self, proper_type: ProperType, generator: GenericCallableAccessibleObject
@@ -297,7 +337,14 @@ class GeneratorProvider:
             proper_type: The type to add the generators for.
             generator: The generator to add.
         """
+        if isinstance(proper_type, NoneType) or proper_type.accept(is_primitive_type):
+            return
         self._generators[proper_type].add(generator)
+        if isinstance(proper_type, TupleType) and not proper_type.unknown_size:
+            for elem_type in proper_type.args:
+                if isinstance(elem_type, NoneType) or elem_type.accept(is_primitive_type):
+                    continue
+                self._generators[elem_type].add(generator)
 
     @functools.lru_cache(maxsize=1024)
     def _sorted_generators(
@@ -337,11 +384,17 @@ class GeneratorProvider:
             return OrderedSet()
 
         generators: OrderedSet[_Generator] = OrderedSet()
+        any_generators: OrderedSet[_Generator] = OrderedSet()
         for generated_typ in self.get_all_types():
             if (distance := self._type_system.subtype_distance(typ, generated_typ)) is not None:
-                generators.update(self._get_for_type(generated_typ, distance))
+                if isinstance(generated_typ, AnyType):
+                    any_generators.update(self._get_for_type(generated_typ, distance))
+                else:
+                    generators.update(self._get_for_type(generated_typ, distance))
 
-        return generators
+        if generators:
+            return generators
+        return any_generators
 
     @functools.lru_cache(maxsize=1024)
     def _get_for_type(self, typ: ProperType, distance: int) -> OrderedSet[_Generator]:
@@ -396,13 +449,21 @@ class RandomGeneratorProvider(GeneratorProvider):
             # Just take everything when it's Any.
             return self._get_all_generators(typ)
 
+        if typ.accept(is_primitive_type):
+            return OrderedSet()
+
         results: OrderedSet[GenericAccessibleObject] = OrderedSet()
+        any_results: OrderedSet[GenericAccessibleObject] = OrderedSet()
         for gen_type, generators in self.get_all().items():
             if self._type_system.is_maybe_subtype(gen_type, typ):
-                results.update(generators)
+                if isinstance(gen_type, AnyType):
+                    any_results.update(generators)
+                else:
+                    results.update(generators)
 
+        matching = results or any_results
         return OrderedSet(
-            _Generator(generator, typ, self._fitness_function) for generator in results
+            _Generator(generator, typ, self._fitness_function) for generator in matching
         )
 
     @functools.lru_cache(maxsize=0)  # Required to avoid mypy error