1. import re
  2. import time
  3. from collections import deque
  5. class QueryStringResourceReleaser:
  6. def __init__(self, max_requests, rate_limit_duration=60):
  7. """
  8. Initializes the QueryStringResourceReleaser.
  10. Args:
  11. max_requests (int): The maximum number of allowed requests within the rate limit duration.
  12. rate_limit_duration (int): The duration of the rate limit in seconds.
  13. """
  14. self.max_requests = max_requests
  15. self.rate_limit_duration = rate_limit_duration
  16. self.request_queue = deque() # Queue to store request timestamps
  17. self.lock = time.monotonic() # Lock for thread-safe access
  19. def release_resource(self, query_string):
  20. """
  21. Releases resources associated with the given query string.
  23. Args:
  24. query_string (str): The query string to release resources for.
  25. """
  26. now = time.monotonic()
  28. # Check if the rate limit has been exceeded
  29. if self.is_rate_limited():
  30. wait_time = self.calculate_wait_time()
  31. print(f"Rate limited. Waiting {wait_time:.2f} seconds.")
  32. time.sleep(wait_time)
  33. self.reset_rate_limit()
  34. self.release_resource(query_string) #retry
  35. return
  37. # Release resources for the query string
  38. print(f"Releasing resources for query string: {query_string}")
  39. # Simulate resource release (e.g., closing connections, freeing memory)
  40. # In a real application, this would involve actual resource management.
  41. #print(f"Resource released for {query_string}") #Added for debugging
  43. def is_rate_limited(self):
  44. """
  45. Checks if the rate limit has been exceeded.
  47. Returns:
  48. bool: True if the rate limit is exceeded, False otherwise.
  49. """
  50. time_since_last_request = now - self.lock
  51. if time_since_last_request < self.rate_limit_duration:
  52. return True
  53. else:
  54. return False
  56. def calculate_wait_time(self):
  57. """
  58. Calculates the wait time required to satisfy the rate limit.
  60. Returns:
  61. float: The wait time in seconds.
  62. """
  63. time_since_last_request = now - self.lock
  64. wait_time = self.rate_limit_duration - time_since_last_request
  65. return max(0, wait_time)
  67. def reset_rate_limit(self):
  68. """
  69. Resets the rate limit timer.
  70. """
  71. self.lock = time.monotonic()
  72. self.request_queue.clear()
  74. if __name__ == '__main__':
  75. # Example Usage:
  76. releaser = QueryStringResourceReleaser(max_requests=2, rate_limit_duration=5)
  78. for i in range(5):
  79. query_string = f"query_{i}"
  80. releaser.release_resource(query_string)
  81. time.sleep(1) # Simulate requests coming in

Add your comment