original_docstring: 
      Checks the proof status in Keybase via the `sig/proof_live` endpoint.
      Returns a tuple (`proof_valid`, `proof_live`) indicating if the signature
      is live and if the proof is publicly verifiable to the Keybase
      client/server, respectively.
  
      Keybase suggests an asynchronous task that calls this endpoint during the
      proof creation flow. It will return (proof_valid=True, proof_live=False)
      until Keybase has seen it being served from this service's API, at which
      point it will update to (proof_valid=True, proof_live=True). This is the
      happy path.  It may also make sense to call this endpoint periodically or
      whenever a user inspects their own proof/profile/settings to update local
      records.  If a user revokes their proof from Keybase, this will return
      (profo_valid=False, proof_live=False).
      
docstring: Checks the proof status in Keybase via the `sig/proof_live` endpoint.
  Returns a tuple (`proof_valid`, `proof_live`) indicating if the signature
  is live and if the proof is publicly verifiable to the Keybase
  client/server, respectively.
  
  Keybase suggests an asynchronous task that calls this endpoint during the
  proof creation flow. It will return (proof_valid=True, proof_live=False)
  until Keybase has seen it being served from this service's API, at which
  point it will update to (proof_valid=True, proof_live=True). This is the
  happy path.  It may also make sense to call this endpoint periodically or
  whenever a user inspects their own proof/profile/settings to update local
  records.  If a user revokes their proof from Keybase, this will return
  (profo_valid=False, proof_live=False).
docstring_tokens: Checks the proof status in Keybase via the ` sig / proof_live ` endpoint . Returns a tuple ( ` proof_valid ` ` proof_live ` ) indicating if the signature is live and if the proof is publicly verifiable to the Keybase client / server respectively . Keybase suggests an asynchronous task that calls this endpoint during the proof creation flow . It will return ( proof_valid = True proof_live = False ) until Keybase has seen it being served from this service ' s API at which point it will update to ( proof_valid = True proof_live = True ) . This is the happy path . It may also make sense to call this endpoint periodically or whenever a user inspects their own proof / profile / settings to update local records . If a user revokes their proof from Keybase this will return ( profo_valid = False proof_live = False ) .
code: def is_proof_live(user, sig_hash, kb_username):
      """
      Checks the proof status in Keybase via the `sig/proof_live` endpoint.
      Returns a tuple (`proof_valid`, `proof_live`) indicating if the signature
      is live and if the proof is publicly verifiable to the Keybase
      client/server, respectively.
  
      Keybase suggests an asynchronous task that calls this endpoint during the
      proof creation flow. It will return (proof_valid=True, proof_live=False)
      until Keybase has seen it being served from this service's API, at which
      point it will update to (proof_valid=True, proof_live=True). This is the
      happy path.  It may also make sense to call this endpoint periodically or
      whenever a user inspects their own proof/profile/settings to update local
      records.  If a user revokes their proof from Keybase, this will return
      (profo_valid=False, proof_live=False).
      """
      domain = get_domain()
      endpoint = "https://keybase.io/_/api/1.0/sig/proof_live.json"
      try:
          r = requests.get(endpoint, params={
              'domain': domain,
              'username': user.username,
              'kb_username': kb_username,
              'sig_hash': sig_hash,
          })
          if r.status_code != 200:
              print("Invalid response:", r)
              return False, False
          r_json = r.json()
          return r_json.get('proof_valid', False), r_json.get('proof_live', False)
      except Exception:
          return False, False
code_tokens: def is_proof_live ( user , sig_hash , kb_username ) : domain = get_domain ( ) endpoint = "https://keybase.io/_/api/1.0/sig/proof_live.json" try : r = requests . get ( endpoint , params = { 'domain' : domain , 'username' : user . username , 'kb_username' : kb_username , 'sig_hash' : sig_hash , } ) if r . status_code != 200 : print ( "Invalid response:" , r ) return False , False r_json = r . json ( ) return r_json . get ( 'proof_valid' , False ) , r_json . get ( 'proof_live' , False ) except Exception : return False , False
short_docstring: Checks the proof status in Keybase via the `sig/proof_live` endpoint.
short_docstring_tokens: Checks the proof status in Keybase via the ` sig / proof_live ` endpoint .
comment: """
      Checks the proof status in Keybase via the `sig/proof_live` endpoint.
      Returns a tuple (`proof_valid`, `proof_live`) indicating if the signature
      is live and if the proof is publicly verifiable to the Keybase
      client/server, respectively.
  
      Keybase suggests an asynchronous task that calls this endpoint during the
      proof creation flow. It will return (proof_valid=True, proof_live=False)
      until Keybase has seen it being served from this service's API, at which
      point it will update to (proof_valid=True, proof_live=True). This is the
      happy path.  It may also make sense to call this endpoint periodically or
      whenever a user inspects their own proof/profile/settings to update local
      records.  If a user revokes their proof from Keybase, this will return
      (profo_valid=False, proof_live=False).
      """