meteoflow 1.0.0__tar.gz

meteoflow-1.0.0/LICENSE

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

meteoflow-1.0.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: meteoflow
+Version: 1.0.0
+Summary: Python SDK for Meteoflow Weather API
+Author: Meteoflow
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.0
+Dynamic: license-file
+Dynamic: requires-python
+
+# Meteoflow Python SDK
+
+Python SDK for Meteoflow Weather API.
+
+## Install
+
+```bash
+pip install meteoflow
+```
+
+## Quick Start
+
+```python
+from meteoflow import WeatherClient, LocationSlug, LocationCoords, LocationIP
+
+client = WeatherClient("TOKEN")
+
+# Current weather by slug
+current = client.current(LocationSlug("united-kingdom-london"))
+
+# Current weather by coords
+current = client.current(LocationCoords(51.5072, -0.1275))
+
+# Current weather by IP
+current = client.current(LocationIP("8.8.8.8"))
+```
+
+## Forecasts
+
+```python
+from meteoflow import WeatherClient, LocationIP, ForecastOptions
+
+client = WeatherClient("TOKEN")
+
+# Hourly forecast by IP
+options = ForecastOptions(days=1, units="metric", lang="en")
+forecast = client.forecast_hourly(LocationIP("8.8.8.8"), options)
+
+# 3-hour forecast by IP
+options = ForecastOptions(days=2, units="metric", lang="en")
+forecast = client.forecast_3hourly(LocationIP("8.8.8.8"), options)
+
+# Daily forecast by IP
+options = ForecastOptions(days=5, units="metric", lang="en")
+forecast = client.forecast_daily(LocationIP("8.8.8.8"), options)
+```
+
+## Air Quality
+
+```python
+from meteoflow import AirQualityClient, LocationCoords, ForecastOptions
+
+client = AirQualityClient("TOKEN")
+
+air = client.by_days(LocationCoords(51.5072, -0.1275), ForecastOptions(days=3))
+```
+
+## Geomagnetic
+
+```python
+from meteoflow import GeomagneticClient, LocationSlug
+
+client = GeomagneticClient("TOKEN")
+
+geo = client.by_days(LocationSlug("united-kingdom-london"))
+```
+
+## Geography Search → Weather
+
+```python
+from meteoflow import GeographyClient, WeatherClient, LocationSlug
+
+geo = GeographyClient("TOKEN")
+weather = WeatherClient("TOKEN")
+
+results = geo.search("London", limit=1)
+slug = results["items"][0]["slug"]
+
+current = weather.current(LocationSlug(slug))
+```
+
+## Auth: Header vs Query
+
+```python
+from meteoflow import WeatherClient, LocationSlug
+
+# Default: X-token header
+client = WeatherClient("TOKEN")
+current = client.current(LocationSlug("united-kingdom-london"))
+
+# Query auth: ?key=TOKEN
+client_q = WeatherClient("TOKEN", auth_in_query=True)
+current_q = client_q.current(LocationSlug("united-kingdom-london"))
+```
+
+## Notes
+
+- Supported Python versions: 3.4+
+- Sync only in core package
+- Returns parsed JSON as `dict`

meteoflow-1.0.0/README.md

