TUTOR 리덕토의 배움세상

PC정비사 공부를 하면서 COMCBT 사이트에서 도움을 받고 있다. 우리나라 자격증의 특징인데, 문제은행식이어서 중복되는 문제들이 너무 많았다. 이를 제거해서 자주출제되었던 것들만 공부할 수 있으면 효율적이지 않을까 하는 생각에 코드를 만들었다. 코드는 다음과 같다.

import os
from PyPDF2 import PdfReader

location = ### 저장소 위치, 있는 폴더로 저장하세요 ###"

def extract(i) :
    reader = PdfReader(i)
    pages = len(reader.pages)
    text = ""
    for i in range(pages) :
        text += reader.pages[i].extract_text()
    return text

def duplicate_checker(l,cand) :
    if(cand[0] in l and cand[1] in l and cand[2] in l) :
        return True
    if(cand[0] in l and cand[2] in l and cand[3] in l) :
        return True
    if(cand[0] in l and cand[3] in l ) :
        return True
    if(cand[1] in l and cand[2] in l ) :
        return True
    if(cand[1] in l and cand[3] in l ) :
        return True
    if(cand[2] in l and cand[3] in l ) :
        return True
    return False

def file_write(i,text) :
    with open(str(i)+".txt","wt",encoding="UTF-8") as f:
        f.write(text)

if __name__=="__main__" :

    os.chdir(location)
    try :
        os.mkdir(r".\OUTPUT")
        os.mkdir(r".\RAW")
    except Exception as e:
        pass
    
    RAW_PDF_LIST = os.listdir(r".\RAW")

    ## Extract Code ##

    dict_dat = dict()
    
    count = 0

    for i in RAW_PDF_LIST :
        dict_dat[i] = extract(".\\RAW\\"+i)
        file_write(".\\OUTPUT\\"+str(count),dict_dat[i])
        count+=1
        print(i," done")

    ## Dict Generate Code
    PARSE_PDF_LIST = os.listdir(r".\OUTPUT")
    STAT_Q = 0

    STAT_A = 1
    STAT_B = 2
    STAT_C = 3
    STAT_D = 4

    cand_id_list = ["①","②","③","④"]
    ans_id_list = ["❶","❷","❸","❹"]

    qs = dict()
    total_count = 0

    for txt in PARSE_PDF_LIST :
        data = list()
        with open(".\\OUTPUT\\"+txt,"rt",encoding="UTF-8") as f :
            lines = f.read().split("\n")
        
        q_count = 0
        question = ""
        cand = ["","","",""]
        answer = 0
        cur_state = -1
        
        for l in lines :
            
            write_flag=False
            
            if(l.strip() == "") :
                continue

            
            if(str(q_count+1)+". " in l) :
                if(question != "") :
                    if(question not in qs) :
                        qs[question] = dict()
                    qs[question]["cand"] = cand
                    qs[question]["answer"] = answer
                    if("count" in qs[question]) :
                        qs[question]["count"] += 1
                    else :
                        qs[question]["count"] = 1
                    question = ""
                    cand = ["","","",""]
                    answer = 0
                    total_count +=1
                question = l.split(str(q_count+1)+". ")[1].strip()
                cur_state = STAT_Q
                write_flag = True
                
            
            if(cand_id_list[0] in l) :
                cand[0] = l.split(cand_id_list[0])[1].split(cand_id_list[1])[0]
                cand[0] = cand[0].split(ans_id_list[1])[0]
                cur_state = STAT_A
                write_flag = True
            elif(ans_id_list[0] in l) :
                cand[0] = l.split(ans_id_list[0])[1].split(cand_id_list[1])[0]
                answer = 1
                cur_state = STAT_A
                write_flag = True
            
            if(cand_id_list[1] in l) :
                cand[1] = l.split(cand_id_list[1])[1].split(cand_id_list[2])[0]
                cand[1] = cand[1].split(ans_id_list[2])[0]
                cur_state = STAT_B
                write_flag = True
            elif(ans_id_list[1] in l) :
                cand[1] = l.split(ans_id_list[1])[1].split(cand_id_list[2])[0]
                answer = 2
                cur_state = STAT_B
                write_flag = True
            
            if(cand_id_list[2] in l) :
                cand[2] = l.split(cand_id_list[2])[1].split(cand_id_list[3])[0]
                cand[2] = cand[2].split(ans_id_list[3])[0]
                cur_state = STAT_C
                write_flag = True
            elif(ans_id_list[2] in l) :
                cand[2] = l.split(ans_id_list[2])[1].split(cand_id_list[3])[0]
                answer = 3
                cur_state = STAT_C
                write_flag = True
            
            if(cand_id_list[3] in l) :
                cand[3] = l.split(cand_id_list[3])[1]
                cur_state = STAT_D
                write_flag = True
                q_count+=1
            elif(ans_id_list[3] in l) :
                cand[3] = l.split(ans_id_list[3])[1]
                answer = 4
                cur_state = STAT_D
                write_flag = True
                q_count+=1
            
            if(write_flag==False) :
                if(cur_state==STAT_Q) :
                    question+= l
                elif(cur_state==STAT_A) :
                    cand[0] += l
                elif(cur_state==STAT_B) :
                    cand[1] += l
                elif(cur_state==STAT_C) :
                    cand[2] += l
                elif(cur_state==STAT_D) :
                    cand[3] += l
                    
    qs_sorted = sorted(qs.items(),key = lambda x:x[1]["count"],reverse=True)
                    
    with open("OUTPUT.txt","wt",encoding="utf-8") as f:
        f.write("#### TARGET FILE ####\n")
        for l in RAW_PDF_LIST :
            f.write(l+"\n")
        f.write("\n")
        f.write("Total Question : "+str(total_count)+"\n\n")
        f.write("Trimmed Question : "+str(len(qs_sorted))+"\n\n")

        f.write("\n")
        f.write("### EXAM LINE ###\n")
        for v in qs_sorted :
            f.write("Question : "+v[0]+" ## Count : "+str(v[1]["count"])+"\n\n")
            f.write("1. "+v[1]["cand"][0]+"\n")
            f.write("2. "+v[1]["cand"][1]+"\n")
            f.write("3. "+v[1]["cand"][2]+"\n")
            f.write("4. "+v[1]["cand"][3]+"\n\n")
            f.write("Answer : "+str(v[1]["answer"]))
            f.write("\n\n\n")

    print("PARSE FINISH")

