powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

npm add -D @tauri-apps/cli
cargo install create-tauri-app --locked

> npm create tauri-app
Need to install the following packages:
create-tauri-app@4.6.2
Ok to proceed? (y) y


> npx
> create-tauri-app

✔ Project name · hello_pytauri
✔ Identifier · com.rmc-8.hello_pytauri
✔ Choose which language to use for your frontend · TypeScript / JavaScript - (pnpm, yarn, npm, deno, bun)
✔ Choose your package manager · npm
✔ Choose your UI template · Svelte - (https://svelte.dev/)
✔ Choose your UI flavor · TypeScript

Template created! To get started run:
  cd hello_pytauri
  npm install
  npm run tauri android init

For Desktop development, run:
  npm run tauri dev

For Android development, run:
  npm run tauri android dev

└─hello_pytauri
    ├─.vscode
    ├─src
    │  └─routes
    ├─src-tauri
    │  ├─capabilities
    │  ├─icons
    │  └─src
    └─static

uv venv --python-preference only-system

.venv\Scripts\Activate.ps1

[project]
name = "hello_pytauri"
version = "0.1.0"
description = "Add your description here"
requires-python = ">=3.9"
dependencies = ["pytauri == 0.8.*"]

[project.entry-points.pytauri]
ext_mod = "tauri_app.ext_mod"

[build-system]
requires = ["setuptools >= 80"]
build-backend = "setuptools.build_meta"

[tool.setuptools.packages]
find = { where = ["python"] }

uv pip install -e src-tauri

from pytauri import (
    builder_factory,
    context_factory,
)


def main() -> int:
    app = builder_factory().build(
        context=context_factory(),
        invoke_handler=None,  # TODO
    )
    exit_code = app.run_return()
    return exit_code

import sys
from multiprocessing import freeze_support

from tauri_app import main

freeze_support()

sys.exit(main())

[dependencies]
# ...
pytauri = { version = "0.8" }
pyo3 = { version = "0.25" }

{
    "build": {
        "features": ["pytauri/standalone"]
    }
}

use pyo3::prelude::*;

// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}! You've been greeted from Rust!", name)
}

pub fn tauri_generate_context() -> tauri::Context {
    tauri::generate_context!()
}

#[pymodule(gil_used = false)]
#[pyo3(name = "ext_mod")]
pub mod ext_mod {
    use super::*;

    #[pymodule_init]
    fn init(module: &Bound<'_, PyModule>) -> PyResult<()> {
        pytauri::pymodule_export(
            module,
            // i.e., `context_factory` function of python binding
            |_args, _kwargs| Ok(tauri_generate_context()),
            // i.e., `builder_factory` function of python binding
            |_args, _kwargs| {
                let builder = tauri::Builder::default()
                    .plugin(tauri_plugin_opener::init())
                    .invoke_handler(tauri::generate_handler![greet]);
                Ok(builder)
            },
        )
    }
}

// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

use std::{convert::Infallible, env::var, error::Error, path::PathBuf};

use pyo3::wrap_pymodule;
use pytauri::standalone::{
    dunce::simplified, PythonInterpreterBuilder, PythonInterpreterEnv, PythonScript,
};
use tauri::utils::platform::resource_dir;

use hello_pytauri_lib::{ext_mod, tauri_generate_context};

fn main() -> Result<Infallible, Box<dyn Error>> {
    let py_env = if cfg!(dev) {
        // `cfg(dev)` is set by `tauri-build` in `build.rs`, which means running with `tauri dev`,
        // see: <https://github.com/tauri-apps/tauri/pull/8937>.

        let venv_dir = var("VIRTUAL_ENV").map_err(|err| {
            format!(
                "The app is running in tauri dev mode, \
                please activate the python virtual environment first \
                or set the `VIRTUAL_ENV` environment variable: {err}",
            )
        })?;
        PythonInterpreterEnv::Venv(PathBuf::from(venv_dir).into())
    } else {
        // embedded Python, i.e., bundle mode with `tauri build`.

        let context = tauri_generate_context();
        let resource_dir = resource_dir(context.package_info(), &tauri::Env::default())
            .map_err(|err| format!("failed to get resource dir: {err}"))?;
        // 👉 Remove the UNC prefix `\\?\`, Python ecosystems don't like it.
        let resource_dir = simplified(&resource_dir).to_owned();

        // 👉 When bundled as a standalone App, we will put python in the resource directory
        PythonInterpreterEnv::Standalone(resource_dir.into())
    };

    // 👉 Equivalent to `python -m tauri_app`,
    // i.e, run the `src-tauri/python/tauri_app/__main__.py`
    let py_script = PythonScript::Module("tauri_app".into());

    // 👉 `ext_mod` is your extension module, we export it from memory,
    // so you don't need to compile it into a binary file (.pyd/.so).
    let builder =
        PythonInterpreterBuilder::new(py_env, py_script, |py| wrap_pymodule!(ext_mod)(py));
    let interpreter = builder.build()?;

    let exit_code = interpreter.run();
    std::process::exit(exit_code);
}

