Example #1
0
    def __init__(self):
        # The actual workers
        self.maker = Maker()
        self.tex = Latex(self.maker)
        self.maker.dep_append(self.tex)

        # What to do
        self.backend = "pdftex"
        self.format = "pdf"
        self.index_style = ""
        self.batch = 1
        self.encoding = "latin-1"
        self.texpost = ""
        self.options = ""
Example #2
0
 def __init__(self, collection, clazz=None, type_bindings=None):
     self.collection = collection
     self.maker =  Maker(type_bindings=type_bindings,
         default_type=clazz,
         object_descriptor_resolver=self)
     self.database = collection.database
     self.name = collection.name
Example #3
0
    def create_objects(self, test_directory):
        """Traverses the XML structure and creates test objects

        Arguments:
        test_directory - The test directory.
        """
        for element in self.root:
            if element.tag == 'maker':
                self.tests.append(Maker(element, test_directory))
            if element.tag == 'merge':
                self.tests.append(Merge(element, test_directory))
    def __init__(self, logLevel=LOGLEVEL):
        ''' Launch CLI'''

        self.logger = logging.getLogger("HTML5kKaraokeMaker")
        self.logger.setLevel(logLevel)

        if self.readCli():
            self.maker = Maker(self.args.webpath,self.args.datapath)
            self.maker.make()
            self.saveFile()
        else:
            print(_("Interface error"))
Example #5
0
    def __init__(self):
        # The actual workers
        self.maker = Maker()
        self.tex = Latex(self.maker)
        self.maker.dep_append(self.tex)

        # What to do
        self.backend = "pdftex"
        self.format = "pdf"
        self.index_style = ""
        self.batch = 1
        self.encoding = "latin-1"
        self.texpost = ""
Example #6
0
def main():
    print()
    if args.image:
        print('1. Read image sheet')
        print('Path : ' + args.image)
    elif args.text:
        print('1. Read text sheet')
        print('Path : ' + args.text)
        sheet_parser = Parser(args.text)
    else:
        print('Needs input')
        exit(1)
    print()

    print('2. Parse sheet')
    try:
        sheet = sheet_parser.parse()
    except SheetParserError as err:
        expression, message = err.args
        print()
        print('!! Sheet Parser Error !!')
        print(expression)
        print(message)
        print()
        exit(1)
    else:
        print('parse success')
        print('Print sheet...')
        print(sheet)
    print()

    print('3. Load videos')
    print()

    print('4. Generate music video.')
    music = Maker(sheet, args.output)
    music.make()
    print()
