massive-api-client 0.0.1a0__tar.gz

massive_api_client-0.0.1a0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 caseyvu
+
+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.

massive_api_client-0.0.1a0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: massive-api-client
+Version: 0.0.1a0
+Summary: A Python async wrapper for massive.com API
+Author: Casey Vu
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: massive>=2.4.0
+Dynamic: license-file
+
+# TODO

massive_api_client-0.0.1a0/README.md

@@ -0,0 +1 @@
+# TODO

massive_api_client-0.0.1a0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "massive-api-client"
+version = "0.0.1-alpha"
+description = "A Python async wrapper for massive.com API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+  { name = "Casey Vu" }
+]
+dependencies = [
+  "httpx >= 0.28.1",
+  "massive >= 2.4.0",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

massive_api_client-0.0.1a0/setup.cfg

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

massive_api_client-0.0.1a0/src/massive_api_client/__init__.py

@@ -0,0 +1,8 @@
+import importlib.metadata
+from .rest import MassiveAPIClient
+from .exceptions import *
+
+
+__version__ = importlib.metadata.version("massive-api-client")
+
+print(__version__)

massive_api_client-0.0.1a0/src/massive_api_client/config.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class MassiveClientConfig:
+    massive_api_key: str
+    api_base_url: str = "https://api.massive.com"
+    timeout_secs: float = 30.0
+    rate_limit_sleep_secs: float = 60.0
+    rate_limit_max_retries: int = 3

massive_api_client-0.0.1a0/src/massive_api_client/exceptions.py

@@ -0,0 +1,19 @@
+from httpx import Response
+from typing import Optional
+
+
+class APIException(Exception):
+    
+    def __init__(self, message: Optional[str] = None, response: Optional[Response] = None):
+        self.status = None if response is None else response.status_code
+        self.response_text = None if response is None else response.text
+        self.message = message
+
+
+class RateLimitException(APIException):
+    pass
+
+
+class BadResponseException(APIException):
+    pass
+

massive_api_client-0.0.1a0/src/massive_api_client/rest/__init__.py

@@ -0,0 +1,4 @@
+from .reference import TickersClient
+
+class MassiveAPIClient(TickersClient):
+    pass

massive_api_client-0.0.1a0/src/massive_api_client/rest/base.py

@@ -0,0 +1,141 @@
+import asyncio
+import httpx
+import inspect
+from collections.abc import AsyncIterator
+from enum import Enum
+from datetime import datetime
+from typing import Any, Dict, Optional, Union
+from urllib.parse import urlparse
+
+from ..config import MassiveClientConfig
+from ..exceptions import BadResponseException, RateLimitException
+
+
+class BaseClient:
+
+    RATE_LIMIT_HTTP_CODE = 429
+    RESULTS_FIELD = "results"
+    NEXT_URL_FIELD = "next_url"
+    HTTP_METHOD_GET = "GET"
+    DEFAULT_MAX_NUM_PAGES = 10000
+
+
+    def __init__(self, config: MassiveClientConfig) -> None:
+        self._api_key = config.massive_api_key
+        self._base_url = config.api_base_url.rstrip("/")
+        self._rate_limit_sleep_secs = config.rate_limit_sleep_secs
+        self._rate_limit_max_retries = config.rate_limit_max_retries
+        self._client = httpx.AsyncClient(timeout=config.timeout_secs)
+        self._headers = {
+            "Authorization": "Bearer " + self._api_key,
+            "Accept-Encoding": "gzip",
+        }
+
+    async def close(self) -> None:
+        await self.client.aclose()
+
+    async def request(self, uri: str, params: Optional[Dict] = None, deserializer=None, result_key: Optional[str] = RESULTS_FIELD, method: str = HTTP_METHOD_GET) -> Any:
+        full_url = self.make_full_url(uri)
+        response = await self._request_with_retries(method, full_url, params, self._headers)
+        if result_key is not None and result_key not in response:
+            raise BadResponseException(message=f"API Response does not contain field: {result_key}", response=response)
+        
+        resp_obj = response if result_key is None else response[result_key]
+        return self._apply_deserializer(deserializer, resp_obj)
+
+    async def request_with_pagination(
+            self, uri: str, params: Optional[Dict] = None, deserializer=None, 
+            max_num_pages: Optional[int] = DEFAULT_MAX_NUM_PAGES, # Defensive check to avoid infinite pagination 
+            result_key: str = RESULTS_FIELD, method: str = HTTP_METHOD_GET) -> AsyncIterator[Any]:
+        full_url = self.make_full_url(uri)
+
+        max_num_pages = self.DEFAULT_MAX_NUM_PAGES if max_num_pages is None else max_num_pages
+        page_i = 0
+        while page_i < max_num_pages:
+            response = await self._request_with_retries(method, full_url, params, self._headers)
+            if result_key not in response:
+                raise BadResponseException(message=f"API Response does not contain field: {result_key}", response=response)
+        
+            for item in response[result_key]:
+                yield self._apply_deserializer(deserializer, item)
+
+            next_url = response.get(self.NEXT_URL_FIELD)
+            if next_url is None:
+                break
+            
+            parsed = urlparse(next_url)
+            params = parsed.query
+            page_i += 1
+
+    def _apply_deserializer(self, deserializer, resp_obj) -> Any:
+        if deserializer:
+            if type(resp_obj) == list:
+                return [deserializer(o) for o in resp_obj]
+            return deserializer(resp_obj)
+        return resp_obj
+
+    def make_full_url(self, uri: str) -> str:
+        return f"{self._base_url}{uri}"
+    
+    async def _request_with_retries(self, method: str, url: str, params: Optional[Union[Dict, str]] = None, headers: Optional[Dict] = None) -> Any:
+        response = await self._client.request(method, url, params=params, headers=headers)
+
+        retries_count = 0
+        while response.status_code == self.RATE_LIMIT_HTTP_CODE and retries_count < self._rate_limit_max_retries:
+            print(f"SLEEPING 1 min because status_code = 409...")
+            await asyncio.sleep(self._rate_limit_sleep_secs)
+            response = await self._client.request(method, url, params=params, headers=headers)
+            retries_count += 1
+
+        if response.status_code == self.RATE_LIMIT_HTTP_CODE:
+            raise RateLimitException(message=f"Receive status_code={response.status_code} even after {retries_count} retries", response=response)
+        
+        response.raise_for_status()
+        return response.json()
+
+    def _get_params(
+        self, fn, caller_locals: Dict[str, Any], datetime_res: str = "nanos"
+    ):
+        params = {}
+        # https://docs.python.org/3.8/library/inspect.html#inspect.Signature
+        for argname, v in inspect.signature(fn).parameters.items():
+            if argname in ["max_num_pages"]: # ignore these params as they are ops params
+                continue
+
+            # Only params with default are considered part of "params"
+            if v.default is v.empty:
+                continue
+            
+            val = caller_locals.get(argname, v.default)
+            if val is None: # If val is None, we can skip this
+                continue
+
+            if isinstance(val, Enum):
+                val = val.value
+            elif isinstance(val, bool):
+                val = str(val).lower()
+            elif isinstance(val, datetime):
+                val = int(val.timestamp() * self.time_mult(datetime_res))
+
+            param_name = argname
+            for ext in ["lt", "lte", "gt", "gte", "any_of"]:
+                if argname.endswith(f"_{ext}"):
+                    param_name = argname[: -len(f"_{ext}")] + f".{ext}"
+                    break
+            if param_name.endswith(".any_of"):
+                val = ",".join(val)
+            params[param_name] = val
+
+        return params
+    
+    @staticmethod
+    def time_mult(timestamp_res: str) -> int:
+        if timestamp_res == "nanos":
+            return 1000000000
+        elif timestamp_res == "micros":
+            return 1000000
+        elif timestamp_res == "millis":
+            return 1000
+
+        return 1
+        

massive_api_client-0.0.1a0/src/massive_api_client/rest/reference.py

@@ -0,0 +1,204 @@
+from collections.abc import AsyncIterator
+from massive.rest.models import (
+    AssetClass,
+    Locale,
+    Order, 
+    Sort,
+    RelatedCompany,
+    Ticker,
+    TickerChange,
+    TickerChangeEvent,
+    TickerChangeResults,
+    TickerDetails,
+    TickerNews,
+    TickerTypes,
+)
+from typing import Any, Dict, List, Optional, Union
+
+from .base import BaseClient
+
+
+class TickersClient(BaseClient):
+    async def list_tickers(
+        self,
+        ticker: Optional[str] = None,
+        ticker_lt: Optional[str] = None,
+        ticker_lte: Optional[str] = None,
+        ticker_gt: Optional[str] = None,
+        ticker_gte: Optional[str] = None,
+        type: Optional[str] = None,
+        market: Optional[str] = None,
+        exchange: Optional[str] = None,
+        cusip: Optional[int] = None,
+        cik: Optional[int] = None,
+        date: Optional[str] = None,
+        active: Optional[bool] = None,
+        search: Optional[str] = None,
+        limit: Optional[int] = 10,
+        sort: Optional[Union[str, Sort]] = "ticker",
+        order: Optional[Union[str, Order]] = "asc",
+        max_num_pages: Optional[int] = None,
+    ) -> AsyncIterator[Ticker]:
+        """
+        Query all ticker symbols which are supported by Massive.com. This API currently includes Stocks/Equities, Indices, Forex, and Crypto.
+
+        :param ticker: Specify a ticker symbol. Defaults to empty string which queries all tickers.
+        :param ticker_lt: Ticker less than.
+        :param ticker_lte: Ticker less than or equal to.
+        :param ticker_gt: Ticker greater than.
+        :param ticker_gte: Ticker greater than or equal to.
+        :param type: Specify the type of the tickers. Find the types that we support via our Ticker Types API. Defaults to empty string which queries all types.
+        :param market: Filter by market type. By default all markets are included.
+        :param exchange: Specify the assets primary exchange Market Identifier Code (MIC) according to ISO 10383. Defaults to empty string which queries all exchanges.
+        :param cusip: Specify the CUSIP code of the asset you want to search for. Find more information about CUSIP codes at their website. Defaults to empty string which queries all CUSIPs.
+        :param cik: Specify the CIK of the asset you want to search for. Find more information about CIK codes at their website. Defaults to empty string which queries all CIKs.
+        :param date: Specify a point in time to retrieve tickers available on that date. Defaults to the most recent available date.
+        :param search: Search for terms within the ticker and/or company name.
+        :param active: Specify if the tickers returned should be actively traded on the queried date. Default is true.
+        :param limit: Limit the size of the response per-page, default is 100 and max is 1000.
+        :param sort: The field to sort the results on. Default is ticker. If the search query parameter is present, sort is ignored and results are ordered by relevance.
+        :param order: The order to sort the results on. Default is asc (ascending).
+        :return: Iterator of tickers.
+        """
+        uri = "/v3/reference/tickers"
+
+        async for r in self.request_with_pagination(
+            uri=uri, 
+            params=self._get_params(self.list_tickers, locals()), 
+            deserializer=Ticker.from_dict,
+            max_num_pages=max_num_pages,
+        ):
+            yield r
+
+    async def get_ticker_details(
+        self,
+        ticker: str,
+        date: Optional[str] = None,
+    ) -> TickerDetails:
+        """
+        Get a single ticker supported by Massive.com. This response will have detailed information about the ticker and the company behind it.
+
+        :param ticker: The ticker symbol of the asset.
+        :param date: Specify a point in time to get information about the ticker available on that date. When retrieving information from SEC filings, we compare this date with the period of report date on the SEC filing.
+        :return: Ticker Details V3
+        """
+        uri = f"/v3/reference/tickers/{ticker}"
+
+        return await self.request(
+            uri=uri, 
+            params=self._get_params(self.get_ticker_details, locals()),
+            deserializer=TickerDetails.from_dict,
+        )
+
+    async def get_ticker_events(
+        self,
+        ticker: str,
+        types: Optional[List[str]] = None,
+    ) -> TickerChangeResults:
+        """
+        Get event history of ticker given particular point in time.
+        :param ticker: The ticker symbol of the asset.
+        :param types: A comma-separated list of the types of event to include. Currently ticker_change is the only supported event_type. Leave blank to return all supported event_types.
+        :return: Ticker Event VX (Experimental)
+        """
+        uri = f"/vX/reference/tickers/{ticker}/events"
+
+        params = {"types": ",".join(types) if types is not None else ""}
+
+        def deserialize_event(e) -> TickerChangeEvent:
+            return TickerChangeEvent(
+                type=e.get("type"),
+                date=e.get("date"),
+                ticker_change=None if "ticker_change" not in e else TickerChange.from_dict(e.get("ticker_change")),
+            )
+        
+        def deserialize_result(d) -> TickerChangeResults:
+            return TickerChangeResults(
+                name=d.get("name"),
+                composite_figi=d.get("composite_figi"),
+                cik=d.get("cik"),
+                events=[deserialize_event(e) for e in d.get("events", [])]
+            )
+
+        return await self.request(
+            uri=uri, 
+            params=params,
+            deserializer=deserialize_result,
+        )
+
+    async def list_ticker_news(
+        self,
+        ticker: Optional[str] = None,
+        ticker_lt: Optional[str] = None,
+        ticker_lte: Optional[str] = None,
+        ticker_gt: Optional[str] = None,
+        ticker_gte: Optional[str] = None,
+        published_utc: Optional[str] = None,
+        published_utc_lt: Optional[str] = None,
+        published_utc_lte: Optional[str] = None,
+        published_utc_gt: Optional[str] = None,
+        published_utc_gte: Optional[str] = None,
+        limit: Optional[int] = None,
+        sort: Optional[Union[str, Sort]] = None,
+        order: Optional[Union[str, Order]] = None,
+        max_num_pages: Optional[int] = None,
+    ) -> AsyncIterator[TickerNews]:
+        """
+        Get the most recent news articles relating to a stock ticker symbol, including a summary of the article and a link to the original source.
+
+        :param ticker: Return results that contain this ticker.
+        :param published_utc: Return results published on, before, or after this date.
+        :param limit: Limit the number of results returned per-page, default is 10 and max is 1000.
+        :param sort: Sort field used for ordering.
+        :param order: Order results based on the sort field.
+        :return: Iterator of Ticker News.
+        """
+        uri = "/v2/reference/news"
+
+        async for r in self.request_with_pagination(
+            uri=uri, 
+            params=self._get_params(self.list_ticker_news, locals()), 
+            deserializer=TickerNews.from_dict,
+            max_num_pages=max_num_pages,
+        ):
+            yield r
+    
+    async def get_ticker_types(
+        self,
+        asset_class: Optional[Union[str, AssetClass]] = None,
+        locale: Optional[Union[str, Locale]] = None,
+    ) -> List[TickerTypes]:
+        """
+        List all ticker types that Massive.com has.
+
+        :param asset_class: Filter by asset class.
+        :param locale: Filter by locale.
+        :param params: Any additional query params.
+        :param raw: Return raw object instead of results object.
+        :return: Ticker Types.
+        """
+        uri = "/v3/reference/tickers/types"
+
+        return await self.request(
+            uri=uri,
+            params=self._get_params(self.get_ticker_types, locals()),
+            deserializer=TickerTypes.from_dict,
+        )
+
+    async def get_related_companies(
+        self,
+        ticker: str,
+    ) -> RelatedCompany:
+        """
+        Get a list of tickers related to the queried ticker based on News and Returns data.
+
+        :param ticker: The ticker symbol to search.
+        :return: Related Companies.
+        """
+        uri = f"/v1/related-companies/{ticker}"
+
+        return await self.request(
+            uri=uri,
+            params={},
+            deserializer=RelatedCompany.from_dict,
+        )

massive_api_client-0.0.1a0/src/massive_api_client.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: massive-api-client
+Version: 0.0.1a0
+Summary: A Python async wrapper for massive.com API
+Author: Casey Vu
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: massive>=2.4.0
+Dynamic: license-file
+
+# TODO

massive_api_client-0.0.1a0/src/massive_api_client.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/massive_api_client/__init__.py
+src/massive_api_client/config.py
+src/massive_api_client/exceptions.py
+src/massive_api_client.egg-info/PKG-INFO
+src/massive_api_client.egg-info/SOURCES.txt
+src/massive_api_client.egg-info/dependency_links.txt
+src/massive_api_client.egg-info/requires.txt
+src/massive_api_client.egg-info/top_level.txt
+src/massive_api_client/rest/__init__.py
+src/massive_api_client/rest/base.py
+src/massive_api_client/rest/reference.py

massive_api_client-0.0.1a0/src/massive_api_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

massive_api_client-0.0.1a0/src/massive_api_client.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.28.1
+massive>=2.4.0

massive_api_client-0.0.1a0/src/massive_api_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+massive_api_client