Spaces:
Runtime error
Runtime error
File size: 4,647 Bytes
d9486d1 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
import json
import re
try:
from pylatexenc.latexencode import utf8tolatex, UnicodeToLatexEncoder
except:
print("Warning: Missing pylatexenc, please do pip install pylatexenc")
def _print_response(response_type: str, theorem_name: str, content: str, separator: str = "=" * 50) -> None:
"""Print formatted responses from the video generation process.
Prints a formatted response with separators and headers for readability.
Args:
response_type (str): Type of response (e.g., 'Scene Plan', 'Implementation Plan')
theorem_name (str): Name of the theorem being processed
content (str): The content to print
separator (str, optional): Separator string for visual distinction. Defaults to 50 equals signs.
Returns:
None
"""
print(f"\n{separator}")
print(f"{response_type} for {theorem_name}:")
print(f"{separator}\n")
print(content)
print(f"\n{separator}")
def _extract_code(response_text: str) -> str:
"""Extract code blocks from a text response.
Extracts Python code blocks delimited by ```python markers. If no code blocks are found,
returns the entire response text.
Args:
response_text (str): The text response containing code blocks
Returns:
str: The extracted code blocks joined by newlines, or the full response if no blocks found
"""
code = ""
code_blocks = re.findall(r'```python\n(.*?)\n```', response_text, re.DOTALL)
if code_blocks:
code = "\n\n".join(code_blocks)
elif "```" not in response_text: # if no code block, return the whole response
code = response_text
return code
def extract_json(response: str) -> dict:
"""Extract and parse JSON content from a text response.
Attempts to parse the response as JSON directly, then tries to extract JSON from code blocks
if direct parsing fails.
Args:
response (str): The text response containing JSON content
Returns:
dict: The parsed JSON content as a dictionary, or empty list if parsing fails
Note:
Will attempt to parse content between ```json markers first, then between generic ``` markers
"""
try:
evaluation_json = json.loads(response)
except json.JSONDecodeError:
# If JSON parsing fails, try to extract the content between ```json and ```
match = re.search(r'```json\n(.*?)\n```', response, re.DOTALL)
if not match:
# If no match for ```json, try to extract content between ``` and ```
match = re.search(r'```\n(.*?)\n```', response, re.DOTALL)
if match:
evaluation_content = match.group(1)
evaluation_json = json.loads(evaluation_content)
else:
# return empty list
evaluation_json = []
print(f"Warning: Failed to extract valid JSON content from {response}")
return evaluation_json
def _fix_unicode_to_latex(text: str, parse_unicode: bool = True) -> str:
"""Convert Unicode symbols to LaTeX source code.
Converts Unicode subscripts and superscripts to LaTeX format, with optional full Unicode parsing.
Args:
text (str): The text containing Unicode symbols to convert
parse_unicode (bool, optional): Whether to perform full Unicode to LaTeX conversion. Defaults to True.
Returns:
str: The text with Unicode symbols converted to LaTeX format
"""
# Map of unicode subscripts to latex format
subscripts = {
"₀": "_0", "₁": "_1", "₂": "_2", "₃": "_3", "₄": "_4",
"₅": "_5", "₆": "_6", "₇": "_7", "₈": "_8", "₉": "_9",
"₊": "_+", "₋": "_-"
}
# Map of unicode superscripts to latex format
superscripts = {
"⁰": "^0", "¹": "^1", "²": "^2", "³": "^3", "⁴": "^4",
"⁵": "^5", "⁶": "^6", "⁷": "^7", "⁸": "^8", "⁹": "^9",
"⁺": "^+", "⁻": "^-"
}
for unicode_char, latex_format in {**subscripts, **superscripts}.items():
text = text.replace(unicode_char, latex_format)
if parse_unicode:
text = utf8tolatex(text)
return text
def extract_xml(response: str) -> str:
"""Extract XML content from a text response.
Extracts XML content between ```xml markers. Returns the full response if no XML blocks found.
Args:
response (str): The text response containing XML content
Returns:
str: The extracted XML content, or the full response if no XML blocks found
"""
try:
return re.search(r'```xml\n(.*?)\n```', response, re.DOTALL).group(1)
except:
return response
|