code: def from_form(
      form,  # type: Type[dm.Model]
      form_kwargs=None,  # type: dict
      **field_strategies,  # type: Union[st.SearchStrategy[Any], InferType]
  ):
      # type: (...) -> st.SearchStrategy[Any]
      """Return a strategy for examples of ``form``.
  
      ``form`` must be an subclass of :class:`~django:django.forms.Form`.
      Strategies for fields may be passed as keyword arguments, for example
      ``is_staff=st.just(False)``.
  
      Hypothesis can often infer a strategy based the field type and validators,
      and will attempt to do so for any required fields.  No strategy will be
      inferred for a disabled field or field for which a keyword argument
      is passed to ``from_form()``.
  
      This function uses the fields of an unbound ``form`` instance to determine
      field strategies, any keyword arguments needed to instantiate the unbound
      ``form`` instance can be passed into ``from_form()`` as a dict with the
      keyword ``form_kwargs``. E.g.::
  
          shop_strategy = from_form(Shop, form_kwargs={"company_id": 5})
  
      Like for :func:`~hypothesis.strategies.builds`, you can pass
      :obj:`~hypothesis.infer` as a keyword argument to infer a strategy for
      a field which has a default value instead of using the default.
      """
      # currently unsupported:
      # ComboField
      # FilePathField
      # FileField
      # ImageField
      form_kwargs = form_kwargs or {}
      if not issubclass(form, df.BaseForm):
          raise InvalidArgument(
              "form=%r must be a subtype of Form" % (form,)
          )
  
      # Forms are a little bit different from models. Model classes have
      # all their fields defined, whereas forms may have different fields
      # per-instance. So, we ought to instantiate the form and get the
      # fields from the instance, thus we need to accept the kwargs for
      # instantiation as well as the explicitly defined strategies
  
      unbound_form = form(**form_kwargs)
      fields_by_name = {}
      for name, field in unbound_form.fields.items():
          if isinstance(field, df.MultiValueField):
              # PS: So this is a little strange, but MultiValueFields must
              # have their form data encoded in a particular way for the
              # values to actually be picked up by the widget instances'
              # ``value_from_datadict``.
              # E.g. if a MultiValueField named 'mv_field' has 3
              # sub-fields then the ``value_from_datadict`` will look for
              # 'mv_field_0', 'mv_field_1', and 'mv_field_2'. Here I'm
              # decomposing the individual sub-fields into the names that
              # the form validation process expects
              for i, _field in enumerate(field.fields):
                  fields_by_name["%s_%d" % (name, i)] = _field
          else:
              fields_by_name[name] = field
      for name, value in sorted(field_strategies.items()):
          if value is infer:
              field_strategies[name] = from_field(fields_by_name[name])
  
      for name, field in sorted(fields_by_name.items()):
          if name not in field_strategies and not field.disabled:
              field_strategies[name] = from_field(field)
  
      return _forms_impl(
          st.builds(
              partial(form, **form_kwargs),
              data=st.fixed_dictionaries(field_strategies),  # type: ignore
          )
      )
  
imports: from __future__ import absolute_import, division, print_function
  import unittest
  from functools import partial
  import django.db.models
  import django.forms
  import django.test
  from django.core.exceptions import ValidationError
  from django.db import IntegrityError
  import hypothesis.strategies._internal.core
  from hypothesis import reject
  from hypothesis.errors import InvalidArgument
  from hypothesis.extra.django._fields import from_field
  from hypothesis.utils.conventions import infer
label_desc: Use image node_id 3 for calling a global function with example usage: from_form(form, form_kwargs) and returns: _forms_impl