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

codex/_vendor/haystack/utils/loading.py

@@ -1,374 +0,0 @@
-import copy
-import inspect
-import threading
-import warnings
-from collections import OrderedDict
-
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
-from django.utils.module_loading import module_has_submodule
-
-from ...haystack import constants
-from ...haystack.exceptions import NotHandled, SearchFieldError
-from ...haystack.utils import importlib
-from ...haystack.utils.app_loading import haystack_get_app_modules
-
-VENDOR_PREFIX = "codex._vendor."
-
-def import_class(path):
-    if path.startswith("haystack"):
-        path = VENDOR_PREFIX + path
-    path_bits = path.split(".")
-    # Cut off the class name at the end.
-    class_name = path_bits.pop()
-    module_path = ".".join(path_bits)
-    module_itself = importlib.import_module(module_path)
-
-    if not hasattr(module_itself, class_name):
-        raise ImportError(
-            "The Python module '%s' has no '%s' class." % (module_path, class_name)
-        )
-
-    return getattr(module_itself, class_name)
-
-
-# Load the search backend.
-def load_backend(full_backend_path):
-    """
-    Loads a backend for interacting with the search engine.
-
-    Requires a ``backend_path``. It should be a string resembling a Python
-    import path, pointing to a ``BaseEngine`` subclass. The built-in options
-    available include::
-
-      * haystack.backends.solr.SolrEngine
-      * haystack.backends.xapian.XapianEngine (third-party)
-      * haystack.backends.whoosh.WhooshEngine
-      * haystack.backends.simple.SimpleEngine
-
-    If you've implemented a custom backend, you can provide the path to
-    your backend & matching ``Engine`` class. For example::
-
-      ``myapp.search_backends.CustomSolrEngine``
-
-    """
-    path_bits = full_backend_path.split(".")
-
-    if len(path_bits) < 2:
-        raise ImproperlyConfigured(
-            "The provided backend '%s' is not a complete Python path to a BaseEngine subclass."
-            % full_backend_path
-        )
-
-    return import_class(full_backend_path)
-
-
-def load_router(full_router_path):
-    """
-    Loads a router for choosing which connection to use.
-
-    Requires a ``full_router_path``. It should be a string resembling a Python
-    import path, pointing to a ``BaseRouter`` subclass. The built-in options
-    available include::
-
-      * haystack.routers.DefaultRouter
-
-    If you've implemented a custom backend, you can provide the path to
-    your backend & matching ``Engine`` class. For example::
-
-      ``myapp.search_routers.MasterSlaveRouter``
-
-    """
-    path_bits = full_router_path.split(".")
-
-    if len(path_bits) < 2:
-        raise ImproperlyConfigured(
-            "The provided router '%s' is not a complete Python path to a BaseRouter subclass."
-            % full_router_path
-        )
-
-    return import_class(full_router_path)
-
-
-class ConnectionHandler:
-    def __init__(self, connections_info):
-        self.connections_info = connections_info
-        self.thread_local = threading.local()
-        self._index = None
-
-    def ensure_defaults(self, alias):
-        try:
-            conn = self.connections_info[alias]
-        except KeyError:
-            raise ImproperlyConfigured(
-                "The key '%s' isn't an available connection." % alias
-            )
-
-        if not conn.get("ENGINE"):
-            conn["ENGINE"] = "haystack.backends.simple_backend.SimpleEngine"
-
-    def __getitem__(self, key):
-        if not hasattr(self.thread_local, "connections"):
-            self.thread_local.connections = {}
-        elif key in self.thread_local.connections:
-            return self.thread_local.connections[key]
-
-        self.ensure_defaults(key)
-        self.thread_local.connections[key] = load_backend(
-            self.connections_info[key]["ENGINE"]
-        )(using=key)
-        return self.thread_local.connections[key]
-
-    def reload(self, key):
-        if not hasattr(self.thread_local, "connections"):
-            self.thread_local.connections = {}
-        try:
-            del self.thread_local.connections[key]
-        except KeyError:
-            pass
-
-        return self.__getitem__(key)
-
-    def all(self):  # noqa A003
-        return [self[alias] for alias in self.connections_info]
-
-
-class ConnectionRouter:
-    def __init__(self):
-        self._routers = None
-
-    @property
-    def routers(self):
-        if self._routers is None:
-            default_routers = ["haystack.routers.DefaultRouter"]
-            router_list = getattr(settings, "HAYSTACK_ROUTERS", default_routers)
-            # in case HAYSTACK_ROUTERS is empty, fallback to default routers
-            if not len(router_list):
-                router_list = default_routers
-
-            self._routers = []
-            for router_path in router_list:
-                router_class = load_router(router_path)
-                self._routers.append(router_class())
-        return self._routers
-
-    def _for_action(self, action, many, **hints):
-        conns = []
-
-        for router in self.routers:
-            if hasattr(router, action):
-                action_callable = getattr(router, action)
-                connection_to_use = action_callable(**hints)
-
-                if connection_to_use is not None:
-                    if isinstance(connection_to_use, str):
-                        conns.append(connection_to_use)
-                    else:
-                        conns.extend(connection_to_use)
-                    if not many:
-                        break
-
-        return conns
-
-    def for_write(self, **hints):
-        return self._for_action("for_write", True, **hints)
-
-    def for_read(self, **hints):
-        return self._for_action("for_read", False, **hints)[0]
-
-
-class UnifiedIndex:
-    # Used to collect all the indexes into a cohesive whole.
-    def __init__(self, excluded_indexes=None):
-        self._indexes = {}
-        self.fields = OrderedDict()
-        self._built = False
-        self.excluded_indexes = excluded_indexes or []
-        self.excluded_indexes_ids = {}
-        self.document_field = constants.DOCUMENT_FIELD
-        self._fieldnames = {}
-        self._facet_fieldnames = {}
-
-    @property
-    def indexes(self):
-        warnings.warn(
-            "'UnifiedIndex.indexes' was deprecated in Haystack v2.3.0. Please use UnifiedIndex.get_indexes()."
-        )
-        return self._indexes
-
-    def collect_indexes(self):
-        indexes = []
-
-        for app_mod in haystack_get_app_modules():
-            try:
-                search_index_module = importlib.import_module(
-                    "%s.search_indexes" % app_mod.__name__
-                )
-            except ImportError:
-                if module_has_submodule(app_mod, "search_indexes"):
-                    raise
-
-                continue
-
-            for item_name, item in inspect.getmembers(
-                search_index_module, inspect.isclass
-            ):
-                if getattr(item, "haystack_use_for_indexing", False) and getattr(
-                    item, "get_model", None
-                ):
-                    # We've got an index. Check if we should be ignoring it.
-                    class_path = "%s.search_indexes.%s" % (app_mod.__name__, item_name)
-
-                    if (
-                        class_path in self.excluded_indexes
-                        or self.excluded_indexes_ids.get(item_name) == id(item)
-                    ):
-                        self.excluded_indexes_ids[str(item_name)] = id(item)
-                        continue
-
-                    indexes.append(item())
-
-        return indexes
-
-    def reset(self):
-        self._indexes = {}
-        self.fields = OrderedDict()
-        self._built = False
-        self._fieldnames = {}
-        self._facet_fieldnames = {}
-
-    def build(self, indexes=None):
-        self.reset()
-
-        if indexes is None:
-            indexes = self.collect_indexes()
-
-        for index in indexes:
-            model = index.get_model()
-
-            if model in self._indexes:
-                raise ImproperlyConfigured(
-                    "Model '%s' has more than one 'SearchIndex`` handling it. "
-                    "Please exclude either '%s' or '%s' using the 'EXCLUDED_INDEXES' "
-                    "setting defined in 'settings.HAYSTACK_CONNECTIONS'."
-                    % (model, self._indexes[model], index)
-                )
-
-            self._indexes[model] = index
-            self.collect_fields(index)
-
-        self._built = True
-
-    def collect_fields(self, index):
-        for fieldname, field_object in index.fields.items():
-            if field_object.document is True:
-                if field_object.index_fieldname != self.document_field:
-                    raise SearchFieldError(
-                        "All 'SearchIndex' classes must use the same '%s' fieldname for the 'document=True' field. Offending index is '%s'."
-                        % (self.document_field, index)
-                    )
-
-            # Stow the index_fieldname so we don't have to get it the hard way again.
-            if (
-                fieldname in self._fieldnames
-                and field_object.index_fieldname != self._fieldnames[fieldname]
-            ):
-                # We've already seen this field in the list. Raise an exception if index_fieldname differs.
-                raise SearchFieldError(
-                    "All uses of the '%s' field need to use the same 'index_fieldname' attribute."
-                    % fieldname
-                )
-
-            self._fieldnames[fieldname] = field_object.index_fieldname
-
-            # Stow the facet_fieldname so we don't have to look that up either.
-            if hasattr(field_object, "facet_for"):
-                if field_object.facet_for:
-                    self._facet_fieldnames[field_object.facet_for] = fieldname
-                else:
-                    self._facet_fieldnames[field_object.instance_name] = fieldname
-
-            # Copy the field in so we've got a unified schema.
-            if field_object.index_fieldname not in self.fields:
-                self.fields[field_object.index_fieldname] = field_object
-                self.fields[field_object.index_fieldname] = copy.copy(field_object)
-            else:
-                # If the field types are different, we can mostly
-                # safely ignore this. The exception is ``MultiValueField``,
-                # in which case we'll use it instead, copying over the
-                # values.
-                if field_object.is_multivalued:
-                    old_field = self.fields[field_object.index_fieldname]
-                    self.fields[field_object.index_fieldname] = field_object
-                    self.fields[field_object.index_fieldname] = copy.copy(field_object)
-
-                    # Switch it so we don't have to dupe the remaining
-                    # checks.
-                    field_object = old_field
-
-                # We've already got this field in the list. Ensure that
-                # what we hand back is a superset of all options that
-                # affect the schema.
-                if field_object.indexed is True:
-                    self.fields[field_object.index_fieldname].indexed = True
-
-                if field_object.stored is True:
-                    self.fields[field_object.index_fieldname].stored = True
-
-                if field_object.faceted is True:
-                    self.fields[field_object.index_fieldname].faceted = True
-
-                if field_object.use_template is True:
-                    self.fields[field_object.index_fieldname].use_template = True
-
-                if field_object.null is True:
-                    self.fields[field_object.index_fieldname].null = True
-
-    def get_indexes(self):
-        if not self._built:
-            self.build()
-
-        return self._indexes
-
-    def get_indexed_models(self):
-        # Ensuring a list here since Python3 will give us an iterator
-        return list(self.get_indexes().keys())
-
-    def get_index_fieldname(self, field):
-        if not self._built:
-            self.build()
-
-        return self._fieldnames.get(field) or field
-
-    def get_index(self, model_klass):
-
-        indexes = self.get_indexes()
-
-        if model_klass not in indexes:
-            raise NotHandled("The model %s is not registered" % model_klass)
-
-        return indexes[model_klass]
-
-    def get_facet_fieldname(self, field):
-        if not self._built:
-            self.build()
-
-        for fieldname, field_object in self.fields.items():
-            if fieldname != field:
-                continue
-
-            if hasattr(field_object, "facet_for"):
-                if field_object.facet_for:
-                    return field_object.facet_for
-                else:
-                    return field_object.instance_name
-            else:
-                return self._facet_fieldnames.get(field) or field
-
-        return field
-
-    def all_searchfields(self):
-        if not self._built:
-            self.build()
-
-        return self.fields

