GIT 修正2

Git_controller/Git_Ctrl.py → Git_controller/GitController.py

@@ -13,46 +13,46 @@ sys_seeting = dict(
     stderr=subprocess.STDOUT,
     universal_newlines=True)
 git_path = 'git'  # git的地址，如果配置了环境变量则不需要修改
-stopKey = '【操作完成】'  # 存储stopKey的global变量
+stop_key = '【操作完成】'  # 存储stopKey的global变量
 passwd = '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'  # stopKey的候选词库
 
 
-class git_Repo:  # git的基类
-    def __init__(self, Dic, *args, **kwargs):
+class GitRepo:  # git的基类
+    def __init__(self, repo_dir, *args, **kwargs):
         self.url = None
         try:
-            if exists(Dic + r'/.git'):  # 是否为git 仓库
+            if exists(repo_dir + r'/.git'):  # 是否为git 仓库
                 pass
-            elif Dic[-4:] == '.git':
-                Dic = Dic[:-5]  # -5,得把/去掉
+            elif repo_dir[-4:] == '.git':
+                repo_dir = repo_dir[:-5]  # -5,得把/去掉
             else:
                 raise Exception
         except BaseException:
             subprocess.Popen(
                 f'{git_path} init',
-                cwd=self.Repo_Dic,
+                cwd=self.repo_dir,
                 **sys_seeting).wait()
-        self.Repo_Dic = Dic  # 仓库地址(末尾不带/)
-        self.repo = Repo(Dic)
-        self.name = split(Dic)[-1]
+        self.repo_dir = repo_dir  # 仓库地址(末尾不带/)
+        self.repo = Repo(repo_dir)  # 读取一个仓库
+        self.name = split(repo_dir)[-1]
         self.have_clone = True
 
-    def make_stopKey(self):  # 生成一个随机stopKey
-        global stopKey, passwd
+    def make_stop_key(self):  # 生成一个随机stopKey
+        global stop_key, passwd
         code = ''
         for _ in range(8):  # 八位随机数
             code += passwd[random.randint(0, len(passwd) - 1)]  # 时间戳+8位随机数
-        stopKey = (str(time()) + code).replace('.', '')
-        return stopKey
+        stop_key = (str(time()) + code).replace('.', '')
+        return stop_key
 
-    def Flie_List(self, file_list, is_file=True, pat=' '):
+    def get_flie_list(self, file_list, is_file=True, pat=' '):
         if file_list == '.':
             file = '..'
         else:
             file_ = []
             for i in file_list:
-                if i[:len(self.Repo_Dic)] == self.Repo_Dic:
-                    file_.append(i[len(self.Repo_Dic) + 1:])  # +1是为了去除/
+                if i[:len(self.repo_dir)] == self.repo_dir:
+                    file_.append(i[len(self.repo_dir) + 1:])  # +1是为了去除/
             if not is_file:
                 return file_
             file = pat.join(file_)
@@ -64,36 +64,36 @@ class git_Repo:  # git的基类
             listfile += [
                 f'[当前分支] {self.repo.active_branch} 工作区{"不" if self.repo.is_dirty() else ""}干净 -> {self.name}']
         listfile += [f'{"[配置文件]" if i == ".git" else "[未跟踪]"if i in self.repo.untracked_files else "[已跟踪]"} {i}'
-                     for i in os.listdir(self.Repo_Dic)]
+                     for i in os.listdir(self.repo_dir)]
         return listfile
 
