http parameter einlesen - aufruf von apache

[alexPython]

Hallo,

ich würde gerne ein programm über apache aufrufen und dem programm einen parameter mitgeben.

wie z.B. http://localhost/prog.py?parameter=bla

und wie kann ich diesen parameter dann auslesen?

Gruß

[Hyperion]

Erst mal ganz viel lesen

[/me]

ich würde gerne ein programm über apache aufrufen und dem programm einen parameter mitgeben.

wie z.B. http://localhost/prog.py?parameter=bla

und wie kann ich diesen parameter dann auslesen?

Wie hast du Python an den Apache angebunden?

Bei der unklaren Fragestellung fürchte ich, dass dir möglicherweise noch Grundlagen fehlen. Beschreib doch mal was du schon hast.

[alexPython]

habe das hier in die default-datei gepackt -> ubuntu lucid

Code: Alles auswählen

<Directory /home/user/webseiten/pyprogs/>
  Options Indexes FollowSymLinks MultiViews
  AllowOverride None
  Order allow,deny
  allow from all
  AddHandler mod_python .py
  PythonHandler mod_python.publisher
  PythonDebug On
</Directory>

ja mir fehlen auf jeden fall python grundlagen.
das ist mein restes mal

also ich muss ein python programm über eine url aufrufen, wie schon erwähnt.

kann man da einen parameter übergeben?

die aufrufe zu meinen programmen funktionieren (ohne parameter)

wenn ich das prgramm aufgerufen habe, möchte ich gerne den parameter verarbeiten.

-> ziel ist es mit
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4.QtWebKit import QWebPage

ein bild von einer seite zu machen und das bild dann im browser auszugeben.

[Hyperion]

Um es kurz zu machen: Vergiss mod_python! Python Scripte verwaltet man im Apache am besten mit modwsgi.

Für so einen einfachen Fall und weil Du ein Anfänger bist rate ich Dir mal zu flask oder bottle als Microwebframeworks. Damit ist alles bis zur eigentlichen Funktionalität ein Kinderspiel und durch die hello-world-Beispiele quasi schon fertig abgedeckt.

[Leonidas]

Für so einen einfachen Fall und weil Du ein Anfänger bist rate ich Dir mal zu flask oder bottle als Microwebframeworks. Damit ist alles bis zur eigentlichen Funktionalität ein Kinderspiel und durch die hello-world-Beispiele quasi schon fertig abgedeckt.

Huch? Gerade eben nicht. Ich finde für einsteiger sind Full-Stack-Frameworks wesentlich besser geeignet, weil sie alles mögliche mitbringen (ich habe 3 Tage bisher gebraucht um mir bei Node.js das Framework, die Templatesprache, die Datenbankanbindung etc auszusuchen) und alles gut dokumentiert an einer Stelle mit einer Community die mehr auf Python-Einstieger ausgelegt ist als etwa ``#pocoo`` wo die meisten schon etliche Jahre Python-Erfahrung haben und viele Kenntnisse bereits als gegeben vorraussetzen.

Nichts gegen die Frameworks, ich finde sie gut, aber für den Anfang würde ich zu etwas anderem raten.

[Hyperion]

Huch? Gerade eben nicht. Ich finde für einsteiger sind Full-Stack-Frameworks wesentlich besser geeignet, weil sie alles mögliche mitbringen.

Ich habe mich da wohl unklar ausgedrückt. Knackpunkt war wohl das "und weil Du Einsteiger bist".

Fangen wir mal mit dem "für so einen einfachen Fall" an: Der OP will offensichtlich nur ein Bild über einen Webserver ausliefern. Dazu braucht es keine DB-Anbindung, keine Templating, keine Admin-Oberfläche oder sonst was. Aus diesem Grunde empfinde ich Django hier fehl am Platze. Genau genommen reicht hier ja fast schon ein einfaches WSGI-Programm aus.

