Get the current settings of the model. The keys depend on the type of
        model.

        Returns
        -------
        out : list
            A list of fields that can be queried using the ``get`` method.
359169
def _list_fields(self):
        

        response = self.__proxy__.list_fields()
        return [s for s in response['value'] if not s.startswith("_")]
892990
def get_keys(self, models, key=None):
        
        return list(set(map(lambda value: value.get_attribute(key) if key else value.get_key(), models)))
1186081
def get_generic_fields():
    """"""
    generic_fields = []
    for model in apps.get_models():
        for field_name, field in model.__dict__.items():
            if isinstance(field, GenericForeignKey):
                generic_fields.append(field)
    return generic_fields
134061
def get_field_mapping(self):
        
        fields = {}
        values = {}
        for tab in self.tabs:
            parameter_values = tab.get_parameter_value()
            fields.update(parameter_values['fields'])
            values.update(parameter_values['values'])
        return {
            'fields': fields,
            'values': values
        }
494126
def params(self):
        
        params = odict([])
        for key,model in self.models.items():
            params.update(model.params)
        return params
1360806
def _get_choices(self):
        
        if self._overridden_choices:
            # Note: choices is a property on Field bound to _get_choices().
            return self._choices
        else:
            menus = getattr(settings, "PAGE_MENU_TEMPLATES", [])
            return (m[:2] for m in menus)
1032728
async def get_settings(self) -> List[SettingsEntry]:
        
        settings = await self.request_settings_tree()
        return [SettingsEntry.make(**x) for x in settings["settings"]]
470609
def _get_related_fields(self, model):
        ""
        reverse_fk = self._get_all_related_objects(model)
        reverse_m2m = self._get_all_related_many_to_many_objects(model)

        fields = tuple(reverse_fk + reverse_m2m)
        names = tuple([x.get_accessor_name() for x in fields])

        return {
            ':related': dict(list(zip(names, fields))),
        }
83625
def settings(self):
        """"""
        if not self.__settings:
            self.__settings = self.request('get', 'settings').json()
        return self.__settings
1063458
def get_meta_fields(self, fields, kwargs={}):
        '''
        
        '''
        fields = to_list(fields)
        meta = self.get_meta()
        return {field: meta.get(field) for field in fields}
353528
def get_fields(self):
        
        result = [key for key in self.__original_data__.keys()
                  if key not in self.__deleted_fields__]
        result.extend([key for key in self.__modified_data__.keys()
                       if key not in result and key not in self.__deleted_fields__])

        return result
1361865
def _key(self):
        
        return (
            self._name,
            self._field_type.upper(),
            self._mode.upper(),
            self._description,
            self._fields,
        )
1177309
def get_fields(self):
        
        for c in self.classes.values():
            for f in c.get_fields():
                yield f
285062
def model_getattr():
    

    def model_getattr(_value, context, **_params):
        value = getattr(context["model"], context["key"])
        return _attr(value)

    return model_getattr
721348
def _get_concrete_fields_with_model(self):
        
        return [
            (f, f.model if f.model != self.model else None)
            for f in self.model._meta.get_fields()
            if f.concrete
            and (
                not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)
            )
        ]
1091470
def keys(self):
        
        keys = []
        for val in self.form.scales.values():
            keys += val.dtype.fields.keys()
        return keys
426300
def get_fields(cls):
        
        fields = {}
        for field_name in dir(cls):
            if isinstance(getattr(cls, field_name), Field):
                field = getattr(cls, field_name)
                field_name = field.field_name or field_name
                fields[field_name] = field
        return fields