fmp-stable-api 0.0.1__tar.gz

fmp_stable_api-0.0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vimal Seshadri Raguraman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fmp_stable_api-0.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include FMP/fmp_endpoints.json
+include pyproject.toml
+include setup.py

fmp_stable_api-0.0.1/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.2
+Name: fmp-stable-api
+Version: 0.0.1
+Summary: Python client library for the Financial Modeling Prep API
+Home-page: https://github.com/Vimal-Seshadri-Raguraman/FMP
+Author: Vimal Seshadri Raguraman
+Project-URL: GitHub, https://github.com/Vimal-Seshadri-Raguraman/FMP
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: requests
+Requires-Dist: ratelimit
+Requires-Dist: websockets
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FMP Client Library
+A Python client library for the [Financial Modeling Prep (FMP) API](https://financialmodelingprep.com/). This library provides both synchronous REST API and asynchronous WebSocket support, all in a modular, easy-to-use package.
+
+The client is built to work with the [**Stable** version](https://site.financialmodelingprep.com/developer/docs/stable) of the Financial Modeling Prep (FMP) API. All endpoints are configured to use the stable base URL:
+```arduino
+https://financialmodelingprep.com/stable/
+```
+The endpoints available in this stable version are defined in the [fmp_endpoints.json](https://github.com/Vimal-Seshadri-Raguraman/FMP/blob/main/FMP/fmp_endpoints.json) file
+
+## Features
+
+- **Unified API Client:**  
+  Dynamically access FMP endpoints using Pythonic method names.
+
+- **Rate-Limited HTTP Session:**  
+  Built-in rate limiting using the `ratelimit` library and robust error handling with logging.
+
+- **Dynamic Endpoint Methods:**  
+  Automatically attaches methods based on your configuration file (`fmp_endpoints.json`).
+
+- **Asynchronous WebSocket Clients:**  
+  Separate clients for stocks, crypto, and forex data available in the `fmp_websockets` subpackage.
+
+- **Flexible Configuration and Logging:**  
+  Easily configure your endpoints with a JSON file and log messages to a file in the same directory as your main script.
+
+## Installation
+
+Clone the repository and install the dependencies:
+
+```bash
+git clone https://github.com/Vimal-Seshadri-Raguraman/FMP.git
+cd FMP
+pip install -r requirements.txt
+python setup.py install
+```
+Alternatively, install directly from Github:
+```bash
+pip install git+https://github.com/Vimal-Seshadri-Raguraman/FMP.git
+```
+
+## Usage
+### API Client
+Initialize the client with your API Key and call any endpoint dynmically:
+```python
+from fmp import FMP
+
+# Initialize client with your API Key
+client = fmp(api_key = "YOUR_API_KEY")
+
+# Call an endpoint (e.g., "Profile")
+response = client.profile(symbol = "AAPL")
+print("Status Code:", response.status_code)
+print("Profile Data:", response.json())
+```
+#### Dynmic Methods and Help
+The client automatically attaches methods based on the JSON configuration. To see available endpoints and their parameters:
+```python
+# General help for all endpoints
+print(client.help())
+
+# Detailed help for a specific endpoint (e.g., "profile")
+print(client.help("profile"))
+
+# Generate a manual page of endpoints
+man_doc = client.man_page() # Create a text file
+print(man_doc)
+```
+### WebSocket Clients
+The library includes asynchronous WebSocket clients for real-time data.
+#### Stock WebSocket Example
+```python
+import asyncio
+from fmp import StockWebsockets
+
+async def run_stock_ws():
+    stock_ws = StockWebsockets(tickers=["AAPL", "MSFT"], api_key="YOUR_API_KEY")
+    async for message in stock_ws.run():
+        print("Stock WebSocket Message:", message)
+
+asyncio.run(run_stock_ws())
+```
+#### Crypto and Forex WebSocket Example
+```python
+import asyncio
+from fmp import CryptoWebsockets, ForexWebsockets
+
+async def run_crypto_ws():
+    crypto_ws = CryptoWebsockets(tickers=["BTCUSD", "ETHUSD"], api_key="YOUR_API_KEY")
+    async for message in crypto_ws.run():
+        print("Crypto WebSocket Message:", message)
+
+async def run_forex_ws():
+    forex_ws = ForexWebsockets(pairs=["EURUSD", "GBPUSD"], api_key="YOUR_API_KEY")
+    async for message in forex_ws.run():
+        print("Forex WebSocket Message:", message)
+
+# Run one example at a time:
+asyncio.run(run_crypto_ws())
+# asyncio.run(run_forex_ws())
+```
+## Configuration
+By default, the client loads endpoint configuration from ```fmp_endpoints.json``` located in the same directory as ```fmp_client.py```. To use a custom configuration file:
+```python
+client = FMP(api_key="YOUR_API_KEY", config_file="path/to/your_config.json")
+```
+If you update the configuration file during runtime, force a reload with:
+```python
+client.config_manager.reload()
+```
+## Logging
+Logging is enabled by default and creates a log file (```fmp.log```) in the directory where your main script is located. To disable logging:
+```python
+client = FMP(api_key="YOUR_API_KEY", log_enabled=False)
+```
+## Contributing
+Contributions, bug reports, and feature requests are welcome. Please open an issue or submit a pull request.
+## License
+This project is licensed under the MIT License. See the [```LICENSE.md```](https://github.com/Vimal-Seshadri-Raguraman/FMP/blob/main/LICENSE) file for details.

fmp_stable_api-0.0.1/README.md

@@ -0,0 +1,119 @@
+# FMP Client Library
+A Python client library for the [Financial Modeling Prep (FMP) API](https://financialmodelingprep.com/). This library provides both synchronous REST API and asynchronous WebSocket support, all in a modular, easy-to-use package.
+
+The client is built to work with the [**Stable** version](https://site.financialmodelingprep.com/developer/docs/stable) of the Financial Modeling Prep (FMP) API. All endpoints are configured to use the stable base URL:
+```arduino
+https://financialmodelingprep.com/stable/
+```
+The endpoints available in this stable version are defined in the [fmp_endpoints.json](https://github.com/Vimal-Seshadri-Raguraman/FMP/blob/main/FMP/fmp_endpoints.json) file
+
+## Features
+
+- **Unified API Client:**  
+  Dynamically access FMP endpoints using Pythonic method names.
+
+- **Rate-Limited HTTP Session:**  
+  Built-in rate limiting using the `ratelimit` library and robust error handling with logging.
+
+- **Dynamic Endpoint Methods:**  
+  Automatically attaches methods based on your configuration file (`fmp_endpoints.json`).
+
+- **Asynchronous WebSocket Clients:**  
+  Separate clients for stocks, crypto, and forex data available in the `fmp_websockets` subpackage.
+
+- **Flexible Configuration and Logging:**  
+  Easily configure your endpoints with a JSON file and log messages to a file in the same directory as your main script.
+
+## Installation
+
+Clone the repository and install the dependencies:
+
+```bash
+git clone https://github.com/Vimal-Seshadri-Raguraman/FMP.git
+cd FMP
+pip install -r requirements.txt
+python setup.py install
+```
+Alternatively, install directly from Github:
+```bash
+pip install git+https://github.com/Vimal-Seshadri-Raguraman/FMP.git
+```
+
+## Usage
+### API Client
+Initialize the client with your API Key and call any endpoint dynmically:
+```python
+from fmp import FMP
+
+# Initialize client with your API Key
+client = fmp(api_key = "YOUR_API_KEY")
+
+# Call an endpoint (e.g., "Profile")
+response = client.profile(symbol = "AAPL")
+print("Status Code:", response.status_code)
+print("Profile Data:", response.json())
+```
+#### Dynmic Methods and Help
+The client automatically attaches methods based on the JSON configuration. To see available endpoints and their parameters:
+```python
+# General help for all endpoints
+print(client.help())
+
+# Detailed help for a specific endpoint (e.g., "profile")
+print(client.help("profile"))
+
+# Generate a manual page of endpoints
+man_doc = client.man_page() # Create a text file
+print(man_doc)
+```
+### WebSocket Clients
+The library includes asynchronous WebSocket clients for real-time data.
+#### Stock WebSocket Example
+```python
+import asyncio
+from fmp import StockWebsockets
+
+async def run_stock_ws():
+    stock_ws = StockWebsockets(tickers=["AAPL", "MSFT"], api_key="YOUR_API_KEY")
+    async for message in stock_ws.run():
+        print("Stock WebSocket Message:", message)
+
+asyncio.run(run_stock_ws())
+```
+#### Crypto and Forex WebSocket Example
+```python
+import asyncio
+from fmp import CryptoWebsockets, ForexWebsockets
+
+async def run_crypto_ws():
+    crypto_ws = CryptoWebsockets(tickers=["BTCUSD", "ETHUSD"], api_key="YOUR_API_KEY")
+    async for message in crypto_ws.run():
+        print("Crypto WebSocket Message:", message)
+
+async def run_forex_ws():
+    forex_ws = ForexWebsockets(pairs=["EURUSD", "GBPUSD"], api_key="YOUR_API_KEY")
+    async for message in forex_ws.run():
+        print("Forex WebSocket Message:", message)
+
+# Run one example at a time:
+asyncio.run(run_crypto_ws())
+# asyncio.run(run_forex_ws())
+```
+## Configuration
+By default, the client loads endpoint configuration from ```fmp_endpoints.json``` located in the same directory as ```fmp_client.py```. To use a custom configuration file:
+```python
+client = FMP(api_key="YOUR_API_KEY", config_file="path/to/your_config.json")
+```
+If you update the configuration file during runtime, force a reload with:
+```python
+client.config_manager.reload()
+```
+## Logging
+Logging is enabled by default and creates a log file (```fmp.log```) in the directory where your main script is located. To disable logging:
+```python
+client = FMP(api_key="YOUR_API_KEY", log_enabled=False)
+```
+## Contributing
+Contributions, bug reports, and feature requests are welcome. Please open an issue or submit a pull request.
+## License
+This project is licensed under the MIT License. See the [```LICENSE.md```](https://github.com/Vimal-Seshadri-Raguraman/FMP/blob/main/LICENSE) file for details.

fmp_stable_api-0.0.1/fmp/__init__.py

@@ -0,0 +1,35 @@
+"""
+Financial Modeling Prep Client Library
+
+Exposes:
+    FMP: Unified REST API client.
+    Logger: Logging utility.
+    ConfigManager: Configuration loader.
+    Session: HTTP session with rate limiting.
+    StockWebsockets: WebSocket client for stock data.
+    CryptoWebsockets: WebSocket client for crypto data.
+    ForexWebsockets: WebSocket client for forex data.
+"""
+
+from .logger import Logger
+from .config_manager import ConfigManager
+from .dynamic import create_endpoint_method, attach_dynamic_functions
+from .session import Session
+from .fmp_client import FMP
+
+from .fmp_websockets.stock_websocket import StockWebsockets
+from .fmp_websockets.crypto_websocket import CryptoWebsockets
+from .fmp_websockets.forex_websocket import ForexWebsockets
+
+__all__ = [
+    "FMP",
+    "Logger",
+    "ConfigManager",
+    "Session",
+    "StockWebsockets",
+    "CryptoWebsockets",
+    "ForexWebsockets",
+]
+
+__version__ = "0.0.1"
+__author__ = "Vimal Seshadri Raguraman"

fmp_stable_api-0.0.1/fmp/config_manager.py

@@ -0,0 +1,34 @@
+import json
+from typing import Dict, Any, Optional
+import importlib.resources as pkg_resources
+
+class ConfigManager:
+    """
+    Loads and caches a JSON configuration file.
+    If no config_file is provided, loads the default configuration
+    from the package resource fmp_endpoints.json.
+    """
+    def __init__(self, config_file: Optional[str] = None) -> None:
+        self.config_file = config_file
+        self._config: Optional[Dict[str, Any]] = None
+
+    def get(self) -> Dict[str, Any]:
+        if self._config is None:
+            if self.config_file is None:
+                # Load default configuration from package resources.
+                with pkg_resources.open_text("fmp", "fmp_endpoints.json") as f:
+                    self._config = json.load(f)
+            else:
+                with open(self.config_file, "r") as f:
+                    self._config = json.load(f)
+        return self._config
+
+    def reload(self) -> Dict[str, Any]:
+        """Force reload of the configuration file."""
+        if self.config_file is None:
+            with pkg_resources.open_text("fmp", "fmp_endpoints.json") as f:
+                self._config = json.load(f)
+        else:
+            with open(self.config_file, "r") as f:
+                self._config = json.load(f)
+        return self._config

fmp_stable_api-0.0.1/fmp/dynamic.py

@@ -0,0 +1,26 @@
+from typing import Callable, Any
+
+def create_endpoint_method(ep: str) -> Callable:
+    """
+    Returns an endpoint method bound to a specific API endpoint.
+    Renames parameters (e.g. 'start_date' to 'from') before calling the client.
+    """
+    def method(self, *args, **kwargs):
+        if 'start_date' in kwargs:
+            kwargs['from'] = kwargs.pop('start_date')
+        elif 'from_' in kwargs:
+            kwargs['from'] = kwargs.pop('from_')
+        if 'end_date' in kwargs:
+            kwargs['to'] = kwargs.pop('end_date')
+        elif 'to_' in kwargs:
+            kwargs['to'] = kwargs.pop('to_')
+        return self.call(ep, **kwargs)
+    return method
+
+def attach_dynamic_functions(client: Any) -> None:
+    """
+    Attaches dynamic endpoint methods to the client.
+    """
+    for ep in client.endpoints.keys():
+        func_name = ep.replace("-", "_")
+        setattr(client.__class__, func_name, create_endpoint_method(ep))

fmp_stable_api-0.0.1/fmp/fmp_client.py

@@ -0,0 +1,118 @@
+import os
+import sys
+import urllib.parse
+from typing import Optional, Dict, Any
+import requests
+
+from .config_manager import ConfigManager
+from .logger import Logger
+from .session import Session
+from .dynamic import attach_dynamic_functions
+
+class FMP:
+    """
+    Unified Financial Modeling Prep API client.
+    
+    Combines configuration management, HTTP session handling, dynamic endpoint methods,
+    and helper functions into one class.
+    
+    Example:
+        client = FMP(api_key="YOUR_API_KEY")
+        response = client.profile(symbol="AAPL")
+        print(response.json())
+    """
+    def __init__(self,
+                 api_key: str,
+                 config_file: Optional[str] = None,
+                 base_url: Optional[str] = None,
+                 logger: Optional[Logger] = None,
+                 log_enabled: bool = True) -> None:
+        self.api_key = api_key
+        # Let ConfigManager load the default config from package resources if config_file is None.
+        self.config_manager = ConfigManager(config_file)
+        self.config = self.config_manager.get()
+        self.base_url = base_url or self.config.get("base_url")
+        if logger is None:
+            logger = Logger("FMP", enabled=log_enabled)
+        self.logger = logger
+        self.session = Session(api_key, logger=logger)
+        self.endpoints: Dict[str, Any] = self.config.get("endpoints", {})
+        attach_dynamic_functions(self)
+
+    def call(self, endpoint_name: str, **kwargs) -> requests.Response:
+        if endpoint_name not in self.endpoints:
+            raise ValueError(f"Endpoint '{endpoint_name}' not found in configuration.")
+        endpoint_info = self.endpoints[endpoint_name]
+        url = urllib.parse.urljoin(self.base_url, endpoint_info["path"])
+        allowed = endpoint_info.get("params", {}).keys()
+        params = {k: v for k, v in kwargs.items() if k in allowed}
+        params["apikey"] = self.api_key
+        return self.session.get(url, params=params)
+
+    def help(self, endpoint: Optional[str] = None) -> str:
+        """
+        Returns help information for endpoints.
+        """
+        doc = ("FMP API Client Help\n\nUsage:\n  client.endpoint_name(param1=value1, ...)\n"
+               "Example:\n  client.profile(symbol='AAPL')\n\n")
+        if endpoint:
+            target = next((key for key in self.endpoints if key.replace("-", "_") == endpoint), None)
+            if not target:
+                doc += f"Endpoint '{endpoint}' not found.\n"
+            else:
+                config = self.endpoints[target]
+                doc += f"Help for endpoint '{target}':\n  Path: {config.get('path')}\n"
+                params = config.get("params", {})
+                if params:
+                    doc += "  Allowed parameters:\n"
+                    for param, details in params.items():
+                        required = details.get("required", False)
+                        param_type = details.get("type", "unknown")
+                        example = details.get("example", "")
+                        doc += f"    - {param} (required: {required}, type: {param_type}, example: {example})\n"
+                else:
+                    doc += "  No parameters defined.\n"
+        else:
+            for ep, config in self.endpoints.items():
+                func_name = ep.replace("-", "_")
+                doc += f"\nEndpoint: {func_name}\n  Path: {config.get('path')}\n"
+                params = config.get("params", {})
+                if params:
+                    doc += "  Allowed parameters:\n"
+                    for param, details in params.items():
+                        required = details.get("required", False)
+                        param_type = details.get("type", "unknown")
+                        example = details.get("example", "")
+                        doc += f"    - {param} (required: {required}, type: {param_type}, example: {example})\n"
+                else:
+                    doc += "  No parameters defined.\n"
+            doc += "\n"
+        return doc
+
+    def man_page(self, just_name: bool = False, filename: str = "FMP_man_page.txt") -> str:
+        main_dir = (os.path.dirname(sys.modules["__main__"].__file__)
+                    if "__main__" in sys.modules and hasattr(sys.modules["__main__"], "__file__")
+                    else os.getcwd())
+        doc_file = os.path.join(main_dir, filename)
+        if os.path.exists(doc_file):
+            os.remove(doc_file)
+        output = "Manual Page for FMP API Client Endpoints:\n"
+        for ep, config in self.endpoints.items():
+            func_name = ep.replace("-", "_")
+            if just_name:
+                output += f"\n\t{func_name}"
+            else:
+                output += f"\n\nEndpoint: {func_name}\n  Path: {config.get('path')}\n"
+                params = config.get("params", {})
+                if params:
+                    output += "  Allowed parameters:\n"
+                    for param, details in params.items():
+                        required = details.get("required", False)
+                        param_type = details.get("type", "unknown")
+                        example = details.get("example", "")
+                        output += f"    - {param} (required: {required}, type: {param_type}, example: {example})\n"
+                else:
+                    output += "  No parameters defined.\n"
+        with open(doc_file, "w") as f:
+            f.write(output)
+        return output

fmp_stable_api-0.0.1/fmp/fmp_websockets/__init__.py

@@ -0,0 +1,9 @@
+from .stock_websocket import StockWebsockets
+from .crypto_websocket import CryptoWebsockets
+from .forex_websocket import ForexWebsockets
+
+__all__ = [
+    "StockWebsockets",
+    "CryptoWebsockets",
+    "ForexWebsockets",
+]

fmp_stable_api-0.0.1/fmp/fmp_websockets/base_websocket_client.py

@@ -0,0 +1,58 @@
+import json
+import asyncio
+from typing import List, Optional, AsyncGenerator
+import websockets
+
+class BaseWebsocketClient:
+    """
+    Base class for FinancialModelingPrep WebSocket clients.
+    Handles connection, login, subscription, and yields messages.
+    """
+    def __init__(self, tickers: List[str], api_key: str, uri: str) -> None:
+        self.tickers = tickers if isinstance(tickers, list) else [tickers]
+        self.api_key = api_key
+        self.uri = uri
+        self.websocket: Optional[websockets.WebSocketClientProtocol] = None
+
+    async def connect(self) -> None:
+        self.websocket = await websockets.connect(self.uri)
+        print(f"Connected to {self.uri}")
+
+    async def login(self) -> None:
+        login_msg = {"event": "login", "data": {"apiKey": self.api_key}}
+        await self.websocket.send(json.dumps(login_msg))
+        print("Sent login message")
+
+    async def subscribe(self) -> None:
+        subscribe_msg = {"event": "subscribe", "data": {"ticker": self.tickers}}
+        await self.websocket.send(json.dumps(subscribe_msg))
+        print(f"Subscribed to tickers: {self.tickers}")
+
+    async def run(self) -> AsyncGenerator[dict, None]:
+        """
+        Connects, logs in, waits for confirmation, subscribes,
+        and yields messages continuously.
+        """
+        await self.connect()
+        await self.login()
+        while True:
+            response = await self.websocket.recv()
+            message = json.loads(response)
+            if message.get("event") == "login":
+                if message.get("status") == 200:
+                    print("Login successful")
+                    break
+                else:
+                    raise Exception("Login failed: " + message.get("message", "Unknown error"))
+            else:
+                print("Received (before login confirmation):", message)
+        await self.subscribe()
+        try:
+            while True:
+                response = await self.websocket.recv()
+                data = json.loads(response)
+                yield data
+        except websockets.ConnectionClosed:
+            print("Connection closed by the server.")
+        finally:
+            await self.websocket.close()

fmp_stable_api-0.0.1/fmp/fmp_websockets/crypto_websocket.py

@@ -0,0 +1,7 @@
+from typing import List
+from .base_websocket_client import BaseWebsocketClient
+
+class CryptoWebsockets(BaseWebsocketClient):
+    def __init__(self, tickers: List[str], api_key: str, 
+                 uri: str = "wss://crypto.financialmodelingprep.com") -> None:
+        super().__init__(tickers, api_key, uri)

fmp_stable_api-0.0.1/fmp/fmp_websockets/forex_websocket.py

@@ -0,0 +1,7 @@
+from typing import List
+from .base_websocket_client import BaseWebsocketClient
+
+class ForexWebsockets(BaseWebsocketClient):
+    def __init__(self, pairs: List[str], api_key: str, 
+                 uri: str = "wss://forex.financialmodelingprep.com") -> None:
+        super().__init__(pairs, api_key, uri)

fmp_stable_api-0.0.1/fmp/fmp_websockets/stock_websocket.py

@@ -0,0 +1,7 @@
+from typing import List
+from .base_websocket_client import BaseWebsocketClient
+
+class StockWebsockets(BaseWebsocketClient):
+    def __init__(self, tickers: List[str], api_key: str, 
+                 uri: str = "wss://websockets.financialmodelingprep.com") -> None:
+        super().__init__(tickers, api_key, uri)

fmp_stable_api-0.0.1/fmp/logger.py

@@ -0,0 +1,29 @@
+import os
+import sys
+import logging
+from typing import Optional
+
+class Logger:
+    def __init__(self, name: str = "FMPLogger", log_file: Optional[str] = None, 
+                 level: int = logging.INFO, enabled: bool = True) -> None:
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(level)
+        if log_file is None:
+            if "__main__" in sys.modules and hasattr(sys.modules["__main__"], "__file__"):
+                main_dir = os.path.dirname(sys.modules["__main__"].__file__)
+            else:
+                main_dir = os.getcwd()
+            log_file = os.path.join(main_dir, "fmp.log")
+        if enabled:
+            handler = logging.FileHandler(log_file)
+            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+        else:
+            self.logger.addHandler(logging.NullHandler())
+
+    def info(self, message: str) -> None:
+        self.logger.info(message)
+
+    def error(self, message: str) -> None:
+        self.logger.error(message)

fmp_stable_api-0.0.1/fmp/session.py

@@ -0,0 +1,30 @@
+import requests
+from typing import Optional, Dict, Any
+from ratelimit import limits, sleep_and_retry
+from concurrent.futures import ThreadPoolExecutor
+from .logger import Logger
+
+REQUEST_RATE = {"calls": 3000, "seconds": 60}
+
+class Session:
+    """
+    Provides a persistent HTTP session with rate limiting.
+    """
+    def __init__(self, api_key: str, logger: Optional[Logger] = None) -> None:
+        self.api_key = api_key
+        self.session = requests.Session()
+        self.logger = logger if logger is not None else Logger("FMP.Session", enabled=True)
+        self.executor = ThreadPoolExecutor(max_workers=5)
+
+    @sleep_and_retry
+    @limits(calls=REQUEST_RATE["calls"], period=REQUEST_RATE["seconds"])
+    def get(self, url: str, params: Optional[Dict[str, Any]] = None) -> requests.Response:
+        self.logger.info(f"HTTP GET: {url} with params {params}")
+        try:
+            response = self.session.get(url, params=params)
+            response.raise_for_status()
+            self.logger.info(f"Response: {response.status_code}")
+            return response
+        except Exception as e:
+            self.logger.error(f"HTTP GET error: {e}")
+            raise

fmp_stable_api-0.0.1/fmp_stable_api.egg-info/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.2
+Name: fmp-stable-api
+Version: 0.0.1
+Summary: Python client library for the Financial Modeling Prep API
+Home-page: https://github.com/Vimal-Seshadri-Raguraman/FMP
+Author: Vimal Seshadri Raguraman
+Project-URL: GitHub, https://github.com/Vimal-Seshadri-Raguraman/FMP
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: requests
+Requires-Dist: ratelimit
+Requires-Dist: websockets
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FMP Client Library
+A Python client library for the [Financial Modeling Prep (FMP) API](https://financialmodelingprep.com/). This library provides both synchronous REST API and asynchronous WebSocket support, all in a modular, easy-to-use package.
+
+The client is built to work with the [**Stable** version](https://site.financialmodelingprep.com/developer/docs/stable) of the Financial Modeling Prep (FMP) API. All endpoints are configured to use the stable base URL:
+```arduino
+https://financialmodelingprep.com/stable/
+```
+The endpoints available in this stable version are defined in the [fmp_endpoints.json](https://github.com/Vimal-Seshadri-Raguraman/FMP/blob/main/FMP/fmp_endpoints.json) file
+
+## Features
+
+- **Unified API Client:**  
+  Dynamically access FMP endpoints using Pythonic method names.
+
+- **Rate-Limited HTTP Session:**  
+  Built-in rate limiting using the `ratelimit` library and robust error handling with logging.
+
+- **Dynamic Endpoint Methods:**  
+  Automatically attaches methods based on your configuration file (`fmp_endpoints.json`).
+
+- **Asynchronous WebSocket Clients:**  
+  Separate clients for stocks, crypto, and forex data available in the `fmp_websockets` subpackage.
+
+- **Flexible Configuration and Logging:**  
+  Easily configure your endpoints with a JSON file and log messages to a file in the same directory as your main script.
+
+## Installation
+
+Clone the repository and install the dependencies:
+
+```bash
+git clone https://github.com/Vimal-Seshadri-Raguraman/FMP.git
+cd FMP
+pip install -r requirements.txt
+python setup.py install
+```
+Alternatively, install directly from Github:
+```bash
+pip install git+https://github.com/Vimal-Seshadri-Raguraman/FMP.git
+```
+
+## Usage
+### API Client
+Initialize the client with your API Key and call any endpoint dynmically:
+```python
+from fmp import FMP
+
+# Initialize client with your API Key
+client = fmp(api_key = "YOUR_API_KEY")
+
+# Call an endpoint (e.g., "Profile")
+response = client.profile(symbol = "AAPL")
+print("Status Code:", response.status_code)
+print("Profile Data:", response.json())
+```
+#### Dynmic Methods and Help
+The client automatically attaches methods based on the JSON configuration. To see available endpoints and their parameters:
+```python
+# General help for all endpoints
+print(client.help())
+
+# Detailed help for a specific endpoint (e.g., "profile")
+print(client.help("profile"))
+
+# Generate a manual page of endpoints
+man_doc = client.man_page() # Create a text file
+print(man_doc)
+```
+### WebSocket Clients
+The library includes asynchronous WebSocket clients for real-time data.
+#### Stock WebSocket Example
+```python
+import asyncio
+from fmp import StockWebsockets
+
+async def run_stock_ws():
+    stock_ws = StockWebsockets(tickers=["AAPL", "MSFT"], api_key="YOUR_API_KEY")
+    async for message in stock_ws.run():
+        print("Stock WebSocket Message:", message)
+
+asyncio.run(run_stock_ws())
+```
+#### Crypto and Forex WebSocket Example
+```python
+import asyncio
+from fmp import CryptoWebsockets, ForexWebsockets
+
+async def run_crypto_ws():
+    crypto_ws = CryptoWebsockets(tickers=["BTCUSD", "ETHUSD"], api_key="YOUR_API_KEY")
+    async for message in crypto_ws.run():
+        print("Crypto WebSocket Message:", message)
+
+async def run_forex_ws():
+    forex_ws = ForexWebsockets(pairs=["EURUSD", "GBPUSD"], api_key="YOUR_API_KEY")
+    async for message in forex_ws.run():
+        print("Forex WebSocket Message:", message)
+
+# Run one example at a time:
+asyncio.run(run_crypto_ws())
+# asyncio.run(run_forex_ws())
+```
+## Configuration
+By default, the client loads endpoint configuration from ```fmp_endpoints.json``` located in the same directory as ```fmp_client.py```. To use a custom configuration file:
+```python
+client = FMP(api_key="YOUR_API_KEY", config_file="path/to/your_config.json")
+```
+If you update the configuration file during runtime, force a reload with:
+```python
+client.config_manager.reload()
+```
+## Logging
+Logging is enabled by default and creates a log file (```fmp.log```) in the directory where your main script is located. To disable logging:
+```python
+client = FMP(api_key="YOUR_API_KEY", log_enabled=False)
+```
+## Contributing
+Contributions, bug reports, and feature requests are welcome. Please open an issue or submit a pull request.
+## License
+This project is licensed under the MIT License. See the [```LICENSE.md```](https://github.com/Vimal-Seshadri-Raguraman/FMP/blob/main/LICENSE) file for details.

fmp_stable_api-0.0.1/fmp_stable_api.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE.txt
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+fmp/__init__.py
+fmp/config_manager.py
+fmp/dynamic.py
+fmp/fmp_client.py
+fmp/logger.py
+fmp/session.py
+fmp/fmp_websockets/__init__.py
+fmp/fmp_websockets/base_websocket_client.py
+fmp/fmp_websockets/crypto_websocket.py
+fmp/fmp_websockets/forex_websocket.py
+fmp/fmp_websockets/stock_websocket.py
+fmp_stable_api.egg-info/PKG-INFO
+fmp_stable_api.egg-info/SOURCES.txt
+fmp_stable_api.egg-info/dependency_links.txt
+fmp_stable_api.egg-info/requires.txt
+fmp_stable_api.egg-info/top_level.txt

fmp_stable_api-0.0.1/fmp_stable_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fmp_stable_api-0.0.1/fmp_stable_api.egg-info/requires.txt

@@ -0,0 +1,7 @@
+requests
+ratelimit
+websockets
+
+[dev]
+pytest
+twine

fmp_stable_api-0.0.1/fmp_stable_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+fmp

fmp_stable_api-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

fmp_stable_api-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fmp_stable_api-0.0.1/setup.py

@@ -0,0 +1,36 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="fmp-stable-api",
+    version="0.0.1",
+    description="Python client library for the Financial Modeling Prep API",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Vimal Seshadri Raguraman",
+    url="https://github.com/Vimal-Seshadri-Raguraman/FMP",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "requests",
+        "ratelimit",
+        "websockets",
+    ],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Financial and Insurance Industry",
+        "Topic :: Office/Business :: Financial"
+    ],
+    extras_require={
+        "dev": [
+            "pytest",
+            "twine"
+        ]
+    },
+    python_requires='>=3.6',
+    project_urls={
+        "GitHub":"https://github.com/Vimal-Seshadri-Raguraman/FMP",
+    }
+)