helldivepy 0.1.0__py3-none-any.whl

helldivepy/__init__.py

@@ -0,0 +1,3 @@
+from .api_client import ApiClient
+
+__all__ = ["ApiClient"]

helldivepy/api/__init__.py

@@ -0,0 +1,15 @@
+from .dispatches import DispatchModule
+from .war import WarModule
+from .steam import SteamModule
+from .assignments import AssignmentsModule
+from .planets import PlanetsModule
+from .campaigns import CampaignModule
+
+__all__ = [
+    "DispatchModule",
+    "WarModule",
+    "SteamModule",
+    "AssignmentsModule",
+    "PlanetsModule",
+    "CampaignModule",
+]

helldivepy/api/assignments.py

@@ -0,0 +1,34 @@
+from helldivepy.api.base import BaseApiModule
+import typing
+import helldivepy.models as models
+
+if typing.TYPE_CHECKING:
+    from helldivepy.api_client import ApiClient
+
+
+class AssignmentsModule(BaseApiModule):
+    """
+    The Assignments API module (Major Order). This module is used to interact with the current major order(s).
+
+    Methods:
+        get_all_assignments(): Gets all current assignments
+        get_assignment(assignment_id: int): Gets one assignment using the assignment ID
+
+    """
+
+    def __init__(self, api_client: "ApiClient") -> None:
+        super().__init__(api_client)
+
+    def get_all_assignments(self) -> typing.List[models.Assignment]:
+        """
+        Gets all current assignments
+        """
+        data = self.get("community", "api", "v1", "assignments")
+        return [models.Assignment(**assignment) for assignment in data]
+
+    def get_assignment(self, assignment_id: int) -> models.Assignment:
+        """
+        Gets one assignment using the assignment ID
+        """
+        data = self.get("community", "api", "v1", "assignments", str(assignment_id))
+        return models.Assignment(**data)

helldivepy/api/base.py

