'Constructor.
Args:
kind: Optional kind string.
ancestor: Optional ancestor Key.
filters: Optional Node representing a filter expression tree.
orders: Optional datastore_query.Order object.
app: Optional app id.
namespace: Optional namespace.
default_options: Optional QueryOptions object.
projection: Optional list or tuple of properties to project.
group_by: Optional list or tuple of properties to group by.'

@utils.positional(1)
def __init__(self, kind=None, ancestor=None, filters=None, orders=None, app=None, namespace=None, default_options=None, projection=None, group_by=None):

    if (ancestor is not None):
        if isinstance(ancestor, ParameterizedThing):
            if isinstance(ancestor, ParameterizedFunction):
                if (ancestor.func != 'key'):
                    raise TypeError('ancestor    cannot    be    a    GQL    function    other    than    KEY')
        else:
            if (not isinstance(ancestor, model.Key)):
                raise TypeError(('ancestor    must    be    a    Key;    received    %r' % (ancestor,)))
            if (not ancestor.id()):
                raise ValueError('ancestor    cannot    be    an    incomplete    key')
            if (app is not None):
                if (app != ancestor.app()):
                    raise TypeError('app/ancestor    mismatch')
            if (namespace is None):
                namespace = ancestor.namespace()
            elif (namespace != ancestor.namespace()):
                raise TypeError('namespace/ancestor    mismatch')
    if (filters is not None):
        if (not isinstance(filters, Node)):
            raise TypeError(('filters    must    be    a    query    Node    or    None;    received    %r' % (filters,)))
    if (orders is not None):
        if (not isinstance(orders, datastore_query.Order)):
            raise TypeError(('orders    must    be    an    Order    instance    or    None;    received    %r' % (orders,)))
    if (default_options is not None):
        if (not isinstance(default_options, datastore_rpc.BaseConfiguration)):
            raise TypeError(('default_options    must    be    a    Configuration    or    None;    received    %r' % (default_options,)))
        if (projection is not None):
            if (default_options.projection is not None):
                raise TypeError('cannot    use    projection=    and    default_options.projection    at    the    same    time')
            if (default_options.keys_only is not None):
                raise TypeError('cannot    use    projection=    and    default_options.keys_only    at    the    same    time')
    self.__kind = kind
    self.__ancestor = ancestor
    self.__filters = filters
    self.__orders = orders
    self.__app = app
    self.__namespace = namespace
    self.__default_options = default_options
    self.__projection = None
    if (projection is not None):
        if (not projection):
            raise TypeError('projection    argument    cannot    be    empty')
        if (not isinstance(projection, (tuple, list))):
            raise TypeError(('projection    must    be    a    tuple,    list    or    None;    received    %r' % (projection,)))
        self._check_properties(self._to_property_names(projection))
        self.__projection = tuple(projection)
    self.__group_by = None
    if (group_by is not None):
        if (not group_by):
            raise TypeError('group_by    argument    cannot    be    empty')
        if (not isinstance(group_by, (tuple, list))):
            raise TypeError(('group_by    must    be    a    tuple,    list    or    None;    received    %r' % (group_by,)))
        self._check_properties(self._to_property_names(group_by))
        self.__group_by = tuple(group_by)
