more unicode

Author: mr-c

schema_salad/ref_resolver.py

@@ -106,32 +106,32 @@ def __init__(self, ctx, schemagraph=None, foreign_properties=None,
         self.rvocab = {}  # type: Dict[unicode, Any]
         self.idmap = None  # type: Dict[unicode, Any]
         self.mapPredicate = None  # type: Dict[unicode, unicode]
-        self.type_dsl_fields = None  # type: Set[str]
+        self.type_dsl_fields = None  # type: Set[unicode]
 
         self.add_context(ctx)
 
     def expand_url(self, url, base_url, scoped_id=False, vocab_term=False, scoped_ref=None):
-        # type: (Union[str, unicode], Union[str, unicode], bool, bool, int) -> Union[str, unicode]
-        if url in ("@id", "@type"):
+        # type: (unicode, unicode, bool, bool, int) -> unicode
+        if url in (u"@id", u"@type"):
             return url
 
         if vocab_term and url in self.vocab:
             return url
 
-        if self.vocab and ":" in url:
-            prefix = url.split(":")[0]
+        if self.vocab and u":" in url:
+            prefix = url.split(u":")[0]
             if prefix in self.vocab:
                 url = self.vocab[prefix] + url[len(prefix) + 1:]
 
         split = urlparse.urlsplit(url)
 
-        if split.scheme or url.startswith("$(") or url.startswith("${"):
+        if split.scheme or url.startswith(u"$(") or url.startswith(u"${"):
             pass
         elif scoped_id and not split.fragment:
             splitbase = urlparse.urlsplit(base_url)
-            frg = ""
+            frg = u""
             if splitbase.fragment:
-                frg = splitbase.fragment + "/" + split.path
+                frg = splitbase.fragment + u"/" + split.path
             else:
                 frg = split.path
             url = urlparse.urlunsplit(

typeshed/2.7/urlparse.pyi

@@ -1,6 +1,6 @@
 # Stubs for urlparse (Python 2)
 
-from typing import Dict, List, NamedTuple, Tuple, Sequence, Union, overload
+from typing import AnyStr, Dict, List, NamedTuple, Tuple, Sequence, Union, overload
 
 uses_relative = []  # type: List[str]
 uses_netloc = []  # type: List[str]
@@ -28,22 +28,47 @@ class SplitResult(NamedTuple('SplitResult', [
     ]), ResultMixin):
     def geturl(self) -> str: ...
 
+class SplitResultU(NamedTuple('SplitResultU', [
+        ('scheme', unicode),
+	('netloc', unicode),
+	('path', unicode),
+	('query', unicode),
+	('fragment', unicode)
+    ]), ResultMixin):
+    def geturl(self) -> unicode: ...
+
 class ParseResult(NamedTuple('ParseResult', [
         ('scheme', str), ('netloc', str), ('path', str), ('params', str), ('query', str),
         ('fragment', str)
     ]), ResultMixin):
     def geturl(self) -> str: ...
 
-def urlparse(url: Union[str, unicode], scheme: str = ..., allow_fragments: bool = ...) -> ParseResult: ...
-def urlsplit(url: Union[str, unicode], scheme: str = ..., allow_fragments: bool = ...) -> SplitResult: ...
+class ParseResultU(NamedTuple('ParseResultU', [
+        ('scheme', unicode),
+	('netloc', unicode),
+	('path', unicode),
+	('params', unicode),
+	('query', unicode),
+        ('fragment', unicode)
+    ]), ResultMixin):
+    def geturl(self) -> unicode: ...
+
+@overload
+def urlparse(url: str, scheme: str = ..., allow_fragments: bool = ...) -> ParseResult: ...
+@overload
+def urlparse(url: unicode, scheme: unicode = ..., allow_fragments: bool = ...) -> ParseResultU: ...
+@overload
+def urlsplit(url: str, scheme: str = ..., allow_fragments: bool = ...) -> SplitResult: ...
+@overload
+def urlsplit(url: unicode, scheme: unicode = ..., allow_fragments: bool = ...) -> SplitResultU: ...
 @overload
-def urlunparse(data: Tuple[str, str, str, str, str, str]) -> str: ...
+def urlunparse(data: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ...
 @overload
-def urlunparse(data: Sequence[str]) -> str: ...
+def urlunparse(data: Sequence[AnyStr]) -> AnyStr: ...
 @overload
-def urlunsplit(data: Tuple[str, str, str, str, str]) -> str: ...
+def urlunsplit(data: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ...
 @overload
-def urlunsplit(data: Sequence[str]) -> str: ...
+def urlunsplit(data: Sequence[AnyStr]) -> AnyStr: ...
 def urljoin(base: Union[str, unicode], url: Union[str, unicode], allow_fragments: bool = ...) -> str: ...
 def urldefrag(url: Union[str, unicode]) -> str: ...
 def unquote(s: str) -> str: ...