<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>apache_beam.coders package &#8212; Apache Beam  documentation</title>
    
    <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    './',
        VERSION:     '',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true,
        SOURCELINK_SUFFIX: '.txt'
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/underscore.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" />
    <link rel="next" title="apache_beam.internal package" href="apache_beam.internal.html" />
    <link rel="prev" title="apache_beam package" href="apache_beam.html" /> 
  </head>
  <body role="document">
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="apache_beam.internal.html" title="apache_beam.internal package"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="apache_beam.html" title="apache_beam package"
             accesskey="P">previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="index.html">Apache Beam  documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="apache_beam.html" accesskey="U">apache_beam package</a> &#187;</li> 
      </ul>
    </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
  <h3><a href="index.html">Table Of Contents</a></h3>
  <ul>
<li><a class="reference internal" href="#">apache_beam.coders package</a><ul>
<li><a class="reference internal" href="#submodules">Submodules</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders.coder_impl">apache_beam.coders.coder_impl module</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders.coders">apache_beam.coders.coders module</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders.coders_test_common">apache_beam.coders.coders_test_common module</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders.observable">apache_beam.coders.observable module</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders.proto2_coder_test_messages_pb2">apache_beam.coders.proto2_coder_test_messages_pb2 module</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders.slow_stream">apache_beam.coders.slow_stream module</a></li>
<li><a class="reference internal" href="#apache-beam-coders-stream-module">apache_beam.coders.stream module</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders.typecoders">apache_beam.coders.typecoders module</a></li>
<li><a class="reference internal" href="#module-apache_beam.coders">Module contents</a></li>
</ul>
</li>
</ul>

  <h4>Previous topic</h4>
  <p class="topless"><a href="apache_beam.html"
                        title="previous chapter">apache_beam package</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="apache_beam.internal.html"
                        title="next chapter">apache_beam.internal package</a></p>
  <div role="note" aria-label="source link">
    <h3>This Page</h3>
    <ul class="this-page-menu">
      <li><a href="_sources/apache_beam.coders.rst.txt"
            rel="nofollow">Show Source</a></li>
    </ul>
   </div>
