Python Tweepy Streaming mit

Question

Multitasking

in Python 2.7 Ich bin erfolgreich in dem folgenden Code verwenden, um eine direkte Nachrichtenstrom auf einem Konto zu hören:

from tweepy import Stream 
from tweepy import OAuthHandler 
from tweepy import API 
from tweepy.streaming import StreamListener 

# These values are appropriately filled in the code 

consumer_key = '######' 
consumer_secret = '######' 
access_token = '######' 
access_token_secret = '######' 

class StdOutListener(StreamListener): 

    def __init__(self): 
     self.tweetCount = 0 

    def on_connect(self): 
     print("Connection established!!") 

    def on_disconnect(self, notice): 
     print("Connection lost!! : ", notice) 

    def on_data(self, status): 
     print("Entered on_data()") 
     print(status, flush = True) 
     return True 
     # I can add code here to execute when a message is received, such as slicing the message and activating something else 

    def on_direct_message(self, status): 
     print("Entered on_direct_message()") 
     try: 
      print(status, flush = True) 
      return True 
     except BaseException as e: 
      print("Failed on_direct_message()", str(e)) 

    def on_error(self, status): 
     print(status) 

def main(): 

    try: 
     auth = OAuthHandler(consumer_key, consumer_secret) 
     auth.secure = True 
     auth.set_access_token(access_token, access_token_secret) 

     api = API(auth) 

     # If the authentication was successful, you should 
     # see the name of the account print out 
     print(api.me().name) 

     stream = Stream(auth, StdOutListener()) 

     stream.userstream() 

    except BaseException as e: 
     print("Error in main()", e) 

if __name__ == '__main__': 
    main() 

Das ist großartig, und ich kann auch Code ausführen, wenn ich erhalte eine Nachricht, aber die Jobs, die ich zu einer Arbeitswarteschlange hinzufüge, müssen nach einer gewissen Zeit anhalten können. Ich verwende einen populären Start = time.time() und subtrahiere die aktuelle Zeit, um die verstrichene Zeit zu bestimmen, aber dieser Streaming-Code führt keine Schleife durch, um die Zeit zu überprüfen. Ich warte nur auf eine neue Nachricht, also wird die Uhr nie sozusagen überprüft.

Meine Frage ist dies: Wie kann ich Streaming auftreten und noch verstrichene Zeit verfolgen? Muss ich Multithreading wie in diesem Artikel beschrieben verwenden? http://www.tutorialspoint.com/python/python_multithreading.htm

Ich bin neu bei Python und habe Spaß beim Spielen mit Hardware an einem Raspberry Pi. Ich habe so viel von Stackoverflow gelernt, danke euch allen :)

Answer 1

ich genau bin nicht sicher, wie Sie entscheiden wollen, wann man aufhören muss, aber Sie können einen timeout argument an den Strom passieren nach einer gewissen Verzögerung aufgeben.

stream = Stream(auth, StdOutListener(), timeout=30) 

Das on_timeout() method Ihre Zuhörer nennen. Wenn Sie true zurückgeben, wird das Streaming fortgesetzt. Sonst wird es aufhören.

Zwischen dem Timeout-Argument des Streams und dem on_timeout() Ihres Hörers sollten Sie entscheiden können, wann das Streaming beendet werden soll.

Answer 2

Ich fand, dass ich etwas Multithreading-Code bekommen konnte, wie ich es wollte. Unlike this tutorial from Tutorialspoint, die ein Beispiel für das Starten mehrerer Instanzen desselben Codes mit unterschiedlichen Timing-Parametern gibt, konnte ich zwei verschiedene Code-Blöcke in ihren eigenen Instanzen ausführen

Ein Codeblock addiert ständig 10 zu einer globalen Variablen (var). Ein weiterer Block prüft, wann 5 Sekunden verstrichen sind und gibt dann den Wert von var aus.

Dies zeigt zwei verschiedene Aufgaben beim Ausführen und Freigeben von Daten mit Python Multithreading.

Siehe Code unten

import threading 
import time 

exitFlag = 0 
var = 10 

class myThread1 (threading.Thread): 
    def __init__(self, threadID, name, counter): 
     threading.Thread.__init__(self) 
     self.threadID = threadID 
     self.name = name 
     self.counter = counter 
    def run(self): 
     #var counting block begins here 
     print "addemup starting" 
     global var 
     while (var < 100000): 
      if var > 90000: 
       var = 0 
      var = var + 10 



class myThread2 (threading.Thread): 
    def __init__(self, threadID, name, counter): 
     threading.Thread.__init__(self) 
     self.threadID = threadID 
     self.name = name 
     self.counter = counter 
    def run(self): 
     #time checking block begins here and prints var every 5 secs 
     print "checkem starting" 
     global var 
     start = time.time() 
     elapsed = time.time() - start 
     while (elapsed < 10): 
      elapsed = time.time() - start 
      if elapsed > 5: 
       print "var = ", var 
       start = time.time() 
       elapsed = time.time() - start 

# Create new threads 
thread1 = myThread1(1, "Thread-1", 1) 
thread2 = myThread2(2, "Thread-2", 2) 

# Start new Threads 
thread1.start() 
thread2.start() 

print "Exiting Main Thread" 

wird Meine nächste Aufgabe Meine Twitter in seinem eigenen Thread-Streaming werden Zerschlagung und Leiten direkte Nachrichten als Variablen zu einer Aufgabe empfangene Programm Schlange stehen, während hoffentlich der erste Thread weiter Höre auf direktere Nachrichten.