fmp-stable-api 2.0.0__tar.gz → 2.0.2__tar.gz

{fmp_stable_api-2.0.0 → fmp_stable_api-2.0.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fmp-stable-api
-Version: 2.0.0
+Version: 2.0.2
 Summary: Financial Modeling Prep API client — auto-updating endpoints, GUI, and MCP server
 Author-email: FMP Dev <vr2969@g.rit.edu>
 License: MIT
-Project-URL: Homepage, https://github.com/YOUR_USERNAME/YOUR_REPO
-Project-URL: Repository, https://github.com/YOUR_USERNAME/YOUR_REPO
-Project-URL: Bug Tracker, https://github.com/YOUR_USERNAME/YOUR_REPO/issues
+Project-URL: Homepage, https://github.com/Vimal-Seshadri-Raguraman/fmp-stable-api
+Project-URL: Repository, https://github.com/Vimal-Seshadri-Raguraman/fmp-stable-api
+Project-URL: Bug Tracker, https://github.com/Vimal-Seshadri-Raguraman/fmp-stable-api/issues
 Keywords: finance,financial,modeling,prep,api,stock,market
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers

{fmp_stable_api-2.0.0 → fmp_stable_api-2.0.2}/fmp_stable_api/__init__.py

@@ -2,5 +2,5 @@ from .client import FMP
 from .updater import update_endpoints
 from .key_manager import KeyManager
 
-__version__ = "1.0.0"
+__version__ = "2.0.2"
 __all__ = ["FMP", "update_endpoints", "KeyManager"]

{fmp_stable_api-2.0.0 → fmp_stable_api-2.0.2}/fmp_stable_api/client.py

@@ -26,6 +26,15 @@ API_KEY_TYPES = {
     "Custom": None,
 }
 
+CLIENT_TYPE_TO_TIER = {
+    "Basic": "FREE",
+    "Starter": "STARTER",
+    "Premium": "PREMIUM",
+    "Ultimate": "ULTIMATE",
+    "Enterprise": "ULTIMATE",
+    "Custom": "ULTIMATE",
+}
+
 
 class CategoryProxy:
     """
@@ -35,10 +44,11 @@ class CategoryProxy:
         client.Search.search_symbol(symbol="AAPL")
     """
 
-    def __init__(self, category_name: str, endpoints: Dict, make_request: Callable):
+    def __init__(self, category_name: str, endpoints: Dict, make_request: Callable, tier: str = "FREE"):
         object.__setattr__(self, "_category_name", category_name)
         object.__setattr__(self, "_endpoints", endpoints)
         object.__setattr__(self, "_make_request", make_request)
+        object.__setattr__(self, "_tier", tier)
         object.__setattr__(self, "_cache", {})
 
     def __getattr__(self, name: str) -> Callable:
@@ -48,6 +58,7 @@ class CategoryProxy:
 
         endpoints = object.__getattribute__(self, "_endpoints")
         make_request = object.__getattribute__(self, "_make_request")
+        tier = object.__getattribute__(self, "_tier")
 
         # Match by snake_case function name
         for endpoint_key, config in endpoints.items():
@@ -60,6 +71,8 @@ class CategoryProxy:
                     required_params=config.get("required_params", []),
                     optional_params=config.get("optional_params", []),
                     make_request=make_request,
+                    access=config.get("access", {}),
+                    tier=tier,
                 )
                 fn.__name__ = name
                 cache[name] = fn
@@ -71,15 +84,19 @@ class CategoryProxy:
     def help(self) -> None:
         category = object.__getattribute__(self, "_category_name")
         endpoints = object.__getattribute__(self, "_endpoints")
+        tier = object.__getattribute__(self, "_tier")
         print(f"\n{'='*60}")
-        print(f"Category: {category}")
+        print(f"Category: {category}  (your tier: {tier})")
         print(f"{'='*60}")
         for endpoint_key, config in endpoints.items():
             func_name = endpoint_key.replace("-", "_").replace(" ", "_").lower()
             desc = config.get("description", "")
             req = [safe_param_name(p) for p in config.get("required_params", [])]
             opt = [safe_param_name(p) for p in config.get("optional_params", [])]
-            print(f"\n  {func_name}")
+            access = config.get("access", {})
+            tier_access = access.get(tier, "FULL") if access else "FULL"
+            badge = "" if tier_access == "FULL" else f"  [{tier_access}]"
+            print(f"\n  {func_name}{badge}")
             if desc:
                 print(f"    {desc}")
             if req:
