xinference 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

xinference/thirdparty/megatts3/tts/utils/commons/ckpt_utils.py

@@ -0,0 +1,171 @@
+# Copyright 2025 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import glob
+import os
+import re
+import subprocess
+import traceback
+
+import torch
+from torch.nn.parallel import DistributedDataParallel
+import torch.distributed as dist
+
+
+@contextlib.contextmanager
+def dist_load(path):
+    if not dist.is_initialized() or dist.get_world_size() == 1 or os.path.realpath(path).startswith('/dev/shm'):
+        yield path
+    else:
+        from tts.utils.commons.hparams import hparams
+        from tts.utils.commons.trainer import LOCAL_RANK
+        tmpdir = '/dev/shm'
+        assert len(os.path.basename(path)) > 0
+        shm_ckpt_path = f'{tmpdir}/{hparams["exp_name"]}/{os.path.basename(path)}'
+        if LOCAL_RANK == 0:
+            subprocess.check_call(
+                f'mkdir -p {os.path.dirname(shm_ckpt_path)}; '
+                f'cp -Lr {path} {shm_ckpt_path}', shell=True)
+        dist.barrier()
+        yield shm_ckpt_path
+        dist.barrier()
+        if LOCAL_RANK == 0:
+            subprocess.check_call(f'rm -rf {shm_ckpt_path}', shell=True)
+
+
+def torch_load_dist(path, map_location='cpu'):
+    with dist_load(path) as tmp_path:
+        checkpoint = torch.load(tmp_path, map_location=map_location)
+    return checkpoint
+
+
+def get_last_checkpoint(work_dir, steps=None):
+    checkpoint = None
+    last_ckpt_path = None
+    ckpt_paths = get_all_ckpts(work_dir, steps)
+    if len(ckpt_paths) > 0:
+        last_ckpt_path = ckpt_paths[0]
+        checkpoint = torch_load_dist(last_ckpt_path, map_location='cpu')
+    return checkpoint, last_ckpt_path
+
+
+def get_all_ckpts(work_dir, steps=None):
+    if steps is None or steps == 0:
+        ckpt_path_pattern = f'{work_dir}/model_ckpt_steps_*.ckpt'
+    else:
+        ckpt_path_pattern = f'{work_dir}/model_ckpt_steps_{steps}.ckpt'
+    return sorted(glob.glob(ckpt_path_pattern),
+                  key=lambda x: -int(re.findall('.*steps\_(\d+)\.ckpt', x)[0]))
+
+
+def load_ckpt(cur_model, ckpt_base_dir, model_name='model', force=True, strict=True,
+              silent=False, load_opt=False, opts=None, steps=None, checkpoint=None, ckpt_path='', delete_unmatch=True):
+    if checkpoint is None:
+        if os.path.isfile(ckpt_base_dir):
+            base_dir = os.path.dirname(ckpt_base_dir)
+            ckpt_path = ckpt_base_dir
+            checkpoint = torch_load_dist(ckpt_base_dir, map_location='cpu')
+        else:
+            base_dir = ckpt_base_dir
+            if load_opt:
+                checkpoint, ckpt_path = get_last_checkpoint(ckpt_base_dir, steps)
+            else:
+                ckpt_path = f'{ckpt_base_dir}/model_only_last.ckpt'
+                if os.path.exists(ckpt_path):
+                    checkpoint = torch_load_dist(ckpt_path, map_location='cpu')
+                else:
+                    checkpoint, ckpt_path = get_last_checkpoint(ckpt_base_dir, steps)
+    if checkpoint is not None:
+        state_dict_all = {
+            k.replace('module.', '').replace('_orig_mod.', ''): v for k, v in checkpoint["state_dict"].items()}
+        if not isinstance(cur_model, list):
+            cur_models = [cur_model]
+            model_names = [model_name]
+        else:
+            cur_models = cur_model
+            model_names = model_name
+        for model_name, cur_model in zip(model_names, cur_models):
+            if isinstance(cur_model, DistributedDataParallel):
+                cur_model = cur_model.module
+            device = next(cur_model.parameters()).device
+            if '.' not in model_name:
+                state_dict = state_dict_all[model_name]
+            else:
+                base_model_name = model_name.split('.')[0]
+                rest_model_name = model_name[len(base_model_name) + 1:]
+                state_dict = {
+                    k[len(rest_model_name) + 1:]: v for k, v in state_dict_all[base_model_name].items()
+                    if k.startswith(f'{rest_model_name}.')}
+            state_dict = {k.replace('module.', '').replace('_orig_mod.', ''): v for k, v in state_dict.items()}
+            if not strict and delete_unmatch:
+                try:
+                    cur_model.load_state_dict(state_dict, strict=True)
+                    if not silent:
+                        print(f"| loaded '{model_name}' from '{ckpt_path}' with strict=True.")
+                except:
+                    cur_model_state_dict = cur_model.state_dict()
+                    cur_model_state_dict = {k.replace('module.', '').replace('_orig_mod.', ''): v for k, v in
+                                            cur_model_state_dict.items()}
+                    unmatched_keys = []
+                    for key, param in state_dict.items():
+                        if key in cur_model_state_dict:
+                            new_param = cur_model_state_dict[key]
+                            if new_param.shape != param.shape:
+                                unmatched_keys.append(key)
+                                print("| Unmatched keys: ", key, "cur model: ", new_param.shape,
+                                        "ckpt model: ", param.shape)
+                    for key in unmatched_keys:
+                        del state_dict[key]
+            load_results = cur_model.load_state_dict(state_dict, strict=strict)
+            cur_model.to(device)
+            if not silent:
+                print(f"| loaded '{model_name}' from '{ckpt_path}'.")
+                missing_keys, unexpected_keys = load_results.missing_keys, load_results.unexpected_keys
+                print(f"| Missing keys: {len(missing_keys)}, Unexpected keys: {len(unexpected_keys)}")
+        if load_opt:
+            optimizer_states = checkpoint['optimizer_states']
+            assert len(opts) == len(optimizer_states)
+            for optimizer, opt_state in zip(opts, optimizer_states):
+                opt_state = {k.replace('_orig_mod.', ''): v for k, v in opt_state.items()}
+                if optimizer is None:
+                    return
+                try:
+                    optimizer.load_state_dict(opt_state)
+                    for i, state in enumerate(optimizer.state.values()):
+                        for k, v in state.items():
+                            if isinstance(v, torch.Tensor):
+                                state[k] = v.to(device)
+                except ValueError:
+                    print(f"| WARMING: optimizer {optimizer} parameters not match !!!")
+        return checkpoint.get('global_step', 0)
+    else:
+        e_msg = f"| ckpt not found in {base_dir}."
+        if force:
+            assert False, e_msg
+        else:
+            print(e_msg)
+
+
+def load_with_size_mismatch(model, state_dict, prefix=""):
+    current_model_dict = model.state_dict()
+    cm_keys = current_model_dict.keys()
+    mismatch_keys = {k.replace(prefix, "") for k, v in state_dict.items() if k.replace(prefix, "") in cm_keys and v.size() != current_model_dict[k.replace(prefix, "")].size()}
+    new_state_dict = {k.replace(prefix, ""): v for k, v in state_dict.items() if k.replace(prefix, "") in cm_keys and v.size() == current_model_dict[k.replace(prefix, "")].size()}
+    missing_keys, unexpected_keys = model.load_state_dict(new_state_dict, strict=False)
+    print(f"| mismatch keys: ", mismatch_keys)
+    if len(missing_keys) > 0:
+        print(f"| missing_keys in dit: {missing_keys}")
+    if len(unexpected_keys) > 0:
+        print(f"| unexpected_keys in dit: {unexpected_keys}")

xinference/thirdparty/megatts3/tts/utils/commons/hparams.py

@@ -0,0 +1,215 @@
+# Copyright 2025 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import json
+import os
+import re
+
+import yaml
+
+global_print_hparams = True
+hparams = {}
+
+
+class Args:
+    def __init__(self, **kwargs):
+        for k, v in kwargs.items():
+            self.__setattr__(k, v)
+
+
+def override_config(old_config: dict, new_config: dict):
+    if new_config.get('__replace', False):
+        old_config.clear()
+    for k, v in new_config.items():
+        if isinstance(v, dict) and k in old_config:
+            override_config(old_config[k], new_config[k])
+        else:
+            old_config[k] = v
+
+
+def traverse_dict(d, func, ctx):
+    for k in list(d.keys()):
+        v = d[k]
+        if isinstance(v, dict):
+            traverse_dict(v, func, ctx)
+        else:
+            d[k] = func(v, ctx)
+
+
+def parse_config(v, context=None):
+    if context is None:
+        context = {}
+
+    if isinstance(v, str):
+        if v.startswith('^'):
+            return load_config(v[1:], [], set())
+
+        match = re.match(r"\${(.*)}", v)
+        if match:
+            expression = match.group(1)
+            return eval(expression, {}, context)
+    return v
+
+
+def remove_meta_key(d):
+    for k in list(d.keys()):
+        v = d[k]
+        if isinstance(v, dict):
+            remove_meta_key(v)
+        else:
+            if k[:2] == '__':
+                del d[k]
+
+
+def load_config(config_fn, config_chains, loaded_configs):
+    # deep first inheritance and avoid the second visit of one node
+    if not os.path.exists(config_fn):
+        print(f"| WARN: {config_fn} not exist.", )
+        return {}
+    with open(config_fn) as f:
+        hparams_ = yaml.safe_load(f)
+    loaded_configs.add(config_fn)
+
+    if 'base_config' in hparams_:
+        ret_hparams = {}
+        if not isinstance(hparams_['base_config'], list):
+            hparams_['base_config'] = [hparams_['base_config']]
+        for c in hparams_['base_config']:
+            if c.startswith('.'):
+                c = f'{os.path.dirname(config_fn)}/{c}'
+                c = os.path.normpath(c)
+            if c not in loaded_configs:
+                override_config(ret_hparams, load_config(c, config_chains, loaded_configs))
+        override_config(ret_hparams, hparams_)
+    else:
+        ret_hparams = hparams_
+
+    config_chains.append(config_fn)
+    return ret_hparams
+
+
+def set_hparams(config='', exp_name='', hparams_str='', print_hparams=True, global_hparams=True):
+    if config == '' and exp_name == '':
+        parser = argparse.ArgumentParser(description='')
+        parser.add_argument('--config', type=str, default='',
+                            help='location of the data corpus')
+        parser.add_argument('--exp_name', type=str, default='', help='exp_name')
+        parser.add_argument('-hp', '--hparams', type=str, default='',
+                            help='location of the data corpus')
+        parser.add_argument('--infer', action='store_true', help='infer')
+        parser.add_argument('--validate', action='store_true', help='validate')
+        parser.add_argument('--reset', action='store_true', help='reset hparams')
+        parser.add_argument('--remove', action='store_true', help='remove old ckpt')
+        parser.add_argument('--debug', action='store_true', help='debug')
+        parser.add_argument('--start_rank', type=int, default=-1,
+                            help='the start rank id for DDP, keep 0 when single-machine multi-GPU')
+        parser.add_argument('--world_size', type=int, default=-1,
+                            help='the total number of GPU used across all machines, keep -1 for single-machine multi-GPU')
+        parser.add_argument('--init_method', type=str, default='tcp', help='method to init ddp, use tcp or file')
+        parser.add_argument('--master_addr', type=str, default='', help='')
+        parser.add_argument('--ddp_dir', type=str, default='', help='')
+
+        args, unknown = parser.parse_known_args()
+        if print_hparams:
+            print("| set_hparams Unknow hparams: ", unknown)
+    else:
+        args = Args(config=config, exp_name=exp_name, hparams=hparams_str,
+                    infer=False, validate=False, reset=False, debug=False, remove=False,
+                    start_rank=-1, world_size=-1, init_method='tcp', ddp_dir='', master_addr='')
+    global hparams
+    assert args.config != '' or args.exp_name != ''
+    if args.config != '':
+        assert os.path.exists(args.config), f"{args.config} not exists"
+
+    saved_hparams = {}
+    args_work_dir = ''
+    if args.exp_name != '':
+        args_work_dir = f'{args.exp_name}'
+        ckpt_config_path = f'{args_work_dir}/config.yaml'
+        if os.path.exists(ckpt_config_path):
+            with open(ckpt_config_path) as f:
+                saved_hparams_ = yaml.safe_load(f)
+                if saved_hparams_ is not None:
+                    saved_hparams.update(saved_hparams_)
+    hparams_ = {}
+    config_chains = []
+    if args.config != '':
+        hparams_.update(load_config(args.config, config_chains, set()))
+        if len(config_chains) > 1 and print_hparams:
+            print('| Hparams chains: ', config_chains)
+    if not args.reset:
+        hparams_.update(saved_hparams)
+    traverse_dict(hparams_, parse_config, hparams_)
+    hparams_['work_dir'] = args_work_dir
+
+    # Support config overriding in command line. Support list type config overriding.
+    # Examples: --hparams="a=1,b.c=2,d=[1 1 1]"
+    if args.hparams != "":
+        for new_hparam in args.hparams.split(","):
+            k, v = new_hparam.split("=")
+            v = v.strip("\'\" ")
+            config_node = hparams_
+            for k_ in k.split(".")[:-1]:
+                config_node = config_node[k_]
+            k = k.split(".")[-1]
+            if k in config_node:
+                if v in ['True', 'False'] or type(config_node[k]) in [bool, list, dict]:
+                    if type(config_node[k]) == list:
+                        v = v.replace(" ", ",").replace('^', "\"")
+                        if '|' in v:
+                            tp = type(config_node[k][0]) if len(config_node[k]) else str
+                            config_node[k] = [tp(x) for x in v.split("|") if x != '']
+                            continue
+                    config_node[k] = eval(v)
+                else:
+                    config_node[k] = type(config_node[k])(v)
+            else:
+                config_node[k] = v
+                try:
+                    config_node[k] = float(v)
+                except:
+                    pass
+                try:
+                    config_node[k] = int(v)
+                except:
+                    pass
+                if v.lower() in ['false', 'true']:
+                    config_node[k] = v.lower() == 'true'
+
+    if args_work_dir != '' and not args.infer:
+        os.makedirs(hparams_['work_dir'], exist_ok=True)
+
+    hparams_['infer'] = args.infer
+    hparams_['debug'] = args.debug
+    hparams_['validate'] = args.validate
+    hparams_['exp_name'] = args.exp_name
+
+    hparams_['start_rank'] = args.start_rank  # useful for multi-machine training
+    hparams_['world_size'] = args.world_size
+    hparams_['init_method'] = args.init_method
+    hparams_['ddp_dir'] = args.ddp_dir
+    hparams_['master_addr'] = args.master_addr
+
+    remove_meta_key(hparams_)
+    global global_print_hparams
+    if global_hparams:
+        hparams.clear()
+        hparams.update(hparams_)
+    if print_hparams and global_print_hparams and global_hparams:
+        print('| Hparams: ', json.dumps(hparams_, indent=2, sort_keys=True))
+        # for i, (k, v) in enumerate(sorted(hparams_.items())):
+        #     print(f"\033[;33;m{k}\033[0m: {v}, ", end="\n" if i % 5 == 4 else "")
+        global_print_hparams = False
+    return hparams_

xinference/thirdparty/megatts3/tts/utils/text_utils/dict.json

@@ -0,0 +1 @@
+{"phone": ["C0a", "C0ai", "C0air", "C0an", "C0ang", "C0angr", "C0anr", "C0ao", "C0aor", "C0ar", "C0b", "C0c", "C0ch", "C0d", "C0e", "C0ei", "C0eir", "C0en", "C0eng", "C0engr", "C0enr", "C0er", "C0f", "C0g", "C0h", "C0i", "C0ia", "C0ian", "C0iang", "C0iangr", "C0ianr", "C0iao", "C0iaor", "C0iar", "C0ie", "C0ier", "C0ii", "C0iii", "C0iiir", "C0iir", "C0in", "C0ing", "C0ingr", "C0inr", "C0io", "C0iong", "C0iongr", "C0iou", "C0iour", "C0ir", "C0j", "C0k", "C0l", "C0m", "C0n", "C0ng", "C0o", "C0ong", "C0ongr", "C0or", "C0ou", "C0our", "C0p", "C0q", "C0r", "C0s", "C0sh", "C0t", "C0u", "C0ua", "C0uai", "C0uair", "C0uan", "C0uang", "C0uangr", "C0uanr", "C0uar", "C0uei", "C0ueir", "C0uen", "C0ueng", "C0uengr", "C0uenr", "C0uo", "C0uor", "C0ur", "C0v", "C0van", "C0vanr", "C0ve", "C0ver", "C0vn", "C0vnr", "C0vr", "C0x", "C0z", "C0zh", "C0＿", "E0aa", "E0ae", "E0ah", "E0ao", "E0aw", "E0ax", "E0ay", "E0b", "E0ch", "E0d", "E0dh", "E0eh", "E0ehr", "E0er", "E0ey", "E0f", "E0g", "E0hh", "E0ih", "E0iy", "E0iyr", "E0jh", "E0k", "E0l", "E0m", "E0n", "E0ng", "E0oh", "E0ow", "E0oy", "E0p", "E0r", "E0s", "E0sh", "E0t", "E0th", "E0uh", "E0uw", "E0uwr", "E0v", "E0w", "E0y", "E0z", "E0zh", "sil", "…", "、", "。", "《", "》", "【", "】", "！", "＂", "＃", "＄", "％", "＇", "＇＇", "（", "）", "＊", "，", "：", "；", "？", "＼", "＾", "＿", "｀", "｛", "｝", "～"], "tone": ["0", "1", "10", "11", "12", "13", "15", "17", "2", "3", "4", "5", "6", "7", "8", "9"], "wordCategory": ["0", "B", "E", "M", "S"], "prosody": ["0", "1", "2", "3", "4"], "focus": ["0", "1"], "intonation": ["0", "1", "2"], "phraseAccent": ["0", "H-", "L-"], "boundaryTone": ["0", "H%", "L%"], "accentType": ["!H*", "0", "H*", "L*", "L*+H", "L+H*"]}

xinference/thirdparty/megatts3/tts/utils/text_utils/ph_tone_convert.py

@@ -0,0 +1,94 @@
+# Copyright 2025 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+import torch.nn.functional as F
+
+def map_phone_to_tokendict(item, pad_bos_eos=True):
+    # Merge Chinese phone and tone (Original dict ends at 173, i.e., ph_dict_size=173). 146~173 is punctuations.
+    phone = item['txt_token'].clone()
+    merged_phone = item['txt_token'].clone()
+    tone_tmp = item['tone'].clone()
+    # In tone_dict, tone_1 is 4, tone_2 is 11, tone_3 is 12, tone_4 is 13, tone_5 is 14, tone_6 is 15
+    tone_tmp[tone_tmp==4] = 1
+    tone_tmp[tone_tmp==11] = 2
+    tone_tmp[tone_tmp==12] = 3
+    tone_tmp[tone_tmp==13] = 4
+    tone_tmp[tone_tmp==14] = 5
+    tone_tmp[tone_tmp==15] = 6
+    # Chinese phones lie in 3~100 in the phone_dict, we map them to 200~788
+    ch_phone_idx = (phone >= 3) & (phone <= 100)
+    merged_phone[ch_phone_idx] = (merged_phone[ch_phone_idx] - 3) * 6 + 200 + tone_tmp[ch_phone_idx]
+
+    if pad_bos_eos:
+        merged_phone = F.pad(merged_phone, (1, 0), mode='constant', value=798)
+        merged_phone = F.pad(merged_phone, (0, 1), mode='constant', value=799)
+    return merged_phone
+    
+def split_ph_timestamp(ph_timestamp):
+    ''' Input: ph_timestamp, shape [T] '''
+
+    # Map the timestamp of each phone back to its original frame-level lengths
+    ph_timestamp[ph_timestamp >= 800] -= 800
+
+    ph_list = []
+    tone_list = []
+    dur_list = []
+    cur_timestamp = 0
+    for idx, item in enumerate(ph_timestamp):
+        if idx % 2 == 0:
+            # Map Chinese phones back to its original phone_dict
+            if (200 <= item <= 788):
+                ph = (item - 200 - 1) // 6 + 3
+                tone = (item - 200 - 1) % 6 + 1
+                if tone == 1:
+                    tone = 4
+                else:
+                    tone = tone + 9
+            # Set English tone to '3'
+            else:
+                ph = item
+                tone = 3
+            ph_list.append(ph)
+            tone_list.append(tone)
+        else:
+            dur_list.append((item - cur_timestamp))
+            cur_timestamp = item
+    assert len(ph_list) == len(dur_list), f"{len(ph_list)}, {len(dur_list)}"
+    ph_seq, tone_seq, dur_seq = torch.LongTensor(ph_list), torch.LongTensor(tone_list), torch.LongTensor(dur_list)
+    return ph_seq, tone_seq, dur_seq, ph_timestamp[-1]
+    
+def split_ph(ph_seq):
+    ''' Input: ph_timestamp, shape [T] '''
+    ph_list = []
+    tone_list = []
+    for idx, item in enumerate(ph_seq):
+        # Map Chinese phones back to its original phone_dict
+        if (200 <= item <= 788):
+            ph = (item - 200 - 1) // 6 + 3
+            tone = (item - 200 - 1) % 6 + 1
+            if tone == 1:
+                tone = 4
+            else:
+                tone = tone + 9
+        # Set English tone to '3'
+        else:
+            ph = item
+            tone = 3
+        ph_list.append(ph)
+        tone_list.append(tone)
+        
+    assert len(ph_list) == len(tone_list)
+    ph_seq, tone_seq = torch.LongTensor(ph_list), torch.LongTensor(tone_list)
+    return ph_seq, tone_seq

xinference/thirdparty/megatts3/tts/utils/text_utils/split_text.py

@@ -0,0 +1,90 @@
+# Copyright 2025 ByteDance and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+
+def chunk_text_chinese(text, limit=60):
+    # 中文字符匹配
+    chinese_pattern = re.compile(r'[\u4e00-\u9fff]')
+    # 标点符号匹配
+    punctuation = "，。！？；：,\.!?;"
+    
+    result = []  # 存储断句结果
+    current_chunk = []  # 当前片段
+    chinese_count = 0  # 中文字符计数
+
+    i = 0
+    while i < len(text):
+        char = text[i]
+        current_chunk.append(char)
+        if chinese_pattern.match(char):
+            chinese_count += 1
+        
+        if chinese_count >= limit:  # 达到限制字符数
+            # 从当前位置往前找最近的标点符号
+            for j in range(len(current_chunk) - 1, -1, -1):
+                if current_chunk[j] in punctuation:
+                    result.append(''.join(current_chunk[:j + 1]))
+                    current_chunk = current_chunk[j + 1:]
+                    chinese_count = sum(1 for c in current_chunk if chinese_pattern.match(c))
+                    break
+            else:
+                # 如果前面没有标点符号，则继续找后面的标点符号
+                for k in range(i + 1, len(text)):
+                    if text[k] in punctuation:
+                        result.append(''.join(current_chunk)+text[i+1:k+1])
+                        current_chunk = []
+                        chinese_count = 0
+                        i = k
+                        break
+        i+=1
+
+    # 添加最后剩余的部分
+    if current_chunk:
+        result.append(''.join(current_chunk))
+
+    return result
+
+def chunk_text_english(text, max_chars=130):
+    """
+    Splits the input text into chunks, each with a maximum number of characters.
+
+    Args:
+        text (str): The text to be split.
+        max_chars (int): The maximum number of characters per chunk.
+
+    Returns:
+        List[str]: A list of text chunks.
+    """
+    chunks = []
+    current_chunk = ""
+    # Split the text into sentences based on punctuation followed by whitespace
+    sentences = re.split(r"(?<=[;:,.!?])\s+|(?<=[；：，。！？])", text)
+
+    for sentence in sentences:
+        if len(current_chunk.encode("utf-8")) + len(sentence.encode("utf-8")) <= max_chars:
+            current_chunk += sentence + " " if sentence and len(sentence[-1].encode("utf-8")) == 1 else sentence
+        else:
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+            current_chunk = sentence + " " if sentence and len(sentence[-1].encode("utf-8")) == 1 else sentence
+
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+
+    return chunks
+
+if __name__ == '__main__':
+    print(chunk_text_chinese("哇塞！家人们，你们太好运了。我居然发现了一个宝藏零食大礼包，简直适合所有人的口味！有香辣的，让你舌尖跳舞；有盐焗的，咸香可口；还有五香的，香气四溢。就连怀孕的姐妹都吃得津津有味！整整三十包啊！什么手撕蟹柳、辣子鸡、嫩豆干、手撕素肉、鹌鹑蛋、小肉枣肠、猪肉腐、魔芋、魔芋丝等等，应有尽有。香辣土豆爽辣过瘾，各种素肉嚼劲十足，鹌鹑蛋营养美味，真的太多太多啦，...家人们，现在价格太划算了，赶紧下单。"))
+    print(chunk_text_english("Washington CNN When President Donald Trump declared in the House Chamber this week that executives at the nation’s top automakers were “so excited” about their prospects amid his new tariff regime, it did not entirely reflect the conversation he’d held with them earlier that day."))