@@ -0,0 +1,41 @@
+import typing
+import requests
+from helldivepy.utils import (
+    DiveHarderAPIConnectionError,
+)
+
+if typing.TYPE_CHECKING:
+    from helldivepy.api_client import ApiClient
+
+
+class BaseApiModule:
+    """
+    The base class for all API modules.
+    """
+
+    def __init__(self, api_client: "ApiClient") -> None:
+        self.api_client = api_client
+        self.logger = api_client.logger
+        self.session = api_client.session
+        self.diveharder_url = api_client.api_config.diveharder
+        self.community_url = api_client.api_config.community
+
+    def get(self, url: typing.Literal["diveharder", "community"], *path) -> typing.Dict:
+        """
+        Sends a GET request to the specified URL.
+        """
+        try:
+            response = self.session.get(
+                url=f"{self.diveharder_url if url == 'diveharder' else self.community_url}/{'/'.join(path)}",
+                timeout=4,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            self.logger.error(f"HTTPError: {e}")
+            return {}
+        except requests.exceptions.ConnectionError as e:
+            self.logger.error(f"ConnectionError: {e}")
+            raise DiveHarderAPIConnectionError(
+                f"Failed to connect to {self.diveharder_url if url == "diveharder" else self.community_url}. (Offline?)"
+            )

helldivepy/api/campaigns.py

@@ -0,0 +1,42 @@
+from helldivepy.api.base import BaseApiModule
+import typing
+import helldivepy.models as models
+
+if typing.TYPE_CHECKING:
+    from helldivepy.api_client import ApiClient
+
+
+class CampaignModule(BaseApiModule):
+    """
+    The Campaign API module. This module is used to interact with all campaigns (Battles/Planets that are accessible).
+
+    Methods:
+        get_campaigns(): Gets all current active campaigns.
+        get_campaign(campaign_id: int): Gets a campaign by its ID.
+
+    """
+
+    def __init__(self, api_client: "ApiClient") -> None:
+        super().__init__(api_client)
+
+    def get_campaigns(self) -> typing.List[models.Campaign]:
+        """Gets all current active campaigns.
+
+        Returns:
+            typing.List[models.Campaign]: The campaigns.
+        """
+        data = self.get("community", "api", "v1", "campaigns")
+        return [models.Campaign(**campaign) for campaign in data]
+
+    def get_campaign(self, campaign_id: int) -> models.Campaign:
+        """Gets a campaign by its ID.
+
+        Args:
+            campaign_id (int): The ID of the campaign.
+
+        Returns:
+            models.Campaign: The campaign.
+        """
+        data = self.get("community", "api", "v1", "campaigns", str(campaign_id))
+
+        return models.Campaign(**data)

helldivepy/api/dispatches.py

@@ -0,0 +1,41 @@
+from helldivepy.api.base import BaseApiModule
+import typing
+import helldivepy.models as models
+
+if typing.TYPE_CHECKING:
+    from helldivepy.api_client import ApiClient
+
+
+class DispatchModule(BaseApiModule):
+    """The Dispatch API module. This module is used to interact with all dispatches (Ingame News)
+
+    Methods:
+        get_dispatches(old_to_new: bool): Gets all dispatches and orders them based on the `old_to_new` argument.
+        get_dispatch(dispatch_id: int): Gets a dispatch by its ID.
+
+    """
+
+    def __init__(self, api_client: "ApiClient") -> None:
+        super().__init__(api_client)
+
+    def get_dispatches(self, old_to_new: bool = True) -> typing.List[models.Dispatch]:
+        """
+        Gets the information about the current war.
+        """
+
+        # Sort the dispatches by published date
+        data = sorted(
+            self.get("community", "api", "v1", "dispatches"),
+            key=lambda x: x["published"],
+            reverse=not old_to_new,
+        )
+
+        return [models.Dispatch(**dispatch) for dispatch in data]
+
+    def get_dispatch(self, dispatch_id: int) -> models.Dispatch:
+        """
+        Gets the information about the current war.
+        """
+        # Get the dispatch by the ID/Index
+        data = self.get("community", "api", "v1", "dispatches", str(dispatch_id))
+        return models.Dispatch(**data)

helldivepy/api/planets.py

@@ -0,0 +1,59 @@
+from helldivepy.api.base import BaseApiModule
+import typing
+import helldivepy.models as models
+
+if typing.TYPE_CHECKING:
+    from helldivepy.api_client import ApiClient
+
+
+class PlanetsModule(BaseApiModule):
+    """
+    The Planets API module. This module is used to interact with the planets.
+
+    Methods:
+        get_planets(): Gets all planets.
+        get_planet(index: int): Gets a planet using the index.
+        get_planets_with_events(): Gets all planets with events.
+    """
+
+    def __init__(self, api_client: "ApiClient") -> None:
+        super().__init__(api_client)
+        self._planets: list[models.Planet] = []
+
+    def get_planets(self) -> typing.List[models.Planet]:
+        """Get all planets
+
+        Returns:
+            typing.List[models.Planet]: The list of planet objects
+        """
+        data = self.get("community", "api", "v1", "planets")
+
+        self._planets = [models.Planet(**planet) for planet in data]
+        return self._planets
+
+    def get_planet(self, index: int, cached: bool = False) -> models.Planet:
+        """Gets a planet using the index
+
+        Args:
+            index (int): The index of the planet
+
+        Returns:
+            models.Planet: The planet object
+        """
+        if cached:
+            if len(self._planets) < index:
+                self.logger.warning(f"Planet {index} not cached. Fetching from API.")
+                self.get_planets()
+                return self._planets[index]
+            return self._planets[index]
+        data = self.get("community", "api", "v1", "planets", str(index))
+        return models.Planet(**data)
+
+    def get_planets_with_events(self) -> typing.List[models.Planet]:
+        """Gets all planets with an active event
+
+        Returns:
+            typing.List[models.Planet]: The list of planet objects
+        """
+        data = self.get("community", "api", "v1", "planet-events")
+        return [models.Planet(**planet) for planet in data]

helldivepy/api/steam.py

@@ -0,0 +1,34 @@
+from helldivepy.api.base import BaseApiModule
+import typing
+import helldivepy.models as models
+
+if typing.TYPE_CHECKING:
+    from helldivepy.api_client import ApiClient
+
+
+class SteamModule(BaseApiModule):
+    """
+    The Steam API module. Used to get all the Game updates and News.
+
+    Methods:
+        get_all_steam_news(): Gets all the steam news.
+        get_steam_news(gid: str): Gets a steam news item by its ID.
+    """
+
+    def __init__(self, api_client: "ApiClient") -> None:
+        super().__init__(api_client)
+
+    def get_all_steam_news(self) -> typing.List[models.SteamNews]:
+        """
+        Gets the information about the current war.
+        """
+        data = self.get("community", "api", "v1", "steam")
+
+        return [models.SteamNews(**news) for news in data]
+
+    def get_steam_news(self, gid: str) -> models.SteamNews:
+        """
+        Gets the information about the current war.
+        """
+        data = self.get("community", "api", "v1", "steam", gid)
+        return models.SteamNews(**data)

helldivepy/api/war.py

@@ -0,0 +1,25 @@
+from helldivepy.api.base import BaseApiModule
+import typing
+import helldivepy.models as models
+
+if typing.TYPE_CHECKING:
+    from helldivepy.api_client import ApiClient
+
+
+class WarModule(BaseApiModule):
+    """The War module of the API. This module is used to get all info about the current war.
+
+    Methods:
+        get_war_info(): Gets the information about the current war.
+    """
+
+    def __init__(self, api_client: "ApiClient") -> None:
+        super().__init__(api_client)
+
+    def get_war_info(self) -> models.WarInfo:
+        """
+        Gets the information about the current war.
+        """
+        data = self.get("community", "api", "v1", "war")
+
+        return models.WarInfo(**data)

helldivepy/api_client.py

@@ -0,0 +1,153 @@
+import logging
+import requests
+from requests.adapters import HTTPAdapter, Retry
+from helldivepy.constants import OFFICIAL_DIVEHARDER_URL, OFFICIAL_COMMUNITY_URL
+import helldivepy.models as models
+import typing
+import helldivepy.api as modules
+
+
+def retry_adapter(
+    backoff_factor: float, retries: int, extra_retry_codes: list | None = None
+) -> HTTPAdapter:
+    """Configures an HTTP adapter with retries and backoff."""
+    if extra_retry_codes is None:
+        extra_retry_codes = []
+    retry_codes = [429] + extra_retry_codes
+    retry_strategy = Retry(
+        total=retries,
+        status_forcelist=retry_codes,
+        backoff_factor=backoff_factor,
+        allowed_methods=["GET"],
+    )
+    return HTTPAdapter(max_retries=retry_strategy)
+
+
+def set_logger(debug: bool) -> logging.Logger:
+    """Configures debug logging if requested."""
+    from rich.logging import RichHandler
+
+    logger = logging.getLogger(__name__)
+    logger.level = logging.DEBUG if debug else 5000
+    if debug:
+        logger.addHandler(
+            RichHandler(
+                level=logging.DEBUG,
+                omit_repeated_times=False,
+                markup=True,
+                rich_tracebacks=True,
+                log_time_format="%X %p",
+            )
+        )
+    return logger
+
+
+class ModuleDict(typing.TypedDict):
+    """A dictionary of modules."""
+
+    war: modules.WarModule
+    dispatch: modules.DispatchModule
+    steam: modules.SteamModule
+    assignments: modules.AssignmentsModule
+    planets: modules.PlanetsModule
+    campaigns: modules.CampaignModule
+
+
+class ApiClient:
+    """
+    The client used to interact with the Helldivers 2 APIs
+    """
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs) -> typing.Self:
+        if cls._instance is None:
+            cls._instance = super(ApiClient, cls).__new__(cls)
+            cls._instance.__init__(*args, **kwargs)
+        return cls._instance
+
+    @classmethod
+    def get_client(cls):
+        return cls._instance
+
+    def __init__(
+        self,
+        user_agent: str,
+        user_contact: str,
+        debug: bool = False,
+        diveharder_url: str = OFFICIAL_DIVEHARDER_URL,
+        community_url: str = OFFICIAL_COMMUNITY_URL,
+    ) -> None:
+        """The client used to interact with the Helldivers 2 APIs
+
+        Args:
+            user_agent (str): The user agent to use when making requests.
+            user_contact (str): The user contact to use when making requests.
+            debug (bool, optional): Enables debug logging for development.
+            diveharder_url (str, optional): The diveharder API url to use. Defaults to `constants.OFFICIAL_DIVEHARDER_URL`.
+            community_url (str, optional): The community API url to use. Defaults to `constants.OFFICIAL_COMMUNITY_URL`.
+        """
+        self.debug = debug
+        self.logger = set_logger(debug)
+        self.api_config = models.APIURLConfiguration(
+            diveharder=diveharder_url, community=community_url
+        )
+        self._user_contact = user_contact
+        self._user_agent = user_agent
+        self._setup_session()
+        self._modules = ModuleDict(
+            war=modules.WarModule(self),
+            dispatch=modules.DispatchModule(self),
+            steam=modules.SteamModule(self),
+            assignments=modules.AssignmentsModule(self),
+            planets=modules.PlanetsModule(self),
+            campaigns=modules.CampaignModule(self),
+        )
+
+    def _setup_session(self):
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "User-Agent": self._user_agent,
+                "X-Super-Client": self._user_agent,
+                "X-Super-Contact": self._user_contact,
+            }
+        )
+        self.session.mount("https://", retry_adapter(0.2, 2))
+        self.session.mount("http://", retry_adapter(0.2, 2))
+
+    def get_war_info(self) -> models.WarInfo:
+        return self._modules["war"].get_war_info()
+
+    # ==============[Modules]==============
+
+    @property
+    def war(self) -> modules.WarModule:
+        return self._modules["war"]
+
+    @property
+    def dispatch(self) -> modules.DispatchModule:
+        return self._modules["dispatch"]
+
+    @property
+    def steam(self) -> modules.SteamModule:
+        return self._modules["steam"]
+
+    @property
+    def assignments(self) -> modules.AssignmentsModule:
+        return self._modules["assignments"]
+
+    @property
+    def major_orders(self) -> modules.AssignmentsModule:
+        return self.assignments
+
+    @property
+    def planets(self) -> modules.PlanetsModule:
+        return self._modules["planets"]
+
+    @property
+    def campaigns(self) -> modules.CampaignModule:
+        return self._modules["campaigns"]
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.api_config})"

