django.forms.IntegerField

Here are the examples of the python api django.forms.IntegerField taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

68 Examples 7

Page 1 Selected Page 2

Example 1

Project: django-salmonella Source File: filters.py
    def __init__(self, rel, admin_site, field_name, **kwargs):
        """Construct field for given field rel."""
        super(SalmonellaFilterForm, self).__init__(**kwargs)

        self.fields['%s' % field_name] = forms.IntegerField(
            label='', widget=SalmonellaIdWidget(
                rel=rel, admin_site=admin_site), required=False)

Example 2

Project: django-url-filter Source File: test_sqlalchemy.py
Function: test_get_filters_with_many_to_many_relations
    def test_get_filters_with_many_to_many_relations(self):
        class ArticleFilterSet(SQLAlchemyModelFilterSet):
            class Meta(object):
                model = M2MArticle

        filters = ArticleFilterSet().get_filters()

        assert set(filters.keys()) == {
            'id', 'headline', 'publications',
        }
        assert set(filters['publications'].filters.keys()) == {
            'id', 'title',
        }

        assert isinstance(filters['id'], Filter)
        assert isinstance(filters['id'].form_field, forms.IntegerField)
        assert isinstance(filters['headline'], Filter)
        assert isinstance(filters['headline'].form_field, forms.CharField)
        assert isinstance(filters['publications'], SQLAlchemyModelFilterSet)

Example 3

Project: django-mysql Source File: test_forms.py
    def test_to_python_no_leading_commas(self):
        field = SimpleSetField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean(',1')
        assert (
            excinfo.value.messages[0] ==
            'No leading, trailing, or double commas.'
        )

Example 4

Project: ocf Source File: modelfields.py
Function: form_field
    def formfield(self, **kwargs):
        defaults = {'form_class': forms.IntegerField,
                    'max_value': self.max_value,
                    'min_value': self.min_value,
                    }
        defaults.update(kwargs)
        return super(LimitedIntegerField, self).formfield(**defaults)

Example 5

Project: django-mysql Source File: test_forms.py
    def test_to_python_duplicates_not_allowed(self):
        field = SimpleSetField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('1,1')
        assert (
            excinfo.value.messages[0] ==
            "Duplicates are not supported. '1' appears twice or more."
        )

Example 6

Project: django-mysql Source File: test_forms.py
    def test_to_python_no_leading_commas(self):
        field = SimpleListField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean(',1')
        assert (
            excinfo.value.messages[0] ==
            'No leading, trailing, or double commas.'
        )

Example 7

Project: django-url-filter Source File: test_django.py
Function: test_get_filters_with_reverse_many_to_many_relations
    def test_get_filters_with_reverse_many_to_many_relations(self):
        class PublicationFilterSet(ModelFilterSet):
            class Meta(object):
                model = Publication

        filters = PublicationFilterSet().get_filters()

        assert set(filters.keys()) == {
            'id', 'title', 'articles',
        }
        assert set(filters['articles'].filters.keys()) == {
            'id', 'headline',
        }

        assert isinstance(filters['id'], Filter)
        assert isinstance(filters['id'].form_field, forms.IntegerField)
        assert isinstance(filters['title'], Filter)
        assert isinstance(filters['title'].form_field, forms.CharField)
        assert isinstance(filters['articles'], ModelFilterSet)

Example 8

Project: django-mongoforms Source File: fields.py
    def generate_intfield(self, field_name, field, label):
        return forms.IntegerField(
            label=label,
            required=field.required,
            min_value=field.min_value,
            max_value=field.max_value,
            initial=field.default)

Example 9

Project: django-mongoengine Source File: djangoflavor.py
Function: form_field
    def formfield(self, **kwargs):
        defaults = {
            'form_class': forms.IntegerField,
        }
        defaults.update(kwargs)
        return super(IntField, self).formfield(**defaults)

Example 10

Project: wagtail Source File: field_block.py
Function: init
    def __init__(self, required=True, help_text=None, min_value=None,
                 max_value=None, **kwargs):
        self.field = forms.IntegerField(
            required=required,
            help_text=help_text,
            min_value=min_value,
            max_value=max_value
        )
        super(IntegerBlock, self).__init__(**kwargs)

