Replace Text with str

Those are synonyms in Python 3.

Author: bbc2

src/dotenv/main.py

@@ -6,8 +6,8 @@
 import tempfile
 from collections import OrderedDict
 from contextlib import contextmanager
-from typing import (IO, Dict, Iterable, Iterator, Mapping, Optional, Text,
-                    Tuple, Union)
+from typing import (IO, Dict, Iterable, Iterator, Mapping, Optional, Tuple,
+                    Union)
 
 from .parser import Binding, parse_stream
 from .variables import parse_variables
@@ -17,7 +17,7 @@
 if sys.version_info >= (3, 6):
     _PathLike = os.PathLike
 else:
-    _PathLike = Text
+    _PathLike = str
 
 
 def with_warn_for_invalid_lines(mappings: Iterator[Binding]) -> Iterator[Binding]:
@@ -33,21 +33,21 @@ def with_warn_for_invalid_lines(mappings: Iterator[Binding]) -> Iterator[Binding
 class DotEnv():
     def __init__(
         self,
-        dotenv_path: Union[Text, _PathLike, io.StringIO],
+        dotenv_path: Union[str, _PathLike, io.StringIO],
         verbose: bool = False,
-        encoding: Union[None, Text] = None,
+        encoding: Union[None, str] = None,
         interpolate: bool = True,
         override: bool = True,
     ) -> None:
-        self.dotenv_path = dotenv_path  # type: Union[Text,_PathLike, io.StringIO]
-        self._dict = None  # type: Optional[Dict[Text, Optional[Text]]]
+        self.dotenv_path = dotenv_path  # type: Union[str,_PathLike, io.StringIO]
+        self._dict = None  # type: Optional[Dict[str, Optional[str]]]
         self.verbose = verbose  # type: bool
-        self.encoding = encoding  # type: Union[None, Text]
+        self.encoding = encoding  # type: Union[None, str]
         self.interpolate = interpolate  # type: bool
         self.override = override  # type: bool
 
     @contextmanager
-    def _get_stream(self) -> Iterator[IO[Text]]:
+    def _get_stream(self) -> Iterator[IO[str]]:
         if isinstance(self.dotenv_path, io.StringIO):
             yield self.dotenv_path
         elif os.path.isfile(self.dotenv_path):
@@ -58,7 +58,7 @@ def _get_stream(self) -> Iterator[IO[Text]]:
                 logger.info("Python-dotenv could not find configuration file %s.", self.dotenv_path or '.env')
             yield io.StringIO('')
 
-    def dict(self) -> Dict[Text, Optional[Text]]:
+    def dict(self) -> Dict[str, Optional[str]]:
         """Return dotenv as dict"""
         if self._dict:
             return self._dict
@@ -72,7 +72,7 @@ def dict(self) -> Dict[Text, Optional[Text]]:
 
         return self._dict
 
-    def parse(self) -> Iterator[Tuple[Text, Optional[Text]]]:
+    def parse(self) -> Iterator[Tuple[str, Optional[str]]]:
         with self._get_stream() as stream:
             for mapping in with_warn_for_invalid_lines(parse_stream(stream)):
                 if mapping.key is not None:
@@ -90,7 +90,7 @@ def set_as_environment_variables(self) -> bool:
 
         return True
 
-    def get(self, key: Text) -> Optional[Text]:
+    def get(self, key: str) -> Optional[str]:
         """
         """
         data = self.dict()
@@ -104,7 +104,7 @@ def get(self, key: Text) -> Optional[Text]:
         return None
 
 
-def get_key(dotenv_path: Union[Text, _PathLike], key_to_get: Text) -> Optional[Text]:
+def get_key(dotenv_path: Union[str, _PathLike], key_to_get: str) -> Optional[str]:
     """
     Gets the value of a given key from the given .env
 
@@ -114,7 +114,7 @@ def get_key(dotenv_path: Union[Text, _PathLike], key_to_get: Text) -> Optional[T
 
 
 @contextmanager
-def rewrite(path: _PathLike) -> Iterator[Tuple[IO[Text], IO[Text]]]:
+def rewrite(path: _PathLike) -> Iterator[Tuple[IO[str], IO[str]]]:
     try:
         if not os.path.isfile(path):
             with io.open(path, "w+") as source:
@@ -132,11 +132,11 @@ def rewrite(path: _PathLike) -> Iterator[Tuple[IO[Text], IO[Text]]]:
 
 def set_key(
     dotenv_path: _PathLike,
-    key_to_set: Text,
-    value_to_set: Text,
-    quote_mode: Text = "always",
+    key_to_set: str,
+    value_to_set: str,
+    quote_mode: str = "always",
     export: bool = False,
-) -> Tuple[Optional[bool], Text, Text]:
+) -> Tuple[Optional[bool], str, str]:
     """
     Adds or Updates a key/value to the given .env
 
@@ -176,9 +176,9 @@ def set_key(
 
 def unset_key(
     dotenv_path: _PathLike,
-    key_to_unset: Text,
-    quote_mode: Text = "always",
-) -> Tuple[Optional[bool], Text]:
+    key_to_unset: str,
+    quote_mode: str = "always",
+) -> Tuple[Optional[bool], str]:
     """
     Removes a given key from the given .env
 
@@ -205,17 +205,17 @@ def unset_key(
 
 
 def resolve_variables(
-    values: Iterable[Tuple[Text, Optional[Text]]],
+    values: Iterable[Tuple[str, Optional[str]]],
     override: bool,
-) -> Mapping[Text, Optional[Text]]:
-    new_values = {}  # type: Dict[Text, Optional[Text]]
+) -> Mapping[str, Optional[str]]:
+    new_values = {}  # type: Dict[str, Optional[str]]
 
     for (name, value) in values:
         if value is None:
             result = None
         else:
             atoms = parse_variables(value)
-            env = {}  # type: Dict[Text, Optional[Text]]
+            env = {}  # type: Dict[str, Optional[str]]
             if override:
                 env.update(os.environ)  # type: ignore
                 env.update(new_values)
@@ -229,7 +229,7 @@ def resolve_variables(
     return new_values
 
 
-def _walk_to_root(path: Text) -> Iterator[Text]:
+def _walk_to_root(path: str) -> Iterator[str]:
     """
     Yield directories starting from the given directory up to the root
     """
@@ -248,10 +248,10 @@ def _walk_to_root(path: Text) -> Iterator[Text]:
 
 
 def find_dotenv(
-    filename: Text = '.env',
+    filename: str = '.env',
     raise_error_if_not_found: bool = False,
     usecwd: bool = False,
-) -> Text:
+) -> str:
     """
     Search in increasingly higher folders for the given file
 
@@ -289,12 +289,12 @@ def _is_interactive():
 
 
 def load_dotenv(
-    dotenv_path: Union[Text, _PathLike, None] = None,
+    dotenv_path: Union[str, _PathLike, None] = None,
     stream: Optional[io.StringIO] = None,
     verbose: bool = False,
     override: bool = False,
     interpolate: bool = True,
-    encoding: Optional[Text] = "utf-8",
+    encoding: Optional[str] = "utf-8",
 ) -> bool:
     """Parse a .env file and then load all the variables found as environment variables.
 
@@ -320,12 +320,12 @@ def load_dotenv(
 
 
 def dotenv_values(
-    dotenv_path: Union[Text, _PathLike, None] = None,
+    dotenv_path: Union[str, _PathLike, None] = None,
     stream: Optional[io.StringIO] = None,
     verbose: bool = False,
     interpolate: bool = True,
-    encoding: Optional[Text] = "utf-8",
-) -> Dict[Text, Optional[Text]]:
+    encoding: Optional[str] = "utf-8",
+) -> Dict[str, Optional[str]]:
     """
     Parse a .env file and return its content as a dict.
 

src/dotenv/parser.py

@@ -1,10 +1,10 @@
 import codecs
 import re
 from typing import (IO, Iterator, Match, NamedTuple, Optional,  # noqa:F401
-                    Pattern, Sequence, Text, Tuple)
+                    Pattern, Sequence, Tuple)
 
 
-def make_regex(string: str, extra_flags: int = 0) -> Pattern[Text]:
+def make_regex(string: str, extra_flags: int = 0) -> Pattern[str]:
     return re.compile(string, re.UNICODE | extra_flags)
 
 
