<html><body>
<style>

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

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

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

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

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

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

pre {
  margin-top: 0.5em;
}

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

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

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

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

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

</style>

<h1><a href="fitness_v1.html">Fitness API</a> . <a href="fitness_v1.users.html">users</a> . <a href="fitness_v1.users.dataSources.html">dataSources</a> . <a href="fitness_v1.users.dataSources.datasets.html">datasets</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#delete">delete(userId, dataSourceId, datasetId, modifiedTimeMillis=None, currentTimeMillis=None, x__xgafv=None)</a></code></p>
<p class="firstline">Performs an inclusive delete of all data points whose start and end times</p>
<p class="toc_element">
  <code><a href="#get">get(userId, dataSourceId, datasetId, limit=None, pageToken=None, x__xgafv=None)</a></code></p>
<p class="firstline">Returns a dataset containing all data points whose start and end times</p>
<p class="toc_element">
  <code><a href="#get_next">get_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#patch">patch(userId, dataSourceId, datasetId, body=None, currentTimeMillis=None, x__xgafv=None)</a></code></p>
<p class="firstline">Adds data points to a dataset. The dataset need not be previously created.</p>
<p class="toc_element">
  <code><a href="#patch_next">patch_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="delete">delete(userId, dataSourceId, datasetId, modifiedTimeMillis=None, currentTimeMillis=None, x__xgafv=None)</code>
  <pre>Performs an inclusive delete of all data points whose start and end times
have any overlap with the time range specified by the dataset ID. For most
data types, the entire data point will be deleted. For data types where the
time span represents a consistent value (such as
&lt;code&gt;com.google.activity.segment&lt;/code&gt;), and a data point straddles
either end point of the dataset, only the overlapping portion of the data
point will be deleted.

Args:
  userId: string, Delete a dataset for the person identified. Use &lt;code&gt;me&lt;/code&gt; to indicate
the authenticated user. Only &lt;code&gt;me&lt;/code&gt; is supported at this time. (required)
  dataSourceId: string, The data stream ID of the data source that created the dataset. (required)
  datasetId: string, Dataset identifier that is a composite of the minimum data point start time
and maximum data point end time represented as nanoseconds from the epoch.
The ID is formatted like: &quot;&lt;var&gt;startTime&lt;/var&gt;-&lt;var&gt;endTime&lt;/var&gt;&quot;
where &lt;var&gt;startTime&lt;/var&gt; and &lt;var&gt;endTime&lt;/var&gt; are 64 bit integers. (required)
  modifiedTimeMillis: string, When the operation was performed on the client.
  currentTimeMillis: string, The client&#x27;s current time in milliseconds since epoch.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
</pre>
</div>

<div class="method">
    <code class="details" id="get">get(userId, dataSourceId, datasetId, limit=None, pageToken=None, x__xgafv=None)</code>
  <pre>Returns a dataset containing all data points whose start and end times
overlap with the specified range of the dataset minimum start time and
maximum end time. Specifically, any data point whose start time is less
than or equal to the dataset end time and whose end time is greater than or
equal to the dataset start time.

Args:
  userId: string, Retrieve a dataset for the person identified. Use &lt;code&gt;me&lt;/code&gt; to
indicate the authenticated user. Only &lt;code&gt;me&lt;/code&gt; is supported at this
time. (required)
  dataSourceId: string, The data stream ID of the data source that created the dataset. (required)
  datasetId: string, Dataset identifier that is a composite of the minimum data point start time
and maximum data point end time represented as nanoseconds from the epoch.
The ID is formatted like: &quot;&lt;var&gt;startTime&lt;/var&gt;-&lt;var&gt;endTime&lt;/var&gt;&quot;
where &lt;var&gt;startTime&lt;/var&gt; and &lt;var&gt;endTime&lt;/var&gt; are 64 bit integers. (required)
  limit: integer, If specified, no more than this many data points will be included in the
dataset. If there are more data points in the dataset, nextPageToken
will be set in the dataset response.
  pageToken: string, The continuation token, which is used to page through large datasets.
