<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="freebase_v1.html">Freebase Search</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#new_batch_http_request">new_batch_http_request()</a></code></p>
<p class="firstline">Create a BatchHttpRequest object based on the discovery document.</p>
<p class="toc_element">
  <code><a href="#reconcile">reconcile(lang=None, confidence=None, name=None, prop=None, limit=None, kind=None)</a></code></p>
<p class="firstline">Reconcile entities to Freebase open data.</p>
<p class="toc_element">
  <code><a href="#search">search(domain=None, help=None, query=None, scoring=None, filter=None, prefixed=None, with=None, mid=None, encode=None, limit=None, type=None, as_of_time=None, stemmed=None, format=None, spell=None, exact=None, lang=None, indent=None, cursor=None, callback=None, without=None, output=None, mql_output=None)</a></code></p>
<p class="firstline">Search Freebase open data.</p>
<p class="toc_element">
  <code><a href="#search_media">search_media(domain=None, help=None, query=None, scoring=None, filter=None, prefixed=None, with=None, mid=None, encode=None, limit=None, type=None, as_of_time=None, stemmed=None, format=None, spell=None, exact=None, lang=None, indent=None, cursor=None, callback=None, without=None, output=None, mql_output=None)</a></code></p>
<p class="firstline">Search Freebase open data.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="new_batch_http_request">new_batch_http_request()</code>
  <pre>Create a BatchHttpRequest object based on the discovery document.

        Args:
          callback: callable, A callback to be called for each response, of the
            form callback(id, response, exception). The first parameter is the
            request id, and the second is the deserialized response object. The
            third is an apiclient.errors.HttpError exception object if an HTTP
            error occurred while processing the request, or None if no error
            occurred.

        Returns:
          A BatchHttpRequest object based on the discovery document.
        </pre>
</div>

<div class="method">
    <code class="details" id="reconcile">reconcile(lang=None, confidence=None, name=None, prop=None, limit=None, kind=None)</code>
  <pre>Reconcile entities to Freebase open data.

Args:
  lang: string, Languages for names and values. First language is used for display. Default is 'en'. (repeated)
  confidence: number, Required confidence for a candidate to match. Must be between .5 and 1.0
  name: string, Name of entity.
  prop: string, Property values for entity formatted as
: (repeated)
  limit: integer, Maximum number of candidates to return.
  kind: string, Classifications of entity e.g. type, category, title. (repeated)

