UzonCalc User Guide

UzonCalc is a Python-based tool for hand-written engineering calculation reports. You only need to focus on writing content and calculation logic, without worrying about calculation results, layout, and other details. UzonCalc automatically substitutes values, calculates results, and generates polished calculation report documents, including tables of contents, mathematical formulas, tables, charts, and more. UzonCalc supports unit calculation and Excel table calculation calls, which makes it well suited to engineering calculation reports. By calling formulas in Excel, you can reuse existing Excel calculation models and reduce migration cost.

Key features:

UzonCalc is very simple to use. You do not need to be proficient in Python. If you have experience using formulas in Excel, you can get started, and you can treat every operation as a function call.

UZONCALC_TOC_HEADING:heading-0|Installation and Usage

UZONCALC_TOC_HEADING:heading-1|Windows Desktop Installation

The desktop app provides extra features such as calculation report management and UI input, and is intended for users. If you are a calculation report author, the CLI method below is recommended. It can be used with VS Code for automatic formatting and syntax checking to improve authoring efficiency.

Install the desktop app as follows:

1. Download the software

2. Copy the following code into the new editor box

from uzoncalc import *

@uzon_calc()
async def sheet():
    doc_title("example")

    "Hello, UzonCalc!"

    w = 10*unit.m
    l = 5*unit.m
    A = w * l

3. Click the run button

UZONCALC_TOC_HEADING:heading-2|CLI Installation

The CLI method is mainly intended for calculation report authors. It supports automatic formatting and syntax checking, which improves authoring efficiency. When editing calculation reports, AI-assisted authoring is recommended, especially for charts and complex calculation logic.

Installation steps:

1. Make sure Python is installed

3. Create a calculation report script

# example.py

from uzoncalc import *

@uzon_calc()
async def sheet():
    doc_title("example")

    "Hello, UzonCalc!"

    w = 10*unit.m
    l = 5*unit.m
    A = w * l

if __name__ == "__main__":
    view(sheet)

4. Run

When you run the following command:

python --serve example.py

You will see `Serving document at: http://127.0.0.1:32180/`.. Click it or open it in a browser to view the result.

A calculation report service started this way does not hot reload. When the report code changes, the service must be restarted manually.

UZONCALC_TOC_HEADING:heading-3|Basic Syntax

UzonCalc is built on Python and introduces no additional language definitions, so writing calculations means writing Python code.

If you have not used the Python programming language before, the following basic syntax introduction will help you get started quickly.

For now, understanding this basic syntax is enough to start writing calculation reports with UzonCalc. As you use it, gradually learn more Python syntax and features so you can use UzonCalc better.

For beginners, the following code style suggestions are recommended:

1. Use English for naming where possible and avoid Pinyin. English expresses meaning better and is easier to read.

2. Use camelCase for variable names and avoid underscores, because `_` is used as a subscript symbol.

3. Add comments where appropriate to help explain code logic.

4. Keep code concise, split complex logic into functions, and put code with different responsibilities into different files.

UZONCALC_TOC_HEADING:heading-4|Automatic Table of Contents

UZONCALC_TOC_HEADING:heading-5|Automatic Figure and Table Numbering

When using UzonCalc, you do not need to number figures and tables manually. The system generates numbers automatically, which greatly reduces maintenance work when figures or tables are added or removed.

When you call Img, Table, Echarts, or Plot, the system returns a placeholder string. You can use that placeholder later in the document to reference the figure or table.

The following uses an image as an example. The code is:

imgNo = Img(
        "https://oss.uzoncloud.com:2234/public/files/images/image-20260527133234259.png",
        alt="UzonCalc run result",
    )

f"Now you can use imgNo to reference this image: see {imgNo}."

Actual result:

Now you can use imgNo to reference this image: see .

From the example above, you can also see that the placeholder is ultimately replaced with the image number, and you can click that number to jump to the corresponding image.

Figure and table numbers can be used anywhere later in the code.

Now reference the image above: see . You can see that the prefix has changed to Figure.

UZONCALC_TOC_HEADING:heading-6|Headings

UZONCALC_TOC_HEADING:heading-7|Text Types

Example:

'Single-quoted text'

"Double-quoted text"

"""
Triple-quoted text,
this is line 1,
this is line 2
"""

The code above outputs:

Single-quoted text

Double-quoted text

Triple-quoted text, this is line 1, this is line 2

