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

codex/_vendor/haystack/templatetags/highlight.py

@@ -1,131 +0,0 @@
-from django import template
-from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured
-
-from ...haystack.utils import importlib
-
-register = template.Library()
-
-
-class HighlightNode(template.Node):
-    def __init__(
-        self, text_block, query, html_tag=None, css_class=None, max_length=None
-    ):
-        self.text_block = template.Variable(text_block)
-        self.query = template.Variable(query)
-        self.html_tag = html_tag
-        self.css_class = css_class
-        self.max_length = max_length
-
-        if html_tag is not None:
-            self.html_tag = template.Variable(html_tag)
-
-        if css_class is not None:
-            self.css_class = template.Variable(css_class)
-
-        if max_length is not None:
-            self.max_length = template.Variable(max_length)
-
-    def render(self, context):
-        text_block = self.text_block.resolve(context)
-        query = self.query.resolve(context)
-        kwargs = {}
-
-        if self.html_tag is not None:
-            kwargs["html_tag"] = self.html_tag.resolve(context)
-
-        if self.css_class is not None:
-            kwargs["css_class"] = self.css_class.resolve(context)
-
-        if self.max_length is not None:
-            kwargs["max_length"] = self.max_length.resolve(context)
-
-        # Handle a user-defined highlighting function.
-        if (
-            hasattr(settings, "HAYSTACK_CUSTOM_HIGHLIGHTER")
-            and settings.HAYSTACK_CUSTOM_HIGHLIGHTER
-        ):
-            # Do the import dance.
-            try:
-                path_bits = settings.HAYSTACK_CUSTOM_HIGHLIGHTER.split(".")
-                highlighter_path, highlighter_classname = (
-                    ".".join(path_bits[:-1]),
-                    path_bits[-1],
-                )
-                highlighter_module = importlib.import_module(highlighter_path)
-                highlighter_class = getattr(highlighter_module, highlighter_classname)
-            except (ImportError, AttributeError) as e:
-                raise ImproperlyConfigured(
-                    "The highlighter '%s' could not be imported: %s"
-                    % (settings.HAYSTACK_CUSTOM_HIGHLIGHTER, e)
-                )
-        else:
-            from ...haystack.utils.highlighting import Highlighter
-
-            highlighter_class = Highlighter
-
-        highlighter = highlighter_class(query, **kwargs)
-        highlighted_text = highlighter.highlight(text_block)
-        return highlighted_text
-
-
-@register.tag
-def highlight(parser, token):
-    """
-    Takes a block of text and highlights words from a provided query within that
-    block of text. Optionally accepts arguments to provide the HTML tag to wrap
-    highlighted word in, a CSS class to use with the tag and a maximum length of
-    the blurb in characters.
-
-    Syntax::
-
-        {% highlight <text_block> with <query> [css_class "class_name"] [html_tag "span"] [max_length 200] %}
-
-    Example::
-
-        # Highlight summary with default behavior.
-        {% highlight result.summary with request.query %}
-
-        # Highlight summary but wrap highlighted words with a div and the
-        # following CSS class.
-        {% highlight result.summary with request.query html_tag "div" css_class "highlight_me_please" %}
-
-        # Highlight summary but only show 40 characters.
-        {% highlight result.summary with request.query max_length 40 %}
-    """
-    bits = token.split_contents()
-    tag_name = bits[0]
-
-    if not len(bits) % 2 == 0:
-        raise template.TemplateSyntaxError(
-            "'%s' tag requires valid pairings arguments." % tag_name
-        )
-
-    text_block = bits[1]
-
-    if len(bits) < 4:
-        raise template.TemplateSyntaxError(
-            "'%s' tag requires an object and a query provided by 'with'." % tag_name
-        )
-
-    if bits[2] != "with":
-        raise template.TemplateSyntaxError(
-            "'%s' tag's second argument should be 'with'." % tag_name
-        )
-
-    query = bits[3]
-
-    arg_bits = iter(bits[4:])
-    kwargs = {}
-
-    for bit in arg_bits:
-        if bit == "css_class":
-            kwargs["css_class"] = next(arg_bits)
-
-        if bit == "html_tag":
-            kwargs["html_tag"] = next(arg_bits)
-
-        if bit == "max_length":
-            kwargs["max_length"] = next(arg_bits)
-
-    return HighlightNode(text_block, query, **kwargs)

