# json_repair

修复 LLM 输出的 json

https://github.com/mangiucugna/json_repair

`pip install json_repair`

## `repair_json()`

```python
from json_repair import repair_json, loads

bad_json_string = '{"a": 1'

good_json_string = repair_json(bad_json_string)
print(good_json_string) # '{"a": 1}'
```



```python
def repair_json(
 json_str: str = "",
 return_objects: Optional[bool] = False, # True：对修复后的 json 字符串反序列化
 skip_json_loads: Optional[bool] = False, # True：在修复前先调用 json.loads()
 logging: Optional[bool] = False, # True：函数将返回一个元组，包含修复后的 json 字符串和一个记录了所有修复操作的日志列表
 json_fd: Optional[TextIO] = None, # True：在修复前先调用 json.load()；False：在修复前先调用 json.loads()
 ensure_ascii: Optional[bool] = True, # True：所有非 ASCII 字符将在 json 字符串中转义；False：可以包含原始的 Unicode 字符
):
```

## `loads()`

```python
def loads(
 json_str: str,
 skip_json_loads: Optional[bool] = False,
 logging: Optional[bool] = False,
):
 return repair_json(
 json_str=json_str,
 return_objects=True, # 默认调用 return_objects=True 的 repair_json 函数
 skip_json_loads=skip_json_loads,
 logging=logging,
 )
```

json_repair，修复 LLM（大语言模型）输出的 JSON 结果

# jsonpath

https://jsonpath.com/

| 功能 | JSONPath符号 | XPath符号 | 描述 | 
| --- | --- | --- | --- | 
| 根节点 | `$` | `/` | 访问JSON或XML的根节点 | 
| 子节点 | `.` | `/` | 访问当前节点的子节点 | 
| 所有子节点 | `*` | `*` | 访问当前节点的所有子节点 | 
| 数组索引 | `[n]` | `[n]` | 访问数组的第n个元素 | 
| 所有数组元素 | `[*]` | `*` | 访问数组中的所有元素 | 
| 合并操作符 | `[,]` | | 访问若干个元素 |
| 切片运算符 | `[:]` | | 访问若干个元素，左闭右开 |
| 递归下级 | `..` | `//` | 访问当前节点及其所有子孙节点 | 
| 过滤条件 | `[?()]` | `[condition]` | 根据条件筛选节点 | 

**返回的结果均为数组**

## 示例



```json
{
 "store": {
 "book": [
 {
 "category": "reference",
 "price": 8.95
 },
 {
 "category": "fiction",
 "price": 18.95
 }
 ],
 "bicycle": {
 "color": "red",
 "price": 9.95
 },
 "candy": [
 2, 10, 7, 9, 8, 5, -1
 ]
 }
}
```

- `$`

```json
[
 {
 "store": {
 "book": [
 {
 "category": "reference",
 "price": 8.95
 },
 {
 "category": "fiction",
 "price": 18.95
 }
 ],
 "bicycle": {
 "color": "red",
 "price": 9.95
 },
 "candy": [
 2, 10, 7, 9, 8, 5, -1
 ]
 }
 }
]
```

- `$.store`

```json
[
 {
 "book": [
 {
 "category": "reference",
 "price": 8.95
 },
 {
 "category": "fiction",
 "price": 18.95
 }
 ],
 "bicycle": {
 "color": "red",
 "price": 9.95
 },
 "candy": [
 2, 10, 7, 9, 8, 5, -1
 ]
 }
]
```

- `$.store.*` | `$.store[*]`

```json
[
 [
 {
 "category": "reference",
 "price": 8.95
 },
 {
 "category": "fiction",
 "price": 18.95
 }
 ],
 {
 "color": "red",
 "price": 9.95
 },
 [
 2, 10, 7, 9, 8, 5, -1
 ]
]
```

- `$.store.book[1]`

```json
[
 {
 "category": "fiction",
 "price": 18.95
 }
]
```

- `$.store.book[*]`

```json
[
 {
 "category": "reference",
 "price": 8.95
 },
 {
 "category": "fiction",
 "price": 18.95
 }
]
```

- `$.store..category`

```json
[
 "reference",
 "fiction"
]
```

- `$.store[?(@.price < 10)]`

```json
[
 {
 "color": "red",
 "price": 9.95
 }
]
```

- `$.store.[?(@.price < 10)]`

```json
[
 {
 "color": "red",
 "price": 9.95
 },
 {
 "category": "reference",
 "price": 8.95
 }
]
```

- `$..candy.[1,3,2]` | `$..candy[1,3,2]`

```json
[
 10,
 9,
 7
]
```

- `$..candy.[1:3]` | `$..candy[1:3]`

```json
[
 10,
 7
]
```

# jsonpath-ng

https://github.com/h2non/jsonpath-ng

https://pypi.org/project/jsonpath-ng/

`pip install jsonpath-ng`

`pip install jsonpath-ng[ext]`（扩展包）

```python
import json
from jsonpath_ng.ext import parse


json_string = '{"store": ["xxx"]}'
data = json.loads(json_string)

expression = parse('$.store')
authors = [match.value for match in expression.find(data)]
print(authors) # [['xxx']]
```

JsonPath 用法详解，使用 Python 处理 JSON 数据

https://github.com/scrapy/w3lib

`pip install w3lib`

# `w3lib.url`

## `canonicalize_url(url, keep_fragments=False)` 规范化 URL

- 排序 URL 中的参数
- 标准化 URL 的大小写
- 删除结尾的无效内容



```python
from w3lib.url import canonicalize_url

url = "HTTP://www.Example.com/a%20b?b=2&a=1#fragment"
canonical_url = canonicalize_url(url)
print(canonical_url) # 输出: "http://www.example.com/a%20b?a=1&b=2"
```

## `add_or_replace_parameter(url, name, new_value)` URL 中添加或替换查询参数

```python
from w3lib.url import add_or_replace_parameter

url = "http://www.example.com/page?param1=value1"
new_url = add_or_replace_parameter(url, "param2", "value2")
print(new_url) # 输出: "http://www.example.com/page?param1=value1&param2=value2"
```

## `is_url(url)` 检查字符串是否为有效的 URL

```python
from w3lib.url import is_url

url = "http://www.example.com"
print(is_url(url)) # 输出: True

invalid_url = "not_a_url"
print(is_url(invalid_url)) # 输出: False
```

## `url_query_cleaner(url, parameterlist=(), remove=False, unique=True)` 清理 URL 中的查询参数

- remove：
 - True：删除 parameterlist 中的参数
 - False：仅保留 parameterlist 中的参数
- unique：
 - True：删除名重复参数
 - False：不删除名重复参数

```python
from w3lib.url import url_query_cleaner

url = "http://www.example.com/page?param1=value1&param2=value2&param1=value3"
cleaned_url = url_query_cleaner(url, parameterlist=["param1", "param2"])
print(cleaned_url) # 输出: "http://www.example.com/page?param1=value1&param2=value2"
```

## `safe_url_string(url)` 将 URL 转换为安全的字符串形式（编码 URL）

```python
from w3lib.url import safe_url_string

url = "http://www.example.com/文件"
safe_url = safe_url_string(url)
print(safe_url) # 输出: "http://www.example.com/%E6%96%87%E4%BB%B6"
```

# `w3lib.html`

## `remove_tags(html, which_ones=())` 移除 HTML 字符串中的指定标签

```python
from w3lib.html import remove_tags

html = "Hello World!"
clean_html = remove_tags(html, which_ones=["b"])
print(clean_html) # 输出: "Hello World!"
```

## `replace_tags(html, token, which_ones=())` 将指定的 HTML 标签替换为给定的字符串

```python
from w3lib.html import replace_tags

html = "Hello World!"
replaced_html = replace_tags(html, token="**", which_ones=["b"])
print(replaced_html) # 输出: "Hello **World**!"
```

## `strip_html5_whitespace(text)` 移除 HTML5 中定义的空白字符

```python
from w3lib.html import strip_html5_whitespace

text = " Hello World! \n\t"
clean_text = strip_html5_whitespace(text)
print(clean_text) # 输出: "Hello World!"
```

## `replace_entities(text)` 替换 HTML 实体为对应的字符

用于将 `&amp;`、`&lt;` 等 HTML 实体转换为其对应的字符

```python
from w3lib.html import replace_entities

text = "Hello &amp; World"
clean_text = replace_entities(text)
print(clean_text) # 输出: "Hello & World"
```

### 常见 HTML 实体

1. 常见符号

