Beispiel #1
0
def edit(filename):

    from ita import Loader
    l = Loader("sablony")

    allowed = (path for path, content in l.getPathsOnly())

    if not filename in allowed:
        msg("Integrita narušena", "error")
        redirect("/templates")

    content = request.forms.get("content")
    if content:
        try:
            save = l.save
        except AttributeError:
            msg("Současný Loader nepodporuje ukládání", "error")
            redirect(request.path)
        save(filename, content)

        msg("Změny uloženy", "success")
        redirect(request.path)

    with open(filename, "rb") as f:
        content = b"".join(f.readlines())

    return template("templates_edit", content=content)
Beispiel #2
0
def run(nonterminal, path, count=None, source=None):
    import ita
    from ita import Loader, Parser, Generator
    ita.VERBOSE = False

    padValue = None
    if source:
        with codecs.open(source, 'rb', 'utf-8-sig') as f:
            data = f.readlines()
    else:
        data = ([str(x) for x in range(count)])
        padValue = len(str(count))

    l = Loader(path)
    p = Parser(l)
    g = Generator(p)

    for name in data:
        name = name.strip()
        if padValue: name = name.rjust(padValue, "0")
        print(name)
        name += ".txt"
        text = g.run(nonterminal)
        with codecs.open(name, 'wb', 'utf-8') as f:
            f.write(text)
Beispiel #3
0
def list():
    """Seznam šablon a možnost jejich úpravy"""

    from ita import Loader, Parser, Generator
    l = Loader("sablony")
    p = Parser(l)

    return template("templates", {"files": p.processedPaths})
    def generate(self):
        """Vrátí vygenerované zadání pro toto cvičení """
        from ita import Loader, Parser, Generator
        l = Loader("sablony")
        p = Parser(l)
        g = Generator(p)

        return g.run(self.nonterminal)
Beispiel #5
0
    def run(self):
        global writeAccess, shouldDie

        loader = Loader("sablony")
        parser = Parser(loader)
        generator = Generator(parser)

        while not shouldDie.is_set():
            text = generator.run(NONTERMINAL)
            hashed = md5(text.encode('utf-8')).hexdigest()
            pendingResolve.put(hashed)
Beispiel #6
0
def run(nonterminal, interval, path, toAscii = True):
    import ita
    from ita import Loader, Parser, Generator
    ita.VERBOSE = False

    print("Stistknutim ENTER se provede pregenerovani")
    print("Pro ukonceni programu pouzijte CTRL+C")
    if toAscii:
        print("Vystup bude preved do cisteho ASCII")

    # event pro synchronizaci změny
    changed = threading.Event()
    
    # vlakno pro odchytavani zmacknuti enter
    inputing = None
    # vlakno pro timeout
    waiting = None

    while True:
        try:
            l = Loader(path)
            try:            
                p = Parser( l )
                g = Generator( p )
                
                text = g.run(nonterminal) 
                
                print( consoleFriendly(text) if toAscii else text )
                
            except SyntaxError as e:
                # chyba při parsování šablony
                print("Syntax error: ", e)
            except NameError as e:
                # neexistující nonterminál při run
                print("Nonterminal not found: ", e)
            except UnicodeDecodeError as e:
                # chybne kodovani sablony
                print("Unicode error in %s : "% (e.filename) , e)
            except ita.GeneratorException as e:
                print(e)

        
            # seznam souborů , které budou hlídány
            filesToBeWatched = { fileName : os.path.getmtime(fileName) for fileName, data in l.getPathsOnly() }

            if not inputing:
                # vlákno inputing muže existovat, 
                # input nelze spustit 2x (jde ale bude se čekat na ukončeni prvniho)
                # pokud dojde k reload z duvodu změny souboru puvodni input porad bezi
                # to je take duvod proc se pouziva stejny event
                inputing = InputThread(changed)
                inputing.start()

            if not waiting:
                # timeout vlakno, startujeme jen když je není z dřívějška
                waiting = WaitingThread(changed, interval)
                waiting.start()

            
            immortal = True
            while immortal:
                #čekáme na změnu
                changed.wait()
            
                # zjistíme kdo změnil stav
                
                if waiting.fired: # čekací vlákno vyvolalo vyjímku  => timeout
                    for fileName, mtime in filesToBeWatched.items():
                        if os.path.getmtime(fileName) != mtime:
                            immortal = False
                            break
                    # force smazani
                    del waiting
                    # nutno zachovat existenci promenne
                    waiting = None
                    
                    if immortal:
                    # pokud doslo k timeoutu ale ne ke zmene souboru, musime nastartovat vlakno znovu
                        waiting = WaitingThread(changed, interval)
                        waiting.start()   
                
                elif inputing.fired: # vlákno vstupu => keypress
                    immortal = False
                    # force smazani
                    del inputing
                    # nutno zachovat existenci promenne 
                    inputing = None
            
            changed.clear()      
            
            print("-"*20)
                    
        except KeyboardInterrupt:
            print("-"*20)
            break 