Example 11

Project: django-rest-framework-braces Source File: test_serializer_form.py
    def test_get_form_fields_from_serializer(self):
        fields = SerializerFormMeta.get_form_fields_from_serializer(
            (object,), mock.Mock(serializer=TestSerializer,
                                 fields=['foo', 'bar'],
                                 exclude=['exclude'],
                                 field_mapping={})
        )

        self.assertSetEqual(set(fields.keys()), {'bar'})
        self.assertIsInstance(fields['bar'], forms.IntegerField)

Example 12

Project: wagtail Source File: tests.py
    def test_focal_point_fields(self):
        form = get_image_form(WagtailImage)

        self.assertIsInstance(form.base_fields['focal_point_x'], forms.IntegerField)
        self.assertIsInstance(form.base_fields['focal_point_y'], forms.IntegerField)
        self.assertIsInstance(form.base_fields['focal_point_width'], forms.IntegerField)
        self.assertIsInstance(form.base_fields['focal_point_height'], forms.IntegerField)

        self.assertIsInstance(form.base_fields['focal_point_x'].widget, forms.HiddenInput)
        self.assertIsInstance(form.base_fields['focal_point_y'].widget, forms.HiddenInput)
        self.assertIsInstance(form.base_fields['focal_point_width'].widget, forms.HiddenInput)
        self.assertIsInstance(form.base_fields['focal_point_height'].widget, forms.HiddenInput)

Example 13

Project: django-surveys Source File: models.py
Function: get_form_field
    def get_form_field(self):
        if self.answer_type == "capt":
            from captcha.fields import CaptchaField
            return CaptchaField

        from widgets import TextField
        fields = {
            'text': TextField,
            'int': forms.IntegerField,
            'bool': forms.BooleanField,
            'choi': forms.ChoiceField,
            'many': forms.MultipleChoiceField,
            }
        return fields[self.answer_type]

Example 14

Project: django-dynamic-rules Source File: test_dynamic_actions.py
    @mock.patch.object(forms.IntegerField, 'to_python')
    def test_action_class_gets_attribute_from_rule_model_dynamic_fields(self, to_python):
        self.rule_model.dynamic_fields = {'amount': '300'}
        action = TestAction(self.rule_model, self.trigger_model)

        amount = action.amount

        to_python.assert_called_once_with('300')
        self.assertEqual(to_python.return_value, amount)

Example 15

Project: django-url-filter Source File: test_sqlalchemy.py
Function: test_get_filters_with_reverse_many_to_many_relations
    def test_get_filters_with_reverse_many_to_many_relations(self):
        class PublicationFilterSet(SQLAlchemyModelFilterSet):
            class Meta(object):
                model = Publication

        filters = PublicationFilterSet().get_filters()

        assert set(filters.keys()) == {
            'id', 'title', 'articles',
        }
        assert set(filters['articles'].filters.keys()) == {
            'id', 'headline',
        }

        assert isinstance(filters['id'], Filter)
        assert isinstance(filters['id'].form_field, forms.IntegerField)
        assert isinstance(filters['title'], Filter)
        assert isinstance(filters['title'].form_field, forms.CharField)
        assert isinstance(filters['articles'], SQLAlchemyModelFilterSet)

Example 16

Project: django-url-filter Source File: test_django.py
Function: test_get_filters_no_relations_place
    def test_get_filters_no_relations_place(self):
        class PlaceFilterSet(ModelFilterSet):
            class Meta(object):
                model = Place
                allow_related = False
                allow_related_reverse = False

        filters = PlaceFilterSet().get_filters()

        assert set(filters.keys()) == {
            'id', 'name', 'address',
        }

        assert isinstance(filters['id'], Filter)
        assert isinstance(filters['id'].form_field, forms.IntegerField)
        assert isinstance(filters['name'], Filter)
        assert isinstance(filters['name'].form_field, forms.CharField)
        assert isinstance(filters['address'], Filter)
        assert isinstance(filters['address'].form_field, forms.CharField)

Example 17