Single-quoted and double-quoted strings are suitable for single-line text, while triple-quoted strings are suitable for multi-line text. Triple-quoted strings can span multiple lines, but they are merged into a single paragraph during rendering and line breaks are not preserved. This is useful when writing longer paragraphs.

UZONCALC_TOC_HEADING:heading-8|Numeric Types

Numeric values do not need to be wrapped in quotes. Enter them directly.

Example:

# Integer
integerNumber = 100
# Floating-point number
floatNumber = 3.1415
# Scientific notation
scientificNumber = 1.2e3
# Complex number
complexNumber = 2 + 3j

The output is:

$\mathit{integerNumber}=100$

$\mathit{floatNumber}=3.1415=3.142$

$\mathit{scientificNumber}=1200.0=1200$

$\mathit{complexNumber}=2+\text{3j}$

UZONCALC_TOC_HEADING:heading-9|Operations and Comparisons

Example:

operatorResult = (5 + 3) * 2 - 4 / 2**2
comparisonResult = (5 > 3) and (2 == 2) or (4 != 5)
        

$\mathit{operatorResult}=\left(5+3\right)·2-\frac{4}{2^2}=15$

$\mathit{comparisonResult}=5>3\wedge 2\equiv 2\vee 4\ne 5=\text{True}$

UZONCALC_TOC_HEADING:heading-10|Using Variables

A variable is a container defined in a program to store data. It lets you reuse the same data without entering it repeatedly.

Consider the following code:

N_s = 100 * unit.KN
A_s = 50 * unit.mm**2
sigma_s = N_s / A_s
         

${\mathit{N}}_{\text{s}}=100\mathrm{\text{kN}}$

${\mathit{A}}_{\text{s}}=50\mathrm{\text{mm²}}$

${\mathit{\sigma }}_{\text{s}}=\frac{{\mathit{N}}_{\text{s}}}{{\mathit{A}}_{\text{s}}}=\frac{100\mathrm{\text{kN}}}{50\mathrm{\text{mm²}}}=2\mathrm{\text{kN/mm²}}$

UZONCALC_TOC_HEADING:heading-11|Variable Naming Rules

Variable names can contain letters, numbers, and underscores, but cannot start with a number.

UZONCALC_TOC_HEADING:heading-12|Variable Aliases

Because Python variable names are limited, you cannot directly use non-ASCII characters as variable names. Sometimes you may want to use a friendlier name in the document, and aliases are designed for that.

Example:

# Concrete strength grade
f_c = 30 * unit.MPa
alias("f_c", "concrete strength grade")

# After the alias is defined, the variable is displayed with the alias until the alias is removed.
f"Now the alias will be output: {f_c}"

# Define a None alias to remove the alias.
alias("f_c", None)

# The alias has been removed and f_c is displayed with its original name again.
f"The alias has been removed. Now the original name is output: {f_c}"

${\mathit{f}}_{\text{c}}=30\mathrm{\text{MPa}}$

Now the alias will be output: $30\mathrm{\text{MPa}}$

The alias has been removed. Now the original name is output: $30\mathrm{\text{MPa}}$

UZONCALC_TOC_HEADING:heading-13|Input Variables

inputs = await UI(
    "Structural Parameter Input",
    [
        Field("width", "Width", FieldType.number, value=10),
        Field("length", "Length", FieldType.number, value=30),
        Field("height", "Height", FieldType.number, value=20),
    ],
)

f"The user-entered width is {inputs.width}, length is {inputs.length}, and height is {inputs.height}."

The UI effect of the code above is shown in the figure below:

From , you can see that the system converts your input code into a visual UI, where users can enter values and interact with the program.

The output of the code above is:

The user-entered width is $10$, length is $30$, and height is $20$.

UZONCALC_TOC_HEADING:heading-14|Variable Subscripts

UZONCALC_TOC_HEADING:heading-15|Default Subscript Rules

If you want a word to become a subscript, put an underscore after it. For example, H₂ is rendered as H₂.

Example:

a_x = 10 * unit.meter / unit.second**2
speed_car = a_x * 2 * unit.second

${\mathit{a}}_{\text{x}}=10\mathrm{\text{m/s²}}$

${\mathit{speed}}_{\text{car}}={\mathit{a}}_{\text{x}}·2\mathrm{\text{s}}=10\mathrm{\text{m/s²}}·2\mathrm{\text{s}}=20\mathrm{\text{m/s}}$

UZONCALC_TOC_HEADING:heading-16|Non-ASCII Character Subscripts

