xlwings Server

https://github.com/xlwings/xlwings-server
Admin
xlwings Server adds Python support to Microsoft Excel and Google Sheets without local installation,...
Tokens:28,833
Snippets:235
Trust Score:8.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### xlwings Server Startup Output Example

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/github_codespaces.md

Example console output when the xlwings server successfully starts, showing the Uvicorn server address, reloader process, and confirmation of application startup completion.

```text
@fzumstein ➜ /workspaces/xlwings-server (main) $ python run.py
INFO:     Will watch for changes in these directories: ['/workspaces/xlwings-server']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [5283] using WatchFiles
INFO:     Started server process [5285]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
```

--------------------------------

### Install 'uv' Package Manager

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

This command uses 'pip' to install 'uv', a fast Python package installer and resolver. 'uv' is recommended for managing project dependencies efficiently.

```python
pip install uv
```

--------------------------------

### Install Docker using convenience script

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/docker_compose.md

This script downloads and runs the official Docker convenience script to install Docker Engine on Linux systems. It's a quick alternative for installation when following official distribution-specific guides is not preferred.

```bash
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
```

--------------------------------

### Install Development Dependencies with 'uv'

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

Using the 'uv' package manager, this command synchronizes the project's development dependencies listed in 'requirements-dev.txt'. This ensures all necessary packages for development are installed in the current Python environment.

```python
uv pip sync requirements-dev.txt
```

--------------------------------

### Install Node.js Dependencies

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

Command to install Node.js dependencies for the project. Node.js is required for upgrading packages, even though the app copies relevant files to a static folder.

```Shell
sudo npm install
```

--------------------------------

### Configure Environment Variables for Local Production Setup

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

Environment variables required for a production-like local setup, including environment type, security headers, and Redis message queue URL for Socket.IO.

```Shell
XLWINGS_ENVIRONMENT="prod"
XLWINGS_ADD_SECURITY_HEADERS=false
XLWINGS_SOCKETIO_MESSAGE_QUEUE_URL=redis://localhost:6379/0
```

--------------------------------

### Change into Project Directory

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

After cloning the repository, use this command to navigate into the newly created project directory. This ensures that subsequent commands are executed within the correct project context.

```text
cd myproject
```

--------------------------------

### Run Local Development Environment with Docker and Uvicorn

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

Commands to set up a production-like local development environment using Docker Compose for Redis and Uvicorn for the main application and Socket.IO server, enabling SSL.

```Shell
docker compose -f tests/docker-compose.redis.yaml up
uvicorn app.main:main_app --host 0.0.0.0 --port 8000 --reload --ssl-keyfile ./certs/localhost+2-key.pem --ssl-certfile ./certs/localhost+2.pem
export XLWINGS_SOCKETIO_SERVER_APP=true && uvicorn app.main:sio_app --host 0.0.0.0 --port 8001 --reload --ssl-keyfile ./certs/localhost+2-key.pem --ssl-certfile ./certs/localhost+2.pem
```

--------------------------------

### Verify Docker and Docker Compose Installation

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dev_docker.md

Before running the development server, ensure that Docker and Docker Compose are correctly installed and accessible from your terminal by executing these commands.

```Shell
docker
docker compose
```

--------------------------------

### Serve Alpine.js Task Pane with FastAPI

Source: https://github.com/xlwings/xlwings-server/blob/main/app/templates/examples/alpine/README.md

This Python code snippet defines a FastAPI GET endpoint for '/taskpane.html'. It serves an HTML template located at 'examples/alpine/taskpane.html', demonstrating how to integrate Alpine.js examples within an xlwings server application. It depends on 'app/static/js/core/examples.js' for full functionality.

```python
from fastapi import APIRouter, Request

from ..config import settings
from ..templates import TemplateResponse

router = APIRouter(prefix=settings.app_path)


@router.get("/taskpane.html")
async def taskpane(request: Request):
    return TemplateResponse(
        request=request,
        name="examples/alpine/taskpane.html",
    )
```

--------------------------------

### Add Personal Git Repository as 'origin'

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

After creating your own empty Git repository, use this command to add its clone URL as the 'origin' remote. This allows you to push your local changes to your personal fork.

```text
git remote add origin <URL>
```

--------------------------------

### Commit and Push Initial Repository Changes

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

These Git commands stage all changes, commit them with a message "updated uuids", and then push the committed changes to your 'origin' remote. This step saves the initial setup changes, including generated UUIDs, to your personal repository.

```text
git add .
git commit -m "updated uuids"
git push origin main
```

--------------------------------

### Build Project Documentation with Sphinx Autobuild

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

Command to build and serve project documentation using Sphinx Autobuild, monitoring changes and reloading automatically on port 9000.

```Shell
sphinx-autobuild docs docs/_build/html  --port 9000 -E
```

--------------------------------

### Start xlwings Server in Codespaces

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/github_codespaces.md

Executes the xlwings server application, starting the Uvicorn server and watching for file changes. This command makes the server accessible locally and prepares it for public exposure.

```bash
python run.py
```

--------------------------------

### Install xlwings Python Package in Editable Mode

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

Commands to uninstall any existing xlwings package and then install the xlwings Python package from its local repository into xlwings-server in editable development mode.

```Shell
pip uninstall xlwings
cd ../xlwings && python setup.py develop && cd ../xlwings-server
```

--------------------------------

### Initialize xlwings Server Repository

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

This Python command initializes the xlwings Server repository. It creates an '.env' file for configuration and generates unique UUIDs within the 'app/config.py' file, setting up the project for first use.

```python
python run.py init
```

--------------------------------

### Verify Docker and Docker Compose installation

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/docker_compose.md

These commands check if Docker Engine and Docker Compose are correctly installed and accessible in the system's PATH. Successful execution indicates that the tools are ready for use, allowing further deployment steps.

```bash
docker
docker compose
```

--------------------------------

### Example of runPython with Configuration Options

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/officescripts_integration.md

This example demonstrates how to pass a configuration object to the `runPython` function, illustrating the use of `auth`, `exclude`, and `headers` parameters to customize the behavior of the call to the xlwings server.

```TypeScript
async function main(workbook: ExcelScript.Workbook) {
  await runPython(
    workbook,
    "https://YOUR_SERVER/xlwings/custom-scripts-call/hello_world",
    {
      auth: "xxxxxxxxxxxx",
      exclude: "Sheet1,Sheet2",
      headers: { key1: "value1" },
    },
  );
}
```

--------------------------------

### Example ngrok terminal output with forwarding URL

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/tunneling.md

This snippet shows the typical output displayed in the terminal after successfully starting ngrok. The 'Forwarding' line provides the public HTTPS URL that can be used by Office Scripts or Google Apps Script to access your local server.

```text
ngrok                                                                                                                (Ctrl+C to quit)

Share what you're building with ngrok https://ngrok.com/share-your-ngrok-story

Session Status                online
Account                       xxx@xxx.com (Plan: Free)
Version                       3.16.0
Region                        Europe (eu)
Web Interface                 http://127.0.0.1:4040
Forwarding                    https://xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx.ngrok-free.app -> http://localhost:8000

Connections                   ttl     opn     rt1     rt5     p50     p90
                            0       0       0.00    0.00    0.00    0.00
```

--------------------------------

### Disable xlwings Server Examples

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/examples.md

This configuration snippet shows how to disable all built-in xlwings Server examples. Setting `XLWINGS_ENABLE_EXAMPLES` to `false` in the server configuration file allows users to switch off the default examples once their own custom code is ready, streamlining the deployment.

```INI
XLWINGS_ENABLE_EXAMPLES=false
```

--------------------------------

### Run Xlwings Development Server with Docker Compose

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dev_docker.md

Execute this command in the root directory of the repository to build and start the xlwings development container. The first execution will include a build step before starting the server.

```Shell
docker compose up
```

--------------------------------

### Configure Socket.IO Client with Authentication

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

JavaScript code to initialize the Socket.IO client, connecting to the server with authentication using an asynchronously retrieved token.

```JavaScript
globalThis.socket = io("https://127.0.0.1:8001", {
  auth: async (callback) => {
    let token = await globalThis.getAuth();
    callback({
      token: token,
    });
  },
});
```

--------------------------------

### Run minimalistic xlwings server with Docker Compose

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/docker_compose.md

This command starts a simplified version of the xlwings server, containing only the main app container. It uses a different Docker Compose file (`docker-compose.prod-min.yaml`) and runs in detached mode, suitable for setups without streaming functions or requiring an external Redis service.

```bash
docker compose -f deployment/docker-compose.prod-min.yaml up -d
```

--------------------------------

### Install and Generate mkcert Development Certificates

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dev_certificates.md

This snippet provides the commands to install mkcert's root CA and generate self-signed TLS certificates for localhost. These certificates are essential for running a local web server over HTTPS, especially for Office.js Add-in development. After execution, two .pem files will be generated, which should be moved to a 'certs' directory.

```text
./mkcert -install
./mkcert localhost 127.0.0.1 ::1
```

--------------------------------

### Deploying xlwings Server Docker Container on Render

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/render.md

This snippet details the steps to quickly deploy the official xlwings Server Docker container on Render.com. It leverages Render's free tier for testing purposes, allowing users to try out pre-built examples. A valid xlwings license key is required for operation.

```Deployment Instructions
1. On the Render dashboard, click on `+ New` on the top right and select `Web Service`.
2. Activate the `Existing Image` tab and paste `xlwings/xlwings-server` as the Image URL. Then click on `Connect`.
3. Select a `Region` that's close to you (optional).
4. Under `Instance Type`, select an appropriate plan, e.g., `Free`.
5. Under `Environment Variables`, add `XLWINGS_LICENSE_KEY` as `NAME_OF_VARIABLE` and your license key as `value`.
6. Click on `Deploy Web Service`.
7. After less than 1 minute, you should see: `Your service is live 🎉`.
8. Click on the URL of your service (e.g., https://yourname.onrender.com). If you see `{"status": "ok"}`, everything is working correctly.
```

--------------------------------

### Install `uv` Package Manager via pip

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dependencies.md

This command installs 'uv', a fast Python package manager, using pip. 'uv' is a prerequisite for managing dependencies in this project setup.

```bash
pip install uv
```

--------------------------------

### Call xlwings Custom Functions in Excel (Office.js)

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/examples.md

This snippet demonstrates how to invoke custom functions provided by xlwings Server directly within Excel cells when using Office.js add-ins. It shows examples for both production (`XLWINGS.HELLO`) and development (`XLWINGS_DEV.HELLO`) environments, illustrating how to pass arguments and the expected 'Hello world!' output. Users can explore more functions by typing `=XLWINGS.` or `=XLWINGS_DEV.`.

```Excel Formula
=XLWINGS.HELLO("world")
=XLWINGS_DEV.HELLO("world")
```

--------------------------------

### Push Local Branch to New 'origin' Remote

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

This command pushes your local 'main' branch to the newly configured 'origin' remote (your personal repository). The '-u' flag sets 'origin/main' as the upstream tracking branch.

```text
git push -u origin main
```

--------------------------------

### Example `requirements.in` File for Application Dependencies

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dependencies.md

This snippet shows the structure of a `requirements.in` file, which is used to declare top-level application-specific Python dependencies. It includes a mandatory reference to `requirements-core.txt` and examples of common packages like pandas and numpy.

```text
-r requirements-core.txt  # Don't delete this line
pandas
numpy==1.26.4
```