Project: django-mysql Source File: test_forms.py
    def test_to_python_no_double_commas(self):
        field = SimpleListField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('1,,2')
        assert (
            excinfo.value.messages[0] ==
            'No leading, trailing, or double commas.'
        )

Example 18

Project: django-url-filter Source File: test_sqlalchemy.py
Function: test_get_filters_no_relations_place
    def test_get_filters_no_relations_place(self):
        class PlaceFilterSet(SQLAlchemyModelFilterSet):
            class Meta(object):
                model = Place
                allow_related = False

        filters = PlaceFilterSet().get_filters()

        assert set(filters.keys()) == {
            'id', 'name', 'address',
        }

        assert isinstance(filters['id'], Filter)
        assert isinstance(filters['id'].form_field, forms.IntegerField)
        assert isinstance(filters['name'], Filter)
        assert isinstance(filters['name'].form_field, forms.CharField)
        assert isinstance(filters['address'], Filter)
        assert isinstance(filters['address'].form_field, forms.CharField)

Example 19

Project: django-url-filter Source File: test_django.py
    def test_get_filters_no_relations_place_exclude_address(self):
        class PlaceFilterSet(ModelFilterSet):
            class Meta(object):
                model = Place
                exclude = ['address']
                allow_related = False
                allow_related_reverse = False

        filters = PlaceFilterSet().get_filters()

        assert set(filters.keys()) == {
            'id', 'name',
        }

        assert isinstance(filters['id'], Filter)
        assert isinstance(filters['id'].form_field, forms.IntegerField)
        assert isinstance(filters['name'], Filter)
        assert isinstance(filters['name'].form_field, forms.CharField)

Example 20

Project: django-url-filter Source File: test_filters.py
    def test_clean_value(self):
        f = Filter(form_field=forms.IntegerField())

        assert f.clean_value('5', 'exact') == 5

        with pytest.raises(forms.ValidationError):
            f.clean_value('a', 'exact')

Example 21

Project: django-mysql Source File: test_forms.py
    def test_to_python_no_double_commas(self):
        field = SimpleSetField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('1,,2')
        assert (
            excinfo.value.messages[0] ==
            'No leading, trailing, or double commas.'
        )

Example 22

Project: django-mysql Source File: test_forms.py
    def test_to_python_base_field_does_not_validate(self):
        field = SimpleSetField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('a,b,9')
        assert (
            excinfo.value.messages[0] ==
            'Item 1 in the set did not validate: Enter a whole number.'
        )

Example 23

Project: django-mysql Source File: test_forms.py
    def test_to_python_no_trailing_commas(self):
        field = SimpleSetField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('1,')
        assert (
            excinfo.value.messages[0] ==
            'No leading, trailing, or double commas.'
        )

Example 24

Project: django-mysql Source File: test_forms.py
    def test_to_python_two_duplicates_not_allowed(self):
        field = SimpleSetField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('1,2,1,2')
        assert (
            excinfo.value.messages[0] ==
            "Duplicates are not supported. '1' appears twice or more."
        )
        assert (
            excinfo.value.messages[1] ==
            "Duplicates are not supported. '2' appears twice or more."
        )

Example 25

Project: dirigible-spreadsheet Source File: test_forms.py
    def test_initialisation(self):
        import_form = ImportCSVForm()
        self.assertTrue(all(map(lambda args : isinstance(*args),[
            (import_form.fields['column'], forms.IntegerField),
            (import_form.fields['row'], forms.IntegerField),
            (import_form.fields['file'], forms.FileField)])))

Example 26

Project: Adlibre-DMS Source File: forms_representator.py
def render_integer_field(counter, field_value, init_dict):
    """Form fields renderer for data type INTEGER

    @param counter: number of field in a form
    @param field_value: additional field data to render a field
    @param init_dict: is a set of optional initial values"""
    initial = None
    if unicode(counter) in init_dict and init_dict[unicode(counter)]:
        # Has initial value
        initial = init_dict[unicode(counter)]
    return forms.IntegerField(
        label=field_value["field_name"],
        help_text=field_value["description"],
        initial=initial
    )

Example 27

