Spyce

http://spyce.sourceforge.net/docs/doc-single.html
Admin
Spyce is a server-side web application framework and programming language that supports dynamic HTML...
Tokens:49,411
Snippets:348
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Spyce configuration file example

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example Spyce configuration file (spyceconf.py) that sets SPYCE_HOME, builds the module search path, defines global tag libraries, and sets the default parent template. Use this as a starting point for custom configuration, but avoid importing it directly from application code.

```python
# NOTE: do note write code that directly imports this module 
# (except when you are writing a custom configuration module.)
# This is a recipe for trouble, since spyce allows the user
# to specify the configuration module filename on the commandline.
# Instead, use import spyce; spyce.getServer().config.

import os, sys
import spycePreload

# Determine SPYCE_HOME dynamically.
# (you can hardcode SPYCE_HOME if you really want to, but it shouldn't be necessary.)
SPYCE_HOME = spycePreload.guessSpyceHome()

# The spyce path determines which directories are searched for when
# loading modules (with [[.import]]) and tag libraries (with [[.taglib]]
# and the globaltags configuration later in this file.
#
# By default, the Spyce installation directory is always searched
# first. Any directories in the SPYCE_PATH environment are also
# searched.
#
# If you need to import from .py modules in nonstandard locations
# (i.e., not in your python installation's library directory),
# you will want to add their directories to sys.path as well, as
# done here for the error module.  (However, Spyce automagically
# changes sys.path dynamically so you will always be able to import
# modules in the same directory as your currently-processing .spy file.)
#
# path += ['/usr/spyce/inc/myapplication', '/var/myapp/lib']
path = [os.path.join(SPYCE_HOME, 'modules'), os.path.join(SPYCE_HOME, 'contrib', 'modules')]
path.append(os.path.join(SPYCE_HOME, 'tags'))
path.append(os.path.join(SPYCE_HOME, 'contrib', 'tags'))
if os.environ.has_key('SPYCE_PATH'):
    path += os.environ['SPYCE_PATH'].split(os.pathsep)
# provide originalsyspath so if someone wants to maintain a config file via
# "from spyceconf import *"
# he can remove the above modifications if desired.
originalsyspath = list(sys.path)
sys.path.extend(path)

# The globaltags option specifies a group of tag libraries that will be autoloaded
# as if [[.taglib name=libname from=file as=prefix]] were specified in every .spy
# file.  (There is no performance hit if the library is not used on a page;
# the Spyce compiler optimizes it out.)
#
# The format is ('libname', 'file', 'prefix').
# For a 2.0-style tag library, the libname attribute is ignored.  Passing None is fine.
#
# globaltags.append(('mytag', 'mytaglib.py', 'my'))
# globaltags.append((None, 'taglib2.py', 'my2'))
globaltags = [
    ('core', 'core.py', 'spy'),
    ('form', 'form.py', 'f'),
    (None, 'render.spi', 'render'),
    ]

# The default parent template is the one that is used by <spy:parent>
# if no src attribute is given, specified as an absolute url.
defaultparent = "/parent.spi"
```

--------------------------------

### Custom filters and transform.create example (examples/transform.spy)

Source: http://spyce.sourceforge.net/docs/doc-single.html

Full example from examples/transform.spy demonstrating the flexibility of the transform module. It defines custom filters (tag, bold, bolditalic, simpletable), creates a compound filter with transform.create, and shows both installing filters via transform.expr and calling them directly. Not typical usage, but highlights creative possibilities.

```spyce
[[.import name=transform]]
[[\
def tag(o, tags=[], **kwargs):
  import string
  pre = string.join(map(lambda x: '<'+x+'>',tags))
  tags.reverse()
  post = string.join(map(lambda x: '</'+x+'>',tags))
  return pre+str(o)+post
def bold(o, _tag=tag, **kwargs):
  kwargs['tags'] = ['b']
  return apply(_tag, (o,), kwargs)
def bolditalic(o, _tag=tag, **kwargs):
  kwargs['tags'] = ['b','i']
  return apply(_tag, (o,), kwargs)
myfilter = transform.create(['html_encode', bolditalic])
mystring = 'bold and italic unsafe string: < > &'
def simpletable(o, **kwargs):
  s = '<table border=1>'
  for row in o:
    s=s+'<tr>'
    for cell in row:
      s=s+'<td>'+str(cell)+'</td>'
    s=s+'</tr>'
  s = s+'</table>'
  return s
]]
<html><body>
  install an expression filter:<br>
  [[transform.expr(['html_encode', tag])]]
  1.[[=mystring, tags=['b','i'] ]]
  <br>
  [[transform.expr(myfilter)]]
  2.[[=mystring]]
  [[transform.expr()]]
  <p>
  or use a filter directly:<br>
  1.[[=transform.create(['html_encode',tag])(mystring,tags=['b','i'])]]
  <br>
  2.[[=myfilter(mystring)]]
  <p>
  Formatting data in a table...<br>
  [[=simpletable([ [1,2,3], [4,5,6] ])]]
  <p>
  Though the transform module is flexible, <br>
  most users will probably only install the <br>
  <b>html_encode</b> filter.
</body></html>
```