조금 비효율적인 조건문이 있으나, 알바없다.... 사용방법은 폴더아래 RAW라는 폴더를 만들고, 그 안에 comcbt.com에서 다운로드 받은 교사용.pdf를 넣어두고 코드를 실행하면 끝이다. 중복된 문제들을 제외하고, 나왔던 빈도수의 내림차순으로 output.txt가 생성된다.

* 참고사항

 1. 텍스트만 추출했기 때문에, 그림문제는 정상적으로 안보인다.

 2. 이유는 모르겠는데, 번호를 구분하는 ① 이런게 한줄에 엄청 많으면 그 파일을 불러오는데 실패한다. 필요하면 나중에 고치지 뭐;

 3. PyPDF2는 pip3로 install 해야한다.

해시계산, 무결성검사기 프로그램을 배포합니다.

- 프로그램명 : IntMan.exe

- 제작기간 : '21.11.06. ~ '21.11.09 (4일) 

- 제작자 : REDUCTO

- 사용언어 : JAVA

- 사용라이브러리 : Swing

- 버전 : v1.0

소개

IntMan은 해시검사기능을 제공하며, 두파일이 같은지 비교, 지정된 파일 무결성 검사를 제공합니다.

* 무단배포는 금지합니다.(댓글달아주세용)
* 기능에 커스터마이징이 필요하시다면 댓글달아주세용

* [해시계산&비교탭] 윗줄은 검사할 해시입니다.

* [무결성검사탭] 무결성검사데이터는 C:\tmp아래 저장되며, 무결성검사를 수행한 날에 C:\tmp\[프로그램실행날짜]\ 에 파일이 복사됩니다. 

* [무결성검사탭] 무결성검사결과 변경된 항목은 기울임꼴, 사라진 파일은 굵음 표시됩니다.

사용법

더보기

윗줄의 해시를 입력하는 것으로 해당하는 해시값이 굵게 표시됩니다.

* 파일선택은 드래그앤 드랍 or [파일선택]버튼을 통해서 수행합니다.

두 파일이 같은 파일이라면 초록색 / 다른파일이라면 붉은색으로 표시됩니다.

 

* 파일추가는 드래그앤 드랍 or [+]버튼을 통해서 수행합니다.

행을 우클릭하여 특정파일 무결성검사, 혹은 삭제할 수 있습니다.

임의길이 난수생성프로그램을 배포합니다.

- 프로그램명 : RanGan.exe

- 제작기간 : '21.11.04. ~ '21.11.04 (1일) 

- 제작자 : REDUCTO

- 사용언어 : JAVA

- 사용라이브러리 : Swing

- 버전 : v1.0

소개

RanGan영소문자 / 영대문자 / 숫자 / 특수문자를 활용하여 지정된 길이의 지정된 숫자 난수를 생성하는 프로그램입니다.

* 무단배포는 금지합니다.(댓글달아주세용)
* 기능에 커스터마이징이 필요하시다면 댓글달아주세용

* 생성결과는 저장위치\output.txt에 저장됩니다.

간단한 크롤링 프로그램을 하나 만들어서 배포합니다. 

- 프로그램명 : Galmuri.exe

- 제작기간 : '21.11.02. ~ '21.11.04 (3일) 

- 제작자 : REDUCTO

- 사용언어 : JAVA

- 사용라이브러리 : Jsoup, Swing

- 버전 : v1.0

소개

Galmuri는 홈페이지에서 정적 스크립트를 읽어와 글 / 사진 / 영상의 태그 소스를 수집하는 크롤러입니다.

* 무단배포는 금지합니다.(댓글달아주세용)
* 기능에 커스터마이징이 필요하시다면 댓글달아주세용

* 글을 캡쳐한 경우 폴더아래 char\result.txt에 저장됩니다.

* User-Agent와 cookie설정이 없는 프로그램이기에 Robots.txt가 허용된 곳만 탐색가능합니다.

사용예시

더보기

1. 수집할 홈페이지 url을 galmuri에 넣고, 수집할 대상을 선택합니다.

 2. ▶누르면 끝! 완료된 결과는 폴더에 태그별로 정리되어있습니다. 

* scrapbody.html에 Galmuri가 접근한 html이 있습니다.

* result.txt는 글을 크롤링한 경우에만 유효한 파일입니다.

로드맵

* 로그인된 화면 혹은 차단된 화면 가져올 수 있게 수정(~11월)

* 프로그램 요청이나 산출물 요청은 댓글로 달아주세요!

시현입니다. 아직 미완인데, 귀차니즘으로 잠깐 정지해두고 다른 공부하다 오려그럽니다. 일전에 스크립트를 포스팅하였으나, 뭐하는 짓인가 싶어 비공개로 돌렸습니다.

프로그램은 사용자가 진입, 구매, 판매조건을 설정하여 그 조건에 맞게 트레이드로봇이 동작하는 구조입니다

MainWindow

기본 화면 구성은 다음과 같다.

위쪽에 menu들은 다음과 같은 하위 항목이 있다.

프로그램은 아래와 같이 tray_icon에 표시되며, 24시간 돌아가야 되는 특성상 X버튼을 눌러도 꺼지지 않고, main 화면만 invisible된다.

SubWindow

1. 거래키 Window

필자의 KEY가 기본으로 들어있어 지우고 사진을 올렸다. 로컬파일인 key.dat을 로딩해서 보여준다.

2. 전체 잔고 확인 Window

가지고 있는 코인을 보여주며, 우클릭으로 판매할 수 있다.(어... VTHO쟨 뭐지?)

3. 시뮬레이터

과거 데이터를 기준으로 구매/판매 조건이 어떤 결과를 가져올지 시뮬레이팅하는 기능이다. 당연히 과거데이터가 한정되어있어 약간의 차이가 존재한다.(upbit에서 ohlcv를 길게 요구하면 중간중간 빠지는 경우가 있더라)

(아... 이거 만들겠다는 생각만 안했으면,... 차라리 안정성이나 늘려두지...)

조건생성을 클릭하면 다음과 같이 구매 / 판매조건을 걸어줄 수 있다. 옆에 [...]버튼을 눌러서 기존 조건을 가져올 수도 있다. 동작중인 조건은 ./criteria 폴더아래 [코인명]_[buy/sell]_criteria.dat로 저장되어 있다.

조건을 클릭하면 다음과 같이 편집할 수 있다.

과거데이터 덤프를 가져오는 화면은 아래와 같다. 궁금한 종목을 가져오고 [가져오기]버튼을 눌러 가져올 수 있다.

가져온 데이터는 ./dump 아래 [코인명].dump로 저장된다.

4. 진입 조건 Window

현재 진입조건으로는 2가지 경우를 만들어 두었다. 업데이트하고 조금 손보면 더 늘어날 예정이다. 글을 쓰는 현재 2분동안 -5%감소한 종목이 없는지 좀처럼 시작을 안해서 2일동안 5%감소한 항목으로 조건을 바꾸어 하나를 시작 시켰다.

짜잔.

저 한 행이 트레이딩봇 한 개이다. 우클릭하면 트레이딩 봇에 대한 동작 기록 확인 / 거래 조건 변경 / 강제 종료 / 일시정지등을 지시할 수 있다.

거래조건확인은 시뮬레이팅에서 본 그 화면과 동일하다. 단 window이름이 코인명으로 지정되어있는데, 글로벌 프리셋에서 복사되어 코인별로 조건을 따로따로 지정하는 동작이다. 현재는 거래가 안되게끔 현재가<현재가로 걸어두었다.

동작기록은 메모장으로 [코인명]_history.log가 열린다. 이 파일은 ./var/log 아래 일자별로 폴더가 생성된다.

마지막으로 강제종료하여 해당 트레이드 봇을 강제종료 시켰다.(...응? 이상한게 하나 시작되었다.)

5. 설정변경 window

프로그램의 동작 설정을 변경할 수 있는 window이다.

Q. 왜 잔고(KRW)가 0인데 시작하나요?

A. 프로그램 테스트 용도로 가짜 돈이 조금 들어가 있습니다.

Q. 남은 개발항목은 어떤게 있나요?

A. 시뮬레이팅 결과화면이 아직 덜 준비되었습니다. 그 외 프로그램의 사용기간 제한이나, 제작자에게 e-mail건의 등을 하는 기능이 미구현상태이고, 전체적으로 안정성을 늘려야합니다. 디버깅없이 열심히 삘받아서 코딩한거라 잔 오류가 조금씩 보이네요. 가능하다면 UI도 조금 꾸미고 싶어요.

Q. 자문자답 쪽팔리지 않으세요?

A. 네

코드구조

• class cleaner
  • clean_history() : 동작기록 삭제, bitmain에서 호출되며, 과거 기록 삭제에 사용
• class key_loader
  • key_set() : 로컬파일 key.dat에서 key 불러옴 [acc,sec]형태로 반환 이거 안씀 왜만들었지?
  • key_save() : [acc,sec]형태로 파라미터를 받아 key.dat update
  • key_loader() :  로컬파일 key.dat에서 key 불러옴 [acc,sec]형태로 반환
• class config_loader
  • loading() : config.dat에서 설정 복사해서 config(dictionary)생성, 반환
  • config_save() : config(dictionary) 파라미터로 받아 config.dat update
  • get, get_config() : 안씁니다. 초기 디버그용
• class history_maker
  • init_history() : 해당 트레이드봇의 동작로그에 맨처음 적을 말 씁니다.
  • write_history() : 해당 트레이드봇의 동작로그 기록
  • load_history() : 해당 트레이드봇의 동작로그 불러옴
  • get_history_list() : 트레이드봇의 동작기록들 목록 로딩
  • open_history() : 해당 트레이드봇의 동작기록 열기(메모장으로) 
