unicodedata-reader 1.2.0__tar.gz → 1.3.1__tar.gz

{unicodedata_reader-1.2.0 → unicodedata_reader-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unicodedata-reader
-Version: 1.2.0
+Version: 1.3.1
 Summary: 
 Home-page: https://github.com/kojiishi/unicodedata-reader
 License: Apache-2.0
@@ -68,7 +68,7 @@ import unicodedata_reader
 
 reader = unicodedata_reader.UnicodeDataReader.default
 lb = reader.line_break()
-print(lb.value(0x41))
+print(lb[0x41])
 ```
 The example above prints `AL`,
 the [Line_Break property] value for U+0041.

{unicodedata_reader-1.2.0 → unicodedata_reader-1.3.1}/README.md

@@ -48,7 +48,7 @@ import unicodedata_reader
 
 reader = unicodedata_reader.UnicodeDataReader.default
 lb = reader.line_break()
-print(lb.value(0x41))
+print(lb[0x41])
 ```
 The example above prints `AL`,
 the [Line_Break property] value for U+0041.

{unicodedata_reader-1.2.0 → unicodedata_reader-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "unicodedata-reader"
-version = "1.2.0"
+version = "1.3.1"
 description = ""
 authors = ["Koji Ishii <kojii@chromium.org>"]
 readme = "README.md"
@@ -17,7 +17,7 @@ platformdirs = ">=2.2,<5.0"
 
 [tool.poetry.dev-dependencies]
 pytest = "*"
-pytype = {version = "*", python = "<3.10"}
+pytype = "*"
 tox = "^4.14.2"
 yapf = "^0.40.2"
 

{unicodedata_reader-1.2.0 → unicodedata_reader-1.3.1}/unicodedata_reader/entry.py

@@ -4,11 +4,13 @@ import logging
 import re
 import types
 from typing import Any
+from typing import Callable
 from typing import Dict
 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
 
@@ -216,6 +218,9 @@ class UnicodeDataEntries(object):
         self._ensure_multi_iterable()
         return len(self._entries)
 
+    def __getitem__(self, code: int) -> Any:
+        return self.value(code)
+
     def missing_value(self, code: int):
         if self._missing_entries:
             # `_missing_entries` can overlap, iterate all entries.
@@ -249,7 +254,7 @@ class UnicodeDataEntries(object):
         self._ensure_multi_iterable()
         return itertools.chain(*(e.range() for e in self._entries))
 
-    def value(self, code: int):
+    def value(self, code: int) -> Any:
         """Returns the value for the given code point."""
         self._ensure_multi_iterable()
         for entry in self._entries:
@@ -259,6 +264,32 @@ class UnicodeDataEntries(object):
                 return entry.value
         return self.missing_value(code)
 
+    def filter(self, pred: Callable[[Any],
+                                    bool]) -> Iterable[UnicodeDataEntry]:
+        """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:
+        """Add values `pred` returns `True` to `set[int]`."""
+        for code in self.codes_for(pred):
+            set.add(code)
+
+    def remove_from_set(self, pred: Callable[[Any], bool],
+                        set: Set[int]) -> None:
+        """Remove values `pred` returns `True` from `set[int]`."""
+        for code in self.codes_for(pred):
+            set.discard(code)
+
+    def to_set(self, pred: Callable[[Any], bool]) -> Set[int]:
+        """Returns a `set[int]` of values `pred` returns `True`."""
+        s = set()  # type: set[int]
+        self.add_to_set(pred, s)
+        return s
+
     def values_for_code(self) -> Iterable[Any]:
         """Returns a list of values whose index is the Unicode code point.
 

{unicodedata_reader-1.2.0 → unicodedata_reader-1.3.1}/unicodedata_reader/set.py

@@ -1,18 +1,23 @@
 from typing import Any
 from typing import Callable
 from typing import Iterable
+from typing import Set
 
 from unicodedata_reader.entry import *
 from unicodedata_reader.reader import *
 
 
 class Set(object):
-    """A simple set of Unicode code points."""
+    """A simple wrapper of a `set` of Unicode code points."""
 
-    def __init__(self) -> None:
-        self.set = set()  # type: set[int]
+    def __init__(self,
+                 entries: UnicodeDataEntries = None,
+                 pred: Callable[[Any], bool] = None) -> None:
+        self.set = set()  # type: Set[int]
+        if entries:
+            self.add_entries(entries, pred)
 
-    def __contains__(self, code_point: int) -> bool:
+    def contains(self, code_point: int) -> bool:
         return code_point in self.set
 
     def __iter__(self) -> Iterable[int]:
@@ -38,40 +43,28 @@ class Set(object):
 
     def add_entries(self, entries: UnicodeDataEntries, pred: Callable[[Any],
                                                                       bool]):
-        for entry in entries:
-            if pred(entry.value):
-                for code in entry.range():
-                    self.set.add(code)
+        entries.add_to_set(pred, self.set)
 
     @staticmethod
     def east_asian_width(
             value: str,
             reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
-        set = Set()
-        set.add_entries(reader.east_asian_width(), lambda v: v == value)
-        return set
+        return Set(reader.east_asian_width(), lambda v: v == value)
 
     @staticmethod
     def general_category(
             value: str,
             reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
-        set = Set()
-        set.add_entries(reader.general_category(),
-                        lambda v: v.startswith(value))
-        return set
+        return Set(reader.general_category(), lambda v: v.startswith(value))
 
     @staticmethod
     def scripts(
             value: str,
             reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
-        set = Set()
-        set.add_entries(reader.scripts(), lambda v: v == value)
-        return set
+        return Set(reader.scripts(), lambda v: v == value)
 
     @staticmethod
     def script_extensions(
             value: str,
             reader: UnicodeDataReader = UnicodeDataReader.default) -> 'Set':
-        set = Set()
-        set.add_entries(reader.script_extensions(), lambda v: value in v)
-        return set
+        return Set(reader.script_extensions(), lambda v: value in v)