codex/_vendor/haystack/templatetags/more_like_this.py

@@ -1,119 +0,0 @@
-import logging
-
-from django import template
-
-from ...haystack.query import SearchQuerySet
-from ...haystack.utils.app_loading import haystack_get_model
-
-register = template.Library()
-
-
-class MoreLikeThisNode(template.Node):
-    def __init__(self, model, varname, for_types=None, limit=None):
-        self.model = template.Variable(model)
-        self.varname = varname
-        self.for_types = for_types
-        self.limit = limit
-
-        if self.limit is not None:
-            self.limit = int(self.limit)
-
-    def render(self, context):
-        try:
-            model_instance = self.model.resolve(context)
-            sqs = SearchQuerySet()
-
-            if self.for_types is not None:
-                intermediate = template.Variable(self.for_types)
-                for_types = intermediate.resolve(context).split(",")
-                search_models = []
-
-                for model in for_types:
-                    model_class = haystack_get_model(*model.split("."))
-
-                    if model_class:
-                        search_models.append(model_class)
-
-                sqs = sqs.models(*search_models)
-
-            sqs = sqs.more_like_this(model_instance)
-
-            if self.limit is not None:
-                sqs = sqs[: self.limit]
-
-            context[self.varname] = sqs
-        except Exception as exc:
-            logging.warning(
-                "Unhandled exception rendering %r: %s", self, exc, exc_info=True
-            )
-
-        return ""
-
-
-@register.tag
-def more_like_this(parser, token):
-    """
-    Fetches similar items from the search index to find content that is similar
-    to the provided model's content.
-
-    Syntax::
-
-        {% more_like_this model_instance as varname [for app_label.model_name,app_label.model_name,...] [limit n] %}
-
-    Example::
-
-        # Pull a full SearchQuerySet (lazy loaded) of similar content.
-        {% more_like_this entry as related_content %}
-
-        # Pull just the top 5 similar pieces of content.
-        {% more_like_this entry as related_content limit 5  %}
-
-        # Pull just the top 5 similar entries or comments.
-        {% more_like_this entry as related_content for "blog.entry,comments.comment" limit 5  %}
-    """
-    bits = token.split_contents()
-
-    if not len(bits) in (4, 6, 8):
-        raise template.TemplateSyntaxError(
-            "'%s' tag requires either 3, 5 or 7 arguments." % bits[0]
-        )
-
-    model = bits[1]
-
-    if bits[2] != "as":
-        raise template.TemplateSyntaxError(
-            "'%s' tag's second argument should be 'as'." % bits[0]
-        )
-
-    varname = bits[3]
-    limit = None
-    for_types = None
-
-    if len(bits) == 6:
-        if bits[4] != "limit" and bits[4] != "for":
-            raise template.TemplateSyntaxError(
-                "'%s' tag's fourth argument should be either 'limit' or 'for'."
-                % bits[0]
-            )
-
-        if bits[4] == "limit":
-            limit = bits[5]
-        else:
-            for_types = bits[5]
-
-    if len(bits) == 8:
-        if bits[4] != "for":
-            raise template.TemplateSyntaxError(
-                "'%s' tag's fourth argument should be 'for'." % bits[0]
-            )
-
-        for_types = bits[5]
-
-        if bits[6] != "limit":
-            raise template.TemplateSyntaxError(
-                "'%s' tag's sixth argument should be 'limit'." % bits[0]
-            )
-
-        limit = bits[7]
-
-    return MoreLikeThisNode(model, varname, for_types, limit)