• class fomula
  • read_raw_buy_parser() : 트레이드봇의 구매조건 읽어옴 raw_parser로 리스트 생성 후 반환
  • read_raw_sell_parser() : 트레이드봇의 판매조건 읽어옴 raw_parser로 리스트 생성 후 반환
  • raw_parser() : 위 두함수로 읽어온 결과 한줄한줄씩 해석가능 리스트로 바꾸어줌
  • read_buy_parser() : 트레이드봇의 구매조건을 읽어와 람다식 함수 리스트생성
  • read_sell_parser() : 트레이드봇의 판매조건을 읽어와 람다식 함수 리스트생성
  • make_fomula() : 아래 make_fomula_sentense을 한줄한줄 read_XX_parser로 읽어온 리스트에 적용
  • make_fomula_sentense() : read_XX_parser로 가져온 한줄에 대한 람다식 생성
  • raw_to_fom() : _criteria.dat에 저장가능한 형태로 변경
  • save_config() : 변경된 설정 저장
  • get_fomula() : 사용가능한 함수반환
  • get_operatator() : 사용가능한 연산자반환
  • get_fom_type() : fomula에 사용가능한 파라미터 수 리스트로 반환
• init_fomula
  • read_raw_data() : 초기 진입 조건 _init_criteria.dat 읽어옴, list로 반환
  • save_init() : 초기 진입 조건 _init_criteria.dat 저장함
  • criteria_list() : 어 이거 왜 만들었지?

코드

### local_loader.py
### 21. 6. 28. add class local_loader, func gey_key()
### 21. 7. 3.  add umm... many class, func

import fileinput
import datetime
import sys
import os
import subprocess
import shutil
from algo_util import *

######################################################
###                                                ###
### This class is to clean previous log            ###
###                                                ###
######################################################
class cleaner :

    def clean_history() :
        pwd = os.getcwd()
        today=datetime.datetime.now()
        now = str(today.year)+"_"+str(today.month)+"_"+str(today.day)
        try :
            os.mkdir("./bot_history/"+now)
        except FileExistsError as e:
            print(e)
        os.chdir("./bot_history/")
        filelist = [ x for x in os.listdir() if ".log" in x ]
        for file in filelist :
            try :
                shutil.move(file,"./"+now)
            except shutil.Error as e:
                shutil.copy(file,"./"+now)
                os.remove(file)
                print(e)
        os.chdir(pwd)

######################################################
###                                                ###
### This class is to handle user's trading key     ###
###                                                ###
######################################################
class key_loader :

    def key_set() :
        with open("./key.dat","r") as f:
            data = f.read().split("\n")
            acc = data[0].split("=")[1].strip()
            sec = data[1].split("=")[1].strip()
        return [acc,sec]

    def key_save(value) :
        with fileinput.FileInput("./key.dat",inplace = True) as f:
            for line in f :
                if("acc" in line) :
                    line = line.replace(line,"acc="+value[0])
                elif("sec" in line) :
                    line = line.replace(line,"sec="+value[1])

    def key_loader() :
        ret = list()
        with open("./key.dat","r") as f:
            data = f.read().split("\n")
            for i in range(len(data)) :
                if("acc=" in data[i]) :
                    ret.append(data[i].split("=")[1])
                elif("sec=" in data[i]) :
                    ret.append(data[i].split("=")[1])

        if(len(ret)!=2) :
            log_maker.write_error_log("failed to load key")
        else :
            return ret
        
######################################################
###                                                ###
### This class is to handle config                 ###
###                                                ###
######################################################   
class config_loader :

    def loading() :
        config = dict()
        with open("./config.dat","r") as f:
            data = f.read().split("\n")

            for i in range(len(data)) :
                if(len(data[i])<3) :
                    continue
                if(data[i][0]=="#" or data[i]=="") :
                    continue
                else :
                    try :
                        data_s = data[i].split("=")[1].strip()
                        if(float(data_s) != int(data_s)) :
                            config[data[i].split("=")[0]] = float(data_s)
                        else :
                            config[data[i].split("=")[0]] = int(data_s)
                    except ValueError :
                        config[data[i].split("=")[0]] = data[i].split("=")[1].strip()

        return config

    def get(self,wh) :
        if(wh in self.config) :
            return self.config[wh]

    def config_save(cd) :
        setter = list(cd.keys())
        with fileinput.FileInput("./config.dat",inplace=True,backup=".bak") as f:
            for line in f :
                set_flag = False
                for i in range(len(setter)) :
                    if(setter[i] in line) :
                        set_flag = True
                        line = line.replace(line,setter[i]+"="+str(cd[setter[i]]))
                        sys.stdout.write(line+"\n")
                        del setter[i]
                        break
                if(set_flag==False) :
                    sys.stdout.write(line)
                if(len(setter) == 0 ) :
                    break


    def get_config() :
        config = dict()
        with open("./config.dat","r") as f:
            data = f.read().split("\n")

            for i in range(len(data)) :
                if ("=" in data[i]) :
                    config[data[i].split("=")[0].strip()] = data[i].split("=")[1].strip()

        return config
        
