测试gitnore

venv/Lib/site-packages/django/contrib/postgres/search.py

@@ -1,25 +1,18 @@
 import psycopg2
 
 from django.db.models import (
-    CharField,
-    Expression,
-    Field,
-    FloatField,
-    Func,
-    Lookup,
-    TextField,
-    Value,
+    CharField, Expression, Field, FloatField, Func, Lookup, TextField, Value,
 )
 from django.db.models.expressions import CombinedExpression
 from django.db.models.functions import Cast, Coalesce
 
 
 class SearchVectorExact(Lookup):
-    lookup_name = "exact"
+    lookup_name = 'exact'
 
     def process_rhs(self, qn, connection):
         if not isinstance(self.rhs, (SearchQuery, CombinedSearchQuery)):
-            config = getattr(self.lhs, "config", None)
+            config = getattr(self.lhs, 'config', None)
             self.rhs = SearchQuery(self.rhs, config=config)
         rhs, rhs_params = super().process_rhs(qn, connection)
         return rhs, rhs_params
@@ -28,23 +21,25 @@ class SearchVectorExact(Lookup):
         lhs, lhs_params = self.process_lhs(qn, connection)
         rhs, rhs_params = self.process_rhs(qn, connection)
         params = lhs_params + rhs_params
-        return "%s @@ %s" % (lhs, rhs), params
+        return '%s @@ %s' % (lhs, rhs), params
 
 
 class SearchVectorField(Field):
+
     def db_type(self, connection):
-        return "tsvector"
+        return 'tsvector'
 
 
 class SearchQueryField(Field):
+
     def db_type(self, connection):
-        return "tsquery"
+        return 'tsquery'
 
 
 class SearchConfig(Expression):
     def __init__(self, config):
         super().__init__()
-        if not hasattr(config, "resolve_expression"):
+        if not hasattr(config, 'resolve_expression'):
             config = Value(config)
         self.config = config
 
@@ -58,21 +53,21 @@ class SearchConfig(Expression):
         return [self.config]
 
     def set_source_expressions(self, exprs):
-        (self.config,) = exprs
+        self.config, = exprs
 
     def as_sql(self, compiler, connection):
         sql, params = compiler.compile(self.config)
-        return "%s::regconfig" % sql, params
+        return '%s::regconfig' % sql, params
 
 
 class SearchVectorCombinable:
-    ADD = "||"
+    ADD = '||'
 
     def _combine(self, other, connector, reversed):
         if not isinstance(other, SearchVectorCombinable):
             raise TypeError(
-                "SearchVector can only be combined with other SearchVector "
-                "instances, got %s." % type(other).__name__
+                'SearchVector can only be combined with other SearchVector '
+                'instances, got %s.' % type(other).__name__
             )
         if reversed:
             return CombinedSearchVector(other, connector, self, self.config)
@@ -80,61 +75,49 @@ class SearchVectorCombinable:
 
 
 class SearchVector(SearchVectorCombinable, Func):
-    function = "to_tsvector"
+    function = 'to_tsvector'
     arg_joiner = " || ' ' || "
     output_field = SearchVectorField()
 
     def __init__(self, *expressions, config=None, weight=None):
         super().__init__(*expressions)
         self.config = SearchConfig.from_parameter(config)
-        if weight is not None and not hasattr(weight, "resolve_expression"):
+        if weight is not None and not hasattr(weight, 'resolve_expression'):
             weight = Value(weight)
         self.weight = weight
 
-    def resolve_expression(
-        self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
-    ):
-        resolved = super().resolve_expression(
-            query, allow_joins, reuse, summarize, for_save
-        )
+    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
+        resolved = super().resolve_expression(query, allow_joins, reuse, summarize, for_save)
         if self.config:
-            resolved.config = self.config.resolve_expression(
-                query, allow_joins, reuse, summarize, for_save
-            )
+            resolved.config = self.config.resolve_expression(query, allow_joins, reuse, summarize, for_save)
         return resolved
 
     def as_sql(self, compiler, connection, function=None, template=None):
         clone = self.copy()
-        clone.set_source_expressions(
-            [
-                Coalesce(
-                    expression
-                    if isinstance(expression.output_field, (CharField, TextField))
-                    else Cast(expression, TextField()),
-                    Value(""),
-                )
-                for expression in clone.get_source_expressions()
-            ]
-        )
+        clone.set_source_expressions([
+            Coalesce(
+                expression
+                if isinstance(expression.output_field, (CharField, TextField))
+                else Cast(expression, TextField()),
+                Value('')
+            ) for expression in clone.get_source_expressions()
+        ])
         config_sql = None
         config_params = []
         if template is None:
             if clone.config:
                 config_sql, config_params = compiler.compile(clone.config)
