codex 1.6.19__py3-none-any.whl → 1.7.0a0__py3-none-any.whl

codex/_vendor/haystack/inputs.py

@@ -1,169 +0,0 @@
-import re
-import warnings
-
-from django.utils.encoding import force_str
-
-
-class BaseInput:
-    """
-    The base input type. Doesn't do much. You want ``Raw`` instead.
-    """
-
-    input_type_name = "base"
-    post_process = True
-
-    def __init__(self, query_string, **kwargs):
-        self.query_string = query_string
-        self.kwargs = kwargs
-
-    def __repr__(self):
-        return "<%s '%s'>" % (self.__class__.__name__, self)
-
-    def __str__(self):
-        return force_str(self.query_string)
-
-    def prepare(self, query_obj):
-        return self.query_string
-
-
-class Raw(BaseInput):
-    """
-    An input type for passing a query directly to the backend.
-
-    Prone to not being very portable.
-    """
-
-    input_type_name = "raw"
-    post_process = False
-
-
-class PythonData(BaseInput):
-    """
-    Represents a bare Python non-string type.
-
-    Largely only for internal use.
-    """
-
-    input_type_name = "python_data"
-
-
-class Clean(BaseInput):
-    """
-    An input type for sanitizing user/untrusted input.
-    """
-
-    input_type_name = "clean"
-
-    def prepare(self, query_obj):
-        query_string = super().prepare(query_obj)
-        return query_obj.clean(query_string)
-
-
-class Exact(BaseInput):
-    """
-    An input type for making exact matches.
-    """
-
-    input_type_name = "exact"
-
-    def prepare(self, query_obj):
-        query_string = super().prepare(query_obj)
-
-        if self.kwargs.get("clean", False):
-            # We need to clean each part of the exact match.
-            exact_bits = [
-                Clean(bit).prepare(query_obj) for bit in query_string.split(" ") if bit
-            ]
-            query_string = " ".join(exact_bits)
-
-        return query_obj.build_exact_query(query_string)
-
-
-class Not(Clean):
-    """
-    An input type for negating a query.
-    """
-
-    input_type_name = "not"
-
-    def prepare(self, query_obj):
-        query_string = super().prepare(query_obj)
-        return query_obj.build_not_query(query_string)
-
-
-class AutoQuery(BaseInput):
-    """
-    A convenience class that handles common user queries.
-
-    In addition to cleaning all tokens, it handles double quote bits as
-    exact matches & terms with '-' in front as NOT queries.
-    """
-
-    input_type_name = "auto_query"
-    post_process = False
-    exact_match_re = re.compile(r'"(?P<phrase>.*?)"')
-
-    def prepare(self, query_obj):
-        query_string = super().prepare(query_obj)
-        exacts = self.exact_match_re.findall(query_string)
-        tokens = []
-        query_bits = []
-
-        for rough_token in self.exact_match_re.split(query_string):
-            if not rough_token:
-                continue
-            elif rough_token not in exacts:
-                # We have something that's not an exact match but may have more
-                # than on word in it.
-                tokens.extend(rough_token.split(" "))
-            else:
-                tokens.append(rough_token)
-
-        for token in tokens:
-            if not token:
-                continue
-            if token in exacts:
-                query_bits.append(Exact(token, clean=True).prepare(query_obj))
-            elif token.startswith("-") and len(token) > 1:
-                # This might break Xapian. Check on this.
-                query_bits.append(Not(token[1:]).prepare(query_obj))
-            else:
-                query_bits.append(Clean(token).prepare(query_obj))
-
-        return " ".join(query_bits)
-
-
-class AltParser(BaseInput):
-    """
-    If the engine supports it, this input type allows for submitting a query
-    that uses a different parser.
-    """
-
-    input_type_name = "alt_parser"
-    post_process = False
-    use_parens = False
-
-    def __init__(self, parser_name, query_string="", **kwargs):
-        self.parser_name = parser_name
-        self.query_string = query_string
-        self.kwargs = kwargs
-
-    def __repr__(self):
-        return "<%s '%s' '%s' '%s'>" % (
-            self.__class__.__name__,
-            self.parser_name,
-            self.query_string,
-            self.kwargs,
-        )
-
-    def prepare(self, query_obj):
-        if not hasattr(query_obj, "build_alt_parser_query"):
-            warnings.warn(
-                "Use of 'AltParser' input type is being ignored, as the '%s' backend doesn't support them."
-                % query_obj
-            )
-            return ""
-
-        return query_obj.build_alt_parser_query(
-            self.parser_name, self.query_string, **self.kwargs
-        )

