Das deutsche Python-Forum

Code: Alles auswählen

def machcall_A(self,website,param1,param2...):
...
def machcall_B(self,website,param1,param2...):

Code: Alles auswählen

def limitkontrolle(self,website,Zeitlimit,CallLimit,Limitcount):
        anfangszeit = int(time.time() * 1000)

        #Zeitlimit  hier die Zeit in milisek eintragen, wie weit die CallLimit calls auseinander sein duerfen
        #CallLimit  Anzahl der Calls in in der Zeit Zeitlimit gemacht werden duerfen
        Ergebnisda = False
        timer = 0
        
        while not self.Datadict[website]["Limitdict"].get(Limitcount-1): # solange es den eintrag zuvor noch nicht gibt, nicht weitermachen
            if Limitcount==0: # wenn limitcount 0, dann ausnahme machen
                break
            timer += 1
            sleep(0.001)
            if timer>=10000: # notausstieg falls fehler in schleife und sonst unendlich (max 10 sek)
                print("unendlich LOOP schleife {} 1. Laenge:{}. Limitcount:{}".format(website,len(self.Datadict[website]["Limitdict"]),Limitcount))
                self.Datadict[website]["Schleifenposition"] = 0
                self.Datadict[website]["Limitdict"] = {}
                self.Datadict[website]["Limitcounter"] = 1
                #break
                return False
            continue  # unendliche oft im kreis drehen, bis eintrag exisitert
        

        while not Ergebnisda:
            sleepen = 0
            zeit = int(time.time() * 1000)
            if len(self.Datadict[website]["Limitdict"]): # wenn schon Eintraege enthalten sind 
                for position in range(self.Datadict[website]["Schleifenposition"],len(self.Datadict[website]["Limitdict"])+min(self.Datadict[website]["Limitdict"])): # min addieren heisst zu anfang null addieren. Aber wenn z.b alle eintraege von 0 bis 4 geloescht wurden, startet es bei 5, dann muss das hier auch bei 5 starten und bis laenge+5 gehen
                    differenz = zeit - self.Datadict[website]["Limitdict"][position] # jetzige Zeit mit erstem Eintrag vergleichen
                    if differenz <= Zeitlimit:  # hier die Zeit in milisek eintragen, wie weit die x calls auseinander sein duerfen
                        if Limitcount - position >= CallLimit:  # wenn die laenge der liste nun CallLimit oder mehr uebersteigt, dann sleepen
                            sleepen = self.Datadict[website]["Limitdict"][position] + Zeitlimit - zeit
                            self.Datadict[website]["Schleifenposition"] = position
                            break
                        else: # falls nicht,dann einfach weiter   
                            self.Datadict[website]["Schleifenposition"] = position # gibt an, bis zu welchem Punkt hinterher geloescht werden soll
                            break # und for schleife beenden, da alles fertig
                    else: # andernfalls alle listenelemte durchgehen, diese evlt rausschmeissen und wenn ueberall differenz <= y, dann liste loeschen und zeit als erten eintrag setzen
                        if position == len(self.Datadict[website]["Limitdict"])+min(self.Datadict[website]["Limitdict"])-1: # wenn das letzte listenelement erreicht ist und differenz offensichtlich immernoch groesser y, dann liste loeschen und nur noch neue zeit drin lassen
                            self.Datadict[website]["Schleifenposition"] = position # gibt an, bis zu welchem Punkt hinterher geloescht werden soll
                            break
                        else:
                            continue # naechste position durchgehen            
            if sleepen:
                sleep(sleepen/1000) # sleepen in sekunden
                continue # von vorne, damit zeit neu genommen wird

            if not sleepen:
                self.Datadict[website]["Limitdict"][Limitcount]=int(time.time() * 1000)
                Ergebnisda = True
                break
        endzeit = int(time.time() * 1000)
        dauer = (float(endzeit)-float(anfangszeit))/1000 # in sek
        if dauer>=0.5:
            self.history("Ein Apicall fuer {} wurde aufgrund des API Limits {} sekunden zurueckgehalten. Evlt. pruefen, ob limit optimaler genutzt werden kann, da durch das Warten viel Zeit verloren geht.".format(website,dauer),0,0,1)
        return True # Call kann gemacht werden

Code: Alles auswählen

In [1]: from collections import defaultdict

In [2]: import requests

In [3]: class limit:
   ...:     def __init__(self, target, limit):
   ...:         self.target = target
   ...:         self.limit = limit
   ...:         self.cache = defaultdict(int)
   ...:     
   ...:     def __call__(self, func):
   ...:         def inner(*args, **kwargs):
   ...:             target = kwargs[self.target]
   ...:             issued = self.cache.get(target, 0)
   ...:             if issued >= self.limit:
   ...:                 raise ValueError('Limit exceeded for parameter "{}"'.format(target))
   ...:             self.cache[target] += 1
   ...:             return func(*args, **kwargs)
   ...:         return inner
   ...:     