Example #7
0
class ObjectCollection(object):

    ###########################################################################
    def __init__(self, collection, clazz=None, type_bindings=None):
        self.collection = collection
        self.maker =  Maker(type_bindings=type_bindings,
            default_type=clazz,
            object_descriptor_resolver=self)
        self.database = collection.database
        self.name = collection.name

    ###########################################################################
    # Object descriptor Resolver implementations
    ###########################################################################


    ###########################################################################
    def is_datum_descriptor(self, value):
        return type(value) is DBRef

    ###########################################################################
    def resolve_datum_descriptor(self, desc):
        db_ref = desc
        ref_collection_name = db_ref.collection
        ref_collection = self.database[ref_collection_name]
        return ref_collection.find_one({"_id": db_ref.id})

    ###########################################################################
    # queries
    ###########################################################################
    @robustify(max_attempts=5, retry_interval=2,
               do_on_exception=_raise_if_not_autoreconnect,
               do_on_failure=_raise_on_failure)
    def find(self, query=None, sort=None, limit=None):
        if query is None or (query.__class__ == dict):
            result = self.find_iter( query, sort, limit )
            # TODO: this is bad for large result sets potentially
            return [ d for d in result ]
        else:
            return self.find_one({ "_id" : query }, sort=sort)

    ###########################################################################
    def find_iter(self, query=None, sort=None, limit=None):
        if query is None or (query.__class__ == dict):
            if limit is None:
                documents = self.collection.find(query, sort=sort)
            else:
                documents = self.collection.find(query, sort=sort, limit=limit)

            for doc in documents:
                yield self.make_obj( doc )
        else:
            # assume query is _id and do _id lookup
            yield self.find_one({ "_id" : query }, sort=sort)

    ###########################################################################
    @robustify(max_attempts=5, retry_interval=2,
               do_on_exception=_raise_if_not_autoreconnect,
               do_on_failure=_raise_on_failure)
    def find_one(self, query=None, sort=None):
        result = self.collection.find_one(query, sort=sort)
        return self.make_obj( result )

    ###########################################################################
    @robustify(max_attempts=5, retry_interval=2,
               do_on_exception=_raise_if_not_autoreconnect,
               do_on_failure=_raise_on_failure)
    def find_and_modify(self, query=None, update=None, sort=None, **kwargs):
        result = self.collection.find_and_modify(query=query, update=update,
                                                 sort=sort, **kwargs)
        return self.make_obj(result)

    ###########################################################################
    @robustify(max_attempts=5, retry_interval=2,
               do_on_exception=_raise_if_not_autoreconnect,
               do_on_failure=_raise_on_failure)
    def update(self, spec, document, upsert=False, manipulate=False,
                     safe=None, multi=False, check_keys=True, **kwargs):
        self.collection.update(spec=spec, document=document, upsert=upsert,
                               manipulate=manipulate, safe=safe, multi=multi,
                               check_keys=check_keys, **kwargs)

    ###########################################################################
    @robustify(max_attempts=5, retry_interval=2,
               do_on_exception=_raise_if_not_autoreconnect,
               do_on_failure=_raise_on_failure)
    def save_document(self, document):
        self.collection.save(document)

    ###########################################################################
    def make_obj( self, doc ):
        return self.maker.make(doc)

    ###########################################################################
    def insert(self, object):
        pass

    ###########################################################################
    def save(self, object):
        pass

    ###########################################################################
    def remove(self, object):
        pass

    ###########################################################################
    @robustify(max_attempts=5, retry_interval=2,
               do_on_exception=_raise_if_not_autoreconnect,
               do_on_failure=_raise_on_failure)
    def remove_by_id(self, id):
        self.collection.remove({"_id": id})
Example #8
0
#!/usr/bin/env python
#-*- coding:utf-8 -*-

from user import User
from maker import Maker
from shareInt import ShareInt

shareObject=ShareInt()
user1=User("user1",shareObject)
maker1=Maker("maker1",shareObject)

user1.start()
maker1.start()

user1.join()
maker1.join()

user1.display()

print "main threading over!"
Example #9
0
from maker import Maker
from winner import Winner

pygame.init()

pygame.display.set_caption('Dreidel Blades')

screen = pygame.display.set_mode(
    # size=(640, 480),
    # size=(1280, 720),
    size=(1366, 768),
    # size=(1920, 1080),
    # flags=pygame.FULLSCREEN,
)

maker = Maker(screen)

choose = Choose(screen)
clock = pygame.time.Clock()

active = choose

lastGameEndTime = None
gameOverTime = None
while True:

    if isinstance(active, Choose):
        if active.startGameWith is not None:
            imgPath, stats = active.startGameWith

            # game = Game(screen)