helldivepy/constants.py

@@ -0,0 +1,3 @@
+OFFICIAL_DIVEHARDER_URL = "https://api.diveharder.com"
+OFFICIAL_COMMUNITY_URL = "https://api.helldivers2.dev"
+FACTIONS = {1: "Humans", 2: "Terminids", 3: "Automaton", 4: "Illuminate"}

helldivepy/enums.py

@@ -0,0 +1,44 @@
+from enum import Enum
+import typing
+
+# {"1": "race", "2": "unknown", "3": "goal", "11": "liberate", "12": "planet_index"}
+
+
+class BetterEnum(Enum):
+    @classmethod
+    def parse(cls, value):
+        try:
+            return cls(value)
+        except ValueError:
+            return None
+
+
+class CampaignTypes(BetterEnum):
+
+    LIBERATION_DEFENSE = 0
+    RECON = 1
+    STORY = 2
+
+
+class ValueTypes(BetterEnum):
+    RACE = 1
+    UNKNOWN = 2
+    TARGET_COUNT = 3
+    UNIT_ID = 4
+    ITEM_ID = 5
+    LIBERATE = 11
+    PLANET = 12
+
+
+class RewardTypes(BetterEnum):
+    MEDALS = 1
+
+
+class AssignmentTypes(BetterEnum):
+    ERADICATE = 3
+    LIBERATION = 11
+    DEFENSE = 12
+    CONTROL = 13
+
+
+FactionType = typing.Literal["Humans", "Terminids", "Automaton", "Illuminate"]