--------------------------------

### Form tag intro example

Source: http://spyce.sourceforge.net/docs/doc-single.html

Simple form example using Spyce form tags. Demonstrates text inputs, a checkboxlist, and a submit button. Shows that Spyce automatically remembers user input unless a value parameter is given, and that arbitrary parameters are passed through to HTML.

```spyce
<spy:parent title="Form tag intro" />

<f:form>

<div class="simpleform">
  <f:text name="text1" label="Text input" default="change me" size=10 maxlength=30 />
  <f:text name="text2" label="Text input 2" value="change me" size=10 maxlength=30 />
</div>

<fieldset style="clear: both">
  <legend>One or two?  Or both?</legend>
  <f:checkboxlist class="radio" name="checkboxlist" data="[(1, 'one'), (2, 'two')]" />
</fieldset>

<div style="clear: both"><f:submit /></div>

</f:form>
```

--------------------------------

### stdout module usage example (examples/stdout.spy)

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example from examples/stdout.spy showing how to use the stdout module: print directly to the response, capture output with stdout.push(), and retrieve it with stdout.pop(). The captured string is later displayed with [[=cached]].

```spyce
**<html><body>
  [[ print '''Using the stdout module redirects 
    stdout to the response object, so you can use
    <b>print</b>!''']]<br>
  redirecting stdout can be used to...
  [[stdout.push()]]
  [[print 'capture']] out[[='put']]
  [[cached = stdout.pop()]]
  ... for later: <br>
  [[=cached]]
</body></html>
**
```

--------------------------------

### Start Spyce web server with spyceCmd.py -l

Source: http://spyce.sourceforge.net/docs/doc-single.html

Starts the Spyce web server on port 8000 by default. The port can be changed in the spyceconf module.

```bash
spyceCmd.py -l
```

--------------------------------

### Create symlink to Spyce executable

Source: http://spyce.sourceforge.net/docs/doc-single.html

Creates a symlink to the Spyce command-line executable for CGI/FastCGI installation. Adjust the path if Spyce is installed elsewhere.

```bash
ln -sf /usr/share/spyce/run_spyceCmd.py /usr/bin/spyce
```

--------------------------------

### Hello world Spyce template with version output

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example Spyce source file from examples/hello.spy. Uses the <spy:parent> tag to set the page title, imports the spyce module, and prints the Spyce version using an expression chunk.

```spyce
**<spy:parent title="Hello" />
[[ import spyce ]]

Hello from Spyce version 
[[= spyce.__version__ ]]!
**
```

--------------------------------

### Redirect example using redirect.internal, redirect.external, and redirect.externalRefresh

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example from examples/redirect.spy showing possible redirects: internal, external, and externalRefresh (with 3-second delay). It reads request['type'] and request['url'] from POST data, displays an error if url is missing, and calls the corresponding redirect method. The form posts back to the current path via request.uri('path').

```spy
**[[.import name=redirect]]
<html><body>
  [[ type = request['type']
     url = request['url']
     if url and not type: {
       ]] 
       <font color=red><b>
         please select a redirect type
       </b></font><br> 
       [[
     }
     if type and url: {
       if type=='internal': redirect.internal(url)
       if type=='external': redirect.external(url)
       if type=='externalRefresh': redirect.externalRefresh(url, 3)
       ]] Received POST info: [[=request.post1()]] [[
     }
  ]]
  <form action="[[=request.uri('path')]]" method=post>
    Redirection url:
    <input type=text name=url value=hello.spy><br>
    Redirection type:
    <table border=0>
      <tr><td>
        <input type=radio name=type value=internal>
        internal
      </td></tr>
      <tr><td>
        <input type=radio name=type value=external>
        external
      </td></tr>
      <tr><td>
        <input type=radio name=type value=externalRefresh>
        externalRefresh (3 seconds)
      </td></tr>
    </table>
    <input type=submit value=redirect>
  </form>
</body></html>
**
```

