Fix deepcopy issue

src/griffe/collections.py

@@ -7,7 +7,7 @@
 from functools import lru_cache
 from io import BytesIO
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, ItemsView, KeysView, ValuesView
 
 from griffe.mixins import GetMembersMixin, SetMembersMixin
 
@@ -31,17 +31,29 @@ def __setitem__(self, key: Path, value: list[str]) -> None:
  def __bool__(self) -> bool:
  return True
 
- def __getattr__(self, name: str, default: Any = None) -> Any:
- """Lookup attributes into underlying dict.
+ def keys(self) -> KeysView:
+ """Return the collection keys.
 
- Parameters:
- name: The attribute name.
- default: A default value.
+ Returns:
+ The collection keys.
+ """
+ return self._data.keys()
+
+ def values(self) -> ValuesView:
+ """Return the collection values.
+
+ Returns:
+ The collection values.
+ """
+ return self._data.values()
+
+ def items(self) -> ItemsView:
+ """Return the collection items.
 
  Returns:
- The attribute of the underlying dict.
+ The collection items.
  """
- return getattr(self._data, name, default)
+ return self._data.items()
 
  # TODO: remove once Python 3.7 support is dropped
  @lru_cache(maxsize=None) # noqa: B019

src/griffe/dataclasses.py

@@ -13,7 +13,7 @@
 from contextlib import suppress
 from pathlib import Path
 from textwrap import dedent
-from typing import Any, Callable, cast
+from typing import Any, Callable, Union, cast
 
 from griffe.collections import LinesCollection, ModulesCollection
 from griffe.docstrings.dataclasses import DocstringSection
@@ -318,7 +318,7 @@ class Object(GetMembersMixin, SetMembersMixin, ObjectAliasMixin, SerializationMi
 
  kind: Kind
  is_alias: bool = False
- is_collection = False
+ is_collection: bool = False
 
  def __init__(
  self,
@@ -754,7 +754,7 @@ def _endlineno(self) -> int | None:
  return blockfinder.last
 
 
-class Alias(ObjectAliasMixin):
+class Alias(ObjectAliasMixin): # noqa: WPS338
  """This class represents an alias, or indirection, to an object declared in another module.
 
  Aliases represent objects that are in the scope of a module or class,
@@ -777,6 +777,7 @@ class Alias(ObjectAliasMixin):
  """
 
  is_alias: bool = True
+ is_collection: bool = False
 
  def __init__(
  self,
@@ -818,19 +819,6 @@ def __init__(
  def __repr__(self) -> str:
  return f"<Alias({self.name!r}, {self.target_path!r})>"
 
- def __getattr__(self, name: str) -> Any:
- # forward everything to the target
- if self._passed_through:
- raise CyclicAliasError([self.target_path])
- self._passed_through = True
- try:
- attr = getattr(self.target, name)
- except CyclicAliasError as error:
- raise CyclicAliasError([self.target_path] + error.chain)
- finally:
- self._passed_through = False
- return attr
-
  def __getitem__(self, key):
  # not handled by __getattr__
  return self.target[key]
@@ -842,6 +830,8 @@ def __setitem__(self, key, value):
  def __len__(self) -> int:
  return 1
 
+ # SPECIAL PROXIES -------------------------------
+
  @property
  def kind(self) -> Kind:
  """Return the target's kind, or Kind.ALIAS if the target cannot be resolved.
@@ -922,6 +912,155 @@ def modules_collection(self) -> ModulesCollection:
  # no need to forward to the target
  return self.parent.modules_collection # type: ignore[union-attr] # we assume there's always a parent
 