Example #10
0
class LatexBuilder:
    """
    Main (g)rubber wrapper hiding all the internals and compiling the
    required tex file.
    """
    def __init__(self):
        # The actual workers
        self.maker = Maker()
        self.tex = Latex(self.maker)
        self.maker.dep_append(self.tex)

        # What to do
        self.backend = "pdftex"
        self.format = "pdf"
        self.index_style = ""
        self.batch = 1
        self.encoding = "latin-1"
        self.texpost = ""
        self.options = ""

    def set_format(self, format):
        # Just record it
        self.format = format

    def set_backend(self, backend):
        self.backend = backend

    def set_index_style(self, index_style):
        self.index_style = index_style

    def compile(self, source):
        self.tex.batch = self.batch
        self.tex.encoding = self.encoding
        self.tex.set_source(source)
        if self.options:
            self.tex.opts += shlex.split(self.options)

        # Load the modules needed to produce the expected output format
        if (self.format == "pdf"):
            if (self.backend == "pdftex"):
                self.tex.modules.register("pdftex")
            elif (self.backend == "xetex"):
                self.tex.modules.register("xetex")
            else:
                self.tex.modules.register("dvips")
                self.tex.modules.register("ps2pdf")
        elif (self.format == "ps"):
            self.tex.modules.register("dvips")

        # Now load other the modules required to compile this file
        self.tex.prepare()

        # Set the index style
        if self.index_style and self.tex.modules.has_key("makeidx"):
            idx = self.tex.modules["makeidx"]
            idx.style = self.index_style

        # Let's go...
        rc = self.maker.make()
        if rc != 0:
            raise OSError("%s compilation failed" % self.tex.program)

        # Post process script to call?
        if not (self.texpost):
            return

        os.environ["LATEX"] = self.tex.program
        rc = subprocess.call([self.texpost, source], stdout=msg.stdout)
        if rc == 1:
            return
        if rc != 0:
            raise OSError("%s texpost failed" % self.texpost)

        rc = self.maker.make(force=1)
        if rc != 0:
            raise OSError("%s post compilation failed" % self.tex.program)

    def clean(self):
        self.tex.clean()
        self.reinit()

    def reinit(self):
        self.tex.reinit()
        self.maker.reinit()
        self.maker.dep_append(self.tex)

    def print_errors(self):
        msg.display_all(self.tex.get_errors(), writer=msg.write_stderr)

    def print_misschars(self):
        # Show the characters not handled by fonts
        self.tex.print_misschars()
import numpy as np
from copy import copy

space = np.random.randn(4)*0.18+1
print space
img_all = []
label_all= []
for s in space:
    require = copy(RE)
    require[0] = [ int(round(n*s)) for n in require[0] ]
    require[1] = [ int(round(n*s)) for n in require[1] ]
    center_scale = np.random.choice(space, 1)
    center = (int(round(128*center_scale)), int(round(128*center_scale)))
    print center, require

    m = Maker(require)
    a = np.random.randint(360)
    m.generate(5, a, center=center)
        
    img = [ i[None,None,None,:,:] for i in m.imgs ]
    label = [ l[None,None,None,:,:] for l in m.labels]
    img = np.concatenate(img, axis=0)
    label = np.concatenate(label, axis=0)
    img_all.append(img)
    label_all.append(label)

img_all = np.concatenate(img_all, axis=1)
img_all =   np.transpose(img_all, (1,0,2,3,4))
label_all = np.concatenate(label_all,axis=1)
label_all = np.transpose(label_all, (1,0,2,3,4))
Example #12
0

pairs = [{"Initsuccess": False, "pair": ' ', "maker": 0, "asset":'GDEX.BTC', "base":'CNY', "priceuplimit": 200000, "pricedownlimit": 10000, "Gaprate": 0.01, "spreadrate": 0.008, "size":4, "amount": 5000}]
pairs.append ({"Initsuccess": False, "pair": ' ', "maker": 0, "asset":'GDEX.ETH', "base":'CNY', "priceuplimit": 20000, "pricedownlimit": 1000, "Gaprate": 0.01, "spreadrate": 0.008, "size":4, "amount": 5000})
pairs.append({"Initsuccess": False, "pair": ' ', "maker": 0, "asset":'GDEX.EOS', "base":'CNY', "priceuplimit": 400, "pricedownlimit": 10, "Gaprate": 0.01, "spreadrate": 0.008, "size":4, "amount": 5000})
pairs.append({"Initsuccess": False, "pair": ' ', "maker": 0, "asset":'GDEX.NEO', "base":'CNY', "priceuplimit": 4000, "pricedownlimit": 100, "Gaprate": 0.011, "spreadrate": 0.0088, "size":6, "amount": 5000})
pairs.append({"Initsuccess": False, "pair": ' ', "maker": 0, "asset":'GDEX.GAS', "base":'CNY', "priceuplimit": 1000, "pricedownlimit": 70, "Gaprate": 0.01, "spreadrate": 0.008, "size":6, "amount": 5000})
pairs.append({"Initsuccess": False, "pair": ' ', "maker": 0, "asset":'GDEX.QTUM', "base":'CNY', "priceuplimit": 1000, "pricedownlimit": 50, "Gaprate": 0.01, "spreadrate": 0.008, "size":6, "amount": 5000})
pairs.append({"Initsuccess": False, "pair": ' ', "maker": 0, "asset":'GDEX.ATN', "base":'CNY', "priceuplimit": 40, "pricedownlimit": 1, "Gaprate": 0.01, "spreadrate": 0.008, "size":4, "amount": 5000})
maker = {}

