Exemplo n.º 1
0
def main(text=None):
    sq = SequenceGenerator(text=text)
    sq.parse()
    tokens = sq.token_list
    bullets = []
    text_line = ""
    alignment_space = ""
    last_tok_type = ""
    create_line_shrink(token_list=tokens)
    for token in tokens:
        if token.tok_type == Token.STARS:
            bullets.append(token.token)
            last_tok_type = Token.STARS
            alignment_space = ""
        elif token.tok_type == Token.DOTS:
            alignment_space = get_alignment_symbol_and_space(token=token)
            last_tok_type = token.tok_type
        elif token.tok_type == Token.TEXTS:
            if last_tok_type == Token.STARS:
                bullet = get_bullet(create_bullet(bullets))
                text_line = bullet + " " + token.token
            elif last_tok_type == Token.DOTS:
                text_line = alignment_space[1] + alignment_space[
                    0] + " " + token.token
            elif last_tok_type == Token.TEXTS:
                text_line = alignment_space[1] + "  " + token.token
            last_tok_type = token.tok_type
            text_line = text_line.strip('\n')
            print(text_line)
Exemplo n.º 2
0
 def shuffle_audio(self, minLength=1, maxLength=1, times=1):
     # logging.debug(self.clips_audio)
     GeneratorAudio = SequenceGenerator(minLength, maxLength)
     for i in self.clips_audio:
         self.clips_audio
         for j in range(0, times):
             self.sequences_audio.append(GeneratorAudio.rand_sequence(i))
     random.shuffle(self.sequences_audio)
Exemplo n.º 3
0
 def shuffle_images(self, minLength=1, maxLength=1, times=1):
     # logging.debug("images are: {}".format(self.clips_video))
     self.clips_video.append(self.Scanner.scan_images(maxLength))
     GeneratorImages = SequenceGenerator(minLength, maxLength)
     for i in self.clips_video:
         for j in range(0, times):
             self.sequences_video.append(GeneratorImages.rand_sequence(i))
     random.shuffle(self.sequences_video)
Exemplo n.º 4
0
 def chop_sequences(self, timecodes):
     if (len(self.sequences_video) > 0):
         with open(timecodes) as chopFile:
             chopStr = chopFile.read()
             chopData = json.loads(chopStr)
         GeneratorVideo = SequenceGenerator()
         for i in self.clips_video:
             for start, end in chopData.items():
                 self.sequences_video.insert(
                     0, GeneratorVideo.sequence(i, start, end))
Exemplo n.º 5
0
def makeSeq(n,tree):
    seq_dir = 'c:\\seqgen\\'
    seq_tree_dir = 'c:\\seqgen\\' + tree + '\\'
    for i in range(1,n+1):
        shutil.copyfile(seq_dir + tree + ".txt", seq_dir + tree + str(i) + ".txt")
        if not os.path.exists(seq_dir + tree + "\\" + tree + str(i) +  ".nex"):
            tree_gen = SequenceGenerator(tree + str(i),"c:\\seqgen\\" + tree + str(i) +  ".txt")
            tree_gen.runseq_gen()
            shutil.copyfile(seq_dir + tree + str(i) + ".txt", seq_dir + tree + str(i) + "\\" + tree + str(i) + ".txt")
        else:
            print("SeqGen already run for tree " + str(i) + " - skipping sequence generation.")
Exemplo n.º 6
0
 def chop_clips(self, timecodes):
     # if (hasattr(self, 'sequences_video')):
     if (len(self.clips_video) > 0):
         clips_video_chop = []
         with open(timecodes) as chopFile:
             chopStr = chopFile.read()
             chopData = json.loads(chopStr)
         GeneratorVideo = SequenceGenerator()
         for i, clip in enumerate(self.clips_video):
             for start, end in chopData.items():
                 try:
                     clips_video_chop.append(
                         GeneratorVideo.sequence(clip, start, end))
                 except Exception as e:
                     logging.info(
                         "An error in function {} occured: '{}'".format(
                             sys._getframe().f_code.co_name, e))
         self.clips_video = clips_video_chop
