Aus einem geschützten Bereich (.htaccess) herunterladen

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

Hallo Leute, ich habe auf meinem kostenlosen Webserver einen geschützten Bereich eingerichtet. Dazu habe ich mich an dieser .htaccess-Geschichte bedient. Funktioniert alles super. In Zeile 11 habe ich eine get_access_data_and_link()-Funktion definiert. Mit entsprechenden Daten meldet sich die requests-Bibliothek auch bei dem geschützten Bereich an. In Zeile 77 wird die Funktion aufgerufen und der Funktion werden Anmeldedaten übergeben. Bis hierher alles super. Nach erfolgreicher Anmeldung wird der Benutzer serverseitig auf eine Textdatei weitergeleitet. Dort wurde eine URL hinterlegt. Der URL-Link wird dann in self.url gespeichert. Und dies wurd dann in Zeile 95 dem Download_Thread() übergeben.

1. Die Anmeldung beim .htaccess ist erfolgreich
2. Der URL-Link wird ausgegeben
3. URL-Link ist korrekt

Jedoch wird die Datei nicht heruntergeladen. Beim Versuch wird der Vorgang abgebrochen und das ganze Programm wird beendet. Ich bekomme in der Konsole keinerlei Fehlermeldung.

Code: Alles auswählen

FILE_NAME = "downloader2.py"

import os
import requests
import sys
from requests.auth import HTTPBasicAuth

from PyQt4.QtCore import QThread, pyqtSignal, Qt, QSemaphore
from PyQt4.QtGui import QVBoxLayout, QPushButton, QDialog, QProgressBar, QApplication, QMessageBox

def get_access_data_and_link(user_name, passwd):
    return requests.get('http://xarphus.de/schutz/', auth=HTTPBasicAuth(user_name, passwd)).text

class Download_Thread(QThread):
    finished_thread = pyqtSignal()
    error_http = pyqtSignal()
    finished_download = pyqtSignal()
    notify_progress = pyqtSignal(int)

    def __init__(self, location, link, parent=None):
        QThread.__init__(self, parent)

        self.url = link
        self.location = location

        self._run_semaphore = QSemaphore(1)

    def run(self):
        try:
            file = requests.get(self.url, stream=True)
            status = file.status_code

            if not status == 200:
                self.error_http.emit()

        except (requests.exceptions.URLRequired,
                requests.exceptions.ConnectionError,
                requests.exceptions.HTTPError,
                requests.exceptions.Timeout,
                requests.exceptions.ConnectTimeout,
                requests.exceptions.ReadTimeout), g:
            print 'Could not download ', g
            self.error_http.emit()
        else:
            file_size = int(requests.head(self.url).headers.get('content-length', [0]))
            print "%s Byte" %file_size
            result = file_size / (1024*5)
            print result
            chunk_size = int(result)
            downloaded_bytes = 0

            with open(self.location, 'wb') as fd:
                for chunk in file.iter_content(chunk_size):
                    fd.write(chunk)
                    downloaded_bytes = fd.tell()
                    #print (float(downloaded_bytes)/file_size*100)
                    self.notify_progress.emit(float(downloaded_bytes)/file_size*100)

                    if self._run_semaphore.available() == 0:
                        self._run_semaphore.release(1)
                        break

                print "Finish"
                self.finished_download.emit()
                self.finished_thread.emit()

    def stop(self):
        print "stop"
        self._run_semaphore.acquire(1)