@@ -0,0 +1,100 @@
+# Meteoflow Python SDK
+
+Python SDK for Meteoflow Weather API.
+
+## Install
+
+```bash
+pip install meteoflow
+```
+
+## Quick Start
+
+```python
+from meteoflow import WeatherClient, LocationSlug, LocationCoords, LocationIP
+
+client = WeatherClient("TOKEN")
+
+# Current weather by slug
+current = client.current(LocationSlug("united-kingdom-london"))
+
+# Current weather by coords
+current = client.current(LocationCoords(51.5072, -0.1275))
+
+# Current weather by IP
+current = client.current(LocationIP("8.8.8.8"))
+```
+
+## Forecasts
+
+```python
+from meteoflow import WeatherClient, LocationIP, ForecastOptions
+
+client = WeatherClient("TOKEN")
+
+# Hourly forecast by IP
+options = ForecastOptions(days=1, units="metric", lang="en")
+forecast = client.forecast_hourly(LocationIP("8.8.8.8"), options)
+
+# 3-hour forecast by IP
+options = ForecastOptions(days=2, units="metric", lang="en")
+forecast = client.forecast_3hourly(LocationIP("8.8.8.8"), options)
+
+# Daily forecast by IP
+options = ForecastOptions(days=5, units="metric", lang="en")
+forecast = client.forecast_daily(LocationIP("8.8.8.8"), options)
+```
+
+## Air Quality
+
+```python
+from meteoflow import AirQualityClient, LocationCoords, ForecastOptions
+
+client = AirQualityClient("TOKEN")
+
+air = client.by_days(LocationCoords(51.5072, -0.1275), ForecastOptions(days=3))
+```
+
+## Geomagnetic
+
+```python
+from meteoflow import GeomagneticClient, LocationSlug
+
+client = GeomagneticClient("TOKEN")
+
+geo = client.by_days(LocationSlug("united-kingdom-london"))
+```
+
+## Geography Search → Weather
+
+```python
+from meteoflow import GeographyClient, WeatherClient, LocationSlug
+
+geo = GeographyClient("TOKEN")
+weather = WeatherClient("TOKEN")
+
+results = geo.search("London", limit=1)
+slug = results["items"][0]["slug"]
+
+current = weather.current(LocationSlug(slug))
+```
+
+## Auth: Header vs Query
+
+```python
+from meteoflow import WeatherClient, LocationSlug
+
+# Default: X-token header
+client = WeatherClient("TOKEN")
+current = client.current(LocationSlug("united-kingdom-london"))
+
+# Query auth: ?key=TOKEN
+client_q = WeatherClient("TOKEN", auth_in_query=True)
+current_q = client_q.current(LocationSlug("united-kingdom-london"))
+```
+
+## Notes
+
+- Supported Python versions: 3.4+
+- Sync only in core package
+- Returns parsed JSON as `dict`

meteoflow-1.0.0/meteoflow/__init__.py

@@ -0,0 +1,39 @@
+from .air import AirQualityClient
+from .client import WeatherClient
+from .exceptions import (
+    ApiError,
+    AuthError,
+    NetworkError,
+    NotFoundError,
+    RateLimitError,
+    SdkError,
+    ServerError,
+    ValidationError,
+)
+from .geomagnetic import GeomagneticClient
+from .geography import GeographyClient
+from .location import LocationCoords, LocationIP, LocationSlug
+from .options import ForecastOptions, UNITS_IMPERIAL, UNITS_METRIC
+from .transport import HttpTransport
+
+__all__ = [
+    "WeatherClient",
+    "AirQualityClient",
+    "GeomagneticClient",
+    "GeographyClient",
+    "LocationSlug",
+    "LocationCoords",
+    "LocationIP",
+    "ForecastOptions",
+    "UNITS_METRIC",
+    "UNITS_IMPERIAL",
+    "HttpTransport",
+    "SdkError",
+    "ValidationError",
+    "NetworkError",
+    "ApiError",
+    "AuthError",
+    "RateLimitError",
+    "NotFoundError",
+    "ServerError",
+]

meteoflow-1.0.0/meteoflow/_base.py

@@ -0,0 +1,95 @@
+from .exceptions import ValidationError
+from .location import location_to_params
+from .options import ForecastOptions, validate_days, validate_lang, validate_units
+from .transport import HttpTransport
+
+
+class BaseClient(object):
+    def __init__(self,
+                 token,
+                 transport=None,
+                 base_url=None,
+                 timeout=None,
+                 retries=None,
+                 backoff_factor=None,
+                 user_agent=None,
+                 proxies=None,
+                 verify_ssl=True,
+                 session=None,
+                 auth_in_query=False,
+                 retry_on_429=True,
+                 default_units=None,
+                 default_lang=None):
+        if not token or not isinstance(token, str):
+            raise ValidationError("token must be a non-empty string")
+        self._token = token
+        self._auth_in_query = auth_in_query
+        self._default_units = default_units
+        self._default_lang = default_lang
+
+        if transport is not None:
+            self._transport = transport
+        else:
+            kwargs = {
+                "base_url": base_url,
+                "timeout": timeout,
+                "retries": retries,
+                "backoff_factor": backoff_factor,
+                "user_agent": user_agent,
+                "proxies": proxies,
+                "verify_ssl": verify_ssl,
+                "session": session,
+                "retry_on_429": retry_on_429,
+            }
+            cleaned = {}
+            for key in kwargs:
+                if kwargs[key] is not None:
+                    cleaned[key] = kwargs[key]
+            self._transport = HttpTransport(**cleaned)
+
+    def _with_auth(self, params):
+        headers = {}
+        if self._auth_in_query:
+            params["key"] = self._token
+        else:
+            headers["X-token"] = self._token
+        return params, headers
+
+    def _build_params(self,
+                      location,
+                      options,
+                      default_days=None,
+                      supports_days=True,
+                      supports_units=True,
+                      supports_lang=True):
+        params = location_to_params(location)
+        if options is None:
+            options = ForecastOptions()
+        if not isinstance(options, ForecastOptions):
+            raise ValidationError("options must be ForecastOptions or None")
+
+        if supports_days:
+            days = options.days
+            if days is None:
+                days = default_days
+            validate_days(days)
+            if days is not None:
+                params["days"] = int(days)
+
+        if supports_units:
+            units = options.units
+            if units is None:
+                units = self._default_units
+            validate_units(units)
+            if units is not None:
+                params["unit"] = units
+
+        if supports_lang:
+            lang = options.lang
+            if lang is None:
+                lang = self._default_lang
+            validate_lang(lang)
+            if lang is not None:
+                params["lang"] = lang
+
+        return params

