Datasets:
ArXiv:
Tags:
License:
| # Created by Danyang Zhang @X-Lance. | |
| import abc | |
| from typing import Iterable, Iterator, Union | |
| from typing import List, Tuple | |
| #import enum | |
| import numpy as np | |
| import itertools | |
| class Item(abc.ABC): | |
| # class Item {{{ # | |
| def instantiate(self) -> str: | |
| """ | |
| Samples from the underlying template a sentence. | |
| Return: | |
| str | |
| """ | |
| raise NotImplementedError() | |
| def regex(self) -> str: | |
| raise NotImplementedError() | |
| def get_targets(self) -> List[str]: | |
| """ | |
| Collects the target patterns from the nodes or the sub-nodes | |
| recursively. | |
| Return: | |
| list of str | |
| """ | |
| raise NotImplementedError() | |
| def implement(self, targets: Iterator[str]): | |
| """ | |
| Implements the target slots by the real target values. It is expected | |
| for `targets` to have the same length with `self.getTarget()`. | |
| Args: | |
| target: iterator of str | |
| """ | |
| raise NotImplementedError() | |
| def __add__(self, item: "Item") -> "Item": | |
| if self is Nil: | |
| return item | |
| elif item is Nil: | |
| return self | |
| return Concat(self, item) | |
| def __str__(self) -> str: | |
| raise NotImplementedError() | |
| def __repr__(self) -> str: | |
| raise NotImplementedError() | |
| # }}} class Item # | |
| Nil = type( "Nil", (Item,) | |
| , { "instantiate": lambda self: "" | |
| , "regex": "" | |
| , "get_targets": lambda self: [] | |
| , "implement": lambda self, tgts: None | |
| , "__str__": lambda self: "" | |
| , "__repr__": lambda self: "Nil" | |
| } | |
| )() | |
| class Concat(Item): | |
| # class Concat {{{ # | |
| def __init__(self, *items: Iterable[Item]): | |
| super(Concat, self).__init__() | |
| self._items: List[Item] = [] | |
| self._regex: str = "" | |
| for itm in items: | |
| self += itm | |
| def __iter__(self) -> Iterator[Item]: | |
| return iter(self._items) | |
| def __iadd__(self, item: Item) -> Item: | |
| if isinstance(item, Concat): | |
| self._items += item | |
| elif item is not Nil: | |
| self._items.append(item) | |
| self._regex += item.regex | |
| return self | |
| def instantiate(self) -> str: | |
| return "".join(map(lambda itm: itm.instantiate(), self._items)) | |
| def regex(self) -> str: | |
| return self._regex | |
| def get_targets(self) -> List[str]: | |
| return list( itertools.chain.from_iterable( | |
| map( lambda itm: itm.get_targets() | |
| , self._items | |
| ) | |
| ) | |
| ) | |
| def implement(self, targets: Iterator[str]): | |
| for itm in self._items: | |
| itm.implement(targets) | |
| def __str__(self) -> str: | |
| return "".join(map(str, self._items)) | |
| def __repr__(self) -> str: | |
| return "Concat({:})".format( | |
| ", ".join( map( repr | |
| , self._items | |
| ) | |
| ) | |
| ) | |
| # }}} class Concat # | |
| class Const(Item): | |
| # class Const {{{ # | |
| regex_meta_chars = str.maketrans( { ch: "\\" + ch | |
| for ch in [ ".", "^", "$", "*" | |
| , "+", "?", "{", "}" | |
| , "\\", "[", "]", "|" | |
| , "(", ")" | |
| ] | |
| } | |
| ) | |
| def __init__(self, value: str): | |
| super(Const, self).__init__() | |
| self.value: str = value | |
| self._regex: str = self.value.translate(Const.regex_meta_chars) | |
| def instantiate(self) -> str: | |
| return self.value | |
| def regex(self) -> str: | |
| return self._regex | |
| def get_targets(self) -> List[str]: | |
| return [] | |
| def implement(self, targets: Iterator[str]): | |
| pass | |
| def __str__(self) -> str: | |
| return self.value | |
| def __repr__(self) -> str: | |
| return "Const({:})".format(repr(self.value)) | |
| # }}} class Const # | |
| class Choice(Item): | |
| # class Choice {{{ # | |
| def __init__(self, *items: Iterable[Item]): | |
| super(Choice, self).__init__() | |
| self._items: List[Item] = list( | |
| filter( lambda itm: itm is not Nil | |
| , items | |
| ) | |
| ) | |
| self._regex: str = "(?:" + "|".join(map(lambda itm: itm.regex, self._items)) + ")" | |
| self._rng: np.random.Generator = np.random.default_rng() | |
| def instantiate(self) -> str: | |
| if len(self._items)==0: | |
| return "" | |
| return self._items[self._rng.integers(len(self._items))].instantiate() | |
| def regex(self) -> str: | |
| return self._regex | |
| def fromItem(cls, item: Item): | |
| if isinstance(item, Concat): | |
| return cls(*item) | |
| else: | |
| return cls(item) | |
| def get_targets(self) -> List[str]: | |
| return list( itertools.chain.from_iterable( | |
| map( lambda itm: itm.get_targets() | |
| , self._items | |
| ) | |
| ) | |
| ) | |
| def implement(self, targets: Iterator[str]): | |
| for itm in self._items: | |
| itm.implement(targets) | |
| def __str__(self) -> str: | |
| return "({:})".format( | |
| "/".join( map( str | |
| , self._items | |
| ) | |
| ) | |
| ) | |
| def __repr__(self) -> str: | |
| return "Choice({:})".format( | |
| ", ".join( map( repr | |
| , self._items | |
| ) | |
| ) | |
| ) | |
| # }}} class Choice # | |
| class Optional(Item): | |
| # class Optional {{{ # | |
| def __init__(self, item: Union[Item, str]): | |
| super(Optional, self).__init__() | |
| if isinstance(item, str): | |
| item = Const(item) | |
| self._item: Item = item | |
| self._regex = "(?:" + self._item.regex + ")?" | |
| self._rng: np.random.Generator = np.random.default_rng() | |
| def instantiate(self) -> str: | |
| return self._item.instantiate() if self._rng.random()<0.5 else "" | |
| def regex(self) -> str: | |
| return self._regex | |
| def get_targets(self) -> List[str]: | |
| return self._item.get_targets() | |
| def implement(self, targets: Iterator[str]): | |
| self._item.implement(targets) | |
| def __str__(self) -> str: | |
| return "[" + str(self._item) + "]" | |
| def __repr__(self) -> str: | |
| return "Optional(" + repr(self._item) + ")" | |
| # }}} class Optional # | |
| class Target(Item): | |
| # class Target {{{ # | |
| def __init__(self, pattern: str): | |
| super(Target, self).__init__() | |
| self._pattern: str = pattern | |
| self._value: str = "" | |
| def instantiate(self) -> str: | |
| return self._value | |
| def regex(self) -> str: | |
| return "(.+)" | |
| def get_targets(self) -> List[str]: | |
| return [self._pattern] | |
| def implement(self, targets: Iterator[str]): | |
| try: | |
| value = next(targets) | |
| self._value = value | |
| except StopIteration: | |
| pass | |
| def __str__(self) -> str: | |
| return "{" + self._pattern + "}" | |
| def __repr__(self) -> str: | |
| return "Target(" + repr(self._pattern) + ")" | |
| # }}} class Target # | |
| def read_plain(pattern: str) -> Tuple[Union[Const, type(Nil)], str]: | |
| # function read_plain {{{ # | |
| plain = "".join( | |
| itertools.takewhile( lambda ch: ch not in { "(", "/", ")" | |
| , "[", "]" | |
| , "{", "}" | |
| } | |
| , pattern | |
| ) | |
| ) | |
| return Const(plain) if len(plain)>0 else Nil\ | |
| , pattern[len(plain):] | |
| # }}} function read_plain # | |
| def read_until(stop: str, pattern: str) -> Tuple[str, str]: | |
| # function read_until {{{ # | |
| """ | |
| Args: | |
| stop: char | |
| pattern: str | |
| Return: | |
| - str as the output | |
| - str as the remaining | |
| """ | |
| plain = "".join( | |
| itertools.takewhile( lambda ch: ch!=stop | |
| , pattern | |
| ) | |
| ) | |
| return plain, pattern[len(plain):] | |
| # }}} function read_until # | |
| def read_while(while_char: str, pattern: str) -> Tuple[List[Item], str]: | |
| # function read_while {{{ # | |
| """ | |
| Args: | |
| while_char: char | |
| pattern: str | |
| Return: | |
| - list of Item | |
| - str | |
| """ | |
| (item, char), remaining = read_item(pattern) | |
| items = [item] | |
| while char==while_char: | |
| (item, char), remaining = read_item(remaining) | |
| items.append(item) | |
| return items, remaining | |
| # }}} function read_while # | |
| def read_item(pattern: str) -> Tuple[ Tuple [ Item | |
| , str | |
| ] | |
| , str | |
| ]: | |
| # function read_item {{{ # | |
| """ | |
| Args: | |
| pattern: str | |
| Return: | |
| - tuple like (Item, char) | |
| - str | |
| """ | |
| prelude, remaining = read_plain(pattern) | |
| if len(remaining)==0: | |
| return (prelude, "$"), "" | |
| head, tail = remaining[0], remaining[1:] | |
| if head=="(": | |
| choices, remaining = read_while("/", tail) | |
| (others, end), remaining = read_item(remaining) | |
| return ( prelude\ | |
| + Choice(*choices)\ | |
| + others\ | |
| , end | |
| )\ | |
| , remaining | |
| elif head=="/": | |
| return (prelude, "/")\ | |
| , tail | |
| elif head==")": | |
| return (prelude, ")")\ | |
| , tail | |
| elif head=="[": | |
| (option, _), remaining = read_item(tail) | |
| (others, end), remaining = read_item(remaining) | |
| return ( prelude\ | |
| + Optional(option)\ | |
| + others\ | |
| , end | |
| )\ | |
| , remaining | |
| elif head=="]": | |
| return (prelude, "]")\ | |
| , tail | |
| elif head=="{": | |
| target, remaining = read_until("}", tail) | |
| (others, end), remaining = read_item(remaining[1:]) | |
| return ( prelude\ | |
| + Target(target)\ | |
| + others\ | |
| , end | |
| )\ | |
| , remaining | |
| # }}} function read_item # | |
| def parse_pattern(pattern: str) -> Item: | |
| (item, end), remaining = read_item(pattern) | |
| assert len(remaining)==0 and end=="$" | |
| return item | |