<div id="searchbox" style="display: none" role="search">
  <h3>Quick search</h3>
    <form class="search" action="search.html" method="get">
      <div><input type="text" name="q" /></div>
      <div><input type="submit" value="Go" /></div>
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <div class="section" id="apache-beam-coders-package">
<h1>apache_beam.coders package<a class="headerlink" href="#apache-beam-coders-package" title="Permalink to this headline">¶</a></h1>
<div class="section" id="submodules">
<h2>Submodules<a class="headerlink" href="#submodules" title="Permalink to this headline">¶</a></h2>
</div>
<div class="section" id="module-apache_beam.coders.coder_impl">
<span id="apache-beam-coders-coder-impl-module"></span><h2>apache_beam.coders.coder_impl module<a class="headerlink" href="#module-apache_beam.coders.coder_impl" title="Permalink to this headline">¶</a></h2>
<p>Coder implementations.</p>
<p>The actual encode/decode implementations are split off from coders to
allow conditional (compiled/pure) implementations, which can be used to
encode many elements with minimal overhead.</p>
<p>This module may be optionally compiled with Cython, using the corresponding
coder_impl.pxd file for type hints.</p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="class">
<dt id="apache_beam.coders.coder_impl.AbstractComponentCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">AbstractComponentCoderImpl</code><span class="sig-paren">(</span><em>coder_impls</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#AbstractComponentCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.AbstractComponentCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>CoderImpl for coders that are comprised of several component coders.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.AbstractComponentCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#AbstractComponentCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.AbstractComponentCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.AbstractComponentCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#AbstractComponentCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.AbstractComponentCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.AbstractComponentCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#AbstractComponentCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.AbstractComponentCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Estimates the encoded size of the given value, in bytes.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.AbstractComponentCoderImpl.get_estimated_size_and_observables">
<code class="descname">get_estimated_size_and_observables</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#AbstractComponentCoderImpl.get_estimated_size_and_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.AbstractComponentCoderImpl.get_estimated_size_and_observables" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns estimated size of value along with any nested observables.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.BytesCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">BytesCoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#BytesCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.BytesCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.CoderImpl" title="apache_beam.coders.coder_impl.CoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.CoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A coder for bytes/str objects.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.BytesCoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#BytesCoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.BytesCoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.BytesCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#BytesCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.BytesCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.BytesCoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#BytesCoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.BytesCoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.BytesCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#BytesCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.BytesCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.CallbackCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">CallbackCoderImpl</code><span class="sig-paren">(</span><em>encoder</em>, <em>decoder</em>, <em>size_estimator=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CallbackCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CallbackCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.CoderImpl" title="apache_beam.coders.coder_impl.CoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.CoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A CoderImpl that calls back to the _impl methods on the Coder itself.</p>
<p>This is the default implementation used if Coder._get_impl()
is not overwritten.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.CallbackCoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CallbackCoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CallbackCoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CallbackCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CallbackCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CallbackCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CallbackCoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CallbackCoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CallbackCoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CallbackCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CallbackCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CallbackCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CallbackCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CallbackCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CallbackCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CallbackCoderImpl.get_estimated_size_and_observables">
<code class="descname">get_estimated_size_and_observables</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CallbackCoderImpl.get_estimated_size_and_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CallbackCoderImpl.get_estimated_size_and_observables" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.CoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">CoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">object</span></code></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.CoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd><p>Decodes an object to an unnested string.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd><p>Reads object from potentially-nested encoding in stream.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd><p>Encodes an object to an unnested string.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd><p>Reads object from potentially-nested encoding in stream.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Estimates the encoded size of the given value, in bytes.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.CoderImpl.get_estimated_size_and_observables">
<code class="descname">get_estimated_size_and_observables</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#CoderImpl.get_estimated_size_and_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.CoderImpl.get_estimated_size_and_observables" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns estimated size of value along with any nested observables.</p>
<p>The list of nested observables is returned as a list of 2-tuples of
(obj, coder_impl), where obj is an instance of observable.ObservableMixin,
and coder_impl is the CoderImpl that can be used to encode elements sent by
obj to its observers.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>value</strong> &#8211; the value whose encoded size is to be estimated.</li>
<li><strong>nested</strong> &#8211; whether the value is nested.</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">The estimated encoded size of the given value and a list of observables
whose elements are 2-tuples of (obj, coder_impl) as described above.</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">DeterministicFastPrimitivesCoderImpl</code><span class="sig-paren">(</span><em>coder</em>, <em>step_label</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#DeterministicFastPrimitivesCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.CoderImpl" title="apache_beam.coders.coder_impl.CoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.CoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#DeterministicFastPrimitivesCoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#DeterministicFastPrimitivesCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#DeterministicFastPrimitivesCoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#DeterministicFastPrimitivesCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#DeterministicFastPrimitivesCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.get_estimated_size_and_observables">
<code class="descname">get_estimated_size_and_observables</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#DeterministicFastPrimitivesCoderImpl.get_estimated_size_and_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.DeterministicFastPrimitivesCoderImpl.get_estimated_size_and_observables" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.FastPrimitivesCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">FastPrimitivesCoderImpl</code><span class="sig-paren">(</span><em>fallback_coder_impl</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FastPrimitivesCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FastPrimitivesCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.FastPrimitivesCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FastPrimitivesCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FastPrimitivesCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.FastPrimitivesCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FastPrimitivesCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FastPrimitivesCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.FastPrimitivesCoderImpl.get_estimated_size_and_observables">
<code class="descname">get_estimated_size_and_observables</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FastPrimitivesCoderImpl.get_estimated_size_and_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FastPrimitivesCoderImpl.get_estimated_size_and_observables" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.FloatCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">FloatCoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FloatCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FloatCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.FloatCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FloatCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FloatCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.FloatCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FloatCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FloatCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.FloatCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>unused_value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#FloatCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.FloatCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.IntervalWindowCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">IntervalWindowCoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#IntervalWindowCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.IntervalWindowCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.IntervalWindowCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#IntervalWindowCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.IntervalWindowCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.IntervalWindowCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#IntervalWindowCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.IntervalWindowCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.IntervalWindowCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#IntervalWindowCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.IntervalWindowCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.IterableCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">IterableCoderImpl</code><span class="sig-paren">(</span><em>elem_coder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#IterableCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.IterableCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.SequenceCoderImpl" title="apache_beam.coders.coder_impl.SequenceCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.SequenceCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A coder for homogeneous iterable objects.</p>
</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.LengthPrefixCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">LengthPrefixCoderImpl</code><span class="sig-paren">(</span><em>value_coder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#LengthPrefixCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.LengthPrefixCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>Coder which prefixes the length of the encoded object in the stream.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.LengthPrefixCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#LengthPrefixCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.LengthPrefixCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.LengthPrefixCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#LengthPrefixCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.LengthPrefixCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.LengthPrefixCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#LengthPrefixCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.LengthPrefixCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.ProtoCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">ProtoCoderImpl</code><span class="sig-paren">(</span><em>proto_message_type</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#ProtoCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.ProtoCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.SimpleCoderImpl" title="apache_beam.coders.coder_impl.SimpleCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.SimpleCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.ProtoCoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#ProtoCoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.ProtoCoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.ProtoCoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#ProtoCoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.ProtoCoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.SequenceCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">SequenceCoderImpl</code><span class="sig-paren">(</span><em>elem_coder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SequenceCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SequenceCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A coder for sequences.</p>
<p>If the length of the sequence in known we encode the length as a 32 bit
<code class="docutils literal"><span class="pre">int</span></code> followed by the encoded bytes.</p>
<p>If the length of the sequence is unknown, we encode the length as <code class="docutils literal"><span class="pre">-1</span></code>
followed by the encoding of elements buffered up to 64K bytes before prefixing
the count of number of elements. A <code class="docutils literal"><span class="pre">0</span></code> is encoded at the end to indicate the
end of stream.</p>
<p>The resulting encoding would look like this:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="o">-</span><span class="mi">1</span>
<span class="n">countA</span> <span class="n">element</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="n">element</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">...</span> <span class="n">element</span><span class="p">(</span><span class="n">countA</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
<span class="n">countB</span> <span class="n">element</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="n">element</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">...</span> <span class="n">element</span><span class="p">(</span><span class="n">countB</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
<span class="o">...</span>
<span class="n">countX</span> <span class="n">element</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="n">element</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">...</span> <span class="n">element</span><span class="p">(</span><span class="n">countX</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
<span class="mi">0</span>
</pre></div>
</div>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.SequenceCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SequenceCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SequenceCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SequenceCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SequenceCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SequenceCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SequenceCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SequenceCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SequenceCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Estimates the encoded size of the given value, in bytes.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SequenceCoderImpl.get_estimated_size_and_observables">
<code class="descname">get_estimated_size_and_observables</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SequenceCoderImpl.get_estimated_size_and_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SequenceCoderImpl.get_estimated_size_and_observables" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns estimated size of value along with any nested observables.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.SimpleCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">SimpleCoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SimpleCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SimpleCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.CoderImpl" title="apache_beam.coders.coder_impl.CoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.CoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>Subclass of CoderImpl implementing stream methods using encode/decode.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.SimpleCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SimpleCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SimpleCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd><p>Reads object from potentially-nested encoding in stream.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SimpleCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SimpleCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SimpleCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd><p>Reads object from potentially-nested encoding in stream.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.SingletonCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">SingletonCoderImpl</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SingletonCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SingletonCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.CoderImpl" title="apache_beam.coders.coder_impl.CoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.CoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A coder that always encodes exactly one value.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.SingletonCoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SingletonCoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SingletonCoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SingletonCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SingletonCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SingletonCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SingletonCoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SingletonCoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SingletonCoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SingletonCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SingletonCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SingletonCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.SingletonCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#SingletonCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.SingletonCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.StreamCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">StreamCoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#StreamCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.CoderImpl" title="apache_beam.coders.coder_impl.CoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.CoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>Subclass of CoderImpl implementing encode/decode using stream methods.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.StreamCoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#StreamCoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.StreamCoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.StreamCoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#StreamCoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.StreamCoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.StreamCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#StreamCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.StreamCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Estimates the encoded size of the given value, in bytes.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.TimestampCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">TimestampCoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#TimestampCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.TimestampCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.TimestampCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#TimestampCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.TimestampCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.TimestampCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#TimestampCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.TimestampCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.TimestampCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>unused_value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#TimestampCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.TimestampCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.TupleCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">TupleCoderImpl</code><span class="sig-paren">(</span><em>coder_impls</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#TupleCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.TupleCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.AbstractComponentCoderImpl" title="apache_beam.coders.coder_impl.AbstractComponentCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.AbstractComponentCoderImpl</span></code></a></p>
<p>A coder for tuple objects.</p>
</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.TupleSequenceCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">TupleSequenceCoderImpl</code><span class="sig-paren">(</span><em>elem_coder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#TupleSequenceCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.TupleSequenceCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.SequenceCoderImpl" title="apache_beam.coders.coder_impl.SequenceCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.SequenceCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A coder for homogeneous tuple objects.</p>
</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.VarIntCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">VarIntCoderImpl</code><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#VarIntCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.VarIntCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A coder for long/int objects.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.VarIntCoderImpl.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#VarIntCoderImpl.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.VarIntCoderImpl.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.VarIntCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#VarIntCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.VarIntCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.VarIntCoderImpl.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#VarIntCoderImpl.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.VarIntCoderImpl.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.VarIntCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#VarIntCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.VarIntCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.VarIntCoderImpl.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#VarIntCoderImpl.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.VarIntCoderImpl.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coder_impl.WindowedValueCoderImpl">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coder_impl.</code><code class="descname">WindowedValueCoderImpl</code><span class="sig-paren">(</span><em>value_coder</em>, <em>timestamp_coder</em>, <em>window_coder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#WindowedValueCoderImpl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.WindowedValueCoderImpl" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coder_impl.StreamCoderImpl" title="apache_beam.coders.coder_impl.StreamCoderImpl"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coder_impl.StreamCoderImpl</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A coder for windowed values.</p>
<dl class="method">
<dt id="apache_beam.coders.coder_impl.WindowedValueCoderImpl.decode_from_stream">
<code class="descname">decode_from_stream</code><span class="sig-paren">(</span><em>in_stream</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#WindowedValueCoderImpl.decode_from_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.WindowedValueCoderImpl.decode_from_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.WindowedValueCoderImpl.encode_to_stream">
<code class="descname">encode_to_stream</code><span class="sig-paren">(</span><em>value</em>, <em>out</em>, <em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#WindowedValueCoderImpl.encode_to_stream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.WindowedValueCoderImpl.encode_to_stream" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coder_impl.WindowedValueCoderImpl.get_estimated_size_and_observables">
<code class="descname">get_estimated_size_and_observables</code><span class="sig-paren">(</span><em>value</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coder_impl.html#WindowedValueCoderImpl.get_estimated_size_and_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coder_impl.WindowedValueCoderImpl.get_estimated_size_and_observables" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns estimated size of value along with any nested observables.</p>
</dd></dl>

</dd></dl>

</div>
<div class="section" id="module-apache_beam.coders.coders">
<span id="apache-beam-coders-coders-module"></span><h2>apache_beam.coders.coders module<a class="headerlink" href="#module-apache_beam.coders.coders" title="Permalink to this headline">¶</a></h2>
<p>Collection of useful coders.</p>
<p>Only those coders listed in __all__ are part of the public API of this module.</p>
<dl class="class">
<dt id="apache_beam.coders.coders.Coder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">Coder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">object</span></code></p>
<p>Base class for coders.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.Coder.as_cloud_object">
<code class="descname">as_cloud_object</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.as_cloud_object"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.as_cloud_object" title="Permalink to this definition">¶</a></dt>
<dd><p>For internal use only; no backwards-compatibility guarantees.</p>
<p>Returns Google Cloud Dataflow API description of this coder.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.decode" title="Permalink to this definition">¶</a></dt>
<dd><p>Decodes the given byte string into the corresponding object.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.encode" title="Permalink to this definition">¶</a></dt>
<dd><p>Encodes the given object into a byte string.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.estimate_size">
<code class="descname">estimate_size</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.estimate_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.estimate_size" title="Permalink to this definition">¶</a></dt>
<dd><p>Estimates the encoded size of the given value, in bytes.</p>
<p>Dataflow estimates the encoded size of a PCollection processed in a pipeline
step by using the estimated size of a random sample of elements in that
PCollection.</p>
<p>The default implementation encodes the given value and returns its byte
size.  If a coder can provide a fast estimate of the encoded size of a value
(e.g., if the encoding has a fixed size), it can provide its estimate here
to improve performance.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>value</strong> &#8211; the value whose encoded size is to be estimated.</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">The estimated encoded size of the given value.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.coders.Coder.from_runner_api">
<em class="property">static </em><code class="descname">from_runner_api</code><span class="sig-paren">(</span><em>proto</em>, <em>context</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.from_runner_api"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.from_runner_api" title="Permalink to this definition">¶</a></dt>
<dd><p>For internal use only; no backwards-compatibility guarantees.</p>
</dd></dl>

<dl class="classmethod">
<dt id="apache_beam.coders.coders.Coder.from_type_hint">
<em class="property">classmethod </em><code class="descname">from_type_hint</code><span class="sig-paren">(</span><em>unused_typehint</em>, <em>unused_registry</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.from_type_hint"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.from_type_hint" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.get_impl">
<code class="descname">get_impl</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.get_impl"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.get_impl" title="Permalink to this definition">¶</a></dt>
<dd><p>For internal use only; no backwards-compatibility guarantees.</p>
<p>Returns the CoderImpl backing this Coder.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd><p>Whether this coder is guaranteed to encode values deterministically.</p>
<p>A deterministic coder is required for key coders in GroupByKey operations
to produce consistent results.</p>
<p>For example, note that the default coder, the PickleCoder, is not
deterministic: the ordering of picked entries in maps may vary across
executions since there is no defined order, and such a coder is not in
general suitable for usage as a key coder in GroupByKey operations, since
each instance of the same key may be encoded differently.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body">Whether coder is deterministic.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.is_kv_coder">
<code class="descname">is_kv_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.is_kv_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.is_kv_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.key_coder">
<code class="descname">key_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.key_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.key_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.to_runner_api">
<code class="descname">to_runner_api</code><span class="sig-paren">(</span><em>context</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.to_runner_api"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.to_runner_api" title="Permalink to this definition">¶</a></dt>
<dd><p>For internal use only; no backwards-compatibility guarantees.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.Coder.value_coder">
<code class="descname">value_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#Coder.value_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.Coder.value_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.BytesCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">BytesCoder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#BytesCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.BytesCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>Byte string coder.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.BytesCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#BytesCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.BytesCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.DillCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">DillCoder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#DillCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.DillCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders._PickleCoderBase</span></code></p>
<p>Coder using dill&#8217;s pickle functionality.</p>
</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.FastPrimitivesCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">FastPrimitivesCoder</code><span class="sig-paren">(</span><em>fallback_coder=PickleCoder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FastPrimitivesCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FastPrimitivesCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>Encodes simple primitives (e.g. str, int) efficiently.</p>
<p>For unknown types, falls back to another coder (e.g. PickleCoder).</p>
<dl class="method">
<dt id="apache_beam.coders.coders.FastPrimitivesCoder.as_cloud_object">
<code class="descname">as_cloud_object</code><span class="sig-paren">(</span><em>is_pair_like=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FastPrimitivesCoder.as_cloud_object"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FastPrimitivesCoder.as_cloud_object" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.FastPrimitivesCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FastPrimitivesCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FastPrimitivesCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.FastPrimitivesCoder.is_kv_coder">
<code class="descname">is_kv_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FastPrimitivesCoder.is_kv_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FastPrimitivesCoder.is_kv_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.FastPrimitivesCoder.key_coder">
<code class="descname">key_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FastPrimitivesCoder.key_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FastPrimitivesCoder.key_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.FastPrimitivesCoder.value_coder">
<code class="descname">value_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FastPrimitivesCoder.value_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FastPrimitivesCoder.value_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.FloatCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">FloatCoder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FloatCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FloatCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>A coder used for floating-point values.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.FloatCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#FloatCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.FloatCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.IterableCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">IterableCoder</code><span class="sig-paren">(</span><em>elem_coder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#IterableCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.IterableCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>Coder of iterables of homogeneous objects.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.IterableCoder.as_cloud_object">
<code class="descname">as_cloud_object</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#IterableCoder.as_cloud_object"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.IterableCoder.as_cloud_object" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.coders.IterableCoder.from_type_hint">
<em class="property">static </em><code class="descname">from_type_hint</code><span class="sig-paren">(</span><em>typehint</em>, <em>registry</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#IterableCoder.from_type_hint"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.IterableCoder.from_type_hint" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.IterableCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#IterableCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.IterableCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.IterableCoder.value_coder">
<code class="descname">value_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#IterableCoder.value_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.IterableCoder.value_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.PickleCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">PickleCoder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#PickleCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.PickleCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders._PickleCoderBase</span></code></p>
<p>Coder using Python&#8217;s pickle functionality.</p>
</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.ProtoCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">ProtoCoder</code><span class="sig-paren">(</span><em>proto_message_type</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#ProtoCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.ProtoCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>A Coder for Google Protocol Buffers.</p>
<p>It supports both Protocol Buffers syntax versions 2 and 3. However,
the runtime version of the python protobuf library must exactly match the
version of the protoc compiler what was used to generate the protobuf
messages.</p>
<p>ProtoCoder is registered in the global CoderRegistry as the default coder for
any protobuf Message object.</p>
<dl class="staticmethod">
<dt id="apache_beam.coders.coders.ProtoCoder.from_type_hint">
<em class="property">static </em><code class="descname">from_type_hint</code><span class="sig-paren">(</span><em>typehint</em>, <em>unused_registry</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#ProtoCoder.from_type_hint"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.ProtoCoder.from_type_hint" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.ProtoCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#ProtoCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.ProtoCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.SingletonCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">SingletonCoder</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#SingletonCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.SingletonCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>A coder that always encodes exactly one value.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.SingletonCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#SingletonCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.SingletonCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.StrUtf8Coder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">StrUtf8Coder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#StrUtf8Coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.StrUtf8Coder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coders.Coder" title="apache_beam.coders.coders.Coder"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.Coder</span></code></a></p>
<p>A coder used for reading and writing strings as UTF-8.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.StrUtf8Coder.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#StrUtf8Coder.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.StrUtf8Coder.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.StrUtf8Coder.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#StrUtf8Coder.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.StrUtf8Coder.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.StrUtf8Coder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#StrUtf8Coder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.StrUtf8Coder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.TimestampCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">TimestampCoder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TimestampCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TimestampCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>A coder used for timeutil.Timestamp values.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.TimestampCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TimestampCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TimestampCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.TupleCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">TupleCoder</code><span class="sig-paren">(</span><em>components</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>Coder of tuple objects.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.TupleCoder.as_cloud_object">
<code class="descname">as_cloud_object</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder.as_cloud_object"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder.as_cloud_object" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.TupleCoder.coders">
<code class="descname">coders</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder.coders"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder.coders" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.coders.TupleCoder.from_type_hint">
<em class="property">static </em><code class="descname">from_type_hint</code><span class="sig-paren">(</span><em>typehint</em>, <em>registry</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder.from_type_hint"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder.from_type_hint" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.TupleCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.TupleCoder.is_kv_coder">
<code class="descname">is_kv_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder.is_kv_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder.is_kv_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.TupleCoder.key_coder">
<code class="descname">key_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder.key_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder.key_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.TupleCoder.value_coder">
<code class="descname">value_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleCoder.value_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleCoder.value_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.TupleSequenceCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">TupleSequenceCoder</code><span class="sig-paren">(</span><em>elem_coder</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleSequenceCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleSequenceCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>Coder of homogeneous tuple objects.</p>
<dl class="staticmethod">
<dt id="apache_beam.coders.coders.TupleSequenceCoder.from_type_hint">
<em class="property">static </em><code class="descname">from_type_hint</code><span class="sig-paren">(</span><em>typehint</em>, <em>registry</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleSequenceCoder.from_type_hint"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleSequenceCoder.from_type_hint" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.TupleSequenceCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#TupleSequenceCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.TupleSequenceCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.VarIntCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">VarIntCoder</code><a class="reference internal" href="_modules/apache_beam/coders/coders.html#VarIntCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.VarIntCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>Variable-length integer coder.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.VarIntCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#VarIntCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.VarIntCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders.WindowedValueCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders.</code><code class="descname">WindowedValueCoder</code><span class="sig-paren">(</span><em>wrapped_value_coder</em>, <em>window_coder=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#WindowedValueCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.WindowedValueCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.FastCoder</span></code></p>
<p>Coder for windowed values.</p>
<dl class="method">
<dt id="apache_beam.coders.coders.WindowedValueCoder.as_cloud_object">
<code class="descname">as_cloud_object</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#WindowedValueCoder.as_cloud_object"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.WindowedValueCoder.as_cloud_object" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.WindowedValueCoder.is_deterministic">
<code class="descname">is_deterministic</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#WindowedValueCoder.is_deterministic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.WindowedValueCoder.is_deterministic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.WindowedValueCoder.is_kv_coder">
<code class="descname">is_kv_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#WindowedValueCoder.is_kv_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.WindowedValueCoder.is_kv_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.WindowedValueCoder.key_coder">
<code class="descname">key_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#WindowedValueCoder.key_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.WindowedValueCoder.key_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders.WindowedValueCoder.value_coder">
<code class="descname">value_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders.html#WindowedValueCoder.value_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders.WindowedValueCoder.value_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

</div>
<div class="section" id="module-apache_beam.coders.coders_test_common">
<span id="apache-beam-coders-coders-test-common-module"></span><h2>apache_beam.coders.coders_test_common module<a class="headerlink" href="#module-apache_beam.coders.coders_test_common" title="Permalink to this headline">¶</a></h2>
<p>Tests common to all coder implementations.</p>
<dl class="class">
<dt id="apache_beam.coders.coders_test_common.CodersTest">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders_test_common.</code><code class="descname">CodersTest</code><span class="sig-paren">(</span><em>methodName='runTest'</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">unittest.case.TestCase</span></code></p>
<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.check_coder">
<code class="descname">check_coder</code><span class="sig-paren">(</span><em>coder</em>, <em>*values</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.check_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.check_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="classmethod">
<dt id="apache_beam.coders.coders_test_common.CodersTest.setUpClass">
<em class="property">classmethod </em><code class="descname">setUpClass</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.setUpClass"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.setUpClass" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="classmethod">
<dt id="apache_beam.coders.coders_test_common.CodersTest.tearDownClass">
<em class="property">classmethod </em><code class="descname">tearDownClass</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.tearDownClass"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.tearDownClass" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_base64_pickle_coder">
<code class="descname">test_base64_pickle_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_base64_pickle_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_base64_pickle_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_bytes_coder">
<code class="descname">test_bytes_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_bytes_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_bytes_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_custom_coder">
<code class="descname">test_custom_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_custom_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_custom_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_deterministic_coder">
<code class="descname">test_deterministic_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_deterministic_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_deterministic_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_dill_coder">
<code class="descname">test_dill_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_dill_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_dill_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_fast_primitives_coder">
<code class="descname">test_fast_primitives_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_fast_primitives_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_fast_primitives_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_float_coder">
<code class="descname">test_float_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_float_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_float_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_global_window_coder">
<code class="descname">test_global_window_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_global_window_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_global_window_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_interval_window_coder">
<code class="descname">test_interval_window_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_interval_window_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_interval_window_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_iterable_coder">
<code class="descname">test_iterable_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_iterable_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_iterable_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_iterable_coder_unknown_length">
<code class="descname">test_iterable_coder_unknown_length</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_iterable_coder_unknown_length"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_iterable_coder_unknown_length" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_length_prefix_coder">
<code class="descname">test_length_prefix_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_length_prefix_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_length_prefix_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_nested_observables">
<code class="descname">test_nested_observables</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_nested_observables"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_nested_observables" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_pickle_coder">
<code class="descname">test_pickle_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_pickle_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_pickle_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_proto_coder">
<code class="descname">test_proto_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_proto_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_proto_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_singleton_coder">
<code class="descname">test_singleton_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_singleton_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_singleton_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_timestamp_coder">
<code class="descname">test_timestamp_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_timestamp_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_timestamp_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_tuple_coder">
<code class="descname">test_tuple_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_tuple_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_tuple_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_tuple_sequence_coder">
<code class="descname">test_tuple_sequence_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_tuple_sequence_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_tuple_sequence_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_utf8_coder">
<code class="descname">test_utf8_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_utf8_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_utf8_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_varint_coder">
<code class="descname">test_varint_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_varint_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_varint_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CodersTest.test_windowed_value_coder">
<code class="descname">test_windowed_value_coder</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CodersTest.test_windowed_value_coder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CodersTest.test_windowed_value_coder" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.coders_test_common.CustomCoder">
<em class="property">class </em><code class="descclassname">apache_beam.coders.coders_test_common.</code><code class="descname">CustomCoder</code><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CustomCoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CustomCoder" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.coders.Coder" title="apache_beam.coders.coders.Coder"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.coders.Coder</span></code></a></p>
<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CustomCoder.decode">
<code class="descname">decode</code><span class="sig-paren">(</span><em>encoded</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CustomCoder.decode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CustomCoder.decode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.coders_test_common.CustomCoder.encode">
<code class="descname">encode</code><span class="sig-paren">(</span><em>x</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/coders_test_common.html#CustomCoder.encode"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.coders_test_common.CustomCoder.encode" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

</div>
<div class="section" id="module-apache_beam.coders.observable">
<span id="apache-beam-coders-observable-module"></span><h2>apache_beam.coders.observable module<a class="headerlink" href="#module-apache_beam.coders.observable" title="Permalink to this headline">¶</a></h2>
<p>Observable base class for iterables.</p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="class">
<dt id="apache_beam.coders.observable.ObservableMixin">
<em class="property">class </em><code class="descclassname">apache_beam.coders.observable.</code><code class="descname">ObservableMixin</code><a class="reference internal" href="_modules/apache_beam/coders/observable.html#ObservableMixin"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.observable.ObservableMixin" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">object</span></code></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>An observable iterable.</p>
<p>Subclasses need to call self.notify_observers with any object yielded.</p>
<dl class="method">
<dt id="apache_beam.coders.observable.ObservableMixin.notify_observers">
<code class="descname">notify_observers</code><span class="sig-paren">(</span><em>value</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/observable.html#ObservableMixin.notify_observers"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.observable.ObservableMixin.notify_observers" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.observable.ObservableMixin.register_observer">
<code class="descname">register_observer</code><span class="sig-paren">(</span><em>callback</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/observable.html#ObservableMixin.register_observer"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.observable.ObservableMixin.register_observer" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

</div>
<div class="section" id="module-apache_beam.coders.proto2_coder_test_messages_pb2">
<span id="apache-beam-coders-proto2-coder-test-messages-pb2-module"></span><h2>apache_beam.coders.proto2_coder_test_messages_pb2 module<a class="headerlink" href="#module-apache_beam.coders.proto2_coder_test_messages_pb2" title="Permalink to this headline">¶</a></h2>
<dl class="class">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA">
<em class="property">class </em><code class="descclassname">apache_beam.coders.proto2_coder_test_messages_pb2.</code><code class="descname">MessageA</code><span class="sig-paren">(</span><em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">google.protobuf.message.Message</span></code></p>
<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.ByteSize">
<code class="descname">ByteSize</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.ByteSize" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.Clear">
<code class="descname">Clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.Clear" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.ClearField">
<code class="descname">ClearField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.ClearField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.DESCRIPTOR">
<code class="descname">DESCRIPTOR</code><em class="property"> = &lt;google.protobuf.descriptor.Descriptor object&gt;</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.DESCRIPTOR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.DiscardUnknownFields">
<code class="descname">DiscardUnknownFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.DiscardUnknownFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FIELD1_FIELD_NUMBER">
<code class="descname">FIELD1_FIELD_NUMBER</code><em class="property"> = 1</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FIELD1_FIELD_NUMBER" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FIELD2_FIELD_NUMBER">
<code class="descname">FIELD2_FIELD_NUMBER</code><em class="property"> = 2</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FIELD2_FIELD_NUMBER" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FindInitializationErrors">
<code class="descname">FindInitializationErrors</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FindInitializationErrors" title="Permalink to this definition">¶</a></dt>
<dd><p>Finds required fields which are not initialized.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body">A list of strings.  Each string is a path to an uninitialized field from
the top-level message, e.g. &#8220;foo.bar[5].baz&#8221;.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FromString">
<em class="property">static </em><code class="descname">FromString</code><span class="sig-paren">(</span><em>s</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.FromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.HasField">
<code class="descname">HasField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.HasField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.IsInitialized">
<code class="descname">IsInitialized</code><span class="sig-paren">(</span><em>errors=None</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.IsInitialized" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if all required fields of a message are set.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>errors</strong> &#8211; A list which, if provided, will be populated with the field
paths of all missing required fields.</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">True iff the specified message has all required fields set.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.ListFields">
<code class="descname">ListFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.ListFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.MergeFrom">
<code class="descname">MergeFrom</code><span class="sig-paren">(</span><em>msg</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.MergeFrom" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.MergeFromString">
<code class="descname">MergeFromString</code><span class="sig-paren">(</span><em>serialized</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.MergeFromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.RegisterExtension">
<em class="property">static </em><code class="descname">RegisterExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.RegisterExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.SerializePartialToString">
<code class="descname">SerializePartialToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.SerializePartialToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.SerializeToString">
<code class="descname">SerializeToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.SerializeToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.SetInParent">
<code class="descname">SetInParent</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.SetInParent" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the _cached_byte_size_dirty bit to true,
and propagates this to our listener iff this was a state change.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.WhichOneof">
<code class="descname">WhichOneof</code><span class="sig-paren">(</span><em>oneof_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.WhichOneof" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the name of the currently set field inside a oneof, or None.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.field1">
<code class="descname">field1</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.field1" title="Permalink to this definition">¶</a></dt>
<dd><p>Magic attribute generated for &#8220;field1&#8221; proto field.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.field2">
<code class="descname">field2</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageA.field2" title="Permalink to this definition">¶</a></dt>
<dd><p>Magic attribute generated for &#8220;field2&#8221; proto field.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB">
<em class="property">class </em><code class="descclassname">apache_beam.coders.proto2_coder_test_messages_pb2.</code><code class="descname">MessageB</code><span class="sig-paren">(</span><em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">google.protobuf.message.Message</span></code></p>
<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.ByteSize">
<code class="descname">ByteSize</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.ByteSize" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.Clear">
<code class="descname">Clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.Clear" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.ClearField">
<code class="descname">ClearField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.ClearField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.DESCRIPTOR">
<code class="descname">DESCRIPTOR</code><em class="property"> = &lt;google.protobuf.descriptor.Descriptor object&gt;</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.DESCRIPTOR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.DiscardUnknownFields">
<code class="descname">DiscardUnknownFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.DiscardUnknownFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.FIELD1_FIELD_NUMBER">
<code class="descname">FIELD1_FIELD_NUMBER</code><em class="property"> = 1</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.FIELD1_FIELD_NUMBER" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.FindInitializationErrors">
<code class="descname">FindInitializationErrors</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.FindInitializationErrors" title="Permalink to this definition">¶</a></dt>
<dd><p>Finds required fields which are not initialized.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body">A list of strings.  Each string is a path to an uninitialized field from
the top-level message, e.g. &#8220;foo.bar[5].baz&#8221;.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.FromString">
<em class="property">static </em><code class="descname">FromString</code><span class="sig-paren">(</span><em>s</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.FromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.HasField">
<code class="descname">HasField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.HasField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.IsInitialized">
<code class="descname">IsInitialized</code><span class="sig-paren">(</span><em>errors=None</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.IsInitialized" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if all required fields of a message are set.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>errors</strong> &#8211; A list which, if provided, will be populated with the field
paths of all missing required fields.</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">True iff the specified message has all required fields set.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.ListFields">
<code class="descname">ListFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.ListFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.MergeFrom">
<code class="descname">MergeFrom</code><span class="sig-paren">(</span><em>msg</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.MergeFrom" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.MergeFromString">
<code class="descname">MergeFromString</code><span class="sig-paren">(</span><em>serialized</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.MergeFromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.RegisterExtension">
<em class="property">static </em><code class="descname">RegisterExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.RegisterExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.SerializePartialToString">
<code class="descname">SerializePartialToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.SerializePartialToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.SerializeToString">
<code class="descname">SerializeToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.SerializeToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.SetInParent">
<code class="descname">SetInParent</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.SetInParent" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the _cached_byte_size_dirty bit to true,
and propagates this to our listener iff this was a state change.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.WhichOneof">
<code class="descname">WhichOneof</code><span class="sig-paren">(</span><em>oneof_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.WhichOneof" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the name of the currently set field inside a oneof, or None.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.field1">
<code class="descname">field1</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageB.field1" title="Permalink to this definition">¶</a></dt>
<dd><p>Magic attribute generated for &#8220;field1&#8221; proto field.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC">
<em class="property">class </em><code class="descclassname">apache_beam.coders.proto2_coder_test_messages_pb2.</code><code class="descname">MessageC</code><span class="sig-paren">(</span><em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">google.protobuf.message.Message</span></code></p>
<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ByteSize">
<code class="descname">ByteSize</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ByteSize" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.Clear">
<code class="descname">Clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.Clear" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ClearExtension">
<code class="descname">ClearExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ClearExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ClearField">
<code class="descname">ClearField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ClearField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.DESCRIPTOR">
<code class="descname">DESCRIPTOR</code><em class="property"> = &lt;google.protobuf.descriptor.Descriptor object&gt;</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.DESCRIPTOR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.DiscardUnknownFields">
<code class="descname">DiscardUnknownFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.DiscardUnknownFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.Extensions">
<code class="descname">Extensions</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.Extensions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.FindInitializationErrors">
<code class="descname">FindInitializationErrors</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.FindInitializationErrors" title="Permalink to this definition">¶</a></dt>
<dd><p>Finds required fields which are not initialized.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body">A list of strings.  Each string is a path to an uninitialized field from
the top-level message, e.g. &#8220;foo.bar[5].baz&#8221;.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.FromString">
<em class="property">static </em><code class="descname">FromString</code><span class="sig-paren">(</span><em>s</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.FromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.HasExtension">
<code class="descname">HasExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.HasExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.HasField">
<code class="descname">HasField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.HasField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.IsInitialized">
<code class="descname">IsInitialized</code><span class="sig-paren">(</span><em>errors=None</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.IsInitialized" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if all required fields of a message are set.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>errors</strong> &#8211; A list which, if provided, will be populated with the field
paths of all missing required fields.</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">True iff the specified message has all required fields set.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ListFields">
<code class="descname">ListFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.ListFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.MergeFrom">
<code class="descname">MergeFrom</code><span class="sig-paren">(</span><em>msg</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.MergeFrom" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.MergeFromString">
<code class="descname">MergeFromString</code><span class="sig-paren">(</span><em>serialized</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.MergeFromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.RegisterExtension">
<em class="property">static </em><code class="descname">RegisterExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.RegisterExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.SerializePartialToString">
<code class="descname">SerializePartialToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.SerializePartialToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.SerializeToString">
<code class="descname">SerializeToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.SerializeToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.SetInParent">
<code class="descname">SetInParent</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.SetInParent" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the _cached_byte_size_dirty bit to true,
and propagates this to our listener iff this was a state change.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.WhichOneof">
<code class="descname">WhichOneof</code><span class="sig-paren">(</span><em>oneof_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageC.WhichOneof" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the name of the currently set field inside a oneof, or None.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap">
<em class="property">class </em><code class="descclassname">apache_beam.coders.proto2_coder_test_messages_pb2.</code><code class="descname">MessageWithMap</code><span class="sig-paren">(</span><em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">google.protobuf.message.Message</span></code></p>
<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.ByteSize">
<code class="descname">ByteSize</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.ByteSize" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Clear">
<code class="descname">Clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Clear" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.ClearField">
<code class="descname">ClearField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.ClearField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.DESCRIPTOR">
<code class="descname">DESCRIPTOR</code><em class="property"> = &lt;google.protobuf.descriptor.Descriptor object&gt;</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.DESCRIPTOR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.DiscardUnknownFields">
<code class="descname">DiscardUnknownFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.DiscardUnknownFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.FIELD1_FIELD_NUMBER">
<code class="descname">FIELD1_FIELD_NUMBER</code><em class="property"> = 1</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.FIELD1_FIELD_NUMBER" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="class">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry">
<em class="property">class </em><code class="descname">Field1Entry</code><span class="sig-paren">(</span><em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">google.protobuf.message.Message</span></code></p>
<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.ByteSize">
<code class="descname">ByteSize</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.ByteSize" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.Clear">
<code class="descname">Clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.Clear" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.ClearField">
<code class="descname">ClearField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.ClearField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.DESCRIPTOR">
<code class="descname">DESCRIPTOR</code><em class="property"> = &lt;google.protobuf.descriptor.Descriptor object&gt;</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.DESCRIPTOR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.DiscardUnknownFields">
<code class="descname">DiscardUnknownFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.DiscardUnknownFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.FindInitializationErrors">
<code class="descname">FindInitializationErrors</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.FindInitializationErrors" title="Permalink to this definition">¶</a></dt>
<dd><p>Finds required fields which are not initialized.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body">A list of strings.  Each string is a path to an uninitialized field from
the top-level message, e.g. &#8220;foo.bar[5].baz&#8221;.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.FromString">
<em class="property">static </em><code class="descname">FromString</code><span class="sig-paren">(</span><em>s</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.FromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.HasField">
<code class="descname">HasField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.HasField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.IsInitialized">
<code class="descname">IsInitialized</code><span class="sig-paren">(</span><em>errors=None</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.IsInitialized" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if all required fields of a message are set.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>errors</strong> &#8211; A list which, if provided, will be populated with the field
paths of all missing required fields.</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">True iff the specified message has all required fields set.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.KEY_FIELD_NUMBER">
<code class="descname">KEY_FIELD_NUMBER</code><em class="property"> = 1</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.KEY_FIELD_NUMBER" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.ListFields">
<code class="descname">ListFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.ListFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.MergeFrom">
<code class="descname">MergeFrom</code><span class="sig-paren">(</span><em>msg</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.MergeFrom" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.MergeFromString">
<code class="descname">MergeFromString</code><span class="sig-paren">(</span><em>serialized</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.MergeFromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.RegisterExtension">
<em class="property">static </em><code class="descname">RegisterExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.RegisterExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.SerializePartialToString">
<code class="descname">SerializePartialToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.SerializePartialToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.SerializeToString">
<code class="descname">SerializeToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.SerializeToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.SetInParent">
<code class="descname">SetInParent</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.SetInParent" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the _cached_byte_size_dirty bit to true,
and propagates this to our listener iff this was a state change.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.VALUE_FIELD_NUMBER">
<code class="descname">VALUE_FIELD_NUMBER</code><em class="property"> = 2</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.VALUE_FIELD_NUMBER" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.WhichOneof">
<code class="descname">WhichOneof</code><span class="sig-paren">(</span><em>oneof_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.WhichOneof" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the name of the currently set field inside a oneof, or None.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.key">
<code class="descname">key</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.key" title="Permalink to this definition">¶</a></dt>
<dd><p>Magic attribute generated for &#8220;key&#8221; proto field.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.value">
<code class="descname">value</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.Field1Entry.value" title="Permalink to this definition">¶</a></dt>
<dd><p>Magic attribute generated for &#8220;value&#8221; proto field.</p>
</dd></dl>

</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.FindInitializationErrors">
<code class="descname">FindInitializationErrors</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.FindInitializationErrors" title="Permalink to this definition">¶</a></dt>
<dd><p>Finds required fields which are not initialized.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body">A list of strings.  Each string is a path to an uninitialized field from
the top-level message, e.g. &#8220;foo.bar[5].baz&#8221;.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.FromString">
<em class="property">static </em><code class="descname">FromString</code><span class="sig-paren">(</span><em>s</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.FromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.HasField">
<code class="descname">HasField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.HasField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.IsInitialized">
<code class="descname">IsInitialized</code><span class="sig-paren">(</span><em>errors=None</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.IsInitialized" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if all required fields of a message are set.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>errors</strong> &#8211; A list which, if provided, will be populated with the field
paths of all missing required fields.</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">True iff the specified message has all required fields set.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.ListFields">
<code class="descname">ListFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.ListFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.MergeFrom">
<code class="descname">MergeFrom</code><span class="sig-paren">(</span><em>msg</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.MergeFrom" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.MergeFromString">
<code class="descname">MergeFromString</code><span class="sig-paren">(</span><em>serialized</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.MergeFromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.RegisterExtension">
<em class="property">static </em><code class="descname">RegisterExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.RegisterExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.SerializePartialToString">
<code class="descname">SerializePartialToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.SerializePartialToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.SerializeToString">
<code class="descname">SerializeToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.SerializeToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.SetInParent">
<code class="descname">SetInParent</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.SetInParent" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the _cached_byte_size_dirty bit to true,
and propagates this to our listener iff this was a state change.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.WhichOneof">
<code class="descname">WhichOneof</code><span class="sig-paren">(</span><em>oneof_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.WhichOneof" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the name of the currently set field inside a oneof, or None.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.field1">
<code class="descname">field1</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.MessageWithMap.field1" title="Permalink to this definition">¶</a></dt>
<dd><p>Magic attribute generated for &#8220;field1&#8221; proto field.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap">
<em class="property">class </em><code class="descclassname">apache_beam.coders.proto2_coder_test_messages_pb2.</code><code class="descname">ReferencesMessageWithMap</code><span class="sig-paren">(</span><em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">google.protobuf.message.Message</span></code></p>
<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.ByteSize">
<code class="descname">ByteSize</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.ByteSize" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.Clear">
<code class="descname">Clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.Clear" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.ClearField">
<code class="descname">ClearField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.ClearField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.DESCRIPTOR">
<code class="descname">DESCRIPTOR</code><em class="property"> = &lt;google.protobuf.descriptor.Descriptor object&gt;</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.DESCRIPTOR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.DiscardUnknownFields">
<code class="descname">DiscardUnknownFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.DiscardUnknownFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.FIELD1_FIELD_NUMBER">
<code class="descname">FIELD1_FIELD_NUMBER</code><em class="property"> = 1</em><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.FIELD1_FIELD_NUMBER" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.FindInitializationErrors">
<code class="descname">FindInitializationErrors</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.FindInitializationErrors" title="Permalink to this definition">¶</a></dt>
<dd><p>Finds required fields which are not initialized.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body">A list of strings.  Each string is a path to an uninitialized field from
the top-level message, e.g. &#8220;foo.bar[5].baz&#8221;.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.FromString">
<em class="property">static </em><code class="descname">FromString</code><span class="sig-paren">(</span><em>s</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.FromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.HasField">
<code class="descname">HasField</code><span class="sig-paren">(</span><em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.HasField" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.IsInitialized">
<code class="descname">IsInitialized</code><span class="sig-paren">(</span><em>errors=None</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.IsInitialized" title="Permalink to this definition">¶</a></dt>
<dd><p>Checks if all required fields of a message are set.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>errors</strong> &#8211; A list which, if provided, will be populated with the field
paths of all missing required fields.</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">True iff the specified message has all required fields set.</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.ListFields">
<code class="descname">ListFields</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.ListFields" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.MergeFrom">
<code class="descname">MergeFrom</code><span class="sig-paren">(</span><em>msg</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.MergeFrom" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.MergeFromString">
<code class="descname">MergeFromString</code><span class="sig-paren">(</span><em>serialized</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.MergeFromString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="staticmethod">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.RegisterExtension">
<em class="property">static </em><code class="descname">RegisterExtension</code><span class="sig-paren">(</span><em>extension_handle</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.RegisterExtension" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.SerializePartialToString">
<code class="descname">SerializePartialToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.SerializePartialToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.SerializeToString">
<code class="descname">SerializeToString</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.SerializeToString" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.SetInParent">
<code class="descname">SetInParent</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.SetInParent" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the _cached_byte_size_dirty bit to true,
and propagates this to our listener iff this was a state change.</p>
</dd></dl>

<dl class="method">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.WhichOneof">
<code class="descname">WhichOneof</code><span class="sig-paren">(</span><em>oneof_name</em><span class="sig-paren">)</span><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.WhichOneof" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the name of the currently set field inside a oneof, or None.</p>
</dd></dl>

<dl class="attribute">
<dt id="apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.field1">
<code class="descname">field1</code><a class="headerlink" href="#apache_beam.coders.proto2_coder_test_messages_pb2.ReferencesMessageWithMap.field1" title="Permalink to this definition">¶</a></dt>
<dd><p>Magic attribute generated for &#8220;field1&#8221; proto field.</p>
</dd></dl>

</dd></dl>

</div>
<div class="section" id="module-apache_beam.coders.slow_stream">
<span id="apache-beam-coders-slow-stream-module"></span><h2>apache_beam.coders.slow_stream module<a class="headerlink" href="#module-apache_beam.coders.slow_stream" title="Permalink to this headline">¶</a></h2>
<p>A pure Python implementation of stream.pyx.</p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<dl class="class">
<dt id="apache_beam.coders.slow_stream.ByteCountingOutputStream">
<em class="property">class </em><code class="descclassname">apache_beam.coders.slow_stream.</code><code class="descname">ByteCountingOutputStream</code><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#ByteCountingOutputStream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.ByteCountingOutputStream" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#apache_beam.coders.slow_stream.OutputStream" title="apache_beam.coders.slow_stream.OutputStream"><code class="xref py py-class docutils literal"><span class="pre">apache_beam.coders.slow_stream.OutputStream</span></code></a></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A pure Python implementation of stream.ByteCountingOutputStream.</p>
<dl class="method">
<dt id="apache_beam.coders.slow_stream.ByteCountingOutputStream.get">
<code class="descname">get</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#ByteCountingOutputStream.get"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.ByteCountingOutputStream.get" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.ByteCountingOutputStream.get_count">
<code class="descname">get_count</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#ByteCountingOutputStream.get_count"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.ByteCountingOutputStream.get_count" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.ByteCountingOutputStream.write">
<code class="descname">write</code><span class="sig-paren">(</span><em>byte_array</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#ByteCountingOutputStream.write"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.ByteCountingOutputStream.write" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.ByteCountingOutputStream.write_byte">
<code class="descname">write_byte</code><span class="sig-paren">(</span><em>_</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#ByteCountingOutputStream.write_byte"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.ByteCountingOutputStream.write_byte" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.slow_stream.InputStream">
<em class="property">class </em><code class="descclassname">apache_beam.coders.slow_stream.</code><code class="descname">InputStream</code><span class="sig-paren">(</span><em>data</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">object</span></code></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A pure Python implementation of stream.InputStream.</p>
<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read">
<code class="descname">read</code><span class="sig-paren">(</span><em>size</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read_all">
<code class="descname">read_all</code><span class="sig-paren">(</span><em>nested</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read_all"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read_all" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read_bigendian_double">
<code class="descname">read_bigendian_double</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read_bigendian_double"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read_bigendian_double" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read_bigendian_int32">
<code class="descname">read_bigendian_int32</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read_bigendian_int32"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read_bigendian_int32" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read_bigendian_int64">
<code class="descname">read_bigendian_int64</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read_bigendian_int64"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read_bigendian_int64" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read_bigendian_uint64">
<code class="descname">read_bigendian_uint64</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read_bigendian_uint64"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read_bigendian_uint64" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read_byte">
<code class="descname">read_byte</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read_byte"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read_byte" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.read_var_int64">
<code class="descname">read_var_int64</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.read_var_int64"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.read_var_int64" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.InputStream.size">
<code class="descname">size</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#InputStream.size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.InputStream.size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="apache_beam.coders.slow_stream.OutputStream">
<em class="property">class </em><code class="descclassname">apache_beam.coders.slow_stream.</code><code class="descname">OutputStream</code><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">object</span></code></p>
<p>For internal use only; no backwards-compatibility guarantees.</p>
<p>A pure Python implementation of stream.OutputStream.</p>
<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.get">
<code class="descname">get</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.get"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.get" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.size">
<code class="descname">size</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.size" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.write">
<code class="descname">write</code><span class="sig-paren">(</span><em>b</em>, <em>nested=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.write"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.write" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.write_bigendian_double">
<code class="descname">write_bigendian_double</code><span class="sig-paren">(</span><em>v</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.write_bigendian_double"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.write_bigendian_double" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.write_bigendian_int32">
<code class="descname">write_bigendian_int32</code><span class="sig-paren">(</span><em>v</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.write_bigendian_int32"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.write_bigendian_int32" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.write_bigendian_int64">
<code class="descname">write_bigendian_int64</code><span class="sig-paren">(</span><em>v</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.write_bigendian_int64"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.write_bigendian_int64" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.write_bigendian_uint64">
<code class="descname">write_bigendian_uint64</code><span class="sig-paren">(</span><em>v</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.write_bigendian_uint64"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.write_bigendian_uint64" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.write_byte">
<code class="descname">write_byte</code><span class="sig-paren">(</span><em>val</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.write_byte"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.write_byte" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="apache_beam.coders.slow_stream.OutputStream.write_var_int64">
<code class="descname">write_var_int64</code><span class="sig-paren">(</span><em>v</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#OutputStream.write_var_int64"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.OutputStream.write_var_int64" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="function">
<dt id="apache_beam.coders.slow_stream.get_varint_size">
<code class="descclassname">apache_beam.coders.slow_stream.</code><code class="descname">get_varint_size</code><span class="sig-paren">(</span><em>v</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/apache_beam/coders/slow_stream.html#get_varint_size"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#apache_beam.coders.slow_stream.get_varint_size" title="Permalink to this definition">¶</a></dt>
<dd><p>For internal use only; no backwards-compatibility guarantees.</p>
<p>Returns the size of the given integer value when encode as a VarInt.</p>
</dd></dl>

</div>
<div class="section" id="apache-beam-coders-stream-module">
<h2>apache_beam.coders.stream module<a class="headerlink" href="#apache-beam-coders-stream-module" title="Permalink to this headline">¶</a></h2>
<blockquote>
<div><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">members:</th><td class="field-body"></td>
</tr>
<tr class="field-even field"><th class="field-name">undoc-members:</th><td class="field-body"></td>
</tr>
<tr class="field-odd field"><th class="field-name" colspan="2">show-inheritance:</th></tr>
<tr class="field-odd field"><td>&#160;</td><td class="field-body"></td>
</tr>
</tbody>
</table>
</div></blockquote>
</div>
<div class="section" id="module-apache_beam.coders.typecoders">
<span id="apache-beam-coders-typecoders-module"></span><h2>apache_beam.coders.typecoders module<a class="headerlink" href="#module-apache_beam.coders.typecoders" title="Permalink to this headline">¶</a></h2>
<p>Type coders registration.</p>
<p>This module contains functionality to define and use coders for custom classes.
Let&#8217;s say we have a class Xyz and we are processing a PCollection with elements
of type Xyz. If we do not register a coder for Xyz, a default pickle-based
fallback coder will be used. This can be undesirable for two reasons. First, we
may want a faster coder or a more space efficient one. Second, the pickle-based
coder is not deterministic in the sense that objects like dictionaries or sets
are not guaranteed to be encoded in the same way every time (elements are not
really ordered).</p>
<dl class="docutils">
<dt>Two (sometimes three) steps are needed to define and use a custom coder:</dt>
<dd><ul class="first last simple">
<li>define the coder class</li>
<li>associate the code with the class (a.k.a. coder registration)</li>
<li>typehint DoFns or transforms with the new class or composite types using
the class.</li>
</ul>
</dd>
</dl>
<p>A coder class is defined by subclassing from CoderBase and defining the
encode_to_bytes and decode_from_bytes methods. The framework uses duck-typing
for coders so it is not strictly required to subclass from CoderBase as long as
the encode/decode methods are defined.</p>
<p>Registering a coder class is made with a register_coder() call:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">apache_beam</span> <span class="k">import</span> <span class="n">coders</span>
<span class="o">...</span>
<span class="n">coders</span><span class="o">.</span><span class="n">registry</span><span class="o">.</span><span class="n">register_coder</span><span class="p">(</span><span class="n">Xyz</span><span class="p">,</span> <span class="n">XyzCoder</span><span class="p">)</span>
</pre></div>
</div>
<p>Additionally, DoFns and PTransforms may need type hints. This is not always
necessary since there is functionality to infer the return types of DoFns by
analyzing the code. For instance, for the function below the return type of
&#8216;Xyz&#8217; will be inferred:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">MakeXyzs</span><span class="p">(</span><span class="n">v</span><span class="p">):</span>
  <span class="k">return</span> <span class="n">Xyz</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
</pre></div>
</div>
<p>If Xyz is inferred then its coder will be used whenever the framework needs to
serialize data (e.g., writing to the shuffler subsystem responsible for group by
key operations). If a typehint is needed it can be specified by decorating the
DoFns or using with_input_types/with_output_types methods on PTransforms. For
example, the above function can be decorated:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="nd">@with_output_types</span><span class="p">(</span><span class="n">Xyz</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">MakeXyzs</span><span class="p">(</span><span class="n">v</span><span class="p">):</span>
  <span class="k">return</span> <span class="n">complex_operation_returning_Xyz</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
</pre></div>
</div>
<p>See apache_beam.typehints.decorators module for more details.</p>
</div>
<div class="section" id="module-apache_beam.coders">
<span id="module-contents"></span><h2>Module contents<a class="headerlink" href="#module-apache_beam.coders" title="Permalink to this headline">¶</a></h2>
</div>
</div>


          </div>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="apache_beam.internal.html" title="apache_beam.internal package"
             >next</a> |</li>
        <li class="right" >
          <a href="apache_beam.html" title="apache_beam package"
             >previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="index.html">Apache Beam  documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="apache_beam.html" >apache_beam package</a> &#187;</li> 
      </ul>
    </div>
    <div class="footer" role="contentinfo">
        &#169; Copyright .
      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.5.5.
    </div>
  </body>
</html>