cnbe32 1.0.0__py3-none-any.whl

cnbe32/__init__.py

@@ -0,0 +1,21 @@
+"""CNBE-32: Chinese Native Binary Encoding - Python SDK"""
+from .core import CNBE32, encode_cnbe, decode_cnbe, hamming_distance
+from .skill_table import SkillTable
+from .constants import (
+    RADIX_SHIFT, STROKE_SHIFT, STRUCT_SHIFT, INDEX_SHIFT, EXT_SHIFT,
+    RADIX_MASK, STROKE_MASK, STRUCT_MASK, INDEX_MASK, EXT_MASK,
+    STRUCT_NAMES, CNBE_STRUCT_MIN, CNBE_STRUCT_MAX,
+    CNBE_STROKE_MIN, CNBE_STROKE_MAX, CNBE_RADIX_MIN, CNBE_RADIX_MAX,
+    CNBE_EXT_FLAGS_MIN, CNBE_EXT_FLAGS_MAX, CNBE_SUB_TYPE_MIN, CNBE_SUB_TYPE_MAX,
+    CNBE_VALUE_MIN, CNBE_VALUE_MAX, CNBE_DEFAULT_ENCODING, CNBE_DEFAULT_DATA_DIR,
+    CJK_UNICODE_START, CJK_UNICODE_COUNT, SKILL_TABLE_FILE, RADIX_TABLE_FILE,
+)
+from .exceptions import (
+    CNBEError, CNBECodePointError, CNBEValueError,
+    CNBEFormatError, CNBECharNotInTableError, CNBEStructureError,
+)
+from .encoders import (
+    TreeEncoder, TyphoonEncoder, BlackHoleEncoder,
+    SocialEncoder, MathEncoder, RawEncoder, OneHotEncoder, RandomEncoder,
+)
+__version__ = "1.0.0"

cnbe32/constants.py

@@ -0,0 +1,43 @@
+"""CNBE-32 encoding constants and bitfield definitions"""
+
+# Bitfield shifts and widths
+RADIX_SHIFT, RADIX_BITS = 24, 8
+STROKE_SHIFT, STROKE_BITS = 19, 5
+STRUCT_SHIFT, STRUCT_BITS = 15, 4
+INDEX_SHIFT, INDEX_BITS = 4, 11
+EXT_SHIFT, EXT_BITS = 0, 4
+
+# Field boundaries
+CNBE_STRUCT_MIN, CNBE_STRUCT_MAX = 0, 15
+CNBE_STROKE_MIN, CNBE_STROKE_MAX = 0, 31
+CNBE_RADIX_MIN, CNBE_RADIX_MAX = 0, 255
+CNBE_EXT_FLAGS_MIN, CNBE_EXT_FLAGS_MAX = 0, 15
+CNBE_SUB_TYPE_MIN, CNBE_SUB_TYPE_MAX = 0, 15
+CNBE_VALUE_MIN, CNBE_VALUE_MAX = 0x00000000, 0xFFFFFFFF
+
+# Encoding masks (auto-calculated from bit widths)
+RADIX_MASK = (1 << RADIX_BITS) - 1
+STROKE_MASK = (1 << STROKE_BITS) - 1
+STRUCT_MASK = (1 << STRUCT_BITS) - 1
+INDEX_MASK = (1 << INDEX_BITS) - 1
+EXT_MASK = (1 << EXT_BITS) - 1
+
+# Default paths and encoding
+CNBE_DEFAULT_ENCODING = "utf-8"
+CNBE_DEFAULT_DATA_DIR = "data"
+
+# Structure type names
+STRUCT_NAMES = {
+    0: "single", 1: "left-right", 2: "left-mid-right", 3: "up-down",
+    4: "up-mid-down", 5: "top-left-wrap", 6: "top-right-wrap",
+    7: "bottom-left-wrap", 8: "top-wrap", 9: "bottom-wrap",
+    10: "left-wrap", 11: "full-wrap", 12: "triangle",
+}
+
+# CJK basic set
+CJK_UNICODE_START = 0x4E00
+CJK_UNICODE_COUNT = 20902
+
+# Default data files
+SKILL_TABLE_FILE = "skill_table.bin"
+RADIX_TABLE_FILE = "radix_table.csv"

cnbe32/core.py

@@ -0,0 +1,70 @@
+"""CNBE-32 core encoding/decoding — uses constants.py + typed exceptions"""
+import numpy as np
+import warnings
+
+from .constants import (
+    RADIX_SHIFT, STROKE_SHIFT, STRUCT_SHIFT, INDEX_SHIFT, EXT_SHIFT,
+    RADIX_MASK, STROKE_MASK, STRUCT_MASK, INDEX_MASK, EXT_MASK,
+    STRUCT_NAMES, CNBE_STRUCT_MIN, CNBE_STRUCT_MAX,
+    CNBE_STROKE_MIN, CNBE_STROKE_MAX, CNBE_RADIX_MIN, CNBE_RADIX_MAX,
+    CJK_UNICODE_START, CJK_UNICODE_COUNT,
+)
+from .exceptions import CNBEValueError, CNBEFormatError, CNBECharNotInTableError
+
+
+def encode_cnbe(radix=0, stroke=0, struct=0, index=0, ext=0):
+    """Encode CJK fields into 32-bit CNBE code with boundary validation"""
+    for (name, val, lo, hi) in [
+        ("radix", radix, CNBE_RADIX_MIN, CNBE_RADIX_MAX),
+        ("stroke", stroke, CNBE_STROKE_MIN, CNBE_STROKE_MAX),
+        ("struct", struct, CNBE_STRUCT_MIN, CNBE_STRUCT_MAX),
+    ]:
+        if not lo <= val <= hi:
+            raise CNBEValueError(f"{name}={val} is out of range [{lo}, {hi}]")
+    return ((radix & 0xFF) << RADIX_SHIFT) | \
+           ((stroke & 0x1F) << STROKE_SHIFT) | \
+           ((struct & 0xF) << STRUCT_SHIFT) | \
+           ((index & INDEX_MASK) << INDEX_SHIFT) | \
+           (ext & 0xF)
+
+
+def decode_cnbe(code):
+    """Decode 32-bit CNBE code into fields; raises CNBEFormatError on invalid code"""
+    if not 0 <= code <= 0xFFFFFFFF:
+        raise CNBEFormatError(f"code 0x{code:08X} is out of 32-bit range")
+    return {
+        "radix": (code >> RADIX_SHIFT) & 0xFF,
+        "stroke": (code >> STROKE_SHIFT) & 0x1F,
+        "structure": (code >> STRUCT_SHIFT) & 0xF,
+        "index": (code >> INDEX_SHIFT) & INDEX_MASK,
+        "extension": code & 0xF,
+        "struct_name": STRUCT_NAMES.get((code >> STRUCT_SHIFT) & 0xF, "unknown"),
+    }
+
+
+def hamming_distance(a, b):
+    """Weighted Hamming distance between two CNBE codes (radix*8 + stroke*5 + struct*4)"""
+    ra = (a >> RADIX_SHIFT) & 0xFF
+    rb = (b >> RADIX_SHIFT) & 0xFF
+    sa = (a >> STROKE_SHIFT) & 0x1F
+    sb = (b >> STROKE_SHIFT) & 0x1F
+    ta = (a >> STRUCT_SHIFT) & 0xF
+    tb = (b >> STRUCT_SHIFT) & 0xF
+    return abs(ra - rb) * 8 + abs(sa - sb) * 5 + abs(ta - tb) * 4
+
+
+class CNBE32:
+    """CNBE-32 encoding/decoding for Chinese characters (wraps constants + SkillTable)"""
+
+    def encode(self, char):
+        code_point = ord(char)
+        idx = code_point - CJK_UNICODE_START
+        if 0 <= idx < CJK_UNICODE_COUNT:
+            return getattr(self, "_table", np.zeros(CJK_UNICODE_COUNT, dtype=np.uint32))[idx]
+        raise CNBECharNotInTableError(char, code_point)
+
+    def decode(self, code):
+        return decode_cnbe(code)
+
+    def distance(self, a, b):
+        return hamming_distance(a, b)

cnbe32/encoders.py

@@ -0,0 +1,46 @@
+"""Domain-specific CNBE encoders from v9.0-v10.8 experiments"""
+import numpy as np
+
+class TreeEncoder:
+    """v9.0: Tree growth [species(4)+height(6)+crown(6)+health(4)+light(4)+water(4)+age(4)]"""
+    def encode(self, species, height, crown, health, light, water, age):
+        return (min(species,15)&0xF)<<28|(min(height,63)&0x3F)<<22|(min(crown,63)&0x3F)<<16|\
+               (min(health,15)&0xF)<<12|(min(light,15)&0xF)<<8|(min(water,15)&0xF)<<4|(min(age,15)&0xF)
+
+class TyphoonEncoder:
+    """v10.3: Typhoon path [lat(8)+lon(8)+wind(8)+pressure(8)]"""
+    def encode(self, lat, lon, wind, pressure):
+        return (int(lat/50*255)&0xFF)<<24|(int((lon-100)/80*255)&0xFF)<<16|(int(wind/85*255)&0xFF)<<8|(int((pressure-900)/120*255)&0xFF)
+
+class BlackHoleEncoder:
+    """v10.5: BH spacetime [r_Rs(8)+redshift(8)+tidal(8)+deflection(8)]"""
+    def encode(self, r_rs, redshift, tidal, deflection):
+        code = 0
+        code |= (min(int((r_rs - 1) / 99 * 255), 255) & 0xFF) << 24
+        code |= (min(redshift, 255) & 0xFF) << 16
+        code |= (min(tidal, 255) & 0xFF) << 8
+        code |= (min(deflection, 255) & 0xFF)
+        return code
+
+class SocialEncoder:
+    """v10.6: Urban state [traffic(8)+livelihood(6)+infra(6)+env(4)+emergency(3)+region(3)+time(2)]"""
+    def encode(self, traffic, livelihood, infra, env, emergency, region, time_slot):
+        return (min(traffic,255)&0xFF)<<24|(min(livelihood,63)&0x3F)<<18|(min(infra,63)&0x3F)<<12|\
+               (min(env,15)&0xF)<<8|(min(emergency,7)&0x7)<<5|(min(region,7)&0x7)<<2|(min(time_slot,3)&0x3)
+
+class MathEncoder:
+    """v10.7-10.8: Math token [type(4)+value(4)]"""
+    def encode(self, token_type, value):
+        return (token_type&0xF)<<28|(value&0xF)<<24
+
+class RawEncoder:
+    def encode(self, x): return x
+
+class OneHotEncoder:
+    def __init__(self, dim=20): self.dim=dim
+    def encode(self, x):
+        oh=np.zeros(self.dim); oh[x]=1.0; return oh
+
+class RandomEncoder:
+    def __init__(self, dim=32): self.dim=dim
+    def encode(self, x): return np.random.randn(self.dim)

cnbe32/exceptions.py

@@ -0,0 +1,24 @@
+"""CNBE-32 专用异常类体系"""
+
+class CNBEError(Exception):
+    """CNBE-32 基础异常类——所有 CNBE 异常的基类"""
+
+class CNBECodePointError(CNBEError):
+    """Unicode 码点映射失败"""
+
+class CNBEValueError(CNBEError, ValueError):
+    """数值超出有效位域范围"""
+
+class CNBEFormatError(CNBEError):
+    """编码格式错误（位布局异常）"""
+
+class CNBECharNotInTableError(CNBEError):
+    """字符不在 CNBE 编码表中"""
+    def __init__(self, char, code_point=None):
+        self.char = char
+        self.code_point = code_point
+        msg = f"字符 '{char}' (U+{code_point:04X}) 不在 CNBE 编码表中" if code_point else f"字符 '{char}' 不在 CNBE 编码表中"
+        super().__init__(msg)
+
+class CNBEStructureError(CNBEError):
+    """结构类型解析错误"""

cnbe32/skill_table.py

@@ -0,0 +1,24 @@
+"""Skill table loader (v6.0 8105-character CJK encoding)"""
+import numpy as np
+import os
+
+class SkillTable:
+    """81.6KB Skill table for 20902 CJK characters"""
+    def __init__(self, path=None):
+        self.table = np.zeros(20902, dtype=np.uint32)
+        if path and os.path.exists(path):
+            self.load(path)
+    def load(self, path):
+        if path.endswith(".npy"):
+            self.table = np.load(path)
+        elif path.endswith(".bin"):
+            self.table = np.frombuffer(open(path,"rb").read(), dtype=np.uint32)
+        print(f"Loaded SkillTable: {len(self.table)} chars")
+    def lookup(self, unicode):
+        if 0x4E00 <= unicode <= 0x9FA5:
+            idx = unicode - 0x4E00
+            if idx < len(self.table):
+                return self.table[idx]
+        return 0
+    def __getitem__(self, char):
+        return self.lookup(ord(char))

cnbe32-1.0.0.dist-info/METADATA

@@ -0,0 +1,592 @@
+Metadata-Version: 2.4
+Name: cnbe32
+Version: 1.0.0
+Summary: CNBE-32: Chinese Native Binary Encoding — Structured 32-bit CJK encoding for AI and hardware
+Author: zairkliu
+License: Mulan PSL v2
+Project-URL: Homepage, https://github.com/zairkliu/CNBE-32-Chinese-Native-Binary-Encoding
+Project-URL: Repository, https://github.com/zairkliu/CNBE-32-Chinese-Native-Binary-Encoding
+Project-URL: Bug Tracker, https://github.com/zairkliu/CNBE-32-Chinese-Native-Binary-Encoding/issues
+Keywords: chinese,encoding,cjk,riscv,nlp,structured-encoding
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Dynamic: license-file
+
+# CNBE-32
+
+**Chinese Native Binary Encoding**
+
+A 32-bit encoding that embeds the structural semantics of Chinese characters (radical, stroke count, and structure type) directly into binary, enabling CPUs and AI to natively understand Chinese.
+
+A structured 32-bit encoding for 97,686 CJK characters that embeds radical, stroke count, and structure type directly into the encoding space.
+
+<p align="center">
+  <a href="docs/specification/bit-layout.md"><img src="https://img.shields.io/badge/Encoding-32--bit%20CNBE-blue?style=for-the-badge" alt="Encoding"></a>
+  <a href="docs/specification/riscv-instructions.md"><img src="https://img.shields.io/badge/ISA-RISC--V%20Custom-green?style=for-the-badge" alt="ISA"></a>
+  <a href="v84_riscv_os_full/"><img src="https://img.shields.io/badge/OS-Full%20Chinese%20Shell-orange?style=for-the-badge" alt="OS"></a>
+  <a href="docs/VISION.md"><img src="https://img.shields.io/badge/Vision-2035%20Digital%20China-red?style=for-the-badge" alt="Vision"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-Mulan%20PSL%20v2-lightgrey?style=for-the-badge" alt="License"></a>
+</p>
+
+<p align="center">
+  <a href="#quick-start"><strong>[ Quick Start ]</strong></a>
+  <a href="#key-experiments"><strong>[ Key Experiments ]</strong></a>
+  <a href="#tech-stack"><strong>[ Tech Stack ]</strong></a>
+  <a href="#how-to-contribute"><strong>[ How to Contribute ]</strong></a>
+  <a href="README_ZH.md"><strong>[ 中文 ]</strong></a>  <a href="README_EN.md"><strong>[ English ]</strong></a>
+</p>
+
+---
+
+## <span id="architecture-panorama">Architecture Panorama</span>
+
+```mermaid
+graph TD
+    A[Chinese Character Input] -->|Radical/Stroke Count/Structure| B(CNBE-32 Encoder)
+    B -->|32-bit Binary| C{RISC-V Custom Instruction Set}
+    C -->|cnhe.map / cnhe.cmp| D[Hardware Layer: Spike/QEMU/FPGA]
+    D --> E[System Layer: Full Chinese Shell]
+    E --> F[Chinese BASIC / JEPA Semantic Engine]
+```
+
+---
+
+## <span id="vision--mission">Vision & Mission</span>
+
+Inspired by the **Digital China 2035** strategy, CNBE-32's goal is:
+
+> **To let every Chinese speaker seamlessly enter the AI era through their native language.**
+
+This is a mature system with a complete closed-loop, but as an early-stage exploration in the field of native Chinese computing, it remains in an open research phase. In the AI Agent era, the dreams of previous generations of scientists about full-Chinese computer systems finally have a chance to be realized.
+
+---
+
+## Table of Contents
+
+- [Architecture Panorama](#architecture-panorama)
+- [Vision & Mission](#vision--mission)
+- [Code Quick Look](#code-quick-look)
+- [Why CNBE?](#why-cnbe)
+- [JEPA Exploration](#jepa-exploration)
+- [Cognitive Equity](#cognitive-equity)
+- [Key Experiments](#key-experiments)
+- [Key Insights I](#key-insights-large-models-vs-small-models)
+- [Experimental Limitations & Future Directions](#experimental-limitations--future-directions)
+- [Tech Stack](#tech-stack)
+- [AI Agent Driven / AI Factory](#ai-agent-driven--ai-factory)
+- [Quick Start](#quick-start)
+- [Project Structure](#project-structure)
+- [Roadmap](#roadmap)
+- [How to Contribute](#how-to-contribute)
+- [Disclaimer](#disclaimer)
+- [License](#license)
+
+---
+
+## <span id="code-quick-look">Code Quick Look</span>
+
+**Core Idea: Transform Chinese characters into 32-bit integers containing radical, stroke count, and structure type — letting the machine "see" the glyph directly.**
+
+### CJK Character Mode (v6.0 Final)
+
+```
+Bit: 31              24 23    19 18    15 14              4  3     0
+     +----------------+--------+--------+------------------------+-------+
+     |  Radical (8bit)|Stroke(5)|Struct(4)|  Glyph Index (11bit)  | Ext(4)|
+     +----------------+--------+--------+------------------------+-------+
+```
+
+| Field | Bit Range | Description | Range |
+|-------|-----------|-------------|-------|
+| Radical | `[31:24]` | 214 Kangxi radicals + 41 extensions | 0-255 |
+| Stroke Count | `[23:19]` | Number of strokes | 1-31 |
+| Structure Type | `[18:15]` | Structural composition type | 9 types (single/left-right/top-bottom/enclosure, etc.) |
+| Glyph Index | `[14:4]` | Intra-group index | 20,902 basic CJK characters |
+| Extension | `[3:0]` | Traditional/Simplified, ancient/modern, dialect, reserved flags | Reserved |
+
+### Encoding Examples
+
+| Character | Unicode | CNBE-32 Encoding | Radical (ID) | Stroke Count | Structure Type |
+|-----------|---------|-----------------|--------------|--------------|----------------|
+| 一 (one) | U+4E00 | `0x01080000` | 一 (1) | 1 | Single (独体) |
+| 汉 (Chinese) | U+6C49 | `0x0F288101` | 氵 (water, 15) | 5 | Left-Right (左右) |
+| 国 (country) | U+56FD | `0x1F400B0B` | 囗 (enclosure, 31) | 8 | Full Enclosure (全包围) |
+| 明 (bright) | U+660E | `0x48400801` | 日 (sun, 72) | 8 | Left-Right (左右) |
+
+---
+
+## Important: This is Not Base32
+
+CNBE-32 is **not** a "Chinese-localized" or "character-replacement" version of Base32.
+
+| Dimension | Base32 | CNBE-32 |
+|-----------|--------|---------|
+| **Encoding target** | Arbitrary binary data | **97,686 CJK characters themselves** |
+| **Code space** | Fixed 32 letters | **Structured 32-bit bitfield** (radical, stroke, structure) |
+| **Goal** | Data compression / transmission | **Let machines "understand" character semantics** |
+| **Target audience** | Human-readable (transcription) | **AI models, CPU instruction sets, OS kernels** |
+
+**In one sentence**: Base32 turns data "into letters", CNBE-32 turns characters "into semantics".
+
+### Who is it for?
+
+- **AI models**: Structured prior knowledge input (radical=spatial anchor, stroke=discrete feature, structure=spatial relationship)
+- **CPU instruction sets**: `cnhe.map` / `cnhe.extract` / `cnhe.cmp` operate at the hardware level
+- **OS kernels**: Filenames, paths, system messages natively support CNBE-32 encoding
+- **Not recommended**: URL transmission, database primary keys, human transcription (use Base64/Base32)
+
+---
+
+## <span id="why-cnbe">Why CNBE?</span>
+
+| Dimension | Unicode / UTF-8 | CNBE-32 |
+|-----------|-----------------|---------|
+| Objective | Character display and exchange | AI understanding and hardware acceleration |
+| Encoding Method | Lookup table (Flat ID) | Semantic structuring |
+| Machine Cognition | Identifies the character | Understands structural composition |
+| AI Compatibility | Learns from data | Provides structural priors |
+
+**10 cross-domain validations passed (incl. LLM LoRA training)**: Linguistics, Ecology, Meteorology, Finance, Biology, Physics, Sociology, Pre-training, Mathematics
+
+---
+
+## <span id="jepa-exploration">JEPA Exploration</span>
+
+CNBE is not a patch for today's Transformers, but foundational infrastructure for tomorrow's JEPA.
+
+Yann LeCun's JEPA emphasizes prediction in representation space — and CNBE provides exactly the most structured representation space:
+
+- **Radical = Spatial Anchor**: Characters sharing the same radical naturally cluster in binary space
+- **Stroke Count = Discrete Feature**: Provides fine-grained morphological differentiation
+- **Structure = Spatial Relationship**: Left-right, top-bottom, enclosure, etc. directly map to topological relationships
+
+Completed JEPA validations: v9 tree structure prediction + v10 cross-9-domain generalization
+
+---
+
+## <span id="cognitive-equity">Cognitive Equity</span>
+
+The underlying logic of modern computers (from instruction sets to OS kernels) is built entirely on English/Latin alphabets. This creates a cognitive barrier for non-native English speakers who must first translate their thoughts before performing low-level development.
+
+The ultimate significance of CNBE-32 is to enable Chinese speakers to define underlying logic directly through their native linguistic thinking, breaking down professional vocabulary barriers and achieving true technological cognitive equity.
+
+> **In the AI era, every Chinese user — regardless of age, education level, or professional background — should be able to engage in deep dialogue with AI, define rules, and even write underlying logic using their native language.**
+
+### Core Performance Overview
+
+| Metric | Value | Equity Value Explanation |
+|--------|:-----:|-------------------------|
+| Small model (<1B) comprehension improvement | **+81%** (48%→87%) | Edge devices can achieve high-quality Chinese comprehension without cloud connectivity, breaking the compute monopoly of large tech companies |
+| Medium model (1-7B) improvement | +9% ~ +17% | Mid-range mobile chips can smoothly run complex Chinese tasks without relying on high-end GPUs |
+| Large model (>7B) benefit | ~0% (diminishing returns) | Validates that large models don't need this encoding; resources should be prioritized for small-to-medium intelligence scenarios |
+| Hardware lookup extreme latency | 0.8 ns (x86) / 1 Cycle (FPGA) | Ultra-fast response for real-time interaction; suitable for low-frequency, low-power embedded chips |
+| Minimal memory footprint | Only 81.6 KB (SRAM/BRAM) | Fits easily into any L1/L2 cache or on-chip storage without external DRAM, reducing BOM cost |
+| Encoding semantic density | 32 bits containing radical/stroke/structure | Single encoding equivalent to dozens of text annotation tokens, greatly reducing learning and inference overhead for small models |
+| CJK coverage breadth | **97,686** characters | Covers ancient texts, rare names, and dialect characters, ensuring cultural diversity isn't marginalized in the AI era |
+| Hard-task rare character handling | **+17.4 pp** (vs Unicode) | Dominates traditional encoding in traditional/variant/chemical equation scenarios, ensuring professional knowledge equity |
+| Lookup collision rate | **0%** (full coverage verified) | Zero-ambiguity lookup, ensuring stability and reliability on edge devices |
+
+---
+
+## <span id="key-experiments">Key Experiments</span>
+
+### Small Model, Big Improvement (v2)
+
+**Hypothesis**: Structured encoding compensates for insufficient small model parameters.
+**Method**: Qwen 3.5 0.8B, CNBE vs standard input.
+
+| Input | Accuracy | Improvement |
+|-------|----------|-------------|
+| Standard input | 48% | -- |
+| **CNBE-32** | **87%** | **+81%** |
+
+### CNBE Surpasses Unicode (v6.5.2)
+
+**Hypothesis**: Structured bit fields carry more semantic information than Unicode code points.
+**Method**: Gemma 4B Chinese hard tasks.
+
+| Input | Accuracy |
+|-------|----------|
+| Unicode | 26.1% |
+| **CNBE-32** | **43.5%** |
+
+**Conclusion**: A brand-new encoding without prior training outperforms the 30-year standard on first attempt (+17.4 pp).
+
+### Full Chinese Operating System (v8.4)
+
+- Full Chinese Shell (output/get encoding/compare commands)
+- Chinese BASIC interpreter (7 keywords)
+- Text editor (built-in Tao Te Ching, 205 lines)
+- RISC-V custom instructions: `cnhe.map` / `cnhe.extract` / `cnhe.cmp`
+
+### Mathematical Reasoning Foundation (v10.8)
+
+**Method**: TinyGPT on odd/even/prime/sequence reasoning tasks comparing 4 encodings.
+
+| Task | CNBE Loss | OneHot Loss | Winner |
+|------|-----------|-------------|--------|
+| Odd/Even | 0.3174 | 0.3427 | **CNBE** |
+| Prime | 0.3894 | 0.5061 | **CNBE** |
+| Sequence | 1.0726 | 1.2344 | **CNBE** |
+
+---
+
+### Complete Experimental Data (v1~v10)
+
+<details>
+<summary><b>Click to expand v1~v10 core experiment overview</b></summary>
+
+| Version | Validation Dimension | Model / Platform | Core Metric | Key Conclusion |
+| :---: | :--- | :--- | :--- | :--- |
+| **v1** | Zero-shot single character understanding | Qwen 0.8B | 200 characters, **100%** effective | Encoding is inherently semantically interpretable |
+| **v2** | Small model sentence understanding | Qwen 0.8B | 48% **→ 87%** (**+81%**) | Structured encoding provides significant compensation for small models |
+| **v3** | Annotation format optimization | Qwen 0.8B | Character-by-character full annotation **87%** effective | Optimal format: character-by-character full annotation |
+| **v4** | Long text (paper-level) | Qwen 0.8B | 90.9% **→ 100%** | Effective in long-text scenarios, eliminates ambiguity |
+| **v5** | Multi-model horizontal comparison | 7 models | <1B: +81%; 1-7B: +9~17%; >7B: ~0% | **Diminishing marginal returns** |
+| **v6** | Unicode hard task comparison | Gemma 4B | Unicode 26.1% **vs** **CNBE 43.5%** | **CNBE > Unicode** (+17.4 pp) |
+| **v7** | RISC-V hardware implementation | C / QEMU / Spike / FPGA | x86 0.8 ns → FPGA **1 Cycle** | Complete hardware path closed-loop |
+| **v8** | Full Chinese operating system | RISC-V QEMU | Chinese Shell + BASIC + Tao Te Ching editor | Encoding can seamlessly integrate into OS underlying layer |
+| **v9** | JEPA tree structure prediction | JEPA architecture | Error **0.0899 → 0.000001** | Extremely strong high-noise temporal feature extraction |
+| **v10** | Cross-9-domain generalization | Multi-domain | Mathematics wins; typhoon error **−19%** | Effective across mathematics/physics/biology/finance and other domains |
+
+</details>
+
+<details>
+<summary><b>Click to expand v1~v10 detailed experimental data</b></summary>
+
+| Version | Sub-item / Task | Test Environment | Specific Data Metrics | Conclusion / Notes |
+| :---: | :--- | :--- | :--- | :--- |
+| **v1** | Single character radical/stroke/structure extraction | Qwen 0.8B | 200 Chinese characters, **100%** zero-shot effective | Proves encoding space IS semantic space |
+| **v2** | Chinese sentence understanding | Qwen 0.8B | Text input 48% → CNBE **87%** | Accuracy improvement 39 pp |
+| **v3** | Encoding format ablation experiment | Qwen 0.8B | Character-by-character 87% > segmented 60% > compact 50% | Optimal: `中(丨,4 strokes, single)` |
+| **v4** | Paper-level semantic understanding | Qwen 0.8B | 90.9% → **100%** | Complements small model long-context reasoning shortcomings |
+| **v5a-5.9** | 7-model horizontal comparison | 0.8B~20B | Domestic 2B **90%**; 8B+ approaches 0 | Less compute power = more important structural priors |
+| **v6.3-6.5** | Numerical format optimization | Qwen 0.8B | **Format F (bare numbers)** optimal | Hardware recommends bare number input |
+| **v6.5.2** | CNBE vs Unicode | Gemma 4B | Unicode 26.1% **vs** CNBE **43.5%** | Outperforms thirty-year industry standard on first attempt |
+| **v7.0** | C language benchmark | x86-64 | Single lookup **0.8 ns** | Software performance baseline established |
+| **v7.0.1** | RISC-V cross-compilation | QEMU | Single lookup 2.5 ns | Validates RISC-V portability |
+| **v7.1.1** | Instruction integration | Spike | `map`(2 cycles) / `extract`(1) / `cmp`(3) | Three Custom-0 instruction behaviors verified |
+| **v7.2** | FPGA logic synthesis | Verilog+BRAM | **Single cycle** lookup complete | 81.6 KB table entries fit BRAM resources |
+| **v8.4** | Full Chinese system | RISC-V QEMU | Shell commands + BASIC 7 keywords + Tao Te Ching | "Full Chinese computing" feasibility validated |
+| **v9.0** | Tree growth JEPA | JEPA | CNBE **86%** better than Raw | Structured encoding improves abstract representation |
+| **v9.1** | Typhoon lifecycle | JEPA | 0.089981 → **0.000001** | Error reduced by 4 orders of magnitude |
+| **v10.3** | Typhoon Bavi path | Meteorological model | 216 km → **174 km** | Actual path prediction accuracy improved 19% |
+| **v10.4** | Protein Q3 structure | Bioinformatics | OH 44.6% vs CNBE 41.0% | Slightly below OH; biological sequence still has optimization room |
+| **v10.5** | Black hole gravitational field | Physics simulation | R² **0.60-0.77** | Good performance in physics field simulation |
+| **v10.7** | TinyGPT frozen embedding | TinyGPT | Learned 1.3653 vs CNBE 1.4568 | Frozen embedding performance close to learned embedding |
+| **v10.8** | Mathematical reasoning foundation | TinyGPT | Odd/Even(0.3174<0.3427) Prime(0.3894<0.5061) Sequence(1.07<1.23) | Universally better than One-Hot |
+| **LLM** | CNBE knowledge LoRA fine-tuning | Qwen3.5-0.8B | 5000 steps, loss **0.6424**, 500-steps 0.7524 | Knowledge injection feasible, edge deployment validated |
+
+
+</details>
+
+### Complete Evidence Chain Logic Closure
+
+| Stage | Corresponding Version | Logical Role |
+| :--- | :--- | :--- |
+| **Semantic Validity** | v1 ~ v4 | Prove encoding itself contains semantics |
+| **Comparative Superiority** | v5 ~ v6 | Prove encoding outperforms Unicode |
+| **Hardware Implementability** | v7 | Prove from software to FPGA is feasible |
+| **System-level Compatibility** | v8 | Prove encoding can support complete OS ecosystem |
+| **Cross-domain Generalization** | v9 ~ v10 | Prove equally effective in physics/biology/finance and other domains |
+
+Complete experimental data → [docs/EXPERIMENTS.md](docs/EXPERIMENTS.md)
+
+---
+
+<details>
+<summary><b>Click to expand v1-v10.8 complete experiment data</b></summary>
+
+### Table 1: CNBE-32 Core Experiment Overview (v1~v10)
+
+| Version | Dimension | Model / Platform | Key Metric | Key Conclusion |
+| :---: | :--- | :--- | :--- | :--- |
+| **v1** | Zero-shot char understanding | Qwen 0.8B | 200 chars, **100%** effective | Encoding inherently semantically interpretable |
+| **v2** | Small model sentence understanding | Qwen 0.8B | 48% **→ 87%** (**+81%**) | Structured encoding compensates small models significantly |
+| **v3** | Annotation format optimization | Qwen 0.8B | Full char annotation **87%** effective | Optimal format: per-character annotation |
+| **v4** | Long text (paper-level) | Qwen 0.8B | 90.9% **→ 100%** | Effective in long-context scenarios |
+| **v5** | Multi-model comparison | 7 models | <1B: +81%; 1-7B: +9~17%; >7B: ~0% | **Diminishing returns law** |
+| **v6** | Unicode hard task comparison | Gemma 4B | Unicode 26.1% **vs** **CNBE 43.5%** | **CNBE > Unicode** (+17.4pp) |
+| **v7** | RISC-V hardware implementation | C/QEMU/Spike/FPGA | x86 0.8ns → FPGA **1 Cycle** | Complete hardware path closed-loop |
+| **v8** | Full Chinese OS | RISC-V QEMU | Chinese Shell + BASIC + Dao De Jing | Encoding integrates seamlessly into OS |
+| **v9** | JEPA tree structure prediction | JEPA architecture | Error **0.0899 → 0.000001** | Powerful feature extraction for noisy data |
+| **v10** | Cross 9-domain generalization | Multi-domain models | Math wins, typhoon error **-19%** | Effective in math/physics/biology/finance |
+
+---
+
+### Table 2: Detailed Experiment Data (v1~v10)
+
+| Version | Sub-task | Environment | Specific Metric | Conclusion |
+| :---: | :--- | :--- | :--- | :--- |
+| **v1** | Char radical/stroke/structure extraction | Qwen 0.8B | 200 chars, **100%** zero-shot | Encoding space = semantic space |
+| **v2** | Chinese sentence understanding | Qwen 0.8B | Text 48% → CNBE **87%** | +39pp absolute improvement |
+| **v3** | Encoding format ablation | Qwen 0.8B | Per-char 87% > segment 60% > compact 50% | Optimal: full per-char annotation |
+| **v4** | Paper-level semantic understanding | Qwen 0.8B | 90.9% → **100%** | Fills small model long-context gap |
+| **v6.5.2** | CNBE vs Unicode | Gemma 4B | Unicode 26.1% **vs** CNBE **43.5%** | Surpassed 30-year standard first try |
+| **v7.1.1** | Custom instruction integration | Spike | map(2 cycles)/extract(1)/cmp(3) | Three Custom-0 instructions verified |
+| **v7.2** | FPGA logic synthesis | Verilog+BRAM | **Single cycle** lookup | 81.6KB table fits BRAM |
+| **v8.4** | Full Chinese system | RISC-V QEMU | Shell + BASIC 7 keywords + Dao De Jing | Chinese computing feasibility proven |
+| **v9.0** | Tree growth JEPA | JEPA | CNBE **86%** better than Raw | Structured encoding boosts abstraction |
+| **v9.1** | Typhoon lifecycle JEPA | JEPA | 0.089981 → **0.000001** | Error reduced 4 orders of magnitude |
+| **v10.3** | Typhoon Barijat path | Meteorological model | 216 km → **174 km** | Path prediction accuracy +19% |
+| **v10.4** | Protein Q3 structure | Bioinformatics | OH 44.6% vs CNBE 41.0% | Slightly below OH, room for improvement |
+| **v10.5** | Black hole gravity simulation | Physics simulation | R² **0.60-0.77** | Physical field simulation performs well |
+| **v10.7** | TinyGPT frozen embedding | TinyGPT | Learned 1.3653 vs CNBE 1.4568 | Close to learned as frozen embedding |
+| **v10.8** | Math reasoning base | TinyGPT | Parity/Prime/Seq CNBE wins all | Comprehensive win over One-Hot |
+
+---
+
+### Table 3: Evidence Chain Logic Closure
+
+| Phase | Version | Role |
+| :--- | :--- | :--- |
+| **Semantic validity** | v1~v4 | Proves encoding contains semantics |
+| **Comparative superiority** | v5~v6 | Proves encoding > Unicode |
+| **Hardware feasibility** | v7 | Proves software-to-FPGA path |
+| **System-level compatibility** | v8 | Proves encoding supports full OS ecosystem |
+| **Cross-domain generalization** | v9~v10 | Proves effective across multiple domains |
+</details>
+
+Full experiment data → [docs/EXPERIMENTS.md](docs/EXPERIMENTS.md)
+
+---
+
+## <span id="key-insights-large-models-vs-small-models">Key Insights: Large Models vs Small Models</span>
+
+Why do 8B+ large models show diminishing returns (~0%) from CNBE, while 0.8B small models achieve massive +81% improvement?
+
+- **Large Model Brute Force Aesthetics**: Massive parameters can implicitly memorize Unicode through brute-force training, masking the structural flaws of the encoding
+- **Small Model Structural Priors**: On compute-constrained edge devices, CNBE transforms glyph structure directly into computational priors
+
+This is the breakthrough path for edge-side AI processing of Chinese.
+
+
+> ## Key Insights III: CNBE Encoding Knowledge LoRA Fine-Tuning
+>
+> — Injecting CNBE-32 encoding knowledge into Qwen3.5-0.8B via LoRA
+>
+> - **LoRA knowledge injection works**: 500 steps (22 min) + 5000 steps (4.14 h) with 25K diverse Chat Template data, loss from 0.7524 → **0.6424** (↓14.6%), augmentation artifacts eliminated
+> - **Model understands encoding concepts**: After fine-tuning, the model recognizes character radicals, stroke counts, and structure types, outputting CNBE-32 encoded information
+> - **Minimal GPU requirements**: RTX 4060 Ti (8GB) handles the entire pipeline, with peak memory usage of only 1.5GB
+> - **Edge deployment validated**: For the first time, CNBE-32 advances from inference-level semantic validation to training-level knowledge injection
+> - **Complete cross-domain chain**: From linguistics to finance to physics to biology to LLM training, CNBE's structured encoding is validated across encoding, hardware, OS, cross-domain prediction, and model fine-tuning
+>
+> Full methodology → [cnbe-llm training(demo)/](./cnbe-llm%20training(demo)/)
+
+
+---
+
+## <span id="experimental-limitations--future-directions">Experimental Limitations & Future Directions</span>
+
+> **We have faithfully documented failures and limitations in all experiments. The following are known boundaries disclosed directly in this README.**
+
+### Known Limitations
+
+| Experiment | Limitation | Future Direction |
+|------------|------------|------------------|
+| v5/v6 (LLM validation) | Some models (DeepSeek 8B / GPT-OSS 20B) showed empty responses or insufficient Chinese capability | Focus on Chinese-friendly small models like Qwen/Gemma |
+| v6.5.3 (Hard task 0.8B) | Overall only 12.5%, CNBE and Unicode showed no difference | 0.8B model capability boundary; requires larger model validation |
+| v9.0 (Tree growth) | Simulated environment, not real climate/economic data | Validate on real temporal data |
+| v10.0/v10.1 (Financial backtesting) | A-share high-frequency trading costs (0.14%/trade) consumed all strategy returns; break-even point not reached | Pivot to low-frequency strategies (daily/weekly) to unlock predictive value |
+| v10.4 (Protein) | Used simplified single-residue method, not standard sliding window; first contact with 30-year domain standard gap of 3.6 pp | Sliding window + CB513 dataset complete experiment |
+| v10.5 (Black hole) | Single-variable input scenario (only r/Rs), continuous value KNN naturally precise; CNBE quantization introduces error | Multi-dimensional input scenario (with observation noise) validation |
+| v10.6 (Sociology) | **CNBE inferior to One-hot in strong classification feature scenarios** (MSE 0.0124 vs OneHot 0.0019) | Field weighting, hierarchical encoding optimization |
+| v10.7 (Pre-training) | Task too simple (13 token vocabulary), difference not statistically significant | Large-scale corpus, larger model validation |
+
+### Applicability Boundaries (Based on All Experimental Data)
+
+| Scenario Type | CNBE Performance | Typical Domains | Reason |
+|---------------|:----------------:|-----------------|--------|
+| Multi-dimensional continuous value + structured temporal | ✅ Significantly better than baseline | Meteorology, ecology, finance, mathematics | Bit-field structured encoding naturally matches |
+| Strong classification features | ❌ Inferior to One-hot | Sociology (8 regions + 4 time periods) | Bit-field mixed encoding cannot distinguish classification field weights |
+| Single-variable deterministic systems | ⚠️ Equal to Raw | Physics (gravitational field) | Continuous value single-variable scenario Raw is optimal |
+| Zero-shot unfamiliar domains | ⚠️ Close to domain standard | Biology (protein) | First attempt approaches 30-year optimized standard |
+| Pattern recognition tasks | ✅ Universally better than One-hot | Mathematical reasoning | Structured encoding matches pattern recognition |
+
+---
+
+## <span id="tech-stack">Tech Stack</span>
+
+```
+Application Layer: Chinese BASIC interpreter + Text Editor + Tao Te Ching
+System Layer: Full Chinese Shell + CNBE Runtime (map/extract/cmp)
+Hardware Layer: RISC-V 1GHz + 1GB RAM (QEMU + Spike)
+Instruction Layer: cnhe.map / cnhe.extract / cnhe.cmp
+Encoding Layer: 32-bit CJK Structured Bit Fields (Radical/Stroke/Structure)
+```
+
+---
+
+## <span id="ai-agent-driven--ai-factory">AI Agent Driven / AI Factory</span>
+
+This is a project that was previously impossible to complete, but is destined to be born in the AI era.
+
+| Past | Present |
+|------|---------|
+| 97,686 Chinese character annotations required thousands of linguist man-years | AI Agent assisted automated annotation |
+| Full-stack validation required top-tier teams for years | LLM-assisted code generation + validation |
+| Single-team siloed development | Open source community collaborative exploration |
+
+The dreams of scientists from the last century finally have a chance to be realized in the AI Agent era.
+
+---
+
+## <span id="quick-start">Quick Start</span>
+
+### Environment Requirements
+- Python 3.8+
+- numpy, torch, scikit-learn (for experiment reproduction)
+
+### Install Python SDK
+
+```bash
+pip install numpy torch scikit-learn
+```
+
+### Usage Example
+
+```python
+import sys; sys.path.insert(0, 'src')
+from cnbe32 import encode_cnbe, hamming_distance
+
+code_ming = encode_cnbe(72, 8, 1)   # 明 (bright) = 日(sun, 72) + 8 strokes + left-right structure
+code_an  = encode_cnbe(72, 9, 1)   # 暗 (dark) = 日(sun, 72) + 9 strokes + left-right structure
+print(hamming_distance(code_ming, code_an))
+```
+
+### Run RISC-V Simulator
+
+```bash
+cd hardware/simulator
+gcc -o cnhe_sim cnhe_sim.c -Wall -O2 && ./cnhe_sim
+```
+
+### Launch Full Chinese Operating System (QEMU)
+
+```bash
+# Ubuntu dependencies
+sudo apt-get install -y gcc-riscv64-linux-gnu qemu-system-misc
+
+cd v84_riscv_os_full
+make all && make run
+```
+
+### Reproduce Experiments
+
+```bash
+cd v10_8_math_reasoning && python run_v108.py
+cd v10_3_typhoon && python v10_3_typhoon.py
+```
+
+---
+
+## Application Scenarios
+
+CNBE-32 is designed for **AI-era Chinese computing infrastructure**, not as a general-purpose encoding tool.
+
+| Scenario | Suitability | Description |
+|----------|:-----------:|-------------|
+| AI model structured input | **Recommended** | Provides radical/stroke/structure priors, improves small model comprehension |
+| RISC-V hardware acceleration | **Recommended** | Custom instructions operate directly on encoding bitfields |
+| Chinese-native OS | **Recommended** | Native support for filenames, paths, system messages |
+| Chinese compiler/BASIC | **Recommended** | Direct encoding operations at the language level |
+| Data compression/obfuscation | Not recommended | Semantic encoding, not compression |
+| URL transmission | Not recommended | Characters broken by %-encoding in URLs |
+| Human transcription | Not recommended | Visually similar characters cause errors |
+| Database primary keys | Use with caution | 32-bit integers are storable but CNBE is not a unique identifier |
+
+---
+
+## <span id="project-structure">Project Structure</span>
+
+```
+CNBE-32-Chinese-Native-Binary-Encoding/
+|-- docs/specification/      # Encoding specification
+|-- docs/EXPERIMENTS.md      # Experiment overview
+|-- docs/VISION.md           # Strategic vision
+|-- src/cnbe32/              # Python SDK
+|-- include/cnbe32.h         # C header file
+|-- data/                    # Encoding database
+|-- tests/                   # Test suite
+|-- tools/                   # Development tools
+|-- bindings/rust/           # Rust bindings
+|-- hardware/                # RISC-V simulator
+|-- v9_jepa_tree/            # JEPA experiments (v9)
+|-- v10_5~v10_8/             # Cross-domain experiments (v10)
+|-- v84_riscv_os_full/       # Chinese OS prototype
+|-- results/                 # White papers (41 documents)
+|-- LICENSE                  # Mulan License
+```
+
+---
+
+## <span id="roadmap">Roadmap</span>
+
+| Phase | Status | Content |
+|-------|--------|---------|
+| Encoding & semantic validation | Completed | v1-v6 CJK encoding design |
+| Hardware & system | Completed | v7-v8 RISC-V + Chinese OS |
+| Complex prediction validation | Completed | v9-v10 9-domain validation |
+| AI compiler | Planned | Chinese natural language → machine code |
+| Edge AI integration | Planned | Edge AI default standard |
+| Ecosystem collaboration | Vision | Open source community + industry standards |
+
+---
+
+## <span id="how-to-contribute">How to Contribute</span>
+
+### Current Directions Most Needing Community Support
+
+- Chinese BASIC interpreter optimization - improve lexical analyzer
+- RISC-V lookup logic acceleration - optimize 81.6 KB L2 Cache hit rate
+- JEPA architecture extension experiments - more physics/biology system tests
+- Frontend visualization tools - Web interface showing encoding decomposition process
+
+| Level | Direction |
+|-------|-----------|
+| Low barrier | Encoding dictionary / Test cases / Documentation |
+| High barrier | RISC-V pipeline / FPGA / LLM adaptation / Compiler |
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details
+
+---
+
+## <span id="disclaimer">Disclaimer</span>
+
+v10.x stage financial time series (US stocks / A-shares) backtesting is solely for validating CNBE-32's feature extraction and structured prior capabilities in high-noise, non-stationary time series data, and does not constitute any investment advice.
+
+---
+
+## <span id="license">License</span>
+
+**Mulan Permissive Software License v2 (Mulan PSL v2)**
+
+[![License](https://img.shields.io/badge/License-MulanPSL2-blue.svg)](http://license.coscl.org.cn/MulanPSL2)
+
+---
+
+**Let Chinese speakers enter the AI era through their native language.**
+
+From the "Digital China 2035" vision to AI Agent era engineering practice.
+
+**Born for Chinese AI ecosystem — from encoding to hardware, from single character to operating system.**
+
+[GitHub](https://github.com/zairkliu/CNBE-32-Chinese-Native-Binary-Encoding)
+
+
+
+
+

cnbe32-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+cnbe32/__init__.py,sha256=LM957vCqrET0xRXh5Wr4TvZNewIZCTJvd8TRuBXwOZc,1030
+cnbe32/constants.py,sha256=OlzrRBSDEwNSp9EYnSSQ48LlwT3CmURGIy8u6l70qh4,1355
+cnbe32/core.py,sha256=uF-6Qb2tmRvIFpyYvWr1BF4hsE9ZKkaD7gbepsoadyg,2772
+cnbe32/encoders.py,sha256=JIN9U0GmPvMpyl3HjM_ST-zLeWCsjmZFWDd7MEvvwYA,2083
+cnbe32/exceptions.py,sha256=TqkP8rTMc4NfbKF6Jrw9geWftTz1kaiZ42Or-IMjcEk,817
+cnbe32/skill_table.py,sha256=ZT4Bw5NJBQdfRs4-REE6FTupODUOGQGWpygQW0eogFs,892
+cnbe32-1.0.0.dist-info/licenses/LICENSE,sha256=t4RvFoJlvXXzkj4C-51QcuYkC6xKMOX-W5x8oewPkO0,11487
+cnbe32-1.0.0.dist-info/METADATA,sha256=HVI2t7wqdRzoN2b1-4rkxpFSseFfgDOZsdi2yS0LkQE,33019
+cnbe32-1.0.0.dist-info/WHEEL,sha256=YLJXdYXQ2FQ0Uqn2J-6iEIC-3iOey8lH3xCtvFLkd8Q,91
+cnbe32-1.0.0.dist-info/top_level.txt,sha256=LZGD_30mG5X9xF71cjKnfWT7pUfoVhch5kZdh9cgooM,7
+cnbe32-1.0.0.dist-info/RECORD,,

cnbe32-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (81.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cnbe32-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,149 @@
+木兰宽松许可证, 第2版
+
+木兰宽松许可证，第2版
+
+2020年1月 http://license.coscl.org.cn/MulanPSL2
+
+您对“软件”的复制、使用、修改及分发受木兰宽松许可证，第2版（MulanPSL v2）的约束。如果您不满足本许可证的任何条件，您无权对“软件”进行复制、使用、修改及分发。
+
+1.  定义
+
+“贡献” 是指由“贡献者”许可在“软件”中的受版权法保护的作品，包括最初由“贡献者”许可在“软件”中的作品及后续“贡献者”许可在“软件”中的作品。
+
+“贡献者” 是指将受版权法保护的作品许可在“软件”中的自然人或“法人实体”。
+
+“法人实体” 是指提交贡献的机构及其“关联实体”。
+
+“关联实体” 是指控制、受控制或共同受控制的机构，此处的控制是指拥有该机构百分之五十（50%）或更多的有表决权的股份、证券或其他有投票权的所有权利益，或者是拥有该机构百分之五十（50%）或更多的利润权益或资本权益。
+
+“软件” 是指“贡献者”许可在“本许可证”下的受版权法保护的作品，包括计算机软件及文档。
+
+“您” 是指行使“本许可证”授予的权利的自然人或“法人实体”。
+
+“相应源代码” 是指生成、安装和（对于可执行作品）运行“软件”目标代码所需的全部源代码，包括与目标代码链接的任何接口定义文件，以及控制这些活动所需的脚本。但是，“相应源代码”不包括“系统库”或一般不为“软件”目标代码部分所需且不作为“软件”常规操作部分使用的工具或程序。
+
+“系统库” 是指包含在“软件”中或用于与“软件”链接的作品，但不是“软件”本身的衍生作品，且其目的是：
+
+(a) 以不违反“本许可证”限制的方式，与主要组件一起进行编译或链接，而主要组件是运行该作品的操作系统、编译器或启动器；或
+
+(b) 用于与“软件”链接的应用程序接口库或工具。
+
+2.  授予版权许可
+
+每个“贡献者”根据“本许可证”授予“您”永久的、全球性的、免费的、非独占的、不可撤销的版权许可，以复制、使用、修改、分发其“贡献”，不论修改与否。
+
+3.  授予专利许可
+
+每个“贡献者”根据“本许可证”授予“您”永久的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销的除外）专利许可，供“您”制作、让其制作、使用、销售、许诺销售、进口或以其他方式转让其“贡献”或“软件”。如果“您”或您的“关联实体”直接或间接地对任何机构就“软件”提起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，则该“贡献者”依据“本许可证”授予“您”的专利许可自“您”提起该诉讼或行动之日起终止。前述专利维权行动是指就“软件”或“贡献”中的任何技术主张专利侵权。
+
+4.  无商标许可
+
+“本许可证”不提供针对“贡献者”或第三方的任何名称、商标、服务标记或产品标识的许可，不论明示或默示。
+
+5.  分发限制
+
+您可以在任何媒介中将“软件”以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供“本许可证”的副本，并保留“软件”中的版权、商标、专利及免责声明。
+
+6.  免责声明与责任限制
+
+“软件”及其中的“贡献”在提供时不带任何明示或默示的担保。在任何情况下，“贡献者”或版权所有者不对任何人因使用“软件”或其中的“贡献”而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。
+
+7.  语言
+
+“本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。
+
+条款结束
+
+如何将木兰宽松许可证，第2版应用到您的软件
+
+如果您希望将木兰宽松许可证，第2版应用到您的软件，为了方便接收者识别，建议您完成如下三步：
+
+1. 请将如下声明文本放入每个源文件（包括脚本等）的头部注释中：
+
+   Copyright (c) [Year] [Name of copyright holder]
+   [Software Name] is licensed under Mulan PSL v2.
+   You can use this software according to the terms and conditions of the Mulan PSL v2.
+   You may obtain a copy of Mulan PSL v2 at:
+       http://license.coscl.org.cn/MulanPSL2
+   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+   EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+   MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+   See the Mulan PSL v2 for more details.
+
+2. 请将“木兰宽松许可证，第2版”的完整文本放入软件中的 LICENSE 或 COPYING 文件中。
+
+3. 请将“木兰宽松许可证，第2版”的声明文本放入软件的 NOTICE 文件中，如果软件中没有 NOTICE 文件，则将其放入 README 文件中。
+
+Mulan Permissive Software License，Version 2
+
+Mulan Permissive Software License，Version 2 (Mulan PSL v2)
+
+January 2020 http://license.coscl.org.cn/MulanPSL2
+
+Your reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following conditions.
+
+1.  Definitions
+
+"Contribution" means the copyrightable work licensed by a particular Contributor in the Software.
+
+"Contributor" means the Individual or Legal Entity who licenses its copyrightable work under this License.
+
+"Legal Entity" means the entity making a Contribution and all its Affiliates.
+
+"Affiliates" means entities that control, are controlled by, or are under common control with the acting entity under this License, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"Software" means the copyrightable work licensed under this License.
+
+"You" means an Individual or Legal Entity exercising permissions granted by this License.
+
+"Corresponding Source Code" means all of the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.
+
+"System Libraries" means anything that is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component" means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.
+
+2.  Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.
+
+3.  Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer its Contribution or the Software. If You or Your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a lawsuit) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to You under this License for the Software shall terminate as of the date such litigation or activity is filed or taken. "Patent litigation or enforcement activities" means any lawsuit or other action alleging that the Software or any Contribution in it infringes any patent.
+
+4.  No Trademark License
+
+No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributors or third parties, except as required to comply with the terms of this License.
+
+5.  Distribution Restriction
+
+You may distribute the Software in any medium with or without modification, whether in source or executable form, provided that You provide recipients a copy of this License and retain copyright, patent, trademark, and disclaimer statements in the Software.
+
+6.  Disclaimer of Warranty and Limitation of Liability
+
+THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT'S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7.  Language
+
+THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
+
+END OF THE TERMS AND CONDITIONS
+
+How to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software
+
+To apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
+
+1.  Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;
+
+    Copyright (c) [Year] [Name of copyright holder]
+    [Software Name] is licensed under Mulan PSL v2.
+    You can use this software according to the terms and conditions of the Mulan PSL v2.
+    You may obtain a copy of Mulan PSL v2 at:
+        http://license.coscl.org.cn/MulanPSL2
+    THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+    EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+    MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+    See the Mulan PSL v2 for more details.
+
+2.  Create a LICENSE and a COPYING file in the top-level directory of your software and copy the Mulan PSL v2 into it.
+
+3.  Create a NOTICE file in the top-level directory of your software and copy the following statement into it. If there is no top-level NOTICE file in your software, you can copy the statement into a README file or any other file containing the top-level license statement.
+
+    Licensed under the Mulan PSL v2.

cnbe32-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cnbe32