codex/_vendor/haystack/urls.py

@@ -1,5 +0,0 @@
-from django.urls import path
-
-from ..haystack.views import SearchView
-
-urlpatterns = [path("", SearchView(), name="haystack_search")]

codex/_vendor/haystack/utils/__init__.py

@@ -1,84 +0,0 @@
-import importlib
-import re
-
-from django.conf import settings
-
-from ...haystack.constants import DJANGO_CT, DJANGO_ID, ID
-from ...haystack.utils.highlighting import Highlighter  # noqa=F401
-
-IDENTIFIER_REGEX = re.compile(r"^[\w\d_]+\.[\w\d_]+\.[\w\d-]+$")
-
-
-def default_get_identifier(obj_or_string):
-    """
-    Get an unique identifier for the object or a string representing the
-    object.
-
-    If not overridden, uses <app_label>.<object_name>.<pk>.
-    """
-    if isinstance(obj_or_string, str):
-        if not IDENTIFIER_REGEX.match(obj_or_string):
-            raise AttributeError(
-                "Provided string '%s' is not a valid identifier." % obj_or_string
-            )
-
-        return obj_or_string
-
-    return "%s.%s" % (get_model_ct(obj_or_string), obj_or_string._get_pk_val())
-
-
-def _lookup_identifier_method():
-    """
-    If the user has set HAYSTACK_IDENTIFIER_METHOD, import it and return the method uncalled.
-    If HAYSTACK_IDENTIFIER_METHOD is not defined, return haystack.utils.default_get_identifier.
-
-    This always runs at module import time.  We keep the code in a function
-    so that it can be called from unit tests, in order to simulate the re-loading
-    of this module.
-    """
-    if not hasattr(settings, "HAYSTACK_IDENTIFIER_METHOD"):
-        return default_get_identifier
-
-    module_path, method_name = settings.HAYSTACK_IDENTIFIER_METHOD.rsplit(".", 1)
-
-    try:
-        module = importlib.import_module(module_path)
-    except ImportError:
-        raise ImportError(
-            "Unable to import module '%s' provided for HAYSTACK_IDENTIFIER_METHOD."
-            % module_path
-        )
-
-    identifier_method = getattr(module, method_name, None)
-
-    if not identifier_method:
-        raise AttributeError(
-            "Provided method '%s' for HAYSTACK_IDENTIFIER_METHOD does not exist in '%s'."
-            % (method_name, module_path)
-        )
-
-    return identifier_method
-
-
-get_identifier = _lookup_identifier_method()
-
-
-def get_model_ct_tuple(model):
-    # Deferred models should be identified as if they were the underlying model.
-    model_name = (
-        model._meta.concrete_model._meta.model_name
-        if hasattr(model, "_deferred") and model._deferred
-        else model._meta.model_name
-    )
-    return (model._meta.app_label, model_name)
-
-
-def get_model_ct(model):
-    return "%s.%s" % get_model_ct_tuple(model)
-
-
-def get_facet_field_name(fieldname):
-    if fieldname in [ID, DJANGO_ID, DJANGO_CT]:
-        return fieldname
-
-    return "%s_exact" % fieldname

codex/_vendor/haystack/utils/app_loading.py

@@ -1,34 +0,0 @@
-from django.apps import apps
-from django.core.exceptions import ImproperlyConfigured
-
-__all__ = ["haystack_get_models", "haystack_load_apps"]
-
-APP = "app"
-MODEL = "model"
-
-
-def haystack_get_app_modules():
-    """Return the Python module for each installed app"""
-    return [i.module for i in apps.get_app_configs()]
-
-
-def haystack_load_apps():
-    """Return a list of app labels for all installed applications which have models"""
-    return [i.label for i in apps.get_app_configs() if i.models_module is not None]
-
-
-def haystack_get_models(label):
-    try:
-        app_mod = apps.get_app_config(label)
-        return app_mod.get_models()
-    except LookupError:
-        if "." not in label:
-            raise ImproperlyConfigured("Unknown application label {}".format(label))
-        app_label, model_name = label.rsplit(".", 1)
-        return [apps.get_model(app_label, model_name)]
-    except ImproperlyConfigured:
-        pass
-
-
-def haystack_get_model(app_label, model_name):
-    return apps.get_model(app_label, model_name)

