Attribute ¤

Bases: Object

              flowchart TD
              griffe.Attribute[Attribute]
              _griffe.models.Object[Object]
              _griffe.mixins.ObjectAliasMixin[ObjectAliasMixin]
              _griffe.mixins.GetMembersMixin[GetMembersMixin]
              _griffe.mixins.SetMembersMixin[SetMembersMixin]
              _griffe.mixins.DelMembersMixin[DelMembersMixin]
              _griffe.mixins.SerializationMixin[SerializationMixin]

                              _griffe.models.Object --> griffe.Attribute
                                _griffe.mixins.ObjectAliasMixin --> _griffe.models.Object
                                _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.Attribute href "" "griffe.Attribute"
              click _griffe.models.Object href "" "_griffe.models.Object"
              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"
            

The class representing a Python module/class/instance attribute.

Parameters:

• *args ¤

  (Any, default: () ) –

  See griffe.Object.

• value ¤

  (str | Expr | None, default: None ) –

  The attribute value, if any.

• annotation ¤

  (str | Expr | None, default: None ) –

  The attribute annotation, if any.

• **kwargs ¤

  (Any, default: {} ) –

  See griffe.Object.

Methods:

• __bool__ –

  An object is always true-ish.

• __delitem__ –

  Delete a member with its name or path.

• __getitem__ –

  Get a member with its name or path.

• __len__ –

  The number of members in this object, recursively.

• __setitem__ –

  Set a member with its name or path.

• as_dict –

  Return this function's data as a dictionary.

• as_json –

  Return this object'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.

• resolve –

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

• set_member –

  Set a member with its name or path.

Attributes:

• 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.

• canonical_path (str) –

  The full dotted path of this object.

• classes (dict[str, Class]) –

  The class members.

• deleter (Function | None) –

  The deleter linked to this property.

• deprecated (bool | str | None) –

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

• docstring (Docstring | None) –

  The object docstring.

• endlineno (int | None) –

  The ending line number of the object.

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

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

• extra (dict[str, dict[str, Any]]) –

  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.

• functions (dict[str, Function]) –

  The function members.

• has_docstring (bool) –

  Whether this object has a docstring (empty or not).

• has_docstrings (bool) –

  Whether this object or any of its members has a docstring (empty or not).

• imports (dict[str, str]) –

  The other objects imported by this object.

• inherited (bool) –

  Always false for objects.

• inherited_members (dict[str, Alias]) –

  Members that are inherited from base classes.

• is_alias (bool) –

  Always false for objects.

• 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 objects.

• 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 object is an __init__.py module.

• is_module (bool) –

  Whether this object is a module.

• is_namespace_package (bool) –

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

• is_namespace_subpackage (bool) –

  Whether this object is a namespace subpackage.

• is_package (bool) –

  Whether this object 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 object is a subpackage.

• is_wildcard_exposed (bool) –

  Whether this object/alias is exposed to wildcard imports.

• kind –

  The object kind.

• labels (set[str]) –

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

• lineno (int | None) –

  The starting line number of the 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 object 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 this object or its parents.

• name (str) –

  The object name.

• package (Module) –

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

• parent (Module | Class | None) –

  The parent of the object (none if top module).

• path (str) –

  The dotted path of this object.

• public (bool | None) –

  Whether this object 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.

• runtime (bool) –

  Whether this object is available at runtime.

• setter (Function | None) –

  The setter linked to this property.

• source (str) –

  The source code of this object.

• value (str | Expr | None) –

  The attribute value.

aliases: dict[str, Alias] = {}

all_members: dict[str, Object | Alias]

annotation: str | Expr | None = annotation

attributes: dict[str, Attribute]

canonical_path: str

classes: dict[str, Class]

deleter: Function | None = None

deprecated: bool | str | None = None

docstring: Docstring | None = docstring

endlineno: int | None = endlineno

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

from .submodule import __all__ as submodule_all

__all__ = ["hello", *submodule_all]

extra: dict[str, dict[str, Any]] = defaultdict(dict)

filepath: Path | list[Path]

>>> import griffe
>>> markdown = griffe.load("markdown")
>>> markdown.filepath
PosixPath('~/project/.venv/lib/python3.11/site-packages/markdown/__init__.py')

functions: dict[str, Function]

has_docstring: bool

has_docstrings: bool

imports: dict[str, str] = {}

inherited: bool = False

inherited_members: dict[str, Alias]

is_alias: bool = False

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 = ATTRIBUTE

labels: set[str] = set()

lineno: int | None = lineno

lines: list[str]

lines_collection: LinesCollection

members: dict[str, Object | Alias] = {}

module: Module

>>> import griffe
>>> markdown = griffe.load("markdown")
>>> markdown["core.Markdown.references"].module
Module(PosixPath('~/project/.venv/lib/python3.11/site-packages/markdown/core.py'))
>>> # The `module` of a module is itself.
>>> markdown["core"].module
Module(PosixPath('~/project/.venv/lib/python3.11/site-packages/markdown/core.py'))

modules: dict[str, Module]

modules_collection: ModulesCollection

name: str = name

package: Module

>>> import griffe
>>> markdown = griffe.load("markdown")
>>> markdown["core.Markdown.references"].package
Module(PosixPath('~/project/.venv/lib/python3.11/site-packages/markdown/__init__.py'))

parent: Module | Class | None = parent

path: str

>>> import griffe
>>> markdown = griffe.load("markdown")
>>> markdown["core.Markdown.references"].path
'markdown.core.Markdown.references'

public: bool | None = None

relative_filepath: Path

relative_package_filepath: Path

runtime: bool = runtime

setter: Function | None = None

source: str

value: str | Expr | None = value

__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(**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

resolve(name: str) -> str

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)