Pygithub: Поддержка ограничения скорости поиска

Я вижу ту же проблему. Вот небольшой скрипт, иллюстрирующий проблему.

import os
from datetime import datetime
from github import Github

# Login
TOKEN = os.getenv("GITHUB_ACCESS_TOKEN")
github = Github(TOKEN)

# Get initial rate limit and reset time
rl1 = github.get_rate_limit().rate
print("RL1 | Limit: {}, Remaining: {}, Reset: {}.".format(
    rl1.limit, rl1.remaining, rl1.reset))
# RL1 | Limit: 5000, Remaining: 5000, Reset: 2017-09-22 17:26:35.

# Perform a search
results = github.search_code("Hello World")

# Rate limit of Github instance is unchanged after a search
rl2 = github.get_rate_limit().rate
print("RL2 | Limit: {}, Remaining: {}, Reset: {}.".format(
    rl2.limit, rl2.remaining, rl2.reset))
# RL2 | Limit: 5000, Remaining: 5000, Reset: 2017-09-22 17:26:35.

# The PaginatedList instance has a Requestor with the same info
rl3 = results._PaginatedList__requester.rate_limiting
rl3_reset = datetime.utcfromtimestamp(int(
        results._PaginatedList__requester.rate_limiting_resettime))
print("RL3 | Limit: {}, Remaining: {}, Reset: {}.".format(
    rl3[0], rl3[1], rl3_reset))
# RL3 | Limit: 5000, Remaining: 5000, Reset: 2017-09-22 17:26:35.

# However, the actual ContentFile results show a different limit
# The Requester of each individual result ...
result = results[0]
rl4 = result._requester.rate_limiting
rl4_reset = datetime.utcfromtimestamp(int(
        result._requester.rate_limiting_resettime))
print("RL4 | Limit: {}, Remaining: {}, Reset: {}.".format(
    rl4[1], rl4[0], rl4_reset))
# RL4 | Limit: 30, Remaining: 29, Reset: 2017-09-22 16:27:36.

# ... and headers stored in the content file directly show a different rate limit.
rl5_limit = result._headers['x-ratelimit-limit']
rl5_remaining = result._headers['x-ratelimit-remaining']
rl5_reset = datetime.utcfromtimestamp(int(
        result._headers['x-ratelimit-reset']))
print("RL5 | Limit: {}, Remaining: {}, Reset: {}.".format(
    rl5_limit, rl5_remaining, rl5_reset))
# RL5 | Limit: 30, Remaining: 29, Reset: 2017-09-22 16:27:36.

# In the end, the main Github instance still shows the original full rate limit
rl6 = github.get_rate_limit().rate
print("RL6 | Limit: {}, Remaining: {}, Reset: {}.".format(
    rl6.limit, rl6.remaining, rl6.reset))
# RL6 | Limit: 5000, Remaining: 5000, Reset: 2017-09-22 17:26:35.

+1 Эта функция необходима для приложения, которое я пытаюсь создать.

@brentshermana для вашего приложения, рассмотрите возможность проверки заголовков ограничения скорости (последнего ответа; см. Мой пример выше) или самостоятельного опроса конечной точки /rate_limit . Это содержит информацию обо всех видах ограничений скорости и не засчитывается в какое-либо ограничение скорости.

В конце концов, было бы неплохо, если бы PyGithub не только анализировал rate , но и анализировал resources из того, что возвращает /rate_limit . Информация есть, к сожалению, она не доступна для пользователей библиотеки.

Кроме того, список с разбивкой на страницы должен возвращать ограничение скорости поиска по коду, если он возвращает результаты такого поиска, то есть все, что хранится в _headers['x-ratelimit-*'] .

Кстати: я только что заметил, что поле rate из JSON, возвращаемое /rate_limit , устарело, а информация в resources является рекомендуемой альтернативой: https://developer.github.com/ v3/rate_limit/#deprecation -уведомление

Я делаю именно это. Если кто-то хочет адаптировать это и попытаться сделать запрос на вытягивание, я благословляю вас:

def wait(seconds):
    print("Waiting for {} seconds ...".format(seconds))
    time.sleep(seconds)
    print("Done waiting - resume!")

def api_wait():
    url = 'https://api.github.com/rate_limit'
    response = urlopen(url).read()
    data = json.loads(response.decode())
    if data['resources']['core']['remaining'] <= 10:  # extra margin of safety
        reset_time = data['resources']['core']['reset']
        wait(reset_time - time.time() + 10)
    elif data['resources']['search']['remaining'] <= 2:
        reset_time = data['resources']['search']['reset']
        wait(reset_time - time.time() + 10)

Я столкнулся с проблемой, когда моя итерация по результатам search_issues останавливается после 1020 результатов, когда должно быть 1869 результатов. Мой скрипт каждый раз останавливается в одном и том же месте. Может ли это быть проблемой ограничения скорости?