| 符号 | 实体名称 | 实体编号 | 描述 |
|-------|----------|----------|-----------------|
| `&` | `&amp;` | `&#38;` | 和号（Ampersand）|
| `<` | `&lt;` | `&#60;` | 小于号（Less Than）|
| `>` | `&gt;` | `&#62;` | 大于号（Greater Than）|
| `"` | `&quot;` | `&#34;` | 双引号（Quotation Mark）|
| `'` | `&apos;` | `&#39;` | 单引号（Apostrophe）|

2. 空格和空白字符

| 符号 | 实体名称 | 实体编号 | 描述 |
|-------|-----------|----------|-------------------------|
| ` ` | `&nbsp;` | `&#160;` | 不间断空格（Non-Breaking Space）|
| ` ` | `&ensp;` | `&#8194;`| 短空格（En Space） |
| ` ` | `&emsp;` | `&#8195;`| 长空格（Em Space） |
| ` ` | `&thinsp;`| `&#8201;`| 细空格（Thin Space） |

3. 数学符号

| 符号 | 实体名称 | 实体编号 | 描述 |
|-------|----------|----------|----------------|
| `+` | `&plus;` | `&#43;` | 加号（Plus Sign）|
| `−` | `&minus;`| `&#8722;`| 减号（Minus Sign）|
| `×` | `&times;`| `&#215;` | 乘号（Multiplication Sign）|
| `÷` | `&divide;`| `&#247;`| 除号（Division Sign）|
| `±` | `&plusmn;`| `&#177;`| 正负号（Plus-Minus Sign）|
| `≠` | `&ne;` | `&#8800;`| 不等号（Not Equal）|

# `w3lib.encoding`

## `html_body_declared_encoding(body)` 从 HTML `<meta>` 标签中提取声明的字符编码

```python
from w3lib.encoding import html_body_declared_encoding

html = '<meta charset="UTF-8">Hello World!'
encoding = html_body_declared_encoding(html)
print(encoding) # 输出: "UTF-8"
```

# `w3lib.http`

## `normalize_headers(headers)` 将 HTTP 头转换为标准化格式

```python
from w3lib.http import normalize_headers

headers = {
 "Content-Type": "text/html",
 "User-Agent": "Mozilla/5.0"
}
normalized_headers = normalize_headers(headers)
print(normalized_headers) # 输出: {'content-type': ['text/html'], 'user-agent': ['Mozilla/5.0']}
```

w3lib 用于处理 Web 数据的 Python 库

https://github.com/rustdesk
https://rustdesk.com/docs/zh-cn/

# 客户端

https://github.com/rustdesk/rustdesk/releases

# 服务端

## docker



https://rustdesk.com/docs/zh-cn/self-host/rustdesk-server-oss/install/#docker%E7%A4%BA%E8%8C%83

1. `docker-compose up` 启动

```dockerfile
networks:
 rustdesk-net:
 external: false

services:
 hbbs: # RustDesk ID 注册服务器
 container_name: hbbs
 ports:
 - 21115:21115
 - 21116:21116 # 自定义 hbbs 映射端口
 - 21116:21116/udp # 自定义 hbbs 映射端口
 image: rustdesk/rustdesk-server
 command: hbbs
 volumes:
 - ./hbbs_root:/root # 自定义挂载目录
 networks:
 - rustdesk-net
 depends_on:
 - hbbr
 restart: unless-stopped
 deploy:
 resources:
 limits:
 memory: 64M

 hbbr: # RustDesk 中继服务器
 container_name: hbbr
 ports:
 - 21117:21117 # 自定义 hbbr 映射端口
 image: rustdesk/rustdesk-server
 command: hbbr
 volumes:
 - ./hbbr_root:/root # 自定义挂载目录
 networks:
 - rustdesk-net
 restart: unless-stopped
 deploy:
 resources:
 limits:
 memory: 64M
```

2. 设置 > 网络 > ID/中继服务器
- ID 服务器：`<your_domain>:21116`
- 中继服务器：`<your_domain>:21117`
- Key：服务端 `/hbbs_root/.pub` 文件内容

RustDesk 远程桌面加自建服务

# 推理参数

## temperature

该参数用于控制生成文本的随机性和多样性，其实是调整了模型输出的 logits 概率分布
- temperature 较高时，会更平均地分配概率给各个 token，这导致生成的文本更具随机性和多样性
- temperatur 较低接近 0 时，会倾向于选择概率最高的 token，从而使生成的文本更加确定和集中
- temperature=1 时表示不使用此方式

## top_k



用于在生成下一个 token 时，限制模型只能考虑前 k 个概率最高的 token，这个策略可以降低模型生成无意义或重复的输出的概率，同时提高模型的生成速度和效率

## top_p

通常用一个介于 0 到 1 之间的值来表示生成下一个 token 时，在概率分布中选择的最高概率的累积阈值
- top_p 较高时比如 0.9，这意味着前 90% 的概率的 token 会被考虑在抽样中，这样会允许更多的 token 参与抽样，增加生成文本的多样性
- top_p 较低时比如 0.1，这意味着只有前 10% 最高概率的 token 会被考虑在抽样中，这样会限制生成文本的可能性，使生成的文本更加确定和集中
- top_p=1 时表示不使用此方式

## repetition_penalty

重复惩罚：目标是在这个概率分布中对先前生成过的 token，又重复的生成了该 token 进行惩罚（降低概率），以减少生成文本中的重复性

## no_repeat_ngram_size

当设为大于 0 的整数时，生成的文本中不会出现指定大小的重复 n-gram（n个连续的token），可以使生成的文本更加多样化，避免出现重复的短语或句子结构

## do_sample

对模型计算出来的概率要不要进行多项式采样

### 多项式采样

多项式采样（Multinomial Sampling）是一种用于从一个具有多个可能结果的离散概率分布中进行随机抽样的方法

在多项式采样中，概率高的结果更有可能被选中，但不同于确定性的选择，每个结果（概率较低但仍然可能的词）仍然有一定的概率被选中

## num_beams

用于束搜索（beam search）算法，用途是控制生成的多个候选句子的数量，该参数控制的是每个生成步要保留的生成结果的数量

### num_beam_groups

beam search 算法的改进，叫做 Diverse Beam Search (DBS)

核心是分组机制，如果设置 num_beams=2，num_beam_groups=2，那就是说分成2个组，每个组里的 beam 可以相似，但组和组之间要有足够的多样性

### diversity_penalty

多样性惩罚参数只有在启用了“num_beam_groups”（组束搜索）时才有效，在这些组之间应用多样性惩罚，以确保每个组生成的内容尽可能不同

### length_penalty

长度惩罚参数也是用于束搜索过程中，作用是将生成序列的长度应用于得分的分母，从而影响候选序列的得分

- length_penalty > 1.0 时，较长的序列得到更大的惩罚，鼓励生成较短的序列
- length_penalty < 1.0 时，较短的序列得到更大的惩罚，鼓励生成较长的序列
- 默认为1，不受惩罚

## use_cache

设置为True时，则模型会利用之前计算得到的注意力权重（key/values attentions）的缓存，当下一个token需要被生成时，模型可以通过缓存的注意力权重来重用之前计算的信息，而不需要重新计算一次，有效地跳过重复计算的步骤，从而减少计算负担，提高生成速度和效率

## max_length

生成的 token 的最大长度 = 输入 prompt 的长度 + max_new_tokens

如果同时设置了 max_new_tokens，则会覆盖此参数

### max_new_tokens

生成的最大 token 的数量，不考虑输入 prompt 中的 token 数

## min_length

生成的 token 的最小长度 = 输入 prompt 的长度 + min_new_tokens

如果同时设置了 min_new_tokens，则会覆盖此参数

### min_new_tokens

生成的最小 token 的数量，不考虑输入 prompt 中的 token 数

## bad_words_ids

包含词汇 id 的列表，用于指定不允许在生成文本中出现的词汇，如果生成的文本包含任何在这个列表中的词汇，它们将被被替换或排除在最终生成的文本之外。

## force_words_ids

包含词汇 id 的列表，用于指定必须包含在生成文本中的词汇，如果给定一个列表，生成的文本将包含这些词汇。

## constraints

自定义约束条件，可以指定约束条件，这些约束条件可以是必须出现的关键词、短语、特定术语或其他文本元素，和 force_words_ids 差不多，在代码实现也是一样的。

json_repair

repair_json()

jsonpath

示例

w3lib.url

canonicalize_url(url, keep_fragments=False) 规范化 URL

客户端

服务端

docker

推理参数

temperature

top_k

`repair_json()`

`w3lib.url`

`canonicalize_url(url, keep_fragments=False)` 规范化 URL