Da das aber, wie wir wissen, unhandlich ist, hätte ich ihm bei einer größeren Vertrautheit zu Python zu einer WSGI-Bibliothek wie Werkzeug geraten. Das erklärt jetzt mein "und weil Du Anfänger bist". Genau aus dem Grund ist es imho dann doch einfacher, sich ein Framework zu schnappen, welches exakt das bietet, was der OP hier nur haben will (+ ganz viel anderes, aber eben nicht so viel mehr als Django).

Letztlich sieht doch damit die Webanwendung des OP nur so aus:

Code: Alles auswählen

# Screenshot Modul vom OP
from mymodule impoer render_image

from flask import Flask
app = Flask(__name__)

# Parameter abfangen
@app.route("/<param>")
def hello(param):
    # Funktion aufrufen, die einen Screenshot macht
    return render_image(param)

if __name__ == "__main__":
    app.run()

Vergleiche das mal mit dem "Hello World"-Beispiel von flask. Da kommt nicht viel Wissen dazu. Da reicht ja schon das Quickstart-Kapitel aus der Doku aus. Zusätzlich noch ein wenig übers modwsgi-Deployment nachlesen und schon läuft die Sache. Imho deutlich einfacher und zielführender als die Scaffolding-Prozesse, die man bei Django erst durchlaufen muss...

Ich gebe Dir natürlich uneingeschränkt recht, sollte der OP letztlich doch mehr wollen und die Applikation ausbauen usw. Dann wäre der Einstieg mit Django natürlich sinnvoller.

Für genau diesen Fall und mit der Annahme, dass der OP ansonsten damit nichts weiter machen will, gab ich die Empfehlung ab.

[Leonidas]

Jetzt überleg mal, wenn der OP irgendein Problem hat, mit irgendwelchen Komponenten oder nicht weiß was er machen soll. Tatsache ist dass die Dajngo-Community ein Vielfaches der Microframework-Community ist (sowohl von Flask, als auch Bottle zusammen, vermutlich selbst noch wenn man TurboGears und Pyramid einrechnet). Er kann sich tausende Tutorials durchlesen, auf einer Vielzahl von Mailinglisten Fragen beantwortet bekommen. Und wenn es etwas mehr sein darf? Dann kommt man auch nicht auf die Idee das Rad neu zu erfinden, sondern kann einfach auf die Möglichkeiten des Frameworks aufsetzen.

Es ist mir schon klar, dass Flask in dem Fall eine Straight-Forward-Lösung ist, wenn man nicht mehr braucht. Aber ich denke man muss das auch aus einer anderen Perspektive als der eigenen sehen. Sonst würde ich Einsteigern vorschlagen Node.js, Clojure, Factor, what-have-you zu nutzen, oder ein obskures Framework, nur weil es diesen kleinen Teilbereich am besten abbildet, wenn man genug Erfahrung hat das zu erkennen.

Ist halt oft eine Frage was man eigentlich machen will. Und ja, ich habe auch schon Leuten Flask empfohlen, die waren auch schon ziemlich begeistert davon.

[DasIch]

Wenn man weiss wo (und wen) man fragen muss ist der Flask Community mehr als ausreichend und man bekommt sehr schnell guten Support.

Gerade bei populäreren Projekten ist die Qualität des Supports schnell ein Problem und dann ist die Masse die man bekommt auch nicht sonderlich hilfreich.

[Hyperion]

Es ist mir schon klar, dass Flask in dem Fall eine Straight-Forward-Lösung ist, wenn man nicht mehr braucht.

Genau davon bin ich eben ausgegangen

@OP: Also wenn Du wirklich nur exakt das haben willst, was Du hier beschrieben hast und Dich nicht weiter mit Web-Programmierung befassen willst, dann greife ruhig zu meiner Empfehlung. Ansonsten befasse Dich mit Django, damit fährst Du als Anfaänger bei mehr als so einem simplen Fall besser.

[snafu]

Flask Plugins existieren...

[Hyperion]

Flask Plugins existieren...

Und Jogurt hat keine Gräten... :K
Was genau willst Du uns sagen

[snafu]