Because Python field names are restricted, non-ASCII characters cannot be used directly as variable names. If you want to use non-ASCII characters as subscripts, use aliases.

You can use an alias to represent non-ASCII characters as a subscript.

Example:

alias("speed_car", "speed_车")
f"Now the alias subscript will be output: {speed_car}"
distance = speed_car * 5 * unit.second
alias("speed_car", None)
f"The alias has been removed, and speed_car is restored to its original name: {speed_car}"

Now the alias subscript will be output: $20\mathrm{\text{m/s}}$

$\mathit{distance}={\mathit{speed}}_{\text{车}}·5\mathrm{\text{s}}=20\mathrm{\text{m/s}}·5\mathrm{\text{s}}=100\mathrm{\text{m}}$

The alias has been removed, and speed_car is restored to its original name: $20\mathrm{\text{m/s}}$

UZONCALC_TOC_HEADING:heading-17|Array Subscripts

For arrays, the content inside [] is automatically handled as a subscript.

arr2d = np.array([[1, 2, 3], [4, 5, 6]])
firstRow = arr2d[0, :]
secondColumn = arr2d[:, 1]
firstCell = arr2d[0, 0]
list1 = [10, 20]
list2 = [30, 40]
combinedList = list1 + list2
secondItem = combinedList[1]

$\mathbf{arr2d}=\mathit{np}.\text{array}\left(\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]\right)=\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]$

$\mathbf{firstRow}={\mathbf{arr2d}}_{0,:}=[1,2,3]$

$\mathbf{secondColumn}={\mathbf{arr2d}}_{:,1}=[2,5]$

$\mathit{firstCell}={\mathbf{arr2d}}_{0,0}=1$

$\mathbf{list1}=[10,20]$

$\mathbf{list2}=[30,40]$

$\mathbf{combinedList}=\mathbf{list1}+\mathbf{list2}=[10,20]+[30,40]=[10,20,30,40]$

$\mathit{secondItem}={\mathbf{combinedList}}_1=20$

UZONCALC_TOC_HEADING:heading-18|Multidimensional Arrays

The general representation of multidimensional arrays is often called a tensor. It can represent scalars (0-dimensional tensors), vectors (1-dimensional tensors), matrices (2-dimensional tensors), and higher-dimensional arrays.

UzonCalc supports tensor calculation with NumPy.

Here are some tensor examples:

arr = np.array([[1, 2, 3], [4, 5, 6]])
firstRow = arr[0, :]
secondColumn = arr[:, 1]
firstCell = arr[0, 0]

$\mathbf{arr}=\mathit{np}.\text{array}\left(\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]\right)=\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]$

$\mathbf{firstRow}={\mathbf{arr}}_{0,:}=[1,2,3]$

$\mathbf{secondColumn}={\mathbf{arr}}_{:,1}=[2,5]$

$\mathit{firstCell}={\mathbf{arr}}_{0,0}=1$

In UzonCalc, variables are displayed in italic. Tensors with more than one dimension are displayed in bold upright style, matching the notation commonly used in papers.

UZONCALC_TOC_HEADING:heading-19|Units

When calculating formulas, UzonCalc supports calculation with units. Different units with the same dimension do not need to be converted manually and can be calculated directly. For example:

$\mathit{totalLength}=10\mathrm{\text{m}}+20\mathrm{\text{cm}}=10.2\mathrm{\text{m}}$

UZONCALC_TOC_HEADING:heading-20|Using Units

l_cp = 5 * unit.meter
w_cp = 10 * unit.m
h_cp = 2 * unit.meter
v_cp = l_cp * w_cp * h_cp

${\mathit{l}}_{\text{cp}}=5\mathrm{\text{m}}$

${\mathit{w}}_{\text{cp}}=10\mathrm{\text{m}}$

${\mathit{h}}_{\text{cp}}=2\mathrm{\text{m}}$

${\mathit{v}}_{\text{cp}}={\mathit{l}}_{\text{cp}}·{\mathit{w}}_{\text{cp}}·{\mathit{h}}_{\text{cp}}=5\mathrm{\text{m}}·10\mathrm{\text{m}}·2\mathrm{\text{m}}=100\mathrm{\text{m³}}$

force = 100 * unit.newton
A_top = l_cp * w_cp
stress_cp = force / A_top

$\mathit{force}=100\mathrm{\text{N}}$

