veriapi 0.1.0__tar.gz

veriapi-0.1.0/LICENSE

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

veriapi-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: veriapi
+Version: 0.1.0
+Summary: VeriApi.Pro resmî Python istemcisi: döviz, hava, namaz, deprem, il/ilçe
+License: MIT
+Project-URL: Homepage, https://veriapi.pro
+Project-URL: Documentation, https://veriapi.pro/dokumantasyon
+Project-URL: Source, https://github.com/veriapipro/veriapi-python
+Project-URL: Issues, https://github.com/veriapipro/veriapi-python/issues
+Keywords: veriapi,turkiye,doviz,hava,namaz,deprem
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# VeriApi.Pro Python SDK: döviz kuru, namaz vakti, hava durumu ve deprem API'si
+
+Python ile döviz kurlarını, namaz vakitlerini, hava durumunu, son depremleri ve il/ilçe listesini tek API anahtarıyla çekin.
+
+Official Python client for [VeriApi.Pro](https://veriapi.pro/?ref=github): Turkish exchange rates, prayer times, weather, earthquakes and cities.
+
+Python 3.9+, bağımlılık yok.
+
+```bash
+pip install veriapi
+```
+
+## Hızlı başlangıç
+
+```python
+from veriapi import VeriApi, VeriApiHatasi
+
+api = VeriApi("va_ANAHTARINIZ")
+
+sonuc = api.doviz("USD,EUR")
+print(sonuc.veri["kurlar"])
+print(sonuc.kaynak[0]["atif"])  # veriyi gösterdiğiniz yerde görünür yazın
+print(sonuc.guncelleme, sonuc.bayat)
+print(sonuc.kota.gunluk_kalan, sonuc.kota.dakikalik_kalan, sonuc.kota.istek_maliyeti)
+```
+
+## Yöntemler
+
+```python
+api.doviz(["USD", "EUR"], tur="referans")      # tur: anlik | referans
+api.hava(il="duzce", ilce="akcakoca")          # ya da konum="duzce-akcakoca", ya da enlem=, boylam=
+api.namaz(il="ankara", tarih="2026-11-05", gun=7)
+api.depremler(limit=10, min_buyukluk=4.0, saat=24, il="izmir", yurtici=True)
+api.iller()
+api.ilceler("duzce")                           # ad, slug ya da plaka
+
+api.get("/v1/takvim/tatiller", {"yil": 2026})  # diğer tüm uçlar
+```
+
+## Seçenekler
+
+```python
+api = VeriApi(
+    "va_ANAHTARINIZ",
+    zaman_asimi=10.0,    # istek başına saniye
+    yeniden_deneme=2,    # 429'da en çok kaç kez daha; 0 kapatır
+    azami_bekleme=60.0,  # bundan uzun Retry-After beklenmez, hata hemen fırlatılır
+)
+```
+
+## Hatalar
+
+```python
+try:
+    api.namaz(il="duzce", gun=99)
+except VeriApiHatasi as hata:
+    print(hata.kod, hata.mesaj, hata.http_durumu)
+    print(hata.alanlar)      # 422: [{"alan": "gun", "mesaj": "..."}]
+    print(hata.retry_after)  # 429: saniye
+    print(hata.zaman_asimi)  # zaman aşımında True; bağlantı hatasında kod ve http_durumu 0
+```
+
+## Webhook doğrulama
+
+Ham gövdeyi kullanın; JSON'u ayrıştırıp yeniden üretirseniz imza tutmaz.
+
+```python
+from flask import Flask, abort, request
+from veriapi import imza_dogrula
+
+app = Flask(__name__)
+
+@app.post("/webhook")
+def webhook():
+    gecerli = imza_dogrula(
+        request.get_data(),
+        request.headers.get("X-VeriApi-Imza"),
+        request.headers.get("X-VeriApi-Zaman"),
+        "WEBHOOK_GIZLI_ANAHTARINIZ",
+    )
+    if not gecerli:
+        abort(401)
+    olay = request.headers.get("X-VeriApi-Olay")
+    print(olay, request.get_json())
+    return "", 204
+```
+
+`tolerans=300` saniyeden eski ya da ileri tarihli imza reddedilir; `tolerans=0` kapatır.
+
+## Test
+
+```bash
+python3 -m unittest discover -s tests
+```
+
+## Bağlantılar
+
+- Ücretsiz anahtar ve canlı deneme: <https://veriapi.pro/?ref=github>
+- Dokümantasyon: <https://veriapi.pro/dokumantasyon>
+- OpenAPI: <https://api.veriapi.pro/v1/openapi.json>
+
+Lisans: MIT

veriapi-0.1.0/README.md

@@ -0,0 +1,102 @@
+# VeriApi.Pro Python SDK: döviz kuru, namaz vakti, hava durumu ve deprem API'si
+
+Python ile döviz kurlarını, namaz vakitlerini, hava durumunu, son depremleri ve il/ilçe listesini tek API anahtarıyla çekin.
+
+Official Python client for [VeriApi.Pro](https://veriapi.pro/?ref=github): Turkish exchange rates, prayer times, weather, earthquakes and cities.
+
+Python 3.9+, bağımlılık yok.
+
+```bash
+pip install veriapi
+```
+
+## Hızlı başlangıç
+
+```python
+from veriapi import VeriApi, VeriApiHatasi
+
+api = VeriApi("va_ANAHTARINIZ")
+
+sonuc = api.doviz("USD,EUR")
+print(sonuc.veri["kurlar"])
+print(sonuc.kaynak[0]["atif"])  # veriyi gösterdiğiniz yerde görünür yazın
+print(sonuc.guncelleme, sonuc.bayat)
+print(sonuc.kota.gunluk_kalan, sonuc.kota.dakikalik_kalan, sonuc.kota.istek_maliyeti)
+```
+
+## Yöntemler
+
+```python
+api.doviz(["USD", "EUR"], tur="referans")      # tur: anlik | referans
+api.hava(il="duzce", ilce="akcakoca")          # ya da konum="duzce-akcakoca", ya da enlem=, boylam=
+api.namaz(il="ankara", tarih="2026-11-05", gun=7)
+api.depremler(limit=10, min_buyukluk=4.0, saat=24, il="izmir", yurtici=True)
+api.iller()
+api.ilceler("duzce")                           # ad, slug ya da plaka
+
+api.get("/v1/takvim/tatiller", {"yil": 2026})  # diğer tüm uçlar
+```
+
+## Seçenekler
+
+```python
+api = VeriApi(
+    "va_ANAHTARINIZ",
+    zaman_asimi=10.0,    # istek başına saniye
+    yeniden_deneme=2,    # 429'da en çok kaç kez daha; 0 kapatır
+    azami_bekleme=60.0,  # bundan uzun Retry-After beklenmez, hata hemen fırlatılır
+)
+```
+
+## Hatalar
+
+```python
+try:
+    api.namaz(il="duzce", gun=99)
+except VeriApiHatasi as hata:
+    print(hata.kod, hata.mesaj, hata.http_durumu)
+    print(hata.alanlar)      # 422: [{"alan": "gun", "mesaj": "..."}]
+    print(hata.retry_after)  # 429: saniye
+    print(hata.zaman_asimi)  # zaman aşımında True; bağlantı hatasında kod ve http_durumu 0
+```
+
+## Webhook doğrulama
+
+Ham gövdeyi kullanın; JSON'u ayrıştırıp yeniden üretirseniz imza tutmaz.
+
+```python
+from flask import Flask, abort, request
+from veriapi import imza_dogrula
+
+app = Flask(__name__)
+
+@app.post("/webhook")
+def webhook():
+    gecerli = imza_dogrula(
+        request.get_data(),
+        request.headers.get("X-VeriApi-Imza"),
+        request.headers.get("X-VeriApi-Zaman"),
+        "WEBHOOK_GIZLI_ANAHTARINIZ",
+    )
+    if not gecerli:
+        abort(401)
+    olay = request.headers.get("X-VeriApi-Olay")
+    print(olay, request.get_json())
+    return "", 204
+```
+
+`tolerans=300` saniyeden eski ya da ileri tarihli imza reddedilir; `tolerans=0` kapatır.
+
+## Test
+
+```bash
+python3 -m unittest discover -s tests
+```
+
+## Bağlantılar
+
+- Ücretsiz anahtar ve canlı deneme: <https://veriapi.pro/?ref=github>
+- Dokümantasyon: <https://veriapi.pro/dokumantasyon>
+- OpenAPI: <https://api.veriapi.pro/v1/openapi.json>
+
+Lisans: MIT

veriapi-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "veriapi"
+version = "0.1.0"
+description = "VeriApi.Pro resmî Python istemcisi: döviz, hava, namaz, deprem, il/ilçe"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+dependencies = []
+keywords = ["veriapi", "turkiye", "doviz", "hava", "namaz", "deprem"]
+
+[project.urls]
+Homepage = "https://veriapi.pro"
+Documentation = "https://veriapi.pro/dokumantasyon"
+Source = "https://github.com/veriapipro/veriapi-python"
+Issues = "https://github.com/veriapipro/veriapi-python/issues"
+
+[tool.setuptools]
+packages = ["veriapi"]
+
+[tool.setuptools.package-data]
+veriapi = ["py.typed"]

veriapi-0.1.0/setup.cfg

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

veriapi-0.1.0/tests/test_veriapi.py

@@ -0,0 +1,252 @@
+"""Sahte yerel HTTP sunucusuyla birim testleri. Çalıştırma: python3 -m unittest discover -s tests"""
+
+import json
+import os
+import sys
+import threading
+import time
+import unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import parse_qs, urlsplit
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from veriapi import VeriApi, VeriApiHatasi, imza_dogrula  # noqa: E402
+
+KOTA = {"X-RateLimit-Limit-Day": "1000", "X-RateLimit-Remaining-Day": "999", "X-RateLimit-Limit-Minute": "20",
+        "X-RateLimit-Remaining-Minute": "19", "X-Istek-Maliyeti": "1"}
+ZARF = {"veri": {"kurlar": [{"kod": "USD"}]},
+        "kaynak": [{"kod": "ecb", "ad": "ECB", "lisans": "x", "atif": "y", "url": "z"}],
+        "guncelleme": "2026-11-05T10:00:00", "bayat": True}
+
+
+class Sunucu(BaseHTTPRequestHandler):
+    def do_GET(self):
+        self.server.istekler.append((self.path, {k.lower(): v for k, v in self.headers.items()}))
+        durum, basliklar, govde, gecikme = self.server.yanitlar.pop(0) if self.server.yanitlar else (200, KOTA, ZARF, 0)
+        if gecikme:
+            time.sleep(gecikme)
+        ham = govde if isinstance(govde, bytes) else json.dumps(govde).encode()
+        self.send_response(durum)
+        for k, v in basliklar.items():
+            self.send_header(k, v)
+        self.send_header("Content-Length", str(len(ham)))
+        self.end_headers()
+        try:
+            self.wfile.write(ham)
+        except BrokenPipeError:  # zaman aşımı testinde istemci çoktan kapatmıştır
+            pass
+
+    def log_message(self, *args):
+        pass
+
+
+class Temel(unittest.TestCase):
+    def setUp(self):
+        self.sunucu = ThreadingHTTPServer(("127.0.0.1", 0), Sunucu)
+        self.sunucu.istekler, self.sunucu.yanitlar = [], []
+        threading.Thread(target=self.sunucu.serve_forever, args=(0.01,), daemon=True).start()
+        self.addCleanup(self.sunucu.server_close)
+        self.addCleanup(self.sunucu.shutdown)
+        self.beklemeler = []
+        self.api = self.istemci()
+
+    def istemci(self, **secenekler):
+        api = VeriApi("va_test", temel_adres=f"http://127.0.0.1:{self.sunucu.server_port}/", **secenekler)
+        api._uyu = self.beklemeler.append
+        return api
+
+    def yanitla(self, *yanitlar):
+        self.sunucu.yanitlar.extend((*y, 0) if len(y) == 3 else y for y in yanitlar)
+
+    def son(self):
+        yol, basliklar = self.sunucu.istekler[-1]
+        parca = urlsplit(yol)
+        return parca.path, parse_qs(parca.query), basliklar
+
+
+class Basari(Temel):
+    def test_zarf_ve_kota(self):
+        sonuc = self.api.get("/v1/doviz", {"kod": "USD", "bos": None})
+        self.assertEqual(sonuc.veri, ZARF["veri"])
+        self.assertEqual(sonuc.kaynak[0]["kod"], "ecb")
+        self.assertEqual(sonuc.guncelleme, ZARF["guncelleme"])
+        self.assertTrue(sonuc.bayat)
+        self.assertEqual((sonuc.kota.gunluk_limit, sonuc.kota.gunluk_kalan, sonuc.kota.dakikalik_limit,
+                          sonuc.kota.dakikalik_kalan, sonuc.kota.istek_maliyeti), (1000, 999, 20, 19, 1))
+        yol, sorgu, basliklar = self.son()
+        self.assertEqual((yol, sorgu), ("/v1/doviz", {"kod": ["USD"]}))
+        self.assertEqual(basliklar["x-api-key"], "va_test")
+        self.assertNotIn("anahtar", self.sunucu.istekler[-1][0])
+
+    def test_kisa_yol_ve_zarfsiz_govde(self):
+        self.yanitla((200, {}, {"durum": "ok"}))
+        sonuc = self.api.get("durum")
+        self.assertEqual(self.son()[0], "/v1/durum")
+        self.assertEqual(sonuc.veri, {"durum": "ok"})
+        self.assertEqual(sonuc.kaynak, [])
+        self.assertIsNone(sonuc.kota.gunluk_kalan)
+
+    def test_kolaylik_yontemleri(self):
+        api = self.api
+        api.doviz(["USD", "EUR"], tur="referans")
+        self.assertEqual(self.son()[:2], ("/v1/doviz", {"kod": ["USD,EUR"], "tur": ["referans"]}))
+        api.hava(il="Düzce", ilce="Akçakoca")
+        self.assertEqual(self.son()[:2], ("/v1/hava", {"il": ["Düzce"], "ilce": ["Akçakoca"]}))
+        api.hava(enlem=0.0, boylam=32.5)
+        self.assertEqual(self.son()[:2], ("/v1/hava", {"enlem": ["0.0"], "boylam": ["32.5"]}))
+        api.namaz(konum="duzce-akcakoca", tarih="2026-11-05", gun=7)
+        self.assertEqual(self.son()[:2], ("/v1/namaz", {"konum": ["duzce-akcakoca"], "tarih": ["2026-11-05"], "gun": ["7"]}))
+        api.depremler(limit=5, min_buyukluk=4.5, saat=24, il=81, yurtici=True)
+        self.assertEqual(self.son()[:2], ("/v1/deprem/son", {"limit": ["5"], "min_buyukluk": ["4.5"], "saat": ["24"],
+                                                             "il": ["81"], "yurtici": ["true"]}))
+        api.iller()
+        self.assertEqual(self.son()[0], "/v1/konumlar/iller")
+        api.ilceler("Düzce/x")
+        self.assertIn("/v1/konumlar/iller/D%C3%BCzce%2Fx/ilceler", self.sunucu.istekler[-1][0])
+
+
+class Hatalar(Temel):
+    def test_tipli_hata(self):
+        self.yanitla((404, KOTA, {"hata": {"kod": 404, "mesaj": "İl bulunamadı: x"}}))
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.api.ilceler("x")
+        hata = baglam.exception
+        self.assertEqual((hata.kod, hata.mesaj, hata.http_durumu), (404, "İl bulunamadı: x", 404))
+        self.assertEqual(str(hata), "İl bulunamadı: x")
+        self.assertEqual(hata.kota.gunluk_kalan, 999)
+
+    def test_422_alanlar(self):
+        alanlar = [{"alan": "gun", "mesaj": "çok büyük"}]
+        self.yanitla((422, {}, {"hata": {"kod": 422, "mesaj": {"metin": "Geçersiz parametre", "alanlar": alanlar}}}))
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.api.namaz(il="duzce", gun=99)
+        self.assertEqual(baglam.exception.mesaj, "Geçersiz parametre")
+        self.assertEqual(baglam.exception.alanlar, alanlar)
+
+    def test_json_olmayan_hata(self):
+        self.yanitla((502, {"Content-Type": "text/html"}, b"<html>Bad Gateway</html>"))
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.api.iller()
+        self.assertEqual((baglam.exception.kod, baglam.exception.http_durumu), (502, 502))
+
+    def test_gecersiz_json_basari(self):
+        self.yanitla((200, {}, b"<html>"))
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.api.iller()
+        self.assertEqual((baglam.exception.kod, baglam.exception.http_durumu), (0, 200))
+
+    def test_yonlendirme_izlenmez(self):
+        self.yanitla((302, {"Location": "/v1/baska"}, b""))
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.api.iller()
+        self.assertEqual(baglam.exception.http_durumu, 302)
+        self.assertEqual(len(self.sunucu.istekler), 1)
+
+    def test_zaman_asimi(self):
+        self.yanitla((200, {}, ZARF, 0.5))
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.istemci(zaman_asimi=0.05).iller()
+        self.assertTrue(baglam.exception.zaman_asimi)
+        self.assertEqual((baglam.exception.kod, baglam.exception.http_durumu), (0, 0))
+
+    def test_baglanti_hatasi(self):
+        api = VeriApi("va_test", temel_adres="http://127.0.0.1:9")
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            api.iller()
+        self.assertFalse(baglam.exception.zaman_asimi)
+        self.assertEqual(baglam.exception.http_durumu, 0)
+
+    def test_bos_anahtar(self):
+        with self.assertRaises(ValueError):
+            VeriApi("")
+
+
+class YenidenDeneme(Temel):
+    SINIR = {"hata": {"kod": 429, "mesaj": "Dakikalık istek sınırı aşıldı"}}
+
+    def test_retry_after_uyulur(self):
+        self.yanitla((429, {"Retry-After": "7"}, self.SINIR), (429, {"Retry-After": "3"}, self.SINIR))
+        self.assertTrue(self.api.iller().bayat)
+        self.assertEqual(self.beklemeler, [7.0, 3.0])
+        self.assertEqual(len(self.sunucu.istekler), 3)
+
+    def test_en_cok_iki_deneme(self):
+        self.yanitla(*[(429, {"Retry-After": "1"}, self.SINIR)] * 3)
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.api.iller()
+        self.assertEqual(baglam.exception.http_durumu, 429)
+        self.assertEqual(baglam.exception.retry_after, 1.0)
+        self.assertEqual(len(self.sunucu.istekler), 3)
+
+    def test_kapatilabilir(self):
+        self.yanitla((429, {"Retry-After": "1"}, self.SINIR))
+        with self.assertRaises(VeriApiHatasi):
+            self.istemci(yeniden_deneme=0).iller()
+        self.assertEqual(self.beklemeler, [])
+        self.assertEqual(len(self.sunucu.istekler), 1)
+
+    def test_uzun_bekleme_denenmez(self):
+        self.yanitla((429, {"Retry-After": "40000"}, self.SINIR))
+        with self.assertRaises(VeriApiHatasi) as baglam:
+            self.api.iller()
+        self.assertEqual(baglam.exception.retry_after, 40000.0)
+        self.assertEqual(self.beklemeler, [])
+
+    def test_baslik_yoksa_varsayilan(self):
+        self.yanitla((429, {}, self.SINIR))
+        self.api.iller()
+        self.assertEqual(self.beklemeler, [1.0])
+
+    def test_baska_hata_denenmez(self):
+        self.yanitla((503, {"Retry-After": "1"}, {"hata": {"kod": 503, "mesaj": "hazır değil"}}))
+        with self.assertRaises(VeriApiHatasi):
+            self.api.iller()
+        self.assertEqual(len(self.sunucu.istekler), 1)
+
+
+class Webhook(unittest.TestCase):
+    # Dört SDK'nın testlerinde aynı örnek
+    GIZLI = "whsec_ornek"
+    ZAMAN = "1762300800"
+    GOVDE = '{"olay":"deprem.yeni","veri":{"buyukluk":4.2,"il":"Düzce"}}'
+    IMZA = "sha256=c7be673a84807aac83b2d3f90ef21166c532c8006043a2558cefe9c3d839edab"
+    SIMDI = 1762300900
+
+    def dogrula(self, govde=GOVDE, imza=IMZA, zaman=ZAMAN, gizli=GIZLI, **secenekler):
+        secenekler.setdefault("simdi", self.SIMDI)
+        return imza_dogrula(govde, imza, zaman, gizli, **secenekler)
+
+    def test_gecerli(self):
+        self.assertTrue(self.dogrula())
+        self.assertTrue(self.dogrula(govde=self.GOVDE.encode()))
+        self.assertTrue(self.dogrula(imza=self.IMZA.upper().replace("SHA256", "sha256")))
+
+    def test_gecersiz(self):
+        self.assertFalse(self.dogrula(govde=self.GOVDE + " "))
+        self.assertFalse(self.dogrula(gizli="baska"))
+        self.assertFalse(self.dogrula(gizli=""))
+        self.assertFalse(self.dogrula(zaman="1762300801"))
+        self.assertFalse(self.dogrula(imza=self.IMZA[7:]))
+        self.assertFalse(self.dogrula(imza="sha256=zz"))
+        self.assertFalse(self.dogrula(imza="sha256=ğğ"))
+        self.assertFalse(self.dogrula(imza=None))
+        self.assertFalse(self.dogrula(zaman=None))
+
+    def test_tolerans(self):
+        self.assertFalse(self.dogrula(simdi=self.SIMDI + 300))
+        self.assertTrue(self.dogrula(simdi=self.SIMDI + 300, tolerans=0))
+        self.assertTrue(self.dogrula(simdi=self.SIMDI + 300, tolerans=1000))
+
+    def test_iso_zaman(self):
+        import hashlib
+        import hmac
+        zaman = "2026-11-05T00:00:00+03:00"
+        ozet = hmac.new(b"g", f"{zaman}.x".encode(), hashlib.sha256).hexdigest()
+        an = 1793826000  # 2026-11-04T21:00:00Z
+        self.assertTrue(imza_dogrula("x", f"sha256={ozet}", zaman, "g", simdi=an + 10))
+        self.assertFalse(imza_dogrula("x", f"sha256={ozet}", zaman, "g", simdi=an + 1000))
+
+
+if __name__ == "__main__":
+    unittest.main()

veriapi-0.1.0/veriapi/__init__.py

@@ -0,0 +1,7 @@
+"""VeriApi.Pro resmî Python istemcisi (yalnızca standart kitaplık)."""
+
+from .istemci import Kota, Sonuc, VeriApi, VeriApiHatasi
+from .webhook import imza_dogrula
+
+__version__ = "0.1.0"
+__all__ = ["Kota", "Sonuc", "VeriApi", "VeriApiHatasi", "imza_dogrula", "__version__"]

veriapi-0.1.0/veriapi/istemci.py

@@ -0,0 +1,223 @@
+"""HTTP istemcisi: zarf çözme, tipli hata, 429 yeniden deneme, kolaylık yöntemleri."""
+
+from __future__ import annotations
+
+import http.client
+import json
+import socket
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Union
+
+SURUM = "0.1.0"
+VARSAYILAN_ADRES = "https://api.veriapi.pro"
+VARSAYILAN_BEKLEME = 1.0  # 429'da Retry-After yoksa (saniye)
+
+
+def _tam(deger: Optional[str]) -> Optional[int]:
+    try:
+        return int(deger) if deger is not None else None
+    except ValueError:
+        return None
+
+
+@dataclass(frozen=True)
+class Kota:
+    """X-RateLimit-* ve X-Istek-Maliyeti başlıkları; başlık yoksa alan None."""
+
+    gunluk_limit: Optional[int] = None
+    gunluk_kalan: Optional[int] = None
+    dakikalik_limit: Optional[int] = None
+    dakikalik_kalan: Optional[int] = None
+    istek_maliyeti: Optional[int] = None
+
+    @classmethod
+    def basliklardan(cls, basliklar: Any) -> "Kota":
+        return cls(
+            gunluk_limit=_tam(basliklar.get("X-RateLimit-Limit-Day")),
+            gunluk_kalan=_tam(basliklar.get("X-RateLimit-Remaining-Day")),
+            dakikalik_limit=_tam(basliklar.get("X-RateLimit-Limit-Minute")),
+            dakikalik_kalan=_tam(basliklar.get("X-RateLimit-Remaining-Minute")),
+            istek_maliyeti=_tam(basliklar.get("X-Istek-Maliyeti")),
+        )
+
+
+@dataclass(frozen=True)
+class Sonuc:
+    """Çözülmüş yanıt zarfı. Zarfsız uçlarda (/v1/durum) `veri` gövdenin tamamıdır."""
+
+    veri: Any
+    kaynak: List[Dict[str, Any]] = field(default_factory=list)
+    guncelleme: Optional[str] = None
+    bayat: bool = False
+    kota: Kota = field(default_factory=Kota)
+
+
+class VeriApiHatasi(Exception):
+    """API ya da bağlantı hatası.
+
+    kod: sunucunun `hata.kod` değeri; bağlantı ve zaman aşımında 0.
+    http_durumu: HTTP durum kodu; yanıt alınamadıysa 0.
+    alanlar: 422'de hatalı parametreler [{"alan", "mesaj"}].
+    retry_after: 429'da saniye. kota: yanıttaki kota başlıkları.
+    """
+
+    def __init__(self, kod: int, mesaj: str, http_durumu: int, *, alanlar: Optional[List[Dict[str, Any]]] = None,
+                 retry_after: Optional[float] = None, kota: Optional[Kota] = None, zaman_asimi: bool = False):
+        super().__init__(mesaj)
+        self.kod = kod
+        self.mesaj = mesaj
+        self.http_durumu = http_durumu
+        self.alanlar = alanlar or []
+        self.retry_after = retry_after
+        self.kota = kota or Kota()
+        self.zaman_asimi = zaman_asimi
+
+
+class _YonlendirmeYok(urllib.request.HTTPRedirectHandler):
+    """X-API-Key başka bir adrese taşınmasın: yönlendirme izlenmez, 3xx hata olur."""
+
+    def redirect_request(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+
+def _deger(deger: Any) -> str:
+    if isinstance(deger, bool):
+        return "true" if deger else "false"
+    if isinstance(deger, (list, tuple)):
+        return ",".join(str(d) for d in deger)
+    return str(deger)
+
+
+def _retry_after(deger: Optional[str]) -> Optional[float]:
+    try:
+        return max(0.0, float(deger)) if deger is not None else None
+    except ValueError:
+        return None
+
+
+def _hata(durum: int, govde: bytes, basliklar: Any) -> VeriApiHatasi:
+    kod, mesaj, alanlar = durum, f"Beklenmeyen yanıt (HTTP {durum})", None
+    try:
+        hata = json.loads(govde)["hata"]
+        kod = int(hata.get("kod", durum))
+        ham = hata.get("mesaj")
+        if isinstance(ham, dict):  # 422: {"metin": "...", "alanlar": [...]}
+            mesaj = str(ham.get("metin") or mesaj)
+            alanlar = ham.get("alanlar")
+        elif ham:
+            mesaj = str(ham)
+    except (ValueError, KeyError, TypeError, AttributeError):
+        pass  # JSON olmayan yanıt (vekil sunucu 502 sayfası vb.)
+    return VeriApiHatasi(kod, mesaj, durum, alanlar=alanlar, kota=Kota.basliklardan(basliklar),
+                         retry_after=_retry_after(basliklar.get("Retry-After")))
+
+
+class VeriApi:
+    """VeriApi.Pro istemcisi.
+
+    yeniden_deneme: 429'da en çok kaç kez daha denensin (0 kapatır).
+    azami_bekleme: bundan uzun Retry-After beklenmez, hata hemen fırlatılır (günlük kota aşımında saatler sürebilir).
+    zaman_asimi: istek başına saniye.
+    """
+
+    def __init__(self, anahtar: str, *, temel_adres: str = VARSAYILAN_ADRES, zaman_asimi: float = 10.0,
+                 yeniden_deneme: int = 2, azami_bekleme: float = 60.0):
+        if not anahtar:
+            raise ValueError("API anahtarı gerekli")
+        self._anahtar = anahtar
+        self._temel = temel_adres.rstrip("/")
+        self._zaman_asimi = zaman_asimi
+        self._yeniden_deneme = max(0, yeniden_deneme)
+        self._azami_bekleme = azami_bekleme
+        self._acici = urllib.request.build_opener(_YonlendirmeYok)
+        self._uyu = time.sleep
+
+    def get(self, yol: str, parametreler: Optional[Mapping[str, Any]] = None) -> Sonuc:
+        """`yol` "/v1/doviz" ya da "doviz" olabilir. None değerli parametreler gönderilmez."""
+        url = self._url(yol, parametreler)
+        deneme = 0
+        while True:
+            durum, govde, basliklar = self._istek(url)
+            if durum != 429 or deneme >= self._yeniden_deneme:
+                break
+            bekle = _retry_after(basliklar.get("Retry-After"))
+            bekle = VARSAYILAN_BEKLEME if bekle is None else bekle
+            if bekle > self._azami_bekleme:
+                break
+            self._uyu(bekle)
+            deneme += 1
+        if not 200 <= durum < 300:
+            raise _hata(durum, govde, basliklar)
+        kota = Kota.basliklardan(basliklar)
+        try:
+            belge = json.loads(govde)
+        except ValueError:
+            raise VeriApiHatasi(0, "Yanıt JSON değil", durum, kota=kota) from None
+        if not isinstance(belge, dict) or "veri" not in belge:
+            return Sonuc(veri=belge, kota=kota)
+        return Sonuc(veri=belge["veri"], kaynak=belge.get("kaynak") or [], guncelleme=belge.get("guncelleme"),
+                     bayat=bool(belge.get("bayat")), kota=kota)
+
+    def _url(self, yol: str, parametreler: Optional[Mapping[str, Any]]) -> str:
+        if not yol.startswith("/v1/"):
+            yol = "/v1/" + yol.lstrip("/")
+        temiz = {k: _deger(v) for k, v in (parametreler or {}).items() if v is not None}
+        if not temiz:
+            return self._temel + yol
+        ayrac = "&" if "?" in yol else "?"
+        return self._temel + yol + ayrac + urllib.parse.urlencode(temiz, quote_via=urllib.parse.quote)
+
+    def _istek(self, url: str) -> Any:
+        istek = urllib.request.Request(url, headers={
+            "X-API-Key": self._anahtar, "Accept": "application/json", "User-Agent": f"veriapi-python/{SURUM}",
+        })
+        try:
+            with self._acici.open(istek, timeout=self._zaman_asimi) as yanit:
+                return yanit.status, yanit.read(), yanit.headers
+        except urllib.error.HTTPError as hata:
+            with hata:
+                return hata.code, hata.read(), hata.headers
+        except (TimeoutError, socket.timeout) as hata:
+            raise self._zaman_asimi_hatasi() from hata
+        except (urllib.error.URLError, http.client.HTTPException, OSError) as hata:
+            if isinstance(getattr(hata, "reason", None), (TimeoutError, socket.timeout)):
+                raise self._zaman_asimi_hatasi() from hata
+            raise VeriApiHatasi(0, f"Bağlantı hatası: {hata}", 0) from hata
+
+    def _zaman_asimi_hatasi(self) -> VeriApiHatasi:
+        return VeriApiHatasi(0, f"Zaman aşımı ({self._zaman_asimi} sn)", 0, zaman_asimi=True)
+
+    # --- Kolaylık yöntemleri (parametreler api/app/routers/data.py ile aynı) ---
+
+    def doviz(self, kod: Union[str, Iterable[str], None] = None, tur: Optional[str] = None) -> Sonuc:
+        """kod: "USD,EUR" ya da ["USD", "EUR"]; tur: "anlik" | "referans"."""
+        if kod is not None and not isinstance(kod, str):
+            kod = list(kod)
+        return self.get("/v1/doviz", {"kod": kod, "tur": tur})
+
+    def hava(self, *, konum: Optional[str] = None, il: Union[str, int, None] = None, ilce: Optional[str] = None,
+             enlem: Optional[float] = None, boylam: Optional[float] = None) -> Sonuc:
+        return self.get("/v1/hava", {"konum": konum, "il": il, "ilce": ilce, "enlem": enlem, "boylam": boylam})
+
+    def namaz(self, *, konum: Optional[str] = None, il: Union[str, int, None] = None, ilce: Optional[str] = None,
+              enlem: Optional[float] = None, boylam: Optional[float] = None, tarih: Optional[str] = None,
+              gun: Optional[int] = None) -> Sonuc:
+        """tarih: YYYY-AA-GG (varsayılan bugün); gun: 1-31."""
+        return self.get("/v1/namaz", {"konum": konum, "il": il, "ilce": ilce, "enlem": enlem, "boylam": boylam,
+                                      "tarih": tarih, "gun": gun})
+
+    def depremler(self, *, limit: Optional[int] = None, min_buyukluk: Optional[float] = None, saat: Optional[int] = None,
+                  il: Union[str, int, None] = None, yurtici: Optional[bool] = None) -> Sonuc:
+        return self.get("/v1/deprem/son", {"limit": limit, "min_buyukluk": min_buyukluk, "saat": saat, "il": il,
+                                           "yurtici": yurtici})
+
+    def iller(self) -> Sonuc:
+        return self.get("/v1/konumlar/iller")
+
+    def ilceler(self, il: Union[str, int]) -> Sonuc:
+        """il: ad, slug ya da plaka."""
+        return self.get(f"/v1/konumlar/iller/{urllib.parse.quote(str(il), safe='')}/ilceler")

veriapi-0.1.0/veriapi/webhook.py

@@ -0,0 +1,53 @@
+"""Webhook imza doğrulama: imzalanan metin `<zaman>.<ham gövde>`, HMAC-SHA256 hex, başlık `sha256=<hex>`."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import re
+import time
+from datetime import datetime
+from typing import Optional, Union
+
+_IMZA = re.compile(r"sha256=([0-9a-fA-F]{64})")
+_RFC3339 = re.compile(r"\d{4}-\d{2}-\d{2}T\S+(Z|[+-]\d{2}:\d{2})")
+_SAYI = re.compile(r"\d+(\.\d+)?")
+
+
+def _saniye(zaman: str) -> Optional[float]:
+    """Unix saniyesi ya da saat dilimli ISO 8601; başka biçim None."""
+    if _SAYI.fullmatch(zaman):
+        return float(zaman)
+    if _RFC3339.fullmatch(zaman):
+        try:
+            return datetime.fromisoformat(zaman.replace("Z", "+00:00")).timestamp()
+        except ValueError:
+            return None
+    return None
+
+
+def imza_dogrula(govde: Union[bytes, str], imza: Optional[str], zaman: Optional[str], gizli: Union[bytes, str],
+                 tolerans: float = 300, simdi: Optional[float] = None) -> bool:
+    """X-VeriApi-Imza başlığını doğrular; geçersiz her girdide False döner, hata fırlatmaz.
+
+    govde: ayrıştırılmamış ham gövde (JSON'u yeniden üretmeyin, imza tutmaz).
+    imza, zaman: X-VeriApi-Imza ve X-VeriApi-Zaman başlıkları.
+    tolerans: yeniden oynatmaya karşı saniye cinsinden zaman farkı sınırı (0 kapatır).
+    """
+    if not gizli or not imza or not zaman:
+        return False
+    eslesme = _IMZA.fullmatch(imza.strip())
+    if not eslesme:
+        return False
+    zaman = zaman.strip()
+    ham = govde.encode("utf-8") if isinstance(govde, str) else bytes(govde)
+    anahtar = gizli.encode("utf-8") if isinstance(gizli, str) else gizli
+    beklenen = hmac.new(anahtar, zaman.encode("utf-8") + b"." + ham, hashlib.sha256).hexdigest()
+    if not hmac.compare_digest(beklenen.encode("ascii"), eslesme.group(1).lower().encode("ascii")):
+        return False
+    if tolerans <= 0:
+        return True
+    saniye = _saniye(zaman)
+    if saniye is None:
+        return False
+    return abs((time.time() if simdi is None else simdi) - saniye) <= tolerans

veriapi-0.1.0/veriapi.egg-info/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: veriapi
+Version: 0.1.0
+Summary: VeriApi.Pro resmî Python istemcisi: döviz, hava, namaz, deprem, il/ilçe
+License: MIT
+Project-URL: Homepage, https://veriapi.pro
+Project-URL: Documentation, https://veriapi.pro/dokumantasyon
+Project-URL: Source, https://github.com/veriapipro/veriapi-python
+Project-URL: Issues, https://github.com/veriapipro/veriapi-python/issues
+Keywords: veriapi,turkiye,doviz,hava,namaz,deprem
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# VeriApi.Pro Python SDK: döviz kuru, namaz vakti, hava durumu ve deprem API'si
+
+Python ile döviz kurlarını, namaz vakitlerini, hava durumunu, son depremleri ve il/ilçe listesini tek API anahtarıyla çekin.
+
+Official Python client for [VeriApi.Pro](https://veriapi.pro/?ref=github): Turkish exchange rates, prayer times, weather, earthquakes and cities.
+
+Python 3.9+, bağımlılık yok.
+
+```bash
+pip install veriapi
+```
+
+## Hızlı başlangıç
+
+```python
+from veriapi import VeriApi, VeriApiHatasi
+
+api = VeriApi("va_ANAHTARINIZ")
+
+sonuc = api.doviz("USD,EUR")
+print(sonuc.veri["kurlar"])
+print(sonuc.kaynak[0]["atif"])  # veriyi gösterdiğiniz yerde görünür yazın
+print(sonuc.guncelleme, sonuc.bayat)
+print(sonuc.kota.gunluk_kalan, sonuc.kota.dakikalik_kalan, sonuc.kota.istek_maliyeti)
+```
+
+## Yöntemler
+
+```python
+api.doviz(["USD", "EUR"], tur="referans")      # tur: anlik | referans
+api.hava(il="duzce", ilce="akcakoca")          # ya da konum="duzce-akcakoca", ya da enlem=, boylam=
+api.namaz(il="ankara", tarih="2026-11-05", gun=7)
+api.depremler(limit=10, min_buyukluk=4.0, saat=24, il="izmir", yurtici=True)
+api.iller()
+api.ilceler("duzce")                           # ad, slug ya da plaka
+
+api.get("/v1/takvim/tatiller", {"yil": 2026})  # diğer tüm uçlar
+```
+
+## Seçenekler
+
+```python
+api = VeriApi(
+    "va_ANAHTARINIZ",
+    zaman_asimi=10.0,    # istek başına saniye
+    yeniden_deneme=2,    # 429'da en çok kaç kez daha; 0 kapatır
+    azami_bekleme=60.0,  # bundan uzun Retry-After beklenmez, hata hemen fırlatılır
+)
+```
+
+## Hatalar
+
+```python
+try:
+    api.namaz(il="duzce", gun=99)
+except VeriApiHatasi as hata:
+    print(hata.kod, hata.mesaj, hata.http_durumu)
+    print(hata.alanlar)      # 422: [{"alan": "gun", "mesaj": "..."}]
+    print(hata.retry_after)  # 429: saniye
+    print(hata.zaman_asimi)  # zaman aşımında True; bağlantı hatasında kod ve http_durumu 0
+```
+
+## Webhook doğrulama
+
+Ham gövdeyi kullanın; JSON'u ayrıştırıp yeniden üretirseniz imza tutmaz.
+
+```python
+from flask import Flask, abort, request
+from veriapi import imza_dogrula
+
+app = Flask(__name__)
+
+@app.post("/webhook")
+def webhook():
+    gecerli = imza_dogrula(
+        request.get_data(),
+        request.headers.get("X-VeriApi-Imza"),
+        request.headers.get("X-VeriApi-Zaman"),
+        "WEBHOOK_GIZLI_ANAHTARINIZ",
+    )
+    if not gecerli:
+        abort(401)
+    olay = request.headers.get("X-VeriApi-Olay")
+    print(olay, request.get_json())
+    return "", 204
+```
+
+`tolerans=300` saniyeden eski ya da ileri tarihli imza reddedilir; `tolerans=0` kapatır.
+
+## Test
+
+```bash
+python3 -m unittest discover -s tests
+```
+
+## Bağlantılar
+
+- Ücretsiz anahtar ve canlı deneme: <https://veriapi.pro/?ref=github>
+- Dokümantasyon: <https://veriapi.pro/dokumantasyon>
+- OpenAPI: <https://api.veriapi.pro/v1/openapi.json>
+
+Lisans: MIT

veriapi-0.1.0/veriapi.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_veriapi.py
+veriapi/__init__.py
+veriapi/istemci.py
+veriapi/py.typed
+veriapi/webhook.py
+veriapi.egg-info/PKG-INFO
+veriapi.egg-info/SOURCES.txt
+veriapi.egg-info/dependency_links.txt
+veriapi.egg-info/top_level.txt

veriapi-0.1.0/veriapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

veriapi-0.1.0/veriapi.egg-info/top_level.txt

@@ -0,0 +1 @@
+veriapi