In [4]: @limit(limit=2, target='website')
   ...: def ping(*, website):
   ...:     result = requests.head(website)
   ...:     return result.status_code
   ...: 

In [5]: ping('http://127.0.0.1:8080')
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-5-5179bb6d5a6e> in <module>()
----> 1 ping('http://127.0.0.1:8080')

<ipython-input-3-a9f00dc00351> in inner(*args, **kwargs)
      7     def __call__(self, func):
      8         def inner(*args, **kwargs):
----> 9             target = kwargs[self.target]
     10             issued = self.cache.get(target, 0)
     11             if issued >= self.limit:

KeyError: 'website'

In [6]: ping(website='http://127.0.0.1:8080')
Out[6]: 200

In [7]: ping(website='http://127.0.0.1:8080')
Out[7]: 200

In [8]: ping(website='http://127.0.0.1:8080')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-8-cf3339e8a9a6> in <module>()
----> 1 ping(website='http://127.0.0.1:8080')

<ipython-input-3-a9f00dc00351> in inner(*args, **kwargs)
     10             issued = self.cache.get(target, 0)
     11             if issued >= self.limit:
---> 12                 raise ValueError('Limit exceeded for parameter "{}"'.format(target))
     13             self.cache[target] += 1
     14             return func(*args, **kwargs)

ValueError: Limit exceeded for parameter "http://127.0.0.1:8080"

In [9]: ping(website='http://127.0.0.1:8080/test')
Out[9]: 404

In [10]: ping(website='http://127.0.0.1:8080/test')
Out[10]: 404

In [11]: ping(website='http://127.0.0.1:8080/test')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-11-380d42fc74c0> in <module>()
----> 1 ping(website='http://127.0.0.1:8080/test')

<ipython-input-3-a9f00dc00351> in inner(*args, **kwargs)
     10             issued = self.cache.get(target, 0)
     11             if issued >= self.limit:
---> 12                 raise ValueError('Limit exceeded for parameter "{}"'.format(target))
     13             self.cache[target] += 1
     14             return func(*args, **kwargs)

ValueError: Limit exceeded for parameter "http://127.0.0.1:8080/test"

Code: Alles auswählen

class Limiter():

    def __init__(self, rate):
          self.rate = rate
          self.laufende_fragen =[]
          self.anfragen = Queue()
          threading.Thread(target=self.run)


     def darfich(self):
           e = Event()
           wartezeit = []
           self.anfragen.put((e, wartezeit))
           e.wait()
           time.sleep(wartezeit)
           

    def run(self):
         while True:
               e, wartezeit = self.anfragen.get()
               w = self.wann_darf_ich() # absoluter ts
               self.laufende_fragen.append(w)
               wartezeit.append(w-jetzt)
               e.notify()

Code: Alles auswählen

import time
import threading
import concurrent.futures
import queue

def print2(txt,*args):
    txt = str(time.time()) + ": " + txt
    print(txt,*args)

class Limiter():
 
    def __init__(self, zeitlimit, calllimit):
        self.zeitlimit = zeitlimit
        self.calllimit = calllimit # diese zahl an Calls darf innerhalb von zeitlimit sekunden gemacht werden.
        self.gemachte_anfragen =[]
        self.anfragen = queue.Queue()
        self.thread = threading.Thread(target=self.run)
 
 
    def darfich(self,a):
        e = threading.Event()
        wartezeit = []
        self.anfragen.put((e, wartezeit))
        e.wait()
        print2("darfich {} sleep {}".format(a,wartezeit[0]))
        if wartezeit[0] > 0:
            time.sleep(wartezeit[0])
           
    
    def wann_darfich(self):
        anfragencopy = self.gemachte_anfragen[:] # eine Kopie machen, damit einträge entfernt werden können (gehts auch weniger fehleranfällig?)
        jetzt = time.time()
        for timestamp in anfragencopy:
            if timestamp < jetzt - self.zeitlimit:
                self.gemachte_anfragen.remove(timestamp) # alle zu alten einträge entfernen, damit len() hinterher gleich den bereits gemachten calls in unserm zeitlimit entspricht
        if len(self.gemachte_anfragen) < self.calllimit:
            return jetzt #darf also sofort gemacht werden
        else: # es wurden soviele wie erlaubt gemacht oder gar mehr, dann warten
            return self.gemachte_anfragen[0] + self.zeitlimit # self.gemachte_anfragen[0] ist der timestamp des ältesten calls
            
    
    def run(self):
        count = 0
        while True:
            count += 1
            e, wartezeit = self.anfragen.get() # wartet, bis etwas vorhanden ist ... nur wie beende ich das, wenn ich es nicht mehr brauche?
            w = self.wann_darfich() # absoluter ts
            self.gemachte_anfragen.append(w)
            wartezeit.append(w-time.time())
            e.set()
            if count>=5: # notmaßnahme damit der thread beendet wird
                return
            