--------------------------------

### spy:parent tag example

Source: http://spyce.sourceforge.net/docs/doc-single.html

Wraps the current page in the parent template found at parent.spi in the same directory. Uses the core tag library installed under the spy prefix.

```spyce
<spy:parent src="parent.spi"/>
```

--------------------------------

### Include module example with header template

Source: http://spyce.sourceforge.net/docs/doc-single.html

Demonstrates the include module. The first block includes a common header template (inc/head.spi) and passes a context dictionary with pagename and page values. The second block, from head.spi, uses the include.context field to set the title.

```spyce
  [[.import name=include]]
  [[include.spyce('inc/head.spi', 
      {'pagename': 'Documentation', 
       'page': 'manual.html'}) ]]
```

```spyce
  [[.import name=include]]
  <title>[[=include.context['pagename'] ]]</title>
```

--------------------------------

### Generate GIF image with Spyce (examples/gif.spy)

Source: http://spyce.sourceforge.net/docs/doc-single.html

Spyce example that generates a GIF image by setting the content type to 'image/gif', reading the Spyce logo file from the server's SPYCE_HOME directory, and writing it to the response. Raises spyceDone to stop processing after writing the binary content.

```spyce
**[[.import name=include ]]
[[\
  # Spyce can also generate other content types
  # The following code displays the Spyce logo
  response.setContentType('image/gif')
  import os.path, spyce
  path = os.path.join(spyce.getServer().config.SPYCE_HOME, 'www', 'spyce.gif')
  response.write(include.dump(path, 1))
  raise spyceDone
]]
**
```

--------------------------------

### Error handling with setFileHandler

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example of using the error module to set a file handler for error handling. The page raises an error, and the handler is invoked. The second block appears to be a duplicate of the first in the source.

```spyce
**[[error.setFileHandler('error.spi') ]]
This is a page with an error...
[[ raise 'an error' ]]
**
```

```spyce
**
[[error.setFileHandler('error.spi') ]]
This is a page with an error...
[[ raise 'an error' ]]
**
```

--------------------------------

### Invoke Spyce code programmatically with spyceStringHandler

Source: http://spyce.sourceforge.net/docs/doc-single.html

Programmatic usage example from examples/programmaticUsage.py. Defines fake request and response classes, then invokes spyce.spyceStringHandler with a signature and arguments to pass parameters into the Spyce code. The output is printed to resp.err and resp.out.

```python
import os
import spyce

#--------------------------------------------------[ a hardcoded fake request ]
class TestRequest(spyce.spyceRequest):
    environment = {'QUERY_STRING': '',
            'REQUEST_METHOD': 'get'}
    headers = {}
    
    def env(self, name=None):
        if not name:
            return self.environment
        return self.environment[name]
    
    def getHeader(self, type=None):
        return self.headers[type]
    
    def getServerID(self):
        os.getpid()


#--------------------------------------------------[ a hardcoded fake response ]
class TestResponse(spyce.spyceResponse):
    returncode = spyce.spyceResponse.RETURN_OK
    out = ''
    err = ''
    headers = {}
    def write(self, s):
        self.out = self.out+s
    def writeErr(self, s):
        self.err = self.err+s
    def close(self):
        pass
    def clear(self):
        self.out = ''
    def sendHeaders(self):
        pass
    def clearHeaders(self):
        self.headers = {}
    def setContentType(self, content_type):
        self.headers['content-type'] = content_type
    def setReturnCode(self, code):
        self.returncode = code
    def addHeader(self, type, data, replace=0):
        self.headers[type] = data
    def flush(self, *args):
        pass
    def unbuffer(self):
        pass


#--------------------------------------------------[ invoking Spyce code ]
import spyceConfig
    
req = TestRequest()
resp = TestResponse()

spyceCode  = 'Hello, the following names are defined: "[[print dir(),]]", and '
spyceCode += 'these were the parameters passed: [[print (a, b, c, d)]]\n',

spyce.spyceStringHandler(
             req,
             resp,
             spyceCode,
             sig='a, b, c="asd", d=None',
             args=(1, 'two'),
             kwargs={'c': 'aa'},
             config=spyceConfig)
print resp.err
print resp.out
```