--------------------------------

### VBA Example: RunServerPython with Advanced Configuration

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/vba_integration.md

A comprehensive VBA example demonstrating how to use the `RunServerPython` function with multiple optional parameters. This includes setting authentication, excluding specific sheets, and providing custom HTTP headers for the server request.

```vb.net
Sub Hello()
    Dim headers As New Dictionary
    headers.Add "key1", "value1"
    RunServerPython "https://YOUR_SERVER/xlwings/custom-scripts-call/hello_world", _
        auth:="xxx", _
        exclude:="Sheet1, Sheet2", _
        headers:=headers
End Sub
```

--------------------------------

### Interactive Pyodide Usage in Node.js REPL

Source: https://github.com/xlwings/xlwings-server/blob/main/app/static/vendor/pyodide/README.md

Shows how to use Pyodide interactively within the Node.js REPL. This example demonstrates loading Pyodide and executing Python code directly in the console, requiring the `--experimental-repl-await` flag for top-level await support.

```shell
$ node --experimental-repl-await
Welcome to Node.js v18.5.0.
Type ".help" for more information.
> const { loadPyodide } = require("pyodide");
undefined
> let pyodide = await loadPyodide();
undefined
> await pyodide.runPythonAsync("1+1");
2
```

--------------------------------

### Disabling Examples in xlwings Server Configuration

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/server_config.md

Demonstrates how to change the `XLWINGS_ENABLE_EXAMPLES` setting to `false` by uncommenting the line and modifying its value in the `.env` file. This disables the examples feature in xlwings Server.

```ini
XLWINGS_ENABLE_EXAMPLES=false
```

--------------------------------

### Build Docker Image with xlwings Developer Key

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/production.md

This Docker build command incorporates the `XLWINGS_DEVELOPER_KEY` as a build argument. This allows the developer license key to be directly installed into the Docker image, facilitating the use of deploy keys during the build process.

```text
docker build --build-arg XLWINGS_DEVELOPER_KEY=${XLWINGS_DEVELOPER_KEY} .
```

--------------------------------

### Disable xlwings Examples

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/production.md

This setting allows you to disable the built-in xlwings examples. Setting `XLWINGS_ENABLE_EXAMPLES` to `false` is recommended for production deployments to remove unnecessary components.

```ini
XLWINGS_ENABLE_EXAMPLES=false
```

--------------------------------

### Clone xlwings Server Repository (HTTPS/SSH)

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

This snippet demonstrates how to clone the xlwings Server repository using either HTTPS or SSH. Replace 'myproject' with your desired local directory name. This is the initial step to obtain the project's source code.

```text
git clone https://github.com/xlwings/xlwings-server.git myproject
```

```text
git clone git@github.com:xlwings/xlwings-server.git myproject
```

--------------------------------

### Install Conda-Specific Packages

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dependencies.md

This command installs packages that are primarily or exclusively available through Conda. Replace 'blas' with the actual package you need to install into your Conda environment.

```bash
conda install blas
```

--------------------------------

### Configure CDN for Office.js in xlwings Server

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/install_officejs_addin.md

This setting ensures that the `office.js` library is loaded via CDN, which is a requirement for publishing an add-in to the Office add-in store (AppSource) as per Microsoft's guidelines.

```ini
XLWINGS_CDN_OFFICEJS=true
```

--------------------------------

### Customize Task Pane HTML for xlwings Add-in

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/production.md

This HTML snippet provides a basic structure for a custom task pane. It extends a base template and includes a placeholder for the add-in's name. This file should replace the default example and be stored as `app/templates/taskpane.html`.

```html
{% extends "base.html" %}

{% block content %}
  <div class="container-fluid pt-3 ps-3">
    <h1>Name of your Add-in</h1>
  </div>
{% endblock content %}
```

--------------------------------

### Start ngrok to expose local HTTP server

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/tunneling.md

This command initiates ngrok to create a secure tunnel to your local HTTP server running on port 8000. It's the basic command for exposing a local development environment to the internet.

```text
ngrok http 8000
```

--------------------------------

### Copy Node Modules to Static Folder

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

Python script command to copy updated Node.js modules from `node_modules` to the `app/static/vendor` folder after an npm package update.

```Shell
python scripts/copy_node_modules_to_static_folder.py
```

--------------------------------

### xlwings-server Development Server Console Output

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/local_development.md

This snippet displays the expected console output when the xlwings-server development server successfully starts. It provides information about watched directories, the server's running address, and process status.

```Text
INFO:     Will watch for changes in these directories: ['/Users/username/dev/xlwings-server']
INFO:     Uvicorn running on https://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [68315] using WatchFiles
INFO:     Started server process [68317]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
```

--------------------------------

### Start ngrok for local HTTPS server with certificates

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/tunneling.md