codex/_vendor/haystack/management/commands/build_solr_schema.py

@@ -1,187 +0,0 @@
-import os
-
-import requests
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
-from django.core.management.base import BaseCommand, CommandError
-from django.template import loader
-
-from ....haystack import connections, constants
-from ....haystack.backends.solr_backend import SolrSearchBackend
-
-
-class Command(BaseCommand):
-    help = (  # noqa A003
-        "Generates a Solr schema that reflects the indexes using templates "
-        " under a django template dir 'search_configuration/*.xml'.  If none are "
-        " found, then provides defaults suitable to Solr 6.4"
-    )
-    schema_template_loc = "search_configuration/schema.xml"
-    solrcfg_template_loc = "search_configuration/solrconfig.xml"
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "-f",
-            "--filename",
-            help="Generate schema.xml directly into a file instead of stdout."
-            " Does not render solrconfig.xml",
-        )
-        parser.add_argument(
-            "-u",
-            "--using",
-            default=constants.DEFAULT_ALIAS,
-            help="Select a specific Solr connection to work with.",
-        )
-        parser.add_argument(
-            "-c",
-            "--configure-directory",
-            help="Attempt to configure a core located in the given directory"
-            " by removing the managed-schema.xml(renaming) if it "
-            " exists, configuring the core by rendering the schema.xml and "
-            " solrconfig.xml templates provided in the django project's "
-            " TEMPLATE_DIR/search_configuration directories",
-        )
-        parser.add_argument(
-            "-r",
-            "--reload-core",
-            help="If provided, attempts to automatically reload the solr core"
-            ' via the urls in the "URL" and "ADMIN_URL" settings of the SOLR'
-            " HAYSTACK_CONNECTIONS entry. Both MUST be set.",
-        )
-
-    def handle(self, **options):
-        """Generates a Solr schema that reflects the indexes."""
-        using = options.get("using")
-        if not isinstance(connections[using].get_backend(), SolrSearchBackend):
-            raise ImproperlyConfigured("'%s' isn't configured as a SolrEngine" % using)
-
-        schema_xml = self.build_template(
-            using=using, template_filename=Command.schema_template_loc
-        )
-        solrcfg_xml = self.build_template(
-            using=using, template_filename=Command.solrcfg_template_loc
-        )
-
-        filename = options.get("filename")
-        configure_directory = options.get("configure_directory")
-        reload_core = options.get("reload_core")
-
-        if filename:
-            self.stdout.write(
-                "Trying to write schema file located at {}".format(filename)
-            )
-            self.write_file(filename, schema_xml)
-
-            if reload_core:
-                connections[using].get_backend().reload()
-
-        if configure_directory:
-            self.stdout.write(
-                "Trying to configure core located at {}".format(configure_directory)
-            )
-
-            managed_schema_path = os.path.join(configure_directory, "managed-schema")
-
-            if os.path.isfile(managed_schema_path):
-                try:
-                    os.rename(managed_schema_path, "%s.old" % managed_schema_path)
-                except OSError as exc:
-                    raise CommandError(
-                        "Could not rename old managed schema file {}: {}".format(
-                            managed_schema_path, exc
-                        )
-                    )
-
-            schema_xml_path = os.path.join(configure_directory, "schema.xml")
-
-            try:
-                self.write_file(schema_xml_path, schema_xml)
-            except EnvironmentError as exc:
-                raise CommandError(
-                    "Could not configure {}: {}".format(schema_xml_path, exc)
-                )
-
-            solrconfig_path = os.path.join(configure_directory, "solrconfig.xml")
-
-            try:
-                self.write_file(solrconfig_path, solrcfg_xml)
-            except EnvironmentError as exc:
-                raise CommandError(
-                    "Could not write {}: {}".format(solrconfig_path, exc)
-                )
-
-        if reload_core:
-            core = settings.HAYSTACK_CONNECTIONS[using]["URL"].rsplit("/", 1)[-1]
-
-            if "ADMIN_URL" not in settings.HAYSTACK_CONNECTIONS[using]:
-                raise ImproperlyConfigured(
-                    "'ADMIN_URL' must be specified in the HAYSTACK_CONNECTIONS"
-                    " for the %s backend" % using
-                )
-            if "URL" not in settings.HAYSTACK_CONNECTIONS[using]:
-                raise ImproperlyConfigured(
-                    "'URL' must be specified in the HAYSTACK_CONNECTIONS"
-                    " for the %s backend" % using
-                )
-
-            try:
-                self.stdout.write("Trying to reload core named {}".format(core))
-                resp = requests.get(
-                    settings.HAYSTACK_CONNECTIONS[using]["ADMIN_URL"],
-                    params={"action": "RELOAD", "core": core},
-                )
-
-                if not resp.ok:
-                    raise CommandError(
-                        "Failed to reload core – Solr error: {}".format(resp)
-                    )
-            except CommandError:
-                raise
-            except Exception as exc:
-                raise CommandError("Failed to reload core {}: {}".format(core, exc))
-
-        if not filename and not configure_directory and not reload_core:
-            self.print_stdout(schema_xml)
-
-    def build_context(self, using):
-        backend = connections[using].get_backend()
-
-        if not isinstance(backend, SolrSearchBackend):
-            raise ImproperlyConfigured(
-                "'%s' isn't configured as a SolrEngine" % backend.connection_alias
-            )
-
-        content_field_name, fields = backend.build_schema(
-            connections[using].get_unified_index().all_searchfields()
-        )
-        return {
-            "content_field_name": content_field_name,
-            "fields": fields,
-            "default_operator": constants.DEFAULT_OPERATOR,
-            "ID": constants.ID,
-            "DJANGO_CT": constants.DJANGO_CT,
-            "DJANGO_ID": constants.DJANGO_ID,
-        }
-
-    def build_template(self, using, template_filename=schema_template_loc):
-        t = loader.get_template(template_filename)
-        c = self.build_context(using=using)
-        return t.render(c)
-
-    def print_stdout(self, schema_xml):
-        self.stderr.write("\n")
-        self.stderr.write("\n")
-        self.stderr.write("\n")
-        self.stderr.write(
-            "Save the following output to 'schema.xml' and place it in your Solr configuration directory.\n"
-        )
-        self.stderr.write(
-            "--------------------------------------------------------------------------------------------\n"
-        )
-        self.stderr.write("\n")
-        self.stdout.write(schema_xml)
-
-    def write_file(self, filename, schema_xml):
-        with open(filename, "w") as schema_file:
-            schema_file.write(schema_xml)
-            os.fsync(schema_file.fileno())

