DB prog-story - 27.01.2021-06:38 ... #1 ... #2 ... #3 ... #4 ... #5 ... #6 ... #7

#| #1 #2 #3 #4 #5 #6 #7
import f     # standardní funkce (prog-story 5989), 
#            Python 3.9.1, autor: Vlastimil Čevela, 25.1.2021

#1 datetime
# DaT = ""
#    f.datetime(DaT) ........ vrátí aktuální datum a čas (dd.mm.rrrr-hh:mm) 

#2 editace 
# C = 0/"", max 9999
# Str = ""
# Del = 0, max 60
#    f.eeee(C) ........ editace čísla do fix formátu, vrátí řetězec " .. CCCC" 
#    f.fix_str_b(Str,Del) ... k řetězci Str doplní mezery do délky Del
#    f.fix_str_p(Str,Del) ... k řetězci Str doplní tečky do délky Del

#3 listing (zápisy formou transakce)
# L = [datetime, listing.txt, archiv.txt, Tra, Lim]
# Tra = 1 .... trasování pomocí f.lst(L,F,Text)
# Lim = Int .. limit vstupních dat pro ukončení čtení
# F = "" ... název funkce pro trasování
#    f.lst_empty(L,New) ...... úvodní řádek, (if New = 0 open "a", else "w")
#    f.lst(L,F,Text) ......... běžný řádek (if Tra = 1 or Text = "*text")
#    f.lst_alw(L,F,Text) ..... řádek vypíše vždy
#    f.lst_datetime(L) ....... do L[0] vloží aktuální datum a čas   
#    f.lst_sez(L,Sez) ........ seznam po řádcích
#    f.lst_sez_alw(L,Sez) .... seznam vypisuje vždy
#    f.lst_sez_poz(L,Sez) .... seznam vč. pozic 

#4 seznamy 
# Sez = []
# Pol = ""/0
# InpF = ""
# OutF = ""
# X = []
# Y = []
# Sez2 = [X,Y]
# App = 0/jinak ... zápis na pokračování ne/ano 
#    Sez.append(Pol) ......... Py - přidá položku do seznamu
#    Sez.index(Pol) .......... Py - vrací pozici položky v seznamu / ValueError
#    f.sez_app_f(Sez,InpF) ... přidá do seznamu řádky textového souboru InpF
#    f.sez2_app_f(Sez2,InpF) . přidá do X a Y řádky textového souboru InpF
#    f.sez_ass(Sez2,Pol) ..... k položce v seznamu X vrátí odpovídající dle Y
#    f.sez_new(Sez,Pol) ...... přidá do seznamu položku, pokud tam nebyla
#    f.sez_out_f(Sez,OutF,App) ... vypíše seznam do souboru
#    f.sez_poz(Sez,Pol) ...... vrátí pozici položky v seznamu / "*"
#    f.sez_str(Sez) .......... vrátí celý seznam jako "str"
#    f.sez_sort(Sez) ......... setřídí seznam dle češtiny UTF-8

#5 skládání a spuštění skriptu
# FcePar ... parametry výstupních sestav (#0, ... dle Par v rámci J = [])
# FceInp ... procedury vstupů (#0, ... dle přiřazení *Inp ve FcePar)
# FceOut ... procedury (#0, ... dle přiřazení *Out ve FcePar)
# w ........ výsledný skript, sestavený z vybraných 3 komponent
#    f.ini_py(L) .................... vytvoří pracovní w_job.py
#    f.create_py(L,Job,Par) ......... postupně vybere komponenty wX.py
#      read_py(L,W,FilX,KodX,Out) ... detail čtení a výběru komponenty
#    f.end_py(L) .................... ohlásí ukončení skládání 
#    f.run_py(L,Par) ................ spustí pracovní skript w_job.py

#6 textové soubory
# InpF, OutF ...... jména souborů
# Text = "" ....... zapisovaný text
# App = 0/jinak ... zápis na pokračování ne/ano 
#    f.copy(L,InpF,OutF,App) ........ kopírování I>O, vypíše počet ř. 
#    f.write_trans(OutF,Text,App) ... zápis Textu jako transakce 

#7 změna skladby řádku
# Radek = "" ..... posloupnost "textX;"
# Inp = [] ....... shodná posloupnost "jméno-textuX" 
# Out = [] ....... nová posloupnost "jméno-textuX"
#    f.corr(Radek,Inp,Out) ... vrací řádek dle seznamu Out

 

