python-eveonline 0.1.0__py3-none-any.whl

eveonline/__init__.py

@@ -0,0 +1,22 @@
+"""Async Python client for the Eve Online ESI API."""
+
+from .auth import AbstractAuth
+from .client import EveOnlineClient
+from .exceptions import (
+    EveOnlineAuthenticationError,
+    EveOnlineConnectionError,
+    EveOnlineError,
+    EveOnlineRateLimitError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AbstractAuth",
+    "EveOnlineAuthenticationError",
+    "EveOnlineClient",
+    "EveOnlineConnectionError",
+    "EveOnlineError",
+    "EveOnlineRateLimitError",
+    "__version__",
+]

eveonline/auth.py

@@ -0,0 +1,68 @@
+"""Abstract authentication for the Eve Online ESI API."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from aiohttp import ClientResponse, ClientSession
+
+from .const import ESI_BASE_URL
+
+
+class AbstractAuth(ABC):
+    """Abstract class to make authenticated requests to the ESI API.
+
+    This follows the Home Assistant API library pattern where the library
+    provides an abstract auth class, and the integration (or standalone user)
+    provides a concrete implementation that handles token management.
+
+    Example usage::
+
+        class MyAuth(AbstractAuth):
+            async def async_get_access_token(self) -> str:
+                return self._my_token_manager.get_token()
+
+        auth = MyAuth(session)
+        client = EveOnlineClient(auth=auth)
+    """
+
+    def __init__(
+        self,
+        websession: ClientSession,
+        host: str = ESI_BASE_URL,
+    ) -> None:
+        """Initialize the auth.
+
+        Args:
+            websession: An aiohttp ClientSession for making requests.
+            host: The ESI API base URL. Defaults to the official ESI endpoint.
+        """
+        self.websession = websession
+        self.host = host
+
+    @abstractmethod
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token for the ESI API."""
+
+    async def request(self, method: str, path: str, **kwargs: Any) -> ClientResponse:
+        """Make an authenticated request to the ESI API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.).
+            path: API path (e.g., "characters/12345/wallet/").
+            **kwargs: Additional arguments passed to aiohttp request.
+
+        Returns:
+            The aiohttp ClientResponse.
+        """
+        headers: dict[str, str] = dict(kwargs.pop("headers", {}) or {})
+        access_token = await self.async_get_access_token()
+        headers["authorization"] = f"Bearer {access_token}"
+
+        return await self.websession.request(
+            method,
+            f"{self.host}/{path}",
+            **kwargs,
+            headers=headers,
+        )

eveonline/client.py

