unicodedata-reader 1.3.2__tar.gz → 1.3.4__tar.gz

{unicodedata_reader-1.3.2 → unicodedata_reader-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unicodedata-reader
-Version: 1.3.2
+Version: 1.3.4
 Summary: 
 Home-page: https://github.com/kojiishi/unicodedata-reader
 License: Apache-2.0

{unicodedata_reader-1.3.2 → unicodedata_reader-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "unicodedata-reader"
-version = "1.3.2"
+version = "1.3.4"
 description = ""
 authors = ["Koji Ishii <kojii@chromium.org>"]
 readme = "README.md"

{unicodedata_reader-1.3.2 → unicodedata_reader-1.3.4}/unicodedata_reader/entry.py

@@ -10,14 +10,13 @@ from typing import Iterable
 from typing import List
 from typing import Optional
 from typing import Sequence
-from typing import Set
 from typing import Union
 from typing import Tuple
 
 _logger = logging.getLogger('UnicodeDataEntry')
 
 
-def u_hex(value):
+def u_hex(value: int) -> str:
     return f'{value:04X}'
 
 
@@ -80,16 +79,24 @@ class UnicodeDataEntry(object):
     def is_in_range(self, code: int) -> bool:
         return code >= self.min and code <= self.max
 
+    @staticmethod
+    def to_codes(entries: Iterable['UnicodeDataEntry']):
+        return itertools.chain(*(e.range() for e in entries))
+
     @property
     def count(self):
         self.assert_range()
         return self.max - self.min + 1
 
-    def range_as_str(self):
+    def range_as_str(self, converter: Callable[[int], str] = u_hex):
         self.assert_range()
+        min = converter(self.min)
         if self.min == self.max:
-            return u_hex(self.min)
-        return f'{u_hex(self.min)}..{u_hex(self.max)}'
+            return min
+        max = converter(self.max)
+        if min == max:
+            return min
+        return f'{min}..{max}'
 
     def to_str(self, separator: str = ';'):
         return separator.join((self.range_as_str(), str(self.value)))
@@ -269,24 +276,19 @@ class UnicodeDataEntries(object):
         """Returns an `Iterable` of `UnicodeDataEntry` for the given `pred`."""
         return (entry for entry in self if pred(entry.value))
 
-    def codes_for(self, pred: Callable[[Any], bool]) -> Iterable[int]:
-        """Returns an `Iterable` of Unicode code points for the given `pred`."""
-        return itertools.chain(*(e.range() for e in self.filter(pred)))
-
-    def add_to_set(self, pred: Callable[[Any], bool], set: Set[int]) -> None:
+    def add_to_set(self, pred: Callable[[Any], bool], set: set) -> None:
         """Add values `pred` returns `True` to `set[int]`."""
-        for code in self.codes_for(pred):
+        for code in UnicodeDataEntry.to_codes(self.filter(pred)):
             set.add(code)
 
-    def remove_from_set(self, pred: Callable[[Any], bool],
-                        set: Set[int]) -> None:
+    def remove_from_set(self, pred: Callable[[Any], bool], set: set) -> None:
         """Remove values `pred` returns `True` from `set[int]`."""
-        for code in self.codes_for(pred):
+        for code in UnicodeDataEntry.to_codes(self.filter(pred)):
             set.discard(code)
 
-    def to_set(self, pred: Callable[[Any], bool]) -> Set[int]:
+    def to_set(self, pred: Callable[[Any], bool]) -> set:
         """Returns a `set[int]` of values `pred` returns `True`."""
-        s = set()  # type: set[int]
+        s = set()
         self.add_to_set(pred, s)
         return s
 

{unicodedata_reader-1.3.2 → unicodedata_reader-1.3.4}/unicodedata_reader/reader.py

@@ -30,6 +30,22 @@ class UnicodeDataReader(object):
     ) -> None:
         self.url_template = url_template
 
+    class Context(object):
+        """This class changes `UnicodeDataReader.default` while in the context,
+        and restores when exit."""
+
+        def __init__(self, reader: 'UnicodeDataReader') -> None:
+            self.reader = reader
+
+        def __enter__(self):
+            self.saved_default = UnicodeDataReader.default
+            UnicodeDataReader.default = self.reader
+            return self.reader
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            UnicodeDataReader.default = self.saved_default
+            return None
+
     def bidi_brackets(self) -> UnicodeDataEntries:
         name = 'BidiBrackets'
         lines = self.read_lines(name)

{unicodedata_reader-1.3.2 → unicodedata_reader-1.3.4}/unicodedata_reader/set.py

@@ -1,7 +1,7 @@
 from typing import Any
 from typing import Callable
 from typing import Iterable
-from typing import Set
+from typing import Optional
 
 from unicodedata_reader.entry import *
 from unicodedata_reader.reader import *
@@ -11,9 +11,9 @@ class Set(object):
     """A simple wrapper of a `set` of Unicode code points."""
 
     def __init__(self,
-                 entries: UnicodeDataEntries = None,
-                 pred: Callable[[Any], bool] = None) -> None:
-        self.set = set()  # type: Set[int]
+                 entries: Optional[UnicodeDataEntries] = None,
+                 pred: Optional[Callable[[Any], bool]] = None) -> None:
+        self.set = set()
         if entries:
             self.add_entries(entries, pred)
 
@@ -46,25 +46,21 @@ class Set(object):
         entries.add_to_set(pred, self.set)
 
     @staticmethod
-    def east_asian_width(
-            value: str,
-            reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
+    def east_asian_width(value: str) -> 'Set':
+        reader = UnicodeDataReader.default
         return Set(reader.east_asian_width(), lambda v: v == value)
 
     @staticmethod
-    def general_category(
-            value: str,
-            reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
+    def general_category(value: str) -> 'Set':
+        reader = UnicodeDataReader.default
         return Set(reader.general_category(), lambda v: v.startswith(value))
 
     @staticmethod
-    def scripts(
-            value: str,
-            reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
+    def scripts(value: str) -> 'Set':
+        reader = UnicodeDataReader.default
         return Set(reader.scripts(), lambda v: v == value)
 
     @staticmethod
-    def script_extensions(
-            value: str,
-            reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
+    def script_extensions(value: str) -> 'Set':
+        reader = UnicodeDataReader.default
         return Set(reader.script_extensions(), lambda v: value in v)