helldivepy/models.py

@@ -0,0 +1,208 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+import typing
+import helldivepy.enums as enums
+import helldivepy.utils as utils
+
+
+class APIURLConfiguration(BaseModel):
+    diveharder: str
+    community: str
+
+
+class Statistics(BaseModel):
+    """The statistics of a player."""
+
+    missions_won: int = Field(alias="missionsWon")
+    missions_lost: int = Field(alias="missionsLost")
+    mission_time: int = Field(alias="missionTime")
+    terminid_kills: int = Field(alias="terminidKills")
+    automaton_kills: int = Field(alias="automatonKills")
+    illuminate_kills: int = Field(alias="illuminateKills")
+    bullets_fired: int = Field(alias="bulletsFired")
+    bullets_hit: int = Field(alias="bulletsHit")
+    time_played: int = Field(alias="timePlayed")
+    deaths: int
+    revives: int
+    friendlies: int
+    mission_success_rate: float = Field(alias="missionSuccessRate")
+    accuracy: int
+    player_count: int = Field(alias="playerCount")
+
+
+class WarInfo(BaseModel):
+    """The information about the current war."""
+
+    started: datetime
+    ended: datetime
+    now: datetime
+    client_version: str = Field(alias="clientVersion")
+    factions: list[typing.Literal["Humans", "Terminids", "Automaton", "Illuminate"]]
+    impact_multiplier: float = Field(alias="impactMultiplier")
+    statistics: Statistics
+
+
+class Dispatch(BaseModel):
+    """The information about the current war."""
+
+    id: int
+    published: datetime
+    type: typing.Literal[0]
+    message: str
+
+
+class SteamNews(BaseModel):
+    """Steam patchh notes."""
+
+    id: str
+    title: str
+    url: str
+    author: str
+    content: str
+    published_at: datetime = Field(alias="publishedAt")
+
+
+class PlanetEvent(BaseModel):
+    """An event on a planet."""
+
+    id: int
+    event_type: typing.Literal[1] = Field(alias="eventType")
+    faction: enums.FactionType
+    health: int
+    max_health: int = Field(alias="maxHealth")
+    start_time: datetime = Field(alias="startTime")
+    end_time: datetime = Field(alias="endTime")
+    campaign_id: int = Field(alias="campaignId")
+    joint_operation_ids: list[int] = Field(alias="jointOperationIds")
+
+    @property
+    def planet(self) -> "Planet | None":
+        from helldivepy import ApiClient
+
+        if ApiClient._instance:
+            return ApiClient._instance.planets.get_planet(self.campaign_id)
+        return None
+
+
+class Position(BaseModel):
+    """A position in the game."""
+
+    x: float
+    y: float
+
+
+class PlanetaryHazard(BaseModel):
+    """A hazard on a planet."""
+
+    name: str
+    description: str
+
+
+class Biome(BaseModel):
+    """A biome on a planet."""
+
+    name: str
+    description: str
+
+
+class Planet(BaseModel):
+    """A planet in the game."""
+
+    index: int
+    name: str
+    sector: str
+    biome: "Biome"
+    hazards: list["PlanetaryHazard"]
+    hash: int
+    position: "Position"
+    waypoints: list[int]
+    max_health: int = Field(alias="maxHealth")
+    health: int
+    disabled: bool
+    initial_owner: enums.FactionType = Field(
+        alias="initialOwner",
+    )
+    current_owner: enums.FactionType = Field(alias="currentOwner")
+    regen_per_second: float = Field(alias="regenPerSecond")
+    event: PlanetEvent | None
+    statistics: Statistics
+    attacking: list[int]
+
+
+# TODO: make better docstrings
+class AssignmentTaskData(BaseModel):
+    liberate: bool | None
+    planet: Planet | None
+    target_count: int | None
+    race: enums.FactionType | None
+
+
+class AssignmentTask(BaseModel):
+    """A task in an assignment"""
+
+    type: enums.AssignmentTypes
+    values: list[int]
+    value_types: list[enums.ValueTypes] = Field(alias="valueTypes")
+    data: AssignmentTaskData = AssignmentTaskData(
+        liberate=None, planet=None, target_count=None, race=None
+    )
+
+    def model_post_init(self, __context: typing.Any) -> None:
+        from helldivepy.api_client import ApiClient
+
+        client = ApiClient._instance
+        if client is None:
+            raise ValueError("ApiClient is not initialized")
+
+        for k, v in zip(self.value_types, self.values):
+            match k:
+                case enums.ValueTypes.PLANET:
+                    self.data.planet = client.planets.get_planet(v, cached=True)
+                case enums.ValueTypes.RACE:
+                    self.data.race = utils.parse_faction(v)
+                case enums.ValueTypes.TARGET_COUNT:
+                    self.data.target_count = v
+                case enums.ValueTypes.LIBERATE:
+                    self.data.liberate = bool(v)
+
+
+class AssignmentReward(BaseModel):
+    """
+    A reward in an assignment\n
+    Medals: 1
+    """
+
+    type: typing.Literal[1]
+    amount: int
+
+
+class Assignment(BaseModel):
+    """An assignment (Major Order)"""
+
+    id: int
+    progress: list[int]
+    title: str | None = None
+    briefing: str | None = None
+    description: str | None = None
+    tasks: list[AssignmentTask]
+    reward: AssignmentReward
+    expiration: datetime
+
+    @property
+    def is_complete(self) -> bool:
+        return all(
+            task.data.target_count == self.progress[index]
+            for index, task in enumerate(self.tasks)
+        )
+
+    def __str__(self) -> str:
+        return f"{self.title} - {self.briefing}"
+
+
+class Campaign(BaseModel):
+    """A campaign or battle in the game."""
+
+    id: int
+    planet: Planet
+    type: int
+    count: int