__pycache__

import { defineConfig } from "vite";

// https://vitejs.dev/config/
export default defineConfig(async () => ({
  // ...
  server: {
    watch: {
      // 3. tell vite to ignore watching `src-tauri`
      ignored: ["**/src-tauri/**", "**/.venv/**"],
    },
  },
}));

[dependencies]
tauri-plugin-pytauri = { version = "0.8" }

{
    // ...
    "permissions": [
        // ...
        "pytauri:default"
    ]
}

# ...

[project]
# ...
dependencies = [
    # ...
    "pydantic == 2.*",
    "anyio == 4.*"
]

npm install json-schema-to-typescript --save-dev
npm instal json2ts --help

import sys
from os import getenv
from pathlib import Path

from anyio.from_thread import start_blocking_portal  # noqa: F401
from pydantic import BaseModel, ConfigDict
from pydantic.alias_generators import to_camel
from pytauri import Commands, builder_factory, context_factory

# TypeScript 타입 정의 자동 생성 활성화 (개발 시에만)
PYTAURI_GEN_TS = getenv("PYTAURI_GEN_TS") != "0"

commands: Commands = Commands(experimental_gen_ts=PYTAURI_GEN_TS)


class _BaseModel(BaseModel):
    model_config = ConfigDict(
        # JavaScript의 camelCase를 Python의 snake_case로 자동 변환
        alias_generator=to_camel,
        # 알 수 없는 필드 금지 (TypeScript 타입 안정성 향상)
        extra="forbid",
    )


class Person(_BaseModel):
    """A person to greet.

    @property name - The name of the person.
    """

    name: str


@commands.command()
async def greet_to_person(body: Person) -> str:
    """A simple command that returns a greeting message from Python backend.

    @param body - The person to greet.
    """
    python_version = ".".join(sys.version.split(".")[:2])  # e.g., "3.12"
    return f"Hello, {body.name}! 👋 This greeting comes from Python {python_version} backend!"


def main() -> int:
    with start_blocking_portal(
        "asyncio"
    ) as portal:  # 추가 (asyncio 대신 trio도 가능)
        if PYTAURI_GEN_TS:
            # TypeScript 클라이언트 코드를 src/lib 디렉토리에 생성
            output_dir = Path(__file__).parent.parent.parent.parent / "src" / "lib"
            json2ts_cmd = "npm json2ts --format=false"

            # 백그라운드에서 TypeScript 타입 정의 자동 생성
            portal.start_task_soon(
                lambda: commands.experimental_gen_ts_background(
                    output_dir, json2ts_cmd, cmd_alias=to_camel
                )
            )

        app = builder_factory().build(
            context=context_factory(),
            invoke_handler=commands.generate_handler(portal),  # 추가
        )
        exit_code = app.run_return()
        return exit_code

/* eslint-disable */
/**
 * This file was automatically generated by pytauri-gen-ts.
 * DO NOT MODIFY IT BY HAND. Instead, modify the source commands API,
 * and run pytauri-gen-ts to regenerate this file.
 */

import { pyInvoke } from "tauri-plugin-pytauri-api";
import type { InvokeOptions } from "@tauri-apps/api/core";

import type { Commands } from "./_apiTypes.d.ts";

/**
 * A simple command that returns a greeting message.
 *
 * @param body - The person to greet.
 */
export async function greetToPerson(
    body: Commands["greet_to_person"]["input"],
    options?: InvokeOptions
): Promise<Commands["greet_to_person"]["output"]> {
    return await pyInvoke("greet_to_person", body, options);
}

<script lang="ts">
  import { greetToPerson } from "$lib/main"; // Python 프로세스를 main.ts에서 import

  let name = $state("");
  let greetMsg = $state("");

  async function greet(event: Event) { // greetToPerson을 함수화
    event.preventDefault();
    greetMsg = await greetToPerson({ name });
  }
</script>

<main class="container">
  <h1>Welcome to Tauri + Svelte</h1>

  <div class="row">
    <a href="https://vite.dev" target="_blank">
      <img src="/vite.svg" class="logo vite" alt="Vite Logo" />
    </a>
    <a href="https://tauri.app" target="_blank">
      <img src="/tauri.svg" class="logo tauri" alt="Tauri Logo" />
    </a>
    <a href="https://svelte.dev" target="_blank">
      <img src="/svelte.svg" class="logo svelte-kit" alt="SvelteKit Logo" />
    </a>
  </div>
  <p>Click on the Tauri, Vite, and SvelteKit logos to learn more.</p>

  <form class="row" onsubmit={greet}> <!-- greet 호출 -->
    <input id="greet-input" placeholder="Enter a name..." bind:value={name} />
    <button type="submit">Greet</button>
  </form>
  <p>{greetMsg}</p>
</main>