--------------------------------

### Compress module example with HTTP request

Source: http://spyce.sourceforge.net/docs/doc-single.html

Shows the compress module in use. The first block is a Spyce file that imports the compress module with gzip and spaces compression enabled. The second block is an HTTP request that includes the Accept-Encoding: gzip header, which is required for the compression to take effect.

```spyce
**[[.import name=compress args="gzip=1, spaces=1"]]
[[\
  response.write('<html><body>')
  response.write('  Space compression will remove these     spaces.<br>')
  response.write('  gzip compression will highly compress this:<br>')
  for i in range(1000):
    response.write('  hello')
  response.write('</body></html>')
]]
**
```

```http
GET /spyce/examples/compress.spy HTTP/1.1
Accept-Encoding: gzip
```

--------------------------------

### File upload handling with request.file and response.setContentType

Source: http://spyce.sourceforge.net/docs/doc-single.html

Spyce file upload example (examples/fileupload.spy). Checks for a posted content-type, sets the response content type, and writes the uploaded file's value back to the client; raises spyceDone after handling the upload.

```spyce
**[[\ 
if request.post('ct'):
  response.setContentType(request.post1('ct'))
  if request.file('upfile')!=None:
    response.write(request.file('upfile').value)
  else:
    print 'file not properly uploaded'
  raise spyceDone
]]
<html><body>
  Upload a file and it will be sent back to you.<br>
  [[-- input forms --]]
  <hr>
  <table>
    <form action="[[=request.uri('path')]]" method=post 
        enctype="multipart/form-data">
      <tr>
        <td>file:</td>
        <td><input type=file name=upfile></td>
      </tr><tr>
        <td>content-type:</td>
        <td><input type=text name=ct value="text/html"></td>
      </tr><tr>
        <td><input type=submit value=ok></td>
      </tr>
    </form>
  </table>
</body></html>
**
```

--------------------------------

### Access spyceConfig.SPYCE_HOME in Spyce

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example Spyce script that imports the spyceConfig module to access the SPYCE_HOME configuration value and outputs it. Use this to retrieve configuration settings from within a Spyce page.

```spyce
[[\
  import spyceConfig
  home = spyceConfig.SPYCE_HOME
]]

[[= home ]]
```

--------------------------------

### Read and insert data with Spyce db module (examples/db.spy)

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example from examples/db.spy showing how to read and insert rows in a table named todo_lists using the implicit Spyce db module. It defines a handler that checks for an existing name, inserts a new row, and flushes; then it selects all lists ordered by name and renders a form to create a new list.

```spyce
<spy:parent title="To-do demo" />

[[!
def list_new(self, api, name):
    if api.db.todo_lists.selectfirst_by(name=name):
        raise HandlerError('New list', 'a list with that description already exists')
    api.db.todo_lists.insert(name=name)
    api.db.flush()
]]

(This is an self-contained example using the same database as the
<a href=/demos/to-do/index.spy>to-do demo</a>.)

<h2>To-do lists</h2>

[[ lists = db.todo_lists.select(order_by=db.todo_lists.c.name) ]]
<spy:ul data="[L.name for L in lists]" />

<h2>New list</h2>
<f:form>
<f:submit value="New list" handler=self.list_new />:
<f:text name=name value="" />
</f:form>
```

--------------------------------

### Initialize Spyce request filters

Source: http://spyce.sourceforge.net/docs/doc-single.html

Initializes the Spyce request filter lists. Each callable in param_filters is called twice per request (once for GET, once for POST), while each callable in file_filters is called once. Each callable receives the request object and the dictionary being filtered.

```python
param_filters = []
file_filters = []

```

--------------------------------

### Schedule daily task with Spyce scheduler

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example from examples/scheduling.py that schedules a daily task to delete unsubmitted alerts older than one week. Uses scheduler.schedule_daily with hour and minute arguments (00, 10) and accesses a database pool from spyce.SPYCE_GLOBALS.

```python
import spyce, scheduler

def delete_unsubmitted():
    db = spyce.SPYCE_GLOBALS['dbpool'].connection()
    sql = "DELETE FROM alerts WHERE status = 'unsubmitted' AND created < now() - '1 week'::interval"
    db.execute(sql)

# delete alerts that were created over a week ago but but still not submitted 
scheduler.schedule_daily(00, 10, delete_unsubmitted)

```