@@ -0,0 +1,364 @@
+"""Async client for the Eve Online ESI API."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from aiohttp import ClientSession
+
+from .auth import AbstractAuth
+from .const import ESI_BASE_URL, ESI_DATASOURCE
+from .exceptions import (
+    EveOnlineAuthenticationError,
+    EveOnlineConnectionError,
+    EveOnlineError,
+    EveOnlineNotFoundError,
+    EveOnlineRateLimitError,
+)
+from .models import (
+    CharacterLocation,
+    CharacterOnlineStatus,
+    CharacterPortrait,
+    CharacterPublicInfo,
+    CharacterShip,
+    CorporationPublicInfo,
+    ServerStatus,
+    SkillQueueEntry,
+    UniverseName,
+    WalletBalance,
+)
+
+
+class EveOnlineClient:
+    """Async client for the Eve Online ESI API.
+
+    This client supports two modes:
+
+    1. **Unauthenticated**: For public endpoints (server status, character
+       public info, corporation info, universe lookups). Only requires an
+       aiohttp session.
+
+    2. **Authenticated**: For character-specific endpoints (online status,
+       wallet, location, skills). Requires an ``AbstractAuth`` implementation
+       that provides access tokens.
+
+    Example (unauthenticated)::
+
+        async with aiohttp.ClientSession() as session:
+            client = EveOnlineClient(session=session)
+            status = await client.async_get_server_status()
+            print(f"Players online: {status.players}")
+
+    Example (authenticated)::
+
+        auth = MyAuth(session)  # Your AbstractAuth implementation
+        client = EveOnlineClient(auth=auth)
+        online = await client.async_get_character_online(character_id)
+        print(f"Online: {online.online}")
+    """
+
+    def __init__(
+        self,
+        session: ClientSession | None = None,
+        auth: AbstractAuth | None = None,
+        host: str = ESI_BASE_URL,
+    ) -> None:
+        """Initialize the client.
+
+        Args:
+            session: aiohttp session for unauthenticated requests.
+                     If ``auth`` is provided, its session is used instead.
+            auth: Authentication provider for authenticated endpoints.
+            host: ESI API base URL. Defaults to the official ESI endpoint.
+        """
+        self._auth = auth
+        self._host = host
+
+        if auth is not None:
+            self._session = auth.websession
+        elif session is not None:
+            self._session = session
+        else:
+            msg = "Either 'session' or 'auth' must be provided"
+            raise EveOnlineError(msg)
+
+    # -------------------------------------------------------------------------
+    # Internal helpers
+    # -------------------------------------------------------------------------
+
+    async def _request(self, method: str, path: str, *, authenticated: bool = False, **kwargs: Any) -> Any:
+        """Make a request to the ESI API.
+
+        Args:
+            method: HTTP method.
+            path: API path relative to ESI base URL.
+            authenticated: Whether this request requires authentication.
+            **kwargs: Additional arguments for the HTTP request.
+
+        Returns:
+            Parsed JSON response.
+
+        Raises:
+            EveOnlineAuthenticationError: If auth is required but not provided,
+                or if the token is invalid/expired.
+            EveOnlineConnectionError: If the ESI API is unreachable.
+            EveOnlineRateLimitError: If the rate limit is exceeded.
+            EveOnlineNotFoundError: If the resource is not found.
+            EveOnlineError: For other ESI API errors.
+        """
+        params: dict[str, Any] = dict(kwargs.pop("params", {}) or {})
+        params.setdefault("datasource", ESI_DATASOURCE)
+
+        try:
+            if authenticated:
+                if self._auth is None:
+                    msg = "Authentication required but no auth provider configured"
+                    raise EveOnlineAuthenticationError(msg)
+                response = await self._auth.request(method, path, params=params, **kwargs)
+            else:
+                response = await self._session.request(
+                    method,
+                    f"{self._host}/{path}",
+                    params=params,
+                    **kwargs,
+                )
+        except EveOnlineError:
+            raise
+        except Exception as err:
+            msg = f"Failed to connect to ESI API: {err}"
+            raise EveOnlineConnectionError(msg) from err
+
+        if response.status in (401, 403):
+            text = await response.text()
+            msg = f"Authentication failed ({response.status}): {text}"
+            raise EveOnlineAuthenticationError(msg)
+
+        if response.status == 404:
+            msg = f"Resource not found: {path}"
+            raise EveOnlineNotFoundError(msg)
+
+        if response.status in (420, 429):
+            retry_after = response.headers.get("Retry-After")
+            raise EveOnlineRateLimitError(retry_after=int(retry_after) if retry_after else None)
+
+        if response.status >= 400:
+            text = await response.text()
+            msg = f"ESI API error ({response.status}): {text}"
+            raise EveOnlineError(msg)
+
+        return await response.json()
+
+    @staticmethod
+    def _parse_datetime(value: str | None) -> datetime | None:
+        """Parse an ISO8601 datetime string from ESI."""
+        if value is None:
+            return None
+        # ESI returns times like "2025-01-15T12:34:56Z"
+        return datetime.fromisoformat(value.replace("Z", "+00:00"))
+
+    # -------------------------------------------------------------------------
+    # Public endpoints (no auth required)
+    # -------------------------------------------------------------------------
+
+    async def async_get_server_status(self) -> ServerStatus:
+        """Get the current Tranquility server status.
+
+        Returns:
+            ServerStatus with player count, version, and start time.
+        """
+        data = await self._request("GET", "status/")
+        return ServerStatus(
+            players=data["players"],
+            server_version=data["server_version"],
+            start_time=datetime.fromisoformat(data["start_time"].replace("Z", "+00:00")),
+            vip=data.get("vip"),
+        )
+
+    async def async_get_character_public(self, character_id: int) -> CharacterPublicInfo:
+        """Get public information about a character.
+
+        Args:
+            character_id: The Eve Online character ID.
+
+        Returns:
+            CharacterPublicInfo with name, corporation, and more.
+        """
+        data = await self._request("GET", f"characters/{character_id}/")
+        return CharacterPublicInfo(
+            character_id=character_id,
+            name=data["name"],
+            corporation_id=data["corporation_id"],
+            birthday=datetime.fromisoformat(data["birthday"].replace("Z", "+00:00")),
+            gender=data["gender"],
+            race_id=data["race_id"],
+            bloodline_id=data["bloodline_id"],
+            ancestry_id=data.get("ancestry_id"),
+            alliance_id=data.get("alliance_id"),
+            faction_id=data.get("faction_id"),
+            description=data.get("description"),
+            title=data.get("title"),
+            security_status=data.get("security_status"),
+        )
+
+    async def async_get_character_portrait(self, character_id: int) -> CharacterPortrait:
+        """Get a character's portrait URLs.
+
+        Args:
+            character_id: The Eve Online character ID.
+
+        Returns:
+            CharacterPortrait with image URLs at various resolutions.
+        """
+        data = await self._request("GET", f"characters/{character_id}/portrait/")
+        return CharacterPortrait(
+            px64x64=data.get("px64x64"),
+            px128x128=data.get("px128x128"),
+            px256x256=data.get("px256x256"),
+            px512x512=data.get("px512x512"),
+        )
+
+    async def async_get_corporation_public(self, corporation_id: int) -> CorporationPublicInfo:
+        """Get public information about a corporation.
+
+        Args:
+            corporation_id: The Eve Online corporation ID.
+
+        Returns:
+            CorporationPublicInfo with name, ticker, member count, and more.
+        """
+        data = await self._request("GET", f"corporations/{corporation_id}/")
+        return CorporationPublicInfo(
+            corporation_id=corporation_id,
+            name=data["name"],
+            ticker=data["ticker"],
+            member_count=data["member_count"],
+            ceo_id=data["ceo_id"],
+            tax_rate=data["tax_rate"],
+            alliance_id=data.get("alliance_id"),
+            description=data.get("description"),
+            date_founded=self._parse_datetime(data.get("date_founded")),
+            url=data.get("url"),
+        )
+
+    async def async_resolve_names(self, ids: list[int]) -> list[UniverseName]:
+        """Resolve a list of IDs to names.
+
+        Args:
+            ids: List of Eve Online entity IDs (characters, corps, etc.).
+
+        Returns:
+            List of UniverseName with id, name, and category.
+        """
+        if not ids:
+            return []
+
+        data = await self._request("POST", "universe/names/", json=ids)
+        return [
+            UniverseName(
+                id=entry["id"],
+                name=entry["name"],
+                category=entry["category"],
+            )
+            for entry in data
+        ]
+
+    # -------------------------------------------------------------------------
+    # Authenticated endpoints (auth required)
+    # -------------------------------------------------------------------------
+
+    async def async_get_character_online(self, character_id: int) -> CharacterOnlineStatus:
+        """Get a character's online status.
+
+        Requires scope: ``esi-location.read_online.v1``
+
+        Args:
+            character_id: The Eve Online character ID.
+
+        Returns:
+            CharacterOnlineStatus with online flag and login/logout times.
+        """
+        data = await self._request("GET", f"characters/{character_id}/online/", authenticated=True)
+        return CharacterOnlineStatus(
+            online=data["online"],
+            last_login=self._parse_datetime(data.get("last_login")),
+            last_logout=self._parse_datetime(data.get("last_logout")),
+            logins=data.get("logins"),
+        )
+
+    async def async_get_character_location(self, character_id: int) -> CharacterLocation:
+        """Get a character's current location.
+
+        Requires scope: ``esi-location.read_location.v1``
+
+        Args:
+            character_id: The Eve Online character ID.
+
+        Returns:
+            CharacterLocation with solar system, station, or structure ID.
+        """
+        data = await self._request("GET", f"characters/{character_id}/location/", authenticated=True)
+        return CharacterLocation(
+            solar_system_id=data["solar_system_id"],
+            station_id=data.get("station_id"),
+            structure_id=data.get("structure_id"),
+        )
+
+    async def async_get_character_ship(self, character_id: int) -> CharacterShip:
+        """Get a character's current ship.
+
+        Requires scope: ``esi-location.read_ship_type.v1``
+
+        Args:
+            character_id: The Eve Online character ID.
+
+        Returns:
+            CharacterShip with ship type, item ID, and name.
+        """
+        data = await self._request("GET", f"characters/{character_id}/ship/", authenticated=True)
+        return CharacterShip(
+            ship_type_id=data["ship_type_id"],
+            ship_item_id=data["ship_item_id"],
+            ship_name=data["ship_name"],
+        )
+
+    async def async_get_wallet_balance(self, character_id: int) -> WalletBalance:
+        """Get a character's wallet balance.
+
+        Requires scope: ``esi-wallet.read_character_wallet.v1``
+
+        Args:
+            character_id: The Eve Online character ID.
+
+        Returns:
+            WalletBalance with ISK balance.
+        """
+        data = await self._request("GET", f"characters/{character_id}/wallet/", authenticated=True)
+        # Wallet endpoint returns a raw float, not a JSON object
+        return WalletBalance(balance=float(data))
+
+    async def async_get_skill_queue(self, character_id: int) -> list[SkillQueueEntry]:
+        """Get a character's skill training queue.
+
+        Requires scope: ``esi-skills.read_skillqueue.v1``
+
+        Args:
+            character_id: The Eve Online character ID.
+
+        Returns:
+            List of SkillQueueEntry, ordered by queue_position.
+        """
+        data = await self._request("GET", f"characters/{character_id}/skillqueue/", authenticated=True)
+        return [
+            SkillQueueEntry(
+                skill_id=entry["skill_id"],
+                queue_position=entry["queue_position"],
+                finished_level=entry["finished_level"],
+                start_date=self._parse_datetime(entry.get("start_date")),
+                finish_date=self._parse_datetime(entry.get("finish_date")),
+                training_start_sp=entry.get("training_start_sp"),
+                level_start_sp=entry.get("level_start_sp"),
+                level_end_sp=entry.get("level_end_sp"),
+            )
+            for entry in data
+        ]

eveonline/const.py

@@ -0,0 +1,34 @@
+"""Constants for the Eve Online ESI API."""
+
+from typing import Final
+
+# ESI API
+ESI_BASE_URL: Final = "https://esi.evetech.net/latest"
+ESI_DATASOURCE: Final = "tranquility"
+
+# EVE SSO
+SSO_AUTHORIZE_URL: Final = "https://login.eveonline.com/v2/oauth/authorize"
+SSO_TOKEN_URL: Final = "https://login.eveonline.com/v2/oauth/token"
+SSO_JWKS_URL: Final = "https://login.eveonline.com/oauth/jwks"
+
+# Scopes
+SCOPE_READ_ONLINE: Final = "esi-location.read_online.v1"
+SCOPE_READ_LOCATION: Final = "esi-location.read_location.v1"
+SCOPE_READ_SHIP_TYPE: Final = "esi-location.read_ship_type.v1"
+SCOPE_READ_WALLET: Final = "esi-wallet.read_character_wallet.v1"
+SCOPE_READ_SKILLS: Final = "esi-skills.read_skills.v1"
+SCOPE_READ_SKILLQUEUE: Final = "esi-skills.read_skillqueue.v1"
+SCOPE_READ_KILLMAILS: Final = "esi-killmails.read_killmails.v1"
+SCOPE_READ_CLONES: Final = "esi-clones.read_clones.v1"
+SCOPE_READ_IMPLANTS: Final = "esi-clones.read_implants.v1"
+SCOPE_READ_NOTIFICATIONS: Final = "esi-characters.read_notifications.v1"
+
+# Default scopes for a typical Home Assistant integration
+DEFAULT_SCOPES: Final = [
+    SCOPE_READ_ONLINE,
+    SCOPE_READ_LOCATION,
+    SCOPE_READ_SHIP_TYPE,
+    SCOPE_READ_WALLET,
+    SCOPE_READ_SKILLS,
+    SCOPE_READ_SKILLQUEUE,
+]

eveonline/exceptions.py

@@ -0,0 +1,29 @@
+"""Exceptions for the Eve Online ESI client."""
+
+
+class EveOnlineError(Exception):
+    """Base exception for Eve Online ESI errors."""
+
+
+class EveOnlineConnectionError(EveOnlineError):
+    """Exception raised when the ESI API is unreachable."""
+
+
+class EveOnlineAuthenticationError(EveOnlineError):
+    """Exception raised when authentication fails or token is invalid."""
+
+
+class EveOnlineRateLimitError(EveOnlineError):
+    """Exception raised when the ESI rate limit is exceeded."""
+
+    def __init__(self, retry_after: int | None = None) -> None:
+        """Initialize the rate limit error."""
+        self.retry_after = retry_after
+        message = "ESI rate limit exceeded"
+        if retry_after is not None:
+            message += f", retry after {retry_after}s"
+        super().__init__(message)
+
+
+class EveOnlineNotFoundError(EveOnlineError):
+    """Exception raised when a resource is not found (404)."""

eveonline/models.py

@@ -0,0 +1,119 @@
+"""Data models for the Eve Online ESI API."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass(frozen=True)
+class ServerStatus:
+    """EVE Online server (Tranquility) status."""
+
+    players: int
+    server_version: str
+    start_time: datetime
+    vip: bool | None = None
+
+
+@dataclass(frozen=True)
+class CharacterPublicInfo:
+    """Public character information (no auth required)."""
+
+    character_id: int
+    name: str
+    corporation_id: int
+    birthday: datetime
+    gender: str
+    race_id: int
+    bloodline_id: int
+    ancestry_id: int | None = None
+    alliance_id: int | None = None
+    faction_id: int | None = None
+    description: str | None = None
+    title: str | None = None
+    security_status: float | None = None
+
+
+@dataclass(frozen=True)
+class CharacterPortrait:
+    """Character portrait URLs."""
+
+    px64x64: str | None = None
+    px128x128: str | None = None
+    px256x256: str | None = None
+    px512x512: str | None = None
+
+
+@dataclass(frozen=True)
+class CorporationPublicInfo:
+    """Public corporation information (no auth required)."""
+
+    corporation_id: int
+    name: str
+    ticker: str
+    member_count: int
+    ceo_id: int
+    tax_rate: float
+    alliance_id: int | None = None
+    description: str | None = None
+    date_founded: datetime | None = None
+    url: str | None = None
+
+
+@dataclass(frozen=True)
+class CharacterOnlineStatus:
+    """Character online status (requires auth)."""
+
+    online: bool
+    last_login: datetime | None = None
+    last_logout: datetime | None = None
+    logins: int | None = None
+
+
+@dataclass(frozen=True)
+class CharacterLocation:
+    """Character current location (requires auth)."""
+
+    solar_system_id: int
+    station_id: int | None = None
+    structure_id: int | None = None
+
+
+@dataclass(frozen=True)
+class CharacterShip:
+    """Character current ship (requires auth)."""
+
+    ship_type_id: int
+    ship_item_id: int
+    ship_name: str
+
+
+@dataclass(frozen=True)
+class WalletBalance:
+    """Character wallet balance (requires auth)."""
+
+    balance: float
+
+
+@dataclass(frozen=True)
+class SkillQueueEntry:
+    """A single skill in the training queue (requires auth)."""
+
+    skill_id: int
+    queue_position: int
+    finished_level: int
+    start_date: datetime | None = None
+    finish_date: datetime | None = None
+    training_start_sp: int | None = None
+    level_start_sp: int | None = None
+    level_end_sp: int | None = None
+
+
+@dataclass(frozen=True)
+class UniverseName:
+    """Resolved ID → name mapping."""
+
+    id: int
+    name: str
+    category: str

