Version bump to v0.1.3: A string generator; Fixed several bugs

Author: lin-toto

cyaron/__init__.py

@@ -1,4 +1,6 @@
 from .io import IO
 from .graph import Graph, Edge
+from .str import String
 from .utils import *
+from .consts import *
 from random import randint, randrange, uniform, choice, random

cyaron/consts.py

@@ -0,0 +1,13 @@
+import math
+import string
+
+PI = math.pi
+E = math.e
+
+ALPHABET_SMALL = string.ascii_lowercase
+ALPHABET_CAPITAL = string.ascii_uppercase
+ALPHABET = string.ascii_uppercase
+NUMBERS = string.digits
+SENTENCE_SEPARATORS = ',,,,,,,;;:' # 70% ',' 20% ';' 10% ':'
+SENTENCE_TERMINATORS = '....!' # 80% '.' 20% '!'
+

cyaron/graph.py

@@ -1,3 +1,4 @@
+from .utils import *
 import random
 
 
@@ -27,7 +28,7 @@ def to_str(self, **kwargs):
             edge_buf = []
             for edge in self.iterate_edges():
                 edge_buf.append(
-                    Edge(tmp[edge.start], tmp[edge.end], edge.weight))
+                    Edge(new_node_id[edge.start], new_node_id[edge.end], edge.weight))
             random.shuffle(edge_buf)
             for edge in edge_buf:
                 if not self.directed and random.randint(0, 1) == 0:
@@ -68,7 +69,7 @@ def flower(point_count, **kwargs):
     def tree(point_count, chain=0, flower=0, **kwargs):
         directed = kwargs.get("directed", False)
         weight_limit = kwargs.get("weight_limit", (1, 1))