meteoflow-1.0.0/meteoflow/air.py

@@ -0,0 +1,17 @@
+from ._base import BaseClient
+
+
+class AirQualityClient(BaseClient):
+    def __init__(self, token, default_days=3, **kwargs):
+        super(AirQualityClient, self).__init__(token, **kwargs)
+        self._default_days = default_days
+
+    def by_days(self, location, options=None):
+        params = self._build_params(
+            location,
+            options,
+            default_days=self._default_days,
+            supports_days=True,
+        )
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/air/by-days/", params=params, headers=headers)

meteoflow-1.0.0/meteoflow/client.py

@@ -0,0 +1,74 @@
+from ._base import BaseClient
+
+
+class WeatherClient(BaseClient):
+    def __init__(self, token, default_days=None, **kwargs):
+        super(WeatherClient, self).__init__(token, **kwargs)
+        self._default_days = self._normalize_default_days(default_days)
+
+    def current(self, location):
+        params = self._build_params(location, options=None, supports_days=False, supports_lang=False)
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/current/", params=params, headers=headers)
+
+    def forecast_hourly(self, location, options=None):
+        params = self._build_params(
+            location,
+            options,
+            default_days=self._default_days["forecast_hourly"],
+            supports_days=True,
+        )
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/forecast/by-hours/", params=params, headers=headers)
+
+    def forecast_3hourly(self, location, options=None):
+        params = self._build_params(
+            location,
+            options,
+            default_days=self._default_days["forecast_3hourly"],
+            supports_days=True,
+        )
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/forecast/by-3hours/", params=params, headers=headers)
+
+    def forecast_daily(self, location, options=None):
+        params = self._build_params(
+            location,
+            options,
+            default_days=self._default_days["forecast_daily"],
+            supports_days=True,
+        )
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/forecast/by-days/", params=params, headers=headers)
+
+    # Aliases for camelCase compatibility
+    def forecastHourly(self, location, options=None):
+        return self.forecast_hourly(location, options)
+
+    def forecast3hourly(self, location, options=None):
+        return self.forecast_3hourly(location, options)
+
+    def forecastDaily(self, location, options=None):
+        return self.forecast_daily(location, options)
+
+    def _normalize_default_days(self, default_days):
+        defaults = {
+            "forecast_hourly": 1,
+            "forecast_3hourly": 2,
+            "forecast_daily": 3,
+        }
+        if default_days is None:
+            return defaults
+        if isinstance(default_days, dict):
+            merged = defaults.copy()
+            merged.update(default_days)
+            return merged
+        try:
+            days_val = int(default_days)
+        except (TypeError, ValueError):
+            return defaults
+        return {
+            "forecast_hourly": days_val,
+            "forecast_3hourly": days_val,
+            "forecast_daily": days_val,
+        }

meteoflow-1.0.0/meteoflow/exceptions.py

@@ -0,0 +1,36 @@
+class SdkError(Exception):
+    pass
+
+
+class ValidationError(SdkError):
+    pass
+
+
+class NetworkError(SdkError):
+    pass
+
+
+class ApiError(SdkError):
+    def __init__(self, status_code, body, message, url, params):
+        super(ApiError, self).__init__(message)
+        self.status_code = status_code
+        self.body = body
+        self.message = message
+        self.url = url
+        self.params = params
+
+
+class AuthError(ApiError):
+    pass
+
+
+class RateLimitError(ApiError):
+    pass
+
+
+class NotFoundError(ApiError):
+    pass
+
+
+class ServerError(ApiError):
+    pass

