apirlpy 0.0.4__tar.gz

apirlpy-0.0.4/LICENSE.txt

@@ -0,0 +1,8 @@
+Copyright 2026 Shaik Naseer John Ahmed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

apirlpy-0.0.4/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: apirlpy
+Version: 0.0.4
+Summary: A Python Based API RateLimiter 
+Author-email: Shaik Naseer John Ahmed <sknaseer.fez@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Naseer-fez/Apirl-py
+Project-URL: Issues, https://github.com/Naseer-fez/Apirl-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.4
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+##  How to Run
+```python
+from apirlpy import  ratelimiter as APIRL
+#Import the Function
+
+# Checking rate limit for a specific IP
+CoolDown=APIRL(IP_Adrs="127.0.0.1", #IP address ofthe Client
+#_______________________________________________________________
+Cleaning=False, #To Enable the Ip Address  Cleaning 
+CleaningFreq=80,# The Frequency at which the cleaning shoudl occur
+AutoUpdate=False, #If you want to update the Data only after a certain time to reduce I/O operations
+UpdateFreq=70, #(value in sec) of auto update
+CooldownTime=20, #Amount of time differnce the Clients last vist shoudld 
+# exced for the IP address cleaner to remove the data
+#    ***  FOR JSON AND SQL Format only     ***
+#If passed to "no stograge" option then this arguments will not be passed to the ratelimiter
+#_______________________________________________________________
+AllowedFreq=8, #The Number of Fair attempts the Client can send the request to the server
+ResetTime=8, # After the Client is denied the access , how much time 
+#they need to wait to get the access again 
+Filename="Test", # The file name to store the data
+Format="sql", # The File extenstion type which the ratelimiter is going to use to store the data
+# Extensions available are : sql to use sqllite , json to use json format and "None" for No storage option  
+# If nothing is mentioned then the data will not be stored
+FolderPath=None # The path at which u want to store this results
+
+)
+if CoolDown == 1: #The Client  can  access the API
+    print( "You are a Valid user")
+else: # the Request is denied 
+    print( f"You need to wait {CoolDown}")
+   ```
+**This is a test code **
+### The Code Return 
+- 1 : Means the Client Can Access the API
+- other than 1: Means the Client Need to wait for the access of the API
+___
+
+
+

apirlpy-0.0.4/README.md

@@ -0,0 +1,40 @@
+##  How to Run
+```python
+from apirlpy import  ratelimiter as APIRL
+#Import the Function
+
+# Checking rate limit for a specific IP
+CoolDown=APIRL(IP_Adrs="127.0.0.1", #IP address ofthe Client
+#_______________________________________________________________
+Cleaning=False, #To Enable the Ip Address  Cleaning 
+CleaningFreq=80,# The Frequency at which the cleaning shoudl occur
+AutoUpdate=False, #If you want to update the Data only after a certain time to reduce I/O operations
+UpdateFreq=70, #(value in sec) of auto update
+CooldownTime=20, #Amount of time differnce the Clients last vist shoudld 
+# exced for the IP address cleaner to remove the data
+#    ***  FOR JSON AND SQL Format only     ***
+#If passed to "no stograge" option then this arguments will not be passed to the ratelimiter
+#_______________________________________________________________
+AllowedFreq=8, #The Number of Fair attempts the Client can send the request to the server
+ResetTime=8, # After the Client is denied the access , how much time 
+#they need to wait to get the access again 
+Filename="Test", # The file name to store the data
+Format="sql", # The File extenstion type which the ratelimiter is going to use to store the data
+# Extensions available are : sql to use sqllite , json to use json format and "None" for No storage option  
+# If nothing is mentioned then the data will not be stored
+FolderPath=None # The path at which u want to store this results
+
+)
+if CoolDown == 1: #The Client  can  access the API
+    print( "You are a Valid user")
+else: # the Request is denied 
+    print( f"You need to wait {CoolDown}")
+   ```
+**This is a test code **
+### The Code Return 
+- 1 : Means the Client Can Access the API
+- other than 1: Means the Client Need to wait for the access of the API
+___
+
+
+

apirlpy-0.0.4/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+
+
+[project]
+name = "apirlpy"
+# name="Api_RateLimiter"
+version = "0.0.4"
+authors = [
+  { name="Shaik Naseer John Ahmed",email="sknaseer.fez@gmail.com" },
+]
+description = "A Python Based API RateLimiter "
+readme = "README.md"
+requires-python = ">=3.4"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/Naseer-fez/Apirl-py"
+Issues = "https://github.com/Naseer-fez/Apirl-py/issues"

apirlpy-0.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

apirlpy-0.0.4/src/apirlpy/ARL_json.py

@@ -0,0 +1,245 @@
+import os
+import sys
+from pathlib import Path
+import json
+import time
+import threading
+import copy
+
+
+
+class __RateLimiter:
+    __isfileopen :bool = False
+    __samplefile = Path(sys.modules['__main__'].__file__).stem
+    def __init__(self,filename=__samplefile,filetype="json",folder=None):
+        self.thread_running = False
+        self.filename=filename 
+        self.filetype=filetype
+        self.Data=dict()
+        self.CurrentFile=None
+        self.lock = threading.RLock()
+        self.stop_event = threading.Event()
+        self.fullpath=os.path.join(folder or "", f"{filename}.{filetype}")
+        self.Validopen=self.__Fileopener()
+
+        pass
+    def API_RL(self,IP_Adrs:str,Cleaning=False,AutoUpdate=False,
+               CooldownTime=20,AllowedFreq=8,CleaningFreq=80,ResetTime=8,
+               UpdateFreq=80)->int:
+        # if isinstance(ipaddress,str):
+        #     self.ip=int(ipaddress.ip_address(IP_Adrs))
+        # else:print("Here")
+        #     self.ip=IP_Adrs
+        self.AutoUpdate=AutoUpdate
+        self.Metrics={
+            "CooldownTime":CooldownTime,
+            "AllowedFreq":AllowedFreq,
+           
+                 }
+        # background_thread = threading.Thread(target=self.hehe, args=(start_val,), daemon=True)
+        if (Cleaning or (AutoUpdate)) and not self.thread_running:
+            self.thread_running=True
+            BackgroundThread=threading.Thread(
+            
+                target=self.__BackgroundWorker,
+                args=(CleaningFreq,ResetTime,UpdateFreq,Cleaning,),
+                daemon=False)
+            BackgroundThread.start()
+            
+        return self.__Validator(ip=IP_Adrs)
+    def __Fileopener(self)->int:
+        if getattr(self, "__isfileopen", False):
+            return 0
+        data=dict()
+        fullpath=self.fullpath
+        try:
+            with open (fullpath,'r') as File:
+                try:
+                    self.CurrentFile = open(fullpath, 'r+')
+                    self.Data=json.load(File)
+                    self.__isfileopen=True
+                    return 1
+                except  json.JSONDecodeError as error:
+                    return 0
+
+                except FileNotFoundError as Fnf:
+
+                    return self.__Filedumper(operation=0)
+        except FileNotFoundError as Fnf:
+                self.CurrentFile=open(fullpath, 'w')
+                # print("HAHHA")
+                # json.dump({},self.CurrentFile,indent=4)
+                return 1
+            # return self.__Filedumper(operation=0)
+
+        except FileExistsError as FEE:
+
+             return 0
+        except Exception as error:
+ 
+            print(error)
+            return 0
+    def __Filedumper(self,operation=0,Data=None,update=1)->int:
+        # print(Data)
+        # if msg is not None: print(msg[0])
+        if (self.AutoUpdate and update) :
+            return 1
+        try:  
+            with self.lock:
+                # if msg is not None: print(msg[1])    
+                fullpath=self.fullpath
+                flag=0
+                
+                if Data is None:
+                    Data={}
+                if self.CurrentFile is None:
+                    self.CurrentFile = open(fullpath, 'w')    
+                try:
+                    self.CurrentFile.seek(0)
+                    json.dump(Data,self.CurrentFile,indent=4)
+                    self.CurrentFile.truncate()
+                    self.CurrentFile.flush()
+                    flag=1
+                    
+                except Exception as e:
+                    try :
+                        with open("LOg..txt",'a') as file:
+                            record=f"{time.time()}:Error is {e}\n"
+                            file.write(record)
+                            
+                        flag=0
+                    except Exception as err:
+                        flag=0
+
+                if operation==1:               
+                        self.CurrentFile.close()
+                        self.__isfileopen=False
+                        return 1
+                else:
+                    self.__isfileopen=True
+                    return flag
+        except Exception as e:
+            print("HEHEH")
+
+            
+                            
+        pass           
+    def __Validator(self,ip:int)->int:
+
+            currenttime=int(time.time())
+            error=False
+            flag=1
+            with self.lock:  
+                try:
+                    lastseen=currenttime-self.Data[ip]["LastSeenTime"]
+                except KeyError:
+
+                    self.Data[ip]={
+                        # "WaitTime":0,
+                        "WaitStamp":0,
+                        "LastSeenTime":currenttime,
+                        "Visits":1   
+                    }
+                    error=True
+                self.Data[ip]["LastSeenTime"]=currenttime
+                if  error is False:
+                    if lastseen>self.Metrics["CooldownTime"]:
+                            # self.Data[ip]["WaitTime"]=0
+                            self.Data[ip]["WaitStamp"]=0
+                            self.Data[ip]["Visits"]=1
+                            flag= 1
+                    else:
+                        Datacopy=copy.deepcopy(self.Data)
+                        self.Data[ip],flag=  self.__RecentVists(Data=Datacopy[ip],CrnTime=currenttime)
+
+                self.__Filedumper(Data=self.Data,update=0)                    
+                return (flag or error)   
+    def __RecentVists(self,Data,CrnTime)->tuple: #Solution For DeadLock
+        
+
+        if Data["Visits"]<=self.Metrics["AllowedFreq"]:
+            Data["WaitStamp"]=0
+            Data["Visits"]+=1
+            return (Data,1)
+        # timetowait=0
+        if Data["WaitStamp"]==0:
+            Data["WaitStamp"]=CrnTime+self.Metrics["CooldownTime"]
+            Data["Visits"]+=1
+            return (Data,self.Metrics["CooldownTime"])
+        else:
+            timetosend=Data["WaitStamp"]-CrnTime
+            Data["Visits"]+=1
+            if timetosend<=0:
+                Data["WaitStamp"]=0
+                Data["Visits"]=0
+                timetosend=1
+            
+            return (Data,timetosend)        
+    def __BackgroundWorker(self,ClnFrq=100,restlimit=80,UpdateFreq=80,Cleaning=False):
+        
+        self.thread_running=True
+        CleanData={}
+        Slptime=self.__Timecalculator(ClnFrq,UpdateFreq)
+        while not self.stop_event.is_set():
+            # print("Inside the Loop")
+            # self.stop_event.wait(ClnFrq)
+            if self.stop_event.is_set():
+                break
+            if Cleaning:
+                with self.lock:
+                    # print("Inside the Lock")
+                    currenttime=int(time.time())
+                    # Keystodelete=[]
+                    changes=False
+                    CleanData=self.Data.copy()
+                    keys=list(CleanData.keys())
+                    for ip in keys:
+                        # print("Checking IPs")
+                        # print("Key here")
+                        if(currenttime-CleanData[ip]["LastSeenTime"]>restlimit):
+                            # print("BYEEE")
+                            # Keystodelete.append(ip)
+                            # print("Found IP")
+                            changes=True
+                            try:
+                                del CleanData[ip]
+                            except Exception as e:
+                                print(e)
+                    if changes is True:
+                        # print("Bye IPPPP")
+                        self.Data=CleanData
+                        changes=False
+            
+            self.__Filedumper(Data=self.Data)
+                # print("Sleep")
+
+            # print("Loop End")
+            time.sleep(Slptime)
+        self.thread_running = False 
+    def __Timecalculator(self,CleaningFrq,UpdateFreq)->int:
+        return UpdateFreq                    
+
+__Rl=__RateLimiter()
+def Ratelimiter(IP_Adrs:str,Cleaning=False,AutoUpdate=False,
+                CooldownTime=20,AllowedFreq=8,CleaningFreq=80,ResetTime=8,UpdateFreq=8,Filename=None,FolderPath=None)->int:
+    global __Rl
+    if (Filename is not None) and (FolderPath is not None):
+        __Rl = __RateLimiter(filename=Filename, folder=FolderPath)
+    
+    return (__Rl.API_RL(IP_Adrs=IP_Adrs,Cleaning=Cleaning,AutoUpdate=AutoUpdate,
+               CooldownTime=CooldownTime,AllowedFreq=AllowedFreq,CleaningFreq=CleaningFreq,ResetTime=ResetTime,UpdateFreq=UpdateFreq))
+
+            
+            
+if __name__=="__main__":
+
+    
+    v=Ratelimiter("127.0.0.2",Cleaning=0,CleaningFreq=1,CooldownTime=7)
+    print(v)
+
+            
+        
+
+
+
+

apirlpy-0.0.4/src/apirlpy/ARL_nostorage.py

@@ -0,0 +1,142 @@
+import time
+import threading
+
+
+
+class __RateLimiter:
+   
+    def __init__(self):
+        self.thread_running = False       
+        self.Data=dict()
+        self.stop_event = threading.Event()
+        self.lock = threading.RLock()
+
+        pass
+    def API_RL(self,IP_Adrs:str,Cleaning=False,CleaningFreq=80,CooldownTime=80,AllowedFreq=10,ResetTime=100)->int:
+        # if isinstance(ipaddress,str):
+        #     self.ip=int(ipaddress.ip_address(IP_Adrs))
+        # else:print("Here")
+        self.Metrics={
+            "CooldownTime":CooldownTime,
+            "AllowedFreq":AllowedFreq}
+        if (Cleaning ) and not self.thread_running:
+            self.thread_running=True
+            BackgroundThread=threading.Thread(
+            
+                target=self.__BackgroundWorker,
+                args=(CleaningFreq,ResetTime,),
+                daemon=True)
+            BackgroundThread.start()
+            
+        return self.__Validator(ip=IP_Adrs)
+    def __Validator(self,ip:int)->int:
+
+            currenttime=int(time.time())
+            error=False
+            flag=1
+            with self.lock:  
+                try:
+                    lastseen=currenttime-self.Data[ip]["LastSeenTime"]
+                except KeyError:
+
+                    self.Data[ip]={
+                        # "WaitTime":0,
+                        "WaitStamp":0,
+                        "LastSeenTime":currenttime,
+                        "Visits":1   
+                    }
+                    error=True
+                self.Data[ip]["LastSeenTime"]=currenttime
+                if  error is False:
+                    if lastseen>self.Metrics["CooldownTime"]:
+                            # self.Data[ip]["WaitTime"]=0
+                            self.Data[ip]["WaitStamp"]=0
+                            self.Data[ip]["Visits"]=1
+                            flag= 1
+                    else:
+                        self.Data[ip],flag=  self.__RecentVists(Data=self.Data[ip],CrnTime=currenttime)
+
+                return (flag or error)   
+    def __RecentVists(self,Data,CrnTime)->tuple: #Solution For DeadLock
+        
+
+        if Data["Visits"]<=self.Metrics["AllowedFreq"]:
+            Data["WaitStamp"]=0
+            Data["Visits"]+=1
+            return (Data,1)
+        # timetowait=0
+        if Data["WaitStamp"]==0:
+            Data["WaitStamp"]=CrnTime+self.Metrics["CooldownTime"]
+            Data["Visits"]+=1
+            return (Data,self.Metrics["CooldownTime"])
+        else:
+            timetosend=Data["WaitStamp"]-CrnTime
+            Data["Visits"]+=1
+            if timetosend<=0:
+                Data["WaitStamp"]=0
+                Data["Visits"]=0
+                timetosend=1
+            
+            return (Data,timetosend)        
+    def __BackgroundWorker(self,ClnFrq=100,restlimit=100):
+        
+        self.thread_running=True
+        self.Data={}
+        
+        while not self.stop_event.is_set():
+            # print("Inside the Loop")
+                # self.stop_event.wait(ClnFrq)
+                if self.stop_event.is_set():
+                    break
+           
+                with self.lock:
+                    # print("Inside the Lock")
+                    currenttime=int(time.time())
+                    # Keystodelete=[]
+                    changes=False
+                    keys=list(self.Data.keys())
+                    for ip in keys:
+                        # print("Checking IPs")
+                        # print("Key here")
+                        if(currenttime-self.Data[ip]["LastSeenTime"]>restlimit):
+                            # print("BYEEE")
+                            # Keystodelete.append(ip)
+                            # print("Found IP")
+                            changes=True
+                            try:
+                                del self.Data[ip]
+                            except Exception as e:
+                                print(e)
+                    if changes is True:
+                        # print("Bye IPPPP")
+                        self.Data=self.Data
+                        changes=False
+            
+                # print("Sleep")
+
+            # print("Loop End")
+                time.sleep(ClnFrq)
+        self.thread_running = False 
+               
+
+__Rl=__RateLimiter()
+def Ratelimiter(IP_Adrs:str,Cleaning=False,CleaningFreq=80,AllowedFreq=10,ResetTime=100)->int:
+    global __Rl
+   
+    
+    return (__Rl.API_RL(IP_Adrs=IP_Adrs,Cleaning=Cleaning,CleaningFreq=CleaningFreq,AllowedFreq=AllowedFreq,ResetTime=ResetTime))
+
+            
+            
+if __name__=="__main__":
+
+    
+    v=Ratelimiter("127.0.0.2",Cleaning=0,CleaningFreq=1)
+    print(v)
+
+            
+        
+
+
+
+

apirlpy-0.0.4/src/apirlpy/ARL_sql.py

@@ -0,0 +1,258 @@
+import os
+import sys
+from pathlib import Path
+import json
+import time
+import threading
+import copy
+import sqlite3
+
+
+class __RateLimiter:
+    __isfileopen :bool = False
+    __samplefile = Path(sys.modules['__main__'].__file__).stem
+    def __init__(self,filename=__samplefile,filetype="db",folder=None):
+        self.thread_running = False
+        self.filename=filename 
+        self.filetype=filetype
+        self.Data=dict()
+        self.CurrentFile=None
+        self.lock = threading.RLock()
+        self.stop_event = threading.Event()
+        self.fullpath=os.path.join(folder or "", f"{filename}.{filetype}")
+        self.cursor=None
+        self.connection=None
+        self.Validopen=self.__Fileopener()
+        self.AutoUpdate=False
+        self.Changes=set()
+        pass
+    def API_RL(self,IP_Adrs:str,Cleaning=False,AutoUpdate=False,
+               CooldownTime=20,AllowedFreq=8,CleaningFreq=80,ResetTime=8,
+               UpdateFreq=80)->int:
+        # if isinstance(ipaddress,str):
+        #     self.ip=int(ipaddress.ip_address(IP_Adrs))
+        # else:print("Here")
+        #     self.ip=IP_Adrs
+        self.AutoUpdate=AutoUpdate
+        self.Metrics={
+            "CooldownTime":CooldownTime,
+            "AllowedFreq":AllowedFreq,
+           
+                 }
+        # background_thread = threading.Thread(target=self.hehe, args=(start_val,), daemon=True)
+        if (Cleaning or (AutoUpdate)) and not self.thread_running:
+            try:
+                self.thread_running=True
+                BackgroundThread=threading.Thread(
+                
+                    target=self.__BackgroundWorker,
+                    args=(CleaningFreq,ResetTime,UpdateFreq,Cleaning,),
+                    daemon=False)
+                BackgroundThread.start()
+            except Exception as e:
+                print("Erro reached")
+                Cleaning=False
+                AutoUpdate=False
+        return self.__Validator(ip=IP_Adrs)
+    def __Fileopener(self)->int:
+        if getattr(self, "__isfileopen", False):
+            return 0
+        data=dict()
+        fullpath=self.fullpath
+        ##Sql implementation here now
+        try: 
+            self.CurrentFile=f"{self.fullpath}"
+            self.__isfileopen=True
+            self.connection=sqlite3.connect(self.CurrentFile,check_same_thread=False, 
+    timeout=10.0)
+            self.cursor=self.connection.cursor()
+            self.cursor.execute('''
+                        create table if not exists UserIps(
+                            IP Text primary key,
+                                Data TEXT
+                                )''') #Table is created 
+            self.cursor.execute("SELECT IP, Data FROM UserIps")#Get the data
+            self.Data={row[0]: json.loads(row[1]) for row in self.cursor.fetchall()}
+            self.__isfileopen=False
+            self.connection.commit()
+            
+        except Exception as e:
+            print(e)
+            return 0 
+        return 1
+    def __Filedumper(self,operation=0,Data=None,update=1)->int:
+        # print(Data)
+        # if msg is not None: print(msg[0])
+        if (update & self.AutoUpdate) :
+            return 1
+        try:  
+            with self.lock:
+                # if msg is not None: print(msg[1])    
+                fullpath=self.fullpath
+                flag=0
+                
+                if Data is None:
+                    Data={}
+                
+                try:
+                   #Write the data 
+                    toupdate=list()
+                    while self.Changes:
+                        values=self.Changes.pop()
+                        datatodump=json.dumps(self.Data[values])
+                        toupdate.append((values,datatodump))
+                    if toupdate:
+                        self.cursor.executemany("INSERT OR REPLACE INTO UserIps (IP, Data) VALUES (?, ?)", toupdate)
+                    self.connection.commit()
+                    flag=1
+
+                except Exception as e:
+                    try :
+                        with open("Log.txt",'a') as file:
+                            record=f"{time.time()}:Error is {e}\n"
+                            file.write(record)
+                            
+                        flag=0
+                    except Exception as err:
+                        flag=0
+
+                if operation==1:               
+                        self.CurrentFile.close()
+                        self.__isfileopen=False
+                        return 1
+                else:
+                    self.__isfileopen=True
+                    return flag
+        except Exception as e:
+            with open("Log.txt",'a') as file:
+                        record=f"{time.time()}:Error is {e}\n"
+                        file.write(record)
+
+            
+                            
+        pass           
+    def __Validator(self,ip:int)->int:
+
+            currenttime=int(time.time())
+            error=False
+            flag=1
+            with self.lock:  
+                try:
+                    lastseen=currenttime-self.Data[ip]["LastSeenTime"]
+                except KeyError:
+
+                    self.Data[ip]={
+                        # "WaitTime":0,
+                        "WaitStamp":0,
+                        "LastSeenTime":currenttime,
+                        "Visits":1   
+                    }
+                    error=True
+                self.Data[ip]["LastSeenTime"]=currenttime
+                if  error is False:
+                    if lastseen>self.Metrics["CooldownTime"]:
+                            # self.Data[ip]["WaitTime"]=0
+                            self.Data[ip]["WaitStamp"]=0
+                            self.Data[ip]["Visits"]=1
+                            flag= 1
+                    else:
+                        Datacopy=copy.deepcopy(self.Data)
+                        self.Data[ip],flag=  self.__RecentVists(Data=Datacopy[ip],CrnTime=currenttime)
+
+                self.__Filedumper(Data=self.Data)
+                self.Changes.add(ip)                    
+                return (flag or error)   
+    def __RecentVists(self,Data,CrnTime)->tuple: #Solution For DeadLock
+        
+
+        if Data["Visits"]<=self.Metrics["AllowedFreq"]:
+            Data["WaitStamp"]=0
+            Data["Visits"]+=1
+            return (Data,1)
+        # timetowait=0
+        if Data["WaitStamp"]==0:
+            Data["WaitStamp"]=CrnTime+self.Metrics["CooldownTime"]
+            Data["Visits"]+=1
+            return (Data,self.Metrics["CooldownTime"])
+        else:
+            timetosend=Data["WaitStamp"]-CrnTime
+            Data["Visits"]+=1
+            if timetosend<=0:
+                Data["WaitStamp"]=0
+                Data["Visits"]=0
+                timetosend=1
+            
+            return (Data,timetosend)        
+    def __BackgroundWorker(self,ClnFrq=100,restlimit=80,UpdateFreq=80,Cleaning=False):
+        
+        self.thread_running=True
+        CleanData={}
+        Slptime=self.__Timecalculator(ClnFrq,UpdateFreq)
+        while not self.stop_event.is_set():
+            # print("Inside the Loop")
+            # self.stop_event.wait(ClnFrq)
+            if self.stop_event.is_set():
+                break
+            #here write about the clenaing freq
+            self.__Filedumper(Data=self.Data,update=0)
+            if Cleaning:
+
+                currenttime=int(time.time())
+                try:
+                    query="""
+                    DELETE FROM UserIps 
+                    WHERE ? - json_extract(Data, '$.LastSeenTime') > ?
+                    RETURNING IP
+                    """
+                    self.cursor.execute(query,(currenttime,restlimit))
+                    deleted_rows = self.cursor.fetchall()
+                    if deleted_rows:
+                        self.connection.commit()
+                    with self.lock: 
+                        for row in deleted_rows:
+                            deleted_ip=row[0]
+                            self.Data.pop(deleted_ip,None)
+                # except sqlite3.OperationalError as e:
+                # #"""THis is the no coloum found error wont be that expsenive and also it will spoil the log.txt so 
+                # #  it is better now to log this error
+                #      pass
+                except Exception as e:
+                        with open("Log.txt",'a') as file:
+                            record=f"{time.time()}:Error is {e}\n"
+                            file.write(record)
+                # print("Sleep")
+            
+            # print("Loop End")
+            time.sleep(Slptime)
+        self.thread_running = False 
+    def __Timecalculator(self,CleaningFrq,UpdateFreq)->int:
+        #Need to create a proper time calcuator here
+        return CleaningFrq                
+
+__Rl=__RateLimiter()
+def Ratelimiter(IP_Adrs:str,Cleaning=False,AutoUpdate=False,
+                CooldownTime=20,AllowedFreq=8,CleaningFreq=80,ResetTime=8,UpdateFreq=8,Filename=None,FolderPath=None)->int:
+    global __Rl
+    if (Filename is not None) and (FolderPath is not None):
+        __Rl = __RateLimiter(filename=Filename, folder=FolderPath)
+    
+# def API_RL(self,IP_Adrs:str,Cleaning=False,AutoUpdate=False,
+#                CooldownTime=20,AllowedFreq=8,CleaningFreq=80,ResetTime=8,
+#                UpdateFreq=80)
+    
+    return (__Rl.API_RL(IP_Adrs=IP_Adrs,Cleaning=Cleaning,AutoUpdate=AutoUpdate,
+               CooldownTime=CooldownTime,AllowedFreq=AllowedFreq,CleaningFreq=CleaningFreq,ResetTime=ResetTime,UpdateFreq=UpdateFreq))
+
+            
+if __name__=="__main__":
+
+    
+    v=Ratelimiter("127.0.0.2",Cleaning=0,CleaningFreq=1,CooldownTime=7)
+    print(v)
+
+            
+        
+
+
+
+

apirlpy-0.0.4/src/apirlpy/__init__.py

@@ -0,0 +1,3 @@
+from .ratelimiter import ratelimiter
+
+__all__=["ratelimiter"]

apirlpy-0.0.4/src/apirlpy/ratelimiter.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+import sys
+__isfileopen :bool = False
+___samplefile = Path(sys.modules['__main__'].__file__).stem
+def ratelimiter(IP_Adrs:str,Cleaning=False,AutoUpdate=False,
+                CooldownTime=20,AllowedFreq=8,CleaningFreq=80,ResetTime=8,UpdateFreq=8,Filename=___samplefile,FolderPath=None,Format=None)->int:
+    if Format is None:
+        from .ARL_nostorage import Ratelimiter as Rl
+        return Rl(IP_Adrs=IP_Adrs,Cleaning=Cleaning,CleaningFreq=CleaningFreq,AllowedFreq=AllowedFreq,ResetTime=ResetTime)
+    if (isinstance(Format,str) is False):
+        raise TypeError("Only String Option is Availabe for Format Option")
+    elif (Format.lower())=="json":
+        from  .ARL_json import Ratelimiter as Rl
+        return Rl(
+            IP_Adrs=IP_Adrs,Cleaning=Cleaning,AutoUpdate=AutoUpdate,
+                CooldownTime=CooldownTime,AllowedFreq=AllowedFreq,CleaningFreq=CleaningFreq,ResetTime=ResetTime,
+                UpdateFreq=UpdateFreq,Filename=Filename,FolderPath=FolderPath)        
+    elif Format.lower()=="sql" :
+        from .ARL_sql import Ratelimiter as Rl
+        return Rl(
+                IP_Adrs=IP_Adrs,Cleaning=Cleaning,AutoUpdate=AutoUpdate,
+                    CooldownTime=CooldownTime,AllowedFreq=AllowedFreq,CleaningFreq=CleaningFreq,ResetTime=ResetTime,
+                    UpdateFreq=UpdateFreq,Filename=Filename,FolderPath=FolderPath)
+    else :
+        raise TypeError("""
+        Format Extensions available here  
+        is not valid please provide a valid extension,
+        Availabe : Sql,json,Nostorage
+        Format : json,sql ,(Python (None))
+        """)
+        
+if __name__=="__main__":
+    options=[None,"json","sql"]
+    ip="111"
+
+    for i in options:
+        ARL(Format=i,IP_Adrs=ip)
+        print(f"Format:{i}")

apirlpy-0.0.4/src/apirlpy.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: apirlpy
+Version: 0.0.4
+Summary: A Python Based API RateLimiter 
+Author-email: Shaik Naseer John Ahmed <sknaseer.fez@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Naseer-fez/Apirl-py
+Project-URL: Issues, https://github.com/Naseer-fez/Apirl-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.4
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+##  How to Run
+```python
+from apirlpy import  ratelimiter as APIRL
+#Import the Function
+
+# Checking rate limit for a specific IP
+CoolDown=APIRL(IP_Adrs="127.0.0.1", #IP address ofthe Client
+#_______________________________________________________________
+Cleaning=False, #To Enable the Ip Address  Cleaning 
+CleaningFreq=80,# The Frequency at which the cleaning shoudl occur
+AutoUpdate=False, #If you want to update the Data only after a certain time to reduce I/O operations
+UpdateFreq=70, #(value in sec) of auto update
+CooldownTime=20, #Amount of time differnce the Clients last vist shoudld 
+# exced for the IP address cleaner to remove the data
+#    ***  FOR JSON AND SQL Format only     ***
+#If passed to "no stograge" option then this arguments will not be passed to the ratelimiter
+#_______________________________________________________________
+AllowedFreq=8, #The Number of Fair attempts the Client can send the request to the server
+ResetTime=8, # After the Client is denied the access , how much time 
+#they need to wait to get the access again 
+Filename="Test", # The file name to store the data
+Format="sql", # The File extenstion type which the ratelimiter is going to use to store the data
+# Extensions available are : sql to use sqllite , json to use json format and "None" for No storage option  
+# If nothing is mentioned then the data will not be stored
+FolderPath=None # The path at which u want to store this results
+
+)
+if CoolDown == 1: #The Client  can  access the API
+    print( "You are a Valid user")
+else: # the Request is denied 
+    print( f"You need to wait {CoolDown}")
+   ```
+**This is a test code **
+### The Code Return 
+- 1 : Means the Client Can Access the API
+- other than 1: Means the Client Need to wait for the access of the API
+___
+
+
+

apirlpy-0.0.4/src/apirlpy.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/apirlpy/ARL_json.py
+src/apirlpy/ARL_nostorage.py
+src/apirlpy/ARL_sql.py
+src/apirlpy/__init__.py
+src/apirlpy/ratelimiter.py
+src/apirlpy.egg-info/PKG-INFO
+src/apirlpy.egg-info/SOURCES.txt
+src/apirlpy.egg-info/dependency_links.txt
+src/apirlpy.egg-info/top_level.txt

apirlpy-0.0.4/src/apirlpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

apirlpy-0.0.4/src/apirlpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+apirlpy