Python Dateien(XML) empfangen und senden

[Denn1s]

Hallo,
ich bin ganz neu im Python und habe als Aufgabe bekommen einen „web Service“ zu bauen, der Dateien empfangen kann und auch Dateien senden kann. Was wäre der einfachste Weg dies zu realisieren?

Zu meinem Hintergrund: Ich kann etwas programmieren aber bei dem Thema Netzwerken habe nur ein paar wenige Grundlagen mit angelesen.

Im Grunde werden XML Dateien verschickt. Welche Programmiersprache die Gegenseite bzw. der Client nutzt kann ich nicht sagen. Diese XML Dateien werden dann bei uns im Programm in Objekte umgewandelt. Ich hab gelesen, dass sowas eigentlich mit SOAP gemacht wird. Allerdings ist die XML Struktur sehr komplex und das einfachste ist wirklich wenn wir in der Lage wären XML Dateien zu schicken und empfangen.

Kann jemand von euch mir einen Tipp geben wie man es am besten machen kann? Gibt es gute Frameworks hierfür?
Bin für jeden Tipp sehr Dankbar.
Viele Grüße,
Dennis

[BlackJack]

@Denn1s: Also das einfachste wäre wahrscheinlich HTTP. Da könnte man sich sicher mit Bottle oder Flask etwas einfaches basteln.

[Denn1s]

Danke für die schnelle Antwort! Werde es mir gleich anschauen.

Wenn man es über HTTP macht muss keine Webseite erstellt werden oder? Im Grunde sollte der Client einfach auf eine IP-adresse anwählen, eine Funktion zum hochladen aufrufen und die Datei verschicken und dann auch eine Datei zurück erhalten.

Sry für die zum Teil "dummen Fragen"

Gruß,
Dennis

[/me]

Wenn man es über HTTP macht muss keine Webseite erstellt werden oder? Im Grunde sollte der Client einfach auf eine IP-adresse anwählen, eine Funktion zum hochladen aufrufen und die Datei verschicken und dann auch eine Datei zurück erhalten.

Eine Webseite besteht im Prinzip auch nur aus einer Sequenz von Daten die du schickst. In diesem Fall erstellst du keine klassische Webseite mit HTML sondern schickst deine XML-Daten zurück.

[Denn1s]

Hallo nochmal,

hab mir das Framework angeschaut und auch geschaft Datein zu senden

Code: Alles auswählen

@route('/static/<filename:path>')
def send_static(filename):
    return static_file(filename, root='/static/')

Damit kann man mit der Methode static_file die Antwort übergeben. Nun würde ich gern an den Server Dateien schicken. Was ich bisher gefunden habe:

Code: Alles auswählen

@route('/upload', method='POST')
def do_upload():
    name = request.forms.name
    data = request.files.data
    if name and data and data.file:
        raw = data.file.read() # This is dangerous for big files
        filename = data.filename
        return "Hello %s! You uploaded %s (%d bytes)." % (name, filename, len(raw))
    return "You missed a field."

Mit dem zugehörigen HTML Code:

Code: Alles auswählen

<form action="/upload" method="post" enctype="multipart/form-data">
  <input type="text" name="name" />
  <input type="file" name="data" />
</form>

Wollte Fragen ob sich der HTML Code vermeiden lässt ? Bzw. dies sieht schon stark nach eine Website aus und ich sollte eigentlich nur die Schnittstelle zu unserem Programm basteln.

Viele Grüße und Danke im Voraus,
Dennis

[EyDu]

Hallo.

Das ist doch gar nicht mehr dein Problem. In der "do_upload"-Funktion kannst du mit dem Dateiinhalt, welcher in "raw" steckt, doch jetzt machen was du willst. Wenn jemand deinen Service verwenden möchte, dann muss er eben einen entsprechenden HTTP-Request erzeugen. Egal wie. Du musst lediglich mitteilen, welche Felder mit was gefüllt werden müssen und an welche Adresse die Anfrage gehen muss.

[Sirius3]