Project: django-sellmo Source File: types.py
Function: get_form_field
    def get_formfield(self, label, required, choices=None):
        field_cls = forms.IntegerField
        kwargs = {'label': label, 'required': required}
        if choices is not None:
            kwargs['choices'] = choices
            kwargs['coerce'] = int
            kwargs['empty_value'] = self.get_empty_value()
            field_cls = forms.TypedChoiceField
        return field_cls, [], kwargs

Example 28

Project: django-mysql Source File: test_forms.py
    def test_to_python_base_field_does_not_validate(self):
        field = SimpleListField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('a,b,9')
        assert (
            excinfo.value.messages[0] ==
            'Item 1 in the list did not validate: Enter a whole number.'
        )

Example 29

Project: django-rest-framework-braces Source File: test_form_serialzier.py
    def test_get_field_kwargs(self):
        serializer = self.serializer_class()
        form_field = forms.IntegerField(
            max_value=500,
            initial=100,
            required=True,
            validators=[mock.sentinel.validator],
        )

        kwargs = serializer._get_field_kwargs(form_field, fields.IntegerField)

        self.assertDictContainsSubset({
            'default': 100,
            'validators': [mock.sentinel.validator, mock.ANY],
        }, kwargs)
        self.assertNotIn('required', kwargs)

Example 30

Project: django-url-filter Source File: test_django.py
Function: test_get_filters_with_many_to_many_relations
    def test_get_filters_with_many_to_many_relations(self):
        class ArticleFilterSet(ModelFilterSet):
            class Meta(object):
                model = M2MArticle

        filters = ArticleFilterSet().get_filters()

        assert set(filters.keys()) == {
            'id', 'headline', 'publications',
        }
        assert set(filters['publications'].filters.keys()) == {
            'id', 'title',
        }

        assert isinstance(filters['id'], Filter)
        assert isinstance(filters['id'].form_field, forms.IntegerField)
        assert isinstance(filters['headline'], Filter)
        assert isinstance(filters['headline'].form_field, forms.CharField)
        assert isinstance(filters['publications'], ModelFilterSet)

Example 31

Project: simian Source File: djangoforms.py
Function: get_form_field
  def get_form_field(self, **kwargs):
    """Return a Django form field appropriate for an integer property.

    This defaults to an IntegerField instance.
    """
    defaults = {'form_class': forms.IntegerField}
    defaults.update(kwargs)
    return super(IntegerProperty, self).get_form_field(**defaults)

Example 32

Project: shuup Source File: product_list_modifiers.py
Function: get_admin_fields
    def get_admin_fields(self):
        default_fields = super(ProductPriceFilter, self).get_admin_fields()
        min_field = forms.IntegerField(
            label=_("Price range minimum"), min_value=0, required=False,
            help_text=_("Set minimum price for filter. First range will be from zero to this value.")
        )
        max_field = forms.IntegerField(
            label=_("Price range maximum"), min_value=0, required=False,
            help_text=_("Set maximum price for filter. Last range will include this value and above.")
        )
        range_step = forms.IntegerField(
            label=_("Price range step"), min_value=0, required=False,
            help_text=_("Set step for ranges. The second range is from min price to this value.")
        )
        return default_fields + [
            (self.range_min_key, min_field),
            (self.range_max_key, max_field),
            (self.range_size_key, range_step),
        ]

Example 33

Project: django-mongonaut Source File: widgets.py
def get_form_field_class(model_field):
    """Gets the default form field  for a mongoenigne field."""

    FIELD_MAPPING = {
        IntField: forms.IntegerField,
        StringField: forms.CharField,
        FloatField: forms.FloatField,
        BooleanField: forms.BooleanField,
        DateTimeField: forms.DateTimeField,
        DecimalField: forms.DecimalField,
        URLField: forms.URLField,
        EmailField: forms.EmailField
    }

    return FIELD_MAPPING.get(model_field.__class__, forms.CharField)

Example 34

