Initial commit

Author: Tiphereth-A

.gitignore

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tifa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE

@@ -0,0 +1,25 @@
+lang = zh-hans en
+latexmk = latexmk -cd -xelatex -synctex=1 -interaction=nonstopmode -file-line-error -halt-on-error -outdir=out -time
+filter = python filter.py -l DEBUG
+texgen = python tex-gen.py -l DEBUG
+
+all: gentex pdf
+.PHONY: gentex pdf $(lang) clean
+
+pdf: $(lang)
+
+gentex:
+	$(filter) clean
+	$(texgen) gen
+
+clean:
+	-rm -rf data
+	-rm tex/oeis.tex
+	-mkdir data
+	-mkdir data/detail
+	-touch data/.gitkeep
+	-touch data/detail/.gitkeep
+	cd tex && (latexmk -C -outdir=out *.tex; cd ..)
+
+$(lang): % : tex/oeis-pdf-%.tex
+	$(latexmk) $<

Makefile

@@ -0,0 +1,148 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+import json
+import os
+import re
+
+import click
+import coloredlogs
+from libs.decorator import withlog
+from libs.predicate import *
+
+
+@click.group()
+@click.option('-l', '--level', type=click.Choice(['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG']), help='log level',
+              default='INFO')
+def cli(level: str):
+    coloredlogs.install(milliseconds=True,
+                        level=level,
+                        fmt='%(asctime)s:%(msecs)03d %(levelname)s %(programname)s::%(name)s [%(process)d] %(message)s',
+                        field_styles={'asctime': {'color': 'green'},
+                                      'msecs': {'color': 'green'},
+                                      'hostname': {'color': 'red'},
+                                      'levelname': {'bold': True, 'color': 'magenta'},
+                                      'name': {'faint': True, 'color': 'blue'},
+                                      'programname': {'bold': True, 'color': 'cyan'},
+                                      'process': {'faint': True, 'color': 'green'},
+                                      'username': {'color': 'yellow'}},
+                        level_styles={'critical': {'bold': True, 'color': 'red'},
+                                      'debug': {'color': 'cyan'},
+                                      'error': {'color': 'red'},
+                                      'info': {'bright': True, 'color': 'white'},
+                                      'notice': {'color': 'magenta'},
+                                      'spam': {'color': 'green', 'faint': True},
+                                      'success': {'bold': True, 'color': 'green'},
+                                      'verbose': {'color': 'blue'},
+                                      'warning': {'bright': True, 'color': 'yellow'}})
+
+
+RE_OEIS_ID = re.compile(r'A\d+')
+
+
+@cli.command('clean')
+@click.argument('folder', type=click.Path(exists=True), default='data/detail')
+def _filter_results(folder):
+    """Filter results
+
+    Remove all sequences with no valid formula"""
+
+    def check(_single_result: dict) -> bool:
+        return 'formula' in _single_result.keys() and 'data' in _single_result.keys()
+
+    @withlog
+    def filter_results(_result_folder: str, **kwargs):
+        logger = kwargs.get('logger')
+
+        __remove_cnt, __clean_cnt, __total_cnt = 0, 0, sum(
+            len(filenames) for _, __, filenames in os.walk(_result_folder))
+        __flag: bool = True
+
+        while __flag:
+            __flag = False
+            __id_set: set = set()
+            for dir_path, _, filenames in os.walk(_result_folder):
+                __id_set = __id_set.union(
+                    x.removesuffix('.json') for x in filter(lambda x: x.endswith('.json'), filenames))
+
+            for dir_path, _, filenames in os.walk(_result_folder):
+                for name in filter(lambda x: x.endswith('.json'), filenames):
+                    filename = os.path.join(dir_path, name)
+                    logger.debug(f'reading {filename}')
+                    now_json: dict = json.load(open(filename, 'r'))
+                    if not check(now_json):
+                        logger.debug(
+                            f'remove {filename} because of failing check')
+                        os.remove(filename)
+                        __remove_cnt += 1
+                        __flag = True
+                    else:
+                        new_formulas: list[str] = list(
+                            filter(lambda x: all(i in __id_set for i in re.findall(RE_OEIS_ID, x)),
+                                   now_json['formula']))
+                        if new_formulas:
+                            if now_json['formula'] != new_formulas:
+                                __clean_cnt += 1
+                                now_json['formula'] = new_formulas
+                                json.dump(now_json, open(filename, 'w'))
+                        else:
+                            logger.debug(
+                                f'remove {filename} because of no valid formula')
+                            os.remove(filename)
+                            __remove_cnt += 1
+                            __flag = True
+
+        logger.info(f'{__remove_cnt} / {__total_cnt} result(s) removed')
+        logger.info(f'{__clean_cnt} / {__total_cnt} result(s) cleaned')
+
+    filter_results(click.format_filename(folder))
+
+
+@cli.command('rmbad')
+@click.argument('folder', type=click.Path(exists=True), default='data/detail')
+def _remove_bad_results(folder):
+    """Remove bad results"""
+
+    @withlog
+    def remove_bad_results(_result_folder: str, **kwargs):
+        logger = kwargs.get('logger')
+
+        __remove_cnt, __total_cnt = 0, 0
+        for dir_path, _, filenames in os.walk(_result_folder):
+            for name in filter(lambda x: x.endswith('.json'), filenames):
+                filename = os.path.join(dir_path, name)
+                __total_cnt += 1
+                try:
+                    if not os.path.getsize(filename):
+                        raise Exception(f'Empty file: {filename}')
+                    if json.load(open(filename, 'r'))['number'] != int(name.removeprefix('A').removesuffix('.json')):
+                        raise Exception('Invalid result')
+                except Exception as e:
+                    os.remove(filename)
+                    __remove_cnt += 1
+        logger.info(f'{__remove_cnt} / {__total_cnt} bad result(s) removed')
+
+    remove_bad_results(click.format_filename(folder))
+
+
+@cli.command('reduce')
+@click.option('-k', '--key', required=True, multiple=True, help='Key which will be removed')
+@click.argument('folder', type=click.Path(exists=True), default='data/detail')
+def _reduce_results(key: tuple[str, ...], folder):
+    """Remove some keys in results"""
+
+    @withlog
+    def reduce_results(_key_removed: set[str], _result_folder: str, **kwargs):
+        logger = kwargs.get('logger')
+
+        for dir_path, _, filenames in os.walk(_result_folder):
+            for name in filter(lambda x: x.endswith('.json'), filenames):
+                filename = os.path.join(dir_path, name)
+                json.dump(dict([(k, v) for k, v in json.load(open(filename, 'r')).items() if k not in _key_removed]),
+                          open(filename, 'w'))
+
+    reduce_results(set(key), click.format_filename(folder))
+
+
+if __name__ == '__main__':
+    cli()