... #1

## ------------------------------------------------------------------------------
DaT = ""
def datetime(DaT):
    import datetime
    x = datetime.datetime.now()
    DaT = x.strftime("%d")+"."+x.strftime("%m")+"."+x.strftime("%Y")+"-"+x.strftime("%H")+":"+x.strftime("%M")
    return DaT

... #2

## ------------------------------------------------------------------------------
Cis = ""
def eeee(Cis):
    if len(Cis) < 2:
        Cis = "..... "+Cis
    elif len(Cis) < 3:
        Cis = ".... "+Cis
    elif len(Cis) < 4:
        Cis = "... "+Cis
    else:
        Cis = ".. "+Cis
    return Cis

Str = ""
Del = 0
def fix_str_b(Str,Del):
          #0....*....1....*....2....*....3....*....4....*....5....*....6
    Mez = "                                                             "    
    Pom = Str[0:len(Str)]+Mez[0:(Del-len(Str))]
    return Pom
def fix_str_p(Str,Del):
          #0....*....1....*....2....*....3....*....4....*....5....*....6
    Tec = " ............................................................"     
    Pom = Str[0:len(Str)]+Tec[0:(Del-len(Str))]
    return Pom

... #3

## ------------------------------------------------------------------------------
New = 0
def lst_empty(L,New):
    F = "lst_empty"
    if New == 1:
        OutSb = str(L[1])
        Out = open(OutSb, "w")
        Out.close()
        lst(L,F," ")

L = []   
F = ""
Text = ""
def lst(L,F,Text):
    OutSb = str(L[1])
    if L[3] == 1 or Text[0:1] == "*":
        if Text[0:1] != "-":
            Out = open(OutSb, "a")
            Out.write("\n"+F+"/"+Text)
            Out.close()
def lst_alw(L,F,Text):
    OutSb = str(L[1])
    Out = open(OutSb, "a")
    Out.write("\n"+F+"/"+Text)
    Out.close()

def lst_datetime(L):
    import datetime
    x = datetime.datetime.now()
    L[0] = x.strftime("%d")+"."+x.strftime("%m")+"."+x.strftime("%Y")+"-"+x.strftime("%H")+":"+x.strftime("%M")
    return L

Sez = []
def lst_sez(L,Sez):
    for Pol in Sez:      
        lst(L,"... ",str(Pol))
Max = 0        
def lst_sez_alw(L,Sez,Max):
    Poc = 1
    for Pol in Sez:
        if Poc > Max:
            break
        lst_alw(L,"... ",str(Pol))
        Poc += 1

def lst_sez_poz(L,Sez):
    Poz = 0
    for Pol in Sez:
        Poz += 1
        Pom = str(Poz)+" ... "
        lst_alw(L,Pom,str(Pol))

... #4

## ------------------------------------------------------------------------------
Sez = []
Pol = 0
InpF = ""
def sez_app_f(Sez,InpF):
    Inp = open(InpF, "r")
    for Radek in Inp.readlines():
        Radek = Radek.strip(",\n")
        Sez.append(Radek)
    Inp.close()
    return Sez

X = []
Y = []
Sez2 = [X,Y]
def sez2_app_f(Sez2,InpF):
    Inp = open(InpF, "r")
    for Radek in Inp.readlines():
        Rad = Radek.strip("\n")
        Rad = Rad.split(";")
        Sez2[0].append(Rad[0])
        Sez2[1].append(Rad[1])
    Inp.close()
    return Sez2

def sez_ass(Sez2,Pol):
    Poz = f.sez_poz(Sez2[0],Pol)
    if Poz != "*":
        New = Sez2[1][Poz]
    else:
        New = "*"
    return New

def sez_new(Sez,Pol):
    try:
        Poz = Sez.index(Pol)
    except ValueError:
        Sez.append(Pol)
    return Sez

OutF = ""
App = 0
def sez_out_f(L,Sez,OutF,App):
    F = "sez_out_f"
    if App == 0:
        Out = open(OutF, "w")
    else:    
        Out = open(OutF, "a")
    Poc = 0    
    for Pol in Sez:
        Out.write(str(Pol)+"\n")
        Poc += 1
    Out.close()
    f.lst(L,F,str(Poc))