def run(nonterminal, interval, path, toAscii=True):
    import ita
    from ita import Loader, Parser, Generator
    ita.VERBOSE = False

    print("Stistknutim ENTER se provede pregenerovani")
    print("Pro ukonceni programu pouzijte CTRL+C")
    if toAscii:
        print("Vystup bude preved do cisteho ASCII")

    # event pro synchronizaci změny
    changed = threading.Event()

    # vlakno pro odchytavani zmacknuti enter
    inputing = None
    # vlakno pro timeout
    waiting = None

    while True:
        try:
            l = Loader(path)
            try:
                p = Parser(l)
                g = Generator(p)

                text = g.run(nonterminal)

                print(consoleFriendly(text) if toAscii else text)

            except SyntaxError as e:
                # chyba při parsování šablony
                print("Syntax error: ", e)
            except NameError as e:
                # neexistující nonterminál při run
                print("Nonterminal not found: ", e)
            except UnicodeDecodeError as e:
                # chybne kodovani sablony
                print("Unicode error in %s : " % (e.filename), e)
            except ita.GeneratorException as e:
                print(e)

            # seznam souborů , které budou hlídány
            filesToBeWatched = {
                fileName: os.path.getmtime(fileName)
                for fileName, data in l.getPathsOnly()
            }

            if not inputing:
                # vlákno inputing muže existovat,
                # input nelze spustit 2x (jde ale bude se čekat na ukončeni prvniho)
                # pokud dojde k reload z duvodu změny souboru puvodni input porad bezi
                # to je take duvod proc se pouziva stejny event
                inputing = InputThread(changed)
                inputing.start()

            if not waiting:
                # timeout vlakno, startujeme jen když je není z dřívějška
                waiting = WaitingThread(changed, interval)
                waiting.start()

            immortal = True
            while immortal:
                #čekáme na změnu
                changed.wait()

                # zjistíme kdo změnil stav

                if waiting.fired:  # čekací vlákno vyvolalo vyjímku  => timeout
                    for fileName, mtime in filesToBeWatched.items():
                        if os.path.getmtime(fileName) != mtime:
                            immortal = False
                            break
                    # force smazani
                    del waiting
                    # nutno zachovat existenci promenne
                    waiting = None

                    if immortal:
                        # pokud doslo k timeoutu ale ne ke zmene souboru, musime nastartovat vlakno znovu
                        waiting = WaitingThread(changed, interval)
                        waiting.start()

                elif inputing.fired:  # vlákno vstupu => keypress
                    immortal = False
                    # force smazani
                    del inputing
                    # nutno zachovat existenci promenne
                    inputing = None

            changed.clear()

            print("-" * 20)

        except KeyboardInterrupt:
            print("-" * 20)
            break
Beispiel #8
0
from ita import Loader, Parser, Generator

loader = Loader("sablony")
parser = Parser( loader )
generator = Generator( parser )

print( generator.run("cviceni") )