最近，我们注意到 IT Craft Development Team 中出现了一些不寻常的现象：一位成员似乎对他曾经参与的事件记忆模糊，并且不断重复询问一些已知的问题。经过我们组织管理层的紧急讨论，我们怀疑这名成员可能已经被一个名为花火的假面愚者所替代。

花火拥有令人难以置信的能力，她能够完美地模仿任何人的外貌、声音，甚至是他们的细微动作和日常习惯。这种能力让她能够在不被察觉的情况下，悄无声息地杀死并取代人们的朋友或亲人。这种替换是如此巧妙，以至于连最亲近的人都难以察觉。

被花火所替代的人通常会表现出以下特征：

1. 对于他们曾经参与的事件，他们的记忆似乎变得模糊不清。
2. 他们会反复询问一些已经过去很久的事件的详细信息，仿佛他们从未了解过。
3. 他们可能会对一些他们原本不感兴趣的话题表现出异常的兴趣，这种兴趣与他们以往的兴趣大相径庭。
4. 他们的出现和消失可能会非常突然，没有合理的解释。

如果您发现您的同事或朋友出现了上述的任何迹象，那么他们很可能已经成为了花火的目标。我们强烈建议您保持高度警惕，并在必要时与他们保持一定的距离。同时，您也应该采取措施保护自己，以免成为花火的下一个目标。请记住，保持警觉是防止被花火替换的关键。

坏

仓库地址: https://github.com/RimoChan/Pepin (这东西代码很抽象)

没错，我还活着

今天在整理 U 盘的时候突然翻出来了一些很久以前写的项目，因为太闲所以发出来。

下载地址

链接: https://pan.baidu.com/s/1-pci\_AYao2FdzJhon0vPNw
提取码: 83sy

链接: https://pan.baidu.com/s/10CRh1uLjSiqhYysz04AxLw
提取码: c7zu

温馨提示

其中大部分项目已停止维护，不保证其可用性，请秉着「能跑就行，不能跑就算了」理念阅读这些项目的代码。不建议学习代码的写法。

我也没认真翻过，所以我不知道会翻出什么奇奇怪怪的东西。

温馨提示：程序接单目前已经不再开放，但您仍然可以在issue中为新项目提供想法

详细信息

• 单号：PYLIB-ORD-20211101
• 委托人（QQ）：3627035438
• 项目：TXTX解析工具
• 类型：Python库-ORD
• 收费：1.0/1.0 CNY（付款方式：QQ）

代码：

./txtx.py

# Powered By XD(www.thisisxd.tk)
import os

def delzhushi(l,start = 0):
    s = l[start].find("#")
    li = l
    if s != -1:
        li[start] = li[start][0:s]
    if start == l.__len__()-1:
        return li
    else:
        return delzhushi(li,start+1)

def run(txt):
    t = txt
    le = 0
    for tx in t:
        where_w = tx.find("[Run_Windows]")
        where_u = tx.find("[Run_Unix](")
        if os.name == "nt":
            if where_w != -1:
                t.pop(le)
                #print(tx[where_w+14:tx.find(")",where_w)])
                os.popen(tx[where_w+14:tx.find(")",where_w)])
        else:
            if where_u != -1:
                t.pep(le)
                os.popen(tx[where_u+14:tx.find(")",where_u)])
        le += 1
    return t

def get_home(txtx):
    tx = txtx
    l = 0
    for t in tx:
        w = t.find("<[")
        if w != -1:
            home = t[w+2:t.find("]",w)]
            for i in range(l):
                tx.pop(0)
            if  home == "":
                raise TypeError("跟声明不能为空")
            else:
                return tx,home

def load(t):
    txtx = {}
    # 逐行分割
    t1 = t.split("\n")
    # 删除注释
    t1 = delzhushi(t1)
    # 跑命令
    t1 = run(t1)
    # 获取跟声明
    temp = get_home(t1)
    t1 = temp[0]
    home = temp[1]
    # 解析
    f = 1
    s = 0
    tw = [False]
    tg = False
    txtx[home] = {}
    y = 0
    for t in t1:
        s += 1
        temp = {}
        k_start = t.find("[")
        if k_start != -1 and tg == False and t.find("<[") == -1:
            k_end = t.find("]",k_start)
            if k_end != -1:
                v_start = t.find("(",k_end)
                if v_start != -1:
                    v_end = t.find(")",v_start)
                    if v_end == -1:
                        raise KeyError(f"行0{s}：这个值没有结尾")
                else:
                     raise KeyError(f"行0{s}：一个没有意义的键")
            else:
                raise KeyError(f"行0{s}：这个键没有结尾")
            # 能执行到这里这行基本就是有效的了
            print(1,t.find("<["),tg,home)
            # 分析键
            key = t[k_start+1:k_end]
            value = t[v_start+1:v_end]
            # 储存
            txtx[home][key] = value
        else:
            tmp = t.find("<[")
            if tmp != -1 and t[tmp+2:t.find("]",tmp)] != home:
                tg = True
                tw[0] = True
                if y != 1:
                    tw  += [[s,t[tmp+2:t.find("]",tmp)]]]
                y += 1
            elif t.find(">") != -1:
                tg = False
                if y == 1:
                    try:
                        tw[tw.__len__()-1] += [s]
                    except:
                        pass
                    y -= 1
                else:
                    y -= 1
                print(t[tmp:t.find("]",tmp)],tw)
            print("y",y)
    if tw[0] == True:
        for tn in tw:
            print("tn",tn,t1)
            if tn != True:
                cs = ""
                for i in t1[tn[0]-1:tn[2]]:
                    cs += str(i)
                    cs += "\n"
                print("cs",cs)
                print("递归后输出：")
                # txtx[home][t[2]] = load(cs)
                tmp114514  =  load(cs)
                print(tmp114514)
                txtx[home][tmp114514[1]] = tmp114514[0][tn[1]]#[[tmp114514[1]]]   #[tmp114514[1]]
    else:
        print("ELSE")
                
        
    # 返回
    return [txtx,home]

def loads(txtx):
    return load(txtx)[0]

def open(path,encoding = "utf-8"):
    with open(path,encoding = encoding) as f:
        return loads(f.read())

用法

import txtx