README.md

@@ -0,0 +1,128 @@
+import re
+
+RE_BRACKET_NEEDS_LSTRIP = re.compile(r'\s+([(\[{])')
+RE_BRACKET_NEEDS_RSTRIP = re.compile(r'([)\]}])\s+')
+RE_RELATION = re.compile(r'\s*([<>:!=]=|=|<|>)\s*')
+RE_FORMULA_AN = re.compile(r'^a\s*\(\s*n\s*\)\s*=\s*', flags=re.IGNORECASE)
+RE_FORMULA_GF = re.compile(r'^g\.f\.\s*:?\s*', flags=re.IGNORECASE)
+RE_FORMULA_EGF = re.compile(r'^e\.g\.f\.\s*:?\s*', flags=re.IGNORECASE)
+RE_FORMULA_DGF = re.compile(
+    r'^d(?:\.|irichlet)\s*g\.f\.\s*:?\s*', flags=re.IGNORECASE)
+RE_AUTHOR_DATE_IN_THE_END = re.compile(
+    r'-\s*_(?P<author>(?:[A-Za-z.\-]+?\s*)+?)_,?\s*(?P<date>(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d+\s+\d+)')
+
+
+class CommandGenerator:
+    def __init__(self, _id: str, seq_detail: dict) -> None:
+        if int(_id.removeprefix('A')) != seq_detail['number']:
+            raise RuntimeError(
+                f"ID match error. ID input = {_id}, ID in seq_detail = {seq_detail['number']}")
+
+        self.id: str = _id
+        self.offset: str = seq_detail.get('offset', '')
+        self.name: str = seq_detail.get('name', '')
+
+        __data: list[int] = [int(i) for i in seq_detail['data'].split(',')]
+        self.cnt0: int = __data.index(
+            next(filter(lambda x: x > 0, __data), __data[-1]))
+        if __data[self.cnt0] == 0:
+            self.cnt0 = len(__data)
+        __data = __data[self.cnt0:]
+        if __data:
+            self.cnt1: int = __data.index(
+                next(filter(lambda x: x > 1, __data), __data[-1]))
+            if __data[self.cnt1] == 1:
+                self.cnt1 = len(__data)
+            self.data: list[int] = __data[self.cnt1:]
+        else:
+            self.cnt1: int = 0
+            self.data: list[int] = []
+
+        self.formula: list[str] = []
+        self.formula_an: list[str] = []
+        self.formula_gf: list[str] = []
+        self.formula_egf: list[str] = []
+        self.formula_dgf: list[str] = []
+
+        for now_formula in [i.strip() for i in seq_detail['formula']]:
+            now_formula = re.sub(RE_AUTHOR_DATE_IN_THE_END, '', now_formula)
+            if re.search(RE_FORMULA_AN, now_formula):
+                self.formula_an.append(re.sub(RE_FORMULA_AN, '', now_formula))
+                continue
+            if re.search(RE_FORMULA_GF, now_formula):
+                self.formula_gf.append(re.sub(RE_FORMULA_GF, '', now_formula))
+                continue
+            if re.search(RE_FORMULA_EGF, now_formula):
+                self.formula_egf.append(
+                    re.sub(RE_FORMULA_EGF, '', now_formula))
+                continue
+            if re.search(RE_FORMULA_DGF, now_formula):
+                self.formula_dgf.append(
+                    re.sub(RE_FORMULA_DGF, '', now_formula))
+                continue
+            self.formula.append(now_formula)
+
+    def __lt__(self, rhs) -> bool:
+        if self.data != rhs.data:
+            return self.data < rhs.data
+        if self.cnt1 != rhs.cnt1:
+            return self.cnt1 < rhs.cnt1
+        if self.cnt0 != rhs.cnt0:
+            return self.cnt0 < rhs.cnt0
+        return self.id < rhs.id
+
+    @staticmethod
+    def __plain_text(formula: str) -> str:
+        def __f(__s: str) -> str:
+            return ''.join(rf'\{ch}' if ch in r'#$%{}_&' else r'\;' if ch == ' ' else ch for ch in __s.strip())
+
+        formula = re.sub(RE_BRACKET_NEEDS_LSTRIP,
+                         lambda x: x.group(1), formula)
+        formula = re.sub(RE_BRACKET_NEEDS_RSTRIP,
+                         lambda x: x.group(1), formula)
+        formula = re.sub(RE_RELATION, lambda x: f' {x.group(1)} ', formula)
+
+        return ' '.join(filter(lambda x: x, r' \^{} '.join(r' \~{} '.join(
+            r' \(\backslash\) '.join(rf' \seqsplit{{{__f(part3)}}} ' for part3 in part2.split('\\')) for part2 in
+            part1.split('~')) for part1 in formula.split('^')).split()))
+
+    def __seq_data(self) -> str:
+        result: str = rf"\{{{str(self.cnt0) if self.cnt0 else ''},{str(self.cnt1) if self.cnt1 else ''}\}}" if self.cnt0 or self.cnt1 else ''
+        __data: list[int] = self.data
+        __cnt: int = 0
+        while __data:
+            if len(__data) < 2 or __data[0] != __data[1]:
+                result += f',{__data[0]}'
+                __data = __data[1:]
+                __cnt += 1
+                if __cnt >= 10:
+                    break
+
+                if __data:
+                    continue
+                else:
+                    break
+
+            __idx: int = __data.index(
+                next(filter(lambda x: x != __data[0], __data), __data[-1]))
+            if not __idx:
+                __idx = len(__data)
+
+            result += f',{__data[0]}:{__idx}' if __idx > 1 else f',{__data[0]}'
+            __data = __data[__idx:]
+            __cnt += 1
+            if __cnt >= 10:
+                break
+
+        return rf"\seqsplit{{{result.strip(',')}}}"
+
+    def str_tex(self) -> str:
+        return ' '.join([rf'\textbf{{{self.id}}}\index{{{self.id}}}' + (rf'\(\langle {self.offset}\rangle\)' if self.offset else ''),
+                         rf'{{\ttfamily {self.__seq_data()}}}',
+                         rf'\textit{{{self.__plain_text(self.name)}}}'] +
+                        [rf'\(\ddagger\) {self.__plain_text(i)}' for i in self.formula_an] +
+                        [rf'\(\flat\) {self.__plain_text(i)}' for i in self.formula_gf] +
+                        [rf'\(\natural\) {self.__plain_text(i)}' for i in self.formula_egf] +
+                        [rf'\(\diamond\) {self.__plain_text(i)}' for i in self.formula_dgf] +
+                        [rf'\(\dagger\) {self.__plain_text(i)}' for i in self.formula] +
+                        [rf'\href{{\oeis {self.id}/}}{{\P}}'])