UniTok 3.5.2__tar.gz → 4.0.0__tar.gz

{UniTok-3.5.2 → UniTok-4.0.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: UniTok
-Version: 3.5.2
+Version: 4.0.0
 Summary: Unified Tokenizer
 Home-page: https://github.com/Jyonn/UnifiedTokenizer
 Author: Jyonn Liu
-Author-email: i@6-79.cn
+Author-email: liu@qijiong.work
 License: MIT Licence
 Keywords: token,tokenizer
 Platform: any
@@ -73,8 +73,8 @@ UniTok提供了一整套的数据预处理工具，包括不同类型的分词
 通过以下代码，我们可以针对每个文件构建一个UniTok对象：
 
 ```python
-from UniTok import UniTok, Column, Vocab
-from UniTok.tok import IdTok, BertTok, EntTok, SplitTok, NumberTok
+from UniTokv3 import UniTok, Column, Vocab
+from UniTokv3.tok import IdTok, BertTok, EntTok, SplitTok, NumberTok
 
 # Create a news id vocab, commonly used in news data, history data, and interaction data.
 nid_vocab = Vocab('nid')
@@ -110,7 +110,7 @@ news_ut.add_col(Column(
 news_ut.read('news.tsv', sep='\t')
 
 # Tokenize the data.
-news_ut.tokenize() 
+news_ut.tokenize()
 
 # Store the tokenized data.
 news_ut.store('data/news')
@@ -130,10 +130,10 @@ user_ut.add_col(Column(
 ))
 
 # Read the data file.
-user_ut.read('user.tsv', sep='\t') 
+user_ut.read('user.tsv', sep='\t')
 
 # Tokenize the data.
-user_ut.tokenize() 
+user_ut.tokenize()
 
 # Store the tokenized data.
 user_ut.store('data/user')
@@ -142,16 +142,16 @@ user_ut.store('data/user')
 def inter_tokenize(mode):
     # Create an interaction UniTok object.
     inter_ut = UniTok()
-    
+
     # Add columns to the interaction UniTok object.
     inter_ut.add_index_col(
         # The index column in the interaction data is automatically generated, and the tokenizer does not need to be specified.
     ).add_col(Column(
         # Align with the uid column in user_ut.
-        tok=EntTok(vocab=uid_vocab), 
+        tok=EntTok(vocab=uid_vocab),
     )).add_col(Column(
         # Align with the nid column in news_ut.
-        tok=EntTok(vocab=nid_vocab),  
+        tok=EntTok(vocab=nid_vocab),
     )).add_col(Column(
         name='label',
         # The label column in the interaction data only has two values, 0 and 1.
@@ -160,14 +160,14 @@ def inter_tokenize(mode):
 
     # Read the data file.
     inter_ut.read(f'{mode}.tsv', sep='\t')
-    
+
     # Tokenize the data.
-    inter_ut.tokenize() 
-    
+    inter_ut.tokenize()
+
     # Store the tokenized data.
     inter_ut.store(mode)
 
-    
+
 inter_tokenize('data/train')
 inter_tokenize('data/dev')
 inter_tokenize('data/test')
@@ -184,7 +184,7 @@ UniDep 是一个数据依赖处理类，可以用于加载和访问 UniTok 预
 以下是一个简单的使用示例：
 
 ```python
-from UniTok import UniDep
+from UniTokv3 import UniDep
 
 # Load the data.
 dep = UniDep('data/news')

{UniTok-3.5.2 → UniTok-4.0.0}/README.md

@@ -61,8 +61,8 @@ UniTok提供了一整套的数据预处理工具，包括不同类型的分词
 通过以下代码，我们可以针对每个文件构建一个UniTok对象：
 
 ```python
-from UniTok import UniTok, Column, Vocab
-from UniTok.tok import IdTok, BertTok, EntTok, SplitTok, NumberTok
+from UniTokv3 import UniTok, Column, Vocab
+from UniTokv3.tok import IdTok, BertTok, EntTok, SplitTok, NumberTok
 
 # Create a news id vocab, commonly used in news data, history data, and interaction data.
 nid_vocab = Vocab('nid')
@@ -98,7 +98,7 @@ news_ut.add_col(Column(
 news_ut.read('news.tsv', sep='\t')
 
 # Tokenize the data.
-news_ut.tokenize() 
+news_ut.tokenize()
 
 # Store the tokenized data.
 news_ut.store('data/news')
@@ -118,10 +118,10 @@ user_ut.add_col(Column(
 ))
 
 # Read the data file.
-user_ut.read('user.tsv', sep='\t') 
+user_ut.read('user.tsv', sep='\t')
 
 # Tokenize the data.
-user_ut.tokenize() 
+user_ut.tokenize()
 
 # Store the tokenized data.
 user_ut.store('data/user')
@@ -130,16 +130,16 @@ user_ut.store('data/user')
 def inter_tokenize(mode):
     # Create an interaction UniTok object.
     inter_ut = UniTok()
-    
+
     # Add columns to the interaction UniTok object.
     inter_ut.add_index_col(
         # The index column in the interaction data is automatically generated, and the tokenizer does not need to be specified.
     ).add_col(Column(
         # Align with the uid column in user_ut.
-        tok=EntTok(vocab=uid_vocab), 
+        tok=EntTok(vocab=uid_vocab),
     )).add_col(Column(
         # Align with the nid column in news_ut.
-        tok=EntTok(vocab=nid_vocab),  
+        tok=EntTok(vocab=nid_vocab),
     )).add_col(Column(
         name='label',
         # The label column in the interaction data only has two values, 0 and 1.
@@ -148,14 +148,14 @@ def inter_tokenize(mode):
 
     # Read the data file.
     inter_ut.read(f'{mode}.tsv', sep='\t')
-    
+
     # Tokenize the data.
-    inter_ut.tokenize() 
-    
+    inter_ut.tokenize()
+
     # Store the tokenized data.
     inter_ut.store(mode)
 
-    
+
 inter_tokenize('data/train')
 inter_tokenize('data/dev')
 inter_tokenize('data/test')
@@ -172,7 +172,7 @@ UniDep 是一个数据依赖处理类，可以用于加载和访问 UniTok 预
 以下是一个简单的使用示例：
 
 ```python
-from UniTok import UniDep
+from UniTokv3 import UniDep
 
 # Load the data.
 dep = UniDep('data/news')

UniTok-4.0.0/UniTok/__init__.py

@@ -0,0 +1,37 @@
+from unitok.utils import Verbose, warning, error, info, debug
+from unitok.utils import Symbol, Symbols
+from unitok.utils import JsonHandler, PickleHandler
+from unitok.utils import Instance, Space, Map
+
+from unitok.utils.hub import Hub, ParamHub
+from unitok.vocabulary import Vocab, Vocabulary, VocabHub, VocabularyHub
+from unitok.tokenizer import BaseTokenizer, TokenizerHub
+from unitok.tokenizer import EntityTokenizer, EntitiesTokenizer
+from unitok.tokenizer import TransformersTokenizer, BertTokenizer
+from unitok.tokenizer import SplitTokenizer, DigitTokenizer, DigitsTokenizer
+from unitok.job import Job, JobHub
+
+from unitok.utils.index_set import IndexSet, VocabSet, TokenizerSet, JobSet
+
+from unitok.meta import Meta
+from unitok.status import Status
+from unitok.unitok import UniTok
+
+
+__all__ = [
+    'Verbose', 'warning', 'error', 'info', 'debug',
+    'Symbol', 'Symbols',
+    'JsonHandler', 'PickleHandler',
+    'Instance', 'Space', 'Map',
+    'Hub', 'ParamHub',
+    'Vocab', 'Vocabulary', 'VocabHub', 'VocabularyHub',
+    'BaseTokenizer', 'TokenizerHub',
+    'EntityTokenizer', 'EntitiesTokenizer',
+    'TransformersTokenizer', 'BertTokenizer',
+    'SplitTokenizer', 'DigitTokenizer', 'DigitsTokenizer',
+    'Job', 'JobHub',
+    'IndexSet', 'VocabSet', 'TokenizerSet', 'JobSet',
+    'Meta',
+    'Status',
+    'UniTok',
+]

UniTok-4.0.0/UniTok/__main__.py

@@ -0,0 +1,78 @@
+import argparse
+
+import pandas as pd
+
+from unitok.tokenizer import BaseTokenizer
+from unitok.unitok import UniTok
+from unitok.utils.class_pool import ClassPool
+
+
+def integrate():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('path', type=str, default='.', help='path to a unitok data directory')
+    parser.add_argument('--file', '-f', type=str, help='csv, tsv, parquet format data')
+    parser.add_argument('--lib', type=str, default=None, help='custom tokenizer library')
+    parser.add_argument('--column', '-c', type=str, help='column name to tokenize')
+    parser.add_argument('--name', '-n', type=str, help='job name and export column name')
+    parser.add_argument('--vocab', '-v', type=str, default=None, help='vocabulary name')
+    parser.add_argument('--tokenizer', '-t', type=str, default=None, help='tokenizer classname')
+    parser.add_argument('--tokenizer_id', type=str, default=None, help='tokenizer id')
+    parser.add_argument('--truncate', type=int, help='truncate length', default=None)
+    args, unknown_args = parser.parse_known_args()
+
+    tokenizer_params = dict()
+    current_param = None
+    for arg in unknown_args:
+        if current_param:
+            tokenizer_params[current_param] = arg
+            current_param = None
+        if arg.startswith('--t.'):
+            current_param = arg[4:]
+        elif arg.startswith('--tokenizer.'):
+            current_param = arg[11:]
+
+    if args.file.endswith('.csv') or args.file.endswith('.tsv'):
+        df = pd.read_csv(args.file, sep='\t')
+    elif args.file.endswith('.parquet'):
+        df = pd.read_parquet(args.file)
+    else:
+        raise ValueError(f'Unsupported file format: {args.file}')
+
+    with UniTok.load(args.path, tokenizer_lib=args.lib) as ut:
+        if args.tokenizer_id:
+            for t in ut.meta.tokenizers:  # type: BaseTokenizer
+                if t.get_tokenizer_id() == args.tokenizer_id:
+                    tokenizer = t
+                    break
+            else:
+                raise ValueError(f'Unknown tokenizer id: {args.tokenizer_id}')
+        else:
+            assert args.tokenizer is not None and args.vocab is not None, 'Tokenizer classname and vocabulary must be specified'
+            tokenizers = ClassPool.tokenizers(args.lib)
+            assert args.tokenizer in tokenizers, f'Unknown tokenizer: {args.tokenizer}. Available tokenizers: {tokenizers.keys()}'
+            tokenizer = tokenizers[args.tokenizer](vocab=args.vocab, **tokenizer_params)
+
+        ut.add_job(tokenizer=tokenizer, column=args.column, name=args.name, truncate=args.truncate)
+        ut.tokenize(df).save(args.path)
+
+
+def summarize():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('path', type=str, default='.', help='path to a unitok data directory')
+    args, _ = parser.parse_known_args()
+
+    with UniTok.load(args.path) as ut:
+        ut.summarize()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--action', '-a', type=str, default='summarize', choices=['summarize', 'integrate'])
+
+    args, _ = parser.parse_known_args()
+    action = args.action
+
+    if action == 'integrate':
+        integrate()
+    else:
+        summarize()

UniTok-4.0.0/UniTok/job.py

@@ -0,0 +1,76 @@
+from unitok.tokenizer import BaseTokenizer
+from unitok.utils import Symbols, Instance
+from unitok.utils.hub import Hub
+
+
+class Job:
+    def __init__(
+            self,
+            tokenizer: BaseTokenizer,
+            column: str,
+            name: str = None,
+            truncate: int = None,
+            order: int = -1,
+            key: bool = False,
+            max_len: int = 0,
+    ):
+        self.tokenizer: BaseTokenizer = tokenizer
+        self.column: str = column
+        self.name: str = name
+        self.truncate: int = truncate
+        self.order: int = order
+        self.slice: slice = self.get_slice(truncate)
+        self.key: bool = key
+        self.max_len = max_len
+
+        JobHub.add(self.name, self)
+
+    @property
+    def return_list(self):
+        return self.truncate is not None
+
+    def clone(self, **kwargs):
+        attributes = {'tokenizer', 'column', 'name', 'truncate', 'order', 'key', 'max_len'}
+        params = dict()
+        for attr in attributes:
+            params[attr] = kwargs[attr] if attr in kwargs else getattr(self, attr)
+
+        return Job(**params)
+
+    def __str__(self):
+        if self.key:
+            return f'Job({self.column} => {self.name}) [PK]'
+        return f'Job({self.column} => {self.name})'
+
+    def __repr__(self):
+        return str(self)
+
+    @property
+    def is_processed(self):
+        return self.order >= 0
+
+    def json(self):
+        column = str(Symbols.idx) if self.column is Symbols.idx else self.column
+        return {
+            'name': self.name,
+            'column': column,
+            'tokenizer': self.tokenizer.get_tokenizer_id(),
+            'truncate': self.truncate,
+            'order': self.order,
+            'key': self.key,
+            'max_len': self.max_len,
+        }
+
+    @staticmethod
+    def get_slice(truncate):
+        if truncate is None:
+            truncate = 0
+        if truncate > 0:
+            return slice(0, truncate)
+        if truncate < 0:
+            return slice(truncate, None)
+        return slice(None)
+
+
+class JobHub(Hub[Job]):
+    _instance = Instance(compulsory_space=True)

UniTok-4.0.0/UniTok/meta.py

@@ -0,0 +1,136 @@
+import json
+import os
+from datetime import datetime
+
+from unitok.utils.verbose import warning
+from unitok.job import Job
+from unitok.tokenizer import TokenizerHub
+from unitok.tokenizer.union_tokenizer import UnionTokenizer
+from unitok.tokenizer.unknown_tokenizer import UnknownTokenizer
+from unitok.utils import Symbols
+from unitok.utils.handler import JsonHandler
+from unitok.utils.class_pool import ClassPool
+from unitok.utils.index_set import VocabSet, TokenizerSet, JobSet
+from unitok.vocabulary import Vocab, VocabHub
+
+
+class Meta:
+    version = 'unidep-v4beta'
+
+    def __init__(self):
+        self.note = ('Not compatible with unitok-v3 or lower version, '
+                     'please upgrade by `pip install unitok>4.0.0` to load the data.')
+        self.website = 'https://unitok.github.io'
+        self.modified_at = self.created_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        self.vocabularies = VocabSet()
+        self.tokenizers = TokenizerSet()
+        self.jobs = JobSet()
+
+    @staticmethod
+    def parse_vocabulary(name: str, **kwargs):
+        return Vocab(name)
+
+    @staticmethod
+    def parse_tokenizer(tokenizer_id: str, classname: str, vocab: str, params: dict):
+        tokenizer_classes = ClassPool.tokenizers()
+
+        if not VocabHub.has(vocab):
+            raise ValueError(f"(unitok.meta) Vocabulary {vocab} not found in the vocabulary hub.")
+        vocab = VocabHub.get(vocab)
+
+        if (classname not in tokenizer_classes or
+                classname in [UnknownTokenizer.get_classname(), UnionTokenizer.get_classname()]):
+            warning(f"(unitok.meta) Tokenizer class {classname} not found in the class hub.")
+            return UnknownTokenizer(tokenizer_id=tokenizer_id, classname=classname, vocab=vocab, **params)
+        return tokenizer_classes[classname](tokenizer_id=tokenizer_id, vocab=vocab, **params)
+
+    @staticmethod
+    def parse_job(name: str, column: str, tokenizer: str, truncate: int, order: int, key: bool, max_len: int):
+        if not TokenizerHub.has(tokenizer):
+            raise ValueError(f"(unitok.meta) Tokenizer {tokenizer} not found in the tokenizer hub.")
+        tokenizer = TokenizerHub.get(tokenizer)
+
+        if column == str(Symbols.idx):
+            column = Symbols.idx
+
+        return Job(
+            name=name,
+            column=column,
+            tokenizer=tokenizer,
+            truncate=truncate,
+            order=order,
+            key=key,
+            max_len=max_len,
+        )
+
+    @staticmethod
+    def parse_version(version):
+        if version.startswith('unidep-v'):
+            return version[8:]
+
+        if version.startswith('UniDep-'):
+            raise ValueError(f'UniDep version ({version}) is not supported. '
+                             f'Please downgrade the unitok version by `pip install unitok==3.5.3`, '
+                             f'or use `unidep-upgrade-v4` to upgrade the version.')
+
+        raise ValueError(f'UniDep version ({version}) is not supported. '
+                         f'Please downgrade the unitok version by `pip install unitok==3.5.3` for compatible upgrade, '
+                         f'and then install the latest unitok version, '
+                         f'following the use of `unidep-upgrade-v4` to upgrade the version.')
+
+    @classmethod
+    def filename(cls, save_dir):
+        return os.path.join(save_dir, 'meta.json')
+
+    @classmethod
+    def _deprecated_filename(cls, save_dir):
+        return os.path.join(save_dir, 'meta.data.json')
+
+    @classmethod
+    def _compatible_readfile(cls, save_dir):
+        filename = cls.filename(save_dir)
+        if not os.path.exists(filename):
+            filename = cls._deprecated_filename(save_dir)
+            if not os.path.exists(filename):
+                raise FileNotFoundError(f"Meta file not found in {save_dir}")
+
+        meta_data = json.load(open(filename))
+
+        if 'version' not in meta_data:
+            raise ValueError(f"Version not found in the meta file {filename}")
+
+        current_version = cls.parse_version(cls.version)
+        depot_version = cls.parse_version(meta_data.get('version'))
+
+        if current_version != depot_version:
+            warning('Version mismatch, unexpected error may occur.')
+
+        return meta_data
+
+    @classmethod
+    def load(cls, save_dir):
+        kwargs = cls._compatible_readfile(save_dir)
+
+        meta = cls()
+        meta.created_at = kwargs.get('created_at')
+        meta.vocabularies = VocabSet({cls.parse_vocabulary(**v).load(save_dir) for v in kwargs.get('vocabularies')})
+        meta.tokenizers = TokenizerSet({cls.parse_tokenizer(**t) for t in kwargs.get('tokenizers')})
+        meta.jobs = JobSet({cls.parse_job(**j) for j in kwargs.get('jobs')})
+
+        return meta
+
+    def json(self):
+        return {
+            "version": self.version,
+            "note": self.note,
+            "website": self.website,
+            "created_at": self.created_at,
+            "modified_at": self.modified_at,
+            "vocabularies": [v.json() for v in self.vocabularies],
+            "tokenizers": [t.json() for t in self.tokenizers],
+            "jobs": [j.json() for j in self.jobs],
+        }
+
+    def save(self, save_dir):
+        filename = self.filename(save_dir)
+        JsonHandler.save(self.json(), filename)

UniTok-4.0.0/UniTok/status.py

@@ -0,0 +1,44 @@
+from unitok.utils import Symbols, Symbol
+
+
+class Status:
+    def __init__(self):
+        self.status = Symbols.initialized
+        # initialized
+        # tokenized
+        # organized
+
+    @staticmethod
+    def require_status(*status: Symbol):
+        status_string = '/'.join([s.name for s in status])
+
+        def decorator(func):
+            def wrapper(self, *args, **kwargs):
+                if self.status in status:
+                    return func(self, *args, **kwargs)
+                raise ValueError(f'UniTok should be in {status_string} status')
+
+            return wrapper
+
+        return decorator
+
+    require_initialized = require_status(Symbols.initialized)
+    require_tokenized = require_status(Symbols.tokenized)
+    require_organized = require_status(Symbols.organized)
+
+    require_not_initialized = require_status(Symbols.tokenized, Symbols.organized)
+    require_not_tokenized = require_status(Symbols.initialized, Symbols.organized)
+    require_not_organized = require_status(Symbols.initialized, Symbols.tokenized)
+
+    @staticmethod
+    def change_status(status: Symbol):
+        def decorator(func):
+            def wrapper(self, *args, **kwargs):
+                result = func(self, *args, **kwargs)
+                self.status = status
+                return result
+            return wrapper
+        return decorator
+
+    to_tokenized = change_status(Symbols.tokenized)
+    to_organized = change_status(Symbols.organized)

UniTok-4.0.0/UniTok/tokenizer/__init__.py

@@ -0,0 +1,18 @@
+from unitok.tokenizer.base_tokenizer import BaseTokenizer, TokenizerHub
+from unitok.tokenizer.entity_tokenizer import EntityTokenizer, EntitiesTokenizer
+from unitok.tokenizer.transformers_tokenizer import TransformersTokenizer, BertTokenizer
+from unitok.tokenizer.split_tokenizer import SplitTokenizer
+from unitok.tokenizer.digit_tokenizer import DigitTokenizer, DigitsTokenizer
+
+
+__all__ = [
+    BaseTokenizer,
+    EntityTokenizer,
+    EntitiesTokenizer,
+    TransformersTokenizer,
+    BertTokenizer,
+    SplitTokenizer,
+    DigitTokenizer,
+    DigitsTokenizer,
+    TokenizerHub
+]

UniTok-4.0.0/UniTok/tokenizer/base_tokenizer.py

@@ -0,0 +1,78 @@
+import abc
+from typing import Union
+
+from unitok.utils import Instance, function
+from unitok.utils.hub import Hub
+from unitok.vocabulary import Vocab, VocabHub
+
+
+class BaseTokenizer(abc.ABC):
+    return_list: bool
+    param_list: list
+
+    prefix = 'auto_'
+
+    def __init__(self, vocab: Union[str, Vocab], tokenizer_id: str = None, **kwargs):
+        if isinstance(vocab, str):
+            if VocabHub.has(vocab):
+                self.vocab = VocabHub.get(vocab)
+            else:
+                self.vocab = Vocab(name=vocab)
+        else:
+            self.vocab = vocab
+
+        self._tokenizer_id = tokenizer_id
+
+        TokenizerHub.add(self.get_tokenizer_id(), self)
+
+    def get_tokenizer_id(self):
+        if self._tokenizer_id is None:
+            self._tokenizer_id = self.prefix + function.get_random_string(length=6)
+        return self._tokenizer_id
+
+    @classmethod
+    def get_classname(cls):
+        # return cls.classname.lower().replace('tokenizer', '')
+        classname = cls.__name__.lower()
+        if not classname.endswith('tokenizer'):
+            raise ValueError(f'({classname}) Unexpected classname, expecting classname to end with "Tokenizer"')
+        return classname.replace('tokenizer', '')
+
+    def _convert_tokens_to_ids(self, tokens):
+        return_list = isinstance(tokens, list)
+        if return_list != self.return_list:
+            raise ValueError(f'(tokenizer.{self.get_classname()}) Unexpected input, requiring return_list={self.return_list}')
+
+        if not return_list:
+            tokens = [tokens]
+
+        ids = [self.vocab.append(token) for token in tokens]
+
+        if not return_list:
+            ids = ids[0]
+        return ids
+
+    def __call__(self, objs):
+        return self._convert_tokens_to_ids(objs)
+
+    def __str__(self):
+        return f'{self._detailed_classname}({self.get_tokenizer_id()}, vocab={self.vocab.name})'
+
+    def __repr__(self):
+        return str(self)
+
+    def json(self):
+        return {
+            'tokenizer_id': self.get_tokenizer_id(),
+            'vocab': self.vocab.name,
+            'classname': self.get_classname(),
+            'params': {param: getattr(self, param) for param in self.param_list},
+        }
+
+    @property
+    def _detailed_classname(self):
+        return self.__class__.__name__
+
+
+class TokenizerHub(Hub[BaseTokenizer]):
+    _instance = Instance()

UniTok-4.0.0/UniTok/tokenizer/digit_tokenizer.py

@@ -0,0 +1,33 @@
+from unitok.tokenizer import BaseTokenizer
+
+
+class DigitTokenizer(BaseTokenizer):
+    return_list = False
+    name = 'digit'
+    param_list = ['vocab_size']
+
+    def __init__(self, vocab_size: int = None, **kwargs):
+        super().__init__(**kwargs)
+
+        self.vocab_size = vocab_size
+        if self.vocab_size is not None:
+            self.vocab.extend([str(i) for i in range(vocab_size)])
+            self.vocab.deny_edit()
+
+    def __call__(self, obj):
+        obj = int(obj)
+        if obj >= len(self.vocab):
+            if self.vocab_size is not None:
+                raise ValueError(f'Vocabulary size is limited to {self.vocab_size}, but {obj} is given')
+            self.vocab.extend([str(i) for i in range(len(self.vocab), obj + 1)])
+        return obj
+
+
+class DigitsTokenizer(DigitTokenizer):
+    return_list = True
+    name = 'digits'
+
+    def __call__(self, obj):
+        obj = [int(o) for o in obj]
+        for o in obj:
+            super().__call__(o)