ips-api-client 0.1.0__py3-none-any.whl

ips_api/__init__.py

@@ -0,0 +1,23 @@
+"""IPS Controllers API Client Library."""
+
+__version__ = "0.1.0"
+
+from .client import IPSClient
+from .models import PoolController, PoolReading, ControllerStatus
+from .exceptions import (
+    IPSError,
+    AuthenticationError,
+    SessionExpiredError,
+    ControllerNotFoundError,
+)
+
+__all__ = [
+    "IPSClient",
+    "PoolController",
+    "PoolReading",
+    "ControllerStatus",
+    "IPSError",
+    "AuthenticationError",
+    "SessionExpiredError",
+    "ControllerNotFoundError",
+]

ips_api/client.py

@@ -0,0 +1,238 @@
+"""Main IPS Controllers API client."""
+
+import logging
+from typing import Dict, List, Optional
+
+import aiohttp
+
+from .const import (
+    BASE_URL,
+    DEFAULT_TIMEOUT,
+    DEVICE_DETAIL_URL,
+    LOGIN_URL,
+    LOGOUT_URL,
+    MY_DEVICES_URL,
+)
+from .exceptions import AuthenticationError, ControllerNotFoundError, SessionExpiredError
+from .models import PoolController, PoolReading
+from .parser import (
+    extract_viewstate_tokens,
+    parse_controllers_list,
+    parse_device_detail,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class IPSClient:
+    """Client for IPS Controllers monitoring system."""
+
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        session: Optional[aiohttp.ClientSession] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ):
+        """Initialize the IPS client.
+
+        Args:
+            username: IPS account email
+            password: IPS account password
+            session: Optional aiohttp session (will create one if not provided)
+            timeout: Request timeout in seconds
+        """
+        self.username = username
+        self.password = password
+        self._session = session
+        self._owned_session = session is None
+        self._timeout = timeout
+        self._authenticated = False
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        if self._owned_session:
+            self._session = aiohttp.ClientSession()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+
+    async def close(self):
+        """Close the client session."""
+        if self._owned_session and self._session:
+            await self._session.close()
+            self._session = None
+
+    async def _get_viewstate_tokens(self) -> Dict[str, str]:
+        """Get ViewState tokens from login page.
+
+        Returns:
+            Dictionary with ViewState tokens
+        """
+        async with self._session.get(LOGIN_URL, timeout=self._timeout) as response:
+            response.raise_for_status()
+            html = await response.text()
+            return extract_viewstate_tokens(html)
+
+    async def login(self) -> bool:
+        """Login to IPS Controllers.
+
+        Returns:
+            True if login successful
+
+        Raises:
+            AuthenticationError: If login fails
+        """
+        _LOGGER.debug("Logging in to IPS Controllers")
+
+        # Get ViewState tokens
+        tokens = await self._get_viewstate_tokens()
+
+        if not all(tokens.values()):
+            raise AuthenticationError("Failed to extract ViewState tokens")
+
+        # Prepare login form
+        form_data = {
+            '__VIEWSTATE': tokens['__VIEWSTATE'],
+            '__VIEWSTATEGENERATOR': tokens['__VIEWSTATEGENERATOR'],
+            '__EVENTVALIDATION': tokens['__EVENTVALIDATION'],
+            'txtLoginName': self.username,
+            'txtLoginPassword': self.password,
+            'imgbtnLogin.x': '40',
+            'imgbtnLogin.y': '32',
+        }
+
+        # Submit login
+        async with self._session.post(
+            LOGIN_URL,
+            data=form_data,
+            allow_redirects=True,
+            timeout=self._timeout,
+        ) as response:
+            response.raise_for_status()
+            final_url = str(response.url)
+
+            # Check if redirected away from login page
+            if 'Login.aspx' in final_url:
+                _LOGGER.error("Login failed - still on login page")
+                raise AuthenticationError("Invalid username or password")
+
+            _LOGGER.info("Successfully logged in to IPS Controllers")
+            self._authenticated = True
+            return True
+
+    async def logout(self):
+        """Logout from IPS Controllers."""
+        if not self._authenticated:
+            return
+
+        try:
+            async with self._session.get(LOGOUT_URL, timeout=self._timeout) as response:
+                response.raise_for_status()
+                _LOGGER.info("Logged out from IPS Controllers")
+        except Exception as e:
+            _LOGGER.warning(f"Error during logout: {e}")
+        finally:
+            self._authenticated = False
+
+    async def _ensure_authenticated(self):
+        """Ensure we're authenticated, login if needed."""
+        if not self._authenticated:
+            await self.login()
+
+    async def _check_session_expired(self, html: str) -> bool:
+        """Check if session has expired by looking for login form.
+
+        Args:
+            html: Response HTML
+
+        Returns:
+            True if session expired
+        """
+        # If we see login form elements, session expired
+        return 'txtLoginName' in html or 'txtLoginPassword' in html
+
+    async def get_controllers(self) -> List[PoolController]:
+        """Get list of all controllers.
+
+        Returns:
+            List of PoolController objects
+
+        Raises:
+            SessionExpiredError: If session has expired
+        """
+        await self._ensure_authenticated()
+
+        _LOGGER.debug("Fetching controllers list")
+
+        async with self._session.get(MY_DEVICES_URL, timeout=self._timeout) as response:
+            response.raise_for_status()
+            html = await response.text()
+
+            # Check if session expired
+            if await self._check_session_expired(html):
+                self._authenticated = False
+                raise SessionExpiredError("Session has expired")
+
+            controllers = parse_controllers_list(html)
+            _LOGGER.info(f"Found {len(controllers)} controller(s)")
+
+            return controllers
+
+    async def get_controller_detail(self, controller_id: str) -> PoolReading:
+        """Get detailed readings for a specific controller.
+
+        Args:
+            controller_id: Controller ID
+
+        Returns:
+            PoolReading with detailed information
+
+        Raises:
+            SessionExpiredError: If session has expired
+            ControllerNotFoundError: If controller not found
+        """
+        await self._ensure_authenticated()
+
+        _LOGGER.debug(f"Fetching details for controller {controller_id}")
+
+        url = f"{DEVICE_DETAIL_URL}?Controller={controller_id}"
+
+        async with self._session.get(url, timeout=self._timeout) as response:
+            if response.status == 404:
+                raise ControllerNotFoundError(f"Controller {controller_id} not found")
+
+            response.raise_for_status()
+            html = await response.text()
+
+            # Check if session expired
+            if await self._check_session_expired(html):
+                self._authenticated = False
+                raise SessionExpiredError("Session has expired")
+
+            reading = parse_device_detail(html)
+            _LOGGER.debug(f"Retrieved reading: pH={reading.ph}, ORP={reading.orp}")
+
+            return reading
+
+    async def get_all_readings(self) -> Dict[str, PoolReading]:
+        """Get detailed readings for all controllers.
+
+        Returns:
+            Dictionary mapping controller_id to PoolReading
+        """
+        controllers = await self.get_controllers()
+
+        readings = {}
+        for controller in controllers:
+            try:
+                reading = await self.get_controller_detail(controller.controller_id)
+                readings[controller.controller_id] = reading
+            except Exception as e:
+                _LOGGER.warning(
+                    f"Failed to get reading for controller {controller.name}: {e}"
+                )
+
+        return readings