--------------------------------

### Login required and logout tags example

Source: http://spyce.sourceforge.net/docs/doc-single.html

Shows how to use the login_required and logout tags. If a valid login cookie is not present, login_required generates a login form and halts execution. The logout tag clears the cookie generated by login and login_required.

```spyce
<spy:parent title="Login example" />

<f:form>
  <spy:login_required />

  You are logged in.
  <spy:logout />
</f:form>
```

--------------------------------

### spy:for and spy:print tag example

Source: http://spyce.sourceforge.net/docs/doc-single.html

Prints the value of foo five times. The expression =range(5) is evaluated by Spyce before being sent to the tag; do not use [[= ]] for tag attributes because it sends output directly and prevents tag recognition.

```spyce
<spy:for items="=range(5)">
<spy:print value="=foo"/>
</spy:for>
```

--------------------------------

### Active handler example with calculate function

Source: http://spyce.sourceforge.net/docs/doc-single.html

Shows how to attach a Python function as an active handler to a form submission. The handler signature pulls parameters from the form; here x and y are typed as float and converted automatically. The result is stored on self and displayed after submission.

```spyce
**[[!
def calculate(self, api, x, y):
    self.result = x * y
]]

<spy:parent title="Active Handler example" />
<f:form>
    <f:text name="x:float" default="2" label="first value" />
    <f:text name="y:float" default="3" label="second value" />

    <f:submit handler="self.calculate" value="Multiply" />
</f:form>

<p>
Result: [[= hasattr(self, 'result') and self.result or '(no result yet)' ]]
</p>
**
```

--------------------------------

### Memoized Spyce lambda table template (examples/spylambda.spy)

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example from examples/spylambda.spy showing a memoized Spyce lambda ([[spy! ... : ...]]) that builds an HTML table from title and data lists, then emits a web page. The lambda is defined with the spy! syntax to enable memoization, and the page calls table(title, data) inside the HTML body.

```spyce
**[[\
  # table template
  table = **[[spy! title, data: 
    <table>
      <tr>
        [[for cell in title: {]]
          <td><b>[[=cell]]</b></td>
        [[}]]
      </tr>
      [[for row in data: {]]
        <tr>
          [[for cell in row: {]]
            <td>[[=cell]]</td>
          [[}]]
        </tr>
      [[}]]
    </table> 
  ]]**

  # table information
  title = ['Country', 'Size', 'Population', 'GDP per capita']
  data = [
    [ 'USA', '9,158,960', '280,562,489', '$36,300' ],
    [ 'Canada', '9,220,970', '31,902,268', '$27,700' ],
    [ 'Mexico', '1,923,040', '103,400,165', '$9,000' ],
  ]
]]

[[-- emit web page --]]
<html><body>
  [[ table(title, data) ]]
</body></html>

**
```

--------------------------------

### Request object methods table with GET/POST forms

Source: http://spyce.sourceforge.net/docs/doc-single.html

Spyce page that displays a form for GET and POST requests and a table of request method return values. Uses request.uri('path') for form actions and evaluates each request method with eval('request.%s' % method).

```spyce
**<html><body>
  Using the Spyce request object, we can obtain 
  information sent along with the request. The 
  table below shows some request methods and their 
  return values. Use the form below to post form 
  data via GET or POST. <br>
  <hr>
  [[-- input forms --]]
  <form action="[[=request.uri('path')]]" method=get>
    get: <input type=text name=name>
    <input type=submit value=ok>
  </form>
  <form action="[[=request.uri('path')]]" method=post>
    post: <input type=text name=name>
    <input type=submit value=ok>
  </form>
  <hr>
  [[-- tabulate response information --]]
  <table border=1>
    <tr>
      <td><b>Method</b></td>
      <td><b>Return value</b></td>
    </tr>
    [[ for method in ['uri()', 'uri("path")',
      'uri("query")', 'method()','query()',
      'get()','get1()', 'post()','post1()',
      'getHeader()','env()', 'filename()']: { 
    ]]
      <tr>
        <td valign=top>request.[[=method]]</td>
        <td>[[=eval('request.%s' % method)]]</td>
      </tr>
    [[ } ]]
  </table>
</body></html>
**
```

--------------------------------

### Create a Spyce project with spyceProject.py

Source: http://spyce.sourceforge.net/docs/doc-single.html