for pair in pairs:
     pair['pair'] = pair['base']+"/"+pair['asset']
     print('pleae input the middle price for ' + pair['pair'] + ':')
     inputprice = float(input())
     pair['maker'] = Maker(globalconfig, inputprice, ex='dex', asset=pair['asset'], base=pair['base'], priceuplimit=pair['priceuplimit'], pricedownlimit=pair['pricedownlimit'],
                 Gaprate=pair['Gaprate'], spreadrate=pair['spreadrate'], size=pair['size'], amount=pair['amount'])


while True:
    for pair in pairs:

        if not pair['Initsuccess']:
            try:
                pair['Initsuccess'] = pair['maker'].InitOrderPlace()
            except Exception as e:
                print(pair['pair'] + "failed to initialize orders, error:", e)
                pair['Initsuccess'] = False
                time.sleep(5)
        if pair['Initsuccess']:
            today = datetime.now()
            yesterday = today + timedelta(hours=-24)
Example #13
0
from maker import Maker, Recipe, Player, Actions

if __name__ == '__main__':

    r = Recipe(name='Crimson Cider')
    r.update_fromdb()

    p = Player(80, 1500, 1350, 300)
    m = Maker(recipe=r, player=p)
    print(m.step, m.durability, m.progress, m.quality, m.player.cp)

    action_rotation = [
        Actions.REFLECT,
        Actions.GREAT_STRIDES,
        Actions.INNOVATION,
        Actions.OBSERVE,
        Actions.BASIC_TOUCH,
        Actions.STANDARD_TOUCH,
        Actions.PREPARATORY_TOUCH,
        Actions.BYREGOTS_BLESSING,
        # Actions.CAREFUL_SYNTHESIS,
        # Actions.VENERATION,
        # Actions.GROUNDWORK
    ]
    print(p.available_actions())
    p.check_rotation(action_rotation)

    for action in action_rotation:
        getattr(m, action.value.function)()
Example #14
0
class LatexBuilder:
    """
    Main (g)rubber wrapper hiding all the internals and compiling the
    required tex file.
    """
    def __init__(self):
        # The actual workers
        self.maker = Maker()
        self.tex = Latex(self.maker)
        self.maker.dep_append(self.tex)

        # What to do
        self.backend = "pdftex"
        self.format = "pdf"
        self.index_style = ""
        self.batch = 1
        self.encoding = "latin-1"
        self.texpost = ""

    def set_format(self, format):
        # Just record it
        self.format = format

    def set_backend(self, backend):
        self.backend = backend

    def set_index_style(self, index_style):
        self.index_style = index_style

    def compile(self, source):
        self.tex.batch = self.batch
        self.tex.encoding = self.encoding
        self.tex.set_source(source)

        # Load the modules needed to produce the expected output format
        if (self.format == "pdf"):
            if (self.backend == "pdftex"):
                self.tex.modules.register("pdftex")
            elif (self.backend == "xetex"):
                self.tex.modules.register("xetex")
            else:
                self.tex.modules.register("dvips")
                self.tex.modules.register("ps2pdf")
        elif (self.format == "ps"):
            self.tex.modules.register("dvips")

        # Now load other the modules required to compile this file
        self.tex.prepare()

        # Set the index style
        if self.index_style and self.tex.modules.has_key("makeidx"):
            idx = self.tex.modules["makeidx"]
            idx.style = self.index_style

        # Let's go...
        rc = self.maker.make()
        if rc != 0:
            raise OSError("%s compilation failed" % self.tex.program)

        # Post process script to call?
        if not(self.texpost):
            return

        os.environ["LATEX"] = self.tex.program
        rc = subprocess.call([self.texpost, source], stdout=msg.stdout)
        if rc == 1:
            return
        if rc != 0:
            raise OSError("%s texpost failed" % self.texpost)

        rc = self.maker.make(force=1)
        if rc != 0:
            raise OSError("%s post compilation failed" % self.tex.program)

    def clean(self):
        self.tex.clean()
        self.reinit()

    def reinit(self):
        self.tex.reinit()
        self.maker.reinit()
        self.maker.dep_append(self.tex)

    def print_errors(self):
        msg.display_all(self.tex.get_errors(), writer=msg.write_stderr)
