Merge branch 'master' into pr/weilycoder/134

Author: Mr-Python-in-China

.gitignore

@@ -1,6 +1,7 @@
 config.py
 *.in
 *.out
+*.exe
 
 # Created by .ignore support plugin (hsz.mobi)
 ### Python template
@@ -133,5 +134,7 @@ target/
 # Pycharm
 venv/
 
+*.DS_Store
+
 # VS Code
-.vscode/
+.vscode

.pylintrc

@@ -0,0 +1,3 @@
+[MASTER]
+py-version=3.5
+disable=R0902,R0913,R0917

cyaron/__init__.py

@@ -5,17 +5,19 @@
 """
 
 from __future__ import absolute_import
+
+from random import choice, randint, random, randrange, uniform
+
+#from .visual import visualize
+from . import log
+from .compare import Compare
+from .consts import *
+from .graph import Edge, Graph
 from .io import IO
-from .graph import Graph, Edge
-from .string import String
+from .math import *
+from .merger import Merger
+from .polygon import Polygon
 from .sequence import Sequence
+from .string import String
 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

@@ -1,5 +1,6 @@
 from __future__ import absolute_import, print_function
-from cyaron import IO, log
+from .io import IO
+from . import log
 from cyaron.utils import *
 from cyaron.consts import *
 from cyaron.graders import CYaRonGraders
@@ -17,7 +18,7 @@ def __init__(self, name, mismatch):
         self.mismatch = mismatch
 
     def __str__(self):
-        return 'In program: \'{}\'. {}'.format(self.name,self.mismatch)
+        return "In program: '{}'. {}".format(self.name, self.mismatch)
 
 
 class Compare:
@@ -37,7 +38,7 @@ def __process_file(file):
             file.output_file.seek(0)
             return file.output_filename, file.output_file.read()
         else:
-            with open(file, "r", newline='\n') as f:
+            with open(file, "r", newline="\n") as f:
                 return file, f.read()
 
     @staticmethod
@@ -50,26 +51,43 @@ def __normal_max_workers(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:
+        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)
+                    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:
@@ -86,61 +104,118 @@ def do(file):
 
     @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:
+        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)
+                    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__))
+            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))
+                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\'')
+            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]):
+            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:
+            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))
+                    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))
+                    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)
 

cyaron/graph.py

@@ -43,6 +43,15 @@ def __init__(self, point_count, directed=False):
         """
         self.directed = directed
         self.edges = [[] for i in range(point_count + 1)]
+    
+    def edge_count(self):
+        """edge_count(self) -> int
+            Return the count of the edges in the graph.
+        """
+        cnt = sum(len(node) for node in self.edges)
+        if not self.directed:
+            cnt //= 2
+        return cnt
 
     def to_matrix(self, **kwargs):
         """to_matrix(self, **kwargs) -> list[list[Any]]
@@ -280,6 +289,11 @@ def graph(point_count, edge_count, **kwargs):
         directed = kwargs.get("directed", False)
         self_loop = kwargs.get("self_loop", True)
         repeated_edges = kwargs.get("repeated_edges", True)
+        if not repeated_edges:
+            max_edge =  Graph._calc_max_edge(point_count, directed, self_loop)
+            if edge_count > max_edge:
+                raise Exception("the number of edges of this kind of graph which has %d vertexes must be less than or equal to %d." % (point_count, max_edge))
+
         weight_limit = kwargs.get("weight_limit", (1, 1))
         if not list_like(weight_limit):
             weight_limit = (1, weight_limit)
@@ -311,7 +325,7 @@ def graph(point_count, edge_count, **kwargs):
     @staticmethod
     def DAG(point_count, edge_count, **kwargs):
         """DAG(point_count, edge_count, **kwargs) -> Graph
-               Factory method. Return a graph with point_count vertexes and edge_count edges.
+               Factory method. Return a directed connected graph with point_count vertexes and edge_count edges.
                int point_count -> the count of vertexes
                int edge_count -> the count of edges
                **kwargs(Keyword args):
@@ -332,6 +346,11 @@ def DAG(point_count, edge_count, **kwargs):
         self_loop = kwargs.get("self_loop", False)  # DAG default has no loop
         repeated_edges = kwargs.get("repeated_edges", True)
         loop = kwargs.get("loop", False)
+        if not repeated_edges:
+            max_edge =  Graph._calc_max_edge(point_count, not loop, self_loop)
+            if edge_count > max_edge:
+                raise Exception("the number of edges of this kind of graph which has %d vertexes must be less than or equal to %d." % (point_count, max_edge))
+
         weight_limit = kwargs.get("weight_limit", (1, 1))
         if not list_like(weight_limit):
             weight_limit = (1, weight_limit)
@@ -377,7 +396,7 @@ def DAG(point_count, edge_count, **kwargs):
     @staticmethod
     def UDAG(point_count, edge_count, **kwargs):
         """UDAG(point_count, edge_count, **kwargs) -> Graph
-               Factory method. Return a graph with point_count vertexes and edge_count edges.
+               Factory method. Return a undirected connected graph with point_count vertexes and edge_count edges.
                int point_count -> the count of vertexes
                int edge_count -> the count of edges
                **kwargs(Keyword args):
@@ -396,6 +415,11 @@ def UDAG(point_count, edge_count, **kwargs):
 
         self_loop = kwargs.get("self_loop", True)
         repeated_edges = kwargs.get("repeated_edges", True)
+        if not repeated_edges:
+            max_edge =  Graph._calc_max_edge(point_count, False, self_loop)
+            if edge_count > max_edge:
+                raise Exception("the number of edges of this kind of graph which has %d vertexes must be less than or equal to %d." % (point_count, max_edge))
+
         weight_limit = kwargs.get("weight_limit", (1, 1))
         if not list_like(weight_limit):
             weight_limit = (1, weight_limit)
@@ -430,6 +454,18 @@ def UDAG(point_count, edge_count, **kwargs):
             i += 1
 
         return graph
+    
+    @staticmethod
+    def connected(point_count, edge_count, directed=False, **kwargs):
+        """connected(point_count, edge_count, **kwargs) -> Graph
+           Factory method. Return a connected graph with point_count vertexes
+           int point_count -> the count of vertexes
+           bool directed -> whether the graph is directed
+        """
+        if directed:
+            return Graph.DAG(point_count, edge_count, **kwargs)
+        else:
+            return Graph.UDAG(point_count, edge_count, **kwargs)
 
     @staticmethod
     def hack_spfa(point_count, **kwargs):
@@ -481,6 +517,15 @@ def hack_spfa(point_count, **kwargs):
             graph.add_edge(u, v, weight=weight_gen())
 
         return graph
+    
+    @staticmethod
+    def _calc_max_edge(point_count, directed, self_loop):
+        max_edge = point_count * (point_count - 1)
+        if not directed:
+            max_edge //= 2
+        if self_loop:
+            max_edge += point_count
+        return max_edge
 
 
 T = TypeVar('T')