Alias¤

              flowchart TD
              griffe.Alias[Alias]
              _griffe.mixins.ObjectAliasMixin[ObjectAliasMixin]
              _griffe.mixins.GetMembersMixin[GetMembersMixin]
              _griffe.mixins.SetMembersMixin[SetMembersMixin]
              _griffe.mixins.DelMembersMixin[DelMembersMixin]
              _griffe.mixins.SerializationMixin[SerializationMixin]

                              _griffe.mixins.ObjectAliasMixin --> griffe.Alias
                                _griffe.mixins.GetMembersMixin --> _griffe.mixins.ObjectAliasMixin
                
                _griffe.mixins.SetMembersMixin --> _griffe.mixins.ObjectAliasMixin
                
                _griffe.mixins.DelMembersMixin --> _griffe.mixins.ObjectAliasMixin
                
                _griffe.mixins.SerializationMixin --> _griffe.mixins.ObjectAliasMixin
                



              click griffe.Alias href "" "griffe.Alias"
              click _griffe.mixins.ObjectAliasMixin href "" "_griffe.mixins.ObjectAliasMixin"
              click _griffe.mixins.GetMembersMixin href "" "_griffe.mixins.GetMembersMixin"
              click _griffe.mixins.SetMembersMixin href "" "_griffe.mixins.SetMembersMixin"
              click _griffe.mixins.DelMembersMixin href "" "_griffe.mixins.DelMembersMixin"
              click _griffe.mixins.SerializationMixin href "" "_griffe.mixins.SerializationMixin"
            

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, but were imported from another module.

They behave almost exactly like regular objects, to a few exceptions:

• line numbers are those of the alias, not the target
• the path is the alias path, not the canonical one
• the name can be different from the target's
• if the target can be resolved, the kind is the target's kind
• if the target cannot be resolved, the kind becomes Kind.ALIAS

Parameters:

• name ¤

  (str) –

  The alias name.

• target ¤

  (str | Object | Alias) –

  If it's a string, the target resolution is delayed until accessing the target property. If it's an object, or even another alias, the target is immediately set.

• lineno ¤

  (int | None, default: None ) –

  The alias starting line number.

• endlineno ¤

  (int | None, default: None ) –

  The alias ending line number.

• runtime ¤

  (bool, default: True ) –

  Whether this alias is present at runtime or not.

• parent ¤

  (Module | Class | Alias | None, default: None ) –

  The alias parent.

• inherited ¤

  (bool, default: False ) –

  Whether this alias wraps an inherited member.

Methods:

• __bool__ –

  An alias is always true-ish.

• __delitem__ –

  Delete a member with its name or path.

• __getitem__ –

  Get a member with its name or path.

• __len__ –

  The length of an alias is always 1.

• __setitem__ –

  Set a member with its name or path.

• as_dict –

  Return this alias' data as a dictionary.

• as_json –

  Return this target's data as a JSON string.

• del_member –

  Delete a member with its name or path.

• filter_members –

  Filter and return members based on predicates.

• from_json –

  Create an instance of this class from a JSON string.

• get_member –

  Get a member with its name or path.

• has_labels –

  Tell if this object has all the given labels.

• is_kind –

  Tell if this object is of the given kind.

• mro –

  Return a list of classes in order corresponding to Python's MRO.

• resolve –

  Resolve a name within this object's and parents' scope.

• resolve_target –

  Resolve the target.

• set_member –

  Set a member with its name or path.

Attributes:

• alias_endlineno (int | None) –

  The ending line number of the alias.

• alias_lineno (int | None) –

  The starting line number of the alias.

• aliases (dict[str, Alias]) –

  The aliases pointing to this object.

• all_members (dict[str, Object | Alias]) –

  All members (declared and inherited).

• annotation (str | Expr | None) –

  The attribute type annotation.

• attributes (dict[str, Attribute]) –

  The attribute members.

• bases (list[Expr | str]) –

  The class bases.

• canonical_path (str) –

  The full dotted path of this object.

• classes (dict[str, Class]) –

  The class members.

• decorators (list[Decorator]) –

  The class/function decorators.

• deleter (Function | None) –

  The deleter linked to this function (property).

