Zusammenfassung

Dieses PEP schlägt eine Reihe von Verbesserungen für die CGI-Entwicklungseinrichtungen in der Python-Standardbibliothek vor. Verbesserungen könnten neue Funktionen, neue Module für Aufgaben wie Cookie-Unterstützung oder die Entfernung veralteten Codes sein.

Die ursprüngliche Absicht war, Verbesserungen für Python 2.1 vorzunehmen. Es schien jedoch wenig Interesse von der Python-Community zu geben und die Zeit war knapp, daher wurde dieses PEP auf eine zukünftige Python-Version verschoben.

Offene Fragen

Dieser Abschnitt listet Änderungen auf, die vorgeschlagen wurden, aber über die noch keine endgültige Entscheidung getroffen wurde. In der endgültigen Version dieses PEP sollte dieser Abschnitt leer sein, da alle Änderungen als akzeptiert oder abgelehnt klassifiziert werden sollten.

cgi.py: Uns sollte nicht gesagt werden, wir müssten unsere eigene Unterklasse erstellen, nur um Dateiuploads verarbeiten zu können. Praktisch gesehen habe ich noch keine Zeit gefunden, dies richtig zu machen, also lese ich am Ende die temporäre Datei von cgi.py in, im besten Fall, eine weitere Datei. Einige unseres Legacy-Codes lesen sie tatsächlich in eine zweite temporäre Datei, dann in ein endgültiges Ziel! Und selbst wenn wir das tun würden, bedeutet das die Erstellung eines weiteren Objekts mit seinem __init__ Aufruf und dem damit verbundenen Overhead.

cgi.py: Derzeit werden Abfragezeichenfolgen ohne = ignoriert. Selbst wenn keep_blank_values gesetzt ist, werden Abfragen wie ...?value=&... mit leeren Werten zurückgegeben, aber Abfragen wie ...?value&... gehen vollständig verloren. Es wäre großartig, wenn solche Daten über die FieldStorage Schnittstelle verfügbar gemacht würden, entweder als Einträge mit None als Werten oder in einer separaten Liste.

Dienstprogrammfunktion: Erstellen einer Abfragezeichenfolge aus einer Liste von 2-Tupeln

Wörterbuchbezogene Dienstprogrammklassen: NoKeyErrors (gibt eine leere Zeichenfolge zurück, niemals einen KeyError), PartialStringSubstitution (gibt die ursprüngliche Schlüsselzeichenfolge zurück, niemals einen KeyError)

Neue Module

Dieser Abschnitt listet Details zu ganzen neuen Paketen oder Modulen auf, die der Python-Standardbibliothek hinzugefügt werden sollten.

• fcgi.py: Ein neues Modul, das Unterstützung für das FastCGI-Protokoll hinzufügt. Robin Dunns Code muss jedoch unter Windows portiert werden.

Wesentliche Änderungen an bestehenden Modulen

Dieser Abschnitt listet Details zu wesentlichen Änderungen an bestehenden Modulen auf, sei es in der Implementierung oder in der Schnittstelle. Die Änderungen in diesem Abschnitt bergen daher ein höheres Risiko, entweder durch die Einführung von Fehlern oder durch Rückwärtsinkompatibilitäten.

Das cgi.py-Modul würde als veraltet markiert werden. (XXX Ein neuer Modul- oder Paketname wurde noch nicht gewählt: 'web'? 'cgilib'?)

Kleinere Änderungen an bestehenden Modulen

Dieser Abschnitt listet Details zu kleineren Änderungen an bestehenden Modulen auf. Diese Änderungen sollten relativ kleine Implementierungen haben und ein geringes Risiko für Inkompatibilitäten mit früheren Versionen bergen.

Abgelehnte Änderungen

Die in diesem Abschnitt aufgeführten Änderungen wurden für Python 2.1 vorgeschlagen, wurden aber als ungeeignet abgelehnt. Für jede abgelehnte Änderung wird eine Begründung gegeben, warum die Änderung als unangemessen erachtet wurde.