Na, wenn er anfängt, Flask zu nutzen und später merkt, dass er Funktionalität benötigt, die nicht in der Basisversion vorhanden ist, dann kann er sich auf der Extensions-Seite umsehen, ob er was für seine Anforderungen dort findet. Das ist quasi als Gegenargument zu "nimm Django, weil schon alles dabei ist, was man später benötigt" gemeint.

[alexPython]

was ich genau machen will:

1. Programmaufruf über Apache
2. Http-Parameter auslesen
3. mit PyQt, WebKit ein Bild von einer Seite generieren
4. Das Bild mittels URL-Parameter weitereichen an eine andere Anwendung -> Java

Benötige ich dazu überhaupt ein Framework?
Scheint mir ein bisschen übertrieben für meinen Fall

Gruß

[Hyperion]

Hätten wir das gleich gewusst, dann hätten wir Dir stattdessen XMLRPC (xmlrpclib) empfohlen

[alexPython]

sorry, dass ich mich nicht deutlich ausgedrückt hatte.

ich schau es mir an, danke!

[alexPython]

Hallo,
ich habe ein Beispiel, dass ein Bild vom Browserinhalt mittels PyQt erstellt
und in eine Datei speichert.
Ich will das nun in eine Webanwendung umbauen, aber dass er das Bild
im Browser anzeigt anstatt zu speichern.

Kennt sich jemand mit PyQt und Prozess-Kommunikation aus?

Code: Alles auswählen

#!/usr/bin/python2.6

#Xvfb :1 -screen 0 800x600x24&
#export DISPLAY=localhost:1.0

import sys

sys.path.append('/home/user/.eclipse/org.eclipse.platform_3.5.0_155965261/plugins/org.python.pydev.debug_2.0.0.2011040403/pysrc')

import pydevd
#pydevd.settrace('localhost')
#pydevd.settrace(stdoutToServer=True, stderrToServer=True)

pydevd._set_trace_lock.acquire()
try:
    pydevd._locked_settrace('localhost',True, True, 5678, True,False)
finally:
    pydevd._set_trace_lock.release()


print 'Hallo'

from PyQt4 import QtCore, QtGui, QtWebKit
from mod_python import apache

class Capturer(object):
    """A class to capture webpages as images"""

    def __init__(self, url, filename, req):

        
        self.url = url
        self.filename = filename
        self.saw_initial_layout = False
        self.saw_document_complete = False
        self.request = req
        self.loading = False
        
#        req.write("Loading in __init__: " + str(self.loading) + "---------")
        

    def loadFinishedSlot(self):
        #self.request.write("--loadFinishedSlot")
        
        #print 'loadFinihed'
        
        self.saw_document_complete = True
        if self.saw_initial_layout and self.saw_document_complete:
            self.doCapture()
        
        #self.request.write("--afterDoCapture")
  

    def initialLayoutSlot(self):
        #self.request.write("--initialLayoutSlot")

        #print 'initialLayoutSlot'
        
        self.saw_initial_layout = True
        if self.saw_initial_layout and self.saw_document_complete:
            self.doCapture()
        #self.request.write("--afterDoCapture")

    def capture(self):
        """Captures url as an image to the file specified"""
        
        #self.request.write("--capture")
        
        self.wb = QtWebKit.QWebPage()
        
        self.wb.mainFrame().setScrollBarPolicy(
            QtCore.Qt.Horizontal, QtCore.Qt.ScrollBarAlwaysOff)
        self.wb.mainFrame().setScrollBarPolicy(
            QtCore.Qt.Vertical, QtCore.Qt.ScrollBarAlwaysOff)


        self.wb.loadFinished.connect(self.loadFinishedSlot)
        
        #self.request.write("--WebPage")
        
        self.wb.mainFrame().initialLayoutCompleted.connect(
            self.initialLayoutSlot)
        
        self.wb.mainFrame().load(QtCore.QUrl(self.url))
       
    def doCapture(self):
        #self.request.write("--doCapture")
        
        self.wb.setViewportSize(self.wb.mainFrame().contentsSize())
        img = QtGui.QImage(self.wb.viewportSize(), QtGui.QImage.Format_ARGB32)
        painter = QtGui.QPainter(img)
        self.wb.mainFrame().render(painter)
        painter.end()
        print self.filename
        img.save(self.filename)
        
        self.loading = True
        #req.write("Loading in doCaputure: " + str(self.loading) + "---------")
        #ba = QByteArray()
        #buffer = QBuffer(ba)
        #buffer.open( QIODevice.WriteOnly )
        #img.save(buffer, "PNG" )
        
        #self.request.write(buffer)
        
        #f = open(self.filename)
        #self.request.write(f.read())
        
        
        #self.request.write("Filename: " + self.filename)
        #self.request.write("--DoCaptureEnd")
        
        QtCore.QCoreApplication.quit()
        #QtCore.QCoreApplication.instance().quit()
        