Exemplo n.º 7
0
	def __parseArguments(self):
		
		parser = argparse.ArgumentParser(
			description="Password generator", 
			epilog="\nExample:\n " + str(sys.argv[0]) + " ")
		parser.add_argument("-v", "--verbose", action="store_true", help="Turn on verbose mode; additionnal messages are going to be printed on stdout.")
		parser.add_argument("-d", "--debug", action="store_true", help="Debug mode; all messages printed on stdout, generated passwords are printed on screen as well.")
		parser.add_argument("-n", "--letter-number", type=int, help="Number of letters for the passwords to generate.", required=True)
		parser.add_argument("-m", "--password-count", type=int, help="Number of passwords that are going to be generated. Default: no limit.")
		parser.add_argument("-s", "--maximum-storage-size", type=str, help="Maximum storage size the password can use. Support K, M, G, T format (ex: 1G = 1073741824 bytes). Default: no limit.")
		parser.add_argument("-w", "--words-dictionnary-path", type=str, action="append", help="Load words from dictionnary at given path (see Format). Can be given multiple time to load multiple files.")
		parser.add_argument("-f", "--letters-by-word-frequency-path", type=str, action="append", help="Load number of letter in a word frequency from path (see Format). Can be given multiple time to load multiple files.")
		parser.add_argument("-o", "--write-output-to", type=str, action="append", help="Write output to given path. Can be given multiple time to write to multiple path at once.")
		
		parser.add_argument("--logging-levels", type=str, help="Use given logging level instead of default ones. Format is 'N1,N2,N3' where N1 stdout level, N2 stderr level and N3 exit level (Ex:'2,3,4' or 'WARNING,ERROR,CRITICAL')")
		parser.add_argument("--forbid-duplicate", action="store_false", help="Forbid duplicate words when loading dictionnaries and/or letters frequency; raise error if a word is present in more than one dictionnary at a time.")
		parser.add_argument("--append-to-output", action="store_false", help="Append to output file(s) instead of starting anew.")
		
		args = parser.parse_args()
		
		# Create logger first as everyone need it
		self._loggerObj = self.__createLogger(args)
		# Create dictionnary object
		self._wordsLoaderObj = self._createDictionnaryLoader(args, self._loggerObj)
		# Create letter frequency loader
		self._letterFreqObj = self._createLetterFrequencyLoader(args, self._loggerObj)
		# Create fuzzers loader
		self._fuzzerLoaderObj = self._createFuzzer(args, self._loggerObj)
		# Create writer controller
		self._writerCtrlObj = self._createWriters(args, self._loggerObj)
		
		# Letter number is given straight
		lettersNumber = args.letter_number
		# Number of password to generate (if any)
		passCount = self._parsePasswordCount(args, self._loggerObj)
		# Storage size limit (if any)
		storageSizeLimit = self._parseSizeLimit(args, self._loggerObj)
		
		# This (finally) create our generator
		generator = SequenceGenerator(loggerObj=self._loggerObj, 
		                        	dictionnaryLoaderObj=self._wordsLoaderObj,
		                        	fuzzerObj=self._fuzzerLoaderObj,
		                        	writerObj=self._writerCtrlObj,
		                        	numberOfLetters=lettersNumber,
		                        	lettersDistributionFrequencyObj=self._letterFreqObj,
		                        	maximumNumberOfSequences=passCount,
		                        	maximumBytesSizeForAllSequences=storageSizeLimit)
		
		return generator
Exemplo n.º 8
0
from BayesExtract import *
from my_helper import *
import shutil
from make_rMDSscript import make_rMDSscript

if __name__ == '__main__':
    tree = ""
    #tree = "basenew" + "_raxml"
    tree_data = "\\" + tree
    seq_dir = 'c:\\seqgen\\'
    seq_tree_dir = 'c:\\seqgen\\' + tree + '\\'
    bayes_exe = 'mrbayes_x64.exe'
    
    
    if not os.path.exists(seq_dir + tree + "\\" + tree + ".nex"):
        tree_gen = SequenceGenerator(tree,"c:\\seqgen\\" + tree + ".txt")
        tree_gen.runseq_gen()
    else:
        print("SeqGen already run - skipping sequence generation.")
    
    # add code to move Mr. Bayes to the new SeqDir
    
    # create Mr. Bayes driver
    
    if not os.path.exists(seq_dir + tree + "\\" + tree + "-command.nex"):
        outfile = open(seq_tree_dir + tree + "-command.nex",'w')
        outfile.write("#NEXUS\n")
        outfile.write("\n")
        outfile.write("begin mrbayes;\n")
        outfile.write("\t" + "set autoclose=yes nowarn=yes;\n")
        outfile.write("\t" + "execute " + tree + ".nex;\n")
Exemplo n.º 9
0
 def shuffle_video(self, minLength=1, maxLength=1, times=1):
     GeneratorVideo = SequenceGenerator(minLength, maxLength)
     for i in self.Scanner.clips_video:
         for j in range(0, times):
             self.sequences_video.append(GeneratorVideo.rand_sequence(i))
     random.shuffle(self.sequences_video)