Returns:
  An object of the form:

    {
    "costs": { # Server costs for reconciling.
      "hits": 42, # Total number of hits found.
      "ms": 42, # Total milliseconds spent.
    },
    "warning": [ # If filled, then there were recoverable problems that affected the request. For example, some of the properties were ignored because they either are not valid Freebase predicates or are not indexed for reconciliation. The candidates returned should be considered valid results, with the caveat that sections of the request were ignored as specified by the warning text.
      {
        "reason": "A String", # Code for identifying classes of warnings.
        "message": "A String", # Warning message to display to the user.
        "location": "A String", # Location of warning in the request e.g. invalid predicate.
      },
    ],
    "match": { # If filled, this entity is guaranteed to match at requested confidence probability (default 99%).
      "lang": "A String", # Language code that candidate and notable names are displayed in.
      "confidence": 3.14, # Percentage likelihood that this candidate is the unique matching entity. Value will be between 0.0 and 1.0
      "notable": { # Type or profession the candidate is notable for.
        "id": "A String", # MID of notable category.
        "name": "A String", # Name of notable category in specified language.
      },
      "mid": "A String", # Freebase MID of candidate entity.
      "name": "A String", # Freebase name of matching entity in specified language.
    },
    "candidate": [ # If filled, then the listed candidates are potential matches, and such should be evaluated by a more discerning algorithm or human. The matches are ordered by confidence.
      {
        "lang": "A String", # Language code that candidate and notable names are displayed in.
        "confidence": 3.14, # Percentage likelihood that this candidate is the unique matching entity. Value will be between 0.0 and 1.0
        "notable": { # Type or profession the candidate is notable for.
          "id": "A String", # MID of notable category.
          "name": "A String", # Name of notable category in specified language.
        },
        "mid": "A String", # Freebase MID of candidate entity.
        "name": "A String", # Freebase name of matching entity in specified language.
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="search">search(domain=None, help=None, query=None, scoring=None, filter=None, prefixed=None, with=None, mid=None, encode=None, limit=None, type=None, as_of_time=None, stemmed=None, format=None, spell=None, exact=None, lang=None, indent=None, cursor=None, callback=None, without=None, output=None, mql_output=None)</code>
  <pre>Search Freebase open data.

Args:
  domain: string, Restrict to topics with this Freebase domain id. (repeated)
  help: string, The keyword to request help on.
    Allowed values
      langs - The language codes served by the service.
      mappings - The property/path mappings supported by the filter and output request parameters.
      predicates - The predicates and path-terminating properties supported by the filter and output request parameters.
  query: string, Query term to search for.
  scoring: string, Relevance scoring algorithm to use.
    Allowed values
      entity - Use freebase and popularity entity ranking.
      freebase - Use freebase entity ranking.
      schema - Use schema ranking for properties and types.
  filter: string, A filter to apply to the query. (repeated)
  prefixed: boolean, Prefix match against names and aliases.
  with: string, A rule to match against. (repeated)
  mid: string, A mid to use instead of a query. (repeated)
  encode: string, The encoding of the response. You can use this parameter to enable html encoding.
    Allowed values
      html - Encode certain characters in the response (such as tags and ambersands) using html encoding.
      off - No encoding of the response. You should not print the results directly on an web page without html-escaping the content first.
  limit: integer, Maximum number of results to return.
  type: string, Restrict to topics with this Freebase type id. (repeated)
  as_of_time: string, A mql as_of_time value to use with mql_output queries.
  stemmed: boolean, Query on stemmed names and aliases. May not be used with prefixed.
  format: string, Structural format of the json response.
    Allowed values
      ac - Compact format useful for autocomplete/suggest UIs.
      classic - [DEPRECATED] Same format as was returned by api.freebase.com.
      entity - Basic information about the entities.
      guids - [DEPRECATED] Ordered list of a freebase guids.
      ids - Ordered list of freebase ids.
      mids - Ordered list of freebase mids.
  spell: string, Request 'did you mean' suggestions
    Allowed values
      always - Request spelling suggestions for any query at least three characters long.
      no_results - Request spelling suggestions if no results were found.
      no_spelling - Don't request spelling suggestions.
  exact: boolean, Query on exact name and keys only.
  lang: string, The code of the language to run the query with. Default is 'en'. (repeated)
  indent: boolean, Whether to indent the json results or not.
  cursor: integer, The cursor value to use for the next page of results.
  callback: string, JS method name for JSONP callbacks.
  without: string, A rule to not match against. (repeated)
  output: string, An output expression to request data from matches.
  mql_output: string, The MQL query to run againist the results to extract more data.
</pre>
</div>

<div class="method">
    <code class="details" id="search_media">search_media(domain=None, help=None, query=None, scoring=None, filter=None, prefixed=None, with=None, mid=None, encode=None, limit=None, type=None, as_of_time=None, stemmed=None, format=None, spell=None, exact=None, lang=None, indent=None, cursor=None, callback=None, without=None, output=None, mql_output=None)</code>
  <pre>Search Freebase open data.

Args:
  domain: string, Restrict to topics with this Freebase domain id. (repeated)
  help: string, The keyword to request help on.
    Allowed values
      langs - The language codes served by the service.
      mappings - The property/path mappings supported by the filter and output request parameters.
      predicates - The predicates and path-terminating properties supported by the filter and output request parameters.
  query: string, Query term to search for.
  scoring: string, Relevance scoring algorithm to use.
    Allowed values
      entity - Use freebase and popularity entity ranking.
      freebase - Use freebase entity ranking.
      schema - Use schema ranking for properties and types.
  filter: string, A filter to apply to the query. (repeated)
  prefixed: boolean, Prefix match against names and aliases.
  with: string, A rule to match against. (repeated)
  mid: string, A mid to use instead of a query. (repeated)
  encode: string, The encoding of the response. You can use this parameter to enable html encoding.
    Allowed values
      html - Encode certain characters in the response (such as tags and ambersands) using html encoding.
      off - No encoding of the response. You should not print the results directly on an web page without html-escaping the content first.
  limit: integer, Maximum number of results to return.
  type: string, Restrict to topics with this Freebase type id. (repeated)
  as_of_time: string, A mql as_of_time value to use with mql_output queries.
  stemmed: boolean, Query on stemmed names and aliases. May not be used with prefixed.
  format: string, Structural format of the json response.
    Allowed values
      ac - Compact format useful for autocomplete/suggest UIs.
      classic - [DEPRECATED] Same format as was returned by api.freebase.com.
      entity - Basic information about the entities.
      guids - [DEPRECATED] Ordered list of a freebase guids.
      ids - Ordered list of freebase ids.
      mids - Ordered list of freebase mids.
  spell: string, Request 'did you mean' suggestions
    Allowed values
      always - Request spelling suggestions for any query at least three characters long.
      no_results - Request spelling suggestions if no results were found.
      no_spelling - Don't request spelling suggestions.
  exact: boolean, Query on exact name and keys only.
  lang: string, The code of the language to run the query with. Default is 'en'. (repeated)
  indent: boolean, Whether to indent the json results or not.
  cursor: integer, The cursor value to use for the next page of results.
  callback: string, JS method name for JSONP callbacks.
  without: string, A rule to not match against. (repeated)
  output: string, An output expression to request data from matches.
  mql_output: string, The MQL query to run againist the results to extract more data.
</pre>
</div>

</body></html>