code: async def throttle(self, key, *, rate=None, user=None, chat=None, no_error=None) -> bool:
          
          if not self.storage.has_bucket():
              raise RuntimeError('This storage does not provide Leaky Bucket')
  
          if no_error is None:
              no_error = self.no_throttle_error
          if rate is None:
              rate = self.throttling_rate_limit
          if user is None and chat is None:
              user = types.User.get_current()
              chat = types.Chat.get_current()
  
          # Detect current time
          now = time.time()
  
          bucket = await self.storage.get_bucket(chat=chat, user=user)
  
          # Fix bucket
          if bucket is None:
              bucket = {key: {}}
          if key not in bucket:
              bucket[key] = {}
          data = bucket[key]
  
          # Calculate
          called = data.get(LAST_CALL, now)
          delta = now - called
          result = delta >= rate or delta <= 0
  
          # Save results
          data[RESULT] = result
          data[RATE_LIMIT] = rate
          data[LAST_CALL] = now
          data[DELTA] = delta
          if not result:
              data[EXCEEDED_COUNT] += 1
          else:
              data[EXCEEDED_COUNT] = 1
          bucket[key].update(data)
          await self.storage.set_bucket(chat=chat, user=user, bucket=bucket)
  
          if not result and not no_error:
              # Raise if it is allowed
              raise Throttled(key=key, chat=chat, user=user, **data)
          return result
docs: Execute throttling manager.
          Returns True if limit has not exceeded otherwise raises ThrottleError or returns False
  
          :param key: key in storage
          :param rate: limit (by default is equal to default rate limit)
          :param user: user id
          :param chat: chat id
          :param no_error: return boolean value instead of raising error
          :return: bool