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 यह सुविधा उस एप्लिकेशन के लिए आवश्यक है जिसे मैं बनाने का प्रयास कर रहा हूं

आपके आवेदन के लिए @brenthermana , दर सीमा शीर्षलेखों का निरीक्षण करने पर विचार करें (अंतिम प्रतिक्रिया का; ऊपर मेरे उदाहरण में देखें) या /rate_limit समापन बिंदु को स्वयं मतदान करें। इसमें सभी प्रकार की दर सीमाओं के बारे में जानकारी होती है और किसी भी दर सीमा की गणना नहीं की जाती है।

आखिरकार, यह अच्छा होगा यदि PyGithub न केवल rate को पार्स करेगा बल्कि /rate_limit रिटर्न से resources को भी पार्स करेगा। जानकारी है, यह दुर्भाग्य से पुस्तकालय के उपभोक्ताओं को उपलब्ध नहीं कराया जाता है।

साथ ही, पृष्ठांकित सूची को कोड खोज के लिए दर सीमा वापस करनी चाहिए यदि यह ऐसी खोज के परिणाम लौटाती है, अर्थात जो कुछ भी _headers['x-ratelimit-*'] में संग्रहीत है।

बीटीडब्ल्यू: मैंने अभी देखा, जेएसओएन से rate /rate_limit लौटाया गया है और resources में जानकारी अनुशंसित विकल्प है: https://developer.github.com/ v3/rate_limit/# पदावनति-सूचना

मैं ठीक यही कर रहा हूं। अगर कोई इसे अनुकूलित करना चाहता है और एक पुल अनुरोध करने का प्रयास करना चाहता है, तो आपको मेरा आशीर्वाद है:

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)

मुझे एक समस्या का सामना करना पड़ रहा है जहां 1869 परिणाम होने पर 1020 परिणामों के बाद search_issues के परिणामों पर मेरा पुनरावृत्ति बंद हो जाता है। मेरी लिपि हर बार एक ही बिंदु पर रुकती है। क्या यह दर-सीमित मुद्दा हो सकता है?

मुझे कोई त्रुटि नहीं मिलती है, परिणाम बस समाप्त हो जाते हैं। अगर मैं अपनी क्वेरी स्ट्रिंग को सीधे गिटहब वेब इंटरफेस में डालता हूं तो मुझे उम्मीद के मुताबिक सभी 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/दर_सीमा/

खोज 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!

खोज दर सीमित करने की समस्याओं से बचने के लिए @brenthermana के प्रतीक्षा फ़ंक्शन का अनुकरण करने के लिए, अब आप कुछ इस तरह कर सकते हैं:

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)

कोर/खोज/ग्राफकल को ध्यान में रखने के लिए उपरोक्त पोकी डेकोरेटर का संशोधित संस्करण।
इसके अलावा 30 सेकंड की देरी भी जोड़ी गई क्योंकि जीथब दर सीमा को ठीक उसी समय रीसेट नहीं करता है जब वह कहता है।

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