Function¤

              flowchart TD
              griffe.Function[Function]
              _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.Function
                                _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.Function href "" "griffe.Function"
              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 function.

Parameters:

• *args ¤

  (Any, default: () ) –

  See griffe.Object.

• parameters ¤

  (Parameters | None, default: None ) –

  The function parameters.

• returns ¤

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

  The function return annotation.

• decorators ¤

  (list[Decorator] | None, default: None ) –

  The function decorators, 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 type annotation of the returned value.

• attributes (dict[str, Attribute]) –

  The attribute members.

• canonical_path (str) –

  The full dotted path of this object.

• classes (dict[str, Class]) –

  The class members.

• decorators (list[Decorator]) –

  The function decorators.

• 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 (set[str] | 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.

• overloads (list[Function] | None) –

  The overloaded signatures of this function.

• package (Module) –

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

• parameters (Parameters) –

  The function parameters.

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

• returns (str | Expr | None) –

  The function return type annotation.

• runtime (bool) –

  Whether this object is available at runtime.

• source (str) –

  The source code of this object.

aliases: dict[str, Alias] = {}

all_members: dict[str, Object | Alias]

annotation: str | Expr | None

attributes: dict[str, Attribute]

canonical_path: str

classes: dict[str, Class]

decorators: list[Decorator] = decorators or []

deprecated: bool | str | None = None

docstring: Docstring | None = docstring

endlineno: int | None = endlineno

exports: set[str] | 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 = FUNCTION

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

overloads: list[Function] | None = None

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'))

parameters: Parameters = parameters or Parameters()

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

returns: str | Expr | None = returns

runtime: bool = runtime

source: str

__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)

This class is a container for parameters.

It allows to get parameters using their position (index) or their name:

>>> parameters = Parameters(Parameter("hello"))
>>> parameters[0] is parameters["hello"]
True

Parameters:

• *parameters ¤

  (Parameter, default: () ) –

  The initial parameters to add to the container.

Methods:

• __contains__ –

  Whether a parameter with the given name is present.

• __delitem__ –

  Delete a parameter by index or name.

• __getitem__ –

  Get a parameter by index or name.

• __iter__ –

  Iterate over the parameters, in order.

• __len__ –

  The number of parameters.

• __setitem__ –

  Set a parameter by index or name.

• add –

  Add a parameter to the container.

__contains__(param_name: str)

__delitem__(name_or_index: int | str) -> None

__getitem__(name_or_index: int | str) -> Parameter

__iter__()

__len__()

__setitem__(
    name_or_index: int | str, parameter: Parameter
) -> None

add(parameter: Parameter) -> None

This class represent a function parameter.

Parameters:

• name ¤

  (str) –

  The parameter name, without leading stars (* or **).

• annotation ¤

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

  The parameter annotation, if any.

• kind ¤

  (ParameterKind | None, default: None ) –

  The parameter kind.

• default ¤

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

  The parameter default, if any.

• docstring ¤

  (Docstring | None, default: None ) –

  The parameter docstring.

Methods:

• __eq__ –

  Parameters are equal if all their attributes except docstring and function are equal.

• as_dict –

  Return this parameter's data as a dictionary.

Attributes:

• annotation (str | Expr | None) –

  The parameter type annotation.

• default (str | Expr | None) –

  The parameter default value.

• docstring (Docstring | None) –

  The parameter docstring.

• function (Function | None) –

  The parent function of the parameter.

• kind (ParameterKind | None) –

  The parameter kind.

• name (str) –

  The parameter name.

• required (bool) –

  Whether this parameter is required.

annotation: str | Expr | None = annotation

default: str | Expr | None = default

docstring: Docstring | None = docstring

function: Function | None = None

kind: ParameterKind | None = kind

name: str = name

required: bool

__eq__(__value: object) -> bool

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

              flowchart TD
              griffe.ParameterKind[ParameterKind]

              

              click griffe.ParameterKind href "" "griffe.ParameterKind"
            

Enumeration of the different parameter kinds.

Attributes:

• keyword_only (str) –

  Keyword-only parameter.

• positional_only (str) –

  Positional-only parameter.

• positional_or_keyword (str) –

  Positional or keyword parameter.

• var_keyword (str) –

  Variadic keyword parameter.

• var_positional (str) –

  Variadic positional parameter.

keyword_only: str = 'keyword-only'

positional_only: str = 'positional-only'

positional_or_keyword: str = 'positional or keyword'

var_keyword: str = 'variadic keyword'

var_positional: str = 'variadic positional'

This class represents decorators.

Parameters:

• value ¤

  (str | Expr) –

  The decorator code.

• lineno ¤

  (int | None) –

  The starting line number.

• endlineno ¤

  (int | None) –

  The ending line number.

Methods:

• as_dict –

  Return this decorator's data as a dictionary.

Attributes:

• callable_path (str) –

  The path of the callable used as decorator.

• endlineno (int | None) –

  The ending line number of the decorator.

• lineno (int | None) –

  The starting line number of the decorator.

• value (str | Expr) –

  The decorator value (as a Griffe expression or string).

callable_path: str

endlineno: int | None = endlineno

lineno: int | None = lineno

value: str | Expr = value

as_dict(**kwargs: Any) -> dict[str, Any]