sentry-relay 0.8.27__zip → 0.8.28__zip

{sentry-relay-0.8.27 → sentry-relay-0.8.28}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 1.0
+Metadata-Version: 1.2
 Name: sentry-relay
-Version: 0.8.27
+Version: 0.8.28
 Summary: A python library to access sentry relay functionality.
 Home-page: UNKNOWN
 Author: Sentry
@@ -8,3 +8,4 @@ Author-email: hello@sentry.io
 License: BSL-1.1
 Description: UNKNOWN
 Platform: any
+Requires-Python: >=3.8

{sentry-relay-0.8.27 → sentry-relay-0.8.28}/sentry_relay/auth.py

@@ -1,7 +1,6 @@
 import json
 import uuid
 from sentry_relay._lowlevel import lib
-from sentry_relay._compat import PY2, text_type, implements_to_string
 from sentry_relay.utils import (
     RustObject,
     encode_str,
@@ -23,7 +22,6 @@ __all__ = [
 ]
 
 
-@implements_to_string
 class PublicKey(RustObject):
     __dealloc_func__ = lib.relay_publickey_free
 
@@ -49,7 +47,7 @@ class PublicKey(RustObject):
         return decode_str(self._methodcall(lib.relay_publickey_to_string), free=True)
 
     def __repr__(self):
-        return "<%s %r>" % (self.__class__.__name__, text_type(self))
+        return f"<{self.__class__.__name__} {str(self)!r}>"
 
 
 class SecretKey(RustObject):
@@ -66,16 +64,14 @@ class SecretKey(RustObject):
         return decode_str(self._methodcall(lib.relay_secretkey_sign, buf), free=True)
 
     def pack(self, data):
-        packed = json.dumps(data, separators=(",", ":"))
-        if not PY2:
-            packed = packed.encode("utf8")
+        packed = json.dumps(data, separators=(",", ":")).encode("utf8")
         return packed, self.sign(packed)
 
     def __str__(self):
         return decode_str(self._methodcall(lib.relay_secretkey_to_string), free=True)
 
     def __repr__(self):
-        return "<%s %r>" % (self.__class__.__name__, text_type(self))
+        return f"<{self.__class__.__name__} {str(self)!r}>"
 
 
 def generate_key_pair():

{sentry-relay-0.8.27 → sentry-relay-0.8.28}/sentry_relay/exceptions.py

@@ -1,4 +1,3 @@
-from sentry_relay._compat import implements_to_string
 from sentry_relay._lowlevel import lib
 
 
@@ -6,7 +5,6 @@ __all__ = ["RelayError"]
 exceptions_by_code = {}
 
 
-@implements_to_string
 class RelayError(Exception):
     code = None
 
@@ -18,7 +16,7 @@ class RelayError(Exception):
     def __str__(self):
         rv = self.message
         if self.rust_info is not None:
-            return "%s\n\n%s" % (rv, self.rust_info)
+            return f"{rv}\n\n{self.rust_info}"
         return rv
 
 

{sentry-relay-0.8.27 → sentry-relay-0.8.28}/sentry_relay/processing.py

@@ -1,6 +1,5 @@
 import json
 
-from sentry_relay._compat import string_types, iteritems, text_type
 from sentry_relay._lowlevel import lib, ffi
 from sentry_relay.utils import (
     encode_str,
@@ -65,10 +64,10 @@ def meta_with_chunks(data, meta):
         return meta
 
     result = {}
-    for key, item in iteritems(meta):
+    for key, item in meta.items():
         if key == "" and isinstance(item, dict):
             result[""] = item.copy()
-            if item.get("rem") and isinstance(data, string_types):
+            if item.get("rem") and isinstance(data, str):
                 result[""]["chunks"] = split_chunks(data, item["rem"])
         elif isinstance(data, dict):
             result[key] = meta_with_chunks(data.get(key), item)
@@ -88,14 +87,14 @@ class GeoIpLookup(RustObject):
 
     @classmethod
     def from_path(cls, path):
-        if isinstance(path, text_type):
+        if isinstance(path, str):
             path = path.encode("utf-8")
         rv = cls._from_objptr(rustcall(lib.relay_geoip_lookup_new, path))
         rv._path = path
         return rv
 
     def __repr__(self):
-        return "<GeoIpLookup %r>" % (self._path,)
+        return f"<GeoIpLookup {self._path!r}>"
 
 
 class StoreNormalizer(RustObject):
@@ -124,7 +123,7 @@ class StoreNormalizer(RustObject):
 
 def _serialize_event(event):
     raw_event = json.dumps(event, ensure_ascii=False)
-    if isinstance(raw_event, text_type):
+    if isinstance(raw_event, str):
         raw_event = raw_event.encode("utf-8", errors="replace")
     return raw_event
 
@@ -157,13 +156,13 @@ def is_glob_match(
     if allow_newline:
         flags |= lib.GLOB_FLAGS_ALLOW_NEWLINE
 
-    if isinstance(value, text_type):
+    if isinstance(value, str):
         value = value.encode("utf-8")
     return rustcall(lib.relay_is_glob_match, make_buf(value), encode_str(pat), flags)
 
 
 def is_codeowners_path_match(value, pattern):
-    if isinstance(value, text_type):
+    if isinstance(value, str):
         value = value.encode("utf-8")
     return rustcall(
         lib.relay_is_codeowners_path_match, make_buf(value), encode_str(pattern)
@@ -178,7 +177,7 @@ def validate_pii_config(config):
     as a string such that line numbers from the error message match with what
     the user typed in.
     """
-    assert isinstance(config, string_types)
+    assert isinstance(config, str)
     raw_error = rustcall(lib.relay_validate_pii_config, encode_str(config))
     error = decode_str(raw_error, free=True)
     if error:
@@ -232,7 +231,7 @@ def validate_sampling_condition(condition):
     Validate a dynamic rule condition. Used in dynamic sampling serializer.
     The parameter is a string containing the rule condition as JSON.
     """
-    assert isinstance(condition, string_types)
+    assert isinstance(condition, str)
     raw_error = rustcall(lib.relay_validate_sampling_condition, encode_str(condition))
     error = decode_str(raw_error, free=True)
     if error:
@@ -244,7 +243,7 @@ def validate_sampling_configuration(condition):
     Validate the whole sampling configuration. Used in dynamic sampling serializer.
     The parameter is a string containing the rules configuration as JSON.
     """
-    assert isinstance(condition, string_types)
+    assert isinstance(condition, str)
     raw_error = rustcall(
         lib.relay_validate_sampling_configuration, encode_str(condition)
     )
@@ -258,7 +257,7 @@ def validate_project_config(config, strict: bool):
 
     :param strict: Whether or not to check for unknown fields.
     """
-    assert isinstance(config, string_types)
+    assert isinstance(config, str)
     raw_error = rustcall(lib.relay_validate_project_config, encode_str(config), strict)
     error = decode_str(raw_error, free=True)
     if error:
@@ -269,10 +268,10 @@ def run_dynamic_sampling(sampling_config, root_sampling_config, dsc, event):
     """
     Runs dynamic sampling on an event and returns the merged rules together with the sample rate.
     """
-    assert isinstance(sampling_config, string_types)
-    assert isinstance(root_sampling_config, string_types)
-    assert isinstance(dsc, string_types)
-    assert isinstance(event, string_types)
+    assert isinstance(sampling_config, str)
+    assert isinstance(root_sampling_config, str)
+    assert isinstance(dsc, str)
+    assert isinstance(event, str)
 
     result_json = rustcall(
         lib.run_dynamic_sampling,

{sentry-relay-0.8.27 → sentry-relay-0.8.28}/sentry_relay/utils.py

@@ -2,7 +2,6 @@ import os
 import uuid
 import weakref
 from sentry_relay._lowlevel import ffi, lib
-from sentry_relay._compat import text_type, with_metaclass
 from sentry_relay.exceptions import exceptions_by_code, RelayError
 
 
@@ -35,7 +34,7 @@ def rustcall(func, *args):
     raise exc
 
 
-class RustObject(with_metaclass(_NoDict)):
+class RustObject(metaclass=_NoDict):
     __slots__ = ["_objptr", "_shared"]
     __dealloc_func__ = None
 
@@ -85,7 +84,7 @@ def decode_str(s, free=False):
 def encode_str(s, mutable=False):
     """Encodes a RelayStr"""
     rv = ffi.new("RelayStr *")
-    if isinstance(s, text_type):
+    if isinstance(s, str):
         s = s.encode("utf-8")
     if mutable:
         s = bytearray(s)

{sentry-relay-0.8.27 → sentry-relay-0.8.28}/setup.py

@@ -59,7 +59,7 @@ def build_native(spec):
         def delete_scratchpad():
             try:
                 shutil.rmtree(scratchpad)
-            except (IOError, OSError):
+            except OSError:
                 pass
 
         zf = zipfile.ZipFile("rustsrc.zip")
@@ -79,7 +79,7 @@ def build_native(spec):
     def find_dylib():
         cargo_target = os.environ.get("CARGO_BUILD_TARGET")
         if cargo_target:
-            in_path = "target/%s/%s" % (cargo_target, target)
+            in_path = f"target/{cargo_target}/{target}"
         else:
             in_path = "target/%s" % target
         return build.find_dylib("relay_cabi", in_path=in_path)
@@ -109,6 +109,7 @@ setup(
     include_package_data=True,
     zip_safe=False,
     platforms="any",
+    python_requires=">=3.8",
     install_requires=['enum34>=1.1.6,<1.2.0;python_version<"3.4"', "milksnake>=0.1.2"],
     setup_requires=["milksnake>=0.1.2"],
     milksnake_tasks=[build_native],

sentry-relay-0.8.28/version.txt

@@ -0,0 +1 @@
+0.8.28

sentry-relay-0.8.27/sentry_relay/_compat.py

@@ -1,36 +0,0 @@
-import sys
-
-
-PY2 = sys.version_info[0] == 2
-
-if PY2:
-    text_type = unicode  # noqa
-    int_types = (int, long)  # noqa
-    string_types = (str, unicode)  # noqa
-    range_type = xrange  # noqa
-    iteritems = lambda x: x.iteritems()
-    itervalues = lambda x: x.itervalues()
-    NUL = "\x00"
-
-    def implements_to_string(cls):
-        cls.__unicode__ = cls.__str__
-        cls.__str__ = lambda x: x.__unicode__().encode("utf-8")
-        return cls
-
-else:
-    text_type = str
-    int_types = (int,)
-    string_types = (str,)
-    range_type = range
-    iteritems = lambda x: x.items()
-    itervalues = lambda x: x.values()
-    NUL = 0
-    implements_to_string = lambda x: x
-
-
-def with_metaclass(meta, *bases):
-    class metaclass(type):
-        def __new__(cls, name, this_bases, d):
-            return meta(name, bases, d)
-
-    return type.__new__(metaclass, "temporary_class", (), {})

sentry-relay-0.8.27/version.txt

@@ -1 +0,0 @@
-0.8.27