• deprecated (str | bool | None) –

  Whether this alias is deprecated (boolean or deprecation message).

• docstring (Docstring | None) –

  The target docstring.

• endlineno (int | None) –

  The ending line number of the target object.

• exports (set[str] | list[str | ExprName] | None) –

  The names of the objects exported by this (module) object through the __all__ variable.

• extra (dict) –

  Namespaced dictionaries storing extra metadata for this object, used by extensions.

• filepath (Path | list[Path]) –

  The file path (or directory list for namespace packages) where this object was defined.

• final_target (Object) –

  The final, resolved target, if possible.

• functions (dict[str, Function]) –

  The function members.

• has_docstring (bool) –

  Whether this alias' target has a non-empty docstring.

• has_docstrings (bool) –

  Whether this alias' target or any of its members has a non-empty docstring.

• imports (dict[str, str]) –

  The other objects imported by this alias' target.

• imports_future_annotations (bool) –

  Whether this module import future annotations.

• inherited (bool) –

  Whether this alias represents an inherited member.

• inherited_members (dict[str, Alias]) –

  Members that are inherited from base classes.

• is_alias (bool) –

  Always true for aliases.

• is_attribute (bool) –

  Whether this object is an attribute.

• is_class (bool) –

  Whether this object is a class.

• is_class_private (bool) –

  Whether this object/alias is class-private (starts with __ and is a class member).

• is_collection (bool) –

  Always false for aliases.

• is_deprecated (bool) –

  Whether this object is deprecated.

• is_exported (bool) –

  Whether this object/alias is exported (listed in __all__).

• is_function (bool) –

  Whether this object is a function.

• is_imported (bool) –

  Whether this object/alias was imported from another module.

• is_init_module (bool) –

  Whether this module is an __init__.py module.

• is_module (bool) –

  Whether this object is a module.

• is_namespace_package (bool) –

  Whether this module is a namespace package (top folder, no __init__.py).

• is_namespace_subpackage (bool) –

  Whether this module is a namespace subpackage.

• is_package (bool) –

  Whether this module is a package (top module).

• is_private (bool) –

  Whether this object/alias is private (starts with _) but not special.

• is_public (bool) –

  Whether this object is considered public.

• is_special (bool) –

  Whether this object/alias is special ("dunder" attribute/method, starts and end with __).

• is_subpackage (bool) –

  Whether this module is a subpackage.

• is_wildcard_exposed (bool) –

  Whether this object/alias is exposed to wildcard imports.

• kind (Kind) –

  The target's kind, or Kind.ALIAS if the target cannot be resolved.

• labels (set[str]) –

  The target labels (property, dataclass, etc.).

• lineno (int | None) –

  The starting line number of the target object.

• lines (list[str]) –

  The lines containing the source of this object.

• lines_collection (LinesCollection) –

  The lines collection attached to this object or its parents.

• members (dict[str, Object | Alias]) –

  The target's members (modules, classes, functions, attributes).

• module (Module) –

  The parent module of this object.

• modules (dict[str, Module]) –

  The module members.

• modules_collection (ModulesCollection) –

  The modules collection attached to the alias parents.

• name (str) –

  The alias name.

• overloads (dict[str, list[Function]] | list[Function] | None) –

  The overloaded signatures declared in this class/module or for this function.

• package (Module) –

  The absolute top module (the package) of this object.

• parameters (Parameters) –

  The parameters of the current function or __init__ method for classes.

• parent (Module | Class | Alias | None) –

  The parent of this alias.

• path (str) –

  The dotted path / import path of this object.

• public (bool | None) –

  Whether this alias is public.

• relative_filepath (Path) –

  The file path where this object was defined, relative to the current working directory.

• relative_package_filepath (Path) –

  The file path where this object was defined, relative to the top module path.

• resolved (bool) –

  Whether this alias' target is resolved.

• resolved_bases (list[Object]) –

  Resolved class bases.

• returns (str | Expr | None) –

  The function return type annotation.

• runtime (bool) –

  Whether this alias is available at runtime.

• setter (Function | None) –

  The setter linked to this function (property).

• source (str) –

  The source code of this object.

