oci 2.138.0__py3-none-any.whl → 2.139.0__py3-none-any.whl

oci/_vendor/idna/__init__.py

@@ -1,7 +1,50 @@
 # coding: utf-8
 # Modified Work: Copyright (c) 2018, 2024, Oracle and/or its affiliates.  All rights reserved.
 # This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-# Copyright (c) 2013-2018, Kim Davies. All rights reserved.
+# Copyright (c) 2013-2024, Kim Davies and contributors. All rights reserved.
 
+from .core import (
+    IDNABidiError,
+    IDNAError,
+    InvalidCodepoint,
+    InvalidCodepointContext,
+    alabel,
+    check_bidi,
+    check_hyphen_ok,
+    check_initial_combiner,
+    check_label,
+    check_nfc,
+    decode,
+    encode,
+    ulabel,
+    uts46_remap,
+    valid_contextj,
+    valid_contexto,
+    valid_label_length,
+    valid_string_length,
+)
+from .intranges import intranges_contain
 from .package_data import __version__
-from .core import *
+
+__all__ = [
+    "__version__",
+    "IDNABidiError",
+    "IDNAError",
+    "InvalidCodepoint",
+    "InvalidCodepointContext",
+    "alabel",
+    "check_bidi",
+    "check_hyphen_ok",
+    "check_initial_combiner",
+    "check_label",
+    "check_nfc",
+    "decode",
+    "encode",
+    "intranges_contain",
+    "ulabel",
+    "uts46_remap",
+    "valid_contextj",
+    "valid_contexto",
+    "valid_label_length",
+    "valid_string_length",
+]

oci/_vendor/idna/codec.py

@@ -1,55 +1,56 @@
 # coding: utf-8
 # Modified Work: Copyright (c) 2018, 2024, Oracle and/or its affiliates.  All rights reserved.
 # This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-# Copyright (c) 2013-2018, Kim Davies. All rights reserved.
+# Copyright (c) 2013-2024, Kim Davies and contributors. All rights reserved.
 
-from .core import encode, decode, alabel, ulabel, IDNAError
 import codecs
 import re
+from typing import Any, Optional, Tuple
 
-_unicode_dots_re = re.compile(u'[\u002e\u3002\uff0e\uff61]')
+from .core import IDNAError, alabel, decode, encode, ulabel
 
-class Codec(codecs.Codec):
+_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
 
-    def encode(self, data, errors='strict'):
 
-        if errors != 'strict':
-            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+class Codec(codecs.Codec):
+    def encode(self, data: str, errors: str = "strict") -> Tuple[bytes, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
-            return "", 0
+            return b"", 0
 
         return encode(data), len(data)
 
-    def decode(self, data, errors='strict'):
-
-        if errors != 'strict':
-            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+    def decode(self, data: bytes, errors: str = "strict") -> Tuple[str, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
-            return u"", 0
+            return "", 0
 
         return decode(data), len(data)
 
+
 class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
-    def _buffer_encode(self, data, errors, final):
-        if errors != 'strict':
-            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+    def _buffer_encode(self, data: str, errors: str, final: bool) -> Tuple[bytes, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
-            return ("", 0)
+            return b"", 0
 
         labels = _unicode_dots_re.split(data)
-        trailing_dot = u''
+        trailing_dot = b""
         if labels:
             if not labels[-1]:
-                trailing_dot = '.'
+                trailing_dot = b"."
                 del labels[-1]
             elif not final:
                 # Keep potentially unfinished label until the next call
                 del labels[-1]
                 if labels:
-                    trailing_dot = '.'
+                    trailing_dot = b"."
 
         result = []
         size = 0
@@ -60,37 +61,33 @@ class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
             size += len(label)
 
         # Join with U+002E
-        result = ".".join(result) + trailing_dot
+        result_bytes = b".".join(result) + trailing_dot
         size += len(trailing_dot)
-        return (result, size)
+        return result_bytes, size
+
 
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-    def _buffer_decode(self, data, errors, final):
-        if errors != 'strict':
-            raise IDNAError("Unsupported error handling \"{0}\"".format(errors))
+    def _buffer_decode(self, data: Any, errors: str, final: bool) -> Tuple[str, int]:
+        if errors != "strict":
+            raise IDNAError('Unsupported error handling "{}"'.format(errors))
 
         if not data:
-            return (u"", 0)
-
-        # IDNA allows decoding to operate on Unicode strings, too.
-        if isinstance(data, unicode):
-            labels = _unicode_dots_re.split(data)
-        else:
-            # Must be ASCII string
-            data = str(data)
-            unicode(data, "ascii")
-            labels = data.split(".")
-
-        trailing_dot = u''
+            return ("", 0)
+
+        if not isinstance(data, str):
+            data = str(data, "ascii")
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = ""
         if labels:
             if not labels[-1]:
-                trailing_dot = u'.'
+                trailing_dot = "."
                 del labels[-1]
             elif not final:
                 # Keep potentially unfinished label until the next call
                 del labels[-1]
                 if labels:
-                    trailing_dot = u'.'
+                    trailing_dot = "."
 
         result = []
         size = 0
@@ -100,20 +97,24 @@ class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
                 size += 1
             size += len(label)
 
-        result = u".".join(result) + trailing_dot
+        result_str = ".".join(result) + trailing_dot
         size += len(trailing_dot)
-        return (result, size)
+        return (result_str, size)
 
 
 class StreamWriter(Codec, codecs.StreamWriter):
     pass
 
+
 class StreamReader(Codec, codecs.StreamReader):
     pass
 
-def getregentry():
+
+def search_function(name: str) -> Optional[codecs.CodecInfo]:
+    if name != "idna2008":
+        return None
     return codecs.CodecInfo(
-        name='idna',
+        name=name,
         encode=Codec().encode,
         decode=Codec().decode,
         incrementalencoder=IncrementalEncoder,
@@ -121,3 +122,6 @@ def getregentry():
         streamwriter=StreamWriter,
         streamreader=StreamReader,
     )
+
+
+codecs.register(search_function)

oci/_vendor/idna/compat.py

@@ -1,17 +1,20 @@
 # coding: utf-8
 # Modified Work: Copyright (c) 2018, 2024, Oracle and/or its affiliates.  All rights reserved.
 # This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
-# Copyright (c) 2013-2018, Kim Davies. All rights reserved.
+# Copyright (c) 2013-2024, Kim Davies and contributors. All rights reserved.
 
-from .core import *
-from .codec import *
+from typing import Any, Union
 
-def ToASCII(label):
+from .core import decode, encode
+
+
+def ToASCII(label: str) -> bytes:
     return encode(label)
 
-def ToUnicode(label):
+
+def ToUnicode(label: Union[bytes, bytearray]) -> str:
     return decode(label)
 
-def nameprep(s):
-    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")
 
+def nameprep(s: Any) -> None:
+    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")