Merge pull request #3 from luogu-dev/master

Follow the upstream

Author: Sweetlemon68

.gitignore

@@ -128,4 +128,7 @@ coverage.xml
 docs/_build/
 
 # PyBuilder
-target/
+target/
+
+# Pycharm
+venv

.travis.yml

@@ -1,9 +1,10 @@
 language: python
 python:
   - "2.7"
-  - "3.5"
   - "3.6"
+  - "3.7"
+  - "3.8"
   - "pypy"
   - "pypy3"
-script: python unit_test.py
-
+install: pip install tox-travis
+script: tox

README.md

@@ -1,33 +1,71 @@
 # Project CYaRon
-CYaRon: Yet Another Random Olympic-iNformatics test data generator
+**CYaRon** **Y**et **A**nother **R**andom **O**lympic-i**N**formatics test data generator
+
+**By Luogu** 项目地址: [https://github.com/luogu-dev/cyaron](https://github.com/luogu-dev/cyaron)
+
 
-By Luogu
 [![](https://travis-ci.org/luogu-dev/cyaron.svg?branch=master)](https://travis-ci.org/luogu-dev/cyaron)
 
 你是否遇到以下情况：
-- 希望在5分钟内写出一组随机数据
+- 希望在5分钟内写出一组随机数据，并方便地使用它们对拍几个程序
 - 希望生成一个合适的随机图或者树，且有一定强度
 - 希望生成一组随机数列或者向量，且不能重复。
 
-那么，你可以借助CYaRon和Python，来快速生成一组数据。目前支持的特性有：
+那么，你可以借助 CYaRon 和 Python ，来快速生成一组数据。目前支持的特性有：
 
 - 建一个随机图（简单图或者非简单图，有向图或无向图，带权图或者无权图）
 - 建一个随机树（链状、随机树、或者菊花图，而且可以设定树的强弱）
 - 生成一组允许相同或者互相不同的多维向量（可以较快速度生成10^6组、范围到10^9的向量或者数列）
 - 根据函数解析式生成数列
 - 生成一些随机多边形，并且可以求面积、周长等
 - 从字典生成随机字符串、单词、句子、段落
+- 使用以上功能生成的数据和您其他地方下载的测试数据方便地进行程序对拍
 
 **快速上手指南**
 
-你可以下载github源代码  https://github.com/luogu-dev/cyaron ，或者`pip install cyaron`。在此之前，需要准备好python2/3。
+稳定版本可以从pip获取: `pip install cyaron`，在此之前，需要准备好Python。
+
+最新开发版可以克隆GitHub源代码: `git clone https://github.com/luogu-dev/cyaron.git`
+
+请您查看[CYaRon文档](https://github.com/luogu-dev/cyaron/wiki)和[CYaRon基本入门](https://github.com/luogu-dev/cyaron/wiki/%E5%9F%BA%E6%9C%AC%E5%85%A5%E9%97%A8)来学习如何使用CYaRon。
+
+若您发现文档中有缺漏，请提出Issue并暂时根据`examples`和源代码进行YY。 
+
+CYaRon基于Python。若您对Python不熟悉，可看[快速入门教程](https://github.com/luogu-dev/cyaron/wiki/Python-30%E5%88%86%E9%92%9F%E5%85%A5%E9%97%A8%E6%8C%87%E5%8D%97)。
+
+之后计划实现云Generator，即只需提供写好的脚本以及std，上传到服务器，即可下载一个测试数据的压缩包，真正实现5分钟生成一个测试数据！
+
+希望各位大佬一起来协助改进这个项目。希望这个项目可以帮助大家节省时间！
+
+**使用范例**
+```python
+#!/usr/bin/env python
+
+from cyaron import * # 引入CYaRon的库
+
+_n = ati([0, 7, 50, 1E4]) # ati函数将数组中的每一个元素转换为整形，方便您可以使用1E4一类的数来表示数据大小
+_m = ati([0, 11, 100, 1E4]) 
+
+# 这是一个图论题的数据生成器，该题目在洛谷的题号为P1339
+for i in range(1, 4): # 即在[1, 4)范围内循环，也就是从1到3
+    test_data = IO(file_prefix="heat", data_id=i) # 生成 heat[1|2|3].in/out 三组测试数据
+
+    n = _n[i] # 点数
+    m = _m[i] # 边数
+    s = randint(1, n) # 源点，随机选取一个
+    t = randint(1, n) # 汇点，随机选取一个
+    test_data.input_writeln(n, m, s, t) # 写入到输入文件里，自动以空格分割并换行
+
+    graph = Graph.graph(n, m, weight_limit=5) # 生成一个n点，m边的随机图，边权限制为5
+    test_data.input_writeln(graph) # 自动写入到输入文件里，默认以一行一组u v w的形式输出
 
-若您对Python不熟悉，可看[快速入门教程](https://github.com/luogu-dev/cyaron/wiki/Python-30%E5%88%86%E9%92%9F%E5%85%A5%E9%97%A8%E6%8C%87%E5%8D%97)。
+    test_data.output_gen("D:\\std_binary.exe") # 标程编译后的可执行文件，不需要freopen等，CYaRon自动给该程序输入并获得输出作为.out
+```
 
-[文档](https://github.com/luogu-dev/cyaron/wiki/%E9%A6%96%E9%A1%B5)已经大体完整，若有缺漏，请提出Issue并暂时根据`examples`和源代码进行YY。
+**贡献**
 
-首批贡献者 @fjzzq2002 @lin_toto @kkksc03 
+所有的贡献者请查看[光荣榜](https://github.com/luogu-dev/cyaron/wiki/光荣榜)页面，衷心感谢他们对CYaRon项目的付出。
 
-之后计划实现云Generator，即只需提供写好的python脚本以及std，上传到服务器，即可下载一个测试数据的压缩包，真正实现5分钟生成一个测试数据！
+欢迎您对 CYaRon 做出贡献。若您有希望加入的功能，可以给我们提出 Issue ，或者自己动手实现，然后发起 Pull Request。
 
-目前CYaRon的功能还比较初级，希望各位大佬一起来协助改进这个项目。希望这个项目可以帮助大家节省时间！
+有关于如何做出贡献的更详细内容，请查看[如何做出贡献](https://github.com/luogu-dev/cyaron/wiki/%E5%A6%82%E4%BD%95%E5%81%9A%E5%87%BA%E8%B4%A1%E7%8C%AE)。

cyaron/__init__.py

@@ -4,13 +4,18 @@
 It has tools for graphs and IO files.
 """
 
+from __future__ import absolute_import
 from .io import IO
 from .graph import Graph, Edge
-from .str import String
+from .string import String
 from .sequence import Sequence
 from .utils import *
 from .consts import *
 from .vector import Vector
 from .polygon import Polygon
+from .compare import Compare
+from .math import *
+from .merger import Merger
+#from .visual import visualize
+from . import log
 from random import randint, randrange, uniform, choice, random
-

cyaron/compare.py

@@ -0,0 +1,150 @@
+from __future__ import absolute_import, print_function
+from cyaron import IO, log
+from cyaron.utils import *
+from cyaron.consts import *
+from cyaron.graders import CYaRonGraders
+import subprocess
+import multiprocessing
+import sys
+from io import open
+import os
+
+
+class CompareMismatch(ValueError):
+    def __init__(self, name, mismatch):
+        super(CompareMismatch, self).__init__(name, mismatch)
+        self.name = name
+        self.mismatch = mismatch
+
+    def __str__(self):
+        return 'In program: \'{}\'. {}'.format(self.name,self.mismatch)
+
+
+class Compare:
+    @staticmethod
+    def __compare_two(name, content, std, grader):
+        (result, info) = CYaRonGraders.invoke(grader, content, std)
+        status = "Correct" if result else "!!!INCORRECT!!!"
+        info = info if info is not None else ""
+        log.debug("{}: {} {}".format(name, status, info))
+        if not result:
+            raise CompareMismatch(name, info)
+
+    @staticmethod
+    def __process_file(file):
+        if isinstance(file, IO):
+            file.flush_buffer()
+            file.output_file.seek(0)
+            return file.output_filename, file.output_file.read()
+        else:
+            with open(file, "r", newline='\n') as f:
+                return file, f.read()
+
+    @staticmethod
+    def __normal_max_workers(workers):
+        if workers is None:
+            if sys.version_info < (3, 5):
+                cpu = multiprocessing.cpu_count()
+                return cpu * 5 if cpu is not None else 1
+        return workers
+
+    @classmethod
+    def output(cls, *files, **kwargs):
+        kwargs = unpack_kwargs('output', kwargs, ('std', ('grader', DEFAULT_GRADER), ('max_workers', -1),
+                                                  ('job_pool', None), ('stop_on_incorrect', None)))
+        std = kwargs['std']
+        grader = kwargs['grader']
+        max_workers = kwargs['max_workers']
+        job_pool = kwargs['job_pool']
+        if kwargs['stop_on_incorrect'] is not None:
+            log.warn("parameter stop_on_incorrect is deprecated and has no effect.")
+
+        if (max_workers is None or max_workers >= 0) and job_pool is None:
+            max_workers = cls.__normal_max_workers(max_workers)
+            try:
+                from concurrent.futures import ThreadPoolExecutor
+                with ThreadPoolExecutor(max_workers=max_workers) as job_pool:
+                    return cls.output(*files, std=std, grader=grader, max_workers=max_workers, job_pool=job_pool)
+            except ImportError:
+                pass
+
+        def get_std():
+            return cls.__process_file(std)[1]
+        if job_pool is not None:
+            std = job_pool.submit(get_std).result()
+        else:
+            std = get_std()
+
+        def do(file):
+            (file_name, content) = cls.__process_file(file)
+            cls.__compare_two(file_name, content, std, grader)
+
+        if job_pool is not None:
+            job_pool.map(do, files)
+        else:
+            [x for x in map(do, files)]
+
+    @classmethod
+    def program(cls, *programs, **kwargs):
+        kwargs = unpack_kwargs('program', kwargs, ('input', ('std', None), ('std_program', None),
+                                                   ('grader', DEFAULT_GRADER), ('max_workers', -1),
+                                                   ('job_pool', None), ('stop_on_incorrect', None)))
+        input = kwargs['input']
+        std = kwargs['std']
+        std_program = kwargs['std_program']
+        grader = kwargs['grader']
+        max_workers = kwargs['max_workers']
+        job_pool = kwargs['job_pool']
+        if kwargs['stop_on_incorrect'] is not None:
+            log.warn("parameter stop_on_incorrect is deprecated and has no effect.")
+
+        if (max_workers is None or max_workers >= 0) and job_pool is None:
+            max_workers = cls.__normal_max_workers(max_workers)
+            try:
+                from concurrent.futures import ThreadPoolExecutor
+                with ThreadPoolExecutor(max_workers=max_workers) as job_pool:
+                    return cls.program(*programs, input=input, std=std, std_program=std_program, grader=grader, max_workers=max_workers, job_pool=job_pool)
+            except ImportError:
+                pass
+
+        if not isinstance(input, IO):
+            raise TypeError("expect {}, got {}".format(type(IO).__name__, type(input).__name__))
+        input.flush_buffer()
+        input.input_file.seek(0)
+
+        if std_program is not None:
+            def get_std():
+                with open(os.dup(input.input_file.fileno()), 'r', newline='\n') as input_file:
+                    content = make_unicode(subprocess.check_output(std_program, shell=(not list_like(std_program)), stdin=input.input_file, universal_newlines=True))
+                    input_file.seek(0)
+                return content
+            if job_pool is not None:
+                std = job_pool.submit(get_std).result()
+            else:
+                std = get_std()
+        elif std is not None:
+            def get_std():
+                return cls.__process_file(std)[1]
+            if job_pool is not None:
+                std = job_pool.submit(get_std).result()
+            else:
+                std = get_std()
+        else:
+            raise TypeError('program() missing 1 required non-None keyword-only argument: \'std\' or \'std_program\'')
+
+        def do(program_name):
+            timeout = None
+            if list_like(program_name) and len(program_name) == 2 and int_like(program_name[-1]):
+                program_name, timeout = program_name
+            with open(os.dup(input.input_file.fileno()), 'r', newline='\n') as input_file:
+                if timeout is None:
+                    content = make_unicode(subprocess.check_output(program_name, shell=(not list_like(program_name)), stdin=input_file, universal_newlines=True))
+                else:
+                    content = make_unicode(subprocess.check_output(program_name, shell=(not list_like(program_name)), stdin=input_file, universal_newlines=True, timeout=timeout))
+                input_file.seek(0)
+            cls.__compare_two(program_name, content, std, grader)
+
+        if job_pool is not None:
+            job_pool.map(do, programs)
+        else:
+            [x for x in map(do, programs)]

cyaron/consts.py

@@ -1,11 +1,12 @@
+from __future__ import absolute_import
 import math
 import string
 
 """Constants Package.
 Constants:
 ALPHABET_SMALL -> All the lower ascii letters
 ALPHABET_CAPITAL -> All the upper ascii letters
-ALPHABET -> All the upper ascii letters
+ALPHABET -> All the ascii letters
 NUMBERS -> All the numbers(0-9)
 SENTENCE_SEPARATORS -> Includes 70% ",", 20% ";" and 10% ":"
 SENTENCE_TERMINATORS -> Includes 80% "." and 20% "!"
@@ -15,7 +16,9 @@
 
 ALPHABET_SMALL = string.ascii_lowercase
 ALPHABET_CAPITAL = string.ascii_uppercase
-ALPHABET = string.ascii_uppercase
+ALPHABET = ALPHABET_SMALL + ALPHABET_CAPITAL
 NUMBERS = string.digits
 SENTENCE_SEPARATORS = ',,,,,,,;;:' # 70% ',' 20% ';' 10% ':'
 SENTENCE_TERMINATORS = '....!' # 80% '.' 20% '!'
+
+DEFAULT_GRADER = "NOIPStyle"

cyaron/graders/__init__.py

@@ -0,0 +1,4 @@
+from .graderregistry import CYaRonGraders
+
+from .fulltext import fulltext
+from .noipstyle import noipstyle

cyaron/graders/fulltext.py

@@ -0,0 +1,10 @@
+import hashlib
+from .graderregistry import CYaRonGraders
+from .mismatch import HashMismatch
+
+@CYaRonGraders.grader("FullText")
+def fulltext(content, std):
+    content_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()
+    std_hash = hashlib.sha256(std.encode('utf-8')).hexdigest()
+    return (True, None) if content_hash == std_hash else (False, HashMismatch(content, std, content_hash, std_hash))
+

cyaron/graders/graderregistry.py

@@ -0,0 +1,18 @@
+class GraderRegistry:
+    _registry = dict()
+
+    def grader(self, name):
+        def wrapper(func):
+            self._registry[name] = func
+            return func
+
+        return wrapper
+
+    def invoke(self, name, content, std):
+        return self._registry[name](content, std)
+
+    def check(self, name):
+        return name in self._registry
+
+
+CYaRonGraders = GraderRegistry()

cyaron/graders/mismatch.py

@@ -0,0 +1,48 @@
+class Mismatch(ValueError):
+    """exception for content mismatch"""
+    def __init__(self, content, std, *args):
+        """
+        content -> content got
+        std -> content expected
+        """
+        super(Mismatch, self).__init__(content, std, *args)
+        self.content = content
+        self.std = std
+
+class HashMismatch(Mismatch):
+    """exception for hash mismatch"""
+    def __init__(self, content, std, content_hash, std_hash):
+        """
+        content -> content got
+        std -> content expected
+        content_hash -> hash of content
+        std_hash -> hash of std
+        """
+        super(HashMismatch, self).__init__(content, std, content_hash, std_hash)
+        self.content_hash = content_hash
+        self.std_hash = std_hash
+
+    def __str__(self):
+        return "Hash mismatch: read %s, expected %s" % (self.content_hash, self.std_hash)
+
+class TextMismatch(Mismatch):
+    """exception for text mismatch"""
+    def __init__(self, content, std, err_msg, lineno=None, colno=None, content_token=None, std_token=None):
+        """
+        content -> content got
+        std -> content expected
+        err_msg -> error message template like "wrong on line {} col {} read {} expected {}"
+        lineno -> line number
+        colno -> column number
+        content_token -> the token of content mismatch
+        std_token -> the token of std
+        """
+        super(TextMismatch, self).__init__(content, std, err_msg, lineno, colno, content_token, std_token)
+        self.err_msg = err_msg.format(lineno, colno, content_token, std_token)
+        self.lineno = lineno
+        self.colno = colno
+        self.content_token = content_token
+        self.std_token = std_token
+
+    def __str__(self):
+        return self.err_msg