@Denn1s: HTTP ist nur ein Protokoll und hat mit Webseiten erstmal wenig zu tun. Daten an einen HTTP-Server kann man entweder mit POST oder PUT schicken. In welcher Form die gesendeten Daten vorliegen, kann man noch mit Header-Variablen festlegen; Server und Client müssen sich halt verstehen.
Für (fast) jede Programmiersprache gibt es Bibliotheken, um solche HTTP-Requests abzuschicken (für Python z.B. requests

[Denn1s]

Hallo nochmal,

danke für die vielen Antworten und für die Tipps! Hab meine Idee mit den Kollegen besprochen und die waren nicht wirklich begeistert und würden gern auf SOAP setzen. Anscheinend müssen dann doch mehr Daten ausgetauscht werden.

Wollte einfach mal fragen ob ihr mir ein Framework für SOAP empfehlen könnte? Ist Ladon gut geeignet? Folgendes Szenario würde ich gern abdecken: Funktion Aufruf in Python und Übergabe einer Datei an diese Funktion. Ich hab gelesen, dass so etwas mit Attachements gemacht wird aber bin mir etwas unsicher. Würde es eigentlich lieber mit Bottle machen. Aber ich glaube als Newbie kann ich mich da auch schlecht durchsetzen...

[Hyperion]

Wollte einfach mal fragen ob ihr mir ein Framework für SOAP empfehlen könnte?

Ja, etwas aus der Java-Welt

Ich würde ja mal hinterfragen, *wieso* SOAP dafür genommen werden soll. Gibt es dafür Beweggründe? SOAP + Python passen imho nicht gut zusammen...

[Denn1s]

Ja das befürchte ich leider auch . Im Grunde liegt der Webservice als Schnittstelle zwischen dem "Rechenkern" der in Python geschrieben ist und der GUI + Datenbank.

Die GUI wird vermutlich (nicht von uns) in Java geschrieben.

Ich denke folgende Szenarien könnten wichtig sein (ist alles noch nicht wirklich festgelegt):
(Gui+Datenbank) anfrage an Rechenkern:
1. Lege Dateien an
2. Füge Dateien hinzu
3. Durchsuche Dateien
4. Lösche Dateien
5. Führe Berechnung durch und gebe Output
etc.
Rechenkern Anfragen:
1. Gebe mir Daten wieder
2. Initialisiere den aktuellen Stand des Rechenkerns
etc.

Keine Ahnung ob es hilft. Ich frage mich auch ob man die Technologien mischen darf, d.h. Anfragen an den Rechenkern per HTTP Request ohne SOAP und Anfragen an GUI / Datenbank mit SOAP? Bisher habe ich für Python die Bibliothek Flask Enterprise gefunden http://massive.immersedcode.org/2011/st ... nterprise/ evtl. wäre dies eine Lösung. Es ist halt schwierig mit Leuten zu diskutieren wenn man selber nicht so viel Ahnung hat.

[BlackJack]

@Denn1s: Ich schliesse mich Hyperions Vorschlag an: Wenn die SOAP wollen, nimm Java statt Python.

Für Python wäre es dann eher etwas Richtung XML-RPC oder JSON-RPC.

[Denn1s]

Die Applikation ist an sich schon fast fertig. Also man kann schlecht umsteigen: ) und wir wollen schon bei python bleiben. Ich hab nochmal mit den Leuten von der GUI gesprochen und die sind auch mit http Reuest einverstanden.

Allerdings waren die damit nicht wirklich zufrieden, da keine Typsicherheit und eben SOAP angeblich genau für diesen Anwendungsfall gemacht ist. Ich habe den Punkt angebracht, dass Python und Soap nicht so gut zusammenspielen.

Letztendlich ist es mir überlassen wie ich es umsetzen will. Sie werden sich sozusagen nach der Schnittstelle richten bzw. dann Feedback geben.
Welches Framework nimmt man am besten bei XML-RPC? Ist eigentlich Bottle weiterhin eine gute Lösung?
Ich hab ein wenig Angst, dass ich es total falsch mache und dann alles Neu machen muss.

[Sirius3]