Creates a new Spyce project directory structure. The command generates the shown tree, including config.py, lib, login_tokens, and www directories. After creation, run spyceCmd.py -l --conf /var/firstproject/config.py and browse to http://localhost:8000/index.spy to verify.

```bash
python spyceProject.py /var/firstproject
```

```text
$ tree /var/firstproject/
    /var/firstproject/
    |-- config.py
    |-- lib
    |-- login_tokens
    `-- www
        |-- _util
        |   |-- form_calendar.gif
        |   `-- form_calendar.js
        |-- index.spy
        |-- parent.spi
        `-- style.css

```

--------------------------------

### Request param filter example (examples/filter.py)

Source: http://spyce.sourceforge.net/docs/doc-single.html

Example filter function for the request module's param_filters hook. It cleans or escapes user-supplied values to prevent HTML injection, using the __htmlfields marker to decide which fields to clean.

```python
def htmlFilter(request, d):
  # note that spoofing __htmlfields doesn't help attacker get unsafe html in;
  # we always call either clean() or escape().
  try:
    # don't use request['__htmlfields'], or you will recurse infinitely
    toClean = request._post['__htmlfields'][0].split(',')
  except KeyError:
    toClean = []
  for key in d:
    if key in toClean:
      d[key] = [Html.clean(s) for s in d[key]]
    else:
      d[key] = [Html.escape(s) for s in d[key]]

```

--------------------------------

### request.method()

Source: http://spyce.sourceforge.net/docs/doc-single.html

Returns the HTTP method (e.g., GET, POST) of the current request.

```APIDOC
## request.method()

### Description
Returns the HTTP method (e.g., GET, POST) of the current request.

### Method
--

### Endpoint
--

### Parameters
No parameters.

### Request Example
--

### Response
#### Success Response
Returns a string representing the HTTP method used for the current request.

#### Response Example
--
```

--------------------------------

### request.get()

Source: http://spyce.sourceforge.net/docs/doc-single.html

Returns a dictionary or similar structure containing all GET parameters sent with the request.

```APIDOC
## request.get()

### Description
Returns a dictionary or similar structure containing all GET parameters sent with the request.

### Method
--

### Endpoint
--

### Parameters
No parameters.

### Request Example
--

### Response
#### Success Response
Returns a mapping of GET parameter names to values.

#### Response Example
--
```

--------------------------------

### Spyce command-line usage

Source: http://spyce.sourceforge.net/docs/doc-single.html

Shows the full command-line syntax for the Spyce 2.1 executable, including options for compiling, CGI mode, batch processing, and running as a proxy server. Use this to understand the available flags such as -c, -w, -O, -l, and --conf.

```text
Spyce 2.1
Command-line usage:
  spyce -c [-o filename.html] <filename.spy>
  spyce -w <filename.spy>                <-- CGI
  spyce -O filename(s).spy               <-- batch process
  spyce -l [-d file ]                    <-- proxy server
  spyce -h | -v
    -h, -?, --help       display this help information
    -v, --version        display version
    -o, --output         send output to given file
    -O                   send outputs of multiple files to *.html
    -c, --compile        compile only; do not execute
    -w, --web            cgi mode: emit headers (or use run_spyceCGI.py)
    -q, --query          set QUERY_STRING environment variable
    -l, --listen         run in HTTP server mode
    -d, --daemon         run as a daemon process with given pidfile
    --conf [file]        Spyce configuration file
To configure Apache, please refer to: spyceApache.conf
For more details, refer to the documentation.
  http://spyce.sourceforge.net
Send comments, suggestions and bug reports to <rimon-AT-acm.org>.
```

--------------------------------

### Form tag example with primitive and compound controls

Source: http://spyce.sourceforge.net/docs/doc-single.html

Complete example of Spyce form tags: primitive controls (text, password, textarea, checkbox, radio) and compound controls (radiolist, checkboxlist, select, date). The data attribute for compound controls is an iterable of (description, value) pairs, here defined inline as L. The default attribute for checkboxlist is a list expression, e.g. ['0', '1'].

```spyce
**<spy:parent title="Form tag example" />

<f:form>

<h2>Primitive controls</h2>