@@ -28,16 +28,16 @@ def make_regex(string: str, extra_flags: int = 0) -> Pattern[Text]:
 Original = NamedTuple(
     "Original",
     [
-        ("string", Text),
+        ("string", str),
         ("line", int),
     ],
 )
 
 Binding = NamedTuple(
     "Binding",
     [
-        ("key", Optional[Text]),
-        ("value", Optional[Text]),
+        ("key", Optional[str]),
+        ("value", Optional[str]),
         ("original", Original),
         ("error", bool),
     ],
@@ -57,7 +57,7 @@ def set(self, other: "Position") -> None:
         self.chars = other.chars
         self.line = other.line
 
-    def advance(self, string: Text) -> None:
+    def advance(self, string: str) -> None:
         self.chars += len(string)
         self.line += len(re.findall(_newline, string))
 
@@ -67,7 +67,7 @@ class Error(Exception):
 
 
 class Reader:
-    def __init__(self, stream: IO[Text]) -> None:
+    def __init__(self, stream: IO[str]) -> None:
         self.string = stream.read()
         self.position = Position.start()
         self.mark = Position.start()
@@ -84,32 +84,32 @@ def get_marked(self) -> Original:
             line=self.mark.line,
         )
 
-    def peek(self, count: int) -> Text:
+    def peek(self, count: int) -> str:
         return self.string[self.position.chars:self.position.chars + count]
 
