Python base.factory函数代码示例

def array_with_array_with_array_with_leafs():
    form = factory("fieldset", name="yafowil.widget.array_with_array_with_array_with_leafs")
    value = [[["1", "2"], ["3"]], [["4", "5"]]]
    arr_1 = form["array_1"] = factory(
        "#array",
        value=value,
        props={"label": "Array 1", "help": "This is Array 1", "required": "Array 1 must not be empty"},
    )
    arr_2 = arr_1["array_2"] = factory(
        "help:error:array",
        props={"label": "Array 2", "help": "This is Array 2", "required": "Array 2 must not be empty"},
    )
    arr_3 = arr_2["array_3"] = factory(
        "help:error:array",
        props={"label": "Array 3", "help": "This is Array 3", "required": "Array 3 must not be empty"},
    )
    arr_3["textfield"] = factory(
        "#arrayfield:text",
        props={"label": "Text Field", "help": "This is the text field", "required": "Text Field is required"},
    )
    return {
        "widget": form,
        "doc": DOC_ARRAY_WITH_ARRAY_WITH_ARRAY_WITH_LEAFS,
        "title": "Single fields in 3-dimensional array",
    }

def image():
    name = 'yafowil.widget.image.image'
    image_name = name + '.jpg'
    image_path = os.path.join(runtime_images_dir(), image_name)
    def get_value(widget, data):
        image_value = UNSET
        if os.path.exists(image_path):
            image_data = read_image(name)
            image_value = {
                'file': StringIO(image_data),
                'mimetype': 'image/jpg',
            }
        return image_value
    def get_src(widget, data):
        if os.path.exists(image_path):
            return image_name
    form = factory('fieldset', name=name)
    form['image'] = factory('#field:image', value=get_value, props={
        'label': 'Image',
        'required': 'No Image uploaded',
        'maxsize': (1024, 768),
        'scales': {'default': (400, 400)},
        'src': get_src,
        'error.class': 'help-block',
    })
    return {
        'widget': form,
        'doc': DOC_IMAGE,
        'title': 'Image',
        'handler': save_image,
        'routes': {
            image_name: image_response,
        },
    }

    def form(self):
        form = factory('form',
            name='search',
            props={
                'action': self._form_action,
            })

        form['searchterm'] = factory(
            'field:label:error:text',
            props={
                'label': MessageFactory(u'Rechercher dans les projets:'),
                'field.class': 'myFieldClass',
                'text.class': 'myInputClass',
                'size': '20',
        })
        form['submit'] = factory(
            'field:submit',
            props={
                'label':  MessageFactory(u'Lancer la recherche'),
                'submit.class': '',
                'handler': self._form_handler,
                'action': 'search'
        })

        controller = Controller(form, self.request)
        return controller.rendered

 def test_compound_blueprint_value_via_compound(self):
     # Render Compound with values set via compound widget
     value = {
         'inner': 'Value 1 from parent',
         'inner2': 'Value 2 from parent',
     }
     compound = factory(
         'compound',
         name='COMPOUND',
         value=value)
     compound['inner'] = factory('text')
     compound['inner2'] = factory(
         'text',
         props={
             'required': True
         })
     self.check_output("""
     <div>
       <input class="text" id="input-COMPOUND-inner" name="COMPOUND.inner"
              type="text" value="Value 1 from parent"/>
       <input class="required text" id="input-COMPOUND-inner2"
              name="COMPOUND.inner2" required="required" type="text"
              value="Value 2 from parent"/>
     </div>
     """, fxml(tag('div', compound())))

 def prepare(self):
     if not readcookie(self.request):
         raise Redirect(self.context.absolute_url())
     checkout = self.form_context is CHECKOUT
     form_class = checkout and 'mode_edit' or 'mode_display'
     self.form = factory('#form', name='checkout', props={
         'action': self.form_action,
         'class_add': form_class})
     for fields_factory in self.provider_registry:
         fields_factory(self.context, self.request).extend(self.form)
     # checkout data input
     if checkout:
         self.form['checkout_back'] = factory('submit', props={
             'label': _('back', 'Back'),
             'action': 'checkout_back',
             'handler': None,
             'next': self.checkout_back,
             'skip': True})
         self.form['next'] = factory('submit', props={
             'label': _('next', 'Next'),
             'action': 'next',
             'handler': None,
             'next': self.checkout_summary})
     # checkout confirmation
     else:
         self.form['confirm_back'] = factory('submit', props={
             'label': _('back', 'Back'),
             'action': 'confirm_back',
             'handler': None,
             'next': self.confirm_back})
         self.form['finish'] = factory('submit', props={
             'label': _('finish', 'Order now'),
             'action': 'finish',
             'handler': self.finish,
             'next': self.checkout_done})