codex/_vendor/haystack/utils/log.py

@@ -1,21 +0,0 @@
-import logging
-
-from django.conf import settings
-
-
-def getLogger(name):
-    real_logger = logging.getLogger(name)
-    return LoggingFacade(real_logger)
-
-
-class LoggingFacade:
-    def __init__(self, real_logger):
-        self.real_logger = real_logger
-
-    def noop(self, *args, **kwargs):
-        pass
-
-    def __getattr__(self, attr):
-        if getattr(settings, "HAYSTACK_LOGGING", True):
-            return getattr(self.real_logger, attr)
-        return self.noop

codex/_vendor/haystack/version.py

@@ -1,16 +0,0 @@
-# file generated by setuptools_scm
-# don't change, don't track in version control
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple, Union
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-else:
-    VERSION_TUPLE = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-
-__version__ = version = '3.2.1'
-__version_tuple__ = version_tuple = (3, 2, 1)

codex/_vendor/haystack/views.py

@@ -1,253 +0,0 @@
-from django.conf import settings
-from django.core.paginator import InvalidPage, Paginator
-from django.http import Http404
-from django.shortcuts import render
-
-from ..haystack.forms import FacetedSearchForm, ModelSearchForm
-from ..haystack.query import EmptySearchQuerySet
-
-RESULTS_PER_PAGE = getattr(settings, "HAYSTACK_SEARCH_RESULTS_PER_PAGE", 20)
-
-
-class SearchView:
-    template = "search/search.html"
-    extra_context = {}
-    query = ""
-    results = EmptySearchQuerySet()
-    request = None
-    form = None
-    results_per_page = RESULTS_PER_PAGE
-
-    def __init__(
-        self,
-        template=None,
-        load_all=True,
-        form_class=None,
-        searchqueryset=None,
-        results_per_page=None,
-    ):
-        self.load_all = load_all
-        self.form_class = form_class
-        self.searchqueryset = searchqueryset
-
-        if form_class is None:
-            self.form_class = ModelSearchForm
-
-        if results_per_page is not None:
-            self.results_per_page = results_per_page
-
-        if template:
-            self.template = template
-
-    def __call__(self, request):
-        """
-        Generates the actual response to the search.
-
-        Relies on internal, overridable methods to construct the response.
-        """
-        self.request = request
-
-        self.form = self.build_form()
-        self.query = self.get_query()
-        self.results = self.get_results()
-
-        return self.create_response()
-
-    def build_form(self, form_kwargs=None):
-        """
-        Instantiates the form the class should use to process the search query.
-        """
-        data = None
-        kwargs = {"load_all": self.load_all}
-        if form_kwargs:
-            kwargs.update(form_kwargs)
-
-        if len(self.request.GET):
-            data = self.request.GET
-
-        if self.searchqueryset is not None:
-            kwargs["searchqueryset"] = self.searchqueryset
-
-        return self.form_class(data, **kwargs)
-
-    def get_query(self):
-        """
-        Returns the query provided by the user.
-
-        Returns an empty string if the query is invalid.
-        """
-        if self.form.is_valid():
-            return self.form.cleaned_data["q"]
-
-        return ""
-
-    def get_results(self):
-        """
-        Fetches the results via the form.
-
-        Returns an empty list if there's no query to search with.
-        """
-        return self.form.search()
-
-    def build_page(self):
-        """
-        Paginates the results appropriately.
-
-        In case someone does not want to use Django's built-in pagination, it
-        should be a simple matter to override this method to do what they would
-        like.
-        """
-        try:
-            page_no = int(self.request.GET.get("page", 1))
-        except (TypeError, ValueError):
-            raise Http404("Not a valid number for page.")
-
-        if page_no < 1:
-            raise Http404("Pages should be 1 or greater.")
-
-        start_offset = (page_no - 1) * self.results_per_page
-        self.results[start_offset : start_offset + self.results_per_page]
-
-        paginator = Paginator(self.results, self.results_per_page)
-
-        try:
-            page = paginator.page(page_no)
-        except InvalidPage:
-            raise Http404("No such page!")
-
-        return (paginator, page)
-
-    def extra_context(self):
-        """
-        Allows the addition of more context variables as needed.
-
-        Must return a dictionary.
-        """
-        return {}
-
-    def get_context(self):
-        (paginator, page) = self.build_page()
-
-        context = {
-            "query": self.query,
-            "form": self.form,
-            "page": page,
-            "paginator": paginator,
-            "suggestion": None,
-        }
-
-        if (
-            hasattr(self.results, "query")
-            and self.results.query.backend.include_spelling
-        ):
-            context["suggestion"] = self.form.get_suggestion()
-
-        context.update(self.extra_context())
-
-        return context
-
-    def create_response(self):
-        """
-        Generates the actual HttpResponse to send back to the user.
-        """
-
-        context = self.get_context()
-
-        return render(self.request, self.template, context)
-
-
-def search_view_factory(view_class=SearchView, *args, **kwargs):
-    def search_view(request):
-        return view_class(*args, **kwargs)(request)
-
-    return search_view
-
-
-class FacetedSearchView(SearchView):
-    def __init__(self, *args, **kwargs):
-        # Needed to switch out the default form class.
-        if kwargs.get("form_class") is None:
-            kwargs["form_class"] = FacetedSearchForm
-
-        super().__init__(*args, **kwargs)
-
-    def build_form(self, form_kwargs=None):
-        if form_kwargs is None:
-            form_kwargs = {}
-
-        # This way the form can always receive a list containing zero or more
-        # facet expressions:
-        form_kwargs["selected_facets"] = self.request.GET.getlist("selected_facets")
-
-        return super().build_form(form_kwargs)
-
-    def extra_context(self):
-        extra = super().extra_context()
-        extra["request"] = self.request
-        extra["facets"] = self.results.facet_counts()
-        return extra
-
-
-def basic_search(
-    request,
-    template="search/search.html",
-    load_all=True,
-    form_class=ModelSearchForm,
-    searchqueryset=None,
-    extra_context=None,
-    results_per_page=None,
-):
-    """
-    A more traditional view that also demonstrate an alternative
-    way to use Haystack.
-
-    Useful as an example of for basing heavily custom views off of.
-
-    Also has the benefit of thread-safety, which the ``SearchView`` class may
-    not be.
-
-    Template:: ``search/search.html``
-    Context::
-        * form
-          An instance of the ``form_class``. (default: ``ModelSearchForm``)
-        * page
-          The current page of search results.
-        * paginator
-          A paginator instance for the results.
-        * query
-          The query received by the form.
-    """
-    query = ""
-    results = EmptySearchQuerySet()
-
-    if request.GET.get("q"):
-        form = form_class(request.GET, searchqueryset=searchqueryset, load_all=load_all)
-
-        if form.is_valid():
-            query = form.cleaned_data["q"]
-            results = form.search()
-    else:
-        form = form_class(searchqueryset=searchqueryset, load_all=load_all)
-
-    paginator = Paginator(results, results_per_page or RESULTS_PER_PAGE)
-
-    try:
-        page = paginator.page(int(request.GET.get("page", 1)))
-    except InvalidPage:
-        raise Http404("No such page of results!")
-
-    context = {
-        "form": form,
-        "page": page,
-        "paginator": paginator,
-        "query": query,
-        "suggestion": None,
-    }
-
-    if results.query.backend.include_spelling:
-        context["suggestion"] = form.get_suggestion()
-
-    if extra_context:
-        context.update(extra_context)
-
-    return render(request, template, context)