limit = Limiter(5,2) # -> alle 5 sekunden werden 2 calls erlaubt

def test(a):
    limit.darfich(a)
    print2("test {}".format(a))
    return a
     
               
if __name__ == '__main__':  
    limit.thread.start()
    pool = concurrent.futures.ThreadPoolExecutor(5) 
    futures = []
    futures.append(pool.submit(test, 1))
    futures.append(pool.submit(test, 2))
    futures.append(pool.submit(test, 3))
    futures.append(pool.submit(test, 4))
    futures.append(pool.submit(test, 5))
    concurrent.futures.wait(futures) 
    print2("Vollständig beendet!")

Code: Alles auswählen

import time
import threading
import concurrent.futures
import queue

def print2(txt,*args):
    txt = str(time.time()) + ": " + txt
    print(txt,*args)

class Limiter():
 
    def __init__(self, zeitlimit, calllimit):
        self.zeitlimit = zeitlimit
        self.calllimit = calllimit # diese zahl an Calls darf innerhalb von zeitlimit sekunden gemacht werden.
        self.gemachte_anfragen =[]
        self.anfragen = queue.Queue()
        self.thread = threading.Thread(target=self.run)
 
 
    def darfich(self,a):
        e = threading.Event()
        wartezeit = []
        self.anfragen.put((e, wartezeit))
        e.wait()
        print2("darfich {} sleep {}".format(a,wartezeit[0]))
        if wartezeit[0] > 0:
            time.sleep(wartezeit[0])
           
    
    def wann_darfich(self):
        jetzt = time.time()

        anfragencopy = self.gemachte_anfragen[:] # eine Kopie machen, damit einträge entfernt werden können (gehts auch weniger fehleranfällig?)
        for timestamp in anfragencopy:
            if timestamp < jetzt - self.zeitlimit:
                self.gemachte_anfragen.remove(timestamp) # alle zu alten einträge entfernen.

        if len(self.gemachte_anfragen) < self.calllimit:
            return jetzt
            
        relevantecalls = self.gemachte_anfragen[-self.calllimit:] # auch zukünftige timestamps muessen beachtet werden

        if len(relevantecalls) < self.calllimit:
            return jetzt
        else: # es wurden soviele wie erlaubt gemacht oder gar mehr, dann warten
            return relevantecalls[0] + self.zeitlimit # relevantecalls[0] ist der timestamp des ältesten relevanten calls
            
    
    def run(self):
        count = 0
        while True:
            count += 1
            e, wartezeit = self.anfragen.get() # wartet, bis etwas vorhanden ist ... nur wie beende ich das, wenn ich es nicht mehr brauche?
            w = self.wann_darfich() # absoluter ts
            self.gemachte_anfragen.append(w)
            wartezeit.append(w-time.time())
            e.set() # e.wait() in "darfich" beenden
            if count>=7: # notmaßnahme damit der thread beendet wird
                return

                
limit = Limiter(5,2)

def test(a):
    limit.darfich(a)
    print2("test {}".format(a))
    return a
     
               
if __name__ == '__main__':  
    limit.thread.start()
    pool = concurrent.futures.ThreadPoolExecutor(7) 
    futures = []
    futures.append(pool.submit(test, 1))
    futures.append(pool.submit(test, 2))
    futures.append(pool.submit(test, 3))
    futures.append(pool.submit(test, 4))
    futures.append(pool.submit(test, 5))
    futures.append(pool.submit(test, 6))
    futures.append(pool.submit(test, 7))
    concurrent.futures.wait(futures) 
    print2("Vollständig beendet!")

Code: Alles auswählen

def run(self):
        while True:
            try:
                e, wartezeit = self.anfragen.get(timeout=0.001) # wartet, bis etwas vorhanden ist
            except queue.Empty:
                if not self.wirdgebraucht:
                    return
                continue # das warten von get() muss ab und zu unterbrochen werden, um zu schauen, ob dieser Thread noch gebraucht wird, oder nicht. Zb. wenn sonst alles fertig ist, sollte das hier auch beendet werden

            w = self.wann_darfich() # absoluter ts
            self.gemachte_anfragen.append(w)
            wartezeit.append(w-time.time())
            e.set() # e.wait() in "darfich" beenden
            if not self.wirdgebraucht:
                return