######################################################
###                                                ###
### This class is to write running log             ###
### error log writer is in utility.py              ###
###                                                ###
######################################################
class history_maker :

    def init_history(fiat) :
        now = datetime.datetime.now()
        try :
            with("./bot_history/"+fiat+"_history.log","w") as f:
                f.write("--------"+fiat+"--------\n")
                f.write(str(now)+"\n\n")
        except FileNotFoundError as e:
            os.mkdir("./bot_history")
            self.init_history(fiat)

    def write_history(fiat,string) :
        now = datetime.datetime.now()
        try :
            with open("./bot_history/"+fiat+"_history.log","a") as f :
                f.write("<"+str(now)+"> "+string+"\n\n")
        except FileNotFoundError as e:
            print(e)

    def load_history(fiat) :
        with open("./bot_history/"+fiat+"_history.log","a") as f:
            data = f.read().split("\n")
        return data

    def get_history_list() :
        list_tmp = [ x for x in os.listdir("./bot_history/") if x.endswith(".log")]
        for i in range(len(list_tmp)) :
            list_tmp[i] = list_tmp[i].split("_")[0]
        return list_tmp

    def open_history(fiat) :
        subprocess.Popen("notepad.exe ./bot_history/"+fiat+"_history.log")


######################################################
###                                                ###
### This script is for parse criteria              ###
### interact with algo_util and trading_bot        ###
### fomula express as form's of                    ###
### EX> A/a M B/b (& another fom)                  ###
###                                                ###
######################################################
class fomula :

    fomula_dict = {"0":"현재가","1":"최소가","2":"최대가","3":"평균가","4":"이동평균가","5":"마지막구매가","6":"마지막판매가"}
    fom_type_dict = {0:[],1:["0","1","2","3","5","6"],2:["4"]}
    operator_dict = {"1":"<","2":"<=","3":">","4":">=","5":"==","6":"!="}

    def read_raw_buy_parser(fiat="") :

        buy_criteria = list()
        
        with open("./criteria/"+fiat+"_buy_criteria.dat","r") as f:
            data = f.read().split("\n")
            for i in range(len(data)) :
                if(data[i].strip() == "") :
                    continue
                elif(data[i][0]=="#") :
                    continue
                else :
                    buy_criteria.append(fomula.raw_parser(data[i].split(":")[1]))
                                        
        return buy_criteria

    def read_raw_sell_parser(fiat="") :

        sell_criteria = list()
        
        with open("./criteria/"+fiat+"_sell_criteria.dat","r") as f:
            data = f.read().split("\n")
            for i in range(len(data)) :
                if(data[i].strip() == "") :
                    continue
                elif(data[i][0]=="#") :
                    continue
                else :
                    sell_criteria.append(fomula.raw_parser(data[i].split(":")[1]))
                                        
        return sell_criteria


    def raw_parser(line) :
        res = list()
        tmp_line = line.split("&")
        for i in range(len(tmp_line)) :
            apt_list = list()
            tmp  = tmp_line[i].strip()
            a1,fo,a2 = tmp.split(" ")
            if("/" in a1) :
                a1_args = a1.split("/")[1:]
                a1 = a1.split("/")[0]
                apt_list.append(fomula.fomula_dict[a1])
                apt_list.append(a1_args)
            else :
                apt_list.append(fomula.fomula_dict[a1])
                
            apt_list.append(fomula.operator_dict[fo])
            
            if("/" in a2) :
                a2_args = a2.split("/")[1:]
                a2 = a2.split("/")[0]
                apt_list.append(fomula.fomula_dict[a2])
                apt_list.append(a2_args)
            else :
                apt_list.append(fomula.fomula_dict[a2])
    
            
            res.append(apt_list)
        return res
        

    def read_buy_parser(fom_algo,arg,fiat="") :

        buy_criteria = list()
        
        with open("./criteria/"+fiat+"_buy_criteria.dat","r") as f:
            data = f.read().split("\n")
            for i in range(len(data)) :
                if(data[i].strip() == "") :
                    continue
                elif(data[i][0]=="#") :
                    continue
                else :
                    buy_criteria.append(fomula.make_fomula(data[i].split(":")[1],fom_algo,arg))            
        return buy_criteria

    def read_sell_parser(fom_algo, arg, fiat="") :    
        sell_criteria = list()
        with open("./criteria/"+fiat+"_sell_criteria.dat","r") as f:
            data = f.read().split("\n")
            for i in range(len(data)) :
                if(data[i].strip() == "") :
                    continue
                elif(data[i][0]=="#") :
                    continue
                else :
                    sell_criteria.append(fomula.make_fomula(data[i].split(":")[1],fom_algo,arg))
                                        
        return sell_criteria

    def make_fomula(fom,fom_algo,arg) :

        fom = fom.split("&")
        fom_list = list()

        for i in range(len(fom)) :
            fom_list.append(fomula.make_fomula_sentence(fom[i],fom_algo,arg))

        return fom_list

    def make_fomula_sentence(fom,fom_algo,arg) :
        fom = fom.strip()
        a1,fo,a2 = fom.split(" ")

        buy_money = arg["buying"]
        sell_money = arg["selling"]

        a1_args = [0,0]
        a2_args = [0,0]
        
        if("/" in a1) :
            a1_args = a1.split("/")[1:]
            a1 = a1.split("/")[0]
        if("/" in a2) :
            a2_args = a2.split("/")[1:]
            a2 = a2.split("/")[0]

        if(a1 == "0") :
            a1_foo = lambda x : fom_algo.current_val()
        elif(a1 == "1") :
            a1_foo = lambda x : fom_algo.min_val(x)*float((100-float(a1_args[0]))/100)
        elif(a1 == "2") :
            a1_foo = lambda x : fom_algo.max_val(x)*float((100-float(a1_args[0]))/100)
        elif(a1 == "3") :
            a1_foo = lambda x : fom_algo.avg_val(x)*float((100-float(a1_args[0]))/100)
        elif(a1 == "4") :
            if(a1_args[0] != 0) :
                a1_foo = lambda x : fom_algo.rolling_mean(x,a1_args[1])*float((100-float(a1_args[0]))/100)
            else :
                a1_foo = lambda x : fom_algo.rolling_mean(x)*float((100-float(a1_args[0]))/100)
        elif(a1 == "5") :
            a1_foo = lambda x : buy_money*float((100-float(a1_args[0]))/100)
        elif(a1 == "6") :
            a1_foo = lambda x : sell_money*float((100-float(a1_args[0]))/100)

        if(a2 == "0") :
            a2_foo = lambda x : fom_algo.current_val()
        elif(a2 == "1") :
            a2_foo = lambda x : fom_algo.min_val(x)*float((100-float(a2_args[0]))/100)
        elif(a2 == "2") :
            a2_foo = lambda x : fom_algo.max_val(x)*float((100-float(a2_args[0]))/100)
        elif(a2 == "3") :
            a2_foo = lambda x : fom_algo.avg_val(x)*float((100-float(a2_args[0]))/100)
        elif(a2 == "4") :
            if(a2_args[1]!=0) :
                a2_foo = lambda x : fom_algo.rolling_mean(x,a2_args[1])*float((100-float(a2_args[0]))/100)
            else :
                a2_foo = lambda x : fom_algo.rolling_mean(x)*float((100-float(a2_args[0]))/100)
        elif(a2 == "5") :
            a2_foo = lambda x : buy_money*float((100-float(a2_args[0]))/100)
        elif(a2 == "6") :
            a2_foo = lambda x : sell_money*float((100-float(a2_args[0]))/100)

        if(fo == "1") :
            fom = lambda x : True if a1_foo(x) < a2_foo(x) else False
        elif(fo == "2") :
            fom = lambda x : True if a1_foo(x) <= a2_foo(x) else False
        elif(fo == "3") :
            fom = lambda x : True if a1_foo(x) > a2_foo(x) else False
        elif(fo == "4") :
            fom = lambda x : True if a1_foo(x) >= a2_foo(x) else False
        elif(fo == "5") :
            fom = lambda x : True if a1_foo(x) == a2_foo(x) else False
        elif(fo == "6") :
            fom = lambda x : True if a1_foo(x) != a2_foo(x) else False

        return fom

    def raw_to_fom(raw) :
        output = ""
        
        if(raw==[]) :
            return ""
        
        rev_fomula = dict([(value,key) for key,value in fomula.fomula_dict.items()])
        rev_ope = dict([(value,key) for key,value in fomula.operator_dict.items()])
        for i in range(len(raw)):
            offset = 0
            output += rev_fomula[raw[i][0]]
            if(isinstance(raw[i][1], list)) :
                for j in range(len(raw[i][1])) :
                    output += "/"+raw[i][1][j]
                offset += 1
            output +=  " "
            output += rev_ope[raw[i][1+offset]] + " "
            output += rev_fomula[raw[i][2+offset]]
            if(isinstance(raw[i][-1],list)) :
                for j in range(len(raw[i][-1])) :
                    output += "/"+raw[i][-1][j]
            output += " & "
        output = output[:-3]
        return output


    def save_config(index,raw,bs_type,fiat="") :
        try :
            if(raw == []) :
                cnt = 1
                with fileinput.FileInput("./criteria/"+fiat+"_"+bs_type+"_criteria.dat",inplace=True) as f:
                    for line in f :
                        try :
                            find_index = line.split(":")[0].strip()
                            setter = line.split(":")[1].strip()
                        except Exception as e:
                            continue
                        if(str(index)+" :" in line) :
                            continue
                        line = line.replace(line,str(cnt)+" : "+setter)
                        cnt+=1
                        sys.stdout.write(line+"\n")
                return
            trans = str(index)+ " : " + fomula.raw_to_fom(raw)+"\n"
            setter = 0
            set_flag=False
            with fileinput.FileInput("./criteria/"+fiat+"_"+bs_type+"_criteria.dat", inplace=True) as f:
                for line in f :
                    setter = line.split(":")[0].strip()
                    if(str(index)==setter):
                        line = line.replace(line, trans)
                    sys.stdout.write(line)
                    set_flag=True
            if(int(setter)<index) :
                with open("./criteria/"+fiat+"_"+bs_type+"_criteria.dat","a") as f:
                    if(set_flag==True) :
                        f.write("\n"+trans)
                    else :
                        f.write(trans)
        except Exception as e:
            print(e)

        
    def get_fomula(self) :
        return self.fomula_dict

    def get_operator(self) :
        return self.operator_dict

    def get_fom_type(self) :
        return self.fom_type_dict
            