-    def read(self, count: int) -> Text:
+    def read(self, count: int) -> str:
         result = self.string[self.position.chars:self.position.chars + count]
         if len(result) < count:
             raise Error("read: End of string")
         self.position.advance(result)
         return result
 
-    def read_regex(self, regex: Pattern[Text]) -> Sequence[Text]:
+    def read_regex(self, regex: Pattern[str]) -> Sequence[str]:
         match = regex.match(self.string, self.position.chars)
         if match is None:
             raise Error("read_regex: Pattern not found")
         self.position.advance(self.string[match.start():match.end()])
         return match.groups()
 
 
-def decode_escapes(regex: Pattern[Text], string: Text) -> Text:
-    def decode_match(match: Match[Text]) -> Text:
+def decode_escapes(regex: Pattern[str], string: str) -> str:
+    def decode_match(match: Match[str]) -> str:
         return codecs.decode(match.group(0), 'unicode-escape')  # type: ignore
 
     return regex.sub(decode_match, string)
 
 
-def parse_key(reader: Reader) -> Optional[Text]:
+def parse_key(reader: Reader) -> Optional[str]:
     char = reader.peek(1)
     if char == "#":
         return None
@@ -120,12 +120,12 @@ def parse_key(reader: Reader) -> Optional[Text]:
     return key
 
 
-def parse_unquoted_value(reader: Reader) -> Text:
+def parse_unquoted_value(reader: Reader) -> str:
     (part,) = reader.read_regex(_unquoted_value)
     return re.sub(r"\s+#.*", "", part).rstrip()
 
 
-def parse_value(reader: Reader) -> Text:
+def parse_value(reader: Reader) -> str:
     char = reader.peek(1)
     if char == u"'":
         (value,) = reader.read_regex(_single_quoted_value)
@@ -155,7 +155,7 @@ def parse_binding(reader: Reader) -> Binding:
         reader.read_regex(_whitespace)
         if reader.peek(1) == "=":
             reader.read_regex(_equal_sign)
-            value = parse_value(reader)  # type: Optional[Text]
+            value = parse_value(reader)  # type: Optional[str]
         else:
             value = None
         reader.read_regex(_comment)
@@ -176,7 +176,7 @@ def parse_binding(reader: Reader) -> Binding:
         )
 
 
-def parse_stream(stream: IO[Text]) -> Iterator[Binding]:
+def parse_stream(stream: IO[str]) -> Iterator[Binding]:
     reader = Reader(stream)
     while reader.has_next():
         yield parse_binding(reader)

src/dotenv/variables.py

@@ -1,6 +1,6 @@
 import re
 from abc import ABCMeta
-from typing import Iterator, Mapping, Optional, Pattern, Text
+from typing import Iterator, Mapping, Optional, Pattern
 
 _posix_variable = re.compile(
     r"""
@@ -12,7 +12,7 @@
     \}
     """,
     re.VERBOSE,
-)  # type: Pattern[Text]
+)  # type: Pattern[str]
 
 
 class Atom():
@@ -24,12 +24,12 @@ def __ne__(self, other: object) -> bool:
             return NotImplemented
         return not result
 
-    def resolve(self, env: Mapping[Text, Optional[Text]]) -> Text:
+    def resolve(self, env: Mapping[str, Optional[str]]) -> str:
         raise NotImplementedError
 
 
 class Literal(Atom):
-    def __init__(self, value: Text) -> None:
+    def __init__(self, value: str) -> None:
         self.value = value
 
     def __repr__(self) -> str:
@@ -43,12 +43,12 @@ def __eq__(self, other: object) -> bool:
     def __hash__(self) -> int:
         return hash((self.__class__, self.value))
 
-    def resolve(self, env: Mapping[Text, Optional[Text]]) -> Text:
+    def resolve(self, env: Mapping[str, Optional[str]]) -> str:
         return self.value
 
 
 class Variable(Atom):
-    def __init__(self, name: Text, default: Optional[Text]) -> None:
+    def __init__(self, name: str, default: Optional[str]) -> None:
         self.name = name
         self.default = default
 
@@ -63,13 +63,13 @@ def __eq__(self, other: object) -> bool:
     def __hash__(self) -> int:
         return hash((self.__class__, self.name, self.default))
 
-    def resolve(self, env: Mapping[Text, Optional[Text]]) -> Text:
+    def resolve(self, env: Mapping[str, Optional[str]]) -> str:
         default = self.default if self.default is not None else ""
         result = env.get(self.name, default)
         return result if result is not None else ""
 
 
-def parse_variables(value: Text) -> Iterator[Atom]:
+def parse_variables(value: str) -> Iterator[Atom]:
     cursor = 0
 
     for match in _posix_variable.finditer(value):