helldivepy/utils.py

@@ -0,0 +1,60 @@
+import re
+from helldivepy.constants import FACTIONS
+import helldivepy.enums as enums
+
+
+def hdml_to_md(text: str) -> str:
+    """
+    Converts a string in HDML (DiveHarder Markup Language) format to Markdown format.
+
+    Args:
+        text (str): The input string in HDML format.
+
+    Returns:
+        str: The input string converted to Markdown format.
+
+    Example:
+        >>> hdml_to_md("<i=3>Hello</i=3> <i=1>World</i=1>")
+        "[b]Hello[/b] [yellow]World[/yellow]"
+    """
+
+    pattern = r"<i=(\d+)>(.*?)<\/i(?:=\1)?>"
+    matches = re.findall(pattern, text)
+
+    modified_text = text
+    for match in matches:
+        if match[0] == "3":
+            modified_text = modified_text.replace(match[1], f"[b]{match[1]}[/b]")
+        elif match[0] == "1":
+            modified_text = modified_text.replace(
+                match[1], f"[yellow]{match[1]}[/yellow]"
+            )
+
+    modified_text = re.sub(r"<\/?i(?:=\d+)?>", "", modified_text)
+
+    return modified_text
+
+
+def url_join(*args):
+    """Join combine URL parts to get the full endpoint address."""
+    return "/".join(arg.strip("/") for arg in args)
+
+
+def parse_faction(faction: int) -> enums.FactionType | None:
+    """Parse faction ID to string
+
+    Args:
+        faction (int): The faction ID
+
+    Returns:
+        str: The faction name
+    """
+    return FACTIONS.get(faction, None)  # type: ignore
+
+
+class DiveHarderException(Exception):
+    """Base exception for all DiveHarder exceptions."""
+
+
+class DiveHarderAPIConnectionError(DiveHarderException):
+    """Exception raised when the DiveHarder API connection fails."""

