def METHOD_NAME(
    minion_id,  # pylint: disable=W0613
    pillar,  # pylint: disable=W0613
    pillar_name,
    project_path,
    settings_module,
    django_app,
    env=None,
    env_file=None,
    *args,  # pylint: disable=W0613
    **kwargs
):  # pylint: disable=W0613
    """
    Connect to a Django database through the ORM and retrieve model fields
    :type pillar_name: str
    :param pillar_name: The name of the pillar to be returned
    :type project_path: str
    :param project_path: The full path to your Django project (the directory
        manage.py is in)
    :type settings_module: str
    :param settings_module: The settings module for your project. This can be
        found in your manage.py file
    :type django_app: str
    :param django_app: A dictionary containing your apps, models, and fields
    :type env: str
    :param env: The full path to the virtualenv for your Django project
    :type env_file: str
    :param env_file: An optional bash file that sets up your environment. The
        file is run in a subprocess and the changed variables are then added
    """
    if not os.path.isdir(project_path):
        log.error("Django project dir: '%s' not a directory!", project_path)
        return {}
    if HAS_VIRTUALENV and env is not None and os.path.isdir(env):
        for path in virtualenv.path_locations(env):
            if not os.path.isdir(path):
                log.error("Virtualenv %s not a directory!", path)
                return {}
        # load the virtualenv first
        sys.path.insert(
            0, os.path.join(virtualenv.path_locations(env)[1], "site-packages")
        )
    # load the django project
    sys.path.append(project_path)
    os.environ["DJANGO_SETTINGS_MODULE"] = settings_module
    if env_file is not None:
        import subprocess
        base_env = {}
        proc = subprocess.Popen(["bash", "-c", "env"], stdout=subprocess.PIPE)
        for line in proc.stdout:
            (key, _, value) = salt.utils.stringutils.to_str(line).partition("=")
            base_env[key] = value
        command = ["bash", "-c", "source {} && env".format(env_file)]
        proc = subprocess.Popen(command, stdout=subprocess.PIPE)
        for line in proc.stdout:
            (key, _, value) = salt.utils.stringutils.to_str(line).partition("=")
            # only add a key if it is different or doesn't already exist
            if key not in base_env or base_env[key] != value:
                os.environ[key] = value.rstrip("\n")
                log.debug(
                    "Adding %s = %s to Django environment", key, value.rstrip("\n")
                )
    try:
        # pylint: disable=no-name-in-module
        from django.db.models.loading import get_model
        # pylint: enable=no-name-in-module
        django_pillar = {}
        for proj_app, models in django_app.items():
            _, _, app = proj_app.rpartition(".")
            django_pillar[app] = {}
            for model_name, model_meta in models.items():
                model_orm = get_model(app, model_name)
                if model_orm is None:
                    raise salt.exceptions.SaltException(
                        "Django model '{}' not found in app '{}'.".format(
                            app, model_name
                        )
                    )
                pillar_for_model = django_pillar[app][model_orm.__name__] = {}
                name_field = model_meta["name"]
                fields = model_meta["fields"]
                if "filter" in model_meta:
                    qs = model_orm.objects.filter(**model_meta["filter"]).values(
                        *fields
                    )
                else:
                    qs = model_orm.objects.values(*fields)
                for model in qs:
                    # Check that the human-friendly name given is valid (will
                    # be able to pick up a value from the query) and unique
                    # (since we're using it as the key in a dictionary)
                    if name_field not in model:
                        raise salt.exceptions.SaltException(
                            "Name '{}' not found in returned fields.".format(name_field)
                        )
                    if model[name_field] in pillar_for_model:
                        raise salt.exceptions.SaltException(
                            "Value for '{0}' is not unique: {0}".format(
                                model[name_field]
                            )
                        )
                    pillar_for_model[model[name_field]] = model
        return {pillar_name: django_pillar}
    except ImportError as e:
        log.error("Failed to import library: %s", e)
        return {}
    except Exception as e:  # pylint: disable=broad-except
        log.error("Failed on Error: %s", e)
        log.debug("django_orm traceback", exc_info=True)
        return {}