Das deutsche Python-Forum

Code: Alles auswählen

class Modul(Modulbasis):
  def __init__(self):
      register_function(self.callme, PText("surname", "Nachname", maxlen=20), PTime("dinner", "Abendessen"))

  def callme(self, surname, dinner):
     # do something with already clean surname and dinner

Code: Alles auswählen

class Modul(ModulBase):
   register_function(callme, ...)
   def callme(self, surname, dinner):
       # ...

Code: Alles auswählen

class Modul(ModulBase):
   # ...
   def callme(self, surname, dinner):
   """ Das hier ist die callme-Funktion.
        Sie tut eigentlich gar nichts.
        | surname = PText("Nachname", maxlen=20)
        | dinner = PTime("Abendessen")
   """
      # ....

Code: Alles auswählen

class Modul(ModulBase):
  # ...
  def callme(self, surname=PText("Nachname", maxlen=20), dinner=PTime("Abendessen"))
     # ...

Code: Alles auswählen

        "internal_page" : {
            "CGI_dependent_actions" : {
                "save_internal_page"        : {
                    "get_CGI_data"  : {"internal_page_name": str, "content": str, "description": str, "markup": int},
                },
            }
        },

Code: Alles auswählen

    def save_internal_page(self, internal_page_name, content, description, markup):
        """ Speichert einen editierte interne Seite """
        ...

Code: Alles auswählen

class MeinModul(BasisModul):
  add_info = (PText("name"), PText("surname"))
  def add(self, name, surname):
      # ...

  # Neue Idee:
  # Viele Funktionalitäten setzen sich aus mehreren aufrufen
  # Zusammen (man denke an eine Bestellung in einem shop-system
  # Also erfinden wir Funktionsgruppen:

  order_info = (PNumeric("step"),)
  def _G_order(self, step):
     step0_info = (PText("product"), PNumeric("count"))
     def step0(self, product, count):
         # ...
     #...
     return ( (step0_info, step0), (step1_info, step1), ...)

Code: Alles auswählen

# ... irgendwo in einer Klasse in einem Modul ...
  fun_info = (PText("name", invalid=RAISE), PText("extra_info", invalid=USE_DEFAULT, default="No extra information given")
  def fun(self, name, extra_info):
      # ...

Code: Alles auswählen

def Beipeiel(self, id1, txt=""):

Code: Alles auswählen

class Modul(ModulBase):
  # ...
  def callme(self, PText("Nachname", maxlen=20), PNumeric("id"=0))
     # ...

Code: Alles auswählen

  fun_info = (PText("name", maxlen=20), PText("extra_info"))
  def fun(self, **kwargs):

Code: Alles auswählen

  fun_info = (PText("name", maxlen=20), PText("extra_info"))
  def fun(self, name, extra_info="No extra information given"):

Code: Alles auswählen

  fun_info = (PText("name", maxlen=20), PText("extra_info", default="No extra information given"))
  def fun(self, **kwargs):

Code: Alles auswählen

import exceptions
from Cheetah.Template import Template

# What to do when validate fails
RAISE = 0        # Raise an exception
USE_DEFAULT = 1  # Use default value
ROBUST = 2       # Try to read what you can,
                 # even if some of the data

class ParamError(exceptions.TypeError):
  def __init__(self, p, s=None):
    exceptions.TypeError.__init__(self)
    self.p = p
    self.s = s
  def __str__(self):
    return "Parameter '%s' ist nicht vom Typ '%s'%s." % (
        self.arg.display, self.arg.typeinfo,
        self.s and (": " + s) or "")

class UncleanError(exceptions.TypeError):
  def __init__(self):
    exceptions.TypeError.__init__(self)
  def __str__(self):
    return "Parameter unvalidiert benutzt!"
    
class Param(Template):
  """
    Encapsulates all functions and data related
    to a parameter.
    A parameter is something that is entered by a user
    in a form and then used by a pice of code.
  """
  def __init__(self, display, internal, value="", default=None, invalid=RAISE, *args, **kwargs):
    Template.__init__(self, *args, **kwargs)
    self.display = display
    self.internal = internal
    self.value = value
    self.invalid = invalid
    self.default = default
    if self.default == None:
      self.default = self.value
    self.typeinfo = "Parameter"

    self.is_clean = False
    
  def validate(self):
    """Validate self.value, react as wanted on failure.
    Override _clean() to validate your way."""
    if not self._clean():
      if self.invalid == RAISE:
        raise ParamError(self)
      else: # self.invalid in (ROBUST, USE_DEFAULT)
        self.value = self.default
    self.is_clean = True

  def __str__(self):
    """Display the value in a nice form.
    (Override _output() to make you own form)"""
    if not self.is_clean:
      #raise UncleanError(self)
      # Be kind, validate now instead of complaining
      self.validate()
    return self._output()
    
  # TODO: Move this to _input,
  # And build a wrapper around it with a nice name
  def input(self):
    """
      Thats how the frontend may ask for self.value.
      Note that its perfectly possible to choose
      special in-/output-Methods for specific params
      or classes at the frontend side.
    """
    return """<input type="text" name="%s" value="%s" />""" % (self.internal, self.value)
    
  def acquire(self, field):
    """
      Read a "dirty" value from Field f.
    """
    self.is_clean = False
    _getfromfield(self, field)

  def acquire_direct(self, v):
    """
      Read a "dirty" value through argument v.
    """
    self.is_clean = False
    self._getdirect(v)
  
  #
  #
  #
    
  def _clean(self):
    """
      If needed transform self.value to a type
      pleasent for your Param-Class,
      Return True if that went okay and self.value afterwards contains
      some useable Data of your favourite type,
      else return False.
    """
    self.value = str(self.value)
    return True

  def _output(self):
    """Thats how the frontend may display self.value.
      This function is meant to be overridden in subclasses."""
    return str(self.value)

  def _getfromfield(self, f):
    """
      Override this method if you have
      a different way of reading data.

      Note that the type of value may change later in
      clean(), just read here as far as you can get
      WITHOUT error checking.
      (i.e. dont raise an error here if the user
       supplied something wrong or nothing or to much
       or what ever can go wrong with the data.)
    """
    self._getdirect(f.getfirst(self.internal))
    
  def _getdirect(self, v):
    """
      Override this method if you have
      a different way of reading data directly.
      You may call this from getfromfield.

      Note that the type of value may change later in
      clean(), just read here as far as you can get
      WITHOUT error checking.
      (i.e. dont raise an error here if the user
       supplied something wrong or nothing or to much
       or what ever can go wrong with the data.)
    """
    self.value = v

Code: Alles auswählen

from Param import Param
from mod_python import apache
    
class PTextBase(Param):
  """
    A parameter class for simple and short text.
  """
  def __init__(self, display, internal, value="", maxlen=0, *args, **kwargs):

    Param.__init__(self, display, internal, value, *args, **kwargs)
    self.maxlen = maxlen
    self.typeinfo = "Text" + (maxlen and (" der Länge %d" % maxlen) or "")

  def _clean(self):
    return (not self.maxlen) or len(self.value) <= self.maxlen

Code: Alles auswählen

#extends PTextBase

#def input
  #set $sz = $maxlen and (" size=%d" % $maxlen) or ""
  <input type="text" name="$internal" value="$value"$sz/>
#end def

Code: Alles auswählen

from Param import Param

class PDecimalBase(PText):
  def __init__(self, display, internal, value="", digits=0, *args, **kwargs):
    PTextBase.__init__(self, display, internal, value, *args, **kwargs)
    self.typeinfo = "Dezimalzahl" + digits and (" mit %d Stellen" % digits) or "")
    self.digits = digits
    
  def _clean(self):
    if (not self.digits) or len(self.value) == self.digits:
      try:
        self.value = int(self.value)
        return True
      except ValueError:
        pass
    return False