meteoflow-1.0.0/meteoflow/geography.py

@@ -0,0 +1,37 @@
+from ._base import BaseClient
+from .exceptions import ValidationError
+
+
+class GeographyClient(BaseClient):
+    def countries(self):
+        params, headers = self._with_auth({})
+        return self._transport.get("/v2/geography/countries/", params=params, headers=headers)
+
+    def country_by_code(self, country_code):
+        if not isinstance(country_code, str) or not country_code:
+            raise ValidationError("country_code must be a non-empty string")
+        params = {"country_code": country_code}
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/geography/countries/", params=params, headers=headers)
+
+    def cities_by_country(self, country_code):
+        if not isinstance(country_code, str) or not country_code:
+            raise ValidationError("country_code must be a non-empty string")
+        params = {"country_code": country_code}
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/geography/countries/cities/", params=params, headers=headers)
+
+    def search(self, q, limit=None):
+        if not isinstance(q, str) or not q:
+            raise ValidationError("q must be a non-empty string")
+        params = {"q": q}
+        if limit is not None:
+            try:
+                limit_val = int(limit)
+            except (TypeError, ValueError):
+                raise ValidationError("limit must be an integer")
+            if limit_val < 1:
+                raise ValidationError("limit must be >= 1")
+            params["limit"] = limit_val
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/geography/search/", params=params, headers=headers)

meteoflow-1.0.0/meteoflow/geomagnetic.py

@@ -0,0 +1,8 @@
+from ._base import BaseClient
+
+
+class GeomagneticClient(BaseClient):
+    def by_days(self, location):
+        params = self._build_params(location, options=None, supports_days=False, supports_units=False, supports_lang=False)
+        params, headers = self._with_auth(params)
+        return self._transport.get("/v2/geomagnetic/by-days/", params=params, headers=headers)

meteoflow-1.0.0/meteoflow/location.py

@@ -0,0 +1,46 @@
+import ipaddress
+
+from .exceptions import ValidationError
+
+
+class LocationSlug(object):
+    def __init__(self, slug):
+        if not isinstance(slug, str) or not slug:
+            raise ValidationError("slug must be a non-empty string")
+        self.slug = slug
+
+
+class LocationCoords(object):
+    def __init__(self, lat, lon):
+        try:
+            lat_val = float(lat)
+            lon_val = float(lon)
+        except (TypeError, ValueError):
+            raise ValidationError("lat and lon must be numbers")
+        if lat_val < -90 or lat_val > 90:
+            raise ValidationError("lat must be between -90 and 90")
+        if lon_val < -180 or lon_val > 180:
+            raise ValidationError("lon must be between -180 and 180")
+        self.lat = lat_val
+        self.lon = lon_val
+
+
+class LocationIP(object):
+    def __init__(self, ip):
+        if not isinstance(ip, str) or not ip:
+            raise ValidationError("ip must be a non-empty string")
+        try:
+            ipaddress.ip_address(ip)
+        except ValueError:
+            raise ValidationError("ip must be a valid IPv4 or IPv6 string")
+        self.ip = ip
+
+
+def location_to_params(location):
+    if isinstance(location, LocationSlug):
+        return {"slug": location.slug}
+    if isinstance(location, LocationCoords):
+        return {"lat": location.lat, "lon": location.lon}
+    if isinstance(location, LocationIP):
+        return {"ip": location.ip}
+    raise ValidationError("location must be LocationSlug, LocationCoords, or LocationIP")

meteoflow-1.0.0/meteoflow/options.py

@@ -0,0 +1,37 @@
+from .exceptions import ValidationError
+
+
+UNITS_METRIC = "metric"
+UNITS_IMPERIAL = "imperial"
+
+
+class ForecastOptions(object):
+    def __init__(self, days=None, units=None, lang=None):
+        self.days = days
+        self.units = units
+        self.lang = lang
+
+
+def validate_days(days):
+    if days is None:
+        return
+    try:
+        days_val = int(days)
+    except (TypeError, ValueError):
+        raise ValidationError("days must be an integer")
+    if days_val < 1:
+        raise ValidationError("days must be >= 1")
+
+
+def validate_units(units):
+    if units is None:
+        return
+    if units not in (UNITS_METRIC, UNITS_IMPERIAL):
+        raise ValidationError("units must be 'metric' or 'imperial'")
+
+
+def validate_lang(lang):
+    if lang is None:
+        return
+    if not isinstance(lang, str) or not lang:
+        raise ValidationError("lang must be a non-empty string")

meteoflow-1.0.0/meteoflow/transport.py

@@ -0,0 +1,124 @@
+import time
+
+import requests
+
+from .exceptions import ApiError, AuthError, NetworkError, NotFoundError, RateLimitError, ServerError
+
+DEFAULT_BASE_URL = "https://api.meteoflow.com"
+DEFAULT_TIMEOUT = 10
+DEFAULT_RETRIES = 2
+DEFAULT_BACKOFF = 0.5
+DEFAULT_USER_AGENT = "meteoflow-python/0.1.0"
+
+
+class HttpTransport(object):
+    def __init__(self,
+                 base_url=DEFAULT_BASE_URL,
+                 timeout=DEFAULT_TIMEOUT,
+                 retries=DEFAULT_RETRIES,
+                 backoff_factor=DEFAULT_BACKOFF,
+                 user_agent=None,
+                 proxies=None,
+                 verify_ssl=True,
+                 session=None,
+                 retry_on_429=True):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.retries = retries
+        self.backoff_factor = backoff_factor
+        self.user_agent = user_agent or DEFAULT_USER_AGENT
+        self.proxies = proxies
+        self.verify_ssl = verify_ssl
+        self.retry_on_429 = retry_on_429
+        self.session = session or requests.Session()
+
+    def get(self, path, params=None, headers=None):
+        return self.request("GET", path, params=params, headers=headers)
+
+    def request(self, method, path, params=None, headers=None):
+        url = self.base_url + path
+        request_headers = {
+            "User-Agent": self.user_agent,
+        }
+        if headers:
+            request_headers.update(headers)
+
+        attempt = 0
+        while True:
+            try:
+                response = self.session.request(
+                    method,
+                    url,
+                    params=params,
+                    headers=request_headers,
+                    timeout=self.timeout,
+                    proxies=self.proxies,
+                    verify=self.verify_ssl,
+                )
+            except requests.RequestException as exc:
+                if attempt >= self.retries:
+                    raise NetworkError(str(exc))
+                self._sleep_backoff(attempt)
+                attempt += 1
+                continue
+
+            if self._should_retry(response, method) and attempt < self.retries:
+                self._sleep_backoff(attempt)
+                attempt += 1
+                continue
+
+            if response.status_code < 200 or response.status_code >= 300:
+                self._raise_api_error(response, params)
+
+            try:
+                return response.json()
+            except ValueError:
+                raise ApiError(
+                    response.status_code,
+                    response.text,
+                    "Invalid JSON response",
+                    response.url,
+                    params,
+                )
+
+    def _sleep_backoff(self, attempt):
+        if self.backoff_factor is None:
+            return
+        delay = self.backoff_factor * (2 ** attempt)
+        if delay > 0:
+            time.sleep(delay)
+
+    def _should_retry(self, response, method):
+        if method != "GET":
+            return False
+        if response.status_code >= 500:
+            return True
+        if response.status_code == 429 and self.retry_on_429:
+            return True
+        return False
+
+    def _raise_api_error(self, response, params):
+        status = response.status_code
+        message = self._extract_message(response)
+        body = response.text
+        url = response.url
+        if status in (401, 403):
+            raise AuthError(status, body, message, url, params)
+        if status == 404:
+            raise NotFoundError(status, body, message, url, params)
+        if status == 429:
+            raise RateLimitError(status, body, message, url, params)
+        if status >= 500:
+            raise ServerError(status, body, message, url, params)
+        raise ApiError(status, body, message, url, params)
+
+    def _extract_message(self, response):
+        try:
+            data = response.json()
+        except ValueError:
+            return response.text
+        if isinstance(data, dict):
+            for key in ("message", "error", "detail"):
+                if key in data and data[key]:
+                    return data[key]
+        return response.text