Use this command if your local development server is already running on HTTPS (e.g., on https://127.0.0.1:8000) and you have local certificates in your certs folder. ngrok will then connect to your local HTTPS endpoint.

```text
ngrok http https://127.0.0.1:8000
```

--------------------------------

### FastAPI Router for HTMX Boosted Navigation

Source: https://github.com/xlwings/xlwings-server/blob/main/app/templates/examples/navigation/README.md

This FastAPI router handles requests for a single taskpane, dynamically loading different HTML pages based on the `page` path parameter. It supports both the base `/taskpane.html` and `/taskpane/{page}` routes, rendering templates using `TemplateResponse` and passing the current page context. This setup is designed to work with htmx's `hx-boost` for partial page loads.

```Python
from fastapi import APIRouter, Request

from ..config import settings
from ..templates import TemplateResponse

router = APIRouter(prefix=settings.app_path)


@router.get("/taskpane.html")
@router.get("/taskpane/{page}")
async def taskpane(request: Request, page: str = "one"):
    return TemplateResponse(
        request=request,
        name=f"examples/navigation/taskpane_{page}.html",
        context={"page": page},
    )
```

--------------------------------

### Install `uv` in an Active Conda Environment

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dependencies.md

This command installs the `uv` package manager into the currently active Conda environment. `uv` is then used for managing Python dependencies within that Conda environment.

```bash
pip install uv
```

--------------------------------

### Implementing Global Keyboard Shortcuts with Alpine.js

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/alpinejs.md

Illustrates how to create global keyboard shortcuts in Alpine.js by attaching event listeners to the `window` object. This example shows how to focus an input field when the '/' key is pressed, preventing its default behavior.

```html
<input @keydown.window.slash.prevent="focus" />
```

```js
focus() {
  this.$el.focus();
}
```

--------------------------------

### Configure Local Git Merge Driver for .gitattributes

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

To reduce future merge conflicts, this command configures a local Git merge driver. It sets 'merge.ours.driver' to 'true', which is typically used in conjunction with '.gitattributes' to handle specific file types during merges.

```text
git config --local merge.ours.driver true
```

--------------------------------

### FastAPI Endpoints for Picture Dropdown and Display

Source: https://github.com/xlwings/xlwings-server/blob/main/app/templates/examples/pictures/README.md

This Python code defines two FastAPI endpoints. The `/taskpane` endpoint retrieves a list of PNG picture names from a specified static directory and passes them to an HTML template for populating a dropdown. The `/picture` endpoint receives a selected picture name via a form submission and renders an HTML partial to display the image. This setup supports dynamic image selection and display within a web application.

```python
from fastapi import APIRouter, Form, Request

from ..config import settings
from ..templates import TemplateResponse

router = APIRouter(prefix=settings.app_path)


@router.get("/taskpane")
@router.get("/taskpane.html")
async def taskpane(request: Request):
    directory = settings.static_dir / "images" / "ribbon" / "examples"
    picture_names = []
    for path in directory.glob("*.png"):
        picture_names.append(path.name)
    return TemplateResponse(
        request=request,
        name="examples/pictures/taskpane_pictures.html",
        context={"picture_names": picture_names},
    )


@router.post("/picture")
async def picture(request: Request, picture_name: str = Form(None)):
    return TemplateResponse(
        request=request,
        name="examples/pictures/_picture.html",
        context={"picture_name": picture_name},
    )
```

--------------------------------

### Rename Git Remote 'origin' to 'upstream'

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/repo_setup.md

This command renames the default 'origin' remote, which points to the xlwings Server repository, to 'upstream'. This convention helps distinguish the original repository from your personal fork.

```text
git remote rename origin upstream
```

--------------------------------

### Update a Specific npm Package

Source: https://github.com/xlwings/xlwings-server/blob/main/DEVELOPER_GUIDE.md

Command to update a specific npm package to its latest version.

```Shell
npm install mypackage@latest
```

--------------------------------

### Create Basic Jinja HTML Template with Context Variables

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/jinja.md

Illustrates a fundamental Jinja template (`taskpane_hello.html`) that extends a base template, defines a content block, and dynamically renders data. It includes examples of displaying variables, conditional rendering (`if`), and iterating over lists (`for`).

```Jinja
{% extends "base.html" %}

{% block content %}
  <h1>{{ title }}</h1>
  {% if show %}
    <ul>
      {% for language in languages %}
        <li>{{ language }}</li>
      {% endfor %}
    </ul>
  {% endif %}
{% endblock content %}
```

--------------------------------

### Compile xlwings Server Project Dependencies

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/upgrade.md

Executes the `run.py` script to compile the project's dependency requirements. This step ensures that all necessary packages are correctly listed and prepared for installation after merging upstream changes.

```text
python run.py deps compile
```

--------------------------------

### Run xlwings server using Docker Compose

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/docker_compose.md

This command starts the xlwings server application and its dependencies in detached mode (`-d`) using the production Docker Compose configuration. It brings up all defined services, making the application accessible.

```bash
docker compose -f deployment/docker-compose.prod.yaml up -d
```

--------------------------------

### Gunicorn Production Configuration for xlwings Server

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/production.md

This snippet shows a typical Gunicorn command for running the xlwings Server application in production. It configures the bind address, enables access logging, sets the number of workers (e.g., 2), defines a timeout, and specifies uvicorn.workers.UvicornWorker as the worker class for asynchronous operations. This setup is crucial for handling multiple requests and leveraging CPU cores effectively.

```text
gunicorn app.main:main_app
--bind 0.0.0.0:8000
--access-logfile -
--workers 2
--timeout 30
--worker-class uvicorn.workers.UvicornWorker
```

--------------------------------

### Sync Requirements in Conda Environment with `uv`

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dependencies.md

This command uses `uv pip sync` to install or update dependencies from a requirements file (e.g., `requirements-dev.txt`) into the active Conda environment. This ensures consistency with pinned dependencies.

```bash
uv pip sync requirements-dev.txt
```

--------------------------------

### Constructing full xlwings custom script URL with ngrok

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/tunneling.md

This example demonstrates how to form the complete URL for calling a custom xlwings script when using an ngrok tunnel. You need to replace the placeholder ngrok URL with your actual forwarding URL and 'hello_world' with your script's name.

```text
https://xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxx.ngrok-free.app/xlwings/custom-scripts-call/hello_world
```

--------------------------------

### Referencing Local Python Packages for Offline xlwings Wasm

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/wasm_deployment.md

This example shows how to reference a locally bundled Python wheel file within the `app/lite/requirements.txt` for xlwings Wasm apps configured for offline use. This ensures that Python packages are loaded from the local static files instead of external CDNs or PyPI.

```text
/static/vendor/pyodide/mypackage.whl
```

--------------------------------

### FastAPI Backend for htmx Form Submission

Source: https://github.com/xlwings/xlwings-server/blob/main/app/templates/examples/htmx_form/README.md

This Python code defines FastAPI routes to handle an htmx form. It includes a GET endpoint to serve the initial task pane HTML and a POST endpoint to receive form data. The POST endpoint validates the 'fullname' input, calls a custom function, and returns a rendered HTML template with the greeting or an error message.

```python
from fastapi import APIRouter, Form, Request

from .. import custom_functions
from ..config import settings
from ..templates import TemplateResponse

router = APIRouter(prefix=settings.app_path)


@router.get("/taskpane.html")
async def taskpane(request: Request):
    return TemplateResponse(
        request=request,
        name="examples/htmx_form/taskpane_htmx_form.html",
    )


@router.post("/hello")
async def hello(request: Request, fullname: str = Form()):
    error = "Please provide a name!" if not fullname else None
    greeting = custom_functions.hello(fullname)
    return TemplateResponse(
        request=request,
        name="examples/htmx_form/_greeting.html",
        context={"greeting": greeting, "error": error},
    )
```

--------------------------------

### FastAPI Endpoints for Task Pane Authentication

Source: https://github.com/xlwings/xlwings-server/blob/main/app/templates/examples/auth/README.md

This Python code defines two FastAPI endpoints for a task pane application. The `/taskpane.html` endpoint serves a publicly accessible landing page, while `/taskpane/protected` requires user authentication via the `dep.User` dependency. This setup demonstrates how to manage public and protected content within an htmx-driven task pane, noting that a full page reload will return to the landing page due to the absence of the Authorization header.

```Python
from fastapi import APIRouter, Request

from .. import dependencies as dep
from ..config import settings
from ..templates import TemplateResponse

router = APIRouter(prefix=settings.app_path)


@router.get("/taskpane.html")
async def taskpane(request: Request):
    return TemplateResponse(
        request=request,
        name="examples/auth/public.html",
    )


@router.get("/taskpane/protected")
async def taskpane_protected(request: Request, current_user: dep.User):
    return TemplateResponse(
        request=request,
        name="examples/auth/protected.html",
        context={"current_user": current_user},
    )
```

--------------------------------

### Expected Output After Docker Server Startup

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dev_docker.md

Upon successful execution of `docker compose up`, your terminal should display output similar to this, confirming the Docker network and container creation, and indicating that the Uvicorn server is running and ready for connections.

```Console
✔ Network xlwings-server_default  Created                                                                                                              0.0s
✔ Container xlwings-server-app-1  Created                                                                                                              0.0s
Attaching to app-1
app-1  | INFO:     Will watch for changes in these directories: ['/project/app']
app-1  | INFO:     Uvicorn running on https://0.0.0.0:8000 (Press CTRL+C to quit)
app-1  | INFO:     Started reloader process [1] using WatchFiles
app-1  | INFO:     Started server process [8]
app-1  | INFO:     Waiting for application startup.
app-1  | INFO:     Application startup complete.
```

--------------------------------

### Configuring htmx and xlwings Server for Excel Interaction

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/htmx.md

This guide details the configuration steps required to enable interaction with the Excel object model from an htmx task pane using xlwings Server. It covers adding specific attributes to HTML elements, including the `Book` dependency in FastAPI endpoints, passing the `Book` object via template context, and including a special template partial for client-side interaction.

```HTML
<!-- Add to the HTML element triggering the htmx request -->
<form hx-post="/excel-action" xw-book="true" xw-config='{"exclude": "MySheet"}'>
  <!-- ... form content ... -->
</form>
```

```Python
# In your FastAPI endpoint (e.g., taskpane.py):
from fastapi import Request
from fastapi.responses import TemplateResponse
from .. import dependencies as dep # Adjust import path as needed

@router.post("/excel-action")
async def excel_action(request: Request, book: dep.Book):
    # 'book' is now an xlwings Book object representing the active workbook
    # Example: Read a cell value
    # cell_value = book.sheets[0].range("A1").value
    # Example: Write to a cell
    # book.sheets[0].range("B1").value = "Updated by htmx"

    return TemplateResponse(
        request=request,
        name="/examples/excel_object_model/_excel_response.html",
        context={"book": book, "some_data": "value"},
        # block_names parameter can be used to return specific Jinja blocks
        # block_names=["my_block"]
    )
```

```Jinja2
<!-- In your Jinja2 template (the part being swapped into HTML) -->
<!-- This line is crucial for client-side interaction with the book object -->
{% include "_book.html" %}

<!-- Example of using book data in template -->
<p>Active Sheet Name: {{ book.sheets[0].name }}</p>
```

--------------------------------

### Pyodide Web Terminal Initialization and Command Processing

Source: https://github.com/xlwings/xlwings-server/blob/main/app/static/vendor/pyodide/console.html

Contains the core JavaScript logic for initializing Pyodide, setting up the terminal environment, and implementing the command interpreter. It includes functions for I/O redirection, asynchronous command execution, and error handling, along with an embedded Python helper function.

```JavaScript
"use strict"; function sleep(s) { return new Promise((resolve) => setTimeout(resolve, s)); } async function main() { let indexURL = "./"; const urlParams = new URLSearchParams(window.location.search); const buildParam = urlParams.get("build"); if (buildParam) { if (["full", "debug", "pyc"].includes(buildParam)) { indexURL = indexURL.replace( "/full/", "/" + urlParams.get("build") + "/", ); } else { console.warn( 'Invalid URL parameter: build=\"' + buildParam + '\". Using default \"full\".', ); } } const { loadPyodide } = await import(indexURL + "pyodide.mjs"); // to facilitate debugging globalThis.loadPyodide = loadPyodide; let term; globalThis.pyodide = await loadPyodide({ stdin: () => { let result = prompt(); echo(result); return result; }, }); let { repr_shorten, BANNER, PyodideConsole } = pyodide.pyimport("pyodide.console"); BANNER = `Welcome to the Pyodide ${pyodide.version} terminal emulator 🐍\n` + BANNER; const pyconsole = PyodideConsole(pyodide.globals); const namespace = pyodide.globals.get("dict")(); const await_fut = pyodide.runPython( ` import builtins from pyodide.ffi import to_js async def await_fut(fut): res = await fut if res is not None: builtins._ = res return to_js([res], depth=1) await_fut `, { globals: namespace }, ); namespace.destroy(); const echo = (msg, ...opts) => term.echo( msg .replaceAll("]]", "&rsqb;&rsqb;") .replaceAll("[[", "&lsqb;&lsqb;"), ...opts, ); const ps1 = ">>> "; const ps2 = "... "; async function lock() { let resolve; const ready = term.ready; term.ready = new Promise((res) => (resolve = res)); await ready; return resolve; } async function interpreter(command) { const unlock = await lock(); term.pause(); // multiline should be split (useful when pasting) for (const c of command.split("\n")) { const escaped = c.replaceAll(/\\u00a0/g, " "); const fut = pyconsole.push(escaped); term.set_prompt(fut.syntax_check === "incomplete" ? ps2 : ps1); switch (fut.syntax_check) { case "syntax-error": term.error(fut.formatted_error.trimEnd()); continue; case "incomplete": continue; case "complete": break; default: throw new Error(`Unexpected type ${ty}`); } // In JavaScript, await automatically also awaits any results of // awaits, so if an async function returns a future, it will await // the inner future too. This is not what we want so we // temporarily put it into a list to protect it. const wrapped = await_fut(fut); // complete case, get result / error and print it. try { const [value] = await wrapped; if (value !== undefined) { echo( repr_shorten.callKwargs(value, { separator: "\n<long output truncated>\n", }), ); } if (value instanceof pyodide.ffi.PyProxy) { value.destroy(); } } catch (e) { if (e.constructor.name === "PythonError") { const message = fut.formatted_error || e.message; term.error(message.trimEnd()); } else { throw e; } } finally { fut.destroy(); wrapped.destroy(); } } term.resume(); await sleep(10); unlock(); } term = $("body").terminal(interpreter, { greetings: BANNER, prompt: ps1, completionEscape: false, completion: function (command, callback) { callback(pyconsole.complete(command).toJs()[0]); }, keymap: { "CTRL+C": async function (event, original) { pyconsole.buffer.clear(); term.enter(); echo("KeyboardInterrupt"); term.set_command(""); term.set_prompt(ps1); }, TAB: (event, original) => { const command = term.before_cursor(); // Disable completion for whitespaces. if (command.trim() === "") { term.insert("\t"); return false; } return original(event); }, }, }); window.term = term; pyconsole.stdout_callback = (s) => echo(s, { newline: false }); pyconsole.stderr_callback = (s) => { term.error(s.trimEnd()); }; term.ready = Promise.resolve(); pyodide._api.on_fatal = async (e) => { if (e.name === "Exit") { term.error(e); term.error("Pyodide exited and can no longer be used."); } else { term.error( "Pyodide has suffered a fatal error. Please report this to the Pyodide maintainers.", ); term.error("The cause of the fatal error was:"); term.error(e); term.error("Look in the browser console for more details."); } await term.ready; term.pause(); await sleep(15); term.pause(); }; const searchParams = new URLSearchParams(window.location.search)
```

```Python
import builtins\nfrom pyodide.ffi import to_js\nasync def await_fut(fut):\n    res = await fut\n    if res is not None:\n        builtins._ = res\n    return to_js([res], depth=1)\nawait_fut
```

--------------------------------

### Load Pyodide and Run Python in Node.js

Source: https://github.com/xlwings/xlwings-server/blob/main/app/static/vendor/pyodide/README.md

Demonstrates how to initialize the Pyodide environment and execute Python code asynchronously within a Node.js script. It requires specifying the `indexURL` for Pyodide artifacts.

```javascript
// hello_python.js
const { loadPyodide } = require("pyodide");

async function hello_python() {
  let pyodide = await loadPyodide({
    indexURL: "<pyodide artifacts folder>",
  });
  return pyodide.runPythonAsync("1+1");
}

hello_python().then((result) => {
  console.log("Python says that 1+1 =", result);
});
```

--------------------------------

### Deploying xlwings Server from a Git Repository on Render

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/render.md

This snippet outlines the process for deploying xlwings Server from a custom Git repository on Render.com. This method is suitable for users who wish to make changes to the xlwings Server code or deploy their own customized version. A valid xlwings license key is required.

```Deployment Instructions
1. Set up your own Git repository containing the xlwings Server code.
2. On the Render dashboard, click on `+ New` on the top right and select `Web Service`.
3. Under `Git Provider`, select your repo, then `Connect`. (You may need to connect with your Git provider first).
4. Select a `Region` that's close to you (optional).
5. Under `Instance Type`, select an appropriate plan, e.g., `Free`.
6. Under `Environment Variables`, add `XLWINGS_LICENSE_KEY` as `NAME_OF_VARIABLE` and your license key as `value`.
7. Click on `Deploy Web Service`.
8. After a couple of minutes, you should see: `Your service is live 🎉`.
9. Click on the URL of your service (e.g., https://yourname.onrender.com). If you see `{"status": "ok"}`, everything is working correctly.
```

--------------------------------

### Execute Node.js Pyodide Script

Source: https://github.com/xlwings/xlwings-server/blob/main/app/static/vendor/pyodide/README.md

Illustrates how to run the previously defined `hello_python.js` script from the command line using Node.js and shows the expected output.

```shell
$ node hello_python.js
Python says that 1+1= 2
```

--------------------------------

### Initialize xlwings Server in Codespaces

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/github_codespaces.md

This command initializes the xlwings server environment within the GitHub Codespaces terminal. It sets up necessary configurations for the server.

```bash
python run.py init
```

--------------------------------

### Displaying xlwings Wasm Lite Build Command Help

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/wasm_deployment.md

This command shows the usage and available options for the `lite` build command, which is used to convert an xlwings Wasm app into a static website. It details arguments like the hosting URL, output directory, zip creation, cleaning, and environment settings.

```none
$ python run.py lite --help
usage: run.py lite [-h] [-o OUTPUT] [-z] [-c] [-e ENV] url

positional arguments:
  url                   URL of where the xlwings Wasm app is going to be hosted

options:
  -h, --help            show this help message and exit
  -o OUTPUT, --output OUTPUT
                        Output directory path. Defaults to ./dist.
  -z, --zip             Create zip archive in addition to the static files.
  -c, --clean           Clean the output directory before building.
  -e ENV, --env ENV     Sets the XLWINGS_ENVIRONMENT. By default uses the one from .env file.
```

--------------------------------

### Default Configuration for XLWINGS_ENABLE_EXAMPLES

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/server_config.md

Shows the default commented-out setting for `XLWINGS_ENABLE_EXAMPLES` in the `.env` file, indicating its default value of `true`. To change this, the line must be uncommented and the value modified.

```ini
# XLWINGS_ENABLE_EXAMPLES=true
```

--------------------------------

### Configure xlwings License Key

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/github_codespaces.md

Add your xlwings trial license key to the `.env` file. This key is essential for the xlwings server to function correctly and should be placed under the `XLWINGS_LICENSE_KEY` entry.

```text
XLWINGS_LICENSE_KEY=YOUR_TRIAL_KEY
```

--------------------------------

### Building xlwings Wasm App for Static Hosting

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/wasm_deployment.md

This command builds the xlwings Wasm app into static files, preparing it for deployment on a static file server. The provided URL specifies where the app will be hosted, influencing relative paths within the generated output.

```none
$ python run.py lite https://my.domain.com
```

--------------------------------

### Handle Variable Arguments with Decorators in xlwings

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/custom_functions.md

Demonstrates how to use the `@arg` decorator with `*args` to apply a converter to a variable number of arguments. This example concatenates multiple pandas DataFrames, ensuring `index=False` for each input DataFrame.

```Python
from xlwings.server import func, arg

@func
@arg("*args", pd.DataFrame, index=False)
def concat(*args):
    return pd.concat(args)
```

--------------------------------

### Run Script to Bust HTTP Cache for Static Files

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/production.md

Instructs to run a Python script as part of the deployment process to add content hashes to static file names. This technique effectively busts browser and server caches when file content changes, ensuring users receive the latest version.

```Python
python scripts/build_static_files.py
```

--------------------------------

### Implement Global Role-Based Authorization for xlwings Server

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/authorization.md

Demonstrates how to enforce global role-based access control by checking if the authenticated user possesses required roles using `self.has_required_roles()`. This example authorizes users with 'xlwings.admin' or 'xlwings.user' roles.

```Python
class User(BaseUser):
    async def is_authorized(self):
        return await self.has_required_roles(["xlwings.admin", "xlwings.user"])
```

--------------------------------

### Clear Office Cache using Script on macOS

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/install_officejs_addin.md

Running this bash script in the Terminal on macOS helps clear the Office cache, addressing problems with add-in updates not appearing correctly. Restart Excel after executing the script.

```bash
bash scripts/clear_office_cache_macos.sh
```

--------------------------------

### Clear Office Cache Folders on Windows

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/install_officejs_addin.md

Deleting these specific folders on Windows can resolve issues where Excel doesn't correctly display add-in manifest updates or opens an incorrect version of the add-in. Restart Excel after deletion.

```text
%LOCALAPPDATA%\Microsoft\Office\16.0\Wef\
%USERPROFILE%\AppData\Local\Packages\Microsoft.Win32WebViewHost_cw5n1h2txyewy\AC\#!123\INetCache\
```

--------------------------------

### Jinja2 Template for Basic Page Structure

Source: https://github.com/xlwings/xlwings-server/blob/main/app/templates/examples/navigation/taskpane_two.html

This snippet illustrates a fundamental Jinja2 template. It extends a 'base.html' file, includes a navigation partial, and defines a content block for the page's specific content.

```Jinja2
{% extends "base.html" %} {% block content %}

{% include "examples/navigation/\_navigation.html" %}

This is Page 2
==============

{% endblock content %}
```

--------------------------------

### Export Conda Environment to YAML File

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/dependencies.md

This command exports the configuration of the current Conda environment, including all installed packages, to a YAML file (e.g., `environment.yml`). This file can be used to recreate the exact environment later.

```bash
conda env export > environment.yml
```

--------------------------------

### JavaScript: Mount Local Directory for Pyodide

Source: https://github.com/xlwings/xlwings-server/blob/main/app/static/vendor/pyodide/console.html

This snippet defines the `mountDirectory` function, which allows a Pyodide instance to access a user-selected local directory. It first checks if the directory is already mounted. It then uses `idb-keyval` to store and retrieve `FileSystemDirectoryHandle` objects, prompting the user via `showDirectoryPicker` if a handle isn't found. Permissions are requested, and if granted, the directory is mounted into Pyodide's virtual file system using `pyodide.mountNativeFS`. The `getIDBKV` function handles the dynamic import of `idb-keyval`.

```javascript
; if (searchParams.has("noblink")) { $(".cmd-cursor").addClass("noblink"); } let idbkvPromise; async function getIDBKV() { if (!idbkvPromise) { idbkvPromise = await import( "https://unpkg.com/idb-keyval@5.0.2/dist/esm/index.js" ); } return idbkvPromise; } async function mountDirectory(pyodideDirectory, directoryKey) { if (pyodide.FS.analyzePath(pyodideDirectory).exists) { return; } const { get, set } = await getIDBKV(); const opts = { id: "mountdirid", mode: "readwrite", }; let directoryHandle = await get(directoryKey); if (!directoryHandle) { directoryHandle = await showDirectoryPicker(opts); await set(directoryKey, directoryHandle); } const permissionStatus = await directoryHandle.requestPermission(opts); if (permissionStatus !== "granted") { throw new Error("readwrite access to directory not granted"); } await pyodide.mountNativeFS(pyodideDirectory, directoryHandle); } globalThis.mountDirectory = mountDirectory; } window.console_ready = main();
```

--------------------------------

### Python: Returning Pandas DataFrames as Dynamic Arrays in xlwings

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/custom_functions.md

This example demonstrates how xlwings-server seamlessly integrates with pandas DataFrames, spilling their content into Excel as dynamic arrays. The function creates and returns a simple DataFrame with language and year data.

```python
import pandas as pd
from xlwings.server import func

@func
def get_dataframe():
    df = pd.DataFrame({"Language": ["Python", "JavaScript"], "Year": [1991, 1995]})
    return df
```

--------------------------------

### Deploy Function App using Azure Functions Core Tools

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/azure_functions.md

Publishes the function app from your local xlwings-server repository to Azure using the `func` CLI. This command is used for both initial deployment and subsequent updates. It must be executed from the root directory of your xlwings-server repository.

```text
func azure functionapp publish xlwings-server
```

--------------------------------

### Python: Implementing Streaming Functions (RTD) with xlwings

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/custom_functions.md

This example demonstrates how to create a streaming function in xlwings-server using an asynchronous generator. The function continuously pushes updates of a random DataFrame to Excel every second, leveraging `async def` and `yield`.

```python
import asyncio
import numpy as np
import pandas as pd
from xlwings.server import func

@func
async def streaming_random(rows, cols):
    """A streaming function pushing updates of a random DataFrame every second"""
    rng = np.random.default_rng()
    while True:
        matrix = rng.standard_normal(size=(rows, cols))
        df = pd.DataFrame(matrix, columns=[f"col{i+1}" for i in range(matrix.shape[1])])
        yield df
        await asyncio.sleep(1)
```

--------------------------------

### Read Excel Error Cells as Strings with err_to_str

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/custom_functions.md

This Python example shows how to configure an xlwings function to read Excel error cells (e.g., `#VALUE!`) as their string representation instead of `None` or `np.nan`. This is achieved by setting `err_to_str=True` on the `@arg` decorator.

```python
from xlwings.server import func, arg

@func
@arg("x", err_to_str=True)
def myfunc(x):
    ...
```

```python
from typing import Annotated, Any
from xlwings.server import func

@func
def myfunc(x: Annotated[list[list[Any]], {"err_to_str": True}]):
    ...
```

--------------------------------

### Enable Office.js Add-in Developer Extras on macOS

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/wasm_development.md

On macOS, to enable developer extras for the Office.js add-in, which allows inspection of the browser console for debugging, execute this command in your Terminal. This is a one-time setup required for enhanced debugging capabilities within Excel.

```bash
defaults write com.microsoft.Excel OfficeWebAddinDeveloperExtras -bool true
```

--------------------------------

### Building xlwings Wasm for GitHub Pages Deployment

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/wasm_deployment.md

This command builds the xlwings Wasm app and outputs the static files to a specified subdirectory, tailored for deployment on GitHub Pages. The URL should reflect the GitHub Pages hosting URL (e.g., `https://username.github.io/reponame`).

```none
python run.py lite https://username.github.io/reponame -o /path/to/repo/xlwings_serverless
```

--------------------------------

### Jinja2 HTML Page Structure

Source: https://github.com/xlwings/xlwings-server/blob/main/app/templates/examples/navigation/taskpane_one.html

This snippet defines the basic structure of a web page using Jinja2 templating. It extends a 'base.html' template, includes a navigation partial, and defines a content block for the page's main body.

```Jinja2
{% extends "base.html" %} {% block content %}

{% include "examples/navigation/\_navigation.html" %}

This is Page 1
==============

{% endblock content %}
```

--------------------------------

### Python: Returning Simple Lists as Dynamic Arrays in xlwings

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/custom_functions.md

This example shows how xlwings-server automatically spills a Python list into surrounding Excel cells as a native dynamic array. No special code changes are required; simply return a one- or two-dimensional list.

```python
from xlwings.server import func

@func
def programming_languages():
    return ["Python", "JavaScript"]
```

--------------------------------

### Generate xlwings-server Python Dependencies with uv

Source: https://github.com/xlwings/xlwings-server/blob/main/requirements.txt

This shell command utilizes `uv pip compile` to create the `requirements.txt` file for the `xlwings-server` project. It compiles dependencies from `requirements.in`, ensures universal compatibility, and explicitly allows certain packages (`pywin32`, `appscript`, `psutil`) that might otherwise be considered unsafe.

```Shell
uv pip compile requirements.in --universal -o requirements.txt --unsafe-package pywin32 --unsafe-package appscript --unsafe-package psutil
```

--------------------------------

### Activate xlwings Developer License Manually

Source: https://github.com/xlwings/xlwings-server/blob/main/docs/production.md

This command activates your xlwings developer license using the provided license key. This step is required before you can manually generate deploy keys for production environments.

```text
xlwings license update -k YOUR_LICENSE_KEY
```
Tokens:
Raw