pynguin 0.46.0__tar.gz → 0.46.0.dev0__tar.gz

{pynguin-0.46.0 → pynguin-0.46.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pynguin
-Version: 0.46.0
+Version: 0.46.0.dev0
 Summary: Pynguin is a tool for automated unit test generation for Python
 License: MIT
 Keywords: unit test,random testing,search based,test generation
@@ -82,7 +82,7 @@ is a tool that allows developers to generate unit tests automatically.
 Testing software is often considered to be a tedious task.
 Thus, automated generation techniques have been proposed and mature tools exist—for
 statically typed languages, such as Java.
-There is, however, no fully automated tool available that produces unit tests for
+There is, however, no fully-automated tool available that produces unit tests for
 general-purpose programs in a dynamically typed language.
 Pynguin is, to the best of our knowledge, the first tool that fills this gap
 and allows the automated generation of unit tests for Python programs.
@@ -129,7 +129,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 (the support for 3.11, 3.12, 3.13, and 3.14 is experimental).
+- You have installed Python 3.10 (the support for 3.11, 3.12, 3.13 and 3.14 is experimental).
 
   **Attention:** Pynguin now requires at least Python 3.10!  Older versions are no longer
   supported!
@@ -190,16 +190,13 @@ Pynguin is developed at the
 [Chair of Software Engineering II](https://www.fim.uni-passau.de/lehrstuhl-fuer-software-engineering-ii/)
 of the [University of Passau](https://www.uni-passau.de).
 
-Maintainer: [Lukas Krodinger](https://github.com/LuKrO2011)
-
-Former Maintainer: [Stephan Lukasczyk](https://codeberg.org/stephanlukasczyk)
+Maintainers: [Stephan Lukasczyk](https://github.com/stephanlukasczyk), [Lukas Krodinger](https://github.com/LuKrO2011)
 
 Contributors:
 - [Lukas Vögl](https://github.com/lvoegl)
 - [Louis Leppelmann](https://github.com/Tudeldu)
 - [Alexander Wüst](https://github.com/Ravaqor)
 - [Altin Hajdari](https://github.com/AltinHajdari)
-- [Ahmed Abidi](https://github.com/AhmedHedi0)
 - [Abdelillah Aissani](https://github.com/Abassion)
 - [Juan Altmayer Pizzorno](https://github.com/jaltmayerpizzorno)
 - [Lucas Berg](https://github.com/BergLucas)
@@ -218,9 +215,9 @@ Contributors:
 
 ### Development using PyCharm.
 
-If you want to use the PyCharm IDE, you have to set up a few things:
+If you want to use the PyCharm IDE you have to set up a few things:
 1. Import `pynguin` into PyCharm.
-2. Let PyCharm configure a virtual environment using `poetry`.
+2. Let PyCharm configure configure a virtual environment using `poetry`.
 3. Set the default test runner to `pytest`
 4. Set the DocString format to `Google`
 
@@ -229,7 +226,7 @@ If you want to use the PyCharm IDE, you have to set up a few things:
 
 This project is licensed under the terms of the [MIT License](LICENSE.rst).
 Pynguin was using the GNU Lesser General Public License (LGPL) until version 0.29.0,
-its license was changed with version 0.30.0.
+its licence was changed with version 0.30.0.
 
 ## Star History
 

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

@@ -18,7 +18,7 @@ is a tool that allows developers to generate unit tests automatically.
 Testing software is often considered to be a tedious task.
 Thus, automated generation techniques have been proposed and mature tools exist—for
 statically typed languages, such as Java.
-There is, however, no fully automated tool available that produces unit tests for
+There is, however, no fully-automated tool available that produces unit tests for
 general-purpose programs in a dynamically typed language.
 Pynguin is, to the best of our knowledge, the first tool that fills this gap
 and allows the automated generation of unit tests for Python programs.
@@ -65,7 +65,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 (the support for 3.11, 3.12, 3.13, and 3.14 is experimental).
+- You have installed Python 3.10 (the support for 3.11, 3.12, 3.13 and 3.14 is experimental).
 
   **Attention:** Pynguin now requires at least Python 3.10!  Older versions are no longer
   supported!
@@ -126,16 +126,13 @@ Pynguin is developed at the
 [Chair of Software Engineering II](https://www.fim.uni-passau.de/lehrstuhl-fuer-software-engineering-ii/)
 of the [University of Passau](https://www.uni-passau.de).
 
-Maintainer: [Lukas Krodinger](https://github.com/LuKrO2011)
-
-Former Maintainer: [Stephan Lukasczyk](https://codeberg.org/stephanlukasczyk)
+Maintainers: [Stephan Lukasczyk](https://github.com/stephanlukasczyk), [Lukas Krodinger](https://github.com/LuKrO2011)
 
 Contributors:
 - [Lukas Vögl](https://github.com/lvoegl)
 - [Louis Leppelmann](https://github.com/Tudeldu)
 - [Alexander Wüst](https://github.com/Ravaqor)
 - [Altin Hajdari](https://github.com/AltinHajdari)
-- [Ahmed Abidi](https://github.com/AhmedHedi0)
 - [Abdelillah Aissani](https://github.com/Abassion)
 - [Juan Altmayer Pizzorno](https://github.com/jaltmayerpizzorno)
 - [Lucas Berg](https://github.com/BergLucas)
@@ -154,9 +151,9 @@ Contributors:
 
 ### Development using PyCharm.
 
-If you want to use the PyCharm IDE, you have to set up a few things:
+If you want to use the PyCharm IDE you have to set up a few things:
 1. Import `pynguin` into PyCharm.
-2. Let PyCharm configure a virtual environment using `poetry`.
+2. Let PyCharm configure configure a virtual environment using `poetry`.
 3. Set the default test runner to `pytest`
 4. Set the DocString format to `Google`
 
@@ -165,7 +162,7 @@ If you want to use the PyCharm IDE, you have to set up a few things:
 
 This project is licensed under the terms of the [MIT License](LICENSE.rst).
 Pynguin was using the GNU Lesser General Public License (LGPL) until version 0.29.0,
-its license was changed with version 0.30.0.
+its licence was changed with version 0.30.0.
 
 ## Star History
 

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

@@ -4,7 +4,7 @@
 
 [tool.poetry]
 name = "pynguin"
-version = "0.46.0"
+version = "0.46.0.dev"
 description = "Pynguin is a tool for automated unit test generation for Python"
 authors = [
   "Stephan Lukasczyk <stephan@pynguin.eu>",

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

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

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

@@ -10,18 +10,80 @@ Generators can be either GenericCallableAccessibleObjects or GenericEnum objects
 
 import functools
 import itertools
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from collections import defaultdict
+from typing import Generic, TypeVar
 
 import pynguin.configuration as config
 from pynguin.analyses.typesystem import AnyType, NoneType, ProperType, TypeSystem, is_primitive_type
-from pynguin.ga.operators.selection import Selectable, SelectionFunction
+from pynguin.utils import randomness
 from pynguin.utils.generic.genericaccessibleobject import (
     GenericAccessibleObject,
     GenericCallableAccessibleObject,
 )
 from pynguin.utils.orderedset import FrozenOrderedSet, OrderedSet
 
+S = TypeVar("S")
+
+
+class Selectable(ABC):
+    """Interface for objects that can be selected based on fitness."""
+
+    @abstractmethod
+    def get_fitness(self) -> float:
+        """Return the fitness value of this selectable object."""
+
+
+class SelectionFunction(ABC, Generic[S]):
+    """Interface for functions that select from a population."""
+
+    @abstractmethod
+    def select(self, population: list[S], number: int = 1) -> list[S]:
+        """Select `number` items from `population`."""
+
+
+class RandomSelection(SelectionFunction[S]):
+    """Selects items uniformly at random."""
+
+    def select(self, population: list[S], number: int = 1) -> list[S]:
+        """Select `number` items from `population`."""
+        return [randomness.RNG.choice(population) for _ in range(number)]
+
+
+class RankSelection(SelectionFunction[S]):
+    """Selects items using linear rank-based probability (lower fitness index = better)."""
+
+    def __init__(self, bias: float = 1.7) -> None:
+        """Initializes the rank selection function.
+
+        Args:
+            bias: The selection bias.
+        """
+        self._bias = bias
+
+    def select(self, population: list[S], number: int = 1) -> list[S]:
+        """Select `number` items from `population`."""
+        n = len(population)
+        if n == 0:
+            return []
+        weights = [
+            max(0.0, (2 - self._bias) + 2 * (self._bias - 1) * (n - 1 - i) / max(n - 1, 1))
+            for i in range(n)
+        ]
+        total = sum(weights)
+        results = []
+        for _ in range(number):
+            r = randomness.RNG.uniform(0, total)
+            cumulative = 0.0
+            selected = population[-1]
+            for i, item in enumerate(population):
+                cumulative += weights[i]
+                if cumulative >= r:
+                    selected = item
+                    break
+            results.append(selected)
+        return results
+
 
 class GeneratorFitnessFunction:
     """Interface for a fitness function for type generators."""

{pynguin-0.46.0 → pynguin-0.46.0.dev0}/src/pynguin/analyses/module.py

@@ -19,7 +19,6 @@ import itertools
 import json
 import logging
 import queue
-import re
 import types
 import typing
 from collections import defaultdict
@@ -54,7 +53,12 @@ from pynguin.utils.llm import LLMProvider
 if config.configuration.pynguinml.ml_testing_enabled or typing.TYPE_CHECKING:
     import pynguin.utils.pynguinml.ml_testing_resources as tr
 
-from pynguin.analyses.generator import GeneratorProvider, RandomGeneratorProvider
+from pynguin.analyses.generator import (
+    GeneratorProvider,
+    RandomGeneratorProvider,
+    RandomSelection,
+    RankSelection,
+)
 from pynguin.analyses.modulecomplexity import mccabe_complexity
 from pynguin.analyses.syntaxtree import (
     FunctionDescription,
@@ -76,12 +80,12 @@ from pynguin.analyses.typesystem import (
     UnionType,
     Unsupported,
 )
-from pynguin.configuration import ElementVisibility, TypeInferenceStrategy
-from pynguin.ga.operators.selection import RandomSelection, RankSelection
+from pynguin.configuration import TypeInferenceStrategy
 from pynguin.utils import randomness
 from pynguin.utils.exceptions import (
     ConstraintValidationError,
     ConstructionFailedException,
+    CoroutineFoundException,
 )
 from pynguin.utils.generic.genericaccessibleobject import (
     GenericAccessibleObject,
@@ -101,9 +105,8 @@ if config.configuration.pynguinml.ml_testing_enabled or typing.TYPE_CHECKING:
 
 if typing.TYPE_CHECKING:
     from collections.abc import Callable, Sequence
+    from typing import Any
 
-    import pynguin.ga.algorithms.archive as arch
-    import pynguin.ga.computations as ff
     from pynguin.instrumentation.tracer import SubjectProperties
     from pynguin.utils.pynguinml.mlparameter import MLParameter
 
@@ -205,27 +208,6 @@ MODULE_BLACKLIST = frozenset((
 METHOD_BLACKLIST = frozenset(("time.sleep",))
 
 
-def _is_function(element: Any) -> bool:
-    """Whether the element is a module-level function we can analyse.
-
-    Besides plain functions this also accepts callables wrapped by
-    ``functools.cache`` / ``functools.lru_cache`` (a
-    ``functools._lru_cache_wrapper``), for which ``inspect.isfunction`` returns
-    ``False``. Without this a cache-decorated public function would be silently
-    dropped from the test cluster.
-
-    Args:
-        element: The element to check
-
-    Returns:
-        Is the element a (possibly cache-wrapped) function?
-    """
-    return inspect.isfunction(element) or (
-        isinstance(element, functools._lru_cache_wrapper)  # noqa: SLF001
-        and inspect.isfunction(inspect.unwrap(element))
-    )
-
-
 def _is_blacklisted(element: Any) -> bool:
     """Checks if the given element belongs to the blacklist.
 
@@ -248,21 +230,19 @@ def _is_blacklisted(element: Any) -> bool:
                 # Allow some builtin types
                 return False
             return element.__module__ in module_blacklist
-        if _is_function(element):
+        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.
-            # Unwrap so cache-wrapped functions are checked against their real name/module.
-            func = inspect.unwrap(element)
             return (
-                func.__module__ is None
-                or func.__module__ in module_blacklist
-                or func.__qualname__.startswith((
+                element.__module__ is None
+                or element.__module__ in module_blacklist
+                or element.__qualname__.startswith((
                     "main",
                     "test",
                 ))
-                or f"{func.__module__}.{func.__qualname__}" in method_blacklist
+                or f"{element.__module__}.{element.__qualname__}" in method_blacklist
             )
     except Exception:  # noqa: BLE001
         LOGGER.warning(
@@ -1170,9 +1150,9 @@ class FilteredModuleTestCluster(TestCluster):  # noqa: PLR0904
     def __init__(  # noqa: D107
         self,
         delegate: ModuleTestCluster,
-        archive: arch.Archive,
+        archive: Any,
         subject_properties: SubjectProperties,
-        targets: OrderedSet[ff.TestCaseFitnessFunction],
+        targets: OrderedSet,
     ) -> None:
         self.__delegate = delegate
         self.__subject_properties = subject_properties
@@ -1204,7 +1184,7 @@ class FilteredModuleTestCluster(TestCluster):  # noqa: PLR0904
         archive.add_on_target_covered(self.on_target_covered)
 
     def __get_accessible_object_for_target(
-        self, target: ff.TestCaseFitnessFunction
+        self, target: Any
     ) -> GenericCallableAccessibleObject | None:
         code_object_id: int | None = target.code_object_id
         while code_object_id is not None:
@@ -1217,7 +1197,7 @@ class FilteredModuleTestCluster(TestCluster):  # noqa: PLR0904
             ].parent_code_object_id
         return None
 
-    def on_target_covered(self, target: ff.TestCaseFitnessFunction) -> None:
+    def on_target_covered(self, target: Any) -> None:
         """A callback function to get informed by an archive when a target is covered.
 
         Args:
@@ -1313,51 +1293,6 @@ def __is_private(method_name: str) -> bool:
     return method_name.startswith("__") and not method_name.endswith("__")
 
 
-__NAME_MANGLED_PATTERN = re.compile(r"^_[A-Za-z][A-Za-z0-9]*__\w+$")
-
-
-def __is_name_mangled(name: str) -> bool:
-    """Checks whether ``name`` looks like a name-mangled private attribute.
-
-    Python mangles a class-private name ``__attr`` defined in class ``Foo`` to
-    ``_Foo__attr``. Since the leading underscores of the class name are
-    stripped during mangling, the mangled name always starts with a single
-    underscore, followed by an identifier not starting with an underscore,
-    followed by a double underscore and the (non-dunder) original name.
-
-    Args:
-        name: The name to check.
-
-    Returns:
-        True, if the name looks like a name-mangled private attribute.
-    """
-    return bool(__NAME_MANGLED_PATTERN.fullmatch(name)) and not name.endswith("__")
-
-
-def __should_skip_by_visibility(name: str, *, add_to_test: bool) -> bool:
-    """Determines whether an element should be skipped based on its visibility.
-
-    Args:
-        name: The (unqualified) name of the element.
-        add_to_test: Whether the element belongs to the module under test.
-
-    Returns:
-        True, if the element should be skipped from analysis.
-    """
-    if not add_to_test:
-        # The relaxed visibility handling only applies to the module under test;
-        # non-public elements of dependency modules are always excluded.
-        return __is_private(name) or __is_protected(name)
-
-    match config.configuration.element_visibility:
-        case ElementVisibility.ALL:
-            return False
-        case ElementVisibility.PROTECTED:
-            return __is_private(name) or __is_name_mangled(name)
-        case _:
-            return __is_private(name) or __is_protected(name)
-
-
 def __is_method_defined_in_class(class_: type | types.UnionType, method: object) -> bool:
     return class_ == get_class_that_defined_method(method)
 
@@ -1425,20 +1360,14 @@ def __analyse_function(
     test_cluster: ModuleTestCluster,
     add_to_test: bool,
 ) -> None:
-    if __should_skip_by_visibility(func_name.rpartition(".")[2], add_to_test=add_to_test):
+    if __is_private(func_name) or __is_protected(func_name):
         LOGGER.debug("Skipping function %s from analysis", func_name)
         return
     if inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction(func):
-        # Pynguin cannot execute coroutines (see issue #62 / MR !59), so we skip
-        # them instead of aborting the whole module and still test its
-        # synchronous members.
         if add_to_test:
-            LOGGER.warning(
-                "Skipping coroutine %s: Pynguin only tests the non-async parts of this module.",
-                func_name,
-            )
-        else:
-            LOGGER.debug("Skipping coroutine %s outside of SUT", func_name)
+            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
 
     LOGGER.debug("Analysing function %s", func_name)
@@ -1631,23 +1560,18 @@ def __analyse_method(
 ) -> None:
     if (
         __is_annotate(method_name)
-        or __should_skip_by_visibility(method_name.rpartition(".")[2], add_to_test=add_to_test)
+        or __is_private(method_name)
+        or __is_protected(method_name)
         or __is_constructor(method_name)
         or not __is_method_defined_in_class(type_info.raw_type, method)
     ):
         LOGGER.debug("Skipping method %s from analysis", method_name)
         return
     if inspect.iscoroutinefunction(method) or inspect.isasyncgenfunction(method):
-        # Pynguin cannot execute coroutines (see issue #62 / MR !59), so we skip
-        # them instead of aborting the whole module and still test its
-        # synchronous members.
         if add_to_test:
-            LOGGER.warning(
-                "Skipping coroutine %s: Pynguin only tests the non-async parts of this module.",
-                method_name,
-            )
-        else:
-            LOGGER.debug("Skipping coroutine %s outside of SUT", method_name)
+            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
 
     LOGGER.debug("Analysing method %s.%s", type_info.full_name, method_name)
@@ -1861,7 +1785,7 @@ def __analyse_included_functions(
     seen_functions: set,
 ) -> None:
     for current in filter(
-        lambda x: _is_function(x) and not _is_blacklisted(x),
+        lambda x: inspect.isfunction(x) and not _is_blacklisted(x),
         vars(module).values(),
     ):
         if current in seen_functions:
@@ -1898,12 +1822,8 @@ def __check_c_modules(
             non_whitelisted_modules.add(module.__name__)
         return non_whitelisted_modules
 
-    # If the module is Python, inspect its members too.
-    # Snapshot the values first: inspecting a member can mutate the module's
-    # globals (e.g. a PEP 562 module-level ``__getattr__`` that lazily caches
-    # results), which would otherwise raise "dictionary changed size during
-    # iteration" while iterating the live ``__dict__``.
-    for element in list(vars(module).values()):
+    # 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)
@@ -2018,48 +1938,33 @@ def _load_typeevalpy_data() -> ParsedTypeEvalPyData | None:
         return None
 
 
-def __collect_module_level_functions(
-    module: ModuleType, add: Callable[[Callable[..., Any]], None]
-) -> None:
+def _collect_public_callables(module: ModuleType) -> Sequence[Callable[..., Any]]:
+    """Collects a list of all public accessibles in a module."""
+    callables = []
+    seen = set()
+
+    def add(obj):
+        if id(obj) not in seen:
+            callables.append(obj)
+            seen.add(id(obj))
+
     for name, obj in vars(module).items():
-        if name != "__init__" and __should_skip_by_visibility(name, add_to_test=True):
+        if name.startswith("_") and name != "__init__":
             continue
         if inspect.isfunction(obj) and obj.__module__ == module.__name__:
             add(obj)
 
-
-def __collect_class_methods(module: ModuleType, add: Callable[[Callable[..., Any]], None]) -> None:
     for cls_name, cls in vars(module).items():
-        if not inspect.isclass(cls) or cls.__module__ != module.__name__:
-            continue
-        # The private-class filter is only applied for PUBLIC visibility; other
-        # visibility levels never filter classes by name (matching the main
-        # analysis, which does not filter classes based on their name).
         if (
-            config.configuration.element_visibility == ElementVisibility.PUBLIC
-            and cls_name.startswith("_")
+            cls_name.startswith("_")
+            or not inspect.isclass(cls)
+            or cls.__module__ != module.__name__
         ):
             continue
         for meth_name, member in inspect.getmembers(cls, predicate=inspect.isfunction):
-            if __is_constructor(meth_name):
-                continue
-            if not __should_skip_by_visibility(meth_name, add_to_test=True):
+            if not meth_name.startswith("_"):
                 add(member)
 
-
-def _collect_public_callables(module: ModuleType) -> Sequence[Callable[..., Any]]:
-    """Collects a list of all public accessibles in a module."""
-    callables: list[Callable[..., Any]] = []
-    seen: set[int] = set()
-
-    def add(obj: Callable[..., Any]) -> None:
-        if id(obj) not in seen:
-            callables.append(obj)
-            seen.add(id(obj))
-
-    __collect_module_level_functions(module, add)
-    __collect_class_methods(module, add)
-
     return callables
 
 

{pynguin-0.46.0 → pynguin-0.46.0.dev0}/src/pynguin/analyses/type_inference.py

@@ -35,16 +35,22 @@ except ImportError:
 
 
 import pynguin.configuration as config
-from pynguin.large_language_model.parsing.type_str_parser import TypeStrParser
-from pynguin.large_language_model.prompts.type_and_subtype_inference_prompt import (
-    TypeAndSubtypeInferencePrompt,
-    get_type_and_subtype_inference_system_prompt,
-)
-from pynguin.large_language_model.prompts.typeinferenceprompt import (
-    TypeInferencePrompt,
-    get_inference_system_prompt,
-)
 from pynguin.utils.llm import LLMProvider
+
+try:
+    from pynguin.large_language_model.parsing.type_str_parser import TypeStrParser
+    from pynguin.large_language_model.prompts.type_and_subtype_inference_prompt import (
+        TypeAndSubtypeInferencePrompt,
+        get_type_and_subtype_inference_system_prompt,
+    )
+    from pynguin.large_language_model.prompts.typeinferenceprompt import (
+        TypeInferencePrompt,
+        get_inference_system_prompt,
+    )
+
+    _LLM_PROMPTS_AVAILABLE = True
+except ImportError:
+    _LLM_PROMPTS_AVAILABLE = False
 from pynguin.utils.orderedset import OrderedSet
 
 if typing.TYPE_CHECKING:
@@ -110,6 +116,8 @@ class LLMInference(InferenceProvider):
         ])
         match provider:
             case LLMProvider.OPENAI:
+                if not _LLM_PROMPTS_AVAILABLE:
+                    raise RuntimeError("LLM prompts not available. install 'openai' extra.")
                 self._model = OpenAI(
                     api_key=SecretStr(config.configuration.large_language_model.api_key),
                     system_prompt=get_inference_system_prompt(),
@@ -174,6 +182,9 @@ class LLMInference(InferenceProvider):
     def _build_prompt_map(
         self, funcs: Sequence[Callable[..., Any]]
     ) -> OrderedDict[Callable[..., Any], str]:
+        if not _LLM_PROMPTS_AVAILABLE:
+            _LOGGER.error("LLM prompts not available. Skipping prompt building.")
+            return OrderedDict()
         prompts: OrderedDict[Callable[..., Any], str] = OrderedDict()
         for func in funcs:
             try:
@@ -363,6 +374,8 @@ class LLMInferenceWithSubtypes(LLMInference):
         ])
         match provider:
             case LLMProvider.OPENAI:
+                if not _LLM_PROMPTS_AVAILABLE:
+                    raise RuntimeError("LLM prompts not available. install 'openai' extra.")
                 self._model = OpenAI(
                     api_key=SecretStr(config.configuration.large_language_model.api_key),
                     system_prompt=get_type_and_subtype_inference_system_prompt(),

pynguin-0.46.0.dev0/src/pynguin/analysis/__init__.py

@@ -0,0 +1,26 @@
+#  This file is part of Pynguin.
+#
+#  SPDX-FileCopyrightText: 2019–2026 Pynguin Contributors
+#
+#  SPDX-License-Identifier: MIT
+"""Public API for the pynguin module analysis subsystem."""
+
+from pynguin.analysis.models import (
+    AttributeInfo,
+    ClassInfo,
+    FunctionInfo,
+    ImportInfo,
+    ModuleInfo,
+    ParameterInfo,
+)
+from pynguin.analysis.module_analyzer import ModuleAnalyzer
+
+__all__ = [
+    "AttributeInfo",
+    "ClassInfo",
+    "FunctionInfo",
+    "ImportInfo",
+    "ModuleAnalyzer",
+    "ModuleInfo",
+    "ParameterInfo",
+]