• target (Object | Alias) –

  The resolved target (actual object), if possible.

• target_path (str) –

  The path of this alias' target.

• value (str | Expr | None) –

  The attribute value.

• wildcard (str | None) –

  The module on which the wildcard import is performed (if any).

alias_endlineno: int | None = endlineno

alias_lineno: int | None = lineno

aliases: dict[str, Alias]

all_members: dict[str, Object | Alias]

annotation: str | Expr | None

attributes: dict[str, Attribute]

bases: list[Expr | str]

canonical_path: str

classes: dict[str, Class]

decorators: list[Decorator]

deleter: Function | None

deprecated: str | bool | None = None

docstring: Docstring | None

endlineno: int | None

exports: set[str] | list[str | ExprName] | None

from .submodule import __all__ as submodule_all

__all__ = ["hello", *submodule_all]

extra: dict

filepath: Path | list[Path]

final_target: Object

functions: dict[str, Function]

has_docstring: bool

has_docstrings: bool

imports: dict[str, str]

imports_future_annotations: bool

inherited: bool = inherited

inherited_members: dict[str, Alias]

is_alias: bool = True

is_attribute: bool

is_class: bool

is_class_private: bool

is_collection: bool = False

is_deprecated: bool

is_exported: bool

is_function: bool

is_imported: bool

is_init_module: bool

is_module: bool

is_namespace_package: bool

is_namespace_subpackage: bool

is_package: bool

is_private: bool

is_public: bool

is_special: bool

is_subpackage: bool

is_wildcard_exposed: bool

kind: Kind

labels: set[str]

lineno: int | None

lines: list[str]

lines_collection: LinesCollection

members: dict[str, Object | Alias]

module: Module

modules: dict[str, Module]

modules_collection: ModulesCollection

name: str = name

overloads: dict[str, list[Function]] | list[Function] | None

package: Module

parameters: Parameters

parent: Module | Class | Alias | None

path: str

public: bool | None = None

relative_filepath: Path

relative_package_filepath: Path

resolved: bool

resolved_bases: list[Object]

returns: str | Expr | None

runtime: bool = runtime

setter: Function | None

source: str

target: Object | Alias

target_path: str

value: str | Expr | None

wildcard: str | None

__bool__() -> bool

__delitem__(key: str | Sequence[str]) -> None

>>> del griffe_object["foo"]
>>> del griffe_object["path.to.bar"]
>>> del griffe_object[("path", "to", "qux")]

__getitem__(key: str | Sequence[str]) -> Any

>>> foo = griffe_object["foo"]
>>> bar = griffe_object["path.to.bar"]
>>> qux = griffe_object[("path", "to", "qux")]

__len__() -> int

__setitem__(
    key: str | Sequence[str], value: Object | Alias
) -> None

>>> griffe_object["foo"] = foo
>>> griffe_object["path.to.bar"] = bar
>>> griffe_object[("path", "to", "qux")] = qux

as_dict(
    *, full: bool = False, **kwargs: Any
) -> dict[str, Any]

as_json(*, full: bool = False, **kwargs: Any) -> str

del_member(key: str | Sequence[str]) -> None

>>> griffe_object.del_member("foo")
>>> griffe_object.del_member("path.to.bar")
>>> griffe_object.del_member(("path", "to", "qux"))

filter_members(
    *predicates: Callable[[Object | Alias], bool]
) -> dict[str, Object | Alias]

from_json(json_string: str, **kwargs: Any) -> _ObjType

get_member(key: str | Sequence[str]) -> Any

>>> foo = griffe_object["foo"]
>>> bar = griffe_object["path.to.bar"]
>>> bar = griffe_object[("path", "to", "bar")]

has_labels(*labels: str) -> bool

is_kind(kind: str | Kind | set[str | Kind]) -> bool

mro() -> list[Class]

resolve(name: str) -> str

resolve_target() -> None

set_member(
    key: str | Sequence[str], value: Object | Alias
) -> None

>>> griffe_object.set_member("foo", foo)
>>> griffe_object.set_member("path.to.bar", bar)
>>> griffe_object.set_member(("path", "to", "qux"), qux)