diff --git a/qsl.py b/qsl.py index 7e29a13..06e8c9b 100644 --- a/qsl.py +++ b/qsl.py @@ -1,28 +1,158 @@ import adif_io import os -filename="hf23wtte.log.adi" -dist_directory = os.path.join(os.getcwd(), "dist") -qsos, headers = adif_io.read_from_file(filename) +def copy_files(current_path) -> str: + """ + The function `copy_files` copies specific files to a specified directory and returns the path to a + specific file. -for qso in qsos: - current_path = os.path.join(dist_directory, qso["CALL"].replace("/","-") + qso["TIME_ON"]) - os.mkdir(current_path) - if "EMAIL" in qso: - os.system("echo " +qso["EMAIL"]+ " >> "+ current_path + "/mail") + :param current_path: The `copy_files` function takes the `current_path` as a parameter, which is the + destination path where the files will be copied. The function copies four files (`qslf.pdf`, + `qsl_r.jpg`, `qsl.tex`, `qsl_r.tex`) from their respective source + :return: The function `copy_files` is returning the path to the copied file "qsl_r.tex" within the + specified `current_path`. The returned value will be in the format `current_path + "/qsl_r.tex"`. + """ os.system("cp ./tex/qslf.pdf " + current_path) - os.system("cp ./img/qsl_r.jpg "+current_path) + os.system("cp ./img/qsl_r.jpg " + current_path) os.system("cp ./tex/qsl.tex " + current_path) os.system("cp ./tex/qsl_r.tex " + current_path) - qsl_r_file = current_path + "/qsl_r.tex" + return current_path + "/qsl_r.tex" + + +def create_working_directory_for_qso(qso -> dict) -> str: + """ + This function creates a working directory for a QSO (amateur radio contact) based on the call sign + and time of the contact. + + :param dict: The function `create_working_directory_for_qso` takes a dictionary `qso` as input and + creates a working directory based on the values in the dictionary. The dictionary `qso` likely + contains information related to a radio communication contact, such as the call sign and time of the + contact + :return: A list containing the current path and the QSL directory name is being returned. + """ + qsl_directory = qso["CALL"].replace("/", "-") + qso["TIME_ON"] + current_path = os.path.join(dist_directory, qsl_directory) + os.mkdir(current_path) + return [current_path, qsl_directory] + + +def create_email_file_for_qso(email - > str, current_path -> str): + """ + The function `create_email_file_for_qso` appends an email address to a file named "mail" in the + specified directory. + + :param email: The `email` parameter is a string that represents the email address that you want to + write to a file + :param current_path: The `current_path` parameter is a string that represents the path to the + directory where you want to create the email file. This path should be the location where you want + to store the email file named "mail" + """ + os.system("echo " + email + " >> " + current_path + "/mail") + + +def update_qsl_content(qso -> dict, content -> str) -> str: + """ + The function `update_qsl_content` updates a given content string with specific values from a QSO + dictionary. + + :param dict: The `update_qsl_content` function takes two parameters: + :param content: The `content` parameter is a string that contains placeholders such as `[CALL]`, + `[TIME]`, `[FREQ]`, `[MODE]`, and `[RST-RECV]`. The function `update_qsl_content` takes a dictionary + `qso` and a string `content` + :return: The function `update_qsl_content` is returning a string with placeholders `[CALL]`, + `[TIME]`, `[FREQ]`, `[MODE]`, and `[RST-RECV]` replaced by corresponding values from the `qso` + dictionary. + """ + qso_call = qso["CALL"].replace("/", "{\\slash}") + qso_time = qso["TIME_ON"][:2] + ":" + qso["TIME_ON"][2:] + qso_freq = qso["FREQ"] + qso_mode = qso["MODE"] + + return content.replace( + "[CALL]", + qso_call).replace( + "[TIME]", + qso_time).replace( + "[FREQ]", + qso_freq).replace( + "[MODE]", + qso_mode).replace( + "[RST-RECV]", + qso["RST_SENT"]) + + +def write_qsl_template_for_qso(content -> str, qsl_r_file_name -> str): + """ + The function `write_qsl_template_for_qso` writes the provided content to a file with the specified + file name. + + :param content: The `content` parameter in the `write_qsl_template_for_qso` function is a string + that represents the content you want to write to a file. This content could be a template for a QSL + (confirmation of a two-way radio communication) that you want to save to a file + :param qsl_r_file_name: The `qsl_r_file_name` parameter is the name of the file where you want to + write the content. It should be a string representing the file name or the path to the file where + you want to save the content + """ + f = open(qsl_r_file_name, "w") + f.write(content) + f.close() + + +def generate_qsl_with_latex(qsl_directory): + """ + The function `generate_qsl_with_latex` executes a shell script `qsl.sh` with the provided directory + as an argument. + + :param qsl_directory: The `qsl_directory` parameter in the `generate_qsl_with_latex` function + represents the directory where the QSL (QSL cards) files are located. This function seems to be + calling a shell script named `qsl.sh` with the provided directory as an argument to generate QSL + """ + os.system("./qsl.sh " + qsl_directory) + + +def preparing_environment_for_generating_qsl_with_qso(qso -> dict): + """ + The function prepares the environment for generating QSL with QSO by creating a working directory, + copying files, and handling email information. + + :param dict: The function `preparing_environment_for_generating_qsl_with_qso` takes a dictionary + `qso` as input and performs the following tasks: + :return: The function `preparing_environment_for_generating_qsl_with_qso` is returning a list + containing the following items: + 1. The QSO dictionary with any modifications made during the preparation process. + 2. The filename of the copied QSL files. + 3. The directory where the QSL files are stored. + """ + current_path, qsl_directory = create_working_directory_for_qso(qso) + if "EMAIL" in qso: + create_email_file_for_qso(qso["EMAIL"], current_path) + qsl_r_file_name = copy_files(current_path) if "RST_SENT" not in qso: qso["RST_SENT"] = "-" - with open(qsl_r_file, "r") as f: - contents = f.read() - contents = contents.replace("[CALL]",qso["CALL"].replace("/","{\slash}")).replace("[TIME]",qso["TIME_ON"][:2]+":"+qso["TIME_ON"][2:]).replace("[FREQ]",qso["FREQ"]).replace("[MODE]",qso["MODE"]).replace("[RST-RECV]",qso["RST_SENT"]) - f.close() - f = open(qsl_r_file, "w") - f.write(contents) - f.close() - os.system("./qsl.sh " + qso["CALL"]+qso["TIME_ON"]) + return [qso, qsl_r_file_name, qsl_directory] + + +def generate_qsl_with_qso(qso -> dict): + """ + The function generates a QSL card using a QSO dictionary and LaTeX templates. + + :param dict: The `generate_qsl_with_qso` function seems to be a part of a larger script or program + related to generating QSL cards for amateur radio contacts + """ + qso, qsl_r_file_name, qsl_directory = preparing_environment_for_generating_qsl_with_qso( + qso) + with open(qsl_r_file_name, "r") as f: + content = update_qsl_content(f.read()) + + write_qsl_template_for_qso(content, qsl_r_file_name) + generate_qsl_with_latex(qsl_directory) + + +filename = "hf23wtte.log.adi" +dist_directory = os.path.join(os.getcwd(), "dist") + +qsos = adif_io.read_from_file(filename)[0] + +for qso in qsos: + generate_qsl_with_qso(qso)