def index():
    #o = {}
    #o = WerkzeugRequestAdapter(request)
    # if request.method == 'POST':
    #     pass
    
    form = factory(u'form', name='helloworld', props={
        'action': url_for("index")})  # was app.config["URL"]

    form['hello'] = factory('field:label:error:text',
        value='preset value',
        props={
            'label': 'Enter some text',
            'required': 'Some Text is required in order to process'})

    form['file'] = factory('field:label:error:file', props={
        'label': 'File Upload',
        'required': 'File is required'})

    form['submit'] = factory('field:submit', props={
        'label': 'store value',
        'action': 'save',
        'handler': store,
        'next': next})
    
    #import pdb; pdb.set_trace() 
    controller = Controller(form, request)
    if controller.next:
        #redirect(controller.next)
        o = controller.next
    else:
        o = controller.rendered

    return render_template("index.html", session=session,o=o)

 def test_extract_dpi_max(self):
     # Maximum DPI
     image = factory(
         'image',
         name='image',
         props={
             'maxdpi': (60, 60)
         })
     request = {
         'image': {
             'file': StringIO(self.dummy_png),
             'mimetype': 'image/png'
         }
     }
     data = image.extract(request)
     self.assertEqual(
         data.errors,
         [ExtractionError('Image must have a maximum of 60 x 60 DPI')]
     )
     image = factory(
         'image',
         name='image',
         props={
             'maxdpi': (80, 80)
         })
     data = image.extract(request)
     self.assertEqual(data.errors, [])

 def test_extract_dpi_exact(self):
     # Exact DPI
     image = factory(
         'image',
         name='image',
         props={
             'mindpi': (60, 60),
             'maxdpi': (60, 60)
         })
     request = {
         'image': {
             'file': StringIO(self.dummy_png),
             'mimetype': 'image/png'
         }
     }
     data = image.extract(request)
     self.assertEqual(
         data.errors,
         [ExtractionError('Image must have a resolution of 60 x 60 DPI')]
     )
     image = factory(
         'image',
         name='image',
         props={
             'mindpi': (72, 72),
             'maxdpi': (72, 72)
         })
     data = image.extract(request)
     self.assertEqual(data.errors, [])

 def test_extract_size_exact(self):
     image = factory(
         'image',
         name='image',
         props={
             'minsize': (40, 40),
             'maxsize': (40, 40)
         })
     request = {
         'image': {
             'file': StringIO(self.dummy_png),
             'mimetype': 'image/png'
         }
     }
     data = image.extract(request)
     self.assertEqual(
         data.errors,
         [ExtractionError('Image must have a size of 40 x 40 pixel')]
     )
     image = factory(
         'image',
         name='image',
         props={
             'minsize': (50, 50),
             'maxsize': (50, 50)
         })
     data = image.extract(request)
     self.assertEqual(data.errors, [])

    def test_render_display(self):
        # Render in display mode
        form = factory(
            'form',
            name='myform',
            props={
                'action': 'myaction'
            })
        form['image'] = factory(
            'image',
            value={
                'file': StringIO(self.dummy_png),
                'mimetype': 'image/png'
            },
            props={
                'src': 'http://www.example.com/someimage.png',
                'alt': 'Alternative text'
            },
            mode='display')
        self.check_output("""
        <form action="myaction" enctype="multipart/form-data" id="form-myform"
              method="post" novalidate="novalidate">
          <img alt="Alternative text"
               src="http://www.example.com/someimage.png"/>
        </form>
        """, fxml(form()))

        # Rendering is skipped if no source
        form['image'].attrs['src'] = None
        self.check_output("""
        <form action="myaction" enctype="multipart/form-data"
              id="form-myform" method="post" novalidate="novalidate"/>
        """, fxml(form()))

 def test_render_with_preset_value_src_property_callable(self):
     # Src property can be callable
     form = factory(
         'form',
         name='myform',
         props={
             'action': 'myaction'
         })
     form['image'] = factory(
         'image',
         value={
             'file': StringIO(self.dummy_png),
             'mimetype': 'image/png'
         },
         props={
             'src': lambda w, d: 'http://www.example.com/otherimage.png',
             'alt': 'Alternative text'
         })
     self.check_output("""
     <form action="myaction" enctype="multipart/form-data" id="form-myform"
           method="post" novalidate="novalidate">
       <img alt="Alternative text" class="image-preview"
            id="image-preview-myform-image"
            src="http://www.example.com/otherimage.png?nocache=..."/>
       <input accept="image/*" class="image" id="input-myform-image"
              name="myform.image" type="file"/>
       ...
     </form>
     """, fxml(form()))

    def test_div_blueprint_compound_leaf(self):
        # Div blueprint as compound, but with ``leaf`` property set. Causes
        # ``hybrid_renderer`` and ``hybrid_extractor`` to skip auto delegating
        # to ``compound_renderer`` and ``compound_extractor``
        div = factory(
            'div',
            name='DIV_COMPOUND_LEAF',
            props={
                'leaf': True
            })
        div['inner'] = factory(
            'text',
            value='value1')
        div['inner2'] = factory(
            'text',
            value='value2',
            props={
                'required': True
            })
        self.assertEqual(div(), '<div></div>')

        data = div.extract({
            'DIV_COMPOUND_LEAF.inner': '1',
            'DIV_COMPOUND_LEAF.inner2': '2',
        })
        self.assertEqual(data.name, 'DIV_COMPOUND_LEAF')
        self.assertEqual(data.value, UNSET)
        self.assertEqual(data.extracted, UNSET)
        self.assertEqual(data.errors, [])
        self.assertEqual(data.keys(), [])

 def prepare(self):
     action = make_url(self.request, node=self.model, resource='login')
     form = factory(
         u'form',
         name='loginform',
         props={
             'action': action
         })
     form['user'] = factory(
         'field:label:error:text',
         props = {
             'required': 'No username given',
             'label': 'Username',
         })    
     form['password'] = factory(
         'field:label:*credentials:error:password',
         props = {
             'required': 'No password given',
             'label': 'Password',
         },
         custom = {
             'credentials': ([self.login], [], [], []),
         })
     form['login'] = factory(
         'submit',
         props = {
             'action': 'login',
             'expression': True,
             'handler': self.noop,
             'next': self.next,
             'label': 'Login',
         })
     self.form = form

 def test_render_table(self):
     form = factory(
         'form',
         name='myform',
         props={
             'action': 'myaction',
         })
     form['table'] = factory('table')
     form['table']['row1'] = factory('tr')
     form['table']['row1']['field1'] = factory(
         'td:text',
         name='field1')
     self.check_output("""
     <form action="myaction" enctype="multipart/form-data" id="form-myform"
           method="post" novalidate="novalidate">
       <table>
         <tr>
           <td>
             <input class="text" id="input-myform-table-row1-field1"
                    name="myform.table.row1.field1" type="text" value=""/>
           </td>
         </tr>
       </table>
     </form>
     """, fxml(form()))

 def form(self):
     form = factory(u'form',
                    name='loginform',
                    props={'action': self.nodeurl})
     form['__do_login'] = factory('hidden', value='true')
     form['user'] = factory(
         'field:label:error:text',
         props = {
             'required': 'No username given',
             'label': 'Username',
         })    
     form['password'] = factory(
         'field:label:*credentials:error:password',
         props = {
             'required': 'No password given',
             'label': 'Password',
         },
         custom = {
             'credentials': ([self.authenticated], [], [], []),
         })
     form['login'] = factory(
         'submit',
         props = {
             'action': 'login',
             'expression': True,
             'handler': None,
             'next': None,
             'label': 'Login',
         })
     return form