open-aea 2.2.6__tar.gz → 2.2.7__tar.gz

{open_aea-2.2.6 → open_aea-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-aea
-Version: 2.2.6
+Version: 2.2.7
 Summary: Open AEA Framework
 License: Apache-2.0
 License-File: AUTHORS.md

{open_aea-2.2.6 → open_aea-2.2.7}/aea/__version__.py

@@ -23,7 +23,7 @@
 __title__ = "open-aea"
 __description__ = "Open Autonomous Economic Agent framework (without vendor lock-in)"
 __url__ = "https://github.com/valory-xyz/open-aea.git"
-__version__ = "2.2.6"
+__version__ = "2.2.7"
 __author__ = "Valory AG"
 __license__ = "Apache-2.0"
 __copyright__ = "2021 Valory AG, 2019 Fetch.AI Limited"

{open_aea-2.2.6 → open_aea-2.2.7}/aea/cli/generate_all_protocols.py

@@ -66,7 +66,6 @@ LIBPROTOC_VERSION = "libprotoc 24.3"
 CUSTOM_TYPE_MODULE_NAME = "custom_types.py"
 PROTOCOL_GENERATOR_DOCSTRING_REGEX = "It was created with protocol buffer compiler version `libprotoc .*` and aea protocol generator version `.*`."
 
-logging.basicConfig(format="[%(asctime)s][%(levelname)s] %(message)s")
 logger = logging.getLogger("generate_all_protocols")
 logger.setLevel(logging.INFO)
 
@@ -460,6 +459,7 @@ def generate_all_protocols(
     check_clean: bool,
 ) -> None:
     """Generate all protocols."""
+    logging.basicConfig(format="[%(asctime)s][%(levelname)s] %(message)s")
 
     _check_preliminaries()
 

{open_aea-2.2.6 → open_aea-2.2.7}/aea/cli/scaffold.py

@@ -244,6 +244,9 @@ def scaffold_item(ctx: Context, item_type: str, item_name: str) -> None:
         )
 
     ctx.clean_paths.append(str(dest))
+    # Save ctx.cwd so the local-registry path swap below does not leak out
+    # of this call.
+    preserve_cwd = ctx.cwd
     try:
         # copy the item package into the agent project.
         src = Path(os.path.join(AEA_DIR, item_type_plural, "scaffold"))
@@ -283,6 +286,12 @@ def scaffold_item(ctx: Context, item_type: str, item_name: str) -> None:
         if to_local_registry:
             ctx.cwd = str(registry_path / author_name)
             fingerprint_item(ctx, item_type, new_public_id)
+            # Restore now (not just in the `finally` below) so the
+            # `--with-symlinks` calls to `create_symlink_vendor_to_local` /
+            # `create_symlink_packages_to_vendor` further down — both of
+            # which read `ctx.cwd` — see the original agent directory
+            # instead of the registry author path.
+            ctx.cwd = preserve_cwd
         else:
             fingerprint_item(ctx, item_type, new_public_id)
 
@@ -314,6 +323,8 @@ def scaffold_item(ctx: Context, item_type: str, item_name: str) -> None:
         )
     except Exception as e:
         raise click.ClickException(str(e))
+    finally:
+        ctx.cwd = preserve_cwd
 
 
 def _scaffold_dm_handler(ctx: Context) -> None:

{open_aea-2.2.6 → open_aea-2.2.7}/aea/configurations/loader.py