To get the next page of a dataset, set this parameter to the value of
&lt;code&gt;nextPageToken&lt;/code&gt; from the previous response. Each subsequent
call will yield a partial dataset with data point end timestamps that are
strictly smaller than those in the previous partial response.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A dataset represents a projection container for data points. They do not
      # carry any info of their own. Datasets represent a set of data points from a
      # particular data source. A data point can be found in more than one dataset.
    &quot;dataSourceId&quot;: &quot;A String&quot;, # The data stream ID of the data source that created the points in this
        # dataset.
    &quot;maxEndTimeNs&quot;: &quot;A String&quot;, # The largest end time of all data points in this possibly partial
        # representation of the dataset. Time is in nanoseconds from epoch. This
        # should also match the second part of the dataset identifier.
    &quot;minStartTimeNs&quot;: &quot;A String&quot;, # The smallest start time of all data points in this possibly partial
        # representation of the dataset. Time is in nanoseconds from epoch. This
        # should also match the first part of the dataset identifier.
    &quot;point&quot;: [ # A partial list of data points contained in the dataset, ordered by largest
        # endTimeNanos first. This list is considered complete when retrieving a
        # small dataset and partial when patching a dataset or retrieving a dataset
        # that is too large to include in a single response.
      { # Represents a single data point, generated by a particular data source.  A
          # data point holds a value for each field, an end timestamp and an optional
          # start time.  The exact semantics of each of these attributes are specified in
          # the documentation for the particular data type.
          #
          # A data point can represent an instantaneous measurement, reading or input
          # observation, as well as averages or aggregates over a time interval.  Check
          # the data type documentation to determine which is the case for a particular
          # data type.
          #
          # Data points always contain one value for each field of the data type.
        &quot;computationTimeMillis&quot;: &quot;A String&quot;, # DO NOT USE THIS FIELD. It is ignored, and not stored.
        &quot;dataTypeName&quot;: &quot;A String&quot;, # The data type defining the format of the values in this data point.
        &quot;endTimeNanos&quot;: &quot;A String&quot;, # The end time of the interval represented by this data point, in
            # nanoseconds since epoch.
        &quot;startTimeNanos&quot;: &quot;A String&quot;, # The start time of the interval represented by this data point, in
            # nanoseconds since epoch.
        &quot;originDataSourceId&quot;: &quot;A String&quot;, # If the data point is contained in a dataset for a derived data source,
            # this field will be populated with the data source stream ID that created
            # the data point originally.
            #
            # WARNING: do not rely on this field for anything other than debugging. The
            # value of this field, if it is set at all, is an implementation detail and
            # is not guaranteed to remain consistent.
        &quot;modifiedTimeMillis&quot;: &quot;A String&quot;, # Indicates the last time this data point was modified. Useful only in
            # contexts where we are listing the data changes, rather than representing
            # the current state of the data.
        &quot;rawTimestampNanos&quot;: &quot;A String&quot;, # The raw timestamp from the original SensorEvent.
        &quot;value&quot;: [ # Values of each data type field for the data point. It is expected that each
            # value corresponding to a data type field will occur in the same order that
            # the field is listed with in the data type specified in a data source.
            #
            # Only one of integer and floating point fields will be populated, depending
            # on the format enum value within data source&#x27;s type field.
          { # Holder object for the value of a single field in a data point.
              #
              # A field value has a particular format and is only ever set to one of an
              # integer or a floating point value.
            &quot;stringVal&quot;: &quot;A String&quot;, # String value.  When this is set, other values must not be set.
                # Strings should be kept small whenever possible.  Data streams with large
                # string values and high data frequency may be down sampled.
            &quot;mapVal&quot;: [ # Map value.  The valid key space and units for the corresponding value
                # of each entry should be documented as part of the data type definition.
                # Keys should be kept small whenever possible. Data streams with large keys
                # and high data frequency may be down sampled.
              {
                &quot;value&quot;: { # Holder object for the value of an entry in a map field of a data point.
                    #
                    # A map value supports a subset of the formats that the regular Value supports.
                  &quot;fpVal&quot;: 3.14, # Floating point value.
                },
                &quot;key&quot;: &quot;A String&quot;,
              },
            ],
            &quot;fpVal&quot;: 3.14, # Floating point value. When this is set, other values must not be set.
            &quot;intVal&quot;: 42, # Integer value. When this is set, other values must not be set.
          },
        ],
      },
    ],
    &quot;nextPageToken&quot;: &quot;A String&quot;, # This token will be set when a dataset is received in response to a GET
        # request and the dataset is too large to be included in a single response.
        # Provide this value in a subsequent GET request to return the next page of
        # data points within this dataset.
  }</pre>
</div>

<div class="method">
    <code class="details" id="get_next">get_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call &#x27;execute()&#x27; on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(userId, dataSourceId, datasetId, body=None, currentTimeMillis=None, x__xgafv=None)</code>
  <pre>Adds data points to a dataset. The dataset need not be previously created.
All points within the given dataset will be returned with subsquent calls
to retrieve this dataset. Data points can belong to more than one dataset.
This method does not use patch semantics.

Args:
  userId: string, Patch a dataset for the person identified. Use &lt;code&gt;me&lt;/code&gt; to indicate
the authenticated user. Only &lt;code&gt;me&lt;/code&gt; is supported at this time. (required)
  dataSourceId: string, The data stream ID of the data source that created the dataset. (required)
  datasetId: string, Dataset identifier that is a composite of the minimum data point start time
and maximum data point end time represented as nanoseconds from the epoch.
The ID is formatted like: &quot;&lt;var&gt;startTime&lt;/var&gt;-&lt;var&gt;endTime&lt;/var&gt;&quot;
where &lt;var&gt;startTime&lt;/var&gt; and &lt;var&gt;endTime&lt;/var&gt; are 64 bit integers. (required)
  body: object, The request body.
    The object takes the form of:

{ # A dataset represents a projection container for data points. They do not
    # carry any info of their own. Datasets represent a set of data points from a
    # particular data source. A data point can be found in more than one dataset.
  &quot;dataSourceId&quot;: &quot;A String&quot;, # The data stream ID of the data source that created the points in this
      # dataset.
  &quot;maxEndTimeNs&quot;: &quot;A String&quot;, # The largest end time of all data points in this possibly partial
      # representation of the dataset. Time is in nanoseconds from epoch. This
      # should also match the second part of the dataset identifier.
  &quot;minStartTimeNs&quot;: &quot;A String&quot;, # The smallest start time of all data points in this possibly partial
      # representation of the dataset. Time is in nanoseconds from epoch. This
      # should also match the first part of the dataset identifier.
  &quot;point&quot;: [ # A partial list of data points contained in the dataset, ordered by largest
      # endTimeNanos first. This list is considered complete when retrieving a
      # small dataset and partial when patching a dataset or retrieving a dataset
      # that is too large to include in a single response.
    { # Represents a single data point, generated by a particular data source.  A
        # data point holds a value for each field, an end timestamp and an optional
        # start time.  The exact semantics of each of these attributes are specified in
        # the documentation for the particular data type.
        #
        # A data point can represent an instantaneous measurement, reading or input
        # observation, as well as averages or aggregates over a time interval.  Check
        # the data type documentation to determine which is the case for a particular
        # data type.
        #
        # Data points always contain one value for each field of the data type.
      &quot;computationTimeMillis&quot;: &quot;A String&quot;, # DO NOT USE THIS FIELD. It is ignored, and not stored.
      &quot;dataTypeName&quot;: &quot;A String&quot;, # The data type defining the format of the values in this data point.
      &quot;endTimeNanos&quot;: &quot;A String&quot;, # The end time of the interval represented by this data point, in
          # nanoseconds since epoch.
      &quot;startTimeNanos&quot;: &quot;A String&quot;, # The start time of the interval represented by this data point, in
          # nanoseconds since epoch.
      &quot;originDataSourceId&quot;: &quot;A String&quot;, # If the data point is contained in a dataset for a derived data source,
          # this field will be populated with the data source stream ID that created
          # the data point originally.
          #
          # WARNING: do not rely on this field for anything other than debugging. The
          # value of this field, if it is set at all, is an implementation detail and
          # is not guaranteed to remain consistent.
      &quot;modifiedTimeMillis&quot;: &quot;A String&quot;, # Indicates the last time this data point was modified. Useful only in
          # contexts where we are listing the data changes, rather than representing
          # the current state of the data.
      &quot;rawTimestampNanos&quot;: &quot;A String&quot;, # The raw timestamp from the original SensorEvent.
      &quot;value&quot;: [ # Values of each data type field for the data point. It is expected that each
          # value corresponding to a data type field will occur in the same order that
          # the field is listed with in the data type specified in a data source.
          #
          # Only one of integer and floating point fields will be populated, depending
          # on the format enum value within data source&#x27;s type field.
        { # Holder object for the value of a single field in a data point.
            #
            # A field value has a particular format and is only ever set to one of an
            # integer or a floating point value.
          &quot;stringVal&quot;: &quot;A String&quot;, # String value.  When this is set, other values must not be set.
              # Strings should be kept small whenever possible.  Data streams with large
              # string values and high data frequency may be down sampled.
          &quot;mapVal&quot;: [ # Map value.  The valid key space and units for the corresponding value
              # of each entry should be documented as part of the data type definition.
              # Keys should be kept small whenever possible. Data streams with large keys
              # and high data frequency may be down sampled.
            {
              &quot;value&quot;: { # Holder object for the value of an entry in a map field of a data point.
                  #
                  # A map value supports a subset of the formats that the regular Value supports.
                &quot;fpVal&quot;: 3.14, # Floating point value.
              },
              &quot;key&quot;: &quot;A String&quot;,
            },
          ],
          &quot;fpVal&quot;: 3.14, # Floating point value. When this is set, other values must not be set.
          &quot;intVal&quot;: 42, # Integer value. When this is set, other values must not be set.
        },
      ],
    },
  ],
  &quot;nextPageToken&quot;: &quot;A String&quot;, # This token will be set when a dataset is received in response to a GET
      # request and the dataset is too large to be included in a single response.
      # Provide this value in a subsequent GET request to return the next page of
      # data points within this dataset.
}

  currentTimeMillis: string, The client&#x27;s current time in milliseconds since epoch. Note that the
&lt;code&gt;minStartTimeNs&lt;/code&gt; and &lt;code&gt;maxEndTimeNs&lt;/code&gt; properties in
the request body are in nanoseconds instead of milliseconds.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A dataset represents a projection container for data points. They do not
      # carry any info of their own. Datasets represent a set of data points from a
      # particular data source. A data point can be found in more than one dataset.
    &quot;dataSourceId&quot;: &quot;A String&quot;, # The data stream ID of the data source that created the points in this
        # dataset.
    &quot;maxEndTimeNs&quot;: &quot;A String&quot;, # The largest end time of all data points in this possibly partial
        # representation of the dataset. Time is in nanoseconds from epoch. This
        # should also match the second part of the dataset identifier.
    &quot;minStartTimeNs&quot;: &quot;A String&quot;, # The smallest start time of all data points in this possibly partial
        # representation of the dataset. Time is in nanoseconds from epoch. This
        # should also match the first part of the dataset identifier.
    &quot;point&quot;: [ # A partial list of data points contained in the dataset, ordered by largest
        # endTimeNanos first. This list is considered complete when retrieving a
        # small dataset and partial when patching a dataset or retrieving a dataset
        # that is too large to include in a single response.
      { # Represents a single data point, generated by a particular data source.  A
          # data point holds a value for each field, an end timestamp and an optional
          # start time.  The exact semantics of each of these attributes are specified in
          # the documentation for the particular data type.
          #
          # A data point can represent an instantaneous measurement, reading or input
          # observation, as well as averages or aggregates over a time interval.  Check
          # the data type documentation to determine which is the case for a particular
          # data type.
          #
          # Data points always contain one value for each field of the data type.
        &quot;computationTimeMillis&quot;: &quot;A String&quot;, # DO NOT USE THIS FIELD. It is ignored, and not stored.
        &quot;dataTypeName&quot;: &quot;A String&quot;, # The data type defining the format of the values in this data point.
        &quot;endTimeNanos&quot;: &quot;A String&quot;, # The end time of the interval represented by this data point, in
            # nanoseconds since epoch.
        &quot;startTimeNanos&quot;: &quot;A String&quot;, # The start time of the interval represented by this data point, in
            # nanoseconds since epoch.
        &quot;originDataSourceId&quot;: &quot;A String&quot;, # If the data point is contained in a dataset for a derived data source,
            # this field will be populated with the data source stream ID that created
            # the data point originally.
            #
            # WARNING: do not rely on this field for anything other than debugging. The
            # value of this field, if it is set at all, is an implementation detail and
            # is not guaranteed to remain consistent.
        &quot;modifiedTimeMillis&quot;: &quot;A String&quot;, # Indicates the last time this data point was modified. Useful only in
            # contexts where we are listing the data changes, rather than representing
            # the current state of the data.
        &quot;rawTimestampNanos&quot;: &quot;A String&quot;, # The raw timestamp from the original SensorEvent.
        &quot;value&quot;: [ # Values of each data type field for the data point. It is expected that each
            # value corresponding to a data type field will occur in the same order that
            # the field is listed with in the data type specified in a data source.
            #
            # Only one of integer and floating point fields will be populated, depending
            # on the format enum value within data source&#x27;s type field.
          { # Holder object for the value of a single field in a data point.
              #
              # A field value has a particular format and is only ever set to one of an
              # integer or a floating point value.
            &quot;stringVal&quot;: &quot;A String&quot;, # String value.  When this is set, other values must not be set.
                # Strings should be kept small whenever possible.  Data streams with large
                # string values and high data frequency may be down sampled.
            &quot;mapVal&quot;: [ # Map value.  The valid key space and units for the corresponding value
                # of each entry should be documented as part of the data type definition.
                # Keys should be kept small whenever possible. Data streams with large keys
                # and high data frequency may be down sampled.
              {
                &quot;value&quot;: { # Holder object for the value of an entry in a map field of a data point.
                    #
                    # A map value supports a subset of the formats that the regular Value supports.
                  &quot;fpVal&quot;: 3.14, # Floating point value.
                },
                &quot;key&quot;: &quot;A String&quot;,
              },
            ],
            &quot;fpVal&quot;: 3.14, # Floating point value. When this is set, other values must not be set.
            &quot;intVal&quot;: 42, # Integer value. When this is set, other values must not be set.
          },
        ],
      },
    ],
    &quot;nextPageToken&quot;: &quot;A String&quot;, # This token will be set when a dataset is received in response to a GET
        # request and the dataset is too large to be included in a single response.
        # Provide this value in a subsequent GET request to return the next page of
        # data points within this dataset.
  }</pre>
</div>

<div class="method">
    <code class="details" id="patch_next">patch_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call &#x27;execute()&#x27; on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

</body></html>