python_eveonline-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: python-eveonline
+Version: 0.1.0
+Summary: Async Python client for the Eve Online ESI API
+Author: Ronald van der Meer
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ronaldvdmeer/python-eveonline
+Project-URL: Repository, https://github.com/ronaldvdmeer/python-eveonline
+Project-URL: Issues, https://github.com/ronaldvdmeer/python-eveonline/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: aioresponses>=0.7; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: pylint>=3.0; extra == "dev"
+Requires-Dist: ruff>=0.3; extra == "dev"
+Dynamic: license-file
+
+# python-eveonline
+
+Async Python client library for the [Eve Online ESI API](https://esi.evetech.net/ui/).
+
+## Features
+
+- Fully async (aiohttp)
+- Typed models (frozen dataclasses)
+- Public endpoints: server status, character info, corporation info, portraits, name resolution
+- Authenticated endpoints: online status, location, ship, wallet, skill queue
+- AbstractAuth pattern for Home Assistant OAuth2 integration
+- PEP 561 typed package (py.typed)
+- 100% test coverage
+
+## Installation
+
+```bash
+pip install python-eveonline
+```
+
+## Quick Start
+
+```python
+import asyncio
+import aiohttp
+from eveonline import EveOnlineClient
+
+async def main():
+    async with aiohttp.ClientSession() as session:
+        client = EveOnlineClient(session=session)
+        status = await client.async_get_server_status()
+        print(f"{status.players} players online")
+
+asyncio.run(main())
+```
+
+## License
+
+MIT

python_eveonline-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+eveonline/__init__.py,sha256=QhHLkq-ZtVzCIAsDARWz5WSyoZpBaRq7vXC4EVylDNY,484
+eveonline/auth.py,sha256=V5QvdKKGAa3N5Kf8NCttmoQfkTK6420eaODWnyECuOM,2101
+eveonline/client.py,sha256=TCTV450v3At1Cv81xml3thiFrfwblDp5JWX8d9WdeU0,13197
+eveonline/const.py,sha256=tdAADyKQlE1c8JFx0zf5-ZvBslC39NZeNICd7lU_uM8,1251
+eveonline/exceptions.py,sha256=DO0V9yXDJbpZ8VfPQpRnUfmNpzetkWcKm1NVVLw2Sik,917
+eveonline/models.py,sha256=uJrQW_DWOx3vOFE_5ZE_ED-_hC8i6wKKpbsjOLnwfDc,2601
+eveonline/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_eveonline-0.1.0.dist-info/licenses/LICENSE,sha256=8548Af-pnudPfoAyQ7EPBO5cIbk1zQmioaQTeDBLVfA,1076
+python_eveonline-0.1.0.dist-info/METADATA,sha256=EH2u8SwcSQu-vzn1BsY1ZP_EcYfuRQix2L6F0_URxHI,2151
+python_eveonline-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_eveonline-0.1.0.dist-info/top_level.txt,sha256=hcD2sMNAD8NE5-bKaUdG9-iwqzKKtqWJcoxeSVOU85M,10
+python_eveonline-0.1.0.dist-info/RECORD,,

python_eveonline-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_eveonline-0.1.0.dist-info/licenses/LICENSE

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

python_eveonline-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eveonline