codex/_vendor/haystack/utils/geo.py

@@ -1,71 +0,0 @@
-from ...haystack.constants import WGS_84_SRID
-from ...haystack.exceptions import SpatialError
-
-
-def ensure_geometry(geom):
-    """
-    Makes sure the parameter passed in looks like a GEOS ``GEOSGeometry``.
-    """
-    if not hasattr(geom, "geom_type"):
-        raise SpatialError("Point '%s' doesn't appear to be a GEOS geometry." % geom)
-
-    return geom
-
-
-def ensure_point(geom):
-    """
-    Makes sure the parameter passed in looks like a GEOS ``Point``.
-    """
-    ensure_geometry(geom)
-
-    if geom.geom_type != "Point":
-        raise SpatialError("Provided geometry '%s' is not a 'Point'." % geom)
-
-    return geom
-
-
-def ensure_wgs84(point):
-    """
-    Ensures the point passed in is a GEOS ``Point`` & returns that point's
-    data is in the WGS-84 spatial reference.
-    """
-    ensure_point(point)
-    # Clone it so we don't alter the original, in case they're using it for
-    # something else.
-    new_point = point.clone()
-
-    if not new_point.srid:
-        # It has no spatial reference id. Assume WGS-84.
-        new_point.srid = WGS_84_SRID
-    elif new_point.srid != WGS_84_SRID:
-        # Transform it to get to the right system.
-        new_point.transform(WGS_84_SRID)
-
-    return new_point
-
-
-def ensure_distance(dist):
-    """
-    Makes sure the parameter passed in is a 'Distance' object.
-    """
-    try:
-        # Since we mostly only care about the ``.km`` attribute, make sure
-        # it's there.
-        dist.km
-    except AttributeError:
-        raise SpatialError("'%s' does not appear to be a 'Distance' object." % dist)
-
-    return dist
-
-
-def generate_bounding_box(bottom_left, top_right):
-    """
-    Takes two opposite corners of a bounding box (order matters!) & generates
-    a two-tuple of the correct coordinates for the bounding box.
-
-    The two-tuple is in the form ``((min_lat, min_lng), (max_lat, max_lng))``.
-    """
-    west, lat_1 = bottom_left.coords
-    east, lat_2 = top_right.coords
-    min_lat, max_lat = min(lat_1, lat_2), max(lat_1, lat_2)
-    return ((min_lat, west), (max_lat, east))

codex/_vendor/haystack/utils/highlighting.py

