brianr/SM2Gen
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f4fc0394f7
SM2Gen/sm2gen.py

902 lines
31 KiB
Python
Raw Blame History

import json5
import sys
import argparse
from chameleon import PageTemplateFile, PageTemplate
import pkg_resources
import xml.etree.ElementTree as ET
import re
from openai import OpenAI
import configparser
import json
from pathlib import Path
import traceback
import os
from datetime import datetime, timedelta
from spellchecker import SpellChecker
import logging
#
# To Do
# 1. Get routing working
# 2. Deal with ? and ! as sentence ends in text-format
# 3. Make lexical scan work with double or single quotes (if possible)
SME2Gen_version = "0.8"
json5_dict: dict = {}
json5_html_list: list = []
# Define the path to the INI file
ini_file_path = os.path.expanduser("~/.smegit/conf")
OPENAI_API_KEY = ""
# Configure the basic logging system
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
# Create a logger
logger = logging.getLogger(__name__)
def example_function(**kwargs):
logger.info(kwargs)
def spell_check_and_correct(text):
try:
# Initialize the spell checker
spell = SpellChecker()
# Tokenize the text into words
words = text.split()
# Create a new list to store corrected words
corrected_words = []
for word in words:
# Skip words that are entirely uppercase
if word.isupper():
corrected_words.append(word)
continue
# Check if the word is correctly spelled
if word in spell:
# Word is correct, add the original word
corrected_words.append(word)
else:
# Word is misspelled, get the correction
correction = spell.correction(word)
# If a correction is found, use it; otherwise, keep the original word
corrected_words.append(correction if correction else word)
# Join the corrected words back into a single string
corrected_text = ' '.join(corrected_words)
except:
logger.warning(f"Spelling checker exception ({text})")
return text
return corrected_text
def python_to_perl_structure(data):
#logger.info(data)
if data:
if isinstance(data, list):
# Convert each dictionary in the list to Perl format: ['text' => 'value']
elements = [
f"['{item['Text']}' => '{item['Value']}']"
for item in data
]
return '[' + ', '.join(elements) + ']'
else:
raise TypeError("Expected a list of dictionaries")
return ""
def assemble_version_string():
try:
chameleon_version = pkg_resources.get_distribution("Chameleon").version
except pkg_resources.DistributionNotFound:
chameleon_version = "No version information"
python_version = sys.version
version_pattern = r"(\d{1,3}\.\d{1,3}\.\d{1,3})"
version_match = re.search(version_pattern, python_version)
python_version = version_match.group(0) if version_match else "Unknown"
current_datetime = datetime.now()
formatted_datetime = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
strVersion = (
"SM2Gen version:"
+ SME2Gen_version
+ " Chameleon version:"
+ chameleon_version
+ " On Python:"
+ python_version
+ " at "
+ formatted_datetime
)
return strVersion
def parse_json(json_obj, prefix=""):
structured_list = []
if isinstance(json_obj, dict):
for k, v in json_obj.items():
new_key = f"{prefix}.{k}" if prefix else k
structured_list.extend(parse_json(v, new_key))
elif isinstance(json_obj, list):
for i, v in enumerate(json_obj):
new_key = f"{prefix}[{i}]"
structured_list.extend(parse_json(v, new_key))
else:
structured_list.append(f"{prefix}: {json_obj}")
return structured_list
def json5_to_list(filename):
with open(filename, "r") as file:
data = json5.load(file)
return parse_json(data)
def json5_to_pandas(filename):
with open(filename, "r") as file:
data = json5.load(file)
logger.debug(data)
return data.json_normalize(data)
def json5_to_dict(filename):
with open(filename, "r") as file:
data = json5.load(file)
return data
def rec_print(data, prefix=""):
# Check if this item is a dictionary.
if isinstance(data, dict):
for key, val in data.items():
rec_print(val, f"{prefix}.{key}")
# Check if this item is a list.
elif isinstance(data, list):
for idx, val in enumerate(data):
rec_print(val, f"{prefix}[{idx}]")
# If neither, it's a basic type.
else:
logger.info(f"{prefix}: {data}")
def find_item(nested_dict, target_key):
for key, val in nested_dict.items():
if key == target_key:
return val
elif isinstance(val, dict):
result = find_item(val, target_key)
if result is not None:
return result
def find_dicts_with_key(data, target_key):
results = []
if isinstance(data, dict):
if target_key in data:
results.append(data)
for val in data.values():
if isinstance(val, (dict, list)):
results.extend(find_dicts_with_key(val, target_key))
elif isinstance(data, list):
for item in data:
if isinstance(item, (dict, list)):
results.extend(find_dicts_with_key(item, target_key))
return results
def find_values_with_key(data, target_key):
results = []
if isinstance(data, dict):
if target_key in data:
results.append(data[target_key])
for val in data.values():
if isinstance(val, (dict, list)):
results.extend(find_values_with_key(val, target_key))
elif isinstance(data, list):
for item in data:
if isinstance(item, (dict, list)):
results.extend(find_values_with_key(item, target_key))
return results
def lint_json5(filename):
try:
with open(filename, "r") as file:
data = file.read()
json5.loads(data)
logger.info(f"{filename} as JSON5 data is valid")
except Exception as e:
logger.warning(f"{filename} as JSON5 data is invalid")
logger.warning("Error:", str(e))
sys.exit()
def flatten_hash_of_lists(hash_of_lists):
flattened = {}
for key, value in hash_of_lists.items():
if isinstance(value, list):
for i, item in enumerate(value):
new_key = (
f"{key}_{i}" # Appending index to the key to maintain uniqueness
)
flattened[new_key] = item
else:
flattened[key] = value
return flattened
def hl(keyname):
# Return highest level value for the keyname
if keyname in json5_dict:
return json5_dict[keyname]
else:
logger.warning(f"{keyname} not found in JSON5 - top level")
return "None"
def get_all_routes():
route_list = [html_block.get("route") for html_block in json5_dict.get("html", [])]
return route_list
def lc_get_all_routes():
# All routes in lower case
route_list = [
html_block.get("route").lower() for html_block in json5_dict.get("html", [])
]
return route_list
def has_file_been_modified(file_path):
# Get the file's creation time and last modification time in Unix timestamp
creation_time = os.path.getctime(file_path)
last_modification_time = os.path.getmtime(file_path)
logger.debug(f"{creation_time}*{last_modification_time}")
quit()
# Compare the creation time and last modification time
if creation_time < last_modification_time:
return True # File has been modified after creation
else:
return False # File has not been modified after creation
def parse_xml_to_dict(xml_file):
# Parse the XML file
tree = ET.parse(xml_file)
root = tree.getroot()
xml_dict = {} # Initialize an empty dictionary to store the data
# Iterate through the XML tree and extract data
for elem in root:
tag = elem.tag
if elem.text:
xml_dict[tag] = elem.text
else:
cdata_content = elem.find(".//").text # Extract CDATA text
xml_dict[tag] = cdata_content
return xml_dict
def deduplicate_array(arr):
# Convert the array to a set to remove duplicates
unique_set = set(arr)
# Convert the set back to a list to maintain the order
deduplicated_list = list(unique_set)
return deduplicated_list
def get_db_fields():
return []
def get_table_control_data():
return find_values_with_key(json5_html_list, "TableControl")
def extract_tables(json_data):
result = {}
# Iterate over the 'html' list in the JSON data
for item in json_data.get('html', []):
if isinstance(item, dict):
for key, value in item.items():
if isinstance(value, dict):
if value.get('Type') == 'Table' and 'TableControl' in value:
table_control = value['TableControl']
columns = value.get('Columns', [])
result[table_control] = {'columns': columns}
return result
def format_text(text):
#
# Turn a piece of text into something a bit better formatted - spaces after full stop and comma and also capitalise sentences
#
# Create a list to hold the formatted sentences
formatted_sentences = []
# Split the text into sentences
sentences = text.split(".")
words = sentences[0].split(" ")
# Deal with one capitalised word
if sentences[0].isupper() and len(sentences) == 1 and len(words) == 1:
return sentences[0].capitalize()
else:
for sentence in sentences:
# and splt into sub phrases, based on comma
formatted_phrases = []
phrases = sentence.split(",")
for phrase in phrases:
phrase = phrase.lstrip()
formatted_words = []
words = phrase.split(" ")
for i, word in enumerate(words):
# Check if the word is fully uppercase or not the first
word = word.lstrip()
if word.isupper() or i != 0:
formatted_words.append(word)
else:
# Capitalize the word
formatted_words.append(word.capitalize())
# Join the formatted words back together for this phrase
formatted_phrase = " ".join(formatted_words).lstrip()
formatted_phrases.append(formatted_phrase)
# and sentence
formatted_sentence = ", ".join(formatted_phrases).lstrip()
formatted_sentences.append(formatted_sentence)
# Join the formatted sentences back together
formatted_text = ". ".join(formatted_sentences).lstrip()
return spell_check_and_correct(capitalize_words_if_all_caps(formatted_text))
def get_completion(prompt):
#
# temperature: Controls the randomness of the response. Lower values make the output more focused and deterministic, while higher values make it more creative and random.
# top_p: Controls the diversity of the response. It relates to nucleus sampling, where the model considers only the tokens with the top p probability mass.
# n: Number of completions to generate for each prompt.
# stop: A string or list of strings. Up to 4 sequences where the API will stop generating further tokens. The returned text will not contain the stop sequence.
# presence_penalty: A number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
# frequency_penalty: A number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
# logit_bias: A dictionary that allows you to manipulate the likelihood of specified tokens appearing in the output.
#
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
temperature=0,
max_tokens=100,
)
# Extracting the content message from the JSON data
response_data = response.to_dict()
content_message = response_data["choices"][0]["message"]["content"]
return content_message.strip()
def get_translation(message="Hello", language="french"):
prompt = f"""Translate the following text in triple ~~~ so that it is suitable for a server management application menu
and only return the actual translation; translate it from from English to {language} ~~~{message}~~~"""
translated_message = get_completion(prompt)
# Look for over long messages
if len(message) / len(translated_message) < 0.2:
logger.error(f"{message} translated to {translated_message}")
quit()
return translated_message
import os
from datetime import datetime, timedelta
def check_file_version(filename,force_Files=False):
#
# Check modified versus creation date of the file and return +".new" if modified since creation + ThresholdSecs
#
if force_Files:
return filename
ThresholdSecs = 3 #allow secs since creation date before treat as changed.
try:
with open(filename, 'r') as file:
# Read the first three lines
header_lines = [file.readline().strip() for _ in range(5)]
# Extract the timestamp
timestamp_str = None
for line in header_lines:
if ' at ' in line:
# Split at 'at', expect the timestamp to be in the third part
timestamp_str = line.split('at')[2].strip()
break
if timestamp_str is None:
logger.warning("Warning: No timestamp found. Returning original filename.")
return filename # Return the original filename if no timestamp is found
# Convert the string timestamp to a datetime object
file_timestamp = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
# Add the threshold seconds to the creation date
file_timestamp += timedelta(seconds=ThresholdSecs)
# Get the last modified time of the file, ignoring milliseconds
file_modified_time = datetime.fromtimestamp(os.path.getmtime(filename)).replace(microsecond=0)
# Compare the timestamps
if file_modified_time > file_timestamp:
return f"{filename}.new"
else:
return filename
except FileNotFoundError:
logger.warning(f"Error: The file '{filename}' does not exist.")
return filename
except Exception as e:
logger.warning(f"An error occurred: {traceback.format_exc()}")
return filename
def convert_lex_to_dict(pairs_string):
# Splitting pairs string by comma and newline, excluding empty lines
pairs_list = [line for line in pairs_string.split(",\n") if line.strip()]
data_dict = {
pair.split(" => ")[0].strip("'"): pair.split(" => ")[1].strip("'")
for pair in pairs_list
}
formatted_dict = [{"id": key, "text": value} for key, value in data_dict.items()]
return formatted_dict
def capitalize_words_if_all_caps(s):
# Check if all characters in the string are uppercase or spaces
if s.replace(" ", "").isupper():
# Capitalize each word
return s.title()
else:
return s
def extract_input_fields(json_data, value_type):
result = {}
# Pattern to identify and strip the specified value type and surrounding brackets
pattern = re.compile(rf"{value_type}\((.*?)\)")
# Iterate over each panel in the 'html' array
for panel in json_data['html']:
panel_name = panel['route']
# Initialize an empty list for each panel
result[panel_name] = []
# Iterate over each item in the panel
for key, value in panel.items():
if key.startswith('Input') and isinstance(value, dict):
if value.get('Type').lower() in ['readonlytext', 'text', 'select','checkbox','textarea','email']:
# input_value = value.get('Value', '')
input_name = value.get('Name', '')
logger.debug(input_name)
# # Match and extract the value without the value_type and parentheses
# match = pattern.search(input_value)
# if match:
# # Extract the inner content of the matching pattern
# clean_value = match.group(1)
# # Take out any double quotes
# clean_value = clean_value.replace('"','')
# # Add the clean value to the list for the current panel
# result[panel_name].append(clean_value)
result[panel_name].append(input_name)
# Note: Empty lists are not removed, so all panels will be present in the result
return result
if __name__ == "__main__":
strVersion = assemble_version_string()
json5_dict: dict = {}
json5_html_list: list = []
logger.info(f"SM2 code from JSON5 - {strVersion}")
home_dir = "/home/brianr/clients/SM2/SM2Gen/"
json_filename = f"{home_dir}/json5/nfsshare.json5" # CreateStarterWebsite.json5"
# read open ai key from ini file
# Check if the file exists
if os.path.exists(ini_file_path):
# Create a configparser object and read the file
config = configparser.ConfigParser()
config.read(ini_file_path)
# Read the value of "OPENAI_API_KEY"
if "OPENAI_API_KEY" in config["smegit"]:
OPENAI_API_KEY = config["smegit"]["OPENAI_API_KEY"]
# logger.info("API Key:", OPENAI_API_KEY)
client = OpenAI(api_key=OPENAI_API_KEY)
else:
logger.info("OPENAI_API_KEY not found in the configuration file.")
else:
logger.info("Configuration file not found at:", file_path)
# Command line parameters - not in use
parser = argparse.ArgumentParser(description="SM2Gen")
parser.add_argument(
"-f",
"--filename",
help="Specify a filename for the JSON5 file",
default=json_filename,
)
parser.add_argument(
"--force",
action = 'store_true',
help="Force an overwrite of all files",
)
parser.add_argument(
"--noController",
action = 'store_false',
help="Stop it creating a controller file (not currently implemented)",
)
parser.add_argument(
"--noHtml",
action = 'store_false',
help="Stop it creating html files(s) (not currently implemented)", default=False
)
parser.add_argument(
"--noLang",
action = 'store_false',
help="Stop it creating language localise files(s)",
)
parser.add_argument(
"--noCust",
action = 'store_false',
help="Stop it creating Custom controller file (not currently implemented)",
)
args = parser.parse_args()
json_filename = args.filename
logger.info(
f"JSON5 from {json_filename} with noController={args.noController}, noHtml={args.noHtml} and noLang={args.noLang}"
) # Not yet activated
# check if json5 file exists
json_file_path = Path(json_filename)
if not json_file_path.exists():
logger.info(f"json5 file: {json_filename} not found")
quit(1)
# check syntax of JSON5
lint_json5(json_filename)
# Get dict of it all
try:
json5_dict = json5_to_dict(json_filename)
except Exception as e:
logger.info(f"json5 file {json_filename} failed lint test (e)")
quit(1)
# Get dict of just the html bit
json5_html_list = json5_dict["html"]
# Identify message
logger.info(f"Generating mojo panels for {hl('PackageName')}")
logger.info("-----------------------------------")
# Routes for each panel
routes = get_all_routes()
lc_routes = lc_get_all_routes()
#
# File names
#
# Define the path for the generated files
# force them to be overwritten
force_Files = args.force
directory_path = Path("Targets/" + hl("PackageName"))
# Create the directory if it doesn't exist
directory_path.mkdir(parents=True, exist_ok=True)
target_directory_path = "Targets/" + hl("PackageName") + "/"
controller_file = check_file_version(target_directory_path + hl("PackageName") + ".pm",force_Files)
custom_controller_file = check_file_version(target_directory_path + hl("PackageName") + "-Custom.pm",force_Files)
#logger.info(custom_controller_file)
layout_file = check_file_version(target_directory_path + hl("PackageName").lower() + ".html.ep",force_Files)
css_file = check_file_version(target_directory_path + hl("PackageName").lower() + ".css",force_Files)
partial_files = list()
for panel in routes:
partial_files.append(check_file_version(
target_directory_path + '_' + hl("prefix") + "_" + panel + ".html.ep",force_Files)
)
logger.debug(f"Partial files to be created:{partial_files}")
lex_file = check_file_version(target_directory_path + hl("PackageName").lower() + "_en.lex",force_Files)
logger.info(lex_file)
tablecontrols = extract_tables(json5_dict)
# arrays of hashes used to drive rows in tables
# Generate controller file
dbfields = [] #extract_input_fields(json5_dict, 'db') # Params which correspond to Db fields - TBD
logger.debug(f"{tablecontrols}")
logger.debug(f"{tablecontrols.items()}")
#quit(1)
try:
controller_template = PageTemplateFile(
"Templates/controller.pm.tem", CHAMELEON_DEBUG="true"
)
try:
controller_perl = controller_template.render(
version=strVersion,
tablecontrols=tablecontrols.items(),
dbfields=dbfields,
**json5_dict,
panels=routes,
lcPackageName=json5_dict["PackageName"].lower(),
)
with open(controller_file, "w") as file:
file.write(controller_perl)
logger.info(f"{controller_file} controller generated ok")
except Exception as e:
logger.info(f"A Chameleon controller render error occurred: {e} {traceback.format_exc()}")
except Exception as e:
logger.info(f"A Chameleon controller template error occurred: {e} {traceback.format_exc()}")
# Generate Custom controller file
try:
custom_controller_template = PageTemplateFile("Templates/custom.pm.tem")
fields = extract_input_fields(json5_dict, 'stash') # Params which correspond to singleton values
#flatfields = flatten_hash_of_lists(fields)
#logger.info(fields)
#quit(0)
try:
custom_controller_perl = custom_controller_template.render(
version=strVersion,
panels=routes,
tablecontrols=tablecontrols.items(),
fields=fields,
dbfields=dbfields
)
# We must be careful to not overwrite the custom file if the developer has already written to it - TBD
with open(custom_controller_file, "w") as file:
file.write(custom_controller_perl)
logger.info(f"{custom_controller_file} custom controller generated ok")
except Exception as e:
logger.info(f"A Chameleon custom controller render error occurred: {e} {traceback.format_exc()}")
except Exception as e:
logger.info(f"A Chameleon custom controller template error occurred: {e} {traceback.format_exc()}")
# generate Layout file
layout_template = PageTemplateFile("Templates/layout.html.ep.tem")
try:
try:
layout_mojo = layout_template.render(
version=strVersion, **json5_dict, conditions=routes,
lcPackageName=json5_dict["PackageName"].lower()
)
with open(layout_file, "w") as file:
file.write(layout_mojo)
logger.info(f"{layout_file} mojo template layout file generated ok")
except Exception as e:
logger.info(f"A Chameleon render on layout file error occurred: {e}")
except Exception as e:
logger.info(f"A Chameleon template layout file error occurred: {e}")
# Generate a partial file for each of the entries in the html list
# Pull in the template code for each of the input types
# html_controls = json5_to_dict('Templates/html_controls.html.ep.tem')
html_controls = parse_xml_to_dict("Templates/html_controls.html.ep.xml")
i = 0
acc_css_entries = ""; #One entry for each class created for html entries
for html in json5_html_list:
# Generate a mojo template file, and then add in the controls
# main file first
try:
partial_template = PageTemplateFile("Templates/partial.html.ep.tem")
partial_mojo_context = {**json5_dict, **html}
try:
partial_mojo_template = partial_template.render(
version=strVersion, **partial_mojo_context,
lcPackageName=json5_dict["PackageName"].lower()
)
with open(partial_files[i], "w") as file:
file.write(partial_mojo_template)
logger.info(f"{partial_files[i]} mojo template generated ok - phase 1")
except Exception as e:
logger.info(
f"A Chameleon render error on partial file {html['route']} occurred: {e}"
)
except Exception as e:
logger.info(f"A Chameleon html {html['route']} error occurred: {e}")
# Now generate the controls from the rest of the entries in the dict.
all_controls_html = ""
prefix_is = hl("prefix")
for html_control in html:
inner_html = html[html_control]
if isinstance(inner_html, dict):
# input or table
html_Type = inner_html['Type']
type_serial = "".join(char for char in html_control if char.isdigit())
class_name = html_Type.lower()[:4]+type_serial
acc_css_entries += f".{class_name} {{}}\n"
OptionsInPerl = python_to_perl_structure(inner_html.get("Options", ""))
#if html_Type == "Select":
# example_function(**inner_html)
# quit(1)
if html_Type == "Table":
acc_css_entries += f"thead .{class_name} {{}}\n"
acc_css_entries += f"tbody .{class_name} {{}}\n"
try:
control_template = PageTemplate(html_controls[inner_html["Type"]])
try:
control_html = control_template.render(
version=strVersion, **inner_html, prefix=prefix_is,
classname=class_name,
type_serial=type_serial,
OptionsInPerl=OptionsInPerl
)
all_controls_html = all_controls_html + control_html
except Exception as e:
logger.info(
f"A Chameleon render on partial file control {html_control} error occurred: {e}"
)
except Exception as e:
logger.info(
f"A Chameleon render on partial file control {html_control} error occurred: {e}"
)
else:
# just a simple entry - name less numerics is type
html_Type = "".join(char for char in html_control if not char.isdigit())
type_serial = "".join(char for char in html_control if char.isdigit())
class_name = html_Type.lower()[:4]+type_serial
acc_css_entries += f".{class_name} {{}}\n"
if not type_serial == "":
logger.debug(f"{html_control},{html_Type},{type_serial}")
try:
simple_control_template = PageTemplate(html_controls[html_Type])
try:
simple_control_html = simple_control_template.render(
version=strVersion, Value=inner_html, prefix=prefix_is,
type_serial=type_serial
)
all_controls_html = all_controls_html + simple_control_html
except Exception as e:
logger.warning(
f"A Chameleon render on partial file control {html_control} error occurred: {e}"
)
except Exception as e:
logger.warning(
f"A Chameleon template partial file control {html_control} error occurred: {e}"
)
# Now insert it into the partial file in the correct place.
# Read in the text file and split at "%# Inputs etc in here."
with open(partial_files[i], "r") as file:
lines = file.readlines()
index = next(
(i for i, line in enumerate(lines) if "%# Inputs etc in here." in line),
len(lines),
)
# Insert the string at the specified index
lines.insert(index + 1, all_controls_html + "\n")
# Write the modified content back to the file
with open(partial_files[i], "w") as file:
file.writelines(lines)
logger.info(f"Content modified and saved to {partial_files[i]}")
i += 1
# Create the css file (the header, followed by a dumy entry for each class created/used above)
with open(css_file, "w") as file:
file.write(f"/*\nGenerated by SM2Gen version: {strVersion}\n*/\n")
file.write(f".{hl('PackageName')}-panel {{}}\n")
file.write(acc_css_entries);
# Now generate the <name>.en file
# Look through the generated files for the /l[\s|(]['|"](.*)['|"]\)/ strings.
# create a combined list of all the files
all_files = [controller_file, layout_file] + partial_files
all_strings = []
for filename in all_files:
with open(filename, "r") as file:
file_content = file.read()
# Define the regular expression pattern to match the strings you want to extract
pattern = r"l[\s|(][\'|\"](.*)[\'|\"]\)"
# Use re.findall to extract all occurrences of the pattern from the file content
extracted_strings = re.findall(pattern, file_content)
all_strings = all_strings + extracted_strings
# Take out any duplicates
all_strings = deduplicate_array(all_strings)
# '<prefix>_english-message' => 'English Message',
string_lib = [] # Array of dicts
for lex_message in all_strings:
# If has a prefix - leave it for left hand side but delete it for the right
# If has no prefix - add one for left hand side but and leave it for the right
# Map all spaces to "_" on left hand side
# amd truncate it to max five words
original_str = lex_message
# Checkif it starts with the prefix (any case|)
if lex_message.lower().startswith(hl("prefix").lower()):
left_str = lex_message
right_str = lex_message[len(hl("prefix")) + 1 :]
# And take out any "_", map to " "
else:
left_str = hl("prefix") + "_" + lex_message
right_str = lex_message
right_str = right_str.replace("_", " ")
right_str = format_text(right_str)
left_str = left_str.replace(" ", "_")
words = left_str.split("_")[:6]
left_str = "_".join(words)
next_lex_str = {"orig": original_str, "left": left_str, "right": right_str}
string_lib.append(next_lex_str)
# And write it to lex file
# Now process them one by one into the lexical file
lex_all = ""
for lex_str in string_lib:
lex_all += f"'{lex_str['left']}' => '{lex_str['right']}',\n"
logger.info(f"Writing {lex_file}")
with open(lex_file, "w") as file:
file.write(f"#\n# Generated by SM2Gen version: {strVersion}\n#\n")
file.write(lex_all)
# and then play the strings back into the partials and the layout file
logger.debug("..and feed the lex string names back into other files")
for filename in all_files:
with open(filename, "r") as file:
file_content = file.read()
# Scan through
for item in string_lib:
original_str = item["orig"]
left_str = item["left"]
right_str = item["right"]
# Replace all occurrences of original string with left string in 'contents'
file_content = file_content.replace(
"l('" + original_str + "')", "l('" + left_str + "')"
)
# and write it back
with open(filename, "w") as file:
file.write(file_content)
logger.info(f"Write out modified:{filename}")
# Now generate all the translated lex files from a list of the languages and codes
# if specifically requested
if args.noLang:
languages_path = "Templates/languages.json"
with open(languages_path, "r") as file:
languages_str = file.read()
lang_dict = json.loads(languages_str)
with open(lex_file, "r") as file:
lex_str = file.read()
eng_lex_dict = convert_lex_to_dict(lex_str)
for lang_item in lang_dict:
logger.info(f"Translating from english lex file to {lang_item['language']}")
code = lang_item["code"]
translated_lex_file = check_file_version(
f"{target_directory_path}{hl('PackageName').lower()}_{code}.lex"
)
# Only do it if the lex file is missing - Removed bjr 18Sept2024
#if not os.path.exists(translated_lex_file):
translated_dict = []
for lex_item in eng_lex_dict:
# Get it from ChatGPT
translated_text = get_translation(
lex_item["text"], lang_item["language"]
)
translated_dict.append(
{"id": lex_item["id"], "text": translated_text}
)
logger.info(f"Writing out lex file for {lang_item['code']}")
with open(translated_lex_file, "w") as file:
file.write(f"#\n# Generated by SM2Gen version: {strVersion}\n#\n")
for item in translated_dict:
# escape any nasties
translated_text = (
item["text"]
.replace("\\", r"\\")
.replace('"', r"\"")
.replace("'", r"\'")
)
line = (
"'" + item["id"] + "' => " + '"' + translated_text + '",\n'
)
file.write(line)
# logger.info(f"{item['id']} => {item['text']}\n")
#else:
# logger.info(
# f"Skipping the creation of {translated_lex_file} as it exists already"
# )
quit() # end of the program
Reference in New Issue View Git Blame Copy Permalink