codex/_vendor/haystack/management/commands/clear_index.py

@@ -1,67 +0,0 @@
-from django.core.management.base import BaseCommand
-
-from ....haystack import connections
-
-
-class Command(BaseCommand):
-    help = "Clears out the search index completely."  # noqa A003
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--noinput",
-            action="store_false",
-            dest="interactive",
-            default=True,
-            help="If provided, no prompts will be issued to the user and the data will be wiped out.",
-        )
-        parser.add_argument(
-            "-u",
-            "--using",
-            action="append",
-            default=[],
-            help="Update only the named backend (can be used multiple times). "
-            "By default all backends will be updated.",
-        )
-        parser.add_argument(
-            "--nocommit",
-            action="store_false",
-            dest="commit",
-            default=True,
-            help="Will pass commit=False to the backend.",
-        )
-
-    def handle(self, **options):
-        """Clears out the search index completely."""
-        self.verbosity = int(options.get("verbosity", 1))
-        self.commit = options.get("commit", True)
-
-        using = options.get("using")
-        if not using:
-            using = connections.connections_info.keys()
-
-        if options.get("interactive", True):
-            self.stdout.write(
-                "WARNING: This will irreparably remove EVERYTHING from your search index in connection '%s'."
-                % "', '".join(using)
-            )
-            self.stdout.write(
-                "Your choices after this are to restore from backups or rebuild via the `rebuild_index` command."
-            )
-
-            yes_or_no = input("Are you sure you wish to continue? [y/N] ")
-
-            if not yes_or_no.lower().startswith("y"):
-                self.stdout.write("No action taken.")
-                return
-
-        if self.verbosity >= 1:
-            self.stdout.write(
-                "Removing all documents from your index because you said so."
-            )
-
-        for backend_name in using:
-            backend = connections[backend_name].get_backend()
-            backend.clear(commit=self.commit)
-
-        if self.verbosity >= 1:
-            self.stdout.write("All documents removed.")