class MyCustomDialog(QDialog):
 
    def __init__(self):
        super(MyCustomDialog, self).__init__()
        layout = QVBoxLayout(self)

        self.url = get_access_data_and_link('your_username','your_password')

        # Create a progress bar and a button and add them to the main layout
        self.progressBarUpdate = QProgressBar(self)
        self.progressBarUpdate.setAlignment(Qt.AlignCenter)
        layout.addWidget(self.progressBarUpdate)

        pushButtonUpdate = QPushButton("Start", self)
        layout.addWidget(pushButtonUpdate)
        pushButtonCancel = QPushButton("Cancel", self)
        layout.addWidget(pushButtonCancel)
 
        pushButtonUpdate.clicked.connect(self.check_folder_exists)

        # Set data for download and saving in path
        self.location = os.path.abspath(os.path.join('temp', 'example-app-0.3.win32.zip'))
        #self.url = 'http://sophus.bplaced.net/download/example-app-0.3.win32.zip'
 
        self.download_task = Download_Thread(self.location, self.url)
        self.download_task.notify_progress.connect(self.on_progress)
        self.download_task.finished_thread.connect(self.on_finished)
        self.download_task.error_http.connect(self.on_HTTPError)
        self.download_task.finished_download.connect(self.on_finish_download)

        pushButtonCancel.clicked.connect(self.on_finished)

    def on_start(self):
        self.progressBarUpdate.setRange(0, 0)
        self.download_task.start()

    def on_finish_download(self):
        msg_box = QMessageBox()

        QMessageBox.question(msg_box, ' Message ',
                                           "The file has been fully downloaded.", msg_box.Ok)
            
    def on_HTTPError(self):
        reply = QMessageBox.question(self, ' Error ',
                                           "The file could not be downloaded. Will they do it again?", QMessageBox.Yes | 
            QMessageBox.No, QMessageBox.No)

        if reply == QMessageBox.Yes:
            self.on_start()
        else:
            print "Close button pressed"
            #event.ignore()

    def on_progress(self, i):
        self.progressBarUpdate.setRange(0, 100)
        self.progressBarUpdate.setValue(i)
 
    def check_folder_exists(self):
        location = os.path.abspath(os.path.join('temp'))
        if not os.path.exists(location):
            os.makedirs(location)
            print "Folder was created"
            self.on_start()
        else:
            print "Folder already exists"
            self.on_start()
 
    def on_finished(self):
        self.progressBarUpdate.setValue(0)
        self.close()

    def closeEvent(self, event):
        self.download_task.stop()
 
def main():
    app = QApplication(sys.argv)
    window = MyCustomDialog()
    window.resize(600, 400)
    window.show()
    sys.exit(app.exec_())
 
if __name__ == "__main__":
    main()
Sirius3
User
Beiträge: 17741
Registriert: Sonntag 21. Oktober 2012, 17:20

@Sophus: Du hast doch etliche prints. Da wird ja schon irgendwas ausgegeben. Warum machst Du immer noch einen unnötigen HEAD-Request. Und die Authentifizierung fehlt auch.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

@Sirius3: Der HEAD-Request wurde nun entfernt. Danke. Bezüglich der Meldungen. Es kommen tatsächlich nur Print-Meldungen:
Folder already exists
290 Byte
0
Finish
stop
Close button pressed
Er setzt also kurz an, und bricht dann ab. Das Programm schließt sich dann. Und zum Thema Authentifizierung. Dazu habe ich diese Dokumentation gelesen. Gleich am Anfang habe ich mich an diesem Beispiel bedient.

Mit der HTTPDigestAuth-Variante kann ich mich nicht anmelden. Da bekomme ich dann folgenden Hinweis:
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>401 Authorization Required</title>
</head><body>
<h1>Authorization Required</h1>
<p>This server could not verify that you
are authorized to access the document
requested. Either you supplied the wrong
credentials (e.g., bad password), or your
browser doesn't understand how to supply
the credentials required.</p>
</body></html>
Wie gesagt, die Anmeldung funktioniert ja auch. Mein Skript bekommt dann dann den Inhalt der Textdatei, die im geschützten Bereich liegt. Und die herunterzuladende Datei liegt ebenfalls im geschützten Bereich. Ich ging davon aus, dass die Datei herunterladbar ist, sobald die Anmeldung erfolgreich war. Über meinem Browser klappt es.
Sirius3
User
Beiträge: 17741
Registriert: Sonntag 21. Oktober 2012, 17:20

@Sophus: wenn Du die Ausgaben anschaust, ist doch klar was passiert. Nämlich genau das, was Du programmiert hast.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

@Sirius3: Mir leuchtet nicht ganz ein, was genau du meinst. Würde ich die Funktion auskommentieren und eine URL hinterlegen, die nicht geschützt ist, dann klappt das Herunterladen wunderbar.
Sirius3
User
Beiträge: 17741
Registriert: Sonntag 21. Oktober 2012, 17:20

@Sophus: schau Dir mal Zeile 47 an und erkläre den Sinn dieser Zeile.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