• Ein Modul zur HTML-Generierung ist kein Teil dieses PEP. Mehrere solcher Module existieren, von der rein programmatischen Schnittstelle von HTMLgen über einfache, ASP-inspirierte Templating bis hin zum komplexen Templating von DTML. Es gibt keinen Hinweis darauf, welches Templating-Modul in die Standardbibliothek aufgenommen werden sollte, und das bedeutet wahrscheinlich, dass kein Modul so gewählt werden sollte.
• cgi.py: Zulassen einer Kombination aus Abfragendaten und POST-Daten. Dies scheint überhaupt nicht Standard zu sein und ist daher zweifelhafte Praxis.

Vorgeschlagene Schnittstelle

XXX offene Punkte: Namenskonvention (studlycaps oder unterstrich-getrennt?); muss die cgi.parse*() Funktionen untersuchen und sehen, ob sie auch vereinfacht werden können.

Parsing-Funktionen: Übernehmen der meisten parse* Funktionen aus cgi.py

# The Response class borrows most of its methods from Zope's
# HTTPResponse class.

class Response:
    """
    Attributes:
    status: HTTP status code to return
    headers: dictionary of response headers
    body: string containing the body of the HTTP response
    """

    def __init__(self, status=200, headers={}, body=""):
        pass

    def setStatus(self, status, reason=None):
        "Set the numeric HTTP response code"
        pass

    def setHeader(self, name, value):
        "Set an HTTP header"
        pass

    def setBody(self, body):
        "Set the body of the response"
        pass

    def setCookie(self, name, value,
                  path = '/',
                  comment = None,
                  domain = None,
                  max-age = None,
                  expires = None,
                  secure = 0
                  ):
        "Set a cookie"
        pass

    def expireCookie(self, name):
        "Remove a cookie from the user"
        pass

    def redirect(self, url):
        "Redirect the browser to another URL"
        pass

    def __str__(self):
        "Convert entire response to a string"
        pass

    def dump(self):
        "Return a string representation useful for debugging"
        pass

    # XXX methods for specific classes of error:serverError,
    # badRequest, etc.?


class Request:

    """
    Attributes:

    XXX should these be dictionaries, or dictionary-like objects?
    .headers : dictionary containing HTTP headers
    .cookies : dictionary of cookies
    .fields  : data from the form
    .env     : environment dictionary
    """

    def __init__(self, environ=os.environ, stdin=sys.stdin,
                 keep_blank_values=1, strict_parsing=0):
        """Initialize the request object, using the provided environment
        and standard input."""
        pass

    # Should people just use the dictionaries directly?
    def getHeader(self, name, default=None):
        pass

    def getCookie(self, name, default=None):
        pass

    def getField(self, name, default=None):
        "Return field's value as a string (even if it's an uploaded file)"
        pass

    def getUploadedFile(self, name):
        """Returns a file object that can be read to obtain the contents
        of an uploaded file.  XXX should this report an error if the
        field isn't actually an uploaded file?  Or should it wrap
        a StringIO around simple fields for consistency?
        """

    def getURL(self, n=0, query_string=0):
        """Return the URL of the current request, chopping off 'n' path
        components from the right.  Eg. if the URL is
        "http://foo.com/bar/baz/quux", n=2 would return
        "http://foo.com/bar".  Does not include the query string (if
        any)
        """

    def getBaseURL(self, n=0):
        """Return the base URL of the current request, adding 'n' path
        components to the end to recreate more of the whole URL.

        Eg. if the request URL is
        "http://foo.com/q/bar/baz/qux", n=0 would return
        "http://foo.com/", and n=2 "http://foo.com/q/bar".

        Returned URL does not include the query string, if any.
        """

    def dump(self):
        "String representation suitable for debugging output"
        pass

    # Possibilities?  I don't know if these are worth doing in the
    # basic objects.
    def getBrowser(self):
        "Returns Mozilla/IE/Lynx/Opera/whatever"

    def isSecure(self):
        "Return true if this is an SSLified request"


# Module-level function
def wrapper(func, logfile=sys.stderr):
    """
    Calls the function 'func', passing it the arguments
    (request, response, logfile).  Exceptions are trapped and
    sent to the file 'logfile'.
    """
    # This wrapper will detect if it's being called from the command-line,
    # and if so, it will run in a debugging mode; name=value pairs
    # can be entered on standard input to set field values.
    # (XXX how to do file uploads in this syntax?)

Urheberrecht

Dieses Dokument wurde gemeinfrei erklärt.