atomgit 1.0.9__tar.gz → 1.0.11__tar.gz

{atomgit-1.0.9 → atomgit-1.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomgit
-Version: 1.0.9
+Version: 1.0.11
 Summary: AtomGit模型文件上传下载CLI工具
 Home-page: https://atomgit.com/gitcode-ai/atomgit_cli
 Author: AtomGit CLI Team

{atomgit-1.0.9 → atomgit-1.0.11}/__init__.py

@@ -8,7 +8,7 @@ AtomGit CLI - 基于Transformers和Hugging Face Hub的模型文件上传下载
 支持模型和数据集的上传、下载等操作。
 """
 
-__version__ = '1.0.9'
+__version__ = '1.0.5'
 __author__ = 'AtomGit CLI Team'
 __description__ = 'AtomGit模型文件上传下载CLI工具'
 
@@ -31,6 +31,6 @@ except ImportError:
 
 __all__ = [
     'config', 'api', 'cli',
-    'snapshot_download', 'hub_download_url', 'download_file',
+    'snapshot_download', 'hub_download_url', 'download_file', 
     'upload_folder', 'create_repository'
-]
+] 

{atomgit-1.0.9 → atomgit-1.0.11}/api.py

@@ -5,8 +5,8 @@ import json
 import urllib.request
 import urllib.error
 
-# 设置Hugging Face Hub的API端点为AtomGit
-os.environ["HF_ENDPOINT"] = "https://hub.atomgit.com"
+# 设置Hugging Face Hub的API端点为AtomGit（可用环境变量覆盖，便于联调测试环境）
+os.environ.setdefault("HF_ENDPOINT", "https://hub.atomgit.com")
 # 禁用Xet协议，避免 xet-write-token 请求
 os.environ["HF_HUB_DISABLE_XET"] = "1"
 # 设置缓存目录
@@ -15,15 +15,20 @@ os.makedirs(cache_dir, exist_ok=True)
 os.environ["HF_HOME"] = cache_dir
 
 
-from huggingface_hub import hf_hub_download, upload_folder, create_repo, snapshot_download, constants as hf_constants
+from huggingface_hub import hf_hub_download, upload_folder, create_repo, constants as hf_constants
+
 try:
-    from .atomgit_hub import snapshot_download as atomgit_snapshot_download
+    from . import atomgit_hub
 except ImportError:
-    from atomgit_hub import snapshot_download as atomgit_snapshot_download
+    import atomgit_hub
+
 try:
     from .rate_limiter import install_hf_rate_limiter
 except ImportError:
-    from rate_limiter import install_hf_rate_limiter
+    try:
+        from rate_limiter import install_hf_rate_limiter
+    except ImportError:
+        from atomgit.rate_limiter import install_hf_rate_limiter
 
 install_hf_rate_limiter()
 
@@ -61,7 +66,7 @@ class HuggingFaceAPI:
         
         # 二层或单层格式直接返回
         return repo_id
-    
+
     def login(self, token: str) -> bool:
         """登录验证"""
         if not token or len(token) < 10:
@@ -215,7 +220,7 @@ class HuggingFaceAPI:
     def download_repo(self, repo_id: str, local_path: Path = None, force_download: bool = False) -> bool:
         """下载仓库 - 使用Hugging Face Hub SDK，支持公开仓库无需token和断点续传"""
         try:
-            # 标准化仓库ID（处理三层格式）
+            # repo_id 交给 atomgit_hub 归一化（三层 -> dash），探测也在那边完成
             normalized_repo_id = self._normalize_repo_id(repo_id)
             
             if local_path is None:
@@ -224,15 +229,16 @@ class HuggingFaceAPI:
             # 创建本地目录
             local_path.mkdir(parents=True, exist_ok=True)
             
-            # 首先尝试不使用token下载（适用于公开仓库）
             credentials = config.get_credentials()
             try:
-                atomgit_snapshot_download(
-                    repo_id=normalized_repo_id,
+                # 复用 atomgit_hub：内部会先探测仓库可访问性，令牌无效但仓库公开时自动降级匿名，
+                # 避免 huggingface_hub 在 403/404 时静默回退本地目录导致假成功
+                atomgit_hub.snapshot_download(
+                    repo_id=repo_id,
                     local_dir=str(local_path),
-                    force_download=force_download,  # 根据用户选择决定是否强制下载
+                    force_download=force_download,
                     token=credentials['token'] if credentials and 'token' in credentials else None,
-                    max_workers=8
+                    max_workers=8,
                 )
                 print(f"✅ 仓库下载成功")
                 return True
@@ -258,14 +264,11 @@ class HuggingFaceAPI:
             local_path.mkdir(parents=True, exist_ok=True)
             
             # 首先尝试不使用token下载（适用于公开仓库）
-            credentials = config.get_credentials()
             try:
                 hf_hub_download(
                     repo_id=normalized_repo_id,
                     filename=filename,
-                    local_dir=str(local_path),
-                    token=credentials['token'] if credentials else None,
-                    force_download=force_download
+                    local_dir=str(local_path)
                 )
                 print(f"✅ 文件下载成功")
                 return True
@@ -278,6 +281,7 @@ class HuggingFaceAPI:
                     print("检测到认证问题，尝试使用token下载...")
                     
                     # 如果公开下载失败，尝试使用token下载
+                    credentials = config.get_credentials()
                     if credentials:
                         try:
                             hf_hub_download(
@@ -320,4 +324,4 @@ class HuggingFaceAPI:
 
 
 # 全局API实例
-api = HuggingFaceAPI()
+api = HuggingFaceAPI() 

{atomgit-1.0.9 → atomgit-1.0.11}/atomgit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomgit
-Version: 1.0.9
+Version: 1.0.11
 Summary: AtomGit模型文件上传下载CLI工具
 Home-page: https://atomgit.com/gitcode-ai/atomgit_cli
 Author: AtomGit CLI Team

{atomgit-1.0.9 → atomgit-1.0.11}/atomgit.egg-info/SOURCES.txt

@@ -24,4 +24,7 @@ atomgit.egg-info/dependency_links.txt
 atomgit.egg-info/entry_points.txt
 atomgit.egg-info/requires.txt
 atomgit.egg-info/top_level.txt
-tests/test_rate_limiter.py
+tests/test_download_real.py
+tests/test_endpoint_config.py
+tests/test_repo_id_normalize.py
+tests/test_repo_name_validation.py

{atomgit-1.0.9 → atomgit-1.0.11}/atomgit_hub.py

@@ -9,11 +9,13 @@ AtomGit Hub SDK - 类似huggingface_hub的SDK接口
 """
 
 import os
+import urllib.error
+import urllib.request
 from typing import Optional, Union, List, Dict, Any
 from pathlib import Path
 
-# 设置Hugging Face Hub的API端点为AtomGit
-os.environ["HF_ENDPOINT"] = "https://hub.atomgit.com"
+# 设置Hugging Face Hub的API端点为AtomGit（可用环境变量覆盖，便于联调测试环境）
+os.environ.setdefault("HF_ENDPOINT", "https://hub.atomgit.com")
 # 禁用Xet协议，避免 xet-write-token 请求
 os.environ["HF_HUB_DISABLE_XET"] = "1"
 # 设置缓存目录
@@ -22,9 +24,8 @@ os.makedirs(cache_dir, exist_ok=True)
 os.environ["HF_HOME"] = cache_dir
 
 from huggingface_hub import snapshot_download as hf_snapshot_download
-from huggingface_hub import hf_hub_download, upload_file as hf_upload_file, upload_folder as hf_upload_folder, create_repo
-from huggingface_hub import HfApi
-from concurrent.futures import ThreadPoolExecutor
+from huggingface_hub import hf_hub_download, upload_folder as hf_upload_folder, create_repo
+
 try:
     from .rate_limiter import install_hf_rate_limiter
 except ImportError:
@@ -88,52 +89,76 @@ def _get_token() -> Optional[str]:
     return None
 
 
-def _snapshot_download_from_tree(
-    repo_id: str,
-    local_dir: Union[str, Path],
-    revision: Optional[str],
-    token: Optional[Union[str, bool]],
-    force_download: bool,
-    allow_patterns: Optional[Union[List[str], str]],
-    ignore_patterns: Optional[Union[List[str], str]],
-    max_workers: int,
-) -> str:
-    """Download through list_repo_tree when repo_info.siblings is unavailable."""
-    from huggingface_hub.utils import filter_repo_objects
-    from huggingface_hub.hf_api import RepoFile
-
-    api = HfApi()
-    files = [
-        item.path
-        for item in api.list_repo_tree(
-            repo_id=repo_id, recursive=True, revision=revision, token=token
+def _probe_status(repo_id: str, token: Optional[str] = None) -> Optional[int]:
+    """探测仓库可访问性，返回 HTTP 状态码；网络异常返回 None。"""
+    endpoint = os.environ.get("HF_ENDPOINT", "https://hub.atomgit.com").rstrip("/")
+    headers = {"User-Agent": "atomgit-cli"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    status = None
+    # 默认分支可能是 main 或 master，404 时再试一个
+    for revision in ("main", "master"):
+        request = urllib.request.Request(
+            f"{endpoint}/api/models/{repo_id}/revision/{revision}", headers=headers
         )
-        if isinstance(item, RepoFile)
-    ]
-    files = list(filter_repo_objects(
-        items=files,
-        allow_patterns=allow_patterns,
-        ignore_patterns=ignore_patterns,
-    ))
-    if not files:
-        raise FileNotFoundError(f"仓库没有可下载的文件: {repo_id}")
-
-    destination = Path(local_dir)
-    destination.mkdir(parents=True, exist_ok=True)
-
-    def download_one(filename: str) -> None:
-        hf_hub_download(
-            repo_id=repo_id,
-            filename=filename,
-            revision=revision,
-            token=token,
-            local_dir=str(destination),
-            force_download=force_download,
+        try:
+            with urllib.request.urlopen(request, timeout=15):
+                return 200
+        except urllib.error.HTTPError as e:
+            status = e.code
+            if status != 404:
+                break
+        except Exception as e:
+            # 网络抖动不阻断下载，交给 SDK 自己重试
+            print(f"⚠ 仓库探测失败，跳过可访问性检查: {e}")
+            return None
+    return status
+
+
+def _probe_repo(repo_id: str, token: Optional[str] = None) -> Optional[str]:
+    """下载前确认仓库可访问，返回最终应使用的 token。
+
+    huggingface_hub 在远端 403/404 且 local_dir 已存在时，会打印一行
+    "Returning existing local_dir ..." 并静默返回本地目录，表现为"下载成功"，
+    实际一个文件都没下。这里提前探测一次，给出明确错误。
+
+    返回值：
+    - 令牌有效：原 token
+    - 令牌无效但仓库公开：None（降级匿名下载，避免 snapshot 列表接口 401）
+    - 私有仓库无权限 / 仓库不存在：抛异常
+    - 网络异常：不阻断，返回原 token
+    """
+    if token:
+        status = _probe_status(repo_id, token)
+        if status is None or 200 <= status < 300:
+            return token
+        if status in (401, 403):
+            anonymous = _probe_status(repo_id, None)
+            if anonymous is not None and 200 <= anonymous < 300:
+                print("⚠ 令牌无效或与仓库不匹配，但该仓库可公开访问，已降级为匿名下载")
+                return None
+            if status == 401:
+                raise Exception(
+                    "认证失败：token 无效或已过期（401）。请使用 'atomgit login' 重新登录。"
+                )
+            raise Exception(
+                f"无权访问：{repo_id}（403）。请确认 token 拥有该仓库的读权限，或该仓库是否为私有。"
+            )
+        if status == 404:
+            raise Exception(f"仓库不存在：{repo_id}。请检查仓库名称是否正确。")
+        return token
+
+    status = _probe_status(repo_id, None)
+    if status is None or 200 <= status < 300:
+        return None
+    if status == 404:
+        raise Exception(f"仓库不存在：{repo_id}。请检查仓库名称是否正确。")
+    if status in (401, 403):
+        raise Exception(
+            f"无权访问：{repo_id}（403）。该仓库为私有，请先登录或提供有读权限的 token。"
         )
-
-    with ThreadPoolExecutor(max_workers=max(1, max_workers)) as executor:
-        list(executor.map(download_one, files))
-    return str(destination.resolve())
+    return None
 
 
 def snapshot_download(
@@ -225,30 +250,20 @@ def snapshot_download(
         'tqdm_class': tqdm_class,
     })
     
+    # 下载前探测：确认可访问；无效令牌在公开仓库上自动降级为匿名
+    if not local_files_only:
+        token = _probe_repo(normalized_repo_id, token)
+        if token is None:
+            kwargs.pop('token', None)
+        else:
+            kwargs['token'] = token
+
     try:
         # 使用token下载
         result = hf_snapshot_download(**{k: v for k, v in kwargs.items() if v is not None})
         return result
     except Exception as e:
         error_msg = str(e)
-        if local_dir is not None and (
-            "min() iterable argument is empty" in error_msg
-            or "min() arg is an empty sequence" in error_msg
-            or "404 Not Found" in error_msg
-        ):
-            try:
-                return _snapshot_download_from_tree(
-                    repo_id=normalized_repo_id,
-                    local_dir=local_dir,
-                    revision=revision,
-                    token=token,
-                    force_download=force_download,
-                    allow_patterns=allow_patterns,
-                    ignore_patterns=ignore_patterns,
-                    max_workers=max_workers,
-                )
-            except Exception as fallback_error:
-                error_msg = str(fallback_error)
         if "401" in error_msg or "403" in error_msg:
             raise Exception(f"认证失败：{error_msg}。请检查token是否正确，或使用 'atomgit login' 重新登录。")
         elif "404" in error_msg:
@@ -333,6 +348,13 @@ def download_file(
     if force_download:
         kwargs['force_download'] = force_download
     
+    # 下载前探测：确认可访问；无效令牌在公开仓库上自动降级为匿名
+    token = _probe_repo(normalized_repo_id, token)
+    if token is None:
+        kwargs.pop('token', None)
+    else:
+        kwargs['token'] = token
+
     try:
         result = hf_hub_download(**{k: v for k, v in kwargs.items() if v is not None})
         return result
@@ -359,21 +381,18 @@ def upload_folder(
     upload_timeout: float = 300.0,
 ) -> str:
     """
-    上传文件或文件夹到AtomGit Hub
-
-    自动判断传入路径是文件还是文件夹，两者都支持。
-
+    上传文件夹到AtomGit Hub
+    
     参数:
-        folder_path (str 或 Path): 本地文件或文件夹路径
+        folder_path (str 或 Path): 本地文件夹路径
         repo_id (str): 仓库ID
         token (str, 可选): 认证token
         repo_type (str, 可选): 仓库类型
         revision (str, 可选): 分支名
         commit_message (str, 可选): 提交消息
         commit_description (str, 可选): 提交描述
-        path_in_repo (str, 可选): 在仓库中的路径，默认为根目录。
-                                  若传入的是文件，文件名会自动拼接到该路径末尾。
-        ignore_patterns (List[str], 可选): 要忽略的文件模式（仅文件夹上传生效）
+        path_in_repo (str, 可选): 在仓库中的路径，默认为根目录
+        ignore_patterns (List[str], 可选): 要忽略的文件模式
         upload_timeout (float, 可选): 上传超时时间（秒），默认60秒（1分钟）。
                                       对于大文件，服务器处理响应可能需要较长时间。
     
@@ -384,7 +403,6 @@ def upload_folder(
         >>> upload_folder("./my-model/", "username/repo-name")
         >>> upload_folder("./data/", "username/repo", path_in_repo="datasets/")
         >>> upload_folder("./big-files/", "username/repo", upload_timeout=1200.0)  # 20分钟超时
-        >>> upload_folder("./weights.pth", "username/repo", path_in_repo="checkpoints/")  # 上传单个文件
     """
     # 标准化仓库ID
     normalized_repo_id = _normalize_repo_id(repo_id)
@@ -393,10 +411,10 @@ def upload_folder(
     folder_path = Path(folder_path)
     
     if not folder_path.exists():
-        raise FileNotFoundError(f"路径不存在: {folder_path}")
-
-    if not folder_path.is_file() and not folder_path.is_dir():
-        raise ValueError(f"路径既不是文件也不是目录: {folder_path}")
+        raise FileNotFoundError(f"文件夹不存在: {folder_path}")
+    
+    if not folder_path.is_dir():
+        raise NotADirectoryError(f"路径不是目录: {folder_path}")
     
     # 如果没有提供token，尝试使用保存的token
     if token is None:
@@ -404,62 +422,36 @@ def upload_folder(
         if token is None:
             raise Exception("上传需要认证token，请先使用 'atomgit login' 登录，或提供token参数。")
     
-    # 使用 Monkey Patch 方式临时修改 huggingface_hub 的默认超时配置
-    from huggingface_hub import constants as hf_constants
+    # 直接使用原始目录，或者创建临时目录来重新组织结构
     import tempfile
     import shutil
 
+    if path_in_repo == "./" or path_in_repo == "." or path_in_repo == "":
+        # 如果要上传到根目录，直接使用源文件夹
+        upload_path = str(folder_path)
+    else:
+        # 如果要上传到特定路径，需要重新组织目录结构
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # 创建目标路径
+            target_path = temp_path / path_in_repo.strip('./')
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # 复制整个目录树
+            shutil.copytree(folder_path, target_path, dirs_exist_ok=True)
+            
+            upload_path = str(temp_path)
+    # 使用 Monkey Patch 方式临时修改 huggingface_hub 的默认超时配置
+    from huggingface_hub import constants as hf_constants
+    
     # 保存原始超时配置
     original_timeout = hf_constants.DEFAULT_REQUEST_TIMEOUT
-
+    
     # 临时修改超时配置
     hf_constants.DEFAULT_REQUEST_TIMEOUT = upload_timeout
-
-    temp_dir = None
+    
     try:
-        # 上传单个文件
-        if folder_path.is_file():
-            # path_in_repo 按目录语义处理（与文件夹分支一致，去掉首尾 ./ 和 /），
-            # 文件名自动拼接到末尾
-            clean_path = path_in_repo.strip().strip("./")
-            if not clean_path:
-                target_path = folder_path.name
-            else:
-                target_path = clean_path + "/" + folder_path.name
-            commit_msg = commit_message or f"Upload file {folder_path.name}"
-            result = hf_upload_file(
-                repo_id=normalized_repo_id,
-                path_or_fileobj=str(folder_path),
-                path_in_repo=target_path,
-                token=token,
-                commit_message=commit_msg
-            )
-            return result
-
-        # 上传文件夹：直接使用原始目录，或者创建临时目录来重新组织结构
-        if path_in_repo == "./" or path_in_repo == "." or path_in_repo == "":
-            # 如果要上传到根目录，直接使用源文件夹
-            upload_path = str(folder_path)
-        else:
-            # 如果要上传到特定路径，需要重新组织目录结构。
-            # 注意：不能提前退出 with TemporaryDirectory()，否则上传时临时目录已被删除。
-            temp_dir = tempfile.mkdtemp(prefix="atomgit_upload_")
-            try:
-                temp_path = Path(temp_dir)
-
-                # 创建目标路径
-                target_path = temp_path / path_in_repo.strip('./')
-                target_path.parent.mkdir(parents=True, exist_ok=True)
-
-                # 复制整个目录树
-                shutil.copytree(folder_path, target_path, dirs_exist_ok=True)
-
-            except Exception:
-                shutil.rmtree(temp_dir, ignore_errors=True)
-                raise
-
-            upload_path = str(temp_path)
-
         # 使用huggingface_hub的upload_folder上传
         commit_msg = commit_message or f"Upload folder {folder_path.name}"
         result = hf_upload_folder(
@@ -468,7 +460,7 @@ def upload_folder(
             token=token,
             commit_message=commit_msg
         )
-
+        
         return result
 
     except Exception as e:
@@ -479,12 +471,6 @@ def upload_folder(
             raise Exception(f"仓库不存在：{repo_id}")
         else:
             raise Exception(f"上传失败：{error_msg}")
-    finally:
-        # 恢复原始超时配置
-        hf_constants.DEFAULT_REQUEST_TIMEOUT = original_timeout
-        # 清理临时目录（仅重新组织目录结构时创建）
-        if temp_dir is not None:
-            shutil.rmtree(temp_dir, ignore_errors=True)
 
 
 def create_repository(

{atomgit-1.0.9 → atomgit-1.0.11}/cli.py

@@ -39,7 +39,7 @@ except ImportError:
 
 
 @click.group()
-@click.version_option(version='1.0.9')
+@click.version_option(version='1.0.5')
 def cli():
     """AtomGit CLI - 基于Transformers和Hugging Face Hub的AtomGit平台模型文件上传下载工具"""
     pass
@@ -292,4 +292,4 @@ def config_show():
 
 
 if __name__ == '__main__':
-    cli()
+    cli() 

{atomgit-1.0.9 → atomgit-1.0.11}/rate_limiter.py

@@ -75,6 +75,17 @@ def install_hf_rate_limiter() -> bool:
     except (ImportError, AttributeError):
         return False
 
+    # huggingface_hub 1.x 默认请求/etag 超时是 10s，且不读取 HF_HUB_ETAG_TIMEOUT /
+    # HF_HUB_DOWNLOAD_TIMEOUT 环境变量；而 AtomGit 的 /tree 接口在大仓库上可能
+    # 耗时 15s 以上（实测 308 个文件的仓库约 18s），会直接 read timeout。
+    try:
+        from huggingface_hub import constants as hf_constants
+
+        hf_constants.DEFAULT_REQUEST_TIMEOUT = max(hf_constants.DEFAULT_REQUEST_TIMEOUT, 60)
+        hf_constants.DEFAULT_ETAG_TIMEOUT = max(hf_constants.DEFAULT_ETAG_TIMEOUT, 60)
+    except (ImportError, AttributeError):
+        pass
+
     # AtomGit's file metadata endpoint is limited to 50 requests/minute.
     # Keep a safety margin and leave ordinary file transfer requests untouched.
     limiter = SharedRateLimiter(rate_per_minute=45.0, burst=2)
@@ -102,6 +113,8 @@ def install_hf_rate_limiter() -> bool:
                 time.sleep(min(delay, 60.0))
                 attempts += 1
 
-    set_client_factory(lambda: LimitedClient())
+    # httpx.Client 默认超时只有 5s，会覆盖 huggingface_hub 自己的超时配置；
+    # AtomGit 的 /tree 接口在较大仓库上可能耗时 15s 以上，必须显式给足超时
+    client_timeout = httpx.Timeout(60.0, connect=15.0)
+    set_client_factory(lambda: LimitedClient(timeout=client_timeout))
     return True
-    _thread_lock = threading.Lock()

{atomgit-1.0.9 → atomgit-1.0.11}/setup.py

@@ -31,7 +31,7 @@ def read_requirements():
 
 setup(
     name='atomgit',
-    version='1.0.9',
+    version='1.0.11',
     author='AtomGit CLI Team',
     author_email='sa@atomgit.com',
     description='AtomGit模型文件上传下载CLI工具',
@@ -69,4 +69,4 @@ setup(
         'Bug Reports': 'https://atomgit.com/gitcode-ai/atomgit_cli/issues',
         'Source': 'https://atomgit.com/gitcode-ai/atomgit_cli',
     },
-)
+) 

atomgit-1.0.11/tests/test_download_real.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""下载语义测试 —— 全部直连 https://hub.atomgit.com，不做任何网络 mock。
+
+覆盖的优化点：
+1. 三层仓库 ID 归一化后能真正下载到文件（端到端验证）；
+2. 仓库 / 文件不存在时返回 False，即使本地目录已有残留也不能报成功；
+3. 无效令牌必须失败，不能静默成功；
+4. 公开仓库匿名可下载。
+
+说明：
+- 除 ``config.get_credentials``（本地凭证来源）外，不 patch 任何东西；
+- 本文件依赖 pre 环境与公网，环境不可用时失败属于预期结果。
+"""
+
+import contextlib
+import io
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+# 必须在导入 api 之前固定端点与超时：api.py / atomgit_hub.py 用 setdefault，不会覆盖这里的值
+os.environ["HF_ENDPOINT"] = "https://hub.atomgit.com"
+os.environ.setdefault("HF_HUB_ETAG_TIMEOUT", "60")
+os.environ.setdefault("HF_HUB_DOWNLOAD_TIMEOUT", "120")
+
+import api  # noqa: E402
+import atomgit_hub  # noqa: E402
+from huggingface_hub import constants as hf_constants  # noqa: E402
+
+ENDPOINT = "https://hub.atomgit.com"
+# 用户输入的三层形态（会被归一化成 dash 形态再请求）
+REPO_THREE_LEVEL = "hf_mirrors/Qwen/Qwen2.5-7B-Instruct-GGUF"
+# 服务端实际使用的 dash 形态
+REPO_DASH = "hf_mirrors-Qwen/Qwen2.5-7B-Instruct-GGUF"
+SMALL_FILES = ["README.md", "LICENSE", ".gitattributes"]
+MISSING_REPO = "hf_mirrors/Qwen/Qwen2.5-7B-Instruct-GGUF8"
+MISSING_FILE = "not_exist_xxxxxxxx.bin"
+
+
+class PreEndpointGuardTests(unittest.TestCase):
+    """确保用例真的打在 pre 上，而不是被外部环境变量带到别的端点。"""
+
+    def test_requests_really_go_to_pre_hub(self):
+        self.assertEqual(hf_constants.ENDPOINT, ENDPOINT)
+
+
+class DownloadFileAgainstPreTests(unittest.TestCase):
+    def setUp(self):
+        self.client = api.HuggingFaceAPI()
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.local_dir = Path(self._tmp.name) / "one-file"
+
+    def _download(self, credentials=None, **kwargs):
+        with mock.patch.object(api.config, "get_credentials", return_value=credentials):
+            with contextlib.redirect_stdout(io.StringIO()) as out:
+                result = self.client.download_file(**kwargs)
+        return result, out.getvalue()
+
+    # ---------- 正例 ----------
+    def test_three_level_repo_downloads_real_file(self):
+        """三层 ID 归一化后真实下载成功，文件非空。"""
+        result, out = self._download(
+            repo_id=REPO_THREE_LEVEL,
+            filename="README.md",
+            local_path=self.local_dir,
+        )
+        self.assertTrue(result, out)
+        target = self.local_dir / "README.md"
+        self.assertTrue(target.is_file(), out)
+        self.assertGreater(target.stat().st_size, 0, "下载到的文件不应是 0 字节")
+
+    def test_public_repo_is_downloadable_without_token(self):
+        result, out = self._download(
+            credentials=None,
+            repo_id=REPO_DASH,
+            filename="LICENSE",
+            local_path=self.local_dir,
+        )
+        self.assertTrue(result, out)
+        self.assertGreater((self.local_dir / "LICENSE").stat().st_size, 0)
+
+    # ---------- 反例 ----------
+    def test_missing_file_returns_false(self):
+        result, out = self._download(
+            credentials=None,
+            repo_id=REPO_DASH,
+            filename=MISSING_FILE,
+            local_path=self.local_dir,
+        )
+        self.assertFalse(result)
+        self.assertNotIn("✅", out)
+
+    def test_public_repo_tolerates_invalid_token(self):
+        """公开仓库不因调用者令牌无效而失败（实测 pre 会忽略无效令牌照常返回内容）。"""
+        result, out = self._download(
+            credentials={"token": "1231321321"},
+            repo_id=REPO_DASH,
+            filename="README.md",
+            local_path=self.local_dir,
+        )
+        self.assertTrue(result, out)
+        self.assertGreater((self.local_dir / "README.md").stat().st_size, 0)
+
+
+class DownloadRepoAgainstPreTests(unittest.TestCase):
+    def setUp(self):
+        self.client = api.HuggingFaceAPI()
+        self._tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp.cleanup)
+        self.local_dir = Path(self._tmp.name) / "snapshot"
+
+    # ---------- 正例：整仓下载路径（限制为小文件，避免拉取数 GB 权重） ----------
+    def test_snapshot_download_with_patterns_succeeds(self):
+        with contextlib.redirect_stdout(io.StringIO()):
+            path = atomgit_hub.snapshot_download(
+                REPO_THREE_LEVEL,
+                local_dir=str(self.local_dir),
+                allow_patterns=SMALL_FILES,
+            )
+        downloaded = [p for p in Path(path).iterdir() if p.is_file()]
+        self.assertTrue(downloaded, "整仓下载应至少落盘一个小文件")
+        for item in downloaded:
+            self.assertGreater(item.stat().st_size, 0, f"{item.name} 不应是 0 字节")
+
+    # ---------- 反例：不存在的仓库 + 已有残留目录，绝不能报成功 ----------
+    def test_missing_repo_with_stale_local_dir_does_not_report_success(self):
+        self.local_dir.mkdir(parents=True)
+        stale = self.local_dir / "keep.txt"
+        stale.write_text("stale-content", encoding="utf-8")
+
+        with mock.patch.object(api.config, "get_credentials", return_value=None):
+            with contextlib.redirect_stdout(io.StringIO()) as out:
+                result = self.client.download_repo(MISSING_REPO, self.local_dir)
+
+        self.assertFalse(result)
+        self.assertNotIn("✅", out.getvalue())
+        self.assertEqual(stale.read_text(encoding="utf-8"), "stale-content")
+
+
+if __name__ == "__main__":
+    unittest.main()

atomgit-1.0.11/tests/test_endpoint_config.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""端点配置测试。
+
+优化点：端点必须可以被 HF_ENDPOINT 环境变量覆盖，否则无法联调 pre/测试环境。
+由于两个模块都在 import 时读取环境变量，这里用子进程隔离验证。
+"""
+
+import os
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_API_ENDPOINT = "https://hub.atomgit.com"
+DEFAULT_HUB_ENDPOINT = "https://hub.atomgit.com"
+CUSTOM_ENDPOINT = "https://example.test"
+
+
+def run_in_project(code, endpoint=None, timeout=120):
+    """在项目根目录、去除 HF_ENDPOINT 的干净环境里执行代码。"""
+    env = {k: v for k, v in os.environ.items() if k != "HF_ENDPOINT"}
+    if endpoint is not None:
+        env["HF_ENDPOINT"] = endpoint
+    return subprocess.run(
+        [sys.executable, "-c", code],
+        cwd=str(ROOT),
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+
+
+def endpoint_of(module, endpoint=None):
+    code = (
+        f"import {module};"
+        "from huggingface_hub import constants;"
+        "print(constants.ENDPOINT)"
+    )
+    result = run_in_project(code, endpoint=endpoint)
+    return result
+
+
+class EndpointConfigTests(unittest.TestCase):
+    # ---------- 正例 ----------
+    def test_api_module_honours_env_override(self):
+        result = endpoint_of("api", endpoint=CUSTOM_ENDPOINT)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), CUSTOM_ENDPOINT)
+
+    def test_sdk_module_honours_env_override(self):
+        result = endpoint_of("atomgit_hub", endpoint=CUSTOM_ENDPOINT)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), CUSTOM_ENDPOINT)
+
+    # ---------- 反例（未设置环境变量时的默认行为） ----------
+    def test_api_module_falls_back_to_pre_hub(self):
+        result = endpoint_of("api", endpoint=None)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), DEFAULT_API_ENDPOINT)
+
+    def test_sdk_module_falls_back_to_hub(self):
+        """记录现状：atomgit_hub 与 api 的默认端点目前不一致。"""
+        result = endpoint_of("atomgit_hub", endpoint=None)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout.strip(), DEFAULT_HUB_ENDPOINT)
+
+    def test_empty_env_value_does_not_break_import(self):
+        """空值属于脏配置，只要 import 不崩即可（不做端点断言）。"""
+        result = endpoint_of("api", endpoint="")
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

atomgit-1.0.11/tests/test_repo_id_normalize.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""三层仓库 ID 归一化测试。
+
+优化点：上游 /api/models/... 只认 dash 前缀（hf_mirrors-Qwen/repo），
+而用户输入是三层形态（hf_mirrors/Qwen/repo），必须在发起请求前归一化。
+"""
+
+import contextlib
+import io
+import unittest
+
+import atomgit_hub
+from api import HuggingFaceAPI
+
+
+class NormalizeRepoIdTests(unittest.TestCase):
+    def setUp(self):
+        self.client = HuggingFaceAPI()
+
+    def normalize(self, repo_id):
+        """归一化会打印转换日志，测试里屏蔽掉避免噪声。"""
+        with contextlib.redirect_stdout(io.StringIO()):
+            return self.client._normalize_repo_id(repo_id)
+
+    # ---------- 正例 ----------
+    def test_three_level_becomes_dash_prefix(self):
+        self.assertEqual(
+            self.normalize("hf_mirrors/Qwen/Qwen2.5-7B-Instruct-GGUF"),
+            "hf_mirrors-Qwen/Qwen2.5-7B-Instruct-GGUF",
+        )
+
+    def test_four_level_keeps_remaining_segments(self):
+        self.assertEqual(self.normalize("a/b/c/d"), "a-b/c/d")
+
+    def test_normalization_prints_conversion_log(self):
+        with contextlib.redirect_stdout(io.StringIO()) as out:
+            self.client._normalize_repo_id("hf_mirrors/Qwen/repo")
+        self.assertIn("三层仓库名称转换", out.getvalue())
+        self.assertIn("hf_mirrors-Qwen/repo", out.getvalue())
+
+    def test_module_level_function_is_consistent_with_client(self):
+        repo_id = "hf_mirrors/Qwen/Qwen2.5-7B-Instruct-GGUF"
+        self.assertEqual(atomgit_hub._normalize_repo_id(repo_id), self.normalize(repo_id))
+
+    # ---------- 反例 ----------
+    def test_two_level_is_unchanged(self):
+        self.assertEqual(
+            self.normalize("gitcode-dev/atomgit-api-doc"),
+            "gitcode-dev/atomgit-api-doc",
+        )
+
+    def test_single_level_is_unchanged(self):
+        self.assertEqual(self.normalize("atomgit-api-doc"), "atomgit-api-doc")
+
+    def test_empty_string_is_unchanged(self):
+        self.assertEqual(self.normalize(""), "")
+
+    def test_leading_slash_produces_empty_first_segment(self):
+        # 记录现状：脏输入不会被归一化修正，需要靠 validate_repo_name 拦截
+        self.assertEqual(self.normalize("/a/b"), "-a/b")
+
+    def test_trailing_slash_keeps_empty_tail(self):
+        self.assertEqual(self.normalize("a/b/"), "a-b/")
+
+
+if __name__ == "__main__":
+    unittest.main()

atomgit-1.0.11/tests/test_repo_name_validation.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""仓库 ID 输入校验测试。
+
+优化点：CLI 命令入口必须容忍合法的三层仓库 ID，同时拦截脏输入，
+避免脏输入一路传到上游变成 404/401 的误导性报错。
+"""
+
+import unittest
+
+from utils import validate_repo_name
+
+
+class ValidateRepoNameTests(unittest.TestCase):
+    # ---------- 正例 ----------
+    def test_two_level_is_valid(self):
+        self.assertTrue(validate_repo_name("gitcode-dev/atomgit-api-doc"))
+
+    def test_three_level_is_valid(self):
+        self.assertTrue(validate_repo_name("hf_mirrors/Qwen/Qwen2.5-7B-Instruct-GGUF"))
+
+    def test_more_than_three_level_is_valid(self):
+        self.assertTrue(validate_repo_name("a/b/c/d"))
+
+    def test_percent_encoded_is_valid(self):
+        self.assertTrue(validate_repo_name("hf_mirrors%2FQwen/Qwen2.5-7B-Instruct-GGUF"))
+
+    def test_dash_dot_underscore_are_valid(self):
+        self.assertTrue(validate_repo_name("hf_mirrors-Qwen/Qwen2.5_7B-GGUF.v1"))
+
+    # ---------- 反例 ----------
+    def test_empty_string_is_invalid(self):
+        self.assertFalse(validate_repo_name(""))
+
+    def test_no_slash_is_invalid(self):
+        self.assertFalse(validate_repo_name("atomgit-api-doc"))
+
+    def test_empty_segment_is_invalid(self):
+        self.assertFalse(validate_repo_name("a//b"))
+
+    def test_trailing_slash_is_invalid(self):
+        self.assertFalse(validate_repo_name("a/b/"))
+
+    def test_whitespace_is_invalid(self):
+        self.assertFalse(validate_repo_name("a/b c"))
+
+    def test_illegal_character_is_invalid(self):
+        self.assertFalse(validate_repo_name("a/b?x"))
+
+
+if __name__ == "__main__":
+    unittest.main()

atomgit-1.0.9/tests/test_rate_limiter.py

@@ -1,72 +0,0 @@
-import json
-import subprocess
-import sys
-import tempfile
-import threading
-import time
-import unittest
-from pathlib import Path
-
-from rate_limiter import SharedRateLimiter, install_hf_rate_limiter
-
-
-class RateLimiterTests(unittest.TestCase):
-    def test_concurrent_access_keeps_valid_shared_state(self):
-        with tempfile.TemporaryDirectory() as directory:
-            state_file = Path(directory) / "rate.json"
-            limiter = SharedRateLimiter(60000, 4, state_file)
-            errors = []
-
-            def worker():
-                try:
-                    for _ in range(10):
-                        limiter.acquire()
-                except Exception as error:  # pragma: no cover - assertion below
-                    errors.append(error)
-
-            threads = [threading.Thread(target=worker) for _ in range(4)]
-            for thread in threads:
-                thread.start()
-            for thread in threads:
-                thread.join()
-
-            self.assertFalse(errors)
-            self.assertIsInstance(json.loads(state_file.read_text()), dict)
-
-    def test_multiple_processes_share_state_file(self):
-        with tempfile.TemporaryDirectory() as directory:
-            state_file = Path(directory) / "rate.json"
-            code = (
-                "from pathlib import Path; "
-                "from rate_limiter import SharedRateLimiter; "
-                f"SharedRateLimiter(60000, 4, Path({str(state_file)!r})).acquire()"
-            )
-            processes = [subprocess.run([sys.executable, "-c", code]) for _ in range(3)]
-            self.assertTrue(all(process.returncode == 0 for process in processes))
-            self.assertTrue(state_file.exists())
-
-    def test_huggingface_client_factory_is_limited(self):
-        import huggingface_hub
-
-        self.assertTrue(install_hf_rate_limiter())
-        self.assertEqual(type(huggingface_hub.get_session()).__name__, "LimitedClient")
-        huggingface_hub.close_session()
-
-    def test_file_api_limit_is_conservative(self):
-        limiter = SharedRateLimiter()
-        self.assertAlmostEqual(limiter.rate * 60, 45.0)
-        self.assertEqual(limiter.burst, 2)
-
-
-class InstalledCliTests(unittest.TestCase):
-    def test_installed_cli_help(self):
-        cli = Path(__file__).parents[1] / ".venv" / "bin" / "atomgit"
-        if not cli.exists():
-            self.skipTest(".venv/bin/atomgit is not installed")
-        result = subprocess.run([str(cli), "--help"], capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertIn("download", result.stdout)
-
-
-if __name__ == "__main__":
-    unittest.main()