-        if not isinstance(weight_limit, tuple):
+        if not list_like(weight_limit):
             weight_limit = (1, weight_limit)
         weight_gen = kwargs.get(
             "weight_gen", lambda: random.randint(
@@ -102,7 +103,7 @@ def tree(point_count, chain=0, flower=0, **kwargs):
     def binary_tree(point_count, left=0, right=0, **kwargs):
         directed = kwargs.get("directed", False)
         weight_limit = kwargs.get("weight_limit", (1, 1))
-        if not isinstance(weight_limit, tuple):
+        if not list_like(weight_limit):
             weight_limit = (1, weight_limit)
         weight_gen = kwargs.get(
             "weight_gen", lambda: random.randint(
@@ -117,7 +118,7 @@ def binary_tree(point_count, left=0, right=0, **kwargs):
         can_right = {1}
         graph = Graph(point_count, directed)
         for i in range(2, point_count + 1):
-            edge_pos = random.uniform(0, 1)
+            edge_pos = random.random()
             node = 0
             # Left
             if edge_pos < left or left + right < edge_pos <= (1.0 - left - right) / 2:
@@ -137,7 +138,7 @@ def binary_tree(point_count, left=0, right=0, **kwargs):
     def graph(point_count, edge_count, **kwargs):
         directed = kwargs.get("directed", False)
         weight_limit = kwargs.get("weight_limit", (1, 1))
-        if not isinstance(weight_limit, tuple):
+        if not list_like(weight_limit):
             weight_limit = (1, weight_limit)
         weight_gen = kwargs.get(
             "weight_gen", lambda: random.randint(
@@ -155,7 +156,7 @@ def hack_spfa(point_count, **kwargs):
         directed = kwargs.get("directed", False)
         extraedg = kwargs.get("extra_edge", 2)
         weight_limit = kwargs.get("weight_limit", (1, 1))
-        if not isinstance(weight_limit, tuple):
+        if not list_like(weight_limit):
             weight_limit = (1, weight_limit)
         weight_gen = kwargs.get(
             "weight_gen", lambda: random.randint(

cyaron/io.py

@@ -1,3 +1,4 @@
+from .utils import *
 import subprocess
 
 

cyaron/str.py

@@ -0,0 +1,96 @@
+from .consts import ALPHABET_SMALL, SENTENCE_SEPARATORS, SENTENCE_TERMINATORS
+from .utils import *
+import random
+
+
+class String:
+    @staticmethod
+    def random(length_range, **kwargs):
+        length = length_range
+        if list_like(length_range):
+            length = random.randint(length_range[0], length_range[1])
+        charset = kwargs.get("charset", ALPHABET_SMALL)
+
+        if list_like(charset):
+            return random.choice(charset)
+        else:
+            return "".join(random.choice(charset) for i in range(length))
+
+    @staticmethod
+    def random_sentence(word_count_range, **kwargs):
+        word_count = word_count_range
+        if list_like(word_count_range):
+            word_count = random.randint(word_count_range[0], word_count_range[1])
+
+        word_length_range = kwargs.get("word_length_range", (3, 8))
+        first_letter_uppercase = kwargs.get("first_letter_uppercase", True)
+        charset = kwargs.get("charset", ALPHABET_SMALL)
+
+        word_separators = kwargs.get("word_separators", " ")
+        if word_separators is None or len(word_separators) == 0:
+            word_separators = [""]
+
+        sentence_terminators = kwargs.get("sentence_terminators", SENTENCE_TERMINATORS)
+        if sentence_terminators is None or len(sentence_terminators) == 0:
+            sentence_terminators = [""]
+
+        words = []
+        for i in range(word_count):
+            words.append(String.random(word_length_range, charset=charset))
+        if first_letter_uppercase:
+            words[0] = words[0].capitalize()
+
+        # We cannot just `sentence_separators.join()` here
+        # since we want to randomly select one on each join
+        sentence = reduce(lambda x, y: x + random.choice(word_separators) + y, words)
+        sentence += random.choice(sentence_terminators)
+
+        return sentence
+
+    @staticmethod
+    def random_paragraph(sentence_count_range, **kwargs):
+        sentence_count = sentence_count_range
+        if list_like(sentence_count_range):
+            sentence_count = random.randint(sentence_count_range[0], sentence_count_range[1])
+
+        first_letter_uppercase = kwargs.get("first_letter_uppercase", True)
+        kwargs["first_letter_uppercase"] = False
+
+        termination_percentage = kwargs.get("termination_percentage", 0.3)
+        if not 0 <= termination_percentage <= 1:
+            raise Exception("Invalid termination_percentage")
+
+        sentence_joiners = kwargs.get("sentence_joiners", " ")
+        if sentence_joiners is None or len(sentence_joiners) == 0:
+            sentence_joiners = [""]
+
+        sentence_separators = kwargs.get("sentence_separators", SENTENCE_SEPARATORS)
+        if sentence_separators is None or len(sentence_separators) == 0:
+            sentence_separators = [""]
+
+        sentence_terminators = kwargs.get("sentence_terminators", SENTENCE_TERMINATORS)
+        if sentence_terminators is None or len(sentence_terminators) == 0:
+            sentence_terminators = [""]
+        kwargs["sentence_terminators"] = None
+
+        sentences = []
+        capitalize_next_sentence = True
+        for i in range(sentence_count):
+            string = String.random_sentence(**kwargs)
+            sep_or_term = random.random()
+
+            if capitalize_next_sentence and first_letter_uppercase:
+                string = string.capitalize()
+
+            if sep_or_term < termination_percentage or i == sentence_count - 1:
+                string += random.choice(sentence_terminators)
+                capitalize_next_sentence = True
+            else:
+                string += random.choice(sentence_separators)
+                capitalize_next_sentence = False
+
+            sentences.append(string)
+
+        paragraph = reduce(lambda x, y: x + random.choice(sentence_joiners) + y, sentences)
+        return paragraph
+

cyaron/tests/general_test.py

@@ -1,3 +1,5 @@
 def ati(array):
     return [int(i) for i in array]
 
+def list_like(data):
+    return isinstance(data, tuple) or isinstance(data, list)