unicodedata-reader 1.1.0__tar.gz → 1.3.0__tar.gz

{unicodedata_reader-1.1.0 → unicodedata_reader-1.3.0}/PKG-INFO

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

{unicodedata_reader-1.1.0 → unicodedata_reader-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "unicodedata-reader"
-version = "1.1.0"
+version = "1.3.0"
 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.1.0 → unicodedata_reader-1.3.0}/unicodedata_reader/cli.py

@@ -125,7 +125,8 @@ class UnicodeDataCli(object):
         parser.add_argument('text',
                             nargs='*',
                             help='show properties for the text')
-        parser.add_argument('-f', '--no-cache', action='store_true')
+        parser.add_argument('-f', '--clear-cache', action='store_true')
+        parser.add_argument('-F', '--no-cache', action='store_true')
         parser.add_argument('--name', help='$NAME in the template')
         parser.add_argument('-t',
                             '--template',
@@ -139,8 +140,10 @@ class UnicodeDataCli(object):
                             default=0)
         parser.parse_args(namespace=self)
         _init_logging(self.verbose)  # pytype: disable=attribute-error
+        if self.clear_cache:
+            UnicodeDataCachedReader.clear_cache()
         if self.no_cache:
-            UnicodeDataReader.is_caching_allowed = False
+            UnicodeDataReader.default = UnicodeDataReader()
 
     def main(self):
         if self.template:

{unicodedata_reader-1.1.0 → unicodedata_reader-1.3.0}/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
 
@@ -259,6 +261,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.1.0 → unicodedata_reader-1.3.0}/unicodedata_reader/reader.py

@@ -1,6 +1,7 @@
 import logging
 import pathlib
 from typing import Iterable
+import shutil
 import urllib.request
 
 from unicodedata_reader.entry import *
@@ -23,6 +24,12 @@ class UnicodeDataReader(object):
     default = None
     is_caching_allowed = True
 
+    def __init__(
+        self,
+        url_template: str = 'https://www.unicode.org/Public/UNIDATA/{0}.txt'
+    ) -> None:
+        self.url_template = url_template
+
     def bidi_brackets(self) -> UnicodeDataEntries:
         name = 'BidiBrackets'
         lines = self.read_lines(name)
@@ -74,8 +81,11 @@ class UnicodeDataReader(object):
         lines = self.read_lines(name)
         return UnicodeVerticalOrientationDataEntries(name=name, lines=lines)
 
+    def get_url(self, name: str) -> str:
+        return self.url_template.format(name)
+
     def read_lines(self, name: str) -> Iterable[str]:
-        url = f'https://www.unicode.org/Public/UNIDATA/{name}.txt'
+        url = self.get_url(name)
         _logger.debug('Downloading %s', url)
         with urllib.request.urlopen(url) as response:
             body = response.read().decode('utf-8')
@@ -112,5 +122,13 @@ class UnicodeDataCachedReader(UnicodeDataReader):
 
         return lines
 
+    @staticmethod
+    def clear_cache(ignore_errors: bool = False):
+        cache_dir = UnicodeDataCachedReader._cache_dir
+        if not cache_dir or not cache_dir.exists():
+            return
+        _logger.debug('Deleting cache %s', cache_dir)
+        shutil.rmtree(cache_dir, ignore_errors=ignore_errors)
+
 
 UnicodeDataReader.default = UnicodeDataCachedReader()

{unicodedata_reader-1.1.0 → unicodedata_reader-1.3.0}/unicodedata_reader/set.py

@@ -1,16 +1,21 @@
 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:
         return code_point in self.set
@@ -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)