Code: Alles auswählen

from Param import Param, ParamError

class PListBase(Param):
  """
    Encapsulates a List.
    This means: The user can select one or more
    items from a given list (choices).
    The selection is the value.
  """
  def __init__(self, display, internal, value="",
      choices=(), multiple=False, *args, **kwargs):
    Param.__init__(self, display, internal, value,
        *args, **kwargs)
    self.choices = choices
    self.multiple = multiple
    self.typeinfo = "Auswahl aus den Werten %s%s" % (
        str(self.choices), (self.multiple and " (mehrere erlaubt)" or ""))

  def _clean(self):
    l = len(self.choices)
    v = {}
    if self.multiple:
      v = {}
      # self.value still is a list of
      # (hopefully) indexes to choices
      for x in self.value:
        if type(x) == int and x in range(l):
          v[x] = True # This is slightly ROBUST, but wont harm too much
        else:
          if not self.invalid == ROBUST:
            return False
      # Now self.values is something like
      # {1: True, 4: True, 5: True}
      # with all indices in range(l)
      return True
      
    else: # value should be an index for choices
      try: self.value = int(self.value)
      except: return False
      return self.value in range(l)

  def _output(self):
    s = comma = ""
    if self.multiple:
      # Return a simple, comma-separated list. (Thats read- and parseable)
      for i in range(len(self.choices)):
        if i in self.value:
          s += comma + self.choices[i]
          comma = ", "
      return s

    else:
      # Just return our value
      return Param._output(self)
  
  def _getfromfield(self, f):
    if self.multiple: # We should receive a list
      self.value = f.getlist(self.internal, [])

    else: # Just get the value
      super(PListBase, self).getfromfield(self, f)

Code: Alles auswählen

#extends PListBase

#def input
  #set $ml = $multiple and ' multiple="multiple"' or ""
  <select$ml>
  #for $i in $range($len($choices))
    #if $multiple
      #set $sel = $value.has_key($i) and ' selected="selected"' or ""
    #else
      #set $sel = ($i == $value) and ' selected="selected"' or ""
    #end if
    <option value="$i"$sel>$choices[$i]</option>
  #end for
  </select>
#end def