@Sirius3: Ursprünglich wollte ich über Zeile 45 die Dateigröße ermitteln, und dann in Zeile 47 damit rechnen, die dann für die chunk_size benötigt wird.

Wenn ich den Header auslese und diese dann per Print ausgeben lasse:

Code: Alles auswählen

            r = requests.head(self.url)
            file_size = r.headers
            print file_size
Bekomme ich diese Information. Und gleich direkt am Anfang steht in content-length die Dateigröße: 13595885.
{'content-length': '13595885', 'accept-ranges': 'bytes', 'keep-alive': 'timeout=4, max=500', 'server': 'Apache/2.4', 'last-modified': 'Thu, 23 Apr 2015 23:26:58 GMT', 'connection': 'Keep-Alive', 'etag': '"cf74ed-5146c9dae0460"', 'date': 'Wed, 22 Jul 2015 21:20:08 GMT', 'content-type': 'application/zip'}
Zuletzt geändert von Sophus am Mittwoch 22. Juli 2015, 22:23, insgesamt 1-mal geändert.
Sirius3
User
Beiträge: 17741
Registriert: Sonntag 21. Oktober 2012, 17:20

Und was hat die chunk_size mit der Dateigröße zu tun?
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

@Sirius3: Ich hatte damit vor, anhand der Dateigröße die chunk_size zu errechnen:

Wenn die Datei also 13595885 groß ist
13595885 / (1024*5) = 2655,4462890625 <-- chunk_size

Aber ich glaube, ich weiß worauf du hinaus willst. Man kann die chunk_size selbst angeben, ohne zu rechnen? Wenn ich dies tue, also die chunk_size selbst angebe, dann ändert sich nichts. Das Fenster schließt sich weiterhin selbst und das Herunterladen wird auch beendet.

Die Dateigröße ist mir auch ziemlich suspekt. Sie ist eigentlich 36 MB groß. Hier sagt content-length, dass sie gerade mal 290 Byte sei.
http://xarphus.de/schutz/datei.rar
Folder already exists
heanders {'content-length': '290', 'x-varnish': '138478030 137095217', 'content-encoding': 'gzip', 'accept-ranges': 'bytes', 'vary': 'Accept-Encoding', 'server': 'Apache', 'age': '555', 'connection': 'keep-alive', 'via': '1.1 varnish', 'date': 'Wed, 22 Jul 2015 21:48:20 GMT', 'content-type': 'text/html; charset=iso-8859-1', 'www-authenticate': 'Basic realm="Service-Bereich"'}
290 Byte
result 0
chunk_size 0
Finish
stop
Close button pressed
Sirius3
User
Beiträge: 17741
Registriert: Sonntag 21. Oktober 2012, 17:20

Jetzt sollte man noch lesen können, was der Header bedeutet. Um es nochmal deutlicher zu sagen: Du kannst Dich bei Deiner Seite nicht anmelden. HTTP ist an sich statuslos. Deshalb fehlt die Authentifizierung bei Deinen Requests. Das merkst Du nicht, weil Du den Status-Code nicht sinnvoll behandelst. Und der HEAD-Request ist absolut überflüssig, und wenn ich den noch einmal sehen muß, dann "Gute Nacht."
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

@Sirius3: Was ich nur nicht verstehe, ist die Authentifizierung. Ich benutze ja auth=HTTPBasicAuth.
Sirius3
User
Beiträge: 17741
Registriert: Sonntag 21. Oktober 2012, 17:20

nein, tust Du nicht.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

Das verwirrt mich nun. In Zeile 12 verwende ich doch auth=HTTPBasicAuth?

Code: Alles auswählen

def get_access_data_and_link(user_name, passwd):

    print "Name:", user_name
    print "Password", passwd
    url = 'http://xarphus.de/schutz/'

    res= requests.get(url, auth=HTTPBasicAuth(user_name, passwd))
    print "Status Code", res.status_code
    print "Content of txt-file", res.text
Name: Sophus
Password xxxx
Status Code 200
Content of txt-file http://xarphus.de/schutz/datei.rar
Passwort habe ich jetzt mal rausgenommen. In der Text-Datei steht diese URL, wo also die Datei zum Herunterladen liegt. Hätte ich keinen Zugang dann käme ich gar nicht an den Inhalt der Datei?
Sirius3
User
Beiträge: 17741
Registriert: Sonntag 21. Oktober 2012, 17:20

