docs: def _apply_query(self, query, document):
          """
          Applies a query to a document. Returns True if the document meets the criteria of
          the supplied query. The ``query`` argument generally follows mongodb style syntax
          and consists of the following logical checks and operators.
  
          Logical: $and, $or, $nor, $not
          Operators: $eq, $ne, $gt, $gte, $lt, $lte, $mod, $in, $nin, $all
  
          If no logical operator is supplied, it assumed that all field checks must pass. For
          example, these are equivalent:
  
              {'foo': 'bar', 'baz': 'qux'}
              {'$and': [{'foo': 'bar'}, {'baz': 'qux'}]}
  
          Both logical and operational queries can be nested in a complex fashion:
  
              {
                  'bar': 'baz',
                  '$or': [
                      {
                          'foo': {
                              '$gte': 0,
                              '$lte': 10,
                              '$mod': [2, 0]
                          }
                      },
                      {
                          'foo': {
                              '$gt': 10,
                              '$mod': [2, 1]
                          }
                      },
                  ]
              }
  
          In the previous example, this will return any document where the 'bar' key is equal
          to 'baz' and either the 'foo' key is an even number between 0 and 10 or is an odd number
          greater than 10.
          """
          matches = []  # A list of booleans
          reapply = lambda q: self._apply_query(q, document)
  
          for field, value in query.items():
              # A more complex query type $and, $or, etc
              if field == '$and':
                  matches.append(all(map(reapply, value)))
              elif field == '$or':
                  matches.append(any(map(reapply, value)))
              elif field == '$nor':
                  matches.append(not any(map(reapply, value)))
              elif field == '$not':
                  matches.append(not self._apply_query(value, document))
  
              # Invoke a query operator
              elif isinstance(value, dict):
                  for operator, arg in value.items():
                      if not self._get_operator_fn(operator)(field, arg, document):
                          matches.append(False)
                          break
                  else:
                      matches.append(True)
  
              # Standard
              elif value != document.get(field, None):
                  # check if field contains a dot
                  if '.' in field:
                      nodes = field.split('.')
                      document_section = document
  
                      try:
                          for path in nodes[:-1]:
                              document_section = document_section.get(path, None)
                      except AttributeError:
                          document_section = None
  
                      if document_section is None:
                          matches.append(False)
                      else:
                          if value != document_section.get(nodes[-1], None):
                              matches.append(False)
                  else:
                      matches.append(False)
  
          return all(matches)