helldivepy-0.1.0.dist-info/LICENSE

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

helldivepy-0.1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: helldivepy
+Version: 0.1.0
+Summary: A Helldivers 2 API wrapper using the Diveharder API and the Helldivers Community API
+License: MIT
+Keywords: helldivers 2,api,wrapper,diveharder,community
+Author: AJXD2
+Author-email: aj@ajxd2.dev
+Requires-Python: >=3.11,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Dist: fire (>=0.7.0,<0.8.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: rich (>=13.9.3,<14.0.0)
+Project-URL: documentation, https://github.com/ajxd2/helldive.py#readme
+Project-URL: homepage, https://github.com/ajxd2/helldive.py
+Project-URL: repository, https://github.com/ajxd2/helldive.py
+Description-Content-Type: text/markdown
+
+# Helldive.py
+
+[![PyPI](https://img.shields.io/pypi/v/helldivepy.svg?label=PyPI&color=blue)](https://pypi.org/project/helldivepy/)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/helldivepy?color=brightgreen)
+![GitHub License](https://img.shields.io/github/license/ajxd2/helldive.py?color=yellow)
+[![Python Versions](https://img.shields.io/pypi/pyversions/helldivepy.svg?color=orange)](https://pypi.org/project/helldivepy/)
+![GitHub contributors](https://img.shields.io/github/contributors/ajxd2/helldive.py?color=ff69b4)
+
+> A simple Python library for diving deep into the [Helldivers Community API](https://github.com/helldivers-2/api) and [Diveharder API](https://github.com/helldivers-2/diveharder_api.py).
+
+---
+
+## ⚙️ Installation
+
+To install **Helldive.py**, just use pip:
+
+```bash
+pip install helldive.py
+```
+
+## 🚀 Quickstart
+
+Here's a super-quick example to get you diving right in:
+
+```python
+import helldivepy
+
+client = helldivepy.ApiClient(user_agent="my-app", user_contact="email@example.com")
+
+# Get the latest dispatches
+dispatches = client.dispatch.get_dispatches()
+
+print(dispatches)
+# Output example
+[
+   Dispatch(id=0, published=datetime.datetime, type=0, message='Hello, World 1!'),
+   Dispatch(id=1, published=datetime.datetime, type=0, message='Hello, World 2!'),
+   Dispatch(id=2, published=datetime.datetime, type=0, message='Hello, World 3!')
+ ]
+```
+
+## 🌟 Features
+
+- **Easy API Access**: Communicate with the Helldivers Community API and Diveharder API without breaking a sweat.
+- **Typed Data**: Get structured, easily readable data like dispatches, planets, and more!
+- **Perfect for Projects**: Ideal for projects, bots, or just exploring Helldivers data.
+
+---
+
+## 🛠️ Contributing
+
+Contributions are always welcome! If you’d like to make changes, feel free to submit a pull request. For major updates, open an issue first to discuss your ideas.
+
+## 📄 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+

helldivepy-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+helldivepy/__init__.py,sha256=z24Nm7mo0d5KRZfgPnoD-CZL-2SICDfYENZgmNseD5o,59
+helldivepy/api/__init__.py,sha256=uVpko11fzttXInMcfHfgyDVMGF6r-nlOB1isIkl-YZY,354
+helldivepy/api/assignments.py,sha256=-hpvQ2zwc1VAoLHuNPtyRUndTbeMKqqrvjPfEgBxLps,1138
+helldivepy/api/base.py,sha256=Rl4CCemDtYlB-P8p6soUprbAvJxSuCYUR5Wdm1AtWkI,1412
+helldivepy/api/campaigns.py,sha256=w49_uLm13US9rv1Dc0Oz5vweGfLLo9Oiwzv7Rsq5PiA,1272
+helldivepy/api/dispatches.py,sha256=pJLPgqSELSLSkIgpgI09RqQB3wP8cqUZMKYNiz3YkqM,1364
+helldivepy/api/planets.py,sha256=tnComjOJAjSnAgkpT8335IYagbJ0Fi8f093YsNonc1Y,1947
+helldivepy/api/steam.py,sha256=TVHb9kMnya0HTggKdfiR9nUJU_AHUUJSPm4yh_5An50,1026
+helldivepy/api/war.py,sha256=m2Ql6o1hlHDObff-AuzfLSx8jvg38tEWzA-p-pl6le0,700
+helldivepy/api_client.py,sha256=kUn85aOXTNtUeMqU3zNdOrocSxgTANWN6Ac89woAw6E,4821
+helldivepy/constants.py,sha256=Ua5L5SfxoEn5SQNn5j-Mk0xZbJQr96TdiV89vVoCJvs,184
+helldivepy/enums.py,sha256=si8sY-El8pFeJsRdNf3ATwpmF9dzRweWqRhEn5xmNOE,763
+helldivepy/models.py,sha256=BUgC6HfRLPo0XKd-kF_Vtd3e9aT8sdHyWIrL7tkD3Cg,5328
+helldivepy/utils.py,sha256=J8UEBHCD_09LjDXmmcdSNZUbbGkdjw_zEzKxHNQvFq0,1593
+helldivepy-0.1.0.dist-info/LICENSE,sha256=lk4otsNbLY8RPt0j7CvbelwWXeOZsXRIkaublucGr-w,1062
+helldivepy-0.1.0.dist-info/METADATA,sha256=kO3LrG-8SFnnol9NuigRd4n89uxSq_7tTk9nOclk1vg,3093
+helldivepy-0.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+helldivepy-0.1.0.dist-info/RECORD,,

helldivepy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any