Я не получаю ошибку, результаты просто заканчиваются. Если я помещу свою строку запроса непосредственно в веб-интерфейс GitHub, я увижу все результаты 1869, как и ожидалось. 1020 кратно 30, что заставляет меня задуматься, не проблема ли это с нумерацией страниц?

Код выглядит следующим образом:

querystring = "type:pr is:closed repo:xxxx closed:2017-07-01..2018-06-30"
issues = git.search_issues(query=querystring, sort="updated", order="asc")
for issue in issues:
    pull = issue.as_pull_request()
    print "%s: %s" % (pull.number, pull.title)

Большое спасибо за любые советы, которыми вы можете поделиться, относительно того, что здесь может пойти не так.

Я также попытался повторить issues.reversed , чтобы увидеть, начнется ли он в конце моих ожидаемых результатов 1869. Однако в этом случае я получаю только 30 вопросов с первой страницы результатов.

Дальнейшее расследование показало, что я упираюсь в 1000 результатов на поисковый лимит .

Как насчет того, чтобы мы предоставили еще один метод get_search_rate_limit() для ограничения скорости поиска, в то время как существующий get_rate_limit() будет анализировать последнее «основное» ограничение скорости, предложенное Github: https://developer.github.com/ v3/rate_limit/

Ограничение скорости поиска API и ограничение скорости GraphQL уже доступны. Один метод для всех.

По умолчанию он покажет вам «основной» предел скорости. Вы также можете получить ограничение скорости поиска/графика, обратившись к соответствующим атрибутам.

r = g.get_rate_limit()
>>> r
RateLimit(core=Rate(remaining=4923, limit=5000))
>>> r.search
Rate(remaining=30, limit=30)
>>> r.graphql
Rate(remaining=5000, limit=5000)

Выглядит отлично, спасибо @sfdye!

Чтобы эмулировать функцию ожидания @brentshermana , чтобы избежать проблем с ограничением скорости поиска, теперь вы можете сделать что-то вроде этого:

from datetime import datetime

def api_wait_search(git):
  limits = git.get_rate_limit()
  if limits.search.remaining <= 2:
    seconds = (limits.search.reset - datetime.now()).total_seconds()
    print "Waiting for %d seconds ..." % (seconds)
    time.sleep(seconds)
    print "Done waiting - resume!"

Обратите внимание, что вызов get_rate_limit() вызовет небольшую задержку, поэтому вы можете свести к минимуму частоту его вызова.

Для людей, которые попадают сюда из поисковой системы, я немного изменил функцию @bbi-yggy:

from datetime import datetime, timezone

def rate_limited_retry(github):
    def decorator(func):
        def ret(*args, **kwargs):
            for _ in range(3):
                try:
                    return func(*args, **kwargs)
                except RateLimitExceededException:
                    limits = github.get_rate_limit()
                    reset = limits.search.reset.replace(tzinfo=timezone.utc)
                    now = datetime.now(timezone.utc)
                    seconds = (reset - now).total_seconds()
                    print(f"Rate limit exceeded")
                    print(f"Reset is in {seconds:.3g} seconds.")
                    if seconds > 0.0:
                        print(f"Waiting for {seconds:.3g} seconds...")
                        time.sleep(seconds)
                        print("Done waiting - resume!")
            raise Exception("Failed too many times")
        return ret
    return decorator

Эту функцию можно использовать следующим образом:

@rate_limited_retry(github)
def run_query(import_string):
    query_string = f"language:Python \"{import_string}\""
    return list(github.search_code(query_string))

results = run_query(import_string)

Модифицированная версия декоратора pokey выше, чтобы учесть core/search/graphql.
Также добавлена ​​30-секундная задержка, потому что Github не сбрасывает ограничение скорости точно в указанное время.

def rate_limited_retry():
    def decorator(func):
        def ret(*args, **kwargs):
            for _ in range(3):
                try:
                    return func(*args, **kwargs)
                except RateLimitExceededException:
                    limits = gh.get_rate_limit()
                    print(f"Rate limit exceeded")
                    print("Search:", limits.search, "Core:", limits.core, "GraphQl:", limits.graphql)

                    if limits.search.remaining == 0:
                        limited = limits.search
                    elif limits.graphql.remaining == 0:
                        limited = limits.graphql
                    else:
                        limited = limits.core
                    reset = limited.reset.replace(tzinfo=timezone.utc)
                    now = datetime.now(timezone.utc)
                    seconds = (reset - now).total_seconds() + 30
                    print(f"Reset is in {seconds} seconds.")
                    if seconds > 0.0:
                        print(f"Waiting for {seconds} seconds...")
                        time.sleep(seconds)
                        print("Done waiting - resume!")
            raise Exception("Failed too many times")
        return ret
    return decorator