meteoflow-1.0.0/meteoflow.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: meteoflow
+Version: 1.0.0
+Summary: Python SDK for Meteoflow Weather API
+Author: Meteoflow
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.0
+Dynamic: license-file
+Dynamic: requires-python
+
+# Meteoflow Python SDK
+
+Python SDK for Meteoflow Weather API.
+
+## Install
+
+```bash
+pip install meteoflow
+```
+
+## Quick Start
+
+```python
+from meteoflow import WeatherClient, LocationSlug, LocationCoords, LocationIP
+
+client = WeatherClient("TOKEN")
+
+# Current weather by slug
+current = client.current(LocationSlug("united-kingdom-london"))
+
+# Current weather by coords
+current = client.current(LocationCoords(51.5072, -0.1275))
+
+# Current weather by IP
+current = client.current(LocationIP("8.8.8.8"))
+```
+
+## Forecasts
+
+```python
+from meteoflow import WeatherClient, LocationIP, ForecastOptions
+
+client = WeatherClient("TOKEN")
+
+# Hourly forecast by IP
+options = ForecastOptions(days=1, units="metric", lang="en")
+forecast = client.forecast_hourly(LocationIP("8.8.8.8"), options)
+
+# 3-hour forecast by IP
+options = ForecastOptions(days=2, units="metric", lang="en")
+forecast = client.forecast_3hourly(LocationIP("8.8.8.8"), options)
+
+# Daily forecast by IP
+options = ForecastOptions(days=5, units="metric", lang="en")
+forecast = client.forecast_daily(LocationIP("8.8.8.8"), options)
+```
+
+## Air Quality
+
+```python
+from meteoflow import AirQualityClient, LocationCoords, ForecastOptions
+
+client = AirQualityClient("TOKEN")
+
+air = client.by_days(LocationCoords(51.5072, -0.1275), ForecastOptions(days=3))
+```
+
+## Geomagnetic
+
+```python
+from meteoflow import GeomagneticClient, LocationSlug
+
+client = GeomagneticClient("TOKEN")
+
+geo = client.by_days(LocationSlug("united-kingdom-london"))
+```
+
+## Geography Search → Weather
+
+```python
+from meteoflow import GeographyClient, WeatherClient, LocationSlug
+
+geo = GeographyClient("TOKEN")
+weather = WeatherClient("TOKEN")
+
+results = geo.search("London", limit=1)
+slug = results["items"][0]["slug"]
+
+current = weather.current(LocationSlug(slug))
+```
+
+## Auth: Header vs Query
+
+```python
+from meteoflow import WeatherClient, LocationSlug
+
+# Default: X-token header
+client = WeatherClient("TOKEN")
+current = client.current(LocationSlug("united-kingdom-london"))
+
+# Query auth: ?key=TOKEN
+client_q = WeatherClient("TOKEN", auth_in_query=True)
+current_q = client_q.current(LocationSlug("united-kingdom-london"))
+```
+
+## Notes
+
+- Supported Python versions: 3.4+
+- Sync only in core package
+- Returns parsed JSON as `dict`

meteoflow-1.0.0/meteoflow.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+meteoflow/__init__.py
+meteoflow/_base.py
+meteoflow/air.py
+meteoflow/client.py
+meteoflow/exceptions.py
+meteoflow/geography.py
+meteoflow/geomagnetic.py
+meteoflow/location.py
+meteoflow/options.py
+meteoflow/transport.py
+meteoflow.egg-info/PKG-INFO
+meteoflow.egg-info/SOURCES.txt
+meteoflow.egg-info/dependency_links.txt
+meteoflow.egg-info/requires.txt
+meteoflow.egg-info/top_level.txt
+tests/test_location.py
+tests/test_options.py
+tests/test_query.py

meteoflow-1.0.0/meteoflow.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

meteoflow-1.0.0/meteoflow.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.0

meteoflow-1.0.0/meteoflow.egg-info/top_level.txt

@@ -0,0 +1 @@
+meteoflow

meteoflow-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "meteoflow"
+version = "1.0.0"
+description = "Python SDK for Meteoflow Weather API"
+readme = "README.md"
+requires-python = ">=3.4"
+license = { text = "MIT" }
+authors = [
+  { name = "Meteoflow" }
+]
+dependencies = [
+  "requests>=2.0"
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.4",
+  "Programming Language :: Python :: 3.5",
+  "Programming Language :: Python :: 3.6",
+  "Programming Language :: Python :: 3.7",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9"
+]
+
+[tool.setuptools]
+packages = ["meteoflow"]