@@ -1,165 +0,0 @@
-from django.utils.html import strip_tags
-
-
-class Highlighter:
-    css_class = "highlighted"
-    html_tag = "span"
-    max_length = 200
-    text_block = ""
-
-    def __init__(self, query, **kwargs):
-        self.query = query
-
-        if "max_length" in kwargs:
-            self.max_length = int(kwargs["max_length"])
-
-        if "html_tag" in kwargs:
-            self.html_tag = kwargs["html_tag"]
-
-        if "css_class" in kwargs:
-            self.css_class = kwargs["css_class"]
-
-        self.query_words = {
-            word.lower() for word in self.query.split() if not word.startswith("-")
-        }
-
-    def highlight(self, text_block):
-        self.text_block = strip_tags(text_block)
-        highlight_locations = self.find_highlightable_words()
-        start_offset, end_offset = self.find_window(highlight_locations)
-        return self.render_html(highlight_locations, start_offset, end_offset)
-
-    def find_highlightable_words(self):
-        # Use a set so we only do this once per unique word.
-        word_positions = {}
-
-        # Pre-compute the length.
-        end_offset = len(self.text_block)
-        lower_text_block = self.text_block.lower()
-
-        for word in self.query_words:
-            if word not in word_positions:
-                word_positions[word] = []
-
-            start_offset = 0
-
-            while start_offset < end_offset:
-                next_offset = lower_text_block.find(word, start_offset, end_offset)
-
-                # If we get a -1 out of find, it wasn't found. Bomb out and
-                # start the next word.
-                if next_offset == -1:
-                    break
-
-                word_positions[word].append(next_offset)
-                start_offset = next_offset + len(word)
-
-        return word_positions
-
-    def find_window(self, highlight_locations):
-        best_start = 0
-        best_end = self.max_length
-
-        # First, make sure we have words.
-        if not len(highlight_locations):
-            return (best_start, best_end)
-
-        words_found = []
-
-        # Next, make sure we found any words at all.
-        for _, offset_list in highlight_locations.items():
-            if len(offset_list):
-                # Add all of the locations to the list.
-                words_found.extend(offset_list)
-
-        if not len(words_found):
-            return (best_start, best_end)
-
-        if len(words_found) == 1:
-            return (words_found[0], words_found[0] + self.max_length)
-
-        # Sort the list so it's in ascending order.
-        words_found = sorted(words_found)
-
-        # We now have a denormalized list of all positions were a word was
-        # found. We'll iterate through and find the densest window we can by
-        # counting the number of found offsets (-1 to fit in the window).
-        highest_density = 0
-
-        if words_found[:-1][0] > self.max_length:
-            best_start = words_found[:-1][0]
-            best_end = best_start + self.max_length
-
-        for count, start in enumerate(words_found[:-1]):
-            current_density = 1
-
-            for end in words_found[count + 1 :]:
-                if end - start < self.max_length:
-                    current_density += 1
-                else:
-                    current_density = 0
-
-                # Only replace if we have a bigger (not equal density) so we
-                # give deference to windows earlier in the document.
-                if current_density > highest_density:
-                    best_start = start
-                    best_end = start + self.max_length
-                    highest_density = current_density
-
-        return (best_start, best_end)
-
-    def render_html(self, highlight_locations=None, start_offset=None, end_offset=None):
-        # Start by chopping the block down to the proper window.
-        text = self.text_block[start_offset:end_offset]
-
-        # Invert highlight_locations to a location -> term list
-        term_list = []
-
-        for term, locations in highlight_locations.items():
-            term_list += [(loc - start_offset, term) for loc in locations]
-
-        loc_to_term = sorted(term_list)
-
-        # Prepare the highlight template
-        if self.css_class:
-            hl_start = '<%s class="%s">' % (self.html_tag, self.css_class)
-        else:
-            hl_start = "<%s>" % (self.html_tag)
-
-        hl_end = "</%s>" % self.html_tag
-
-        # Copy the part from the start of the string to the first match,
-        # and there replace the match with a highlighted version.
-        highlighted_chunk = ""
-        matched_so_far = 0
-        prev = 0
-        prev_str = ""
-
-        for cur, cur_str in loc_to_term:
-            # This can be in a different case than cur_str
-            actual_term = text[cur : cur + len(cur_str)]
-
-            # Handle incorrect highlight_locations by first checking for the term
-            if actual_term.lower() == cur_str:
-                if cur < prev + len(prev_str):
-                    continue
-
-                highlighted_chunk += (
-                    text[prev + len(prev_str) : cur] + hl_start + actual_term + hl_end
-                )
-                prev = cur
-                prev_str = cur_str
-
-                # Keep track of how far we've copied so far, for the last step
-                matched_so_far = cur + len(actual_term)
-
-        # Don't forget the chunk after the last term
-        highlighted_chunk += text[matched_so_far:]
-
-        if start_offset > 0:
-            highlighted_chunk = "...%s" % highlighted_chunk
-
-        if end_offset < len(self.text_block):
-            highlighted_chunk = "%s..." % highlighted_chunk
-
-        return highlighted_chunk