@Sophus: Dein Problem ist, dass Du nicht an den Inhalt von datei.rar kommst, weil Du Dich nicht authentifizierst.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

@Sirius3: Ich glaube jetzt geht bei mir ein Licht auf. Du meinst, meine Authentifizierung gilt nur das Lesen der Text-Datei, aber nicht für die rar-Datei?

Ich ging nämlich davon aus, dass ich mich mit dem nachfolgenden Quelltext bereits authentifiziert habe, und mich nun im geschützten Bereich tätigen kann wie ich mag. Genauso wie im Browser gibt man dort einmal seine Benutzerdaten ein, und kann durch sämtliche Unterorder des geschützten Bereich surfen. Da war ich wohl zu blauäugig. Ich muss mich also jedesmal erneut authentifizieren?

Code: Alles auswählen

import requests
from requests.auth import HTTPBasicAuth
resp = requests.get('http://xarphus.de/protect_folder/', auth=HTTPBasicAuth('test_account', 'test_user'))
print "Status: ", resp.status_code
content_txt_file = resp.text
print "Content of txt file: ", content_txt_file
Ich habe das Konto test_account mit dem Passwort test_user angelegt. Ist also funktionsfähig.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

Ich habe es mit einer "doppelten" Authentifizierung probiert, aber auch fehlgeschlagen. Ich veröffentliche mal mein Minimal-Programm, auch wenn der Quelltext totaler quatsch ist:

Code: Alles auswählen

import requests
import shutil
from requests.auth import HTTPBasicAuth

def log_in(user, pwd):
    s = requests.session()
    resp = s.get('http://xarphus.de/protect_folder/', auth=HTTPBasicAuth(user, pwd))
    print "Status: ", resp.status_code
    content_txt_file = resp.text
    print "Cookies: ", requests.utils.dict_from_cookiejar(s.cookies)
    print "Content of txt file: ", content_txt_file
    print "start downloading"
    response = s.get(content_txt_file, stream=True)
    with open('test_rar.rar', 'wb') as out_file:
        shutil.copyfileobj(response.raw, out_file)
    del response

if __name__ == '__main__':
    user_name = 'test_account'
    user_password = 'test_user'
    log_in(user_name, user_password)
Ich dachte, ich arbeite mal mit der Session, um die Sitzung mit den LogIn-Daten beizubehalten. Das Herunterladen wird vollzogen, aber die Datei ist nach wie vor 290 Byte groß.
Benutzeravatar
jens
Python-Forum Veteran
Beiträge: 8502
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Wie glaubst du, weiß ein Server ob ein user eingeloggt ist oder nicht?!?

Das Stichwort wäre: session cookie

GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Benutzeravatar
snafu
User
Beiträge: 6738
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Sophus hat geschrieben:Ich ging nämlich davon aus, (...)
Den Ausspruch habe ich jetzt schon mehrfach von dir gelesen und ich glaube, deine Annahme war jedes Mal ein totaler Griff ins Klo. Möglicherweise würde es ja Sinn machen, sich mit Fachliteratur zu befassen und das wilde Herumgerate ein bißchen zurück zu fahren. ;)

In einigen Fällen kann eine gezielte Google-Suche die Fachliteratur auch ersetzen (sofern man gute Online-Artikel nicht schon als Fachliteratur bezeichnen möchte). Aber das Programmieren völlig ins Blaue hinein kann auf diesem Themengebiet einfach nur schiefgehen.

Da hilft einem dann auch keine Bibliothek, wenn es an den Grundlagen schon scheitert. Die Bibliothek erleichtert in aller Regel ja nur die Anwendung. Man sollte als Programmierer trotzdem technisches Hintergrundwissen mitbringen, bei dem, was man tut.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

@snafu: Ich weiß, du meinst es gut. Also nimm es mir nicht persönlich was ich jetzt schreiben werde. Würde ich wild herumraten, so stünde da am Ende nur WirrWarr, ein Quelltext, der von der ersten Zeile an falsch ist. Trifft dies hierbei zu? 8) Ich möchte nicht raten, sondern versuchen es zu verstehen. Das ich nicht immer richtig liege oder Dinge nicht auf Anhieb alles richtig verstehe, ist richtig. Wäre ich richtig gut und ein Bill Gates 2.0, dann wär ich bestimmt nicht hier im Forum angemeldet oder? :)