meteoflow-1.0.0/setup.cfg

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

meteoflow-1.0.0/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="meteoflow",
+    version="0.1.0",
+    description="Python SDK for Meteoflow Weather API",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Meteoflow",
+    license="MIT",
+    packages=find_packages(exclude=("tests",)),
+    install_requires=[
+        "requests>=2.0",
+    ],
+    python_requires=">=3.4",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+    ],
+)

meteoflow-1.0.0/tests/test_location.py

@@ -0,0 +1,34 @@
+import pytest
+
+from meteoflow.exceptions import ValidationError
+from meteoflow.location import LocationCoords, LocationIP, LocationSlug, location_to_params
+
+
+def test_location_slug_params():
+    loc = LocationSlug("paris")
+    assert location_to_params(loc) == {"slug": "paris"}
+
+
+def test_location_coords_params():
+    loc = LocationCoords(10.5, -20.25)
+    assert location_to_params(loc) == {"lat": 10.5, "lon": -20.25}
+
+
+def test_location_ip_params():
+    loc = LocationIP("8.8.8.8")
+    assert location_to_params(loc) == {"ip": "8.8.8.8"}
+
+
+def test_location_invalid_slug():
+    with pytest.raises(ValidationError):
+        LocationSlug("")
+
+
+def test_location_invalid_coords():
+    with pytest.raises(ValidationError):
+        LocationCoords(91, 0)
+
+
+def test_location_invalid_ip():
+    with pytest.raises(ValidationError):
+        LocationIP("999.999.999.999")

meteoflow-1.0.0/tests/test_options.py

@@ -0,0 +1,38 @@
+import pytest
+
+from meteoflow.exceptions import ValidationError
+from meteoflow.options import validate_days, validate_lang, validate_units
+
+
+def test_validate_days_ok():
+    validate_days(1)
+    validate_days("2")
+    validate_days(None)
+
+
+def test_validate_days_invalid():
+    with pytest.raises(ValidationError):
+        validate_days(0)
+    with pytest.raises(ValidationError):
+        validate_days("bad")
+
+
+def test_validate_units_ok():
+    validate_units("metric")
+    validate_units("imperial")
+    validate_units(None)
+
+
+def test_validate_units_invalid():
+    with pytest.raises(ValidationError):
+        validate_units("si")
+
+
+def test_validate_lang_ok():
+    validate_lang("en")
+    validate_lang(None)
+
+
+def test_validate_lang_invalid():
+    with pytest.raises(ValidationError):
+        validate_lang(123)

meteoflow-1.0.0/tests/test_query.py

@@ -0,0 +1,45 @@
+from meteoflow.client import WeatherClient
+from meteoflow.location import LocationCoords, LocationSlug
+from meteoflow.options import ForecastOptions
+
+
+class FakeTransport(object):
+    def __init__(self):
+        self.last = None
+
+    def get(self, path, params=None, headers=None):
+        self.last = {
+            "path": path,
+            "params": params,
+            "headers": headers,
+        }
+        return {"ok": True}
+
+
+def test_weather_current_slug_auth_header():
+    transport = FakeTransport()
+    client = WeatherClient("TOKEN", transport=transport)
+    client.current(LocationSlug("london"))
+    assert transport.last["path"] == "/v2/current/"
+    assert transport.last["params"] == {"slug": "london"}
+    assert transport.last["headers"]["X-token"] == "TOKEN"
+
+
+def test_weather_forecast_coords_options():
+    transport = FakeTransport()
+    client = WeatherClient("TOKEN", transport=transport, default_units="metric", default_lang="en")
+    options = ForecastOptions(days=2, units="imperial", lang="ru")
+    client.forecast_daily(LocationCoords(10, 20), options)
+    assert transport.last["path"] == "/v2/forecast/by-days/"
+    assert transport.last["params"]["lat"] == 10.0
+    assert transport.last["params"]["lon"] == 20.0
+    assert transport.last["params"]["days"] == 2
+    assert transport.last["params"]["unit"] == "imperial"
+    assert transport.last["params"]["lang"] == "ru"
+
+
+def test_weather_auth_query():
+    transport = FakeTransport()
+    client = WeatherClient("TOKEN", transport=transport, auth_in_query=True)
+    client.current(LocationSlug("london"))
+    assert transport.last["params"]["key"] == "TOKEN"