ips_api/const.py

@@ -0,0 +1,25 @@
+"""Constants for IPS Controllers API."""
+
+BASE_URL = "https://monitor.ipscontrollers.com"
+
+# Endpoints
+LOGIN_URL = f"{BASE_URL}/Login.aspx"
+MY_DEVICES_URL = f"{BASE_URL}/MyDevices.aspx"
+DEVICE_DETAIL_URL = f"{BASE_URL}/DeviceDetail.aspx"
+LOGOUT_URL = f"{BASE_URL}/Logout.aspx"
+
+# Default settings
+DEFAULT_TIMEOUT = 30
+DEFAULT_POLL_INTERVAL = 900  # 15 minutes
+
+# Status indicators (from image filenames)
+STATUS_NORMAL = "normal"
+STATUS_ALERT = "alert"
+STATUS_WARNING = "warning"
+STATUS_OFFLINE = "offline"
+
+STATUS_ICONS = {
+    "icon_green_light.png": STATUS_NORMAL,
+    "icon_red_light.png": STATUS_ALERT,
+    "icon_yellow_light.png": STATUS_WARNING,
+}

ips_api/exceptions.py

@@ -0,0 +1,26 @@
+"""Custom exceptions for IPS Controllers API."""
+
+
+class IPSError(Exception):
+    """Base exception for IPS API errors."""
+    pass
+
+
+class AuthenticationError(IPSError):
+    """Raised when authentication fails."""
+    pass
+
+
+class SessionExpiredError(IPSError):
+    """Raised when the session has expired."""
+    pass
+
+
+class ControllerNotFoundError(IPSError):
+    """Raised when a controller is not found."""
+    pass
+
+
+class ParseError(IPSError):
+    """Raised when HTML parsing fails."""
+    pass

