File Manager

X7ROOT File Manager

Current Path: /opt/hc_python/lib/python3.12/site-packages/sentry_sdk/integrations/django

opt / hc_python / lib / python3.12 / site-packages / sentry_sdk / integrations / django /

?? ..
?? __init__.py(28.25 KB)
?? __pycache__
?? asgi.py(9.04 KB)
?? caching.py(9.37 KB)
?? middleware.py(6.4 KB)
?? signals_handlers.py(3.71 KB)
?? tasks.py(1.58 KB)
?? templates.py(6.6 KB)
?? transactions.py(4.68 KB)
?? views.py(4.46 KB)

Editing: transactions.py

"""
Copied from raven-python.

Despite being called "legacy" in some places this resolver is very much still
in use.
"""

import re
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from re import Pattern
    from typing import Dict, List, Optional, Tuple, Union

from django.urls.resolvers import URLPattern, URLResolver

from django import VERSION as DJANGO_VERSION

if DJANGO_VERSION >= (2, 0):
    from django.urls.resolvers import RoutePattern
else:
    RoutePattern = None

try:
    from django.urls import get_resolver
except ImportError:
    from django.core.urlresolvers import get_resolver

def get_regex(resolver_or_pattern: "Union[URLPattern, URLResolver]") -> "Pattern[str]":
    """Utility method for django's deprecated resolver.regex"""
    try:
        regex = resolver_or_pattern.regex
    except AttributeError:
        regex = resolver_or_pattern.pattern.regex
    return regex

class RavenResolver:
    _new_style_group_matcher = re.compile(
        r"<(?:([^>:]+):)?([^>]+)>"
    )  # https://github.com/django/django/blob/21382e2743d06efbf5623e7c9b6dccf2a325669b/django/urls/resolvers.py#L245-L247
    _optional_group_matcher = re.compile(r"$\?\:([^$]+)\)")
    _named_group_matcher = re.compile(r"$\?P<(\w+)>[^$]+\)+")
    _non_named_group_matcher = re.compile(r"$[^$]+\)")
    # [foo|bar|baz]
    _either_option_matcher = re.compile(r"\[([^\]]+)\|([^\]]+)\]")
    _camel_re = re.compile(r"([A-Z]+)([a-z])")

_cache: "Dict[URLPattern, str]" = {}

def _simplify(self, pattern: "Union[URLPattern, URLResolver]") -> str:
        r"""
        Clean up urlpattern regexes into something readable by humans:

From:
        > "^(?P<sport_slug>\w+)/athletes/(?P<athlete_slug>\w+)/$"

To:
        > "{sport_slug}/athletes/{athlete_slug}/"
        """
        # "new-style" path patterns can be parsed directly without turning them
        # into regexes first
        if (
            RoutePattern is not None
            and hasattr(pattern, "pattern")
            and isinstance(pattern.pattern, RoutePattern)
        ):
            return self._new_style_group_matcher.sub(
                lambda m: "{%s}" % m.group(2), str(pattern.pattern._route)
            )

result = get_regex(pattern).pattern

# remove optional params
        # TODO(dcramer): it'd be nice to change these into [%s] but it currently
        # conflicts with the other rules because we're doing regexp matches
        # rather than parsing tokens
        result = self._optional_group_matcher.sub(lambda m: "%s" % m.group(1), result)

# handle named groups first
        result = self._named_group_matcher.sub(lambda m: "{%s}" % m.group(1), result)

# handle non-named groups
        result = self._non_named_group_matcher.sub("{var}", result)

# handle optional params
        result = self._either_option_matcher.sub(lambda m: m.group(1), result)

# clean up any outstanding regex-y characters.
        result = (
            result.replace("^", "")
            .replace("$", "")
            .replace("?", "")
            .replace("\\A", "")
            .replace("\\Z", "")
            .replace("//", "/")
            .replace("\\", "")
        )

return result

def _resolve(
        self,
        resolver: "URLResolver",
        path: str,
        parents: "Optional[List[URLResolver]]" = None,
    ) -> "Optional[str]":
        match = get_regex(resolver).search(path)  # Django < 2.0

if not match:
            return None

if parents is None:
            parents = [resolver]
        elif resolver not in parents:
            parents = parents + [resolver]

new_path = path[match.end() :]
        for pattern in resolver.url_patterns:
            # this is an include()
            if not pattern.callback:
                match_ = self._resolve(pattern, new_path, parents)
                if match_:
                    return match_
                continue
            elif not get_regex(pattern).search(new_path):
                continue

try:
                return self._cache[pattern]
            except KeyError:
                pass

prefix = "".join(self._simplify(p) for p in parents)
            result = prefix + self._simplify(pattern)
            if not result.startswith("/"):
                result = "/" + result
            self._cache[pattern] = result
            return result

return None

def resolve(
        self,
        path: str,
        urlconf: "Union[None, Tuple[URLPattern, URLPattern, URLResolver], Tuple[URLPattern]]" = None,
    ) -> "Optional[str]":
        resolver = get_resolver(urlconf)
        match = self._resolve(resolver, path)
        return match

LEGACY_RESOLVER = RavenResolver()

X7ROOT File Manager

Editing: transactions.py

Upload File

Create Folder