LBI/modules/fractale.py

#dummy module
import asyncio
import fractale.source.main
import random
import discord
import os
from PIL import Image
from concurrent.futures import ThreadPoolExecutor
class MainClass():
    def __init__(self, client, modules, owners, prefix):
        self.client = client
        self.modules = modules
        self.owners = owners
        self.prefix = prefix
        self.events=['on_message'] #events list
        self.command="%sfractale"%self.prefix #command prefix (can be empty to catch every single messages)

        self.name="Fractale"
        self.description="Module de génération de fractales"
        self.interactive=True
        self.color=0x78ffc3
        self.fractals={
            "von_koch_curve_flake":{"Type":"Figures", "Max":((5000,5000), 5000, 10), "Min":((0,0),0,1), "Default":"(2500 2500) 2000 5 #ffffff 1", "Indication":"(départ) (arrivée) longueur iterations color bg stroke", "ParseData":"pfixi"},
            "von_koch_curve":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1), "Default":"(0 2500) (5000 2500) 5 #ffffff 1", "Indication":"(départ) (arrivée) iterations color bg stroke", "ParseData":"ppixi"},
            "blanc_manger":{"Type":"Figures", "Max":((5000,5000),(5000,5000),10), "Min":((0,0),(0,0),1), "Default":"(1000 1000) (4000 4000) 7 #ffffff 1", "Indication":"(départ) (arrivée) iterations color bg stroke", "ParseData":"ppixi"},
            "dragon":{"Type":"Lsystem", "Max":((5000,5000), 2500,19), "Min":((0,0),1,1), "Default":"(2500 2500)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
            "sierpinski_triangle":{"Type":"Lsystem", "Max":((5000,5000),2500,11), "Min":((0,0),0,1), "Default":"(0 0)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
            "fractal_plant":{"Type":"Lsystem", "Max":((5000,5000),2500,8), "Min":((0,0),0,1), "Default":"(0 2500)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
            "koch_curve_right_angle":{"Type":"Lsystem", "Max":((5000,5000),2500,9), "Min":((0,0),0,1), "Default":"(0 5000)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"},
            "fractal_binary_tree":{"Type":"Lsystem", "Max":((5000,5000),2500,15), "Min":((0,0),0,1), "Default":"(0 0)", "Indication":"(origine) longueur iterations color bg stroke", "ParseData":"pfixi"}
            }
        self.help="""\
 </prefix>fractale [fractale] [nombre d'itérations]
 => Génère une image fractale. (Si on met le nombre d'itérations, on doit mettre le nom de la fractale.)
 
 -> Valeurs possible pour [fractale]
```..: Toutes les fractales:
%s```"""%'\n'.join(['......: %s'%t for t in self.fractals.keys()])


    def parse(self, inp):
        retDic={"Success":False, "Message":"", "Result":()}
        #Parsing the fractal name and storing the corresponding dic into a variable
        try:
            fractal=self.fractals[inp.split(' ')[0]]
        except KeyError:
            retDic.update({"Success":False, "Message":"La fractale %s n'existe pas."%inp.split(' ')[0]})
            return(retDic)
        arg=' '.join(inp.split(' ')[1:]) #Stuff after the fractal name
        #checking for incoherent parentheses usage
        parentheses_count=0
        for i,char in enumerate(arg):
            if char=='(':
                parentheses_count+=1
            elif char==')':
                parentheses_count-=1
            if not(-1<parentheses_count<2):
                retDic.update({"Success":False, "Message":"Usage invalide de parentheses au charactère numéro %s (à partir d'après le nom de la fractale)."%i})
                return(retDic)

        #Here, we have a coherent parentheses usage
        if ',' in arg:
            retDic.update({"Success":False, "Message":"Les virgules n'ont pas leur place dans les paramètres de génération. Il ne doit y avoir que des espaces uniques."})
            return(retDic)

        #parsing the fractal
        args=arg.replace(')','').replace('(','').split(' ')
        parsed_args=[]
        i=0
        for parse in fractal['ParseData'] :
            if parse=='p':
                if args[i]!='*':
                    try:
                        int(args[i])
                        int(args[i+1])
                    except:
                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (nombre entiers attendus pour les coordonnées d'un point)"})
                        return(retDic)
                    parsed_args.append((int(args[i]),int(args[i+1])))
                    i+=2
                else:
                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
                    i+=1

            elif parse=='f':
                if args[i]!='*':
                    try:
                        float(args[i])
                    except:
                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Nombre à virgule flottante attendu (mettre un point pour la virgule))"})
                        return(retDic)
                    parsed_args.append(float(args[i]))
                    i+=1
                else:
                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
                    i+=1

            elif parse=='i':
                if args[i]!='*':
                    try:
                        int(args[i])
                    except:
                        print(args[i])
                        print(i)
                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Nombre entier attendu)"})
                        return(retDic)
                    parsed_args.append(int(args[i]))
                    i+=1
                else:
                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
                    i+=1

            elif parse=='x':
                if args[i]!='*':
                    try:
                        if '#' in args[i]:
                            int(args[i].replace('#','0x'),16)
                        else:
                            raise
                    except:
                        retDic.update({"Success":False, "Message":"Les valeurs ne sont pas du bon type. (Valeur hexadécimale attendue)"})
                        return(retDic)
                    parsed_args.append(int(args[i].replace('#','0x'),16))
                    i+=1
                else:
                    parsed_args.append(self.parse(inp.split(' ')[0]+' '+fractal['Default'])['Result'][len(parsed_args)])
                    i+=1
        retDic.update({"Success":True, "Result":parsed_args})
        return(retDic)

    async def on_message(self, message):
        #await message.channel.send(str(self.parse(message.content[len("%sfractale "%self.prefix):])))
        #ħere
        args=message.content.split(" ")
        tmpstr="/tmp/%s.png"%random.randint(1,10000000)
        im=Image.new('RGB', (5000, 5000), (0, 0, 0))#here
        
        fig = fractale.source.main.Figures(im=im)#here
        if len(args)==1 :
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve_flake,*((2500, 2500), 2000, 5))
        elif args[1].lower()=="blanc_manger" :
            iterations=7
            if len(args)>2 and int(args[2])<=20:
                iterations=int(args[2])
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.blanc_manger,*((1000, 1000), (4000, 4000), iterations))
        elif args[1].lower()=="von_koch_curve_flake" :
            iterations=5
            if len(args)>2 and int(args[2])<=7:
                iterations=int(args[2])
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve_flake,*((2500, 2500), 2000, iterations))
        elif args[1].lower()=="von_koch_curve" :
            iterations=5
            if len(args)>2 and int(args[2])<=7:
                iterations=int(args[2])
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve,*((0, 2500), (5000,2500), iterations))
        else:
            await self.modules['help'][1].send_help(message.channel, self)
            return#here
        im.save(tmpstr)#here
        await message.channel.send(file=discord.File(tmpstr))
        os.remove(tmpstr)#here