Mit JSON hast Du die Typsicherheit, die man bei dynamischen Sprachen braucht. Mit SOAP hat man nur noch eine automatisierte Typsicherheit mit tausenden Seiten Dokumentation und hundertausend Zeilen Code erkauft. Da Du aber sowieso die Validität des Inhalts der Strukturen prüfen mußt (weil das automatisiert nicht geht) programmiert man aber dadurch schon die Validierung der Struktur praktisch mit. Einen wirklichen Vorteil hat SOAP damit nicht.
Die Auswahl des Framework ist in Bezug auf RPC fast egal. Requests parsen und Antworten senden können alle.

[Hyperion]

Mit JSON hast Du die Typsicherheit, die man bei dynamischen Sprachen braucht.

Aber wie macht man das "langweiligen" Java-Entwicklern klar, die nie über den Tellerrand geschaut haben? Und das werden ja solche sein, denn sonst hätten Sie ohne Not nicht SOAP vorgeschlagen... (offenbar gibt es ja keine Infrastruktur, in die man sich damit hätte einpassen *müssen*)

[Denn1s]

Hallo, nochmal werde es jetzt mit JSON versuchen. XML Datein werde ich dann serialisieren und per JSON verschicken falls nötig.
Was haltet ihr übrigens von diesem Framework http://spyne.io/? sieht auf dem ersten Blick vielversprechend aus.

Grüße Dennis

PS: Die Java Entwickler waren aber auch eig recht offen für Neues. Was mir noch noch vorgeschlagen wurde waren googles protocol buffers.. aber ich möchte es schon so einfach wie möglich halten.

[jerch]

@Denn1s:
spyne.io sieht in der Tat vielversprechend aus und kann offensichtlich auch SOAP verbacken Die lange Abhängigkeitsliste ist zunächst etwas abschreckend, je nach Protokoll/Backendfunktionalität die Ihr einsetzt, könnten diese Abhängigkeiten aber eh bestehen.

Ein paar Hinweise zum API-Design:
Deine Aufgabenliste oben sieht recht dokumenten-/ressourcenzentrisch aus. Da bietet sich an, die API an CRUD bzw. REST (HTTP) zu orientieren. Z.B. könntest eine Ressource "task" kreieren, welche die Initialisierung vornimmt, die Berechnung anstösst, evtl. einen Fortschritt ausgibt und letztendlich die Ergebnisse vorhält. Und für die nötigen Rohdaten ist die CRUD-Metapher ja direkt einleuchtend.

XML über JSON ist im Prinzip doppelt gemoppelt. Klar kannst Du XML als String in JSON verpacken und müsstest dann JSON und XML parsen. Warum dann nicht XML direkt? JSON macht anstelle von XML Sinn, falls Ihr nicht eine der wenigen cutting edges nutzt, die XML JSON voraus hat. Wahrscheinlich haben Eure Javaentwickler aber die tollen XMLSerializer schon fertig und wollen da nicht von abrücken

[Denn1s]

Danke für die Tipps. Wir machen es jetzt doch mit SOAP ; ) Die Java Menschen freuen sich und im Grunde ist es genauso einfach bzw. schwer. Bei Soap Frameworks für python ist allerdings die Auswahl nicht so groß. Spyne.io geht mit python 3 nicht. Ladon scheint eine gute Lösung zu sein, obwohl das Framework noch paar Bugs hat.

Viele Grüße
Dennis

[snafu]

Wenn du eh schon relativ eng mit in Zusammenhang mit Java arbeiten musst, dann wäre vielleicht auch Jython einen Blick wert. Damit kannst du Java-Klassen in Python importieren und dann ganz "normal" mit Python-Syntax nutzen.

[snafu]

Im Übrigen mag SOAP aus Python-Sicht durchaus fragwürdig erscheinen. In der Java-Welt ist es jedoch relativ easy, ein paar öffentliche Methoden auf entsprechende SOAP-Messages abbilden zu lassen.

Die Frage ist halt, ob man die zu realisierende Aufgabe wirklich in Form von entfernten Methodenaufrufen umsetzen möchte oder ob man lieber ein passendes Format für den Austausch entwickelt.

Letzteres wäre nämlich in einer deutlich freieren Form via JSON möglich. JSON-Bibliotheken gibt es auch in Java. Und sofern du deinen Kollegen mitteilst, welcher Datentyp vom jeweiligen Schlüssel geliefert wird (bei einer HashMap), dann sollte die Einbindung in deren Java-Architektur keine große Hürde darstellen.