Added API in api reference and updated documentation.

Author: Sylvain MARIE

docs/api_reference.md

@@ -132,6 +132,14 @@ generating default value for <pyfields.core.Pocket object ...
 []
 ```
 
+Several helper functions are available to create default factories:
+
+ - `copy_value(<value>)` returns a factory that creates a copy of the provided `val` everytime it is called. Handy if you wish to use mutable
+    objects as default values for your fields ; for example lists.
+  
+ - `copy_attr(<att_name>, deep=True)` returns a factory that creates a (deep or not) copy of the value in the given attribute everytime it is called.
+
+ - `copy_field(<field_or_name>, deep=True)` is similar to `copy_attr` but you can provide a `field` instead of a name.
 
 ### `@<field>.validator`
 
@@ -343,3 +351,52 @@ Wall<height=1, color='white'>
 **Parameters:**
 
  - `fields`: list of fields to initialize before entering the decorated `__init__` method. For each of these fields a corresponding argument will be added in the method's signature. If an empty list is provided, all fields from the class will be used including inherited fields following the mro.
+
+
+## API
+
+### `has_fields`
+
+```python
+def has_fields(cls,
+               include_inherited=True  # type: bool
+               )
+```
+
+Returns True if class `cls` defines at least one `pyfields` field.
+If `include_inherited` is `True` (default), the method will return `True` if at least a field is defined in the class or one of its ancestors. If `False`, the fields need to be defined on the class itself.
+
+### `get_fields`
+
+```python
+def get_fields(cls,
+               include_inherited=True,  # type: bool
+               remove_duplicates=True,  # type: bool
+               ancestors_first=True,    # type: bool
+               container_type=tuple,    # type: Type[T]
+               )
+```
+
+Utility method to collect all fields defined in a class, including all inherited or not.
+By default duplicates are removed and ancestor fields are included and appear first. If a field is overridden, it will appear at the position of the overridden field in the order.
+
+### `yield_fields`
+
+```python
+def yield_fields(cls,
+                 include_inherited=True,  # type: bool
+                 remove_duplicates=True,  # type: bool
+                 ancestors_first=True,    # type: bool
+                 )
+```
+
+Similar to `get_fields` but as a generator.
+
+### `get_field`
+
+```python
+def get_field(cls, name)
+```
+
+Utility method to return the field member with name `name` in class `cls`.
+If the member is not a field, a `NotAFieldError` is raised.

docs/index.md

@@ -6,6 +6,7 @@
 
 [![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://smarie.github.io/python-pyfields/) [![PyPI](https://img.shields.io/pypi/v/pyfields.svg)](https://pypi.python.org/pypi/pyfields/) [![Downloads](https://pepy.tech/badge/pyfields)](https://pepy.tech/project/pyfields) [![Downloads per week](https://pepy.tech/badge/pyfields/week)](https://pepy.tech/project/pyfields) [![GitHub stars](https://img.shields.io/github/stars/smarie/python-pyfields.svg)](https://github.com/smarie/python-pyfields/stargazers)
 
+!!! success "`pyfields` is now automatically supported by `autoclass` ! See [here](https://smarie.github.io/python-autoclass/#pyfields-combo) for details."
 
 `pyfields` provides a simple and elegant way to define fields in python classes. With `pyfields` you explicitly define all aspects of a field (default value, type, documentation...) in a single place, and can refer to it from other places.
 
@@ -27,7 +28,9 @@ It provides **many optional features** that will make your object-oriented devel
 
  - initializing fields in your *constructor* is very easy and highly customizable
 
-If your first reaction is "what about `attrs` / `dataclasses` / `pydantic` / `characteristic` / `traits` / `traitlets` / `autoclass` / ...", please have a look [here](why.md).
+Finally, it offers an API that other libraries can leverage to get the list of fields. For example `autoclass` now leverages `pyfields` to automatically add hash/dict/eq/repr to your class.
+
+If your first reaction is "what about `attrs` / `dataclasses` / `pydantic` / `characteristic` / `traits` / `traitlets` / ...", please have a look [here](why.md).
 
 
 ## Installing
@@ -603,6 +606,14 @@ Note on the order of arguments in the resulting `__init__` signature: as you can
 
 ### 3. Misc.
 
+#### API
+
+`pyfields` offers an API so that other libraries can inspect the fields: `get_fields`, `yield_fields`, `has_fields`, `get_field`. See [API reference](https://smarie.github.io/python-pyfields/api_reference/#api) for details.
+
+#### hash, dict, eq, repr 
+
+`autoclass` is now compliant with `pyfields`. So you can use `@autoclass`, or `@autorepr`, `@autohash`, `@autodict`... on the decorated class. That way, your fields definition is directly reused for most of the class behaviour. See [here](https://smarie.github.io/python-autoclass/#pyfields-combo) for details.
+
 #### Slots
 
 You can use `pyfields` if your class has `__slots__`. You will simply have to use an underscore in the slot name corresponding to a field: `_<field_name>`. For example:

pyfields/helpers.py

@@ -51,6 +51,7 @@ def yield_fields(cls,
                  _auto_fix_fields=False   # type: bool
                  ):
     """
+    Similar to `get_fields` but as a generator.
 
     :param cls:
     :param include_inherited:
@@ -125,7 +126,9 @@ def has_fields(cls,
                include_inherited=True  # type: bool
                ):
     """
-    Returns True if class `cls` defines at least one `pyfields` field
+    Returns True if class `cls` defines at least one `pyfields` field.
+    If `include_inherited` is `True` (default), the method will return `True` if at least a field is defined in the
+    class or one of its ancestors. If `False`, the fields need to be defined on the class itself.
 
     :param cls:
     :param include_inherited:
@@ -145,6 +148,9 @@ def get_fields(cls,
     """
     Utility method to collect all fields defined in a class, including all inherited or not.
 
+    By default duplicates are removed and ancestor fields are included and appear first. If a field is overridden,
+    it will appear at the position of the overridden field in the order.
+
     :param cls:
     :param include_inherited:
     :param remove_duplicates: