First real commit

Author: secnot

.gitignore

@@ -0,0 +1,63 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Vim temp files
+*~
+*.swp
+*.swo
+

MANIFEST.in

@@ -0,0 +1 @@
+

README.md

@@ -1,2 +1,116 @@
 # django-param-field
-A Django model field that uses a DSL to define, generate, and validate, custom forms
+
+A Django model field that uses a DSL to define, generate, and validate, custom forms.
+
+After reading this [fantastic presentation](http://es.slideshare.net/Siddhi/creating-domain-specific-languages-in-python)
+on how flexible can be a DSL to generate forms, I created a django implementation for
+some of my projects.
+
+
+## Requirement
+
+It has been tested on
+
+* Python 3
+* Django 1.9, 1.10
+
+
+## Installation
+
+For now:
+
+```bash
+$ python setup.py install
+```
+
+And pypi as soon as it is available
+
+```bash
+$ pip intall django-param-field
+```
+
+## Usage
+
+Add the param_field to INSTALLED_APPS
+
+```python
+# settings.py
+INSTALLED_APPS = [
+	...
+	'param_field',
+]
+```
+
+Add the field to your model:
+
+```python
+from djang.db import models
+from param_field import ParamField, ParamDict
+
+class CustomProduct(models.Model):
+	name = models.CharField(max_length=44)
+	...
+	params = ParamField(blank=True, max_length=3000)
+```
+
+Now that you have a working model create a new one, and add the
+parameters that it will accept:
+
+```python
+params = """
+	width: Dimmension-> max:50.0 min:5.0
+	height: Dimmension-> max:40.0 min:3.0"""
+
+CustomProduct.objects.create(
+	name='Custom wooden box",
+	parms=parms)
+```
+
+
+The formview handling this parameters, once it has retrieved the model,
+
+```python
+from django.shortcuts import render, get_object_or_404
+from django.views.generic import FormView
+from django import forms
+from .models import CustomProduct
+
+class CustomProductFormView(FormView):
+	template_name = 'product_form.html'
+	form_class = forms.Form
+
+	def dispatch(self, request, *args, **kwargs):
+		"""Find requested CustomProduct it's needed both in post and get 
+		request so the form can be genereted"""
+		pk = self.kwargs['pk']
+		self.product = get_object_or_404(CustomProduct, pk=pk)
+		return super().dispatch(request, *args, **kwargs)
+	
+    def get_context_data(self, **kwargs):
+		"""Send product info to template"""
+        context = super().get_context_data(**kwargs)
+        context['product'] = self.product
+        return context
+
+	def get_form(self, form_class=None):
+		"""Generate """
+		return self.product.params.form(**self.get_form_kwargs())
+
+	def form_valid(self, form):
+		"""Do what ever you want with the form, at this point it's a
+		validated django form like any other"""
+		custom_parameters = form.cleaned_data.copy()
+		...
+```
+
+Available parameters ....
+
+## Testing
+
+Once the app has been added to settings.py, you can run the tests with:
+
+```bash
+$ python manage.py test paramfield
+```
+
+

param_field/__init__.py

@@ -0,0 +1,2 @@
+from .models import ParamField
+from .params import ParamDict

param_field/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

param_field/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class ParamFieldConfig(AppConfig):
+    name = 'param_field'

param_field/fields.py

@@ -0,0 +1,6 @@
+from django.db import models
+from django import forms
+from django.utils.translation import ugettext_lazy as _
+from django.core.exceptions import ObjectDoesNotExist
+
+

param_field/forms.py

@@ -0,0 +1,145 @@
+from django import forms
+from .validators import *
+from .params import *
+
+
+class ForeignKeyField(forms.ModelChoiceField):
+    pass
+
+class ForeignKeyChoiceField(forms.ChoiceField):
+    pass
+
+class GeneratorField(forms.CharField):   
+    def to_python(self, value):
+        """Convert part generator slug"""
+        from .models import PartGenerator
+        try:
+            obj = PartGenerator.objects.get(slug=value)
+            return obj
+        except (ValueError, TypeError, ObjectDoesNotExist):
+            raise forms.ValidationError(
+                _("Unknown generator %(value)s"),
+                params={'value': value})
+
+
+
+
+FORM_FIELD_CLASS = {
+    BoolParam: forms.BooleanField,
+    TextParam: forms.CharField,
+    TextAreaParam: forms.CharField,
+    IntegerParam: forms.IntegerField,
+    DecimalParam: forms.DecimalField,
+    DimmensionParam: forms.DecimalField,
+    GeneratorParam: ForeignKeyField,
+    FileParam: ForeignKeyField,
+    ImageParam: ForeignKeyField,
+}
+
+
+def expand_name(name):
+    """Convert param  name string from 'this_is_a_name' to 'This is a name' so
+    it can be used as the a field label
+    
+    Arguments:
+        -name (string):
+    Returns:
+        string
+    """
+    chars = '*+-_=,;.:\\/[]{}()<>#@$%&'
+    text = name.lower()
+    for c in chars:
+        text = text.replace(c, ' ')
+    text = text[0].upper() + text[1:]
+    return text
+
+
+
+def ForeignKeyFieldFactory(param, name):
+    """Form field factory for all params using one"""
+    choices = param.get_choices()
+    if choices:
+        # Construct a query that returns the models present in choices.
+        choices = [getattr(c, param.model_field) for c in choices]
+        query_args = {param.model_field+'__in': choices_field}
+        query = param.model_class.objects.filter(query_args)
+    else:
+        query = param.model_class.objects.all()
+
+    field_args = {
+        'help_text': param.help_text or None,
+        'label': param.label or expand_name(name),
+        'initial': param.default,
+        'required': param.default is None,
+        'queryset': query}
+
+    return forms.ModelChoiceField(**field_args)
+
+
+def StdFieldFactory(param, name):
+    """Form field  factory for fields using standard fields, that is:
+    Bool, Text, TextArea, Integer, Decimal, Dimmension"""
+    field_args = {
+        'help_text': param.help_text or None,
+        'label': param.label or expand_name(name),
+        'initial': param.default,
+        'required': param.default is None,
+        'validators': [ParamFormFieldValidator(param),]}
+
+    # Generate correct Field type or ChoiceField
+    choices = param.get_choices()
+    if choices:
+        field_args['coerce'] = param.native_type
+        field_args['choices'] = choices
+        field_args.pop('validators', None)
+        return forms.TypedChoiceField(**field_args)
+    else:
+        return FORM_FIELD_CLASS[type(param)](**field_args)
+
+
+def ParamFieldFactory(param, name):
+    field_class = FORM_FIELD_CLASS[type(param)]
+    if field_class == ForeignKeyField:
+        return ForeignKeyFieldFactory(param, name)
+    else:
+        return StdFieldFactory(param, name)
+
+
+class ParamInputForm(forms.Form):
+    """
+    Form with fields for the parametes of a PartGenerator, can
+    be used to validate inputs
+   
+    Arguments:
+        - params: ParamDict
+
+    Examples: 
+        https://jacobian.org/writing/dynamic-form-generation/
+        http://stackoverflow.com/questions/5871730/need-a-minimal-django-file-upload-example
+    """
+    def __init__(self, *args, **kwargs):
+        """
+        Argument:
+            part_gen (PartGenerator): Form's part generator instance
+
+        """
+        self._params = kwargs.pop('params')
+        super(ParamInputForm, self).__init__(*args, **kwargs)
+       
+        # Add all visible fields from ParamDict to the form
+        for name, param in self._params.items():
+            if not param.visible or not isinstance(param, Param):
+                continue
+            self.fields[name] = ParamFieldFactory(param, name)
+
+    def clean(self):
+        # When a form's non-string and non-required field is not supplied by
+        # the user, None is asigned by default. Here all those fields are 
+        # removed after validation so the default value for the parameter
+        # is used by PartGenerator.
+        cd = dict((k, v) for k, v in self.cleaned_data.items() if v is not None) 
+        return self.cleaned_data
+        self.cleaned_data = cd
+        return self.cleaned_data
+
+

param_field/limits.py

@@ -0,0 +1,10 @@
+from decimal import Decimal
+
+INT_MAX = 999999
+INT_MIN = -999999
+REAL_MAX = Decimal("999999.9999") 
+REAL_MIN = Decimal("-999999.9999")
+STRING_MAX_LENGTH = 300
+LABEL_MAX_LENGTH = 40
+HELP_TEXT_MAX_LENGTH = 200
+