-    def Add_File(self, file_list):
-        file = self.Flie_List(file_list)
+    def add(self, file_list):
+        file = self.get_flie_list(file_list)
         return subprocess.Popen(
-            f'echo 添加文件... && {git_path} add {file} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 添加文件... && {git_path} add {file} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Reset_File(self, file_list):
-        file = self.Flie_List(file_list)
+    def del_cached_file(self, file_list):
+        file = self.get_flie_list(file_list)
         return subprocess.Popen(
-            f'echo 撤销文件... && {git_path} rm --cached {file} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 撤销文件... && {git_path} rm --cached {file} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Commit_File(self, m):
+    def commit_file(self, m):
         return subprocess.Popen(
-            f'echo 提交文件: && {git_path} commit -m "{m}" && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 提交文件: && {git_path} commit -m "{m}" && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Status(self):  # 执行status
+    def status(self):  # 执行status
         return subprocess.Popen(
-            f'echo 仓库状态: && {git_path} status && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 仓库状态: && {git_path} status && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Log(self, graph, pretty, abbrev):  # 执行log
+    def log(self, graph, pretty, abbrev):  # 执行log
         args = ''
         if graph:
             args += ' --graph'
@@ -102,20 +102,20 @@ class git_Repo:  # git的基类
         if abbrev:
             args += ' --abbrev-commit'
         return subprocess.Popen(
-            f'echo 仓库日志: && {git_path} log{args} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 仓库日志: && {git_path} log{args} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def refLog(self):  # 执行reflog
+    def do_log(self):  # 执行reflog
         return subprocess.Popen(
-            f'echo 操作记录: && {git_path} reflog && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 操作记录: && {git_path} reflog && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Diff_File(self, MASTER='HEAD'):  # 执行diff
+    def diff(self, MASTER='HEAD'):  # 执行diff
         return subprocess.Popen(
-            f'echo 文件日志: && {git_path} diff {MASTER} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 文件日志: && {git_path} diff {MASTER} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
     def reset(self, HEAD='HEAD~1', Type=0):
@@ -126,137 +126,137 @@ class git_Repo:  # git的基类
         else:
             type_ = '--hard'  # 退回到暂存区
         return subprocess.Popen(
-            f'echo 回退... && {git_path} reset {type_} {HEAD} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 回退... && {git_path} reset {type_} {HEAD} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
     def checkout(self, file_list):
         if len(file_list) >= 1:  # 多于一个文件，不用--，空格
-            file = self.Flie_List(file_list, pat=' ')
+            file = self.get_flie_list(file_list, pat=' ')
             return subprocess.Popen(
-                f'echo 丢弃修改: && {git_path} checkout {file} && echo {self.make_stopKey()}',
-                cwd=self.Repo_Dic,
+                f'echo 丢弃修改: && {git_path} checkout {file} && echo {self.make_stop_key()}',
+                cwd=self.repo_dir,
                 **sys_seeting)
         elif len(file_list) == 1:
             return subprocess.Popen(
-                f'echo 丢弃修改: && {git_path} checkout -- {file_list[0]} && echo {self.make_stopKey()}',
-                cwd=self.Repo_Dic,
+                f'echo 丢弃修改: && {git_path} checkout -- {file_list[0]} && echo {self.make_stop_key()}',
+                cwd=self.repo_dir,
                 **sys_seeting)
         else:
             return subprocess.Popen(
-                f'echo 丢弃修改: && {git_path} checkout * && echo {self.make_stopKey()}',
-                cwd=self.Repo_Dic,
+                f'echo 丢弃修改: && {git_path} checkout * && echo {self.make_stop_key()}',
+                cwd=self.repo_dir,
                 **sys_seeting)
 
     def rm(self, file_list):  # 删除版本库中的文件
-        file = self.Flie_List(file_list)
+        file = self.get_flie_list(file_list)
         return subprocess.Popen(
             f'echo 删除... && {git_path} rm {file}',
-            cwd=self.Repo_Dic,
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def check_Branch(self):  # 查看本地分支和远程分支
+    def branch_view(self):  # 查看本地分支和远程分支
         return subprocess.Popen(
             f'echo 仓库分支: && {git_path} branch -a && echo 远程仓库信息: && {git_path} remote -v && '
-            f'echo 分支详情: && {git_path} branch -vv && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 分支详情: && {git_path} branch -vv && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def new_Branch(self, branch_name, origin):  # 新建分支
+    def new_branch(self, branch_name, origin):  # 新建分支
         return subprocess.Popen(
-            f'echo 新建分支... && {git_path} branch {branch_name} {origin} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 新建分支... && {git_path} branch {branch_name} {origin} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def switch_Branch(self, branch_name):  # 切换分支
+    def switch_branch(self, branch_name):  # 切换分支
         return subprocess.Popen(
-            f'echo 切换分支... && {git_path} switch {branch_name} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 切换分支... && {git_path} switch {branch_name} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def del_Branch(self, branch_name, del_type):  # 删除分支
+    def del_branch(self, branch_name, del_type):  # 删除分支
         return subprocess.Popen(
-            f'echo 删除分支... && {git_path} branch -{del_type} {branch_name} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 删除分支... && {git_path} branch -{del_type} {branch_name} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def merge_Branch(self, branch_name, no_ff, m=''):  # 合并分支
+    def merge_branch(self, branch_name, no_ff, m=''):  # 合并分支
         if no_ff:
             no_ff = f' --no-ff -m "{m}"'  # --no-ff前有空格
         else:
             no_ff = ''
         return subprocess.Popen(
-            f'echo 合并分支... && {git_path} merge{no_ff} {branch_name} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 合并分支... && {git_path} merge{no_ff} {branch_name} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
     def merge_abort(self):  # 退出冲突处理
         return subprocess.Popen(
-            f'echo 冲突处理退出... && {git_path} merge --abort && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 冲突处理退出... && {git_path} merge --abort && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Save_stash(self):  # 保存工作区
+    def save_stash(self):  # 保存工作区
         return subprocess.Popen(
-            f'echo 保存工作区... && {git_path} stash && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 保存工作区... && {git_path} stash && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Stash_List(self):  # 工作区列表
+    def get_stash_list(self):  # 工作区列表
         return subprocess.Popen(
-            f'echo 工作区列表: && {git_path} stash list && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 工作区列表: && {git_path} stash list && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Apply_stash(self, stash_num='0'):  # 恢复工作区
+    def apply_stash(self, stash_num='0'):  # 恢复工作区
         return subprocess.Popen(
-            f'echo 恢复工作区... && {git_path} stash apply stash@{{{stash_num}}} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 恢复工作区... && {git_path} stash apply stash@{{{stash_num}}} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Drop_stash(self, stash_num='0'):  # 删除工作区
+    def drop_stash(self, stash_num='0'):  # 删除工作区
         return subprocess.Popen(
-            f'echo 删除工作区... && {git_path} stash drop stash@{{{stash_num}}} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 删除工作区... && {git_path} stash drop stash@{{{stash_num}}} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
     def cherry_pick(self, commit):  # 补丁
         return subprocess.Popen(
-            f'echo 补丁... && {git_path} cherry-pick {commit} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 补丁... && {git_path} cherry-pick {commit} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Del_remote(self, remote_name):
+    def del_remote(self, remote_name):
         return subprocess.Popen(
-            f'echo 删除远程仓库... && {git_path} remote remove {remote_name} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 删除远程仓库... && {git_path} remote remove {remote_name} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Add_remote(self, remote, remote_name):
+    def remote_add(self, remote, remote_name):
         return subprocess.Popen(
-            f'echo 添加远程仓库... && {git_path} remote add {remote_name} {remote} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 添加远程仓库... && {git_path} remote add {remote_name} {remote} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Bind_remote(self, local_name, remote_name):
+    def bind_branch(self, local_name, remote_name):
         return subprocess.Popen(
-            f'echo 分支绑定... && {git_path} branch --set-upstream-to={remote_name} {local_name} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 分支绑定... && {git_path} branch --set-upstream-to={remote_name} {local_name} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def push_Tag(self, tag, remote_name):
+    def push_tag(self, tag, remote_name):
         return subprocess.Popen(
-            f'echo 推送标签... && {git_path} push {remote_name} {tag} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 推送标签... && {git_path} push {remote_name} {tag} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
     def del_tag(self, tag):
         return subprocess.Popen(
-            f'echo 删除本地标签... && {git_path} tag -d {tag} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 删除本地标签... && {git_path} tag -d {tag} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Add_Tag(self, tag, commit, message=''):
+    def add_tag(self, tag, commit, message=''):
         a = ' -a'
         if message != '':
             message = f' -m "{message}"'  # 自带空格
@@ -265,27 +265,27 @@ class git_Repo:  # git的基类
         if commit != '':
             commit = f' {commit}'  # 自带空格
         return subprocess.Popen(
-            f'echo 添加标签... && {git_path} tag{a} {tag}{commit}{message} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 添加标签... && {git_path} tag{a} {tag}{commit}{message} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Tag(self, condition=''):
+    def get_tag_list(self, condition=''):
         if condition != '':
             condition = f' -l {condition}'
         return subprocess.Popen(
-            f'echo 标签列表: && {git_path} tag{condition} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 标签列表: && {git_path} tag{condition} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def show_new(self, condition):
+    def search_commit(self, condition):
         return subprocess.Popen(
-            f'echo 查询结果: && {git_path} show {condition} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 查询结果: && {git_path} show {condition} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Pull_Push_remote(
+    def pull_push(
         self,
-        Pull_Push=0,
+        pull_or_push=0,
         remote='',
         remote_branch='',
         local='',
@@ -313,7 +313,7 @@ class git_Repo:  # git的基类
         if remote_name == '':  # 4)
             branch = ''
         else:
-            if Pull_Push == 1:
+            if pull_or_push == 1:
                 # 注意，local不可以为空，也不会为空
                 if remote_branch != '':
                     # git push <远程主机名> <本地分支名>:<远程分支名>
@@ -335,14 +335,15 @@ class git_Repo:  # git的基类
             0: "pull",
             1: f"push{' -u' if u else ''}{' -f' if f else ''}"}
         return subprocess.Popen(
-            f'''echo 与服务器连接... && {git_path} {push_pull.get(Pull_Push,"pull")}{history} {remote_name} {branch} && echo {self.make_stopKey()}''',
-            cwd=self.Repo_Dic,
+            f'''echo 与服务器连接... && {git_path} {push_pull.get(pull_or_push, "pull")}{history} {remote_name} {branch} 
+&& echo {self.make_stop_key()}''',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def del_Branch_remote(self, remote, remote_branch):
-        split = remote.split('/')
+    def del_branch_remote(self, remote, remote_branch):
+        remote_split = remote.split('/')
         try:
-            remote_name = split[0]  # 获取主机名 1）
+            remote_name = remote_split[0]  # 获取主机名 1）
         except BaseException:
             remote_name = ''  # 没有主机名 1）
         branch_split = remote_branch.split('/')
@@ -350,14 +351,14 @@ class git_Repo:  # git的基类
             remote_name = branch_split[0]  # 2)
             remote_branch = '/'.join(branch_split[1:])  # 2)
         return subprocess.Popen(
-            f'echo 删除远程分支... && {git_path} push {remote_name} :{remote_branch} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 删除远程分支... && {git_path} push {remote_name} :{remote_branch} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def del_Tag_remote(self, remote, tag):
+    def del_tag_remote(self, remote, tag):
         return subprocess.Popen(
-            f'echo 删除远程标签... && {git_path} push {remote} :refs/tags/{tag} && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 删除远程标签... && {git_path} push {remote} :refs/tags/{tag} && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
     def fetch(self, remote, remote_branch, local):
@@ -389,49 +390,49 @@ class git_Repo:  # git的基类
                 branch = f'{remote_branch}'
 
         return subprocess.Popen(
-            f'''echo 更新远程仓库... && {git_path} fetch {remote_name} {branch} && echo {self.make_stopKey()}''',
-            cwd=self.Repo_Dic,
+            f'''echo 更新远程仓库... && {git_path} fetch {remote_name} {branch} && echo {self.make_stop_key()}''',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def Customize(self, command: str):
-        return subprocess.Popen(command, cwd=self.Repo_Dic, **sys_seeting)
+    def customize_command(self, command: str):
+        return subprocess.Popen(f'{command} && echo {self.make_stop_key()}', cwd=self.repo_dir, **sys_seeting)
 
-    def Clone(self, url):
+    def clone(self, url):
         return subprocess.Popen(
-            f'echo 克隆操作不被允许 && echo {self.make_stopKey()}',
-            cwd=self.Repo_Dic,
+            f'echo 克隆操作不被允许 && echo {self.make_stop_key()}',
+            cwd=self.repo_dir,
             **sys_seeting)
 
-    def make_Dir(self, dir):
+    def make_dir(self, dir):
         if len(dir) == '':
             return dir
         inside = '/'
         if dir[0] == '/':
             inside = ''
-        return self.Repo_Dic + inside + dir
+        return self.repo_dir + inside + dir
 
-    def reset_File(self, hard, file_list):  # 注意版本回退是:Reset_File
-        file = self.Flie_List(file_list)
+    def reset_file(self, hard, file_list):  # 注意版本回退是:Reset_File
+        file = self.get_flie_list(file_list)
         return subprocess.Popen(
-            f'''echo 回退文件... && {git_path} reset {hard} {file} && echo {self.make_stopKey()}''',
-            cwd=self.Repo_Dic, **sys_seeting)
+            f'''echo 回退文件... && {git_path} reset {hard} {file} && echo {self.make_stop_key()}''',
+            cwd=self.repo_dir, **sys_seeting)
 
-    def Branch_new(self, old_name, new_name):
+    def rename_branch(self, old_name, new_name):
         return subprocess.Popen(
-            f'''echo 回退文件... && {git_path} branch -m {old_name} {new_name} && echo {self.make_stopKey()}''',
-            cwd=self.Repo_Dic, **sys_seeting)
+            f'''echo 回退文件... && {git_path} branch -m {old_name} {new_name} && echo {self.make_stop_key()}''',
+            cwd=self.repo_dir, **sys_seeting)
 
 
-class Clone_git(git_Repo):  # Clone一个git
+class CloneGit(GitRepo):  # Clone一个git
     def __init__(self, Dic, *args, **kwargs):
         self.Repo_Dic = Dic  # 仓库地址
         self.url = None
         self.name = split(Dic)[-1]
         self.have_clone = False
 
-    def Clone(self, url):
+    def clone(self, url):
         if self.have_clone:
-            super(Clone_git, self).Clone(url)
+            super(CloneGit, self).clone(url)
         self.have_clone = True
         return subprocess.Popen(
             f'echo 正在克隆... && {git_path} clone {url} {self.Repo_Dic}',
@@ -439,62 +440,62 @@ class Clone_git(git_Repo):  # Clone一个git
                 self.Repo_Dic)[0],
             **sys_seeting)
 
-    def after_Clone(self):
+    def after_clone(self):
         self.repo = Repo(self.Repo_Dic)
 
 
 class git_Ctrol:
     def __init__(self):
-        self.git_Dic = {}  # 名字-文件位置
-        self.gitType_Dic = {}  # 名字-类型
+        self.git_dict = {}  # 名字-文件位置
+        self.git_type_dict = {}  # 名字-类型
 
-    def Add_init(self, Dic, **kwargs):
-        git = git_Repo(Dic)
-        self.git_Dic[git.name] = git
-        self.gitType_Dic[git.name] = 'init'
+    def open_repo(self, repo_dir, **kwargs):
+        git = GitRepo(repo_dir)
+        self.git_dict[git.name] = git
+        self.git_type_dict[git.name] = 'init'
         return git.name
 
-    def Clone_init(self, Dic, **kwargs):
-        git = Clone_git(Dic)
-        self.git_Dic[git.name] = git
-        self.gitType_Dic[git.name] = 'clone'
+    def clone_repo(self, repo_dir, **kwargs):
+        git = CloneGit(repo_dir)
+        self.git_dict[git.name] = git
+        self.git_type_dict[git.name] = 'clone'
         return git.name
 
     def get_git(self, name):
-        return self.git_Dic[name]
+        return self.git_dict[name]
 
-    def get_git_Dic(self):
-        return self.git_Dic.copy()
+    def get_git_dict(self):
+        return self.git_dict.copy()
 
-    def get_Dir(self, name):
+    def get_dir(self, name):
         return self.get_git(name).dir_list()
 
-    def add_File(self, name, dic_list):
-        return self.get_git(name).Add_File(dic_list)
+    def add_file(self, name, file_list):
+        return self.get_git(name).add(file_list)
 
-    def reset_File(self, name, dic_list):
-        return self.get_git(name).Reset_File(dic_list)  # 移除出去暂存区
+    def del_cached_file(self, name, file_list):
+        return self.get_git(name).del_cached_file(file_list)  # 移除出去暂存区
 
-    def commit_File(self, name, m):
-        return self.get_git(name).Commit_File(m)
+    def commit_file(self, name, message):
+        return self.get_git(name).commit_file(message)
 
     def log(self, name, graph, pretty, abbrev):
-        return self.get_git(name).Log(graph, pretty, abbrev)
+        return self.get_git(name).log(graph, pretty, abbrev)
 
-    def reflog(self, name):
-        return self.get_git(name).refLog()
+    def do_log(self, name):
+        return self.get_git(name).do_log()
 
     def status(self, name):
-        return self.get_git(name).Status()
+        return self.get_git(name).status()
 
-    def diff_File(self, name, MASTER):
-        return self.get_git(name).diff(MASTER)
+    def diff_file(self, name, brach):
+        return self.get_git(name).diff(brach)
 
-    def back_version(self, name, HEAD, Type=0):
-        return self.get_git(name).reset(HEAD, Type)  # 版本回退HEAD
+    def back_version(self, name, head, reset_type=0):
+        return self.get_git(name).reset(head, reset_type)  # 版本回退HEAD
 
-    def back_version_file(self, name, HEAD, File_list):
-        return self.get_git(name).reset_File(HEAD, File_list)  # 文件回退
+    def back_version_file(self, name, head, file_list):
+        return self.get_git(name).reset_file(head, file_list)  # 文件回退
 
     def checkout_version(self, name, file):
         return self.get_git(name).checkout(file)  # 弹出
@@ -502,115 +503,99 @@ class git_Ctrol:
     def rm(self, name, file):
         return self.get_git(name).rm(file)
 
-    def check_Branch(self, name):
-        return self.get_git(name).check_Branch()
+    def branch_view(self, name):
+        return self.get_git(name).branch_view()
 
-    def new_Branch(self, name, new_branch, origin):
-        return self.get_git(name).new_Branch(new_branch, origin)
+    def new_branch(self, name, new_branch, origin):
+        return self.get_git(name).new_branch(new_branch, origin)
 
-    def switch_Branch(self, name, branch_name):
-        return self.get_git(name).switch_Branch(branch_name)
+    def switch_branch(self, name, branch_name):
+        return self.get_git(name).switch_branch(branch_name)
 
-    def Del_Branch(self, name, branch_name, type_):
+    def del_branch(self, name, branch_name, type_):
         d = {1: 'd', 0: 'D'}.get(type_, 'd')
-        return self.get_git(name).del_Branch(branch_name, d)
+        return self.get_git(name).del_branch(branch_name, d)
 
-    def merge_Branch(self, name, branch_name, no_ff, m):
-        return self.get_git(name).merge_Branch(branch_name, no_ff, m)
+    def merge_branch(self, name, branch_name, no_ff, m):
+        return self.get_git(name).merge_branch(branch_name, no_ff, m)
 
     def merge_abort(self, name):
         return self.get_git(name).merge_abort()
 
-    def Save_stash(self, name):
-        return self.get_git(name).Save_stash()
+    def save_stash(self, name):
+        return self.get_git(name).save_stash()
 
-    def Stash_List(self, name):
-        return self.get_git(name).Stash_List()
+    def stash_list(self, name):
+        return self.get_git(name).get_stash_list()
 
-    def Apply_stash(self, name, stash_num='0'):
-        return self.get_git(name).Apply_stash(stash_num)
+    def apply_stash(self, name, stash_num='0'):
+        return self.get_git(name).apply_stash(stash_num)
 
-    def Drop_stash(self, name, stash_num='0'):
-        return self.get_git(name).Drop_stash(stash_num)
+    def drop_stash(self, name, stash_num='0'):
+        return self.get_git(name).drop_stash(stash_num)
 
     def cherry_pick(self, name, commit):
         return self.get_git(name).cherry_pick(commit)
 
-    def Del_remote(self, name, remote_name):
-        return self.get_git(name).Del_remote(remote_name)
+    def del_remote(self, name, remote_name):
+        return self.get_git(name).del_remote(remote_name)
 
-    def Add_remote(self, name, remote, remote_name):
-        return self.get_git(name).Add_remote(remote, remote_name)
+    def remote_add(self, name, remote, remote_name):
+        return self.get_git(name).remote_add(remote, remote_name)
 
-    def Bind_remote(self, name, local_name, remote_name):
-        return self.get_git(name).Bind_remote(local_name, remote_name)
+    def bind_branch(self, name, local_name, remote_name):
+        return self.get_git(name).bind_branch(local_name, remote_name)
 
-    def Pull_remote(
-        self,
-        name,
-        local_name,
-        remote_name,
-        remote_branch,
-        allow=False,
-        u=False,
-            f=False):
-        return self.get_git(name).Pull_Push_remote(
+    def pull_from_remote(self, name, local_name, remote_name, remote_branch, allow=False, u=False):
+        return self.get_git(name).pull_push(
             0, remote_name, remote_branch, local_name, allow, u, False)
 
-    def Push_remote(
-        self,
-        name,
-        local_name,
-        remote_name,
-        remote_branch,
-        allow=False,
-        u=False,
-            f=False):
-        return self.get_git(name).Pull_Push_remote(
+    def push_to_remote(self, name, local_name, remote_name, remote_branch, u=False, f=False):
+        return self.get_git(name).pull_push(
             1, remote_name, remote_branch, local_name, False, u, f)  # push没有allow选项
 
-    def Tag(self, name, condition=''):
-        return self.get_git(name).Tag(condition)  # push没有allow选项
+    def tag(self, name, condition=''):
+        return self.get_git(name).get_tag_list(condition)  # push没有allow选项
 
     def show_new(self, name, condition):
-        return self.get_git(name).show_new(condition)  # push没有allow选项
+        return self.get_git(name).search_commit(condition)  # push没有allow选项
 
-    def Add_Tag(self, name, tag, commit, message=''):
-        return self.get_git(name).Add_Tag(
+    def add_tag(self, name, tag, commit, message=''):
+        return self.get_git(name).add_tag(
             tag, commit, message)  # push没有allow选项
 
-    def push_Tag(self, name, tag, remoto):
-        return self.get_git(name).push_Tag(tag, remoto)
+    def push_tag(self, name, tag, remoto):
+        return self.get_git(name).push_tag(tag, remoto)
 
-    def push_allTag(self, name, remoto):
-        return self.get_git(name).push_Tag('--tags', remoto)
+    def push_all_tag(self, name, remoto):
+        return self.get_git(name).push_tag('--tags', remoto)
 
-    def del_Tag_remote(self, name, remote, tag):
-        return self.get_git(name).del_Tag_remote(remote, tag)
+    def del_tag_remote(self, name, remote, tag):
+        return self.get_git(name).del_tag_remote(remote, tag)
 
-    def del_Branch_remote(self, name, remote, remote_Branch):
-        return self.get_git(name).del_Branch_remote(remote, remote_Branch)
+    def del_branch_remote(self, name, remote, remote_Branch):
+        return self.get_git(name).del_branch_remote(remote, remote_Branch)
 
     def del_tag(self, name, tag):
         return self.get_git(name).del_tag(tag)
 
-    def Fetch(self, name, local_name, remote_name, remote_branch):
+    def fetch(self, name, local_name, remote_name, remote_branch):
         return self.get_git(name).fetch(remote_name, remote_branch, local_name)
 
-    def Customize(self, name, command: str):
-        return self.get_git(name).Customize(command)
+    def customize_command(self, name, command: str):
+        return self.get_git(name).customize_command(command)
 
-    def Clone(self, name, url):
-        return self.get_git(name).Clone(url)
+    def clone(self, name, url):
+        return self.get_git(name).clone(url)
 
-    def After_Clone(self, name):
+    def after_clone(self, name):
         try:
-            return self.get_git(name).after_Clone()
+            return self.get_git(name).after_clone()
         except BaseException:
             return None
 
-    def make_Dir(self, name, dir):
-        return self.get_git(name).make_Dir(dir)
+    def make_dir(self, name, dir):
+        return self.get_git(name).make_dir(dir)
 
-    def Branch_new(self, name, old_name, new_name):
-        return self.get_git(name).Branch_new(old_name, new_name)
+    def rename_branch(self, name, old_name, new_name):
+        return self.get_git(name).rename_branch(old_name, new_name)