@@ -155,12 +172,20 @@ class FMP:
 
         self._api_key = client_key
         self._client_type = client_type
+        self._tier = CLIENT_TYPE_TO_TIER.get(client_type, "FREE")
         self._minute_limit = minute_limit
         self._rate_limiter = RateLimiter(minute_limit)
 
-        # Load config and derive base URL
+        # Load config and derive base URL; auto-refresh if cache is stale (>24h)
         self._config = load_config()
         self._base_url = get_base_url(self._config)
+        try:
+            from .updater import update_endpoints
+            if update_endpoints():
+                self._config = load_config()
+                self._base_url = get_base_url(self._config)
+        except Exception:
+            pass
 
         # HTTP session with retry
         self._session = self._build_session()
@@ -206,7 +231,7 @@ class FMP:
         config = load_config()
         category_key = category_map[name]
         endpoints_dict = list_endpoints(config, category_key)
-        proxy = CategoryProxy(name, endpoints_dict, self._make_request)
+        proxy = CategoryProxy(name, endpoints_dict, self._make_request, self._tier)
         self.__dict__[name] = proxy
         return proxy
 
@@ -216,19 +241,13 @@ class FMP:
 
     def request(self, url: str, params: Optional[Dict] = None) -> Dict:
         """Make a GET request to any FMP URL."""
-        if not self._rate_limiter.can_make_request():
-            wait = self._rate_limiter.seconds_until_reset()
-            raise Exception(
-                f"Rate limit reached ({self._minute_limit} req/min). "
-                f"Resets in {wait:.0f}s."
-            )
+        self._rate_limiter.acquire()
 
         if params is None:
             params = {}
         params["apikey"] = self._api_key
 
         response = self._session.get(url, params=params, timeout=30)
-        self._rate_limiter.record_request()
 
         if response.status_code == 429:
             time.sleep(60)
@@ -250,16 +269,13 @@ class FMP:
         filename: Optional[str] = None,
     ) -> str:
         """Download a URL to a file; returns the saved filename."""
-        if not self._rate_limiter.can_make_request():
-            wait = self._rate_limiter.seconds_until_reset()
-            raise Exception(f"Rate limit reached. Resets in {wait:.0f}s.")
+        self._rate_limiter.acquire()
 
         if params is None:
             params = {}
         params["apikey"] = self._api_key
 
         response = self._session.get(url, params=params, timeout=30)
-        self._rate_limiter.record_request()
 
         if response.status_code == 401:
             raise Exception("Invalid API key.")

{fmp_stable_api-2.0.0 → fmp_stable_api-2.0.2}/fmp_stable_api/endpoints.py

@@ -2,11 +2,16 @@
 import json
 import keyword
 import os
-from typing import Callable, Dict, List
+import warnings
+from typing import Callable, Dict, List, Optional
 
 
 _BUNDLED = os.path.join(os.path.dirname(__file__), "fmp_endpoints.json")
 
+TIERS = ["FREE", "STARTER", "PREMIUM", "ULTIMATE"]
+ACCESS_LEVELS = ["FULL", "LIMITED", "NO_ACCESS"]
+DEFAULT_ACCESS = {tier: "FULL" for tier in TIERS}
+
 
 def load_config() -> Dict:
     """Load endpoints config via updater if available, else read bundled file."""
@@ -44,6 +49,8 @@ def build_endpoint_func(
     required_params: List[str],
     optional_params: List[str],
     make_request: Callable,
+    access: Optional[Dict] = None,
+    tier: Optional[str] = None,
 ) -> Callable:
     """
     Return a callable that validates required params and calls make_request.
@@ -56,6 +63,20 @@ def build_endpoint_func(
     all_safe = set(safe_required + safe_optional)
 
     def endpoint_func(**kwargs):
+        if tier and access:
+            tier_access = access.get(tier, "FULL")
+            if tier_access == "NO_ACCESS":
+                raise PermissionError(
+                    f"This endpoint is not available on the {tier} tier. "
+                    "Upgrade your plan to access it."
+                )
+            if tier_access == "LIMITED":
+                warnings.warn(
+                    f"This endpoint has LIMITED access on the {tier} tier. "
+                    "The response may be restricted.",
+                    stacklevel=2,
+                )
+
         # Validate required params
         for param in safe_required:
             if param not in kwargs: