[Python] mod_python ed il giusto handler

[Valentino Volonghi aka Dialtone]

On Sat, 19 Aug 2006 01:05:00 +0200, Andrea Giammarchi <andrea a 3site.it> wrote:

>>Poi basta isinstance() senza scomodare il modulo types
>>per vedere se qualcosa è di un certo tipo.
>http://www.canonical.org/~kragen/isinstance/

Guarda che qua dice robe abbastanza complesse che poco hanno a che fare con la funzione isinstance() ma piuttosto con cio` che fa isinstance(), non e` che se non la usi non sei caduto nella trappola :).

>>Il resto è tutto più o meno uguale. parseType con un dizionario la fai
>>in 3 righe ed è più facilmente manutenibile.
>???
>def parseType(self, value):
>        stypes = {
>            "string":"s",
>            "int":"i", "integer":"i",
>            "null":"N", "none":"N",
>            "class":"O", "object":"O",
>            "bool":"b", "boolean":"b",
>            "array":"a", "list":"a", "dict":"a", "tuple":"a",
>            "float":"d", "double":"d", "long":"d"
>        }
>        result = "u"
>        vtype = ""
>        if "type" in value:
>            vtype = value["type"].lower()
>            if vtype in stypes:
>                result = stypes[vtype]
>        return result

def parseType(self, value):
    stypes = {...}
    type = value.get('type', '').lower()
    return stypes.get(type, 'u')

>invio / ricezione di variabili complesse attraverso l'uso di metodi server 
>al fine di togliere metà del debug sul client e dedicarsi al solo debug 
>server

Non sacrificherei mai l'architettura alla mia comodita` di breve periodo, anche perche` poi una volta che e` stato sviluppato il tutto e` piu` comoda l'architettura ben fatta.

>>- procedurale = chiamo una procedura. *ESATTAMENTE* la stessa cosa che
>>stai facendo tu.
>attraverso un oggetto

No, non c'entra un tubo. send(state, 'method_name') e` una notazione perfettamente OO.

In common lisp (a mio parere l'object system piu` potente mai creato):

(defclass song ()
  ((name
    :initarg :name
    :initform (error "Ci vuole un nome")
    :accessor name
    :documentation "Il nome della traccia")
   (artist
    :initarg :artist
    :accessor artist)
   (duration
    :initarg :duration
    :accessor duration)))

(defmethod duration-in-minutes ((s song))
  (/ (duration s) 60.0))

(defmethod print-object ((s song) stream)
  (print-unreadable-object (s stream :type t :identity t)
    (format stream "~A - ~A" (name s) (artist s))))

(defparameter *song* (make-instance
                      'song
                      :name "My way"
                      :artist "Frank Sinatra"
                      :duration 180))

(princ-to-string (duration-in-minutes *song*))
(print-object *song* t)

La chiamata di metodo e`:

(duration-in-minutes *song*)

il che equivale a chiamare la funzione duration-in-minutes passando *song* come primo argomento su cui viene fatto il multiple dispatch per tipo (attraverso il quale vengono indicizzate le generic function agenti sugli stessi tipi in ingresso).

Il tipo di notazione che si usa ha ben poco a che fare con l'essere o meno OO. C'e` ben altro dietro.

>UTF-8 è un modo php per dire che sfrutta la serializzazione / 
>unserializzazione in multibytes ... in Python non esisterebbe UTF-8, anzi 
>... quella var la dovrei togliere ma la PHP_Serializer, per portabilità, 
>deve poter supportare la modalità di php

Provo a rispiegartelo:
Non esistono stringhe di cui non si conosce l'encoding. E non esistono stringhe di testo che non siano unicode e ti riconsiglio di leggere il link che ti ho gia` postato riguardo a unicode e` _DAVVERO_ il _MINIMO_ che si _DEVE_ assolutamente _SAPERE_.