<div class="simpleform">
  <f:text name="mytext" label="Text" default="some text" size=10 maxlength=30 />

  <f:password name="mypass" label="Password" default="secret" />

  <f:textarea name="mytextarea" label="Textarea" default="rimon" rows=2 cols=50></f:textarea>

  <label for="mycheck">Checkbox</label><f:checkbox name=mycheck value=check1 />

  <label for="myradio1">Radio option 1</label><f:radio name=myradio value=option1 />
  <label for="myradio2">Radio option 2</label><f:radio name=myradio value=option2 />
</div>

<div style="clear: both">
  <h2 style="padding-top: 1em;">Compound controls</h2>
  [[-- a simple data source for the compound controls -- in practice
	     this would probably come from the database --]]
  [[ L = [('option %d' %i, str(i)) for i in range(5)] ]]

  <fieldset>
    <legend>Radiolist</legend>
    <f:radiolist class=radio name=radiolist data="L" default="3" />
  </fieldset>

  <fieldset>
    <legend>Checkboxlist</legend>
    <f:checkboxlist class=radio name=checkboxlist data="L" default="=['0', '1']" />
  </fieldset>

  <fieldset>
    <legend>Select</legend>
    <f:select name=myselect multiple size=5 data="L" default="2" />
  </fieldset>

  <fieldset>
    <legend>Date</legend>
    <f:date name=mydate />
  </fieldset>

  <h2 style="clear:both; padding-top: 1em;">Test it!</h2>
  <input type="submit" name="foo" value="Submit!">

</f:form>

**
```

--------------------------------

### request.get1()

Source: http://spyce.sourceforge.net/docs/doc-single.html

Returns the first value of a GET parameter. Typically used to retrieve a single value when multiple values may exist.

```APIDOC
## request.get1()

### Description
Returns the first value of a GET parameter. Typically used to retrieve a single value when multiple values may exist.

### Method
--

### Endpoint
--

### Parameters
No parameters.

### Request Example
--

### Response
#### Success Response
Returns a single value (string) of a GET parameter.

#### Response Example
--
```

--------------------------------

### CompoundHandlerError example with multiple errors

Source: http://spyce.sourceforge.net/docs/doc-single.html

Shows how to raise multiple validation errors at once using CompoundHandlerError. The handler adds two HandlerError instances and raises the compound error if it is non-empty. The form displays all errors together.

```spyce
**[[!
def errors(self, api):
    from spyceException import HandlerError, CompoundHandlerError
    cve = CompoundHandlerError()
    cve.add(HandlerError('One', 'First error'))
    cve.add(HandlerError('Two', 'Second error'))
    if cve:
        raise cve
]]

<spy:parent title="Active Handler Validation 2" />
<f:form>
    <f:submit handler="self.errors" value="Show me some errors" />
</f:form>
**
```

--------------------------------

### Configure Apache to handle .spy files

Source: http://spyce.sourceforge.net/docs/doc-single.html

Add this line to httpd.conf or .htaccess to enable Spyce as a CGI script. Requires the ExecCGI option and cgi_allow_only_redirect set to False.

```apache
AddHandler cgi-script spy
```

--------------------------------

### Dynamic include with include.spyce()

Source: http://spyce.sourceforge.net/docs/doc-single.html

Shows dynamic includes: the main file uses include.spyce() to include 'include.spi' with a context, and the included file accesses that context and returns a value. The included file runs in a separate context, so changes to its variables do not affect the main file.

```spyce
**[[.import name=include]]
<html><body>
  main file<br>
  <hr>
  [[
    context = {'foo': 'old value'}
    result=include.spyce('include.spi', context)
  ]]
  <hr>
  main file again<br>
  context: [[=context]]<br>
  return value: [[=result]]<br>
</body></html>
**
```

```spyce
**begin include<br>
context: [[=include.context ]]<br>
from: [[=request.stack()[-2] ]]<br>
foo was [[=include.vars.foo]]<br>
setting foo to 'new value' [[include.vars.foo = 'new value']]<br>
returing 'retval'<br>
end include<br>
[[ return 'retval' ]]
**
```

--------------------------------

### Execute raw SQL via SqlSoup engine

Source: http://spyce.sourceforge.net/docs/doc-single.html

Shows how to access SqlSoup's engine attribute and use its execute method to run raw SQL, returning a ResultProxy with fetch methods. The output displays the fetched rows.

```python
    >>> rp = db.engine.execute('select name, email from users order by name')
    >>> for name, email in rp.fetchall(): print name, email
    Bhargan Basepair basepair+nospam@example.edu
    Joe Student student@example.edu

```
Tokens:
Raw