def sez_poz(Sez,Pol):
    try:
        Pol = Sez.index(Pol)
        return Pol
    except ValueError:
        Pom = "*"
        return Pom
    
def sez_str(Sez):
    Pom = ""
    for Pol in Sez:      
        Pom = Pom+str(Pol)+","
    return Pom

def sez_sort(Sez):
    import locale
    locale.setlocale(locale.LC_ALL,'czech')
    Sez.sort(key=locale.strxfrm)

... #5

## -------------------------------------------------------
L = []
Par = 0
Step = 0
def ini_py(L):
    F = "ini_py"
    lst(L,F," ")
    Job = open("w_job.py", "w")
    Job.write("# pracovni job: \n")
    Job.write("L = [] \n")
    Job.write("P = [] \n")
    Job.write("D = [] \n")
    Job.write("def job(L,P,D): \n")
    Job.write("    import f \n")
    Job.close()
def end_py(L):
    F = "end_py"
    lst(L,F," ")

    
def create_py(L,Par,W,Step):
    F = "create_py"
    W = ["FcePar.py", "-", "FceInp.py", "-", "FceOut.Py", "-", 0, 0]
    W[1] = "#"+str(Par)
    W[7] = str(Step)

    Job = open("w_job.py", "a")
    Job.write("    import w"+str(Step)+"\n")
    Job.write("    w"+str(Step)+".inp(L,w"+str(Step)+".par(L,P),D) \n")
    Job.close()
    
    FilW = "w"+str(Step)+".py"
    Out = open(FilW, "w")
    Out.write("import f, c \n")   
    Out.close()
    
    read_py(L,W,W[0],W[1],Out,FilW)  
    read_py(L,W,W[2],W[3],Out,FilW)  
    read_py(L,W,W[4],W[5],Out,FilW)  


    Pom = " W: "+sez_str(W)
    lst_alw(L,F,Pom)
    return W

W = []
FilX = ""
KodX = ""
FilW = ""
def read_py(L,W,FilX,KodX,Out,FilW):
    Out = open(FilW, "a")
    F = "read_py"
    Pom = "-1: "+sez_str(W)
    lst(L,F,Pom)
    Inp = open(FilX, "r")
    Pla = 0
    for Radek in Inp.readlines():
        A = Radek.strip("\n")
        B = A.split(",")
        if B[0] == KodX:
            if W[3] == "-":
                W[3] = B[1]
                W[5] = B[2]
            Pla = 1
        if A[0:2] == "# ":
            Pla = 0
        if Pla == 1:
            Out.write(Radek)
            W[6] += 1

    Pom = "-2: "+sez_str(W)
    lst(L,F,Pom)
    Inp.close()
    Out.close()
    return W


L = []
def run_py(L):
    lst_alw(L," "," ")
    F = "run_py"
    lst(L,F," ")
    import w_job
    P = []
    D = []
    w_job.job(L,P,D)

... #6

## ------------------------------------------------------------------------------
InpF = ""
OutF = ""
App = 0
def copy(L,InpF,OutF,App):
    F = "copy"
    Inp = open(InpF, "r")
    if App == 0:
        Out = open(OutF, "w")
    else:    
        Out = open(OutF, "a")
    Poc = 0
    for Radek in Inp.readlines():
        Poc += 1
        Out.write(Radek)
    Inp.close()
    Out.close()
    Pom = "*"+InpF+","+OutF+","+Q+", počet řádků: "+str(Poc)
    lst(L,F,Pom)

OutF = ""
Text = ""
App = 1
def write_trans(OutF,Text,App):
    if App == 0:
        Out = open(OutF,"w")
    else:
        Out = open(OutF,"a")
    Out.write(Text)
    Out.close()

... #7

## ------------------------------------------------------------------------------
Radek = ""
Inp = []
Out = []

def corr(Radek,Inp,Out):    
    Rad = Radek.split(";")
    Radek = ""
    if len(Out) == 2 and Out[1] == "*/":
        Pol = Out[0]
        Poz = Inp.index(Pol)
        Radek = Radek + Rad[Poz] + ";"
    else:
        for Pol in Out:
            Poz = Inp.index(Pol)
            try:
                Radek = Radek + Rad[Poz] + ";"
            except ValueError:
                Radek = Radek + "Err *****;"
#   Radek = Radek[0:len(Radek)-1]
    return Radek

#/