+ # GENERIC OBJECT PROXIES --------------------------------
+
+ @property
+ def docstring(self): # noqa: D102
+ return self.target.docstring
+
+ @property
+ def members(self): # noqa: D102
+ return self.target.members
+
+ @property
+ def labels(self): # noqa: D102
+ return self.target.labels
+
+ @property
+ def imports(self): # noqa: D102
+ return self.target.imports
+
+ @property
+ def exports(self): # noqa: D102
+ return self.target.exports
+
+ @property
+ def aliases(self): # noqa: D102
+ return self.target.aliases
+
+ def member_is_exported(self, member: Object | Alias, explicitely: bool = True) -> bool: # noqa: D102
+ return self.target.member_is_exported(member, explicitely)
+
+ def is_kind(self, kind: str | Kind | set[str | Kind]) -> bool: # noqa: D102
+ return self.target.is_kind(kind)
+
+ @property
+ def is_module(self): # noqa: D102
+ return self.target.is_module
+
+ @property
+ def is_class(self): # noqa: D102
+ return self.target.is_class
+
+ @property
+ def is_function(self): # noqa: D102
+ return self.target.is_function
+
+ @property
+ def is_attribute(self): # noqa: D102
+ return self.target.is_attribute
+
+ def has_labels(self, labels: set[str]) -> bool: # noqa: D102
+ return self.target.has_labels(labels)
+
+ def filter_members(self, *predicates: Callable[[Object | Alias], bool]) -> dict[str, Object | Alias]: # noqa: D102
+ return self.target.filter_members(*predicates)
+
+ @property
+ def modules(self): # noqa: D102
+ return self.target.modules
+
+ @property
+ def classes(self): # noqa: D102
+ return self.target.classes
+
+ @property
+ def functions(self): # noqa: D102
+ return self.target.functions
+
+ @property
+ def attributes(self): # noqa: D102
+ return self.target.attributes
+
+ @property
+ def module(self): # noqa: D102
+ return self.target.module
+
+ @property
+ def package(self): # noqa: D102
+ return self.target.package
+
+ @property
+ def filepath(self): # noqa: D102
+ return self.target.filepath
+
+ @property
+ def relative_filepath(self): # noqa: D102
+ return self.target.relative_filepath
+
+ @property
+ def canonical_path(self): # noqa: D102
+ return self.target.canonical_path
+
+ @property
+ def lines_collection(self): # noqa: D102
+ return self.target.lines_collection
+
+ @property
+ def lines(self): # noqa: D102
+ return self.target.lines
+
+ @property
+ def source(self): # noqa: D102
+ return self.target.source
+
+ def resolve(self, name: str) -> str: # noqa: D102
+ return self.target.resolve(name)
+
+ # SPECIFIC MODULE/CLASS/FUNCTION/ATTRIBUTE PROXIES ---------------
+
+ @property
+ def _filepath(self) -> Path | list[Path] | None: # noqa: D102
+ return cast(Module, self.target)._filepath # noqa: WPS437
+
+ @property
+ def bases(self) -> list[Name | Expression | str]: # noqa: D102
+ return cast(Class, self.target).bases
+
+ @property
+ def decorators(self) -> list[Decorator]: # noqa: D102
+ return cast(Union[Class, Function], self.target).decorators
+
+ @property
+ def overloads(self) -> dict[str, list[Function]] | list[Function] | None: # noqa: D102
+ return cast(Union[Module, Class, Function], self.target).overloads
+
+ @property
+ def parameters(self) -> Parameters: # noqa: D102
+ return cast(Function, self.target).parameters
+
+ @property
+ def returns(self) -> str | Name | Expression | None: # noqa: D102
+ return cast(Function, self.target).returns
+
+ @property
+ def setter(self) -> Function | None: # noqa: D102
+ return cast(Function, self.target).setter
+
+ @property
+ def deleter(self) -> Function | None: # noqa: D102
+ return cast(Function, self.target).deleter
+
+ @property
+ def value(self) -> str | None: # noqa: D102
+ return cast(Attribute, self.target).value
+
+ @property
+ def annotation(self) -> str | Name | Expression | None: # noqa: D102
+ return cast(Attribute, self.target).annotation
+
+ # SPECIFIC ALIAS METHOD AND PROPERTIES -----------------
+
  @property
  def target(self) -> Object | Alias:
  """Resolve and return the target, if possible.

tests/test_dataclasses.py

@@ -1,5 +1,7 @@
 """Tests for the `dataclasses` module."""
 
+from copy import deepcopy
+
 from griffe.dataclasses import Docstring, Module
 from griffe.loader import GriffeLoader
 from tests.helpers import module_vtree, temporary_pypackage
@@ -57,3 +59,12 @@ def test_has_docstrings_does_not_trigger_alias_resolution():
  package = loader.load_module(tmp_package.name)
  assert not package.has_docstrings
  assert not package["mod_a.someobj"].resolved
+
+
+def test_deepcopy():
+ """Assert we can deep-copy object trees."""
+ loader = GriffeLoader()
+ mod = loader.load_module("griffe")
+
+ deepcopy(mod)
+ deepcopy(mod.as_dict())