-                template = "%(function)s(%(config)s, %(expressions)s)"
+                template = '%(function)s(%(config)s, %(expressions)s)'
             else:
                 template = clone.template
         sql, params = super(SearchVector, clone).as_sql(
-            compiler,
-            connection,
-            function=function,
-            template=template,
+            compiler, connection, function=function, template=template,
             config=config_sql,
         )
         extra_params = []
         if clone.weight:
             weight_sql, extra_params = compiler.compile(clone.weight)
-            sql = "setweight({}, {})".format(sql, weight_sql)
+            sql = 'setweight({}, {})'.format(sql, weight_sql)
         return sql, config_params + params + extra_params
 
 
@@ -145,14 +128,14 @@ class CombinedSearchVector(SearchVectorCombinable, CombinedExpression):
 
 
 class SearchQueryCombinable:
-    BITAND = "&&"
-    BITOR = "||"
+    BITAND = '&&'
+    BITOR = '||'
 
     def _combine(self, other, connector, reversed):
         if not isinstance(other, SearchQueryCombinable):
             raise TypeError(
-                "SearchQuery can only be combined with other SearchQuery "
-                "instances, got %s." % type(other).__name__
+                'SearchQuery can only be combined with other SearchQuery '
+                'instances, got %s.' % type(other).__name__
             )
         if reversed:
             return CombinedSearchQuery(other, connector, self, self.config)
@@ -177,25 +160,17 @@ class SearchQueryCombinable:
 class SearchQuery(SearchQueryCombinable, Func):
     output_field = SearchQueryField()
     SEARCH_TYPES = {
-        "plain": "plainto_tsquery",
-        "phrase": "phraseto_tsquery",
-        "raw": "to_tsquery",
-        "websearch": "websearch_to_tsquery",
+        'plain': 'plainto_tsquery',
+        'phrase': 'phraseto_tsquery',
+        'raw': 'to_tsquery',
+        'websearch': 'websearch_to_tsquery',
     }
 
-    def __init__(
-        self,
-        value,
-        output_field=None,
-        *,
-        config=None,
-        invert=False,
-        search_type="plain",
-    ):
+    def __init__(self, value, output_field=None, *, config=None, invert=False, search_type='plain'):
         self.function = self.SEARCH_TYPES.get(search_type)
         if self.function is None:
             raise ValueError("Unknown search_type argument '%s'." % search_type)
-        if not hasattr(value, "resolve_expression"):
+        if not hasattr(value, 'resolve_expression'):
             value = Value(value)
         expressions = (value,)
         self.config = SearchConfig.from_parameter(config)
@@ -207,7 +182,7 @@ class SearchQuery(SearchQueryCombinable, Func):
     def as_sql(self, compiler, connection, function=None, template=None):
         sql, params = super().as_sql(compiler, connection, function, template)
         if self.invert:
-            sql = "!!(%s)" % sql
+            sql = '!!(%s)' % sql
         return sql, params
 
     def __invert__(self):
@@ -217,7 +192,7 @@ class SearchQuery(SearchQueryCombinable, Func):
 
     def __str__(self):
         result = super().__str__()
-        return ("~%s" % result) if self.invert else result
+        return ('~%s' % result) if self.invert else result
 
 
 class CombinedSearchQuery(SearchQueryCombinable, CombinedExpression):
@@ -226,73 +201,60 @@ class CombinedSearchQuery(SearchQueryCombinable, CombinedExpression):
         super().__init__(lhs, connector, rhs, output_field)
 
     def __str__(self):
-        return "(%s)" % super().__str__()
+        return '(%s)' % super().__str__()
 
 
 class SearchRank(Func):
-    function = "ts_rank"
+    function = 'ts_rank'
     output_field = FloatField()
 
     def __init__(
-        self,
-        vector,
-        query,
-        weights=None,
-        normalization=None,
+        self, vector, query, weights=None, normalization=None,
         cover_density=False,
     ):
-        if not hasattr(vector, "resolve_expression"):
+        if not hasattr(vector, 'resolve_expression'):
             vector = SearchVector(vector)
-        if not hasattr(query, "resolve_expression"):
+        if not hasattr(query, 'resolve_expression'):
             query = SearchQuery(query)
         expressions = (vector, query)
         if weights is not None:
-            if not hasattr(weights, "resolve_expression"):
+            if not hasattr(weights, 'resolve_expression'):
                 weights = Value(weights)
             expressions = (weights,) + expressions
         if normalization is not None:
-            if not hasattr(normalization, "resolve_expression"):
+            if not hasattr(normalization, 'resolve_expression'):
                 normalization = Value(normalization)
             expressions += (normalization,)
         if cover_density:
-            self.function = "ts_rank_cd"
+            self.function = 'ts_rank_cd'
         super().__init__(*expressions)
 
 
 class SearchHeadline(Func):
-    function = "ts_headline"
-    template = "%(function)s(%(expressions)s%(options)s)"
+    function = 'ts_headline'
+    template = '%(function)s(%(expressions)s%(options)s)'
     output_field = TextField()
 
     def __init__(
-        self,
-        expression,
-        query,
-        *,
-        config=None,
-        start_sel=None,
-        stop_sel=None,
-        max_words=None,
-        min_words=None,
-        short_word=None,
-        highlight_all=None,
-        max_fragments=None,
-        fragment_delimiter=None,
+        self, expression, query, *, config=None, start_sel=None, stop_sel=None,
+        max_words=None, min_words=None, short_word=None, highlight_all=None,
+        max_fragments=None, fragment_delimiter=None,
     ):
-        if not hasattr(query, "resolve_expression"):
+        if not hasattr(query, 'resolve_expression'):
             query = SearchQuery(query)
         options = {
-            "StartSel": start_sel,
-            "StopSel": stop_sel,
-            "MaxWords": max_words,
-            "MinWords": min_words,
-            "ShortWord": short_word,
-            "HighlightAll": highlight_all,
-            "MaxFragments": max_fragments,
-            "FragmentDelimiter": fragment_delimiter,
+            'StartSel': start_sel,
+            'StopSel': stop_sel,
+            'MaxWords': max_words,
+            'MinWords': min_words,
+            'ShortWord': short_word,
+            'HighlightAll': highlight_all,
+            'MaxFragments': max_fragments,
+            'FragmentDelimiter': fragment_delimiter,
         }
         self.options = {
-            option: value for option, value in options.items() if value is not None
+            option: value
+            for option, value in options.items() if value is not None
         }
         expressions = (expression, query)
         if config is not None:
@@ -301,26 +263,19 @@ class SearchHeadline(Func):
         super().__init__(*expressions)
 
     def as_sql(self, compiler, connection, function=None, template=None):
-        options_sql = ""
+        options_sql = ''
         options_params = []
         if self.options:
             # getquoted() returns a quoted bytestring of the adapted value.
-            options_params.append(
-                ", ".join(
-                    "%s=%s"
-                    % (
-                        option,
-                        psycopg2.extensions.adapt(value).getquoted().decode(),
-                    )
-                    for option, value in self.options.items()
-                )
-            )
-            options_sql = ", %s"
+            options_params.append(', '.join(
+                '%s=%s' % (
+                    option,
+                    psycopg2.extensions.adapt(value).getquoted().decode(),
+                ) for option, value in self.options.items()
+            ))
+            options_sql = ', %s'
         sql, params = super().as_sql(
-            compiler,
-            connection,
-            function=function,
-            template=template,
+            compiler, connection, function=function, template=template,
             options=options_sql,
         )
         return sql, params + options_params
@@ -333,33 +288,15 @@ class TrigramBase(Func):
     output_field = FloatField()
 
     def __init__(self, expression, string, **extra):
-        if not hasattr(string, "resolve_expression"):
+        if not hasattr(string, 'resolve_expression'):
             string = Value(string)
         super().__init__(expression, string, **extra)
 
 
-class TrigramWordBase(Func):
-    output_field = FloatField()
-
-    def __init__(self, string, expression, **extra):
-        if not hasattr(string, "resolve_expression"):
-            string = Value(string)
-        super().__init__(string, expression, **extra)
-
-
 class TrigramSimilarity(TrigramBase):
-    function = "SIMILARITY"
+    function = 'SIMILARITY'
 
 
 class TrigramDistance(TrigramBase):
-    function = ""
-    arg_joiner = " <-> "
-
-
-class TrigramWordDistance(TrigramWordBase):
-    function = ""
-    arg_joiner = " <<-> "
-
-
-class TrigramWordSimilarity(TrigramWordBase):
-    function = "WORD_SIMILARITY"
+    function = ''
+    arg_joiner = ' <-> '