rrss-sdk-wrapper 0.2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- rrss/__init__.py +50 -0
- rrss/adapters/base.py +80 -0
- rrss/adapters/instagram.py +123 -0
- rrss/adapters/threads.py +62 -0
- rrss/adapters/tiktok.py +76 -0
- rrss/adapters/x.py +224 -0
- rrss/adapters/x_stub.py +5 -0
- rrss/auth/__init__.py +19 -0
- rrss/cache.py +209 -0
- rrss/cli.py +78 -0
- rrss/client.py +35 -0
- rrss/errors.py +31 -0
- rrss/gateway.py +306 -0
- rrss/models.py +61 -0
- rrss/normalize/__init__.py +1 -0
- rrss/normalize/instagram.py +82 -0
- rrss/normalize/threads.py +82 -0
- rrss/normalize/tiktok.py +51 -0
- rrss/normalize/x.py +192 -0
- rrss/ratelimit.py +30 -0
- rrss/serialize.py +216 -0
- rrss/stream.py +198 -0
- rrss_sdk_wrapper-0.2.0.dist-info/METADATA +173 -0
- rrss_sdk_wrapper-0.2.0.dist-info/RECORD +26 -0
- rrss_sdk_wrapper-0.2.0.dist-info/WHEEL +4 -0
- rrss_sdk_wrapper-0.2.0.dist-info/entry_points.txt +2 -0
rrss/cache.py
ADDED
|
@@ -0,0 +1,209 @@
|
|
|
1
|
+
"""Optional response cache.
|
|
2
|
+
|
|
3
|
+
``MemoryCache`` is the default and is what tests use. ``RedisCache`` speaks the
|
|
4
|
+
same ``get`` / ``set`` interface and is constructed only when the ``redis``
|
|
5
|
+
package is installed (extra ``rrss[cache]``).
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from __future__ import annotations
|
|
9
|
+
|
|
10
|
+
import json
|
|
11
|
+
import os
|
|
12
|
+
import threading
|
|
13
|
+
import time
|
|
14
|
+
from collections.abc import Callable, Mapping
|
|
15
|
+
from typing import Any, Protocol, cast
|
|
16
|
+
|
|
17
|
+
from rrss.adapters.base import BaseAdapter
|
|
18
|
+
from rrss.models import Comment, CursorPage, Post, User
|
|
19
|
+
from rrss.serialize import (
|
|
20
|
+
comments_page_from_dict,
|
|
21
|
+
model_to_dict,
|
|
22
|
+
post_from_dict,
|
|
23
|
+
posts_page_from_dict,
|
|
24
|
+
user_from_dict,
|
|
25
|
+
)
|
|
26
|
+
|
|
27
|
+
# Lower bound of the ranges in the API wrapper plan §9.
|
|
28
|
+
DEFAULT_TTLS: dict[str, int] = {
|
|
29
|
+
"user": 15 * 60,
|
|
30
|
+
"posts": 5 * 60,
|
|
31
|
+
"comments": 60,
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
class CacheBackend(Protocol):
|
|
36
|
+
def get(self, key: str) -> bytes | None: ...
|
|
37
|
+
|
|
38
|
+
def set(self, key: str, value: bytes, *, ttl_seconds: int) -> None: ...
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
class MemoryCache:
|
|
42
|
+
"""Process-local TTL cache. Safe for concurrent gateway threads."""
|
|
43
|
+
|
|
44
|
+
def __init__(self, *, clock: Callable[[], float] | None = None) -> None:
|
|
45
|
+
self._clock = clock or time.monotonic
|
|
46
|
+
self._lock = threading.Lock()
|
|
47
|
+
self._store: dict[str, tuple[bytes, float | None]] = {}
|
|
48
|
+
|
|
49
|
+
def get(self, key: str) -> bytes | None:
|
|
50
|
+
now = self._clock()
|
|
51
|
+
with self._lock:
|
|
52
|
+
item = self._store.get(key)
|
|
53
|
+
if item is None:
|
|
54
|
+
return None
|
|
55
|
+
value, expires = item
|
|
56
|
+
if expires is not None and now >= expires:
|
|
57
|
+
del self._store[key]
|
|
58
|
+
return None
|
|
59
|
+
return value
|
|
60
|
+
|
|
61
|
+
def set(self, key: str, value: bytes, *, ttl_seconds: int) -> None:
|
|
62
|
+
expires = None if ttl_seconds <= 0 else self._clock() + ttl_seconds
|
|
63
|
+
with self._lock:
|
|
64
|
+
self._store[key] = (value, expires)
|
|
65
|
+
|
|
66
|
+
|
|
67
|
+
class RedisLike(Protocol):
|
|
68
|
+
def get(self, key: str) -> bytes | str | None: ...
|
|
69
|
+
|
|
70
|
+
def set(self, key: str, value: bytes, ex: int | None = None) -> object: ...
|
|
71
|
+
|
|
72
|
+
|
|
73
|
+
class RedisCache:
|
|
74
|
+
"""Redis-backed cache. Pass ``client`` in tests to avoid a live server."""
|
|
75
|
+
|
|
76
|
+
def __init__(
|
|
77
|
+
self,
|
|
78
|
+
url: str = "redis://localhost:6379/0",
|
|
79
|
+
*,
|
|
80
|
+
client: RedisLike | None = None,
|
|
81
|
+
) -> None:
|
|
82
|
+
if client is not None:
|
|
83
|
+
self._client = client
|
|
84
|
+
return
|
|
85
|
+
self._client = _connect_redis(url)
|
|
86
|
+
|
|
87
|
+
def get(self, key: str) -> bytes | None:
|
|
88
|
+
raw = self._client.get(key)
|
|
89
|
+
if raw is None:
|
|
90
|
+
return None
|
|
91
|
+
if isinstance(raw, str):
|
|
92
|
+
return raw.encode("utf-8")
|
|
93
|
+
return bytes(raw)
|
|
94
|
+
|
|
95
|
+
def set(self, key: str, value: bytes, *, ttl_seconds: int) -> None:
|
|
96
|
+
if ttl_seconds > 0:
|
|
97
|
+
self._client.set(key, value, ex=ttl_seconds)
|
|
98
|
+
return
|
|
99
|
+
self._client.set(key, value)
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
def cache_from_env() -> CacheBackend:
|
|
103
|
+
"""Use Redis when ``RRSS_REDIS_URL`` is set, otherwise memory."""
|
|
104
|
+
url = os.environ.get("RRSS_REDIS_URL")
|
|
105
|
+
if url:
|
|
106
|
+
return RedisCache(url)
|
|
107
|
+
return MemoryCache()
|
|
108
|
+
|
|
109
|
+
|
|
110
|
+
class CachingAdapter(BaseAdapter):
|
|
111
|
+
"""Wrap an adapter and cache canonical reads."""
|
|
112
|
+
|
|
113
|
+
def __init__(
|
|
114
|
+
self,
|
|
115
|
+
inner: BaseAdapter,
|
|
116
|
+
cache: CacheBackend | None = None,
|
|
117
|
+
*,
|
|
118
|
+
ttls: Mapping[str, int] | None = None,
|
|
119
|
+
) -> None:
|
|
120
|
+
self._inner = inner
|
|
121
|
+
self._cache = cache if cache is not None else MemoryCache()
|
|
122
|
+
self.platform = inner.platform
|
|
123
|
+
self._ttls = dict(DEFAULT_TTLS)
|
|
124
|
+
if ttls:
|
|
125
|
+
self._ttls.update(ttls)
|
|
126
|
+
|
|
127
|
+
def get_user(self, user_ref: str) -> User:
|
|
128
|
+
key = self._key("user", user_ref)
|
|
129
|
+
cached = self._read_json(key)
|
|
130
|
+
if cached is not None:
|
|
131
|
+
return user_from_dict(cached)
|
|
132
|
+
user = self._inner.get_user(user_ref)
|
|
133
|
+
self._write(key, user, "user")
|
|
134
|
+
return user
|
|
135
|
+
|
|
136
|
+
def list_user_posts(
|
|
137
|
+
self,
|
|
138
|
+
user_ref: str,
|
|
139
|
+
*,
|
|
140
|
+
cursor: str | None = None,
|
|
141
|
+
limit: int = 25,
|
|
142
|
+
) -> CursorPage[Post]:
|
|
143
|
+
key = self._key("posts", user_ref, cursor or "", str(limit))
|
|
144
|
+
cached = self._read_json(key)
|
|
145
|
+
if cached is not None:
|
|
146
|
+
return posts_page_from_dict(cached)
|
|
147
|
+
page = self._inner.list_user_posts(user_ref, cursor=cursor, limit=limit)
|
|
148
|
+
self._write(key, page, "posts")
|
|
149
|
+
return page
|
|
150
|
+
|
|
151
|
+
def get_post(self, post_id: str) -> Post:
|
|
152
|
+
key = self._key("post", post_id)
|
|
153
|
+
cached = self._read_json(key)
|
|
154
|
+
if cached is not None:
|
|
155
|
+
return post_from_dict(cached)
|
|
156
|
+
post = self._inner.get_post(post_id)
|
|
157
|
+
self._write(key, post, "posts")
|
|
158
|
+
return post
|
|
159
|
+
|
|
160
|
+
def list_post_comments(
|
|
161
|
+
self,
|
|
162
|
+
post_id: str,
|
|
163
|
+
*,
|
|
164
|
+
cursor: str | None = None,
|
|
165
|
+
limit: int = 25,
|
|
166
|
+
) -> CursorPage[Comment]:
|
|
167
|
+
key = self._key("comments", post_id, cursor or "", str(limit))
|
|
168
|
+
cached = self._read_json(key)
|
|
169
|
+
if cached is not None:
|
|
170
|
+
return comments_page_from_dict(cached)
|
|
171
|
+
page = self._inner.list_post_comments(post_id, cursor=cursor, limit=limit)
|
|
172
|
+
self._write(key, page, "comments")
|
|
173
|
+
return page
|
|
174
|
+
|
|
175
|
+
def _key(self, kind: str, *parts: str) -> str:
|
|
176
|
+
cleaned = [part.replace("\n", "") for part in parts]
|
|
177
|
+
return ":".join(["rrss", "v1", self.platform, kind, *cleaned])
|
|
178
|
+
|
|
179
|
+
def _read_json(self, key: str) -> dict[str, Any] | None:
|
|
180
|
+
raw = self._cache.get(key)
|
|
181
|
+
if raw is None:
|
|
182
|
+
return None
|
|
183
|
+
try:
|
|
184
|
+
loaded = json.loads(raw.decode("utf-8"))
|
|
185
|
+
except (UnicodeDecodeError, json.JSONDecodeError):
|
|
186
|
+
return None
|
|
187
|
+
if not isinstance(loaded, dict):
|
|
188
|
+
return None
|
|
189
|
+
return cast(dict[str, Any], loaded)
|
|
190
|
+
|
|
191
|
+
def _write(
|
|
192
|
+
self,
|
|
193
|
+
key: str,
|
|
194
|
+
model: User | Post | Comment | CursorPage[Any],
|
|
195
|
+
ttl_name: str,
|
|
196
|
+
) -> None:
|
|
197
|
+
payload = json.dumps(model_to_dict(model), ensure_ascii=False).encode("utf-8")
|
|
198
|
+
self._cache.set(key, payload, ttl_seconds=self._ttls[ttl_name])
|
|
199
|
+
|
|
200
|
+
|
|
201
|
+
def _connect_redis(url: str) -> RedisLike:
|
|
202
|
+
try:
|
|
203
|
+
import redis # type: ignore[import-not-found]
|
|
204
|
+
except ImportError as exc:
|
|
205
|
+
raise RuntimeError(
|
|
206
|
+
"redis is not installed; use MemoryCache or pip install 'rrss[cache]'"
|
|
207
|
+
) from exc
|
|
208
|
+
client: RedisLike = redis.Redis.from_url(url)
|
|
209
|
+
return client
|
rrss/cli.py
ADDED
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
"""Command line for canonical reads.
|
|
2
|
+
|
|
3
|
+
Passwords and tokens stay in the environment (see ``.env.example``). The CLI
|
|
4
|
+
never accepts them as flags, and it prints the canonical JSON only.
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
from __future__ import annotations
|
|
8
|
+
|
|
9
|
+
import argparse
|
|
10
|
+
import json
|
|
11
|
+
import sys
|
|
12
|
+
from collections.abc import Callable
|
|
13
|
+
from typing import Any, TextIO
|
|
14
|
+
|
|
15
|
+
from rrss.adapters.base import BaseAdapter
|
|
16
|
+
from rrss.client import Client
|
|
17
|
+
from rrss.errors import RRSSError
|
|
18
|
+
from rrss.serialize import dumps_model
|
|
19
|
+
|
|
20
|
+
ClientFactory = Callable[..., BaseAdapter]
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
def build_parser() -> argparse.ArgumentParser:
|
|
24
|
+
parser = argparse.ArgumentParser(
|
|
25
|
+
prog="rrss",
|
|
26
|
+
description="Read normalized social profiles and posts.",
|
|
27
|
+
)
|
|
28
|
+
sub = parser.add_subparsers(dest="command", required=True)
|
|
29
|
+
pull = sub.add_parser("pull", help="Fetch a canonical resource")
|
|
30
|
+
pull_sub = pull.add_subparsers(dest="resource", required=True)
|
|
31
|
+
user = pull_sub.add_parser("user", help="Fetch a user profile")
|
|
32
|
+
user.add_argument("platform", help="instagram, threads, tiktok, or x")
|
|
33
|
+
user.add_argument("ref", help="Username or platform user id")
|
|
34
|
+
return parser
|
|
35
|
+
|
|
36
|
+
|
|
37
|
+
def main(
|
|
38
|
+
argv: list[str] | None = None,
|
|
39
|
+
*,
|
|
40
|
+
client_factory: ClientFactory | None = None,
|
|
41
|
+
stdout: TextIO | None = None,
|
|
42
|
+
stderr: TextIO | None = None,
|
|
43
|
+
) -> int:
|
|
44
|
+
"""Run the CLI. Returns a process exit code."""
|
|
45
|
+
parser = build_parser()
|
|
46
|
+
args = parser.parse_args(argv)
|
|
47
|
+
out = stdout or sys.stdout
|
|
48
|
+
err = stderr or sys.stderr
|
|
49
|
+
factory = client_factory or Client
|
|
50
|
+
try:
|
|
51
|
+
return _run(args, factory, out)
|
|
52
|
+
except RRSSError as exc:
|
|
53
|
+
_write_error(err, exc.code, str(exc))
|
|
54
|
+
return 1
|
|
55
|
+
except ValueError as exc:
|
|
56
|
+
_write_error(err, "BAD_REQUEST", str(exc))
|
|
57
|
+
return 2
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def _run(args: argparse.Namespace, factory: ClientFactory, out: TextIO) -> int:
|
|
61
|
+
if args.command == "pull" and args.resource == "user":
|
|
62
|
+
adapter = factory(args.platform)
|
|
63
|
+
user = adapter.get_user(args.ref)
|
|
64
|
+
out.write(dumps_model(user, pretty=True))
|
|
65
|
+
out.write("\n")
|
|
66
|
+
return 0
|
|
67
|
+
_write_error(out, "BAD_REQUEST", "unsupported command")
|
|
68
|
+
return 2
|
|
69
|
+
|
|
70
|
+
|
|
71
|
+
def _write_error(stream: TextIO, code: str, message: str) -> None:
|
|
72
|
+
payload: dict[str, Any] = {"error": {"code": code, "message": message}}
|
|
73
|
+
stream.write(json.dumps(payload))
|
|
74
|
+
stream.write("\n")
|
|
75
|
+
|
|
76
|
+
|
|
77
|
+
if __name__ == "__main__":
|
|
78
|
+
raise SystemExit(main())
|
rrss/client.py
ADDED
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
from rrss.adapters.base import BaseAdapter
|
|
6
|
+
from rrss.adapters.instagram import InstagramAdapter
|
|
7
|
+
from rrss.adapters.threads import ThreadsAdapter
|
|
8
|
+
from rrss.adapters.tiktok import TikTokAdapter
|
|
9
|
+
from rrss.adapters.x import XAdapter
|
|
10
|
+
from rrss.errors import NotSupported
|
|
11
|
+
from rrss.models import Comment, CursorPage, Post, User
|
|
12
|
+
from rrss.stream import iter_user_posts
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
def Client(platform: str, **kwargs: Any) -> BaseAdapter:
|
|
16
|
+
"""Factory returning a platform adapter."""
|
|
17
|
+
key = platform.lower().strip()
|
|
18
|
+
if key == "instagram":
|
|
19
|
+
return InstagramAdapter(**kwargs)
|
|
20
|
+
if key == "threads":
|
|
21
|
+
return ThreadsAdapter(**kwargs)
|
|
22
|
+
if key == "tiktok":
|
|
23
|
+
return TikTokAdapter(**kwargs)
|
|
24
|
+
if key in ("x", "twitter"):
|
|
25
|
+
return XAdapter(**kwargs)
|
|
26
|
+
if key == "facebook":
|
|
27
|
+
raise NotSupported(
|
|
28
|
+
"Facebook adapter is deferred; see docs/platforms/facebook-v1-deferral.md"
|
|
29
|
+
" and https://developers.facebook.com/docs/graph-api",
|
|
30
|
+
)
|
|
31
|
+
raise ValueError(f"Unknown platform: {platform!r}")
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
# Re-export types for `from rrss.client import ...` ergonomics.
|
|
35
|
+
__all__ = ["Client", "Comment", "CursorPage", "Post", "User", "iter_user_posts"]
|
rrss/errors.py
ADDED
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
class RRSSError(Exception):
|
|
5
|
+
"""Base error for the rrss package."""
|
|
6
|
+
|
|
7
|
+
code: str = "PLATFORM_ERROR"
|
|
8
|
+
|
|
9
|
+
def __init__(self, message: str, *, detail: object | None = None) -> None:
|
|
10
|
+
super().__init__(message)
|
|
11
|
+
self.detail = detail
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class AuthFailed(RRSSError):
|
|
15
|
+
code = "AUTH_FAILED"
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
class RateLimited(RRSSError):
|
|
19
|
+
code = "RATE_LIMITED"
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
class NotFound(RRSSError):
|
|
23
|
+
code = "NOT_FOUND"
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
class NotSupported(RRSSError):
|
|
27
|
+
code = "NOT_SUPPORTED"
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
class PlatformError(RRSSError):
|
|
31
|
+
code = "PLATFORM_ERROR"
|
rrss/gateway.py
ADDED
|
@@ -0,0 +1,306 @@
|
|
|
1
|
+
"""Minimal HTTP gateway for canonical reads.
|
|
2
|
+
|
|
3
|
+
Stdlib only, so tests can boot it without FastAPI. Platform credentials stay in
|
|
4
|
+
the adapter factory (environment or an injected client). Callers send
|
|
5
|
+
``X-RRSS-Key`` when the gateway is constructed with ``api_key``.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from __future__ import annotations
|
|
9
|
+
|
|
10
|
+
import hmac
|
|
11
|
+
import json
|
|
12
|
+
import os
|
|
13
|
+
import re
|
|
14
|
+
import threading
|
|
15
|
+
from collections.abc import Callable, Mapping
|
|
16
|
+
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
17
|
+
from pathlib import Path
|
|
18
|
+
from typing import Any, cast
|
|
19
|
+
from urllib.parse import parse_qs, unquote, urlsplit
|
|
20
|
+
|
|
21
|
+
from rrss.adapters.base import BaseAdapter
|
|
22
|
+
from rrss.cache import CacheBackend, CachingAdapter, cache_from_env
|
|
23
|
+
from rrss.client import Client
|
|
24
|
+
from rrss.errors import RRSSError
|
|
25
|
+
from rrss.serialize import dumps_model
|
|
26
|
+
from rrss.stream import WebhookStub
|
|
27
|
+
|
|
28
|
+
ClientFactory = Callable[..., BaseAdapter]
|
|
29
|
+
|
|
30
|
+
_STATUS = {
|
|
31
|
+
"AUTH_FAILED": 401,
|
|
32
|
+
"RATE_LIMITED": 429,
|
|
33
|
+
"NOT_FOUND": 404,
|
|
34
|
+
"NOT_SUPPORTED": 501,
|
|
35
|
+
"PLATFORM_ERROR": 502,
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
_USER_RE = re.compile(r"^/v1/(?P<platform>[A-Za-z0-9_]+)/users/(?P<user_ref>[^/]+)$")
|
|
39
|
+
_POSTS_RE = re.compile(r"^/v1/(?P<platform>[A-Za-z0-9_]+)/users/(?P<user_ref>[^/]+)/posts$")
|
|
40
|
+
_POST_RE = re.compile(r"^/v1/(?P<platform>[A-Za-z0-9_]+)/posts/(?P<post_id>[^/]+)$")
|
|
41
|
+
_COMMENTS_RE = re.compile(r"^/v1/(?P<platform>[A-Za-z0-9_]+)/posts/(?P<post_id>[^/]+)/comments$")
|
|
42
|
+
|
|
43
|
+
_PUBLIC_GET = {"/health", "/openapi.yaml"}
|
|
44
|
+
_DEFERRED = {"facebook"}
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
class _HTTPAbort(Exception):
|
|
48
|
+
def __init__(self, status: int, code: str, message: str) -> None:
|
|
49
|
+
super().__init__(message)
|
|
50
|
+
self.status = status
|
|
51
|
+
self.code = code
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
class Gateway:
|
|
55
|
+
"""Read-only HTTP surface over ``rrss.Client``."""
|
|
56
|
+
|
|
57
|
+
def __init__(
|
|
58
|
+
self,
|
|
59
|
+
*,
|
|
60
|
+
client_factory: ClientFactory | None = None,
|
|
61
|
+
api_key: str | None = None,
|
|
62
|
+
cache: CacheBackend | None = None,
|
|
63
|
+
webhooks: WebhookStub | None = None,
|
|
64
|
+
openapi_file: Path | None = None,
|
|
65
|
+
) -> None:
|
|
66
|
+
self._client_factory = client_factory or Client
|
|
67
|
+
self._api_key = api_key
|
|
68
|
+
self._cache = cache
|
|
69
|
+
self.webhooks = webhooks or WebhookStub()
|
|
70
|
+
self._openapi_file = openapi_file or default_openapi_path()
|
|
71
|
+
self._httpd: ThreadingHTTPServer | None = None
|
|
72
|
+
self._thread: threading.Thread | None = None
|
|
73
|
+
|
|
74
|
+
def dispatch(
|
|
75
|
+
self,
|
|
76
|
+
method: str,
|
|
77
|
+
target: str,
|
|
78
|
+
headers: Mapping[str, str],
|
|
79
|
+
body: bytes,
|
|
80
|
+
) -> tuple[int, dict[str, str], bytes]:
|
|
81
|
+
try:
|
|
82
|
+
return self._dispatch(method.upper(), target, headers, body)
|
|
83
|
+
except _HTTPAbort as exc:
|
|
84
|
+
return _error(exc.status, exc.code, str(exc))
|
|
85
|
+
except RRSSError as exc:
|
|
86
|
+
return _error(_STATUS.get(exc.code, 502), exc.code, str(exc))
|
|
87
|
+
except ValueError as exc:
|
|
88
|
+
return _error(400, "BAD_REQUEST", str(exc))
|
|
89
|
+
|
|
90
|
+
def start(self, host: str = "127.0.0.1", port: int = 0) -> tuple[str, int]:
|
|
91
|
+
if self._httpd is not None:
|
|
92
|
+
raise RuntimeError("gateway already started")
|
|
93
|
+
self._httpd = ThreadingHTTPServer((host, port), self._handler_class())
|
|
94
|
+
self._thread = threading.Thread(
|
|
95
|
+
target=self._httpd.serve_forever,
|
|
96
|
+
name="rrss-gateway",
|
|
97
|
+
daemon=True,
|
|
98
|
+
)
|
|
99
|
+
self._thread.start()
|
|
100
|
+
bound = self._httpd.server_address
|
|
101
|
+
return str(bound[0]), int(bound[1])
|
|
102
|
+
|
|
103
|
+
def stop(self) -> None:
|
|
104
|
+
httpd = self._httpd
|
|
105
|
+
thread = self._thread
|
|
106
|
+
if httpd is None:
|
|
107
|
+
return
|
|
108
|
+
httpd.shutdown()
|
|
109
|
+
httpd.server_close()
|
|
110
|
+
if thread is not None:
|
|
111
|
+
thread.join(timeout=5)
|
|
112
|
+
self._httpd = None
|
|
113
|
+
self._thread = None
|
|
114
|
+
|
|
115
|
+
def serve(self, host: str = "127.0.0.1", port: int = 8080) -> None:
|
|
116
|
+
httpd = ThreadingHTTPServer((host, port), self._handler_class())
|
|
117
|
+
try:
|
|
118
|
+
httpd.serve_forever()
|
|
119
|
+
finally:
|
|
120
|
+
httpd.server_close()
|
|
121
|
+
|
|
122
|
+
def _dispatch(
|
|
123
|
+
self,
|
|
124
|
+
method: str,
|
|
125
|
+
target: str,
|
|
126
|
+
headers: Mapping[str, str],
|
|
127
|
+
body: bytes,
|
|
128
|
+
) -> tuple[int, dict[str, str], bytes]:
|
|
129
|
+
parsed = urlsplit(target)
|
|
130
|
+
path = parsed.path.rstrip("/") or "/"
|
|
131
|
+
if path not in _PUBLIC_GET and not _authorized(headers, self._api_key):
|
|
132
|
+
raise _HTTPAbort(401, "AUTH_FAILED", "Missing or invalid X-RRSS-Key")
|
|
133
|
+
if path == "/health":
|
|
134
|
+
_require_method(method, "GET")
|
|
135
|
+
return _json(200, {"ok": True})
|
|
136
|
+
if path == "/openapi.yaml":
|
|
137
|
+
_require_method(method, "GET")
|
|
138
|
+
return self._openapi()
|
|
139
|
+
if path == "/v1/webhooks":
|
|
140
|
+
_require_method(method, "POST")
|
|
141
|
+
return self._webhook(body)
|
|
142
|
+
query = parse_qs(parsed.query, keep_blank_values=True)
|
|
143
|
+
match = _USER_RE.match(path)
|
|
144
|
+
if match and method == "GET":
|
|
145
|
+
adapter = self._adapter(match.group("platform"))
|
|
146
|
+
user = adapter.get_user(unquote(match.group("user_ref")))
|
|
147
|
+
return _raw(200, dumps_model(user).encode("utf-8"))
|
|
148
|
+
match = _POSTS_RE.match(path)
|
|
149
|
+
if match and method == "GET":
|
|
150
|
+
adapter = self._adapter(match.group("platform"))
|
|
151
|
+
page = adapter.list_user_posts(
|
|
152
|
+
unquote(match.group("user_ref")),
|
|
153
|
+
cursor=_cursor(query),
|
|
154
|
+
limit=_limit(query),
|
|
155
|
+
)
|
|
156
|
+
return _raw(200, dumps_model(page).encode("utf-8"))
|
|
157
|
+
match = _POST_RE.match(path)
|
|
158
|
+
if match and method == "GET":
|
|
159
|
+
adapter = self._adapter(match.group("platform"))
|
|
160
|
+
post = adapter.get_post(unquote(match.group("post_id")))
|
|
161
|
+
return _raw(200, dumps_model(post).encode("utf-8"))
|
|
162
|
+
match = _COMMENTS_RE.match(path)
|
|
163
|
+
if match and method == "GET":
|
|
164
|
+
adapter = self._adapter(match.group("platform"))
|
|
165
|
+
comments = adapter.list_post_comments(
|
|
166
|
+
unquote(match.group("post_id")),
|
|
167
|
+
cursor=_cursor(query),
|
|
168
|
+
limit=_limit(query),
|
|
169
|
+
)
|
|
170
|
+
return _raw(200, dumps_model(comments).encode("utf-8"))
|
|
171
|
+
if any(pattern.match(path) for pattern in (_USER_RE, _POSTS_RE, _POST_RE, _COMMENTS_RE)):
|
|
172
|
+
raise _HTTPAbort(405, "BAD_REQUEST", "method not allowed")
|
|
173
|
+
raise _HTTPAbort(404, "NOT_FOUND", f"No route for {path}")
|
|
174
|
+
|
|
175
|
+
def _adapter(self, platform: str) -> BaseAdapter:
|
|
176
|
+
key = platform.lower()
|
|
177
|
+
if key in _DEFERRED:
|
|
178
|
+
raise _HTTPAbort(501, "NOT_SUPPORTED", "Facebook adapter is deferred")
|
|
179
|
+
inner = self._client_factory(key)
|
|
180
|
+
if self._cache is None:
|
|
181
|
+
return inner
|
|
182
|
+
return CachingAdapter(inner, self._cache)
|
|
183
|
+
|
|
184
|
+
def _webhook(self, body: bytes) -> tuple[int, dict[str, str], bytes]:
|
|
185
|
+
try:
|
|
186
|
+
text = body.decode("utf-8") if body else ""
|
|
187
|
+
parsed = json.loads(text) if text else None
|
|
188
|
+
except (UnicodeDecodeError, json.JSONDecodeError) as exc:
|
|
189
|
+
raise _HTTPAbort(400, "BAD_REQUEST", "webhook body must be JSON") from exc
|
|
190
|
+
if not isinstance(parsed, dict):
|
|
191
|
+
raise _HTTPAbort(400, "BAD_REQUEST", "webhook body must be a JSON object")
|
|
192
|
+
try:
|
|
193
|
+
event = self.webhooks.accept(cast(dict[str, Any], parsed))
|
|
194
|
+
except TypeError as exc:
|
|
195
|
+
raise _HTTPAbort(400, "BAD_REQUEST", str(exc)) from exc
|
|
196
|
+
return _json(202, {"accepted": True, "event": event.event, "platform": event.platform})
|
|
197
|
+
|
|
198
|
+
def _openapi(self) -> tuple[int, dict[str, str], bytes]:
|
|
199
|
+
path = self._openapi_file
|
|
200
|
+
if not path.is_file():
|
|
201
|
+
raise _HTTPAbort(404, "NOT_FOUND", "OpenAPI spec is not available")
|
|
202
|
+
payload = path.read_bytes()
|
|
203
|
+
return 200, {"Content-Type": "application/yaml; charset=utf-8"}, payload
|
|
204
|
+
|
|
205
|
+
def _handler_class(self) -> type[BaseHTTPRequestHandler]:
|
|
206
|
+
gateway = self
|
|
207
|
+
|
|
208
|
+
class Handler(BaseHTTPRequestHandler):
|
|
209
|
+
def do_GET(self) -> None: # noqa: N802
|
|
210
|
+
self._respond("GET")
|
|
211
|
+
|
|
212
|
+
def do_POST(self) -> None: # noqa: N802
|
|
213
|
+
self._respond("POST")
|
|
214
|
+
|
|
215
|
+
def _respond(self, method: str) -> None:
|
|
216
|
+
length = int(self.headers.get("Content-Length", "0") or 0)
|
|
217
|
+
payload = self.rfile.read(length) if length else b""
|
|
218
|
+
header_map = {key: value for key, value in self.headers.items()}
|
|
219
|
+
status, headers, body = gateway.dispatch(method, self.path, header_map, payload)
|
|
220
|
+
self.send_response(status)
|
|
221
|
+
for key, value in headers.items():
|
|
222
|
+
self.send_header(key, value)
|
|
223
|
+
self.send_header("Content-Length", str(len(body)))
|
|
224
|
+
self.end_headers()
|
|
225
|
+
self.wfile.write(body)
|
|
226
|
+
|
|
227
|
+
def log_message(self, fmt: str, *args: object) -> None:
|
|
228
|
+
# Request lines can carry user refs. Keep them out of stderr.
|
|
229
|
+
del fmt, args
|
|
230
|
+
|
|
231
|
+
return Handler
|
|
232
|
+
|
|
233
|
+
|
|
234
|
+
def default_openapi_path() -> Path:
|
|
235
|
+
env = os.environ.get("RRSS_OPENAPI_PATH")
|
|
236
|
+
if env:
|
|
237
|
+
return Path(env)
|
|
238
|
+
packaged = Path(__file__).resolve().parent / "schemas" / "openapi.yaml"
|
|
239
|
+
repo = Path(__file__).resolve().parents[1] / "schemas" / "openapi.yaml"
|
|
240
|
+
if packaged.is_file():
|
|
241
|
+
return packaged
|
|
242
|
+
return repo
|
|
243
|
+
|
|
244
|
+
|
|
245
|
+
def main() -> None:
|
|
246
|
+
host = os.environ.get("RRSS_GATEWAY_HOST", "127.0.0.1")
|
|
247
|
+
port = int(os.environ.get("RRSS_GATEWAY_PORT", "8080"))
|
|
248
|
+
api_key = os.environ.get("RRSS_GATEWAY_API_KEY") or None
|
|
249
|
+
cache = cache_from_env() if os.environ.get("RRSS_REDIS_URL") else None
|
|
250
|
+
gateway = Gateway(api_key=api_key, cache=cache)
|
|
251
|
+
print(f"rrss gateway http://{host}:{port}", flush=True)
|
|
252
|
+
gateway.serve(host, port)
|
|
253
|
+
|
|
254
|
+
|
|
255
|
+
def _authorized(headers: Mapping[str, str], api_key: str | None) -> bool:
|
|
256
|
+
if not api_key:
|
|
257
|
+
return True
|
|
258
|
+
provided = _header(headers, "X-RRSS-Key") or ""
|
|
259
|
+
return hmac.compare_digest(provided.encode("utf-8"), api_key.encode("utf-8"))
|
|
260
|
+
|
|
261
|
+
|
|
262
|
+
def _header(headers: Mapping[str, str], name: str) -> str | None:
|
|
263
|
+
wanted = name.lower()
|
|
264
|
+
for key, value in headers.items():
|
|
265
|
+
if key.lower() == wanted:
|
|
266
|
+
return value
|
|
267
|
+
return None
|
|
268
|
+
|
|
269
|
+
|
|
270
|
+
def _require_method(method: str, expected: str) -> None:
|
|
271
|
+
if method != expected:
|
|
272
|
+
raise _HTTPAbort(405, "BAD_REQUEST", "method not allowed")
|
|
273
|
+
|
|
274
|
+
|
|
275
|
+
def _cursor(query: Mapping[str, list[str]]) -> str | None:
|
|
276
|
+
values = query.get("cursor")
|
|
277
|
+
if not values or values[0] == "":
|
|
278
|
+
return None
|
|
279
|
+
return values[0]
|
|
280
|
+
|
|
281
|
+
|
|
282
|
+
def _limit(query: Mapping[str, list[str]]) -> int:
|
|
283
|
+
raw = (query.get("limit") or ["25"])[0]
|
|
284
|
+
try:
|
|
285
|
+
value = int(raw)
|
|
286
|
+
except ValueError as exc:
|
|
287
|
+
raise _HTTPAbort(400, "BAD_REQUEST", "limit must be an integer") from exc
|
|
288
|
+
if value < 1 or value > 100:
|
|
289
|
+
raise _HTTPAbort(400, "BAD_REQUEST", "limit must be between 1 and 100")
|
|
290
|
+
return value
|
|
291
|
+
|
|
292
|
+
|
|
293
|
+
def _json(status: int, payload: dict[str, Any]) -> tuple[int, dict[str, str], bytes]:
|
|
294
|
+
return _raw(status, json.dumps(payload).encode("utf-8"))
|
|
295
|
+
|
|
296
|
+
|
|
297
|
+
def _raw(status: int, body: bytes) -> tuple[int, dict[str, str], bytes]:
|
|
298
|
+
return status, {"Content-Type": "application/json; charset=utf-8"}, body
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
def _error(status: int, code: str, message: str) -> tuple[int, dict[str, str], bytes]:
|
|
302
|
+
return _json(status, {"error": {"code": code, "message": message}})
|
|
303
|
+
|
|
304
|
+
|
|
305
|
+
if __name__ == "__main__":
|
|
306
|
+
main()
|