Project: django-easymode Source File: formsets.py
Function: add_fields
    def add_fields(self, form, index):

        self._pk_field = self.model._meta.pk

        if form.is_bound:
            pk_value = form.instance.pk
        else:
            try:
                pk_value = self.get_queryset()[index].pk
            except IndexError:
                pk_value = None

        attrs = dict(app_label=self.model._meta.app_label, modelname=self.model.__name__.lower(), label=unicode(form.instance))
        form.fields[self._pk_field.name] = IntegerField( initial=pk_value, required=False, 
                                                         widget=RenderLink(attrs=attrs), label=_("Navigate to:"))

        BaseFormSet.add_fields(self, form, index)

Example 35

Project: django-twitter-stream Source File: fields.py
Function: form_field
    def formfield(self, **kwargs):
        defaults = {'min_value': 0,
                    'max_value': PositiveBigAutoField.MAX_BIGINT * 2 - 1,
                    'form_class': forms.IntegerField }
        defaults.update(kwargs)
        return super(PositiveBigAutoField, self).formfield(**defaults)

Example 36

Project: django-mysql Source File: test_forms.py
    def test_to_python_no_trailing_commas(self):
        field = SimpleListField(forms.IntegerField())
        with pytest.raises(exceptions.ValidationError) as excinfo:
            field.clean('1,')
        assert (
            excinfo.value.messages[0] ==
            'No leading, trailing, or double commas.'
        )

Example 37

Project: django-url-filter Source File: test_fields.py
    def test_init(self):
        field = MultipleValuesField(
            child=forms.IntegerField(),
            min_values=2,
            max_values=100,
            delimiter=';'
        )

        assert isinstance(field.child, forms.IntegerField)
        assert field.delimiter == ';'
        assert any((isinstance(i, MinLengthValidator) for i in field.many_validators))
        assert any((isinstance(i, MaxLengthValidator) for i in field.many_validators))

Example 38

Project: handy Source File: fields.py
    def formfield(self, **kwargs):
        if self.primary_key:
            return None
        defaults = {'form_class': forms.IntegerField, 'widget': forms.HiddenInput}
        defaults.update(kwargs)
        return models.Field.formfield(self, **defaults)

Example 39

Project: django-datatable Source File: forms.py
Function: init
    def __init__(self, data=None, *args, **kwargs):
        super(QueryDataForm, self).__init__(data, *args, **kwargs)
        for key in data.keys():
            if key.startswith("iSortCol"):
                self.fields[key] = forms.IntegerField()
            if key.startswith("sSortDir"):
                self.fields[key] = forms.CharField()

Example 40

Project: dj-dynamic-forms Source File: test_formfields.py
Function: test_options
    def test_options(self):
        metafield = MetaField('name', 'label')
        # This check implies, that neither Meta attributes starting with a _
        # not those part of the _exclude list are available
        self.assertEqual(metafield.options, {
            'max_length': [int, None, forms.IntegerField],
        })

Example 41

Project: django-api Source File: tests.py
    @override_settings(DEBUG=True)
    def test_api_accepts_decorator_debug(self):
        """
        Test the @api_accepts decorator (with DEBUG=True).
        """
        rf = RequestFactory()

        # Test that POSTs are validated.
        @api_accepts({
            'im_required': forms.IntegerField(),
        })
        def my_post_view(request, *args, **kwargs):
            self.assertIsInstance(request.POST['im_required'], int)
            return JsonResponseWithStatus('post called')

        request = rf.post('/post_success', data={'im_required': '10'})
        response = my_post_view(request)
        self.assertEquals(response.status_code, 200)
        response_json = json.loads(response.content)
        self.assertEquals(response_json['error_message'], 'post called')

        # Test that GETs are validated.
        @api_accepts({
            'im_required': forms.IntegerField(),
        })
        def my_get_view(request, *args, **kwargs):
            self.assertIsInstance(request.GET['im_required'], int)
            return JsonResponseWithStatus('get called')

        request = rf.get('/get_success', data={'im_required': '10'})
        response = my_get_view(request)
        self.assertEquals(response.status_code, 200)
        response_json = json.loads(response.content)
        self.assertEquals(response_json['error_message'], 'get called')

        # Test that POSTs are validated.
        @api_accepts({
            'im_required': forms.IntegerField(),
        })
        def my_failed_post_view(request, *args, **kwargs):
            return JsonResponseWithStatus('not called on failure')

        # Test that failed validation results in a 400 Bad Request when DEBUG
        # == True.
        request = rf.post('/post_failure', data={'hello': 'world'})
        response = my_failed_post_view(request)
        self.assertEquals(response.status_code, 400)

        # Test that Django models can be accepted by @api
        user = User.objects.create()
        @api_accepts({
            'im_required': forms.IntegerField(),
            'user': User(),
        })
        def model_view(request, *args, **kwargs):
            self.assertTrue(request.GET['user'].id == user.id)
            return JsonResponse()

        request = rf.get('/model_failure', data={'im_required': 10, 'user-id': 99999})
        response = model_view(request)
        self.assertEquals(response.status_code, 404)

        request = rf.get('/model_success', data={'im_required': 10, 'user-id': user.id})
        response = model_view(request)
        self.assertEquals(response.status_code, 200)

        # Test that datetime are handled by @api_accepts
        @api_accepts({
            'date_param': forms.DateField(),
            'datetime_param': forms.DateTimeField(input_formats=['%Y-%m-%dT%H:%M:%S']),
            'time_param': forms.TimeField(),
        })
        def datetime_view(request, *args, **kwargs):
            self.assertTrue(request.GET['date_param'], datetime.date(2010, 2, 17))
            self.assertTrue(request.GET['datetime_param'], datetime.datetime(2006, 11, 21, 16, 30))
            self.assertTrue(request.GET['time_param'], datetime.time(16, 30))
            return JsonResponse()
        request = rf.get('/datetime_success', data={
            'date_param': '2010-02-17',
            'datetime_param': '2006-11-21T16:30:00',
            'time_param': '16:30:00',
        })
        response = datetime_view(request)
        self.assertEquals(response.status_code, 200)

Example 42

Project: django-api Source File: tests.py
    @override_settings(DEBUG=False)
    def test_api_accepts_decorator(self):
        """
        Test that failures to validate with the @api_accepts decorator do not result in
        400 Bad Requests in production.

        This is a temporary measure to avoid breaking production as we apply
        this decorator to existing APIs.
        """
        original_log_level = logger.level
        logger.setLevel(1000)

        # Test that POSTs are validated.
        @api_accepts({
            'im_required': forms.IntegerField(),
        })
        def my_failed_post_view(request, *args, **kwargs):
            return JsonResponseWithStatus('still called on failure')

        rf = RequestFactory()
        request = rf.post('/post_failure', data={'hello': 'world'})
        response = my_failed_post_view(request)
        self.assertEquals(response.status_code, 200)
        response_json = json.loads(response.content)
        self.assertEquals(response_json['error_message'], 'still called on failure')
        logger.setLevel(original_log_level)

Example 43

Project: vumi-go Source File: forms.py
Function: add_fields
    def add_fields(self, form, index):
        super(BaseCreditLoadFormSet, self).add_fields(form, index)
        form.fields['credit_amount'] = forms.IntegerField()

Example 44

Project: shuup Source File: _attributes.py
Function: form_field
    def formfield(self, **kwargs):
        """
        Get a form field for this attribute.

        :param kwargs: Kwargs to pass for the form field class.
        :return: Form field.
        :rtype: forms.Field
        """
        kwargs.setdefault("required", False)
        kwargs.setdefault("label", self.safe_translation_getter("name", self.identifier))
        if self.type == AttributeType.INTEGER:
            return forms.IntegerField(**kwargs)
        elif self.type == AttributeType.DECIMAL:
            return forms.DecimalField(**kwargs)
        elif self.type == AttributeType.BOOLEAN:
            return forms.NullBooleanField(**kwargs)
        elif self.type == AttributeType.TIMEDELTA:
            kwargs.setdefault("help_text", "(as seconds)")
            # TODO: This should be more user friendly
            return forms.DecimalField(**kwargs)
        elif self.type == AttributeType.DATETIME:
            return forms.DateTimeField(**kwargs)
        elif self.type == AttributeType.DATE:
            return forms.DateField(**kwargs)
        elif self.type == AttributeType.UNTRANSLATED_STRING:
            return forms.CharField(**kwargs)
        elif self.type == AttributeType.TRANSLATED_STRING:
            # Note: this isn't enough for actually saving multi-language entries;
            #       the caller will have to deal with calling this function several
            #       times for that.
            return forms.CharField(**kwargs)
        else:
            raise ValueError("`formfield` can't deal with fields of type %r" % self.type)

Example 45

Project: django-easymode Source File: forms.py
Function: add_fields
    def add_fields(self, form, index):
        super(RecursiveInlineFormSet, self).add_fields(form, index)
        
        # get the primary key and it's options
        hidden_pk_field = form.fields[self._pk_field.name]
        options =  hidden_pk_field.queryset.model._meta
        
        # the only fields that must show is the primary key
        form._meta.fields = [self._pk_field.name]
        
        widget_attrs = {}
        
        # show the link widget if the item allready exists
        if hidden_pk_field.initial is not None: 
            widget_attrs['url'] = reverse('admin:%s_%s_change' % (options.app_label, options.object_name.lower()), args=[hidden_pk_field.initial])
            widget_attrs['label'] = 'Edit %s' % force_unicode(options.verbose_name)
            
        # if the parent model exists but the item doesn't show the add button
        elif self.instance.pk is not None:
            url = reverse('admin:%s_%s_add' % (options.app_label, options.object_name.lower()))
            widget_attrs['url'] = '%s?%s=%s' % (url, self.fk.name, self.instance.pk)
            widget_attrs['label'] = 'Add %s' % force_unicode(options.verbose_name)
            widget_attrs['popup'] = True
            
        # if the parent model does not exist use an empty link widget.
        else:
            widget_attrs['url'] = None
            widget_attrs['label'] = ''
        
        # turn the primary key into a field that displays a fieldset with a link
        form.fields[self._pk_field.name] = IntegerField(hidden_pk_field.queryset, 
            initial=hidden_pk_field.initial, required=False,
            widget=self.PRIMARY_KEY_WIDGET(attrs=widget_attrs)
        )

Example 46

Project: django-api Source File: tests.py
    @override_settings(DEBUG=True)
    def test_api_decorator_debug(self):
        """
        Test that the @api decorator (in debug mode)
        """
        @api({
            'accepts': {
                'im_required': forms.IntegerField(),
                'ok': forms.IntegerField(required=False),
            },
            'returns': {
                200: 'OK',
                403: 'Permission denied',
            },
        })
        def simple_view(request):
            if request.GET['ok']:
                return JsonResponse()
            else:
                return JsonResponseAccepted()  # Not declared in @api_returns

        rf = RequestFactory()
        request = rf.get('/simple_view', data={'im_required': '1', 'ok': '1'})
        response = simple_view(request)
        self.assertEquals(response.status_code, 200)

        # fail accepts
        request = rf.get('/simple_view', data={'ok': '1'})
        response = simple_view(request)
        self.assertEquals(response.status_code, 400)

        # fail returns
        request = rf.get('/simple_view', data={'im_required': '1'})
        response = simple_view(request)
        self.assertEquals(response.status_code, 400)

Example 47

Project: shuup Source File: typology.py
Function: get_field
    def get_field(self, **kwargs):
        return forms.IntegerField(**kwargs)

Example 48

Project: talk.org Source File: __init__.py
Function: form_field
    def formfield(self, **kwargs):
        defaults = {'form_class': forms.IntegerField}
        defaults.update(kwargs)
        return super(IntegerField, self).formfield(**defaults)

Example 49

Project: django-sellmo Source File: blocks.py
Function: init
    def __init__(self, required=True, help_text=None, min_value=None, max_value=None, **kwargs):
        self.field = forms.IntegerField(required=required, min_value=min_value, max_value=max_value, help_text=help_text)
        super(IntegerBlock, self).__init__(**kwargs)

Example 50

Project: django-autoreports Source File: fields.py
Function: get_basic_field_form
    def get_basic_field_form(self, form, field_name):
        return forms.IntegerField(label=self.get_verbose_name())
See More Examples - Go to Next Page
Page 1 Selected Page 2