EDIT: Finde ich es schon nahezu übertrieben, zu behaupten, ich mache grundsätzliche alles falsch, und sollte am Besten nochmal mit dem ABC unserer deutschen Muttersprache anfangen. Am Ende ist es vermutlich nur eine einzige Zeile, die ich vermutlich durch zu vieles Nachdenken übersehen habe. Das wäre ja so, als wenn ein Professor wegen einer falschen Zeile behaupten würde, meine ganze wissenschaftliche Arbeit wäre "hinfällig", und ich solle mir mal Literatur besorgen "Das ABC, wie schreibe ich eine wissenschaftliche Arbeit" :shock: Und am Ende habe ich nur eine Zeile falsch gemacht.
Benutzeravatar
Sophus
User
Beiträge: 1109
Registriert: Freitag 25. April 2014, 12:46
Wohnort: Osnabrück

Nun, damit wir hier nicht den Eindruck bekommen, dass ich hier wild auf die Tastatur klopfe - in der Hoffnung, es ergeben zufällig paar nützliche Python-Befehle - werde ich mich mal bemühen den Code so zu beschreiben wie ich ihn interpretiere. Es wird sich dann zeigen, ob ich wirklich nur blind rate :)

Zeile 1: Die Bibliothek requests wird importiert. Diese Bibliothek benötigen wir um später überhaupt mit dem Web-Server kommunizieren zu können
Zeile 2: Hier wird die "Basis Authentifizierung" importiert. Warum? Weil viele Web-Services, die eine Authentifizierung erfordern, in der Regel die HTTPBasicAuth akzeptieren.
Zeile 3: Die Bibliothek shutil wird importiert. Wird später für Dateioperationen benötigt (Kopiervorgang).
Zeile 5: Ich definiere hier eine def get_logged_in_session():-Funktion. Diese Funktion werden zwei Argumente hinzugefügt, einmal user und einmal pwd.
Zeile 7: Hier wird eine Session-Instanz aufgebaut. Mit diesem Session-Objekt wird ermöglicht, dass bestimmte Parameter (z.B. Benutzername und Passwort) bestehen bleiben.
Zeile 8: Nun erstelle ich mit HTTPBasicAuth eine Anfrage. Ich übergebe der get()-Methode eine URL, die geschützt ist, und dann durch einen Komma getrennt die Authentifizierung (auth=HTTPBasicAuth(user,pwd)). user und pwd sind hierbei Argumente. Wenn diese Funktion aufgerufen wird, werden der Funktion Argumente übergeben. Die Argumente werden verarbeitet und für die Anfrage verwendet. Jetzt habe ich ein sogenanntes Response-Objekt (resp). Dort werden die Informationen gespeichert. Dieser Vorgang ist deswegen wichtig, damit ich im späteren Verlauf immer wieder auf das Response-Objekt zugreifen kann.
Zeile 12: Das Response-Objekt verfügt über ein status_code()-Attribut. Ich lasse mir anzeigen, wie der gegenwärtige Status lautet. War die Anmeldung erfolgreich, dann bekommt man die Zahl 200. Bekommt man unter anderem die Zahl 401, dann kann man davon ausgehen, dass die Anmeldung fehlgeschlagen ist.
Zeile 13: Ich lasse mir mit Hilfe des text-Attributes den Inhalt ausgeben. Auf meinem Web-Server wird der entsprechende Anwender auf eine bestimmte nach erfolgreicher Anmeldung auf Text-Datei weitergeleitet. Hier bekomme ich also den Inhalt der Text-Datei angezeigt. In meinem Fall wird dann eine URL angezeigt. Der Inhalt wird in die content_txt_file-Variable gespeichert.
Zeile 14: Hier wird das Objekt cookie über die Print-Anweisung ausgegeben.
Zeile 15: Zur Überprüfung lasse noch einmal den Inhalt per Print-Anweisung ausgeben, um sicher zu gehen, ob ich hier eine URL habe. Also greife ich auf die content_txt_file-Variable zu.
Zeile 18: Hier wird das Herunterladen vorbereitet. Ich greife also auf die content_txt_file-Variable zu. Denn dort ist ja die URL gespeichert, die mir sagt, wo die Datei gespeichert ist. Darüber hinaus verwende ich stream=True. Auf diese Weise bleibt die Verbindung geöffnet und der Header wird heruntergeladen. All diese Information wird in ein Response-Objekt (response) gespeichert.
Zeile 19: Hier beginne ich mit einer with-Anweisung. Mit dieser Anweisung erspare ich mit hinterher das Schließen der Datei. Denn die with-Anweisung macht es quasi für mich. In der with-Anweisung finden wir zwei Parameter. Im ersten Parameter gebe ich einen Namen an. Den kann man beliebig benennen. Hier heißt meine Datei nach dem Herunterladen test_rar.rar. Der zweite Parameter besagt zunächst, dass schreibend (w) auf die Datei zugegriffen werden soll. Warum? Wenn eine Datei heruntergeladen wird, muss schreibend darauf zugegriffen werden. Das b ist ein Modus, hier greife ich also schreibend und binär auf die Datei zu. Innerhalb der with-Anweisung muss man diesen Vorgang mit eigenen Variablen deklarieren. Da es sich hierbei um eine heruntergeladene Datei handelt, die schreibend erstellt wird, deklariere ich es als (as) out_file. Im späteren Verlauf ist also die Variable out_file für die Verwendung wichtig.
Zeile 20: Jetzt kommen wir zum shutil-Modul. Ich bediene mich in diesem Kontext der copyfileobj ()-Methode. Warum? Wir erinnern uns, dass ich während des Herunterladen schreibend auf eine Datei zugreife. Mit diese Methode wird es mir also möglich sein, das Kopieren einer Datei mit dem tatsächlichen Dateiobjekt. Das heißt, die Datei, die auf dem Server liegt, wird schreibend auf dem lokalen Rechner asl Dateiobjekt kopiert. Mit einem Blick in die Methode sehen wir, dass ich response.raw verwende. Damit ich das Attribut raw verwenden kann, muss also stream=True gegeben sein. Ich bekomme hier also eine rohe Antwort vom Webserver. Und in dieser Methode steckt ein weiter Parameter out_file, hier wird gesagt, in welches Dateiobjekt die Datei auf dem Rechner kopiert werden soll, die vom Server herunterladen wird.
Zeile 21: Hier lösche ich das Response-Objekt, sprich ich leere das Objekt. Weil ich es nach dem erfolgreichen Herunterladen nicht mehr gebrauchen kann.
Zeile 22: Und ich schließe auch die erste Anfrage (resp), um die Kommunikation mit dem Web-Server zu unterbrechen. Ich muss ja nicht mehr mit dem Web-Server kommunizieren. Hat sich ja alles erledigt.
Zeile 25: Wird das Modul als Haupt-Modul gestartet, also nicht ein einem anderen Modul aus, dann greift hier eine Bedingung.
Zeile 26 und Zeile 27: : Hier werden Informationen für die Anmeldung in den jeweiligen Variablen gespeichert. Hier werden die Informationen mittels String-Literale angegeben, d. h. direkt im Modul angegeben. Die Angaben werden also nicht erst zur Laufzeit bekannt gegeben, sondern schon vorher festgelegt.
Zeile 28: Nun rufe ich die get_logged_in_session()-Funktion auf. Der Funktion werden dann die zuvor festgelegten Informationen (user_name und user_password) als Argumente übergeben.

Code: Alles auswählen

import requests
from requests.auth import HTTPBasicAuth
import shutil

def get_logged_in_session(user, pwd):

    s = requests.session()
    resp = s.get('http://xarphus.de/protect_folder/', auth=HTTPBasicAuth(user,pwd))

    print "Status: ", resp.status_code
    content_txt_file = resp.text
    print "Cookies: ", s.cookies
    print "Content of txt file: ", content_txt_file
    print "start downloading"
   
    response = s.get(content_txt_file, stream=True)
    with open('test_rar.rar', 'wb') as out_file:
        shutil.copyfileobj(response.raw, out_file)
    del response
    resp.close


if __name__ == '__main__':
    user_name = 'test_account'
    user_password = 'test_user'
    get_logged_in_session(user_name, user_password)
Zuletzt geändert von Sophus am Donnerstag 23. Juli 2015, 20:25, insgesamt 2-mal geändert.
Antworten