def from_strings(cls, query_parts, default_fields=None, all_keys=ITEM_KEYS): """Creates a query from a list of strings in the format used by _parse_query_part. If default_fields are specified, they are the fields to be searched by unqualified search terms. Otherwise, all fields are searched for those terms. """ subqueries = [] for part in query_parts: res = cls._parse_query_part(part) if not res: continue key, pattern = res if key is None: # No key specified. if os.sep in pattern and 'path' in all_keys: # This looks like a path. subqueries.append(PathQuery(pattern)) else: # Match any field. subqueries.append(AnySubstringQuery(pattern, default_fields)) elif key.lower() == 'comp': # a boolean field subqueries.append(BooleanQuery(key.lower(), pattern)) elif key.lower() == 'path' and 'path' in all_keys: subqueries.append(PathQuery(pattern)) elif key.lower() in all_keys: # ignore unrecognized keys subqueries.append(SubstringQuery(key.lower(), pattern)) elif key.lower() == 'singleton': subqueries.append(SingletonQuery(util.str2bool(pattern))) if not subqueries: # no terms in query subqueries = [TrueQuery()] return cls(subqueries)
def from_strings(cls, query_parts, default_fields=None, all_keys=ITEM_KEYS): """Creates a query from a list of strings in the format used by _parse_query_part. If default_fields are specified, they are the fields to be searched by unqualified search terms. Otherwise, all fields are searched for those terms. """ subqueries = [] for part in query_parts: res = cls._parse_query_part(part) if not res: continue key, pattern = res if key is None: # No key specified. if os.sep in pattern: # This looks like a path. subqueries.append(PathQuery(pattern)) else: # Match any field. subqueries.append(AnySubstringQuery(pattern, default_fields)) elif key.lower() == 'comp': # a boolean field subqueries.append(BooleanQuery(key.lower(), pattern)) elif key.lower() == 'path': subqueries.append(PathQuery(pattern)) elif key.lower() in all_keys: # ignore unrecognized keys subqueries.append(SubstringQuery(key.lower(), pattern)) elif key.lower() == 'singleton': subqueries.append(SingletonQuery(util.str2bool(pattern))) if not subqueries: # no terms in query subqueries = [TrueQuery()] return cls(subqueries)
def construct_query_part(query_part, default_fields, all_keys): """Create a query from a single query component. Return a Query instance or None if the value cannot be parsed. """ parsed = parse_query_part(query_part) if not parsed: return key, pattern, query_class = parsed # No key specified. if key is None: if os.sep in pattern and 'path' in all_keys: # This looks like a path. return PathQuery(pattern) elif issubclass(query_class, dbcore.FieldQuery): # The query type matches a specific field, but none was # specified. So we use a version of the query that matches # any field. return AnyFieldQuery(pattern, default_fields, query_class) else: # Other query type. return query_class(pattern) key = key.lower() # A boolean field. if key.lower() == 'comp': return BooleanQuery(key, pattern) # Path field. elif key == 'path' and 'path' in all_keys: if query_class is SubstringQuery: # By default, use special path matching logic. return PathQuery(pattern) else: # Specific query type requested. return query_class('path', pattern) # Singleton query (not a real field). elif key == 'singleton': return SingletonQuery(util.str2bool(pattern)) # Other field. else: return query_class(key.lower(), pattern, key in all_keys)
def from_string(cls, query_string, default_fields=None): """Creates a query from a string in the format used by _parse_query. If default_fields are specified, they are the fields to be searched by unqualified search terms. Otherwise, all fields are searched for those terms. """ subqueries = [] for key, pattern in cls._parse_query(query_string): if key is None: # no key specified; match any field subqueries.append(AnySubstringQuery(pattern, default_fields)) elif key.lower() == 'comp': # a boolean field subqueries.append(BooleanQuery(key.lower(), pattern)) elif key.lower() in ITEM_KEYS: # ignore unrecognized keys subqueries.append(SubstringQuery(key.lower(), pattern)) elif key.lower() == 'singleton': subqueries.append(SingletonQuery(util.str2bool(pattern))) if not subqueries: # no terms in query subqueries = [TrueQuery()] return cls(subqueries)
def _convert_type(key, value, album=False): """Convert a string to the appropriate type for the given field. `album` indicates whether to use album or item field definitions. """ fields = library.ALBUM_FIELDS if album else library.ITEM_FIELDS typ = [f[1] for f in fields if f[0] == key][0] if typ is bool: return util.str2bool(value) elif typ is datetime: fmt = config['time_format'].get(unicode) try: return time.mktime(time.strptime(value, fmt)) except ValueError: raise ui.UserError(u'{0} must have format {1}'.format(key, fmt)) else: try: return typ(value) except ValueError: raise ui.UserError(u'{0} must be a {1}'.format(key, typ))
def construct_query_part(query_part, model_cls): """Create a query from a single query component, `query_part`, for querying instances of `model_cls`. Return a `Query` instance. """ # Shortcut for empty query parts. if not query_part: return dbcore.query.TrueQuery() # Set up and parse the string. query_classes = dict((k, t.query) for (k, t) in model_cls._fields.items()) prefixes = {':': dbcore.query.RegexpQuery} prefixes.update(plugins.queries()) key, pattern, query_class = \ parse_query_part(query_part, query_classes, prefixes) # No key specified. if key is None: if os.sep in pattern and 'path' in model_cls._fields: # This looks like a path. return PathQuery('path', pattern) elif issubclass(query_class, dbcore.FieldQuery): # The query type matches a specific field, but none was # specified. So we use a version of the query that matches # any field. return dbcore.query.AnyFieldQuery(pattern, model_cls._search_fields, query_class) else: # Other query type. return query_class(pattern) key = key.lower() # Singleton query (not a real field). if key == 'singleton': return SingletonQuery(util.str2bool(pattern)) # Other field. else: return query_class(key.lower(), pattern, key in model_cls._fields)
def __init__(self, field, pattern, fast=True): super(BooleanQuery, self).__init__(field, pattern, fast) if isinstance(pattern, basestring): self.pattern = util.str2bool(pattern) self.pattern = int(self.pattern)
def parse(self, string): return str2bool(string)
def __init__(self, field, pattern, fast=True): super().__init__(field, pattern, fast) if isinstance(pattern, str): self.pattern = util.str2bool(pattern) self.pattern = int(self.pattern)