docs: async def prover_get_credentials_for_proof_req(wallet_handle: int,
                                                 proof_request_json: str) -> str:
      """
      Gets human readable credentials matching the given proof request.
  
      NOTE: This method is deprecated because immediately returns all fetched credentials.
      Use <prover_search_credentials_for_proof_req> to fetch records by small batches.
  
      :param wallet_handle: wallet handler (created by open_wallet).
      :param proof_request_json: proof request json
          {
              "name": string,
              "version": string,
              "nonce": string,
              "requested_attributes": { // set of requested attributes
                   "<attr_referent>": <attr_info>, // see below
                   ...,
              },
              "requested_predicates": { // set of requested predicates
                   "<predicate_referent>": <predicate_info>, // see below
                   ...,
               },
              "non_revoked": Optional<<non_revoc_interval>>, // see below,
                             // If specified prover must proof non-revocation
                             // for date in this interval for each attribute
                             // (can be overridden on attribute level)
          }
      where:
           attr_referent: Proof-request local identifier of requested attribute
           attr_info: Describes requested attribute
               {
                   "name": string, // attribute name, (case insensitive and ignore spaces)
                   "restrictions": Optional<[<filter_json>]>, // see above
                                    // if specified, credential must satisfy to one of the given restriction.
                   "non_revoked": Optional<<non_revoc_interval>>, // see below,
                                  // If specified prover must proof non-revocation
                                  // for date in this interval this attribute
                                  // (overrides proof level interval)
               }
           predicate_referent: Proof-request local identifier of requested attribute predicate
           predicate_info: Describes requested attribute predicate
               {
                   "name": attribute name, (case insensitive and ignore spaces)
                   "p_type": predicate type (Currently >= only)
                   "p_value": predicate value
                   "restrictions": Optional<[<filter_json>]>, // see above
                                   // if specified, credential must satisfy to one of the given restriction.
                   "non_revoked": Optional<<non_revoc_interval>>, // see below,
                                  // If specified prover must proof non-revocation
                                  // for date in this interval this attribute
                                  // (overrides proof level interval)
               }
           non_revoc_interval: Defines non-revocation interval
               {
                   "from": Optional<int>, // timestamp of interval beginning
                   "to": Optional<int>, // timestamp of interval ending
               }
      :return: json with credentials for the given proof request.
               {
                   "requested_attrs": {
                       "<attr_referent>": [{ cred_info: <credential_info>, interval: Optional<non_revoc_interval> }],
                       ...,
                   },
                   "requested_predicates": {
                       "requested_predicates": [{ cred_info: <credential_info>, timestamp: Optional<integer> }, { cred_info: <credential_2_info>, timestamp: Optional<integer> }],
                       "requested_predicate_2_referent": [{ cred_info: <credential_2_info>, timestamp: Optional<integer> }]
                   }
               }, where credential is
               {
                   "referent": <string>,
                   "attrs": [{"attr_name" : "attr_raw_value"}],
                   "schema_id": string,
                   "cred_def_id": string,
                   "rev_reg_id": Optional<int>,
                   "cred_rev_id": Optional<int>,
               }
      """
  
      logger = logging.getLogger(__name__)
      logger.debug("prover_get_credentials_for_proof_req: >>> wallet_handle: %r, proof_request_json: %r",
                   wallet_handle,
                   proof_request_json)
  
      if not hasattr(prover_get_credentials_for_proof_req, "cb"):
          logger.debug("prover_get_credentials_for_proof_req: Creating callback")
          prover_get_credentials_for_proof_req.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p))
  
      c_wallet_handle = c_int32(wallet_handle)
      c_proof_request_json = c_char_p(proof_request_json.encode('utf-8'))
  
      credentials_json = await do_call('indy_prover_get_credentials_for_proof_req',
                                       c_wallet_handle,
                                       c_proof_request_json,
                                       prover_get_credentials_for_proof_req.cb)
  
      res = credentials_json.decode()
      logger.debug("prover_get_credentials_for_proof_req: <<< res: %r", res)
      return res