class init_fomula :

    def read_raw_data() :
        crit = list()
        with open("./criteria/_init_criteria.dat","r") as f:
            data = f.read().split("\n")
            for i in range(len(data)) :
                if(i == 0):
                    tmp_line = data[i].split(" ")
                    crit.append([tmp_line[0].strip(),[tmp_line[1].split("/")[0].strip(),tmp_line[1].split("/")[1].strip()],tmp_line[2].strip()])
                elif(i == 1) :
                    tmp_line = data[i].split(" ")
                    crit.append([tmp_line[0].strip(),[tmp_line[1].split("/")[0].strip(),tmp_line[1].split("/")[1].strip()]])
                
        return crit

    def save_init(res) :
        with fileinput.FileInput("./criteria/_init_criteria.dat", inplace = True) as f :
            cnt = 0 
            for line in f:
                if(cnt == 0) :
                    write_line = res[cnt][0]+" "+res[cnt][1][0]+"/"+res[cnt][1][1]+" "+res[cnt][2]
                    line = line.replace(line,write_line+"\n")
                    sys.stdout.write(line)
                elif(cnt == 1) :
                    write_line = res[cnt][0]+" "+res[cnt][1][0]+"/"+res[cnt][1][1]
                    line = line.replace(line,write_line+"\n")
                    sys.stdout.write(line)
                cnt+=1 

    def criteria_list() :
        with open("./criteria/_init_criteria.dat","r") as f:
            data = f.read().split("\n")
        return data

변경점

• 21. 6. 28. add class local_loader, func gey_key()
• 21. 7. 3. add many class(fomula, init_fomual, history_maker, config_loader,cleaner)