ips_api/models.py

@@ -0,0 +1,41 @@
+"""Data models for IPS Controllers."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class PoolReading:
+    """Pool chemistry reading."""
+
+    ph: Optional[float] = None
+    orp: Optional[int] = None  # Oxidation-Reduction Potential in mV
+    temperature: Optional[float] = None
+    ppm: Optional[float] = None  # Parts per million (chlorine)
+    timestamp: Optional[datetime] = None
+
+    # Additional details (from detail page)
+    ph_state: Optional[str] = None
+    ph_setpoint: Optional[float] = None
+
+
+@dataclass
+class PoolController:
+    """Pool controller device."""
+
+    controller_id: str
+    name: str
+    status: str  # normal, alert, warning, offline
+    current_reading: Optional[PoolReading] = None
+    last_reading_time: Optional[datetime] = None
+    last_alert_time: Optional[datetime] = None
+
+
+@dataclass
+class ControllerStatus:
+    """Overall status information."""
+
+    is_online: bool
+    status_code: str  # normal, alert, warning, offline
+    status_message: Optional[str] = None

ips_api/parser.py

@@ -0,0 +1,267 @@
+"""HTML parsing utilities for IPS Controllers."""
+
+import re
+from datetime import datetime
+from html.parser import HTMLParser
+from typing import Dict, List, Optional
+
+from bs4 import BeautifulSoup
+
+from .const import STATUS_ICONS, STATUS_OFFLINE
+from .exceptions import ParseError
+from .models import PoolController, PoolReading
+
+
+class ViewStateParser(HTMLParser):
+    """Parse ASP.NET ViewState tokens from HTML."""
+
+    def __init__(self):
+        super().__init__()
+        self.viewstate = None
+        self.viewstate_generator = None
+        self.event_validation = None
+
+    def handle_starttag(self, tag, attrs):
+        attrs_dict = dict(attrs)
+        if tag == 'input':
+            input_id = attrs_dict.get('id', '')
+            input_value = attrs_dict.get('value', '')
+
+            if input_id == '__VIEWSTATE':
+                self.viewstate = input_value
+            elif input_id == '__VIEWSTATEGENERATOR':
+                self.viewstate_generator = input_value
+            elif input_id == '__EVENTVALIDATION':
+                self.event_validation = input_value
+
+
+def extract_viewstate_tokens(html: str) -> Dict[str, str]:
+    """Extract ASP.NET ViewState tokens from HTML.
+
+    Args:
+        html: HTML content
+
+    Returns:
+        Dictionary with __VIEWSTATE, __VIEWSTATEGENERATOR, __EVENTVALIDATION
+    """
+    parser = ViewStateParser()
+    parser.feed(html)
+
+    return {
+        '__VIEWSTATE': parser.viewstate,
+        '__VIEWSTATEGENERATOR': parser.viewstate_generator,
+        '__EVENTVALIDATION': parser.event_validation,
+    }
+
+
+def parse_datetime(date_str: str) -> Optional[datetime]:
+    """Parse datetime from IPS format.
+
+    Args:
+        date_str: Date string like "10/21/2025 11:20:21 AM"
+
+    Returns:
+        datetime object or None if parsing fails
+    """
+    if not date_str or not date_str.strip():
+        return None
+
+    try:
+        return datetime.strptime(date_str.strip(), "%m/%d/%Y %I:%M:%S %p")
+    except ValueError:
+        try:
+            # Try without seconds
+            return datetime.strptime(date_str.strip(), "%m/%d/%Y %I:%M %p")
+        except ValueError:
+            return None
+
+
+def parse_float(value: str) -> Optional[float]:
+    """Parse float value, handling empty strings.
+
+    Args:
+        value: String value
+
+    Returns:
+        Float or None
+    """
+    if not value or not value.strip():
+        return None
+
+    try:
+        return float(value.strip())
+    except ValueError:
+        return None
+
+
+def parse_int(value: str) -> Optional[int]:
+    """Parse int value, handling empty strings.
+
+    Args:
+        value: String value
+
+    Returns:
+        Int or None
+    """
+    if not value or not value.strip():
+        return None
+
+    try:
+        return int(value.strip())
+    except ValueError:
+        return None
+
+
+def extract_status_from_icon(img_src: str) -> str:
+    """Extract status from icon filename.
+
+    Args:
+        img_src: Image source path
+
+    Returns:
+        Status code
+    """
+    for icon_name, status in STATUS_ICONS.items():
+        if icon_name in img_src:
+            return status
+    return STATUS_OFFLINE
+
+
+def parse_controllers_list(html: str) -> List[PoolController]:
+    """Parse list of controllers from MyDevices.aspx.
+
+    Args:
+        html: HTML content from MyDevices.aspx
+
+    Returns:
+        List of PoolController objects
+    """
+    soup = BeautifulSoup(html, 'html.parser')
+    controllers = []
+
+    # Find all device links
+    device_links = soup.find_all('a', href=re.compile(r'DeviceDetail\.aspx\?Controller='))
+
+    for link in device_links:
+        try:
+            # Extract controller ID from URL
+            href = link.get('href', '')
+            match = re.search(r'Controller=([^&]+)', href)
+            if not match:
+                continue
+
+            controller_id = match.group(1)
+            name = link.get_text(strip=True)
+
+            # Find the parent container to get associated data
+            parent = link.find_parent('td')
+            if not parent:
+                parent = link.find_parent('div')
+
+            if not parent:
+                continue
+
+            # Look for status icon (sibling or nearby)
+            status_img = parent.find_next('img', src=re.compile(r'icon_.*_light\.png'))
+            status = STATUS_OFFLINE
+            if status_img:
+                status = extract_status_from_icon(status_img.get('src', ''))
+
+            # Look for data spans - they have specific IDs
+            # Pattern: dlLocations_ctl00_dlDevices_ctl01_lblDevicepH
+            parent_container = link.find_parent('tr') or link.find_parent(['table', 'div'], recursive=True)
+
+            ph_span = None
+            orp_span = None
+            ppm_span = None
+            temp_span = None
+            checked_span = None
+            alert_span = None
+
+            if parent_container:
+                # Find all spans in the container
+                spans = parent_container.find_all('span')
+                for span in spans:
+                    span_id = span.get('id', '')
+                    if 'lblDevicepH' in span_id:
+                        ph_span = span
+                    elif 'lblDeviceORP' in span_id:
+                        orp_span = span
+                    elif 'lblPPM' in span_id:
+                        ppm_span = span
+                    elif 'lblTemp' in span_id:
+                        temp_span = span
+                    elif 'lblDeviceChecked' in span_id:
+                        checked_span = span
+                    elif 'lblAlertReading' in span_id:
+                        alert_span = span
+
+            # Parse values
+            reading = PoolReading(
+                ph=parse_float(ph_span.get_text() if ph_span else ''),
+                orp=parse_int(orp_span.get_text() if orp_span else ''),
+                ppm=parse_float(ppm_span.get_text() if ppm_span else ''),
+                temperature=parse_float(temp_span.get_text() if temp_span else ''),
+            )
+
+            last_reading_time = parse_datetime(checked_span.get_text() if checked_span else '')
+            last_alert_time = parse_datetime(alert_span.get_text() if alert_span else '')
+
+            controller = PoolController(
+                controller_id=controller_id,
+                name=name,
+                status=status,
+                current_reading=reading,
+                last_reading_time=last_reading_time,
+                last_alert_time=last_alert_time,
+            )
+
+            controllers.append(controller)
+
+        except Exception as e:
+            # Skip controllers that fail to parse
+            continue
+
+    if not controllers:
+        raise ParseError("No controllers found in HTML")
+
+    return controllers
+
+
+def parse_device_detail(html: str) -> PoolReading:
+    """Parse detailed readings from DeviceDetail.aspx.
+
+    Args:
+        html: HTML content from DeviceDetail.aspx
+
+    Returns:
+        PoolReading object with detailed information
+    """
+    soup = BeautifulSoup(html, 'html.parser')
+
+    # Find specific labeled elements
+    ph_elem = soup.find('span', id='lblphNum')
+    orp_elem = soup.find('span', id='lblOrpNum')
+    temp_elem = soup.find('span', id='lblTempValue')
+    ph_state_elem = soup.find('span', id='lblpHState')
+    ph_setpoint_elem = soup.find('span', id='lblphSetpoint')
+    timestamp_elem = soup.find('span', id='lblLastReading')
+
+    # Extract pH setpoint from text like "Setpoint: 7.3"
+    ph_setpoint = None
+    if ph_setpoint_elem:
+        setpoint_text = ph_setpoint_elem.get_text()
+        match = re.search(r'([0-9.]+)', setpoint_text)
+        if match:
+            ph_setpoint = parse_float(match.group(1))
+
+    reading = PoolReading(
+        ph=parse_float(ph_elem.get_text() if ph_elem else ''),
+        orp=parse_int(orp_elem.get_text() if orp_elem else ''),
+        temperature=parse_float(temp_elem.get_text() if temp_elem else ''),
+        ph_state=ph_state_elem.get_text(strip=True) if ph_state_elem else None,
+        ph_setpoint=ph_setpoint,
+        timestamp=parse_datetime(timestamp_elem.get_text() if timestamp_elem else ''),
+    )
+
+    return reading

ips_api_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: ips-api-client
+Version: 0.1.0
+Summary: Async Python client for IPS Controllers pool monitoring system
+Home-page: https://github.com/stgarrity/ips-api-client
+Author: Steve Garrity
+Author-email: Steve Garrity <sgarrity@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/stgarrity/ips-api-client
+Project-URL: Documentation, https://github.com/stgarrity/ips-api-client#readme
+Project-URL: Repository, https://github.com/stgarrity/ips-api-client
+Project-URL: Issues, https://github.com/stgarrity/ips-api-client/issues
+Keywords: ips,pool,chemistry,monitoring,home-assistant
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: beautifulsoup4>=4.11.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# IPS Controllers API Client
+
+Python client library for the IPS Controllers pool monitoring system.
+
+## Installation
+
+```bash
+pip install ips-api-client
+```
+
+## Usage
+
+```python
+import asyncio
+from ips_api import IPSClient
+
+async def main():
+    async with IPSClient("your_email@example.com", "your_password") as client:
+        # Get all controllers
+        controllers = await client.get_controllers()
+
+        for controller in controllers:
+            print(f"Controller: {controller.name}")
+            print(f"  pH: {controller.current_reading.ph}")
+            print(f"  ORP: {controller.current_reading.orp} mV")
+            print(f"  Status: {controller.status}")
+
+            # Get detailed reading
+            detail = await client.get_controller_detail(controller.controller_id)
+            print(f"  pH Setpoint: {detail.ph_setpoint}")
+            print(f"  pH State: {detail.ph_state}")
+
+asyncio.run(main())
+```
+
+## Features
+
+- Async/await support
+- Automatic session management
+- Support for multiple controllers
+- Detailed pool chemistry readings (pH, ORP, temperature, chlorine)
+- Controller status monitoring
+
+## Data Available
+
+- pH level
+- ORP (Oxidation-Reduction Potential) in mV
+- Water temperature (when available)
+- Chlorine PPM (when available)
+- Controller status
+- Last reading timestamp
+- pH setpoint and state
+
+## License
+
+MIT

ips_api_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ips_api/__init__.py,sha256=aeEKd4CGHL1ypLOFUFT2op1yrSQ8_UVLY6xRQ0r4aaE,481
+ips_api/client.py,sha256=Wvgmew9yZcBVma7A1XcKcLJh45qfCGyisT94we_klPg,7517
+ips_api/const.py,sha256=lrjsMBCtTnmgn9_LyKm6q6qGrbZLdeR3grqTn2MbPOM,654
+ips_api/exceptions.py,sha256=YXUkJUFgs2qJqZ94pgk2FOzRu0ojy6kw6ia_CgUefAU,501
+ips_api/models.py,sha256=c1qoVTVUitLrF-EFDliXjDMk6FXt2dgCm9I46Mcpr6A,1061
+ips_api/parser.py,sha256=la5K3n4Wn4vurz4KXA9Ut9O7kuWoHGIYYK07ibruPak,8094
+ips_api_client-0.1.0.dist-info/licenses/LICENSE,sha256=VT1yKHLweBlpBR7vx-Xyy3jzNcdhCsevHJG5db7ln5E,1070
+ips_api_client-0.1.0.dist-info/METADATA,sha256=Ku3GGSv7rgDjkhtidefI7o6TNAN75ARZZcN3VkzksbI,2751
+ips_api_client-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ips_api_client-0.1.0.dist-info/top_level.txt,sha256=wDiAuWxLDsOdWyycllaqUv5MZRe5-uVbHp-TGeycfq4,8
+ips_api_client-0.1.0.dist-info/RECORD,,

ips_api_client-0.1.0.dist-info/WHEEL

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

ips_api_client-0.1.0.dist-info/licenses/LICENSE

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

ips_api_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ips_api