@@ -29,6 +29,7 @@ from typing import (
     List,
     Optional,
     TextIO,
+    Tuple,
     Type,
     TypeVar,
     Union,
@@ -320,11 +321,7 @@ class ConfigLoader(Generic[T], BaseConfigLoader):
 
     def _load_service_config(self, file_pointer: TextIO) -> PackageConfiguration:
         """Load a service configuration."""
-        configuration_data = yaml_load_all(file_pointer)
-        if not configuration_data:
-            raise ValueError("Service configuration file was empty.")
-
-        service_config, *overrides = configuration_data
+        service_config, overrides = parse_service_yaml(file_pointer)
         self.validate(service_config)
         key_order = list(service_config.keys())
         service = self.configuration_class.from_json(service_config)
@@ -384,6 +381,44 @@ class ConfigLoader(Generic[T], BaseConfigLoader):
         return component_id
 
 
+def parse_service_yaml(
+    file_pointer: TextIO,
+) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+    """
+    Parse a service configuration YAML stream into its raw documents.
+
+    Returns the head service configuration document and any override
+    documents without applying schema validation or constructing a
+    typed configuration object. Callers that need to apply additional
+    transformations (e.g. environment variable substitution) before
+    validation can use this helper as the parse step.
+
+    :param file_pointer: an open text stream pointing at a service.yaml.
+    :return: a ``(service_config, overrides)`` tuple where ``service_config``
+        is the head document and ``overrides`` is the list of trailing
+        documents.
+    :raises ValueError: if the stream is empty, or if the head document is
+        not a YAML mapping (e.g. a bare ``---``, a scalar, or a sequence).
+    :raises yaml.YAMLError: if the stream contains malformed YAML and the underlying parser fails (propagated as-is so callers can handle parse errors and shape errors distinctly).  # noqa: DAR402
+    """
+    configuration_data = yaml_load_all(file_pointer)
+    if not configuration_data:
+        raise ValueError("Service configuration file was empty.")
+    service_config, *overrides = configuration_data
+    # The head document must be a mapping. `yaml_load_all` happily returns
+    # `[None]` / `[False]` / `[0]` / `[""]` / `[[]]` for malformed YAML
+    # (bare `---`, a scalar, a sequence, etc.) — surface those at parse
+    # time rather than as opaque AttributeErrors from the downstream
+    # validator. Distinct from the empty-stream message so an operator
+    # reading the traceback can tell the two cases apart.
+    if not isinstance(service_config, dict):
+        raise ValueError(
+            "Service configuration head document must be a YAML mapping, "
+            f"got {type(service_config).__name__}."
+        )
+    return service_config, overrides
+
+
 class ConfigLoaders:
     """Configuration Loader class to load any package type."""
 

{open_aea-2.2.6 → open_aea-2.2.7}/aea/configurations/utils.py

@@ -34,9 +34,34 @@ from aea.configurations.base import (
     PublicId,
     SkillConfig,
 )
+from aea.configurations.constants import PACKAGES
 from aea.configurations.data_types import PackageIdPrefix
 
 
+def package_dotted_path(
+    author: str,
+    package_type_plural: str,
+    package_name: str,
+    file_stem: str,
+) -> str:
+    """
+    Compose the canonical dotted path string for a file inside an AEA package.
+
+    Returns a string of the form ``packages.<author>.<plural>.<name>.<stem>``.
+    Has no side effects; the loaded module is registered in
+    ``sys.modules`` by ``aea.helpers.base.load_module``.
+
+    :param author: package author (e.g. ``"valory"``).
+    :param package_type_plural: plural package-type token (``"skills"`` /
+        ``"contracts"`` / ``"connections"`` / ``"protocols"``).
+    :param package_name: the package's local name.
+    :param file_stem: source file stem without the ``.py`` suffix
+        (``"contract"`` / ``"connection"`` / ``"behaviours"`` / ...).
+    :return: the composed packages-prefixed dotted path string.
+    """
+    return f"{PACKAGES}.{author}.{package_type_plural}.{package_name}.{file_stem}"
+
+
 @singledispatch
 def replace_component_ids(
     _arg: PackageConfiguration,

{open_aea-2.2.6 → open_aea-2.2.7}/aea/connections/base.py

@@ -30,8 +30,10 @@ from typing import Any, Callable, Generator, Optional, Set, TYPE_CHECKING, cast
 
 from aea.components.base import Component, load_aea_package
 from aea.configurations.base import ComponentType, ConnectionConfig
+from aea.configurations.constants import CONNECTIONS
 from aea.configurations.data_types import PublicId
 from aea.configurations.loader import load_component_configuration
+from aea.configurations.utils import package_dotted_path
 from aea.crypto.wallet import CryptoStore
 from aea.exceptions import (
     AEAComponentLoadException,
@@ -284,9 +286,13 @@ class Connection(Component, ABC):
                 "Connection module '{}' not found.".format(connection_module_path)
             )
         load_aea_package(configuration)
-        connection_module = load_module(
-            "connection_module", directory / "connection.py"
+        dotted_path = package_dotted_path(
+            configuration.public_id.author,
+            CONNECTIONS,
+            configuration.public_id.name,
+            "connection",
         )
+        connection_module = load_module(dotted_path, directory / "connection.py")
         classes = inspect.getmembers(connection_module, inspect.isclass)
         connection_class_name = cast(str, configuration.class_name)
         connection_classes = list(

{open_aea-2.2.6 → open_aea-2.2.7}/aea/contracts/base.py

@@ -30,6 +30,7 @@ from aea.components.base import Component, load_aea_package
 from aea.configurations.base import ComponentType, ContractConfig, PublicId
 from aea.configurations.constants import CONTRACTS
 from aea.configurations.loader import load_component_configuration
+from aea.configurations.utils import package_dotted_path
 from aea.crypto.base import LedgerApi
 from aea.crypto.registries import Registry, ledger_apis_registry, make_ledger_api_cls
 from aea.exceptions import AEAComponentLoadException, AEAException
@@ -123,7 +124,13 @@ class Contract(Component):
             raise ValueError("Configuration must be associated with a directory.")
         directory = configuration.directory
         load_aea_package(configuration)
-        contract_module = load_module(CONTRACTS, directory / "contract.py")
+        dotted_path = package_dotted_path(
+            configuration.public_id.author,
+            CONTRACTS,
+            configuration.public_id.name,
+            "contract",
+        )
+        contract_module = load_module(dotted_path, directory / "contract.py")
         classes = inspect.getmembers(contract_module, inspect.isclass)
         contract_class_name = cast(str, configuration.class_name)
         contract_classes = list(filter(lambda x: x[0] == contract_class_name, classes))

{open_aea-2.2.6 → open_aea-2.2.7}/aea/helpers/base.py

@@ -127,9 +127,37 @@ def load_module(dotted_path: str, filepath: Path) -> types.ModuleType:
     :raises ValueError: if the filepath provided is not a module.  # noqa: DAR402
     :raises Exception: if the execution of the module raises exception.  # noqa: DAR402
     """
+    # If the dotted path is already in ``sys.modules``, reuse it instead
+    # of re-executing the file. Re-execution creates a duplicate copy of
+    # every class defined in the source, breaking class identity for
+    # callers that already hold a reference (e.g. via an earlier
+    # ``from ... import X``). ``__file__`` is intentionally NOT compared
+    # — in test fixtures the same logical package may be reached
+    # through different physical files (vendor copy in a tmpdir vs the
+    # source tree) but both register the same dotted path and must
+    # resolve to the same module object across the whole process. An
+    # explicit ``None`` entry is CPython's block-import sentinel: raise
+    # ``ImportError`` to match the standard import semantics rather
+    # than silently overwriting it with a fresh exec.
+    if dotted_path in sys.modules:
+        existing = sys.modules[dotted_path]
+        if existing is None:
+            raise ImportError(f"import of {dotted_path!r} halted; None in sys.modules")
+        return existing
     spec = importlib.util.spec_from_file_location(dotted_path, str(filepath))
     module = importlib.util.module_from_spec(cast(ModuleSpec, spec))
-    spec.loader.exec_module(module)  # type: ignore
+    # Register before exec so a downstream `import` of the same dotted
+    # path during exec resolves to this module. We only reach this point
+    # when the key was absent (the cache-hit and block-import branches
+    # above covered the other two cases), so on exec failure we pop the
+    # half-built stub rather than restoring a prior entry that, by
+    # construction, did not exist.
+    sys.modules[dotted_path] = module
+    try:
+        spec.loader.exec_module(module)  # type: ignore
+    except BaseException:  # pylint: disable=broad-except
+        sys.modules.pop(dotted_path, None)
+        raise
     return module
 
 

{open_aea-2.2.6 → open_aea-2.2.7}/aea/helpers/env_vars.py

@@ -21,6 +21,7 @@
 """Implementation of the environment variables support."""
 
 import json
+import logging
 import re
 from collections.abc import Mapping as MappingType
 from typing import Any, Dict, List, Mapping, Optional, Tuple, Union, cast
@@ -33,6 +34,8 @@ from aea.helpers.constants import (
     NULL_EQUIVALENTS,
 )
 
+_logger = logging.getLogger(__name__)
+
 ENV_VARIABLE_RE = re.compile(r"^\$\{(([A-Z0-9_]+):?)?([a-z]+)?(:(.+))?}$")
 MODELS = "models"
 ARGS = "args"
@@ -272,6 +275,30 @@ def is_strict_list(data: Union[List, Tuple]) -> bool:
     return is_strict
 
 
+_BASH_SAFE_KEY_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def has_env_safe_keys(data: dict) -> bool:
+    """
+    Check if a dict can be safely flattened into per-key env vars.
+
+    Returns True only when every key is a string matching the bash
+    identifier rule `[A-Za-z_][A-Za-z0-9_]*`. An empty dict is
+    vacuously safe (True). When this returns False, flattening would
+    produce env var names that bash refuses to set (notably containing
+    `.`), so callers should JSON-encode the whole dict as a single env
+    var instead.
+
+    For example, `{"timeout": 30, "retries": 5}` returns True; while
+    `{"0.0": 0, "1.0": 100}` and `{1: "v"}` return False.
+
+    :param data: Data dict
+    :return: True if every key is a valid bash identifier, or the
+        dict is empty.
+    """
+    return all(isinstance(k, str) and _BASH_SAFE_KEY_RE.match(k) for k in data)
+
+
 def list_to_nested_dict(lst: list, val: Any) -> dict:
     """Convert a list to a nested dict."""
     nested_dict = val
@@ -280,6 +307,37 @@ def list_to_nested_dict(lst: list, val: Any) -> dict:
     return nested_dict
 
 
+def _encode_as_json_env_var(
+    data: JSON_TYPES, export_path: List[str]
+) -> Tuple[str, str]:
+    """
+    Encode data as a single JSON-string env var.
+
+    Used when a value cannot be flattened per-leaf (e.g. a list with
+    non-scalar elements, or a dict with bash-unsafe keys). Honours
+    `restrict_model_args`: if the export path is truncated by the model
+    arg restriction, the data is nested under the restricted suffix
+    (the deeper path keys) before encoding so they are not lost.
+
+    :param data: JSON-encodable value to encode.
+    :param export_path: Path keys leading to the value, from
+        `generate_env_vars_recursively`.
+    :return: (env_var_name, json_value) pair.
+    :raises ValueError: if ``data`` contains a value ``json.dumps`` cannot
+        serialise. The export path is included in the message so the
+        operator can locate the offending config key.
+    """
+    restricted, path = export_path_to_env_var_string(export_path=export_path)
+    payload = list_to_nested_dict(restricted, data) if restricted else data
+    try:
+        encoded = json.dumps(payload, separators=(",", ":"))
+    except TypeError as e:
+        raise ValueError(
+            f"Cannot JSON-encode value at export path {export_path}: {e}"
+        ) from e
+    return path, encoded
+
+
 def ensure_dict(dict_: Dict[str, Union[dict, str]]) -> dict:
     """Return the given dictionary converting any values which are json strings as dicts."""
     return {k: json.loads(v) for k, v in dict_.items() if isinstance(v, str)}
@@ -312,6 +370,26 @@ def generate_env_vars_recursively(
     env_var_dict: Dict[str, Any] = {}
 
     if isinstance(data, dict):
+        if not has_env_safe_keys(data):
+            safe_keys = [
+                k for k in data if isinstance(k, str) and _BASH_SAFE_KEY_RE.match(k)
+            ]
+            if safe_keys:
+                # Mixed-key dict: per-key env var overrides for the safe
+                # keys silently stop applying once the whole dict is
+                # JSON-encoded. Warn so the operator can see why their
+                # override does not take effect.
+                _logger.warning(
+                    "Collapsing mixed-key dict at export path %s to a "
+                    "single JSON env var because of bash-unsafe keys; "
+                    "per-key overrides for safe keys %s will no longer "
+                    "apply. Set the whole-dict env var instead.",
+                    export_path,
+                    safe_keys,
+                )
+            path, value = _encode_as_json_env_var(data, export_path)
+            env_var_dict[path] = value
+            return env_var_dict
         for key, value in data.items():
             res = generate_env_vars_recursively(
                 data=value,
@@ -325,11 +403,8 @@ def generate_env_vars_recursively(
             env_var_dict.update(res)
     elif isinstance(data, list):
         if is_strict_list(data=data):
-            restricted, path = export_path_to_env_var_string(export_path=export_path)
-            if restricted:
-                env_var_dict[path] = json.dumps(list_to_nested_dict(restricted, data))
-            else:
-                env_var_dict[path] = json.dumps(data, separators=(",", ":"))
+            path, value = _encode_as_json_env_var(data, export_path)
+            env_var_dict[path] = value
         else:
             for key, value in enumerate(data):
                 res = generate_env_vars_recursively(
@@ -340,7 +415,9 @@ def generate_env_vars_recursively(
     else:
         restricted, path = export_path_to_env_var_string(export_path=export_path)
         if restricted:
-            env_var_dict[path] = json.dumps(list_to_nested_dict(restricted, data))
+            env_var_dict[path] = json.dumps(
+                list_to_nested_dict(restricted, data), separators=(",", ":")
+            )
         else:
             env_var_dict[path] = data
 

{open_aea-2.2.6 → open_aea-2.2.7}/aea/helpers/logging.py

@@ -31,7 +31,21 @@ DEFAULT_FORMAT = "[%(asctime)s][%(levelname)s] %(message)s"
 def setup_logger(
     name: str, level: int = logging.INFO, log_format: str = DEFAULT_FORMAT
 ) -> Logger:
-    """Set up the logger."""
+    """Set up the logger.
+
+    Kept as a public helper for downstream consumers outside this repo;
+    new in-repo callers should prefer ``logging.getLogger(name)`` and set
+    the level directly. Calling ``logging.basicConfig`` at module-import
+    time pollutes the root logger and was the cause of the duplicate-log
+    bug fixed in #914 (PR #917).
+
+    :param name: logger name.
+    :param level: log level applied to the returned logger.
+    :param log_format: format string passed to ``logging.basicConfig``.
+        Only takes effect on the first call when the root logger has no
+        handlers yet; subsequent calls are a no-op for the format.
+    :return: the configured logger.
+    """
     logging.basicConfig(format=log_format)
     logger = logging.getLogger(name)
     logger.setLevel(level)

{open_aea-2.2.6 → open_aea-2.2.7}/aea/helpers/protocols.py

@@ -19,20 +19,21 @@
 
 """Protocol helpers."""
 
+import logging
 import re
 from pathlib import Path
 from typing import Match, cast
 
 from aea.configurations.loader import load_protocol_specification_from_string
 from aea.exceptions import enforce
-from aea.helpers.logging import setup_logger
 
 SPECIFICATION_REGEX = re.compile(r"(---\nname.*\.\.\.)", re.DOTALL)
 PROTOCOL_SPECIFICATION_ID_IN_SPECIFICATION_REGEX = re.compile(
     "^protocol_specification_id: (.*)$", re.MULTILINE
 )
 
-_logger = setup_logger(__name__)
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.INFO)
 
 
 def get_protocol_specification_from_readme(package_path: Path) -> str:

{open_aea-2.2.6 → open_aea-2.2.7}/aea/skills/base.py

@@ -41,7 +41,9 @@ from aea.configurations.base import (
     SkillComponentConfiguration,
     SkillConfig,
 )
+from aea.configurations.constants import SKILLS
 from aea.configurations.loader import load_component_configuration
+from aea.configurations.utils import package_dotted_path
 from aea.context.base import AgentContext
 from aea.exceptions import (
     AEAActException,
@@ -759,17 +761,44 @@ def _parse_module(
     if component_configs == {}:
         return components
     component_names = set(config.class_name for _, config in component_configs.items())
-    component_module = load_module(component_type_name_plural, Path(path))
+    # Build the same canonical dotted key the main loader uses for the
+    # same physical file (including subpackage files such as
+    # `<skill>/subpkg/behaviours.py`) so `sys.modules` cache hits across
+    # both load paths. `SkillContext` stores the Skill on the private
+    # `_skill` attribute (no public `skill` property — see the
+    # ``self._skill_context._skill = self`` assignment in ``Skill.__init__``),
+    # so we walk that explicitly. The `relative_to` call's narrow
+    # exceptions are caught only at the point they can fire.
+    file_stem = Path(path).stem
+    parent_parts: Tuple[str, ...] = ()
+    skill_dir = getattr(
+        getattr(getattr(skill_context, "_skill", None), "configuration", None),
+        "directory",
+        None,
+    )
+    if skill_dir is not None:
+        try:
+            relative = Path(path).resolve().relative_to(Path(skill_dir).resolve())
+            parent_parts = relative.parent.parts
+        except (ValueError, OSError):
+            pass
+    dotted_path = package_dotted_path(
+        skill_context.skill_id.author,
+        SKILLS,
+        skill_context.skill_id.name,
+        ".".join(parent_parts + (file_stem,)),
+    )
+    component_module = load_module(dotted_path, Path(path))
     classes = inspect.getmembers(component_module, inspect.isclass)
+    # Keep `SkillComponent` subclasses except those provided by the
+    # framework (`aea.*`). Cross-skill re-exports (composition idiom)
+    # have a `__module__` from another skill, not `aea.`, and are kept
+    # by design.
     component_classes = list(
         filter(
             lambda x: x[0] in component_names
             and issubclass(x[1], component_class)
-            and not str.startswith(x[1].__module__, "aea.")
-            and not str.startswith(
-                x[1].__module__,
-                f"packages.{skill_context.skill_id.author}.skills.{skill_context.skill_id.name}",
-            ),
+            and not str.startswith(x[1].__module__, "aea."),
             classes,
         )
     )
@@ -924,11 +953,25 @@ class _SkillComponentLoader:
         )
         return module_paths
 
-    @classmethod
-    def _compute_module_dotted_path(cls, module_path: Path) -> str:
-        """Compute the dotted path for a skill module."""
+    def _compute_module_dotted_path(self, module_path: Path) -> str:
+        """Compute the dotted path for a skill module.
+
+        ``__init__.py`` files are registered by ``load_aea_package``
+        under the parent package's dotted path (no ``.__init__``
+        suffix). Return that exact key so ``load_module`` cache-hits
+        on the already-loaded module instead of re-executing the file
+        (which would create duplicate class objects).
+
+        :param module_path: the module path, relative to the skill directory.
+        :return: the canonical dotted import path for that module.
+        """
+        if module_path.name == "__init__.py":
+            parent_parts = module_path.parent.parts
+            if not parent_parts:
+                return self.skill_dotted_path
+            return f"{self.skill_dotted_path}.{'.'.join(parent_parts)}"
         suffix = ".".join(module_path.with_name(module_path.stem).parts)
-        return suffix
+        return f"{self.skill_dotted_path}.{suffix}"
 
     def _filter_classes(
         self, classes: List[Tuple[str, Type]]
@@ -937,23 +980,24 @@ class _SkillComponentLoader:
         Filter classes of skill components.
 
         The following filters are applied:
-        - the class must be a subclass of "SkillComponent";
-        - its __module__ attribute must not start with 'aea.' (we exclude classes provided by the framework)
-        - its __module__ attribute starts with the expected dotted path of this skill.
-            In particular, it should not be imported from another skill.
+        - the class must be a subclass of ``SkillComponent``;
+        - its ``__module__`` attribute must not start with ``aea.``
+          (classes provided by the framework are excluded).
+
+        Cross-skill re-exports (composition skills binding another skill's
+        ``Handler``, ``Model``, etc. as their own — including the
+        ``Model``-wrapped dialogues classes such as ``AbciDialogues``) are
+        kept by design: such classes have a ``__module__`` from another
+        skill and pass the filter. Framework dialogue base classes from
+        ``aea.protocols.dialogue.base`` are not ``SkillComponent``
+        subclasses and are filtered out by the first condition anyway.
 
         :param classes: a list of pairs (class name, class object)
         :return: a list of the same kind, but filtered with only skill component classes.
         """
         filtered_classes = filter(
             lambda name_and_class: issubclass(name_and_class[1], SkillComponent)
-            # the following condition filters out classes imported from 'aea'
-            and not str.startswith(name_and_class[1].__module__, "aea.")
-            # the following condition filters out classes imported
-            # from other skills
-            and not str.startswith(
-                name_and_class[1].__module__, self.skill_dotted_path + "."
-            ),
+            and not str.startswith(name_and_class[1].__module__, "aea."),
             classes,
         )
         classes = list(filtered_classes)
@@ -1186,10 +1230,14 @@ class _SkillComponentLoader:
             set_of_unused_classes = set(
                 filter(lambda x: x not in used_classes, set_of_classes)
             )
-            # filter out classes that are from other packages
+            # Filter out classes that are from other packages. Match both
+            # submodule classes (`packages.<a>.skills.<n>.foo.Bar`) and
+            # classes defined at the skill's `__init__.py` level (whose
+            # `__module__` equals `self.skill_dotted_path` exactly).
             set_of_unused_classes = set(
                 filter(
-                    lambda x: not str.startswith(x.__module__, "packages."),
+                    lambda x: x.__module__ == self.skill_dotted_path
+                    or str.startswith(x.__module__, self.skill_dotted_path + "."),
                     set_of_unused_classes,
                 )
             )

{open_aea-2.2.6 → open_aea-2.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "open-aea"
-version = "2.2.6"
+version = "2.2.7"
 description = "Open AEA Framework"
 authors = ["developer-valory <develope@valory.xyz>"]
 license = "Apache-2.0"