${\mathit{A}}_{\text{top}}={\mathit{l}}_{\text{cp}}·{\mathit{w}}_{\text{cp}}=5\mathrm{\text{m}}·10\mathrm{\text{m}}=50\mathrm{\text{m²}}$

${\mathit{stress}}_{\text{cp}}=\frac{\mathit{force}}{{\mathit{A}}_{\text{top}}}=\frac{100\mathrm{\text{N}}}{50\mathrm{\text{m²}}}=2\mathrm{\text{N/m²}}$

UZONCALC_TOC_HEADING:heading-21|Unit Calculation

You can perform mathematical operations directly on quantities with units: addition, subtraction, multiplication, division, powers, square roots, and so on.

sqrtArea = sqrt(A_top + 10 * unit.meter**2)
acceleration = force * 1000 / (10 * unit.kilogram)

$\mathit{sqrtArea}=\sqrt{{\mathit{A}}_{\text{top}}+10\mathrm{\text{m²}}}=\sqrt{50\mathrm{\text{m²}}+10\mathrm{\text{m²}}}=7.746\mathrm{\text{m}}$

$\mathit{acceleration}=\frac{\mathit{force}·1000}{10\mathrm{\text{kg}}}=\frac{100\mathrm{\text{N}}·1000}{10\mathrm{\text{kg}}}=10000\mathrm{\text{N/kg}}$

Different units with the same dimension do not need to be converted manually and can be calculated directly. For example:

$\mathit{totalLength}=10\mathrm{\text{m}}+20\mathrm{\text{cm}}=10.2\mathrm{\text{m}}$

UZONCALC_TOC_HEADING:heading-22|Unit Conversion

speedMPerS = 18 * unit.meter / unit.second
speedKmPerH = speedMPerS.to(unit.kilometer / unit.hour)
"Before unit conversion, speed (m/s):"
speedMPerS
"After unit conversion, speed (km/h):"
speedKmPerH

$\mathit{speedMPerS}=18\mathrm{\text{m/s}}$

$\mathit{speedKmPerH}=\mathit{speedMPerS}.\text{to}\left(\mathrm{\text{km/h}}\right)=64.8\mathrm{\text{km/h}}$

Before unit conversion, speed (m/s):

$\mathit{speedMPerS}=18\mathrm{\text{m/s}}$

After unit conversion, speed (km/h):

$\mathit{speedKmPerH}=64.8\mathrm{\text{km/h}}$

UZONCALC_TOC_HEADING:heading-23|Greek Letter Conversion

Use Greek letter English names directly, such as alpha (α), beta (β), gamma (γ), and delta (δ). The system automatically renders them as the corresponding Greek letters.

Names starting with lowercase letters are rendered as lowercase Greek letters, and names starting with uppercase letters are rendered as uppercase Greek letters.

If you do not want a name to be converted to a Greek letter, add \ before the name, for example, \\alpha.

rho_water = 1000 * unit.kilogram / unit.meter**3
gamma_0 = 9.81 * unit.meter / unit.second**2

${\mathit{\rho }}_{\text{water}}=1000\mathrm{\text{kg/m³}}$

${\mathit{\gamma }}_{\text{0}}=9.81\mathrm{\text{m/s²}}$

UZONCALC_TOC_HEADING:heading-24|Function Styles

The following functions are automatically converted to mathematical style:

UZONCALC_TOC_HEADING:heading-25|Square Root

Use sqrt(x) to represent the square root of x.

edge1 = 3 * unit.meter
edge2 = 4 * unit.meter
diagonal = sqrt(edge1**2 + edge2**2)

$\mathit{edge1}=3\mathrm{\text{m}}$

$\mathit{edge2}=4\mathrm{\text{m}}$

$\mathit{diagonal}=\sqrt{{\mathit{edge1}}^2+{\mathit{edge2}}^2}=\sqrt{{\left(3\mathrm{\text{m}}\right)}^2+{\left(4\mathrm{\text{m}}\right)}^2}=5\mathrm{\text{m}}$

UZONCALC_TOC_HEADING:heading-26|Absolute Value

Use abs(x) to represent the absolute value of x.

value = -15 * unit.newton
absValue = abs(value)

$\mathit{value}=-15\mathrm{\text{N}}=-15\mathrm{\text{N}}$

$\mathit{absValue}=\left|\mathit{value}\right|=\left|-15\mathrm{\text{N}}\right|=15\mathrm{\text{N}}$

