unicodedata-reader 1.3.3__tar.gz → 1.3.5__tar.gz

{unicodedata_reader-1.3.3 → unicodedata_reader-1.3.5}/PKG-INFO

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

{unicodedata_reader-1.3.3 → unicodedata_reader-1.3.5}/pyproject.toml

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

{unicodedata_reader-1.3.3 → unicodedata_reader-1.3.5}/unicodedata_reader/entry.py

@@ -16,7 +16,7 @@ from typing import Tuple
 _logger = logging.getLogger('UnicodeDataEntry')
 
 
-def u_hex(value):
+def u_hex(value: int) -> str:
     return f'{value:04X}'
 
 
@@ -79,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)))
@@ -268,18 +276,14 @@ 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) -> 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) -> 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:

unicodedata_reader-1.3.5/unicodedata_reader/set.py

@@ -0,0 +1,84 @@
+from typing import Any
+from typing import Callable
+from typing import Iterable
+from typing import Optional
+
+from unicodedata_reader.entry import *
+from unicodedata_reader.reader import *
+
+
+class Set(object):
+    """A simple wrapper of a `set` of Unicode code points."""
+
+    def __init__(self,
+                 entries: Optional[UnicodeDataEntries] = None,
+                 predicate: Optional[Callable[[Any], bool]] = None) -> None:
+        self.set = set()
+        if entries:
+            entries.add_to_set(predicate, self.set)
+
+    @staticmethod
+    def east_asian_width(*values: str) -> 'Set':
+        entries = UnicodeDataReader.default.east_asian_width()
+        if len(values) == 1:
+            value = values[0]
+            return Set(entries, lambda v: v == value)
+        s = set(values)
+        return Set(entries, lambda v: v in s)
+
+    @staticmethod
+    def general_category(*values: str) -> 'Set':
+        entries = UnicodeDataReader.default.general_category()
+        if len(values) == 1:
+            value = values[0]
+            return Set(entries, lambda v: v.startswith(value))
+
+        def predicate(v: str) -> bool:
+            for value in values:
+                if v.startswith(value):
+                    return True
+            return False
+
+        return Set(entries, predicate)
+
+    @staticmethod
+    def scripts(*values: str) -> 'Set':
+        entries = UnicodeDataReader.default.scripts()
+        if len(values) == 1:
+            value = values[0]
+            return Set(entries, lambda v: v == value)
+        s = set(values)
+        return Set(entries, lambda v: v in s)
+
+    @staticmethod
+    def script_extensions(*values: str) -> 'Set':
+        entries = UnicodeDataReader.default.script_extensions()
+        if len(values) == 1:
+            value = values[0]
+            return Set(entries, lambda v: value in v)
+        s = set(values)
+        return Set(entries, lambda v: len(set(v) & s))
+
+    def __contains__(self, code_point: int) -> bool:
+        return code_point in self.set
+
+    def __iter__(self) -> Iterable[int]:
+        return self.set.__iter__()
+
+    def __isub__(self, other: 'Set') -> 'Set':
+        self.set -= other.set
+        return self
+
+    def __iand__(self, other: 'Set') -> 'Set':
+        self.set &= other.set
+        return self
+
+    def __ior__(self, other: 'Set') -> 'Set':
+        self.set |= other.set
+        return self
+
+    def add(self, code: int) -> None:
+        self.set.add(code)
+
+    def remove(self, code: int) -> None:
+        self.set.discard(code)

unicodedata_reader-1.3.3/unicodedata_reader/set.py

@@ -1,66 +0,0 @@
-from typing import Any
-from typing import Callable
-from typing import Iterable
-from typing import Optional
-
-from unicodedata_reader.entry import *
-from unicodedata_reader.reader import *
-
-
-class Set(object):
-    """A simple wrapper of a `set` of Unicode code points."""
-
-    def __init__(self,
-                 entries: Optional[UnicodeDataEntries] = None,
-                 pred: Optional[Callable[[Any], bool]] = None) -> None:
-        self.set = set()
-        if entries:
-            self.add_entries(entries, pred)
-
-    def __contains__(self, code_point: int) -> bool:
-        return code_point in self.set
-
-    def __iter__(self) -> Iterable[int]:
-        return self.set.__iter__()
-
-    def __isub__(self, other: 'Set') -> 'Set':
-        self.set -= other.set
-        return self
-
-    def __iand__(self, other: 'Set') -> 'Set':
-        self.set &= other.set
-        return self
-
-    def __ior__(self, other: 'Set') -> 'Set':
-        self.set |= other.set
-        return self
-
-    def add(self, code: int) -> None:
-        self.set.add(code)
-
-    def remove(self, code: int) -> None:
-        self.set.discard(code)
-
-    def add_entries(self, entries: UnicodeDataEntries, pred: Callable[[Any],
-                                                                      bool]):
-        entries.add_to_set(pred, self.set)
-
-    @staticmethod
-    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) -> 'Set':
-        reader = UnicodeDataReader.default
-        return Set(reader.general_category(), lambda v: v.startswith(value))
-
-    @staticmethod
-    def scripts(value: str) -> 'Set':
-        reader = UnicodeDataReader.default
-        return Set(reader.scripts(), lambda v: v == value)
-
-    @staticmethod
-    def script_extensions(value: str) -> 'Set':
-        reader = UnicodeDataReader.default
-        return Set(reader.script_extensions(), lambda v: value in v)