const name: string = "張三";
const age: number = 25;
const isActive: boolean = true;
const hobbies: string[] = ["讀書", "游泳"];

name: str = "張三"
age: int = 25
is_active: bool = True  # 注意：Python 使用 snake_case 命名規(guī)范
hobbies: List[str] = ["讀書", "游泳"]  # 需要從 typing 導(dǎo)入 List

function greet(name: string): string {
    return `Hello, ${name}!`;
}

// 箭頭函數(shù)
const greet = (name: string): string => {
    return `Hello, ${name}!`;
};

def greet(name: str) -> str:
    return f"Hello, {name}!"

# Lambda 函數(shù)
greet = lambda name: f"Hello, {name}!"

// Promise 方式
function fetchData(): Promise<string> {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("數(shù)據(jù)獲取成功");
        }, 1000);
    });
}

// Async/await 方式
async function getData(): Promise<void> {
    try {
        const result: string = await fetchData();
        console.log(result);
    } catch (error) {
        console.error(error);
    }
}

import asyncio
from typing import Awaitable

async def fetch_data() -> str:
    await asyncio.sleep(1)  # 模擬異步操作
    return "數(shù)據(jù)獲取成功"

async def get_data() -> None:
    try:
        result: str = await fetch_data()
        print(result)
    except Exception as e:
        print(f"錯(cuò)誤: {e}")

# 運(yùn)行異步函數(shù)
asyncio.run(get_data())

// CommonJS
const fs = require('fs');
const myModule = require('./myModule');

// ES6 模塊
import fs from 'fs';
import { someFunction } from './myModule';

// TypeScript 中的類型導(dǎo)入
import type { SomeInterface } from './interfaces';

# Python 標(biāo)準(zhǔn)庫(kù)導(dǎo)入
import os
import json
from typing import Dict, List, Optional

# 自定義模塊導(dǎo)入
from concat_model.service import default_concat_service
from concat_model.types import Node, Workflow

import sys
import os
from typing import Dict, List, Any

# 添加項(xiàng)目根目錄到Python路徑，以便正確導(dǎo)入chat_model
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))

# 直接導(dǎo)入chat_model中的llm_service
from search_rag_graph.chat_model.llm_service import llm_service as external_llm_service

class Person {
  private name: string;
  private age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  public greet(): string {
    return `Hello, I'm ${this.name}`;
  }
}

class Node:
    """節(jié)點(diǎn)類"""
    def __init__(self, node_id: str, tag_key: str, action_type: str, action_target: str, pre_snapshot: Optional[Any] = None, **kwargs):
        self.node_id = node_id
        self.tag_key = tag_key
        self.action_type = action_type
        self.action_target = action_target
        self.pre_snapshot = pre_snapshot
        self.__dict__.update(kwargs)

    def to_dict(self) -> Dict[str, Any]:
        """轉(zhuǎn)換為字典"""
        return self.__dict__.copy()

interface User {
    id: number;
    name: string;
    email?: string; // 可選屬性
}

// 泛型
interface ApiResponse<T> {
    data: T;
    status: number;
}

// 聯(lián)合類型
type Status = "pending" | "approved" | "rejected";

// 類型別名
type UserId = string | number;

# Python 類型提示
from typing import Optional, Union, Dict, List, TypeVar, Generic

# 類似接口的概念（使用 Protocol，Python 3.8+）
from typing_extensions import Protocol

class User(Protocol):
    id: int
    name: str
    email: Optional[str]

# 泛型
T = TypeVar('T')

class ApiResponse(Generic[T]):
    def __init__(self, data: T, status: int):
        self.data = data
        self.status = status

# 聯(lián)合類型
from typing import Literal
Status = Literal["pending", "approved", "rejected"]

# 類型別名
UserId = Union[str, int]

class QueryFullFlowInput(BaseModel):
    """
    查詢?nèi)鞒梯斎雲(yún)?shù)
    """
    query_text: str = Field(..., description="查詢語(yǔ)句，描述業(yè)務(wù)意圖")
    env_type: EnvironmentType = Field(..., description="環(huán)境類型，dev、test或prod")
    form_params: Optional[List[str]] = Field(None, description="表單參數(shù)數(shù)組，可選")
    version: Optional[str] = Field(None, description="版本約束，test、prod必填")

{
  "dependencies": {
    "express": "^4.18.0",
    "lodash": "^4.17.21"
  },
  "devDependencies": {
    "typescript": "^4.9.0",
    "ts-node": "^10.9.0"
  }
}

[project]
dependencies = [
    "fastapi>=0.124.4",
    "uvicorn>=0.38.0",
    "requests>=2.31.0",
    "chromadb>=0.4.24",
    "jieba>=0.42.1",
    "numpy>=1.26.4",
    "pydantic>=2.5.3",
]
[build-system]
requires = ["setuptools>=42", "wheel"]
build-backend = "setuptools.build_meta"