UZONCALC_TOC_HEADING:heading-27|Advanced String Usage

UZONCALC_TOC_HEADING:heading-28|f-string

An f-string, also called a formatted string literal, lets you embed expressions directly in a string and calculate their values at runtime.

To create an f-string, add `f` or `F` before the opening quote of the string.

name = "Uzon"
f"Hello, {name}! Welcome to UzonCalc."
pi = 3.1415926535
f"Value of pi up to 3 decimal places: {pi:.3f}"

Run result:

$\mathit{name}=\text{Uzon}$

Hello, $\text{Uzon}$! Welcome to UzonCalc.

$\mathit{\pi }=3.1415926535=3.142$

Value of π up to 3 decimal places: $\text{3.142}$

UZONCALC_TOC_HEADING:heading-29|Displaying Formulas in f-strings

By default, expressions in f-strings display only their calculation results. Sometimes you may want to display both the formula and the calculation process in the document. Use the enable_fstring_equation() function to enable this feature. After it is enabled, expressions in f-strings display both formulas and calculation results, until you call disable_fstring_equation() to turn it off.

enable_fstring_equation()
width = 10 * unit.meter
length = 20 * unit.meter
f"Area is calculated as {width * length}."
disable_fstring_equation()

$\mathit{width}=10\mathrm{\text{m}}$

$\mathit{length}=20\mathrm{\text{m}}$

Area is calculated as $\mathit{width}·\mathit{length}=10\mathrm{\text{m}}·20\mathrm{\text{m}}=200\mathrm{\text{m²}}$.

UZONCALC_TOC_HEADING:heading-30|Assigning f-string Calculation Results

Use the `:=` walrus operator to assign the result of an expression in an f-string to a variable for later calculations.

f"Area is calculated as {(tempArea := width * length)}."
enable_fstring_equation()
f"Area is calculated as {(tempArea := width * length)}."
disable_fstring_equation()
tempArea

Run result:

Area is calculated as $200\mathrm{\text{m²}}$.

Area is calculated as $\mathit{tempArea}=\mathit{width}·\mathit{length}=10\mathrm{\text{m}}·20\mathrm{\text{m}}=200\mathrm{\text{m²}}$.

$\mathit{tempArea}=200\mathrm{\text{m²}}$

UZONCALC_TOC_HEADING:heading-31|String Escaping

UZONCALC_TOC_HEADING:heading-32|Charts

Use ECharts and Matplotlib to create charts in UzonCalc.

You can also use other plotting libraries you prefer, such as Plotly and Seaborn.

JavaScript charts are interactive, while Matplotlib charts are rendered as static images and are suitable for print output.

UZONCALC_TOC_HEADING:heading-33|ECharts Example

Use the echarts library to create rich interactive charts. For more details, see the official documentation and examples: https://echarts.apache.org/examples/zh/index.html#chart-type-line

# Create an ECharts chart.
EChart(options)

The options parameter in this example refers to: https://echarts.apache.org/examples/zh/editor.html?c=area-stack

UZONCALC_TOC_HEADING:heading-34|ECharts 3D Example

Use ECharts GL to create 3D charts. You can rotate and zoom the chart with the mouse to view different angles and details.

hide()
    ROOT_PATH = "https://oss.uzoncloud.com:2234/public/files/images"
    show()

    EChart(
        {
            "backgroundColor": "#000",
            "globe": {
                "baseTexture": ROOT_PATH + "/earth.jpg",
                "heightTexture": ROOT_PATH + "/bathymetry_bw_composite_4k.jpg",
                "displacementScale": 0.1,
                "shading": "lambert",
                "environment": ROOT_PATH + "/starfield.jpg",
                "light": {"ambient": {"intensity": 0.1}, "main": {"intensity": 1.5}},
                "layers": [
                    {
                        "type": "blend",
                        "blendTo": "emission",
                        "texture": ROOT_PATH + "/night.jpg",
                    },
                    {
                        "type": "overlay",
                        "texture": ROOT_PATH + "/clouds.png",
                        "shading": "lambert",
                        "distance": 5,
                    },
                ],
            },
            "series": [],
        },
        use_gl=True,
        caption="3D Earth Example",
    )

UZONCALC_TOC_HEADING:heading-35|Matplotlib Example

hide()