def index(req):
    """Run a simple capture"""

    #pydevd.settrace('localhost')
    #NOTE 1: the settrace() function can have an optional parameter to specify the 
    #host where the remote debugger is listening. E.g.: pydevd.settrace('10.0.0.1')
    #NOTE 2: the settrace() function can have optional parameters to specify that all 
    #the messages printed to stdout or stderr should be passed to the server to show. 
    #E.g.: pydevd.settrace(stdoutToServer=True, stderrToServer=True) 
    
    qtargs = ["bild.py"]
    qtargs.append("-display")
    qtargs.append("localhost:1.0")
    #req.content_type = "image/png"
    req.content_type = "text/plain"
    
    app = QtGui.QApplication(qtargs)
    c = Capturer("http://www.devicecompass.com", "bild2.png", req)
    c.capture()
    app.exec_()
    #app.processEvents()
    
  
#    req.write("Loading: " + str(c.loading) + "-----")
    #while c.loading == False:
    #    req.write("In While: " + str(c.loading) + "-----")
    
    #f = open("/home/user/webseiten/pyprogs/bild2.png")#c.filename)
    
    #req.write(f.read())
    
    req.write("Ende")
    
    #QtCore.QCoreApplication.quit()#instance().quit()
    
    #f = open(c.filename)
    #req.write(f.read())               
    #while c.saw_document_complete:
    #    bla = 0
    
    #f = open("/home/user/webseiten/pyprogs/image.png")
    
    #req.write("--ende")
    #req.content_type = "image/png"
    #req.write(f.read())
    #req.write(c.i)
    
    
    #app = QtCore.QCoreApplication(sys.argv)
    
    #web = QtWebKit.QWebPage()
    #url = "http://google.pl"
    #web.load(QUrl("http://google.pl"))
    #web.mainFrame().load(QUrl(url))
    #size = web.mainFrame().contentsSize()
    #web.setViewportSize(size)
    
    # Paint this frame into an image
    #image = QImage(web.viewportSize(), QImage.Format_ARGB32)
    #painter = QPainter(image)
    #web.mainFrame().render(painter)
    #painter.end()
    
    #f = open("/home/user/webseiten/pyprogs/image.png")
    #req.content_type = "image/png"
    #req.write(f.read())
    
    
    
    #req.write(f.read())
    
    
    return apache.OK

[BlackJack]

@alexPython: Funktioniert das denn soweit wie Du es da gezeigt hast?

Du könntest das Bild mit der `save()`-Methode in einen `QBuffer` speichern und dann die Bytes über `req` an den Client schicken.

[alexPython]

Hallo,

das habe ich auch schon probiert, es aber nicht hinbekommen.
siehe:

Code: Alles auswählen

#ba = QByteArray()
#buffer = QBuffer(ba)
#buffer.open( QIODevice.WriteOnly )
#img.save(buffer, "PNG" )
#self.request.write(buffer)

das Bild speichern funktioniert.

Gruß

[BlackJack]

@alexPython: Du musst Dir von dem `buffer` dann schon den Inhalt geben lassen und den als Antwort schicken.