codex/_vendor/haystack/management/commands/haystack_info.py

@@ -1,22 +0,0 @@
-from django.core.management.base import BaseCommand
-
-from ....haystack import connections
-from ....haystack.constants import DEFAULT_ALIAS
-
-
-class Command(BaseCommand):
-    help = "Provides feedback about the current Haystack setup."  # noqa A003
-
-    def handle(self, **options):
-        """Provides feedback about the current Haystack setup."""
-
-        unified_index = connections[DEFAULT_ALIAS].get_unified_index()
-        indexed = unified_index.get_indexed_models()
-        index_count = len(indexed)
-        self.stdout.write("Number of handled %s index(es)." % index_count)
-
-        for index in indexed:
-            self.stdout.write(
-                "  - Model: %s by Index: %s"
-                % (index.__name__, unified_index.get_indexes()[index])
-            )

codex/_vendor/haystack/management/commands/rebuild_index.py

@@ -1,65 +0,0 @@
-from django.core.management import call_command
-from django.core.management.base import BaseCommand
-
-from .update_index import DEFAULT_MAX_RETRIES
-
-
-class Command(BaseCommand):
-    help = "Completely rebuilds the search index by removing the old data and then updating."  # noqa A003
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--noinput",
-            action="store_false",
-            dest="interactive",
-            default=True,
-            help="If provided, no prompts will be issued to the user and the data will be wiped out.",
-        )
-        parser.add_argument(
-            "-u",
-            "--using",
-            action="append",
-            default=[],
-            help="Update only the named backend (can be used multiple times). "
-            "By default all backends will be updated.",
-        )
-        parser.add_argument(
-            "-k",
-            "--workers",
-            default=0,
-            type=int,
-            help="Allows for the use multiple workers to parallelize indexing. Requires multiprocessing.",
-        )
-        parser.add_argument(
-            "--nocommit",
-            action="store_false",
-            dest="commit",
-            default=True,
-            help="Will pass commit=False to the backend.",
-        )
-        parser.add_argument(
-            "-b",
-            "--batch-size",
-            dest="batchsize",
-            type=int,
-            help="Number of items to index at once.",
-        )
-        parser.add_argument(
-            "-t",
-            "--max-retries",
-            action="store",
-            dest="max_retries",
-            type=int,
-            default=DEFAULT_MAX_RETRIES,
-            help="Maximum number of attempts to write to the backend when an error occurs.",
-        )
-
-    def handle(self, **options):
-        clear_options = options.copy()
-        update_options = options.copy()
-        for key in ("batchsize", "workers", "max_retries"):
-            del clear_options[key]
-        for key in ("interactive",):
-            del update_options[key]
-        call_command("clear_index", **clear_options)
-        call_command("update_index", **update_options)