def get_contour3d_plot():
    '''
    Create an example 3D contour plot.
    reference: https://matplotlib.org/stable/gallery/mplot3d/contour3d_3.html
    '''
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import axes3d
    ax = plt.figure().add_subplot(projection="3d")
    X, Y, Z = axes3d.get_test_data(0.05)
    # Plot the 3D surface
    ax.plot_surface(
        X, Y, Z, edgecolor="royalblue", lw=0.5, rstride=8, cstride=8, alpha=0.3
    )
    # Plot projections of the contours for each dimension.  By choosing offsets
    # that match the appropriate axes limits, the projected contours will sit on
    # the 'walls' of the graph.
    ax.contour(X, Y, Z, zdir="z", offset=-100, cmap="coolwarm")
    ax.contour(X, Y, Z, zdir="x", offset=-40, cmap="coolwarm")
    ax.contour(X, Y, Z, zdir="y", offset=40, cmap="coolwarm")
    ax.set(
        xlim=(-40, 40),
        ylim=(-40, 40),
        zlim=(-100, 100),
        xlabel="X",
        ylabel="Y",
        zlabel="Z",
    )
    return plt
show()
Plot(get_contour3d_plot(), caption="3D Contour Example")

UZONCALC_TOC_HEADING:heading-36|Tables

Call the Table() function to create tables.

The table header definition may look complex, but it is flexible and powerful, supporting merged cells and other features. See the example below:

This rule is designed based on HTML table definitions. You can refer to HTML table materials for detailed usage.

In the example, rowspan means the number of rows a cell spans, and colspan means the number of columns a cell spans.

Table(
    [
        [
            th("Component", rowspan=3),
            th("Material", rowspan=3),
            th("Elastic Modulus (MPa)", colspan=2),
            th("Design Strength (MPa)", colspan=2),
            th("Standard Strength (MPa)", colspan=2),
        ],
        [
            "Ec/Es",
            "Compressive",
            "Tensile",
            "Compressive",
            "Tensile",
        ],
    ],
    [
        ["Cap Beam", "C60", 3.6e4, 26.5, 1.96, 38.5, 2.85],
        ["Cap Beam 2", "C60", 3.6e4, 26.5, 1.96, 38.5, 2.85],
    ],
    title="Example Table",
)

Example Table

Component	Material	Elastic Modulus (MPa)		Design Strength (MPa)		Standard Strength (MPa)
		Ec/Es	Compressive	Tensile	Compressive	Tensile
		Cap Beam	C60	36000	26.5	1.96	38.5	2.85
Cap Beam 2	C60	36000	26.5	1.96	38.5	2.85

The Table() function returns the table reference. You can use it directly later, for example: the reference to the table above is .

UZONCALC_TOC_HEADING:heading-37|Calling Existing Excel Calculation Tables

You can update cell values in an Excel workbook from a calculation report, execute formulas in Excel, then retrieve and output calculation results in the report.

This is useful for reusing existing Excel calculation tables.

The P function can output table content as a paragraph.

P(
    get_excel_table(
        excel_path="examples/data/calculation.xlsx",
        values={
            "Sheet2!A3": 6,
            "Sheet2!B3": 10,
            "Sheet2!C3": 2,
        },
        range="Sheet2!A1:D3",
    )
)

No Excel/xlwings engine available. Please install Excel/xlwings and try again.

By default, if the input values do not change, the Excel table is cached to speed up the next render.

UZONCALC_TOC_HEADING:heading-38|Saving Documents

UZONCALC_TOC_HEADING:heading-39|Saving as an HTML File

Inside a function defined with uzoncalc, use the save() function to save the document as an HTML file.

You can get the calculation context object from the return value of run_sync(), then call the object's save() method to save the document.

ctx = run_sync(sheet2)
ctx.save("../output/example.en.html")
        

UZONCALC_TOC_HEADING:heading-40|Printing as a PDF File

Open the generated HTML file in a browser, then use the browser's built-in print feature to save the document as a PDF file.

UZONCALC_TOC_HEADING:heading-41|Converting to a Word Document

Use the pandoc command to convert an HTML document to a Word document. See the official pandoc documentation for detailed usage.

UZONCALC_TOC_HEADING:heading-42|Future Plans

UzonCalc will add the following features in the future:

1. Add UI and calculation report publishing features.

2. Add AI support. After you accumulate enough calculation templates, AI can automatically generate initial drafts of new calculation reports.

UZONCALC_TOC_HEADING:heading-43|Conclusion

AI has arrived. Standing still means falling behind. Let us embrace AI and begin a new calculation journey.