class HTML5kKaraokeMaker(object):

    "CLI interface of HTML5kKaraokeMaker"

    def readCli(self):
        '''CLI:Argument parser'''

        parser = argparse.ArgumentParser()
        parser.add_argument(
            '-p',
            '--webpath',
            help=_("use a local web path file"),
            default=D_WEB_DIR
        )
        parser.add_argument(
            '-d',
            '--datapath',
            help=_("use a local data path file"),
            default=D_DATA_DIR
        )
        parser.add_argument(
            '-o',
            '--output',
            help=_("choose a specific output directory"),
            default=D_WEB_DIR
        )
        self.args = parser.parse_args()
        return True

    def __init__(self, logLevel=LOGLEVEL):
        ''' Launch CLI'''

        self.logger = logging.getLogger("HTML5kKaraokeMaker")
        self.logger.setLevel(logLevel)

        if self.readCli():
            self.maker = Maker(self.args.webpath,self.args.datapath)
            self.maker.make()
            self.saveFile()
        else:
            print(_("Interface error"))

    def __str__(self):
        '''Print text'''

        if self.maker:
            return str(self.maker)
        else:
            return _("No file")

    def saveFile(self):

        #copy needed data
        audioPath=self.args.output+'/audio'
        dependPath=self.args.output+'/depend'
        if os.path.exists(audioPath):
            shutil.rmtree(audioPath)
        if os.path.exists(dependPath):
            shutil.rmtree(dependPath)
        shutil.copytree('data/audio','web/audio')
        shutil.copytree('data/depend','web/depend')

        with open(self.args.output+"/index.html", "w+") as doc:
            doc.write(self.__str__())
Example #16
0
from maker import Maker
from time import sleep
m = Maker()
m.go()
print "sleeping..."
sleep(2)
for thing in m.box:
    print thing
Example #17
0
                        })
                    elif ds_name == 'three_fruits':
                        paths = easydict.EasyDict({
                            'datasetFile':
                            os.path.join(dirs_suffix, 'datasets',
                                         'three_fruits'),
                            'textDir':
                            'text_c10',
                            'maxEpochs':
                            '1000'
                        })

                    maker = Maker(datasetFile=paths.datasetFile,
                                  textDir=paths.textDir,
                                  checking_folder=checking_folder,
                                  lang=lang,
                                  client_txt=desc,
                                  pre_trained_gen=os.path.join(
                                      dirs_suffix, 'checkpoints',
                                      ds_name + '_cls_test',
                                      'gen_' + paths.maxEpochs + '.pth'),
                                  pre_trained_disc=os.path.join(
                                      dirs_suffix, 'checkpoints',
                                      ds_name + '_cls_test',
                                      'disc_' + paths.maxEpochs + '.pth'),
                                  ID=ID)

                    maker.generate()
                os.remove(filepath)
    time.sleep(0.5)
    print('Listening folder ' + rootdir + '...')
import numpy as np
from copy import copy

space = np.random.randn(4) * 0.18 + 1
print space
img_all = []
label_all = []
for s in space:
    require = copy(RE)
    require[0] = [int(round(n * s)) for n in require[0]]
    require[1] = [int(round(n * s)) for n in require[1]]
    center_scale = np.random.choice(space, 1)
    center = (int(round(128 * center_scale)), int(round(128 * center_scale)))
    print center, require

    m = Maker(require)
    a = np.random.randint(360)
    m.generate(5, a, center=center)

    img = [i[None, None, None, :, :] for i in m.imgs]
    label = [l[None, None, None, :, :] for l in m.labels]
    img = np.concatenate(img, axis=0)
    label = np.concatenate(label, axis=0)
    img_all.append(img)
    label_all.append(label)

img_all = np.concatenate(img_all, axis=1)
img_all = np.transpose(img_all, (1, 0, 2, 3, 4))
label_all = np.concatenate(label_all, axis=1)
label_all = np.transpose(label_all, (1, 0, 2, 3, 4))