instruction_rewriting/sentence_pattern.py

# 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 {{{ # 
    @abc.abstractmethod
    def instantiate(self) -> str:
        """
        Samples from the underlying template a sentence.

        Return:
            str
        """

        raise NotImplementedError()

    @property
    @abc.abstractmethod
    def regex(self) -> str:
        raise NotImplementedError()

    @abc.abstractmethod
    def get_targets(self) -> List[str]:
        """
        Collects the target patterns from the nodes or the sub-nodes
        recursively.

        Return:
            list of str
        """

        raise NotImplementedError()

    @abc.abstractmethod
    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))

    @property
    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

    @property
    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()

    @property
    def regex(self) -> str:
        return self._regex

    @classmethod
    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 ""

    @property
    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

    @property
    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