docs: def logs(self, container, stdout=True, stderr=True, stream=False,
               timestamps=False, tail='all', since=None, follow=None,
               until=None):
          """
          Get logs from a container. Similar to the ``docker logs`` command.
  
          The ``stream`` parameter makes the ``logs`` function return a blocking
          generator you can iterate over to retrieve log output as it happens.
  
          Args:
              container (str): The container to get logs from
              stdout (bool): Get ``STDOUT``. Default ``True``
              stderr (bool): Get ``STDERR``. Default ``True``
              stream (bool): Stream the response. Default ``False``
              timestamps (bool): Show timestamps. Default ``False``
              tail (str or int): Output specified number of lines at the end of
                  logs. Either an integer of number of lines or the string
                  ``all``. Default ``all``
              since (datetime or int): Show logs since a given datetime or
                  integer epoch (in seconds)
              follow (bool): Follow log output. Default ``False``
              until (datetime or int): Show logs that occurred before the given
                  datetime or integer epoch (in seconds)
  
          Returns:
              (generator or str)
  
          Raises:
              :py:class:`docker.errors.APIError`
                  If the server returns an error.
          """
          if follow is None:
              follow = stream
          params = {'stderr': stderr and 1 or 0,
                    'stdout': stdout and 1 or 0,
                    'timestamps': timestamps and 1 or 0,
                    'follow': follow and 1 or 0,
                    }
          if tail != 'all' and (not isinstance(tail, int) or tail < 0):
              tail = 'all'
          params['tail'] = tail
  
          if since is not None:
              if isinstance(since, datetime):
                  params['since'] = utils.datetime_to_timestamp(since)
              elif (isinstance(since, int) and since > 0):
                  params['since'] = since
              else:
                  raise errors.InvalidArgument(
                      'since value should be datetime or positive int, '
                      'not {}'.format(type(since))
                  )
  
          if until is not None:
              if utils.version_lt(self._version, '1.35'):
                  raise errors.InvalidVersion(
                      'until is not supported for API version < 1.35'
                  )
              if isinstance(until, datetime):
                  params['until'] = utils.datetime_to_timestamp(until)
              elif (isinstance(until, int) and until > 0):
                  params['until'] = until
              else:
                  raise errors.InvalidArgument(
                      'until value should be datetime or positive int, '
                      'not {}'.format(type(until))
                  )
  
          url = self._url("/containers/{0}/logs", container)
          res = self._get(url, params=params, stream=stream)
          output = self._get_result(container, stream, res)
  
          if stream:
              return CancellableStream(output, res)
          else:
              return output