httpee 0.1.0__tar.gz

httpee-0.1.0/LICENSE

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

httpee-0.1.0/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: httpee
+Version: 0.1.0
+Summary: httpee — thin httpx wrapper for eelang pipelines
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Dynamic: license-file
+
+# httpee
+
+`httpee` is a thin wrapper around [httpx](https://www.python-httpx.org/) for
+[eelang](https://github.com/eel-lang/eelang-py): requests are written as pipelines,
+responses are checked with patterns.
+
+```python
+from httpee import POST, headers, httpee, Response
+
+user =
+    {'name': 'kenneth', 'role': 'admin'}      # dict → form-encoded, like requests data=
+    ..headers: {'Authorization': f'Bearer {token}'}
+    ..POST: 'https://api.example.com/users'
+    ..assert:
+        Response(status=201)
+
+page =
+    httpee()                                  # empty request — no body
+    ..query: {'page': 2}
+    ..GET: 'https://api.example.com/users'
+    ..assert:
+        Response(status=200)
+```
+
+## Cheatsheet
+
+```python
+from httpee import (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, send,
+                    httpee, headers, query, timeout, cookies, auth, json,
+                    method, url, Response)
+from eelang import MatchError
+```
+
+### A request is a pipeline
+
+```python
+r =
+    {'name': 'kenneth', 'role': 'admin'}     # dict → form-encoded
+    ..headers: {'X-Key': v}                  # headers (repeats add keys)
+    ..query: {'page': 2}                     # query parameters (repeats add keys)
+    ..POST: 'https://api.example.com/users'  # verb performs the request
+    ..assert:
+        Response(status=201)                 # failure → MatchError
+```
+
+### Bodies
+
+| Value | Sent as |
+|---|---|
+| dict | form-encoded (`data=`, like requests) |
+| str | text |
+| bytes | raw bytes |
+| `httpee()` | empty request — no body |
+| `..json: {…}` | JSON — takes precedence over the pipeline body |
+
+### Dynamic method — `..send()`
+
+```python
+r =
+    {'role': 'moderator'}
+    ..method: m                          # any method, even from a variable
+    ..url: 'https://…'
+    ..send()                             # without ..method: defaults to GET
+    ..assert:
+        Response(status=200)
+```
+
+### Pattern checks
+
+```python
+# ..assert: — shape check, binds variables, failure → MatchError
+p =
+    httpee()
+    ..GET: url
+    ..assert:
+        Response(status=s)               # s is available afterwards
+
+# ..match: — branch on status; no match → the value is unchanged
+verdict =
+    httpee()
+    ..GET: url
+    ..match:
+        case Response(status=200): 'ok'
+        case Response(status=n): f'HTTP {n}'
+```
+
+### Errors
+
+- 4xx/5xx do **not** raise: check the status with a pattern.
+- Network errors and timeouts are httpx exceptions (`ConnectError`, `TimeoutException`).
+- `Response` is `httpx.Response` plus `.status`: `.json()`, `.text`, `.headers` work as usual.
+
+### Modifiers at a glance
+
+`..headers:` · `..query:` · `..timeout: 5.0` · `..cookies:` · `..auth: (u, p)` · `..json:` · `..method:` · `..url:`
+
+## How it works
+
+- The pipeline's initial value is the request body: dict → form-encoded, str → text,
+  bytes → raw bytes. JSON goes through an explicit `..json: {…}`. A request without
+  a body starts with `httpee()`.
+- Modifiers accumulate parameters (repeatable, in any order); the verb at the end
+  performs the request and returns a `Response`.
+- 4xx/5xx do not raise — the status is checked with a pattern; a failed `..assert:`
+  raises `MatchError`. Network errors and timeouts are httpx exceptions.
+
+## Verbs
+
+| Verb | Example | What it does |
+|---|---|---|
+| `GET` … `OPTIONS` | `..GET: url` | performs the request with this method |
+| `send` | `..send()` | performs the request with a previously set `..method:`/`..url:` |
+
+The method can be set up front — and can be anything:
+
+```python
+patch =
+    {'role': 'moderator'}
+    ..method: 'PATCH'                          # or from a variable
+    ..url: 'https://api.example.com/users/1'
+    ..send()
+    ..assert:
+        Response(status=200)
+```
+
+## Modifiers
+
+| Modifier | Example | What it does |
+|---|---|---|
+| `headers` | `..headers: {'X-Key': v}` | headers (repeats add keys) |
+| `query` | `..query: {'page': 2}` | URL query parameters (repeats add keys) |
+| `timeout` | `..timeout: 5.0` | request timeout, seconds |
+| `cookies` | `..cookies: {'sid': v}` | cookies |
+| `auth` | `..auth: ('user', 'pass')` | basic auth (any `httpx.Auth` works) |
+| `json` | `..json: {…}` | JSON body (takes precedence over the pipeline body) |
+| `method` | `..method: 'PATCH'` | method up front — for `..send()` |
+| `url` | `..url: 'https://…'` | URL up front — for `..send()` |
+
+## Installation
+
+```sh
+pip install httpee
+```
+
+From source:
+
+```sh
+git clone https://github.com/eel-lang/httpee
+pip install ./httpee
+```
+
+Requires CPython 3.15 + [eelang](https://github.com/eel-lang/eelang-py) to run `.eel`
+files — the package itself is plain Python, and httpx is its only dependency.
+Works under gevent (`gevent.monkey.patch_all()`).
+
+## Tests
+
+```sh
+python -m unittest discover -s tests
+```
+
+## License
+
+MIT (`LICENSE`).

httpee-0.1.0/README.md

@@ -0,0 +1,164 @@
+# httpee
+
+`httpee` is a thin wrapper around [httpx](https://www.python-httpx.org/) for
+[eelang](https://github.com/eel-lang/eelang-py): requests are written as pipelines,
+responses are checked with patterns.
+
+```python
+from httpee import POST, headers, httpee, Response
+
+user =
+    {'name': 'kenneth', 'role': 'admin'}      # dict → form-encoded, like requests data=
+    ..headers: {'Authorization': f'Bearer {token}'}
+    ..POST: 'https://api.example.com/users'
+    ..assert:
+        Response(status=201)
+
+page =
+    httpee()                                  # empty request — no body
+    ..query: {'page': 2}
+    ..GET: 'https://api.example.com/users'
+    ..assert:
+        Response(status=200)
+```
+
+## Cheatsheet
+
+```python
+from httpee import (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, send,
+                    httpee, headers, query, timeout, cookies, auth, json,
+                    method, url, Response)
+from eelang import MatchError
+```
+
+### A request is a pipeline
+
+```python
+r =
+    {'name': 'kenneth', 'role': 'admin'}     # dict → form-encoded
+    ..headers: {'X-Key': v}                  # headers (repeats add keys)
+    ..query: {'page': 2}                     # query parameters (repeats add keys)
+    ..POST: 'https://api.example.com/users'  # verb performs the request
+    ..assert:
+        Response(status=201)                 # failure → MatchError
+```
+
+### Bodies
+
+| Value | Sent as |
+|---|---|
+| dict | form-encoded (`data=`, like requests) |
+| str | text |
+| bytes | raw bytes |
+| `httpee()` | empty request — no body |
+| `..json: {…}` | JSON — takes precedence over the pipeline body |
+
+### Dynamic method — `..send()`
+
+```python
+r =
+    {'role': 'moderator'}
+    ..method: m                          # any method, even from a variable
+    ..url: 'https://…'
+    ..send()                             # without ..method: defaults to GET
+    ..assert:
+        Response(status=200)
+```
+
+### Pattern checks
+
+```python
+# ..assert: — shape check, binds variables, failure → MatchError
+p =
+    httpee()
+    ..GET: url
+    ..assert:
+        Response(status=s)               # s is available afterwards
+
+# ..match: — branch on status; no match → the value is unchanged
+verdict =
+    httpee()
+    ..GET: url
+    ..match:
+        case Response(status=200): 'ok'
+        case Response(status=n): f'HTTP {n}'
+```
+
+### Errors
+
+- 4xx/5xx do **not** raise: check the status with a pattern.
+- Network errors and timeouts are httpx exceptions (`ConnectError`, `TimeoutException`).
+- `Response` is `httpx.Response` plus `.status`: `.json()`, `.text`, `.headers` work as usual.
+
+### Modifiers at a glance
+
+`..headers:` · `..query:` · `..timeout: 5.0` · `..cookies:` · `..auth: (u, p)` · `..json:` · `..method:` · `..url:`
+
+## How it works
+
+- The pipeline's initial value is the request body: dict → form-encoded, str → text,
+  bytes → raw bytes. JSON goes through an explicit `..json: {…}`. A request without
+  a body starts with `httpee()`.
+- Modifiers accumulate parameters (repeatable, in any order); the verb at the end
+  performs the request and returns a `Response`.
+- 4xx/5xx do not raise — the status is checked with a pattern; a failed `..assert:`
+  raises `MatchError`. Network errors and timeouts are httpx exceptions.
+
+## Verbs
+
+| Verb | Example | What it does |
+|---|---|---|
+| `GET` … `OPTIONS` | `..GET: url` | performs the request with this method |
+| `send` | `..send()` | performs the request with a previously set `..method:`/`..url:` |
+
+The method can be set up front — and can be anything:
+
+```python
+patch =
+    {'role': 'moderator'}
+    ..method: 'PATCH'                          # or from a variable
+    ..url: 'https://api.example.com/users/1'
+    ..send()
+    ..assert:
+        Response(status=200)
+```
+
+## Modifiers
+
+| Modifier | Example | What it does |
+|---|---|---|
+| `headers` | `..headers: {'X-Key': v}` | headers (repeats add keys) |
+| `query` | `..query: {'page': 2}` | URL query parameters (repeats add keys) |
+| `timeout` | `..timeout: 5.0` | request timeout, seconds |
+| `cookies` | `..cookies: {'sid': v}` | cookies |
+| `auth` | `..auth: ('user', 'pass')` | basic auth (any `httpx.Auth` works) |
+| `json` | `..json: {…}` | JSON body (takes precedence over the pipeline body) |
+| `method` | `..method: 'PATCH'` | method up front — for `..send()` |
+| `url` | `..url: 'https://…'` | URL up front — for `..send()` |
+
+## Installation
+
+```sh
+pip install httpee
+```
+
+From source:
+
+```sh
+git clone https://github.com/eel-lang/httpee
+pip install ./httpee
+```
+
+Requires CPython 3.15 + [eelang](https://github.com/eel-lang/eelang-py) to run `.eel`
+files — the package itself is plain Python, and httpx is its only dependency.
+Works under gevent (`gevent.monkey.patch_all()`).
+
+## Tests
+
+```sh
+python -m unittest discover -s tests
+```
+
+## License
+
+MIT (`LICENSE`).

httpee-0.1.0/httpee/__init__.py

@@ -0,0 +1,204 @@
+"""httpee — HTTP для людей. Теперь пайплайнами.
+
+Тонкая обёртка над httpx для eelang: запрос собирается пайплайном, результат
+проверяется паттернами::
+
+    from httpee import POST, headers, Response
+
+    user =
+        {'name': 'kenneth', 'role': 'admin'}
+        ..headers: {'Authorization': 'Bearer ...'}
+        ..POST: 'https://api.example.com/users'
+        ..assert:
+            Response(status=201)
+
+    page =
+        httpee()
+        ..GET: 'https://api.example.com/users'
+        ..assert:
+            Response(status=200)
+
+4xx/5xx исключений не вызывают — статус проверяется ``..assert:``/``..match:``.
+"""
+
+import httpx
+
+__version__ = "0.1.0"
+
+
+class Response(httpx.Response):
+    """httpx.Response + свойство ``status`` для паттерна ``Response(status=200)``.
+
+    Остальное — родное: ``.json()``, ``.text``, ``.content``, ``.headers``,
+    ``.raise_for_status()``.
+    """
+
+    @property
+    def status(self):
+        return self.status_code
+
+
+class _Request:
+    """Накопленное состояние запроса. Пользователю не виден."""
+
+    __slots__ = ('method', 'url', 'body', 'json_body', 'headers', 'params',
+                 'timeout', 'cookies', 'auth')
+
+    def __init__(self, body=None):
+        self.method = None
+        self.url = None
+        self.body = body
+        self.json_body = None
+        self.headers = {}
+        self.params = {}
+        self.timeout = None
+        self.cookies = None
+        self.auth = None
+
+
+def httpee():
+    """Пустой запрос: httpee() ..GET: url — когда тела нет."""
+    return _Request()
+
+
+def _ensure(value):
+    """Тело или _Request → _Request; на Response — внятный TypeError."""
+    if isinstance(value, Response):
+        raise TypeError(
+            'это уже Response — модификаторы и глаголы идут до выполнения запроса')
+    return value if isinstance(value, _Request) else _Request(body=value)
+
+
+def _wrap(resp):
+    """httpx.Response → httpee.Response (для class-паттернов)."""
+    return Response(
+        resp.status_code,
+        headers=resp.headers,
+        content=resp.content,
+        request=resp.request,
+        extensions=resp.extensions,
+        history=resp.history,
+        default_encoding=resp.default_encoding,
+    )
+
+
+def _execute(req):
+    """Отправить _Request новым httpx.Client и вернуть Response."""
+    if req.url is None:
+        raise TypeError(
+            'запрос без адреса: задайте ..url: или вызовите ..GET:/..POST: с адресом')
+    method = (req.method or 'GET').upper()
+    kwargs = {}
+    if req.json_body is not None:
+        kwargs['json'] = req.json_body
+    else:
+        body = req.body
+        if body is None:
+            pass
+        elif isinstance(body, dict):
+            kwargs['data'] = body
+        elif isinstance(body, str):
+            kwargs['content'] = body.encode()
+        elif isinstance(body, (bytes, bytearray, memoryview)):
+            kwargs['content'] = bytes(body)
+        else:
+            raise TypeError(
+                f'неподдерживаемое тело запроса: {type(body).__name__} '
+                '(ожидаются dict/str/bytes)')
+    with httpx.Client(timeout=req.timeout) as client:
+        resp = client.request(method, req.url, headers=req.headers or None,
+                              params=req.params or None, cookies=req.cookies,
+                              auth=req.auth, **kwargs)
+    return _wrap(resp)
+
+
+def _verb(method):
+    """Глагол: ..GET: url → GET(url, значение) — выполняет запрос сразу."""
+
+    def run(url, value):
+        req = _ensure(value)
+        req.method = method
+        req.url = url
+        return _execute(req)
+
+    run.__name__ = method
+    run.__qualname__ = method
+    run.__doc__ = (
+        f'Выполнить {method}-запрос: ..{method}: url. '
+        'Значение пайплайна — тело или накопленный запрос.')
+    return run
+
+
+GET = _verb('GET')
+POST = _verb('POST')
+PUT = _verb('PUT')
+PATCH = _verb('PATCH')
+DELETE = _verb('DELETE')
+HEAD = _verb('HEAD')
+OPTIONS = _verb('OPTIONS')
+
+
+def send(value):
+    """Выполнить запрос с заранее заданными ..method:/..url: (..send())."""
+    return _execute(_ensure(value))
+
+
+def headers(headers_value, value):
+    """..headers: {...} — заголовки запроса (повторные вызовы дополняют)."""
+    req = _ensure(value)
+    req.headers.update(dict(headers_value))
+    return req
+
+
+def query(params_value, value):
+    """..query: {...} — query-параметры URL (повторные вызовы дополняют)."""
+    req = _ensure(value)
+    req.params.update(dict(params_value))
+    return req
+
+
+def timeout(timeout_value, value):
+    """..timeout: 5.0 — таймаут запроса в секундах."""
+    req = _ensure(value)
+    req.timeout = timeout_value
+    return req
+
+
+def cookies(cookies_value, value):
+    """..cookies: {...} — куки запроса."""
+    req = _ensure(value)
+    req.cookies = cookies_value
+    return req
+
+
+def auth(auth_value, value):
+    """..auth: ('user', 'pass') — basic-auth; можно httpx.Auth."""
+    req = _ensure(value)
+    req.auth = auth_value
+    return req
+
+
+def json(json_value, value):
+    """..json: {...} — тело JSON-ом (побеждает над телом пайплайна)."""
+    req = _ensure(value)
+    req.json_body = json_value
+    return req
+
+
+def method(method_value, value):
+    """..method: 'PATCH' — метод заранее; выполняется ..send()."""
+    req = _ensure(value)
+    req.method = str(method_value).upper()
+    return req
+
+
+def url(url_value, value):
+    """..url: 'https://...' — адрес заранее; выполняется ..send()."""
+    req = _ensure(value)
+    req.url = url_value
+    return req
+
+
+__all__ = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS',
+           'send', 'headers', 'query', 'timeout', 'cookies', 'auth', 'json',
+           'method', 'url', 'Response', 'httpee']

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

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: httpee
+Version: 0.1.0
+Summary: httpee — thin httpx wrapper for eelang pipelines
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Dynamic: license-file
+
+# httpee
+
+`httpee` is a thin wrapper around [httpx](https://www.python-httpx.org/) for
+[eelang](https://github.com/eel-lang/eelang-py): requests are written as pipelines,
+responses are checked with patterns.
+
+```python
+from httpee import POST, headers, httpee, Response
+
+user =
+    {'name': 'kenneth', 'role': 'admin'}      # dict → form-encoded, like requests data=
+    ..headers: {'Authorization': f'Bearer {token}'}
+    ..POST: 'https://api.example.com/users'
+    ..assert:
+        Response(status=201)
+
+page =
+    httpee()                                  # empty request — no body
+    ..query: {'page': 2}
+    ..GET: 'https://api.example.com/users'
+    ..assert:
+        Response(status=200)
+```
+
+## Cheatsheet
+
+```python
+from httpee import (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, send,
+                    httpee, headers, query, timeout, cookies, auth, json,
+                    method, url, Response)
+from eelang import MatchError
+```
+
+### A request is a pipeline
+
+```python
+r =
+    {'name': 'kenneth', 'role': 'admin'}     # dict → form-encoded
+    ..headers: {'X-Key': v}                  # headers (repeats add keys)
+    ..query: {'page': 2}                     # query parameters (repeats add keys)
+    ..POST: 'https://api.example.com/users'  # verb performs the request
+    ..assert:
+        Response(status=201)                 # failure → MatchError
+```
+
+### Bodies
+
+| Value | Sent as |
+|---|---|
+| dict | form-encoded (`data=`, like requests) |
+| str | text |
+| bytes | raw bytes |
+| `httpee()` | empty request — no body |
+| `..json: {…}` | JSON — takes precedence over the pipeline body |
+
+### Dynamic method — `..send()`
+
+```python
+r =
+    {'role': 'moderator'}
+    ..method: m                          # any method, even from a variable
+    ..url: 'https://…'
+    ..send()                             # without ..method: defaults to GET
+    ..assert:
+        Response(status=200)
+```
+
+### Pattern checks
+
+```python
+# ..assert: — shape check, binds variables, failure → MatchError
+p =
+    httpee()
+    ..GET: url
+    ..assert:
+        Response(status=s)               # s is available afterwards
+
+# ..match: — branch on status; no match → the value is unchanged
+verdict =
+    httpee()
+    ..GET: url
+    ..match:
+        case Response(status=200): 'ok'
+        case Response(status=n): f'HTTP {n}'
+```
+
+### Errors
+
+- 4xx/5xx do **not** raise: check the status with a pattern.
+- Network errors and timeouts are httpx exceptions (`ConnectError`, `TimeoutException`).
+- `Response` is `httpx.Response` plus `.status`: `.json()`, `.text`, `.headers` work as usual.
+
+### Modifiers at a glance
+
+`..headers:` · `..query:` · `..timeout: 5.0` · `..cookies:` · `..auth: (u, p)` · `..json:` · `..method:` · `..url:`
+
+## How it works
+
+- The pipeline's initial value is the request body: dict → form-encoded, str → text,
+  bytes → raw bytes. JSON goes through an explicit `..json: {…}`. A request without
+  a body starts with `httpee()`.
+- Modifiers accumulate parameters (repeatable, in any order); the verb at the end
+  performs the request and returns a `Response`.
+- 4xx/5xx do not raise — the status is checked with a pattern; a failed `..assert:`
+  raises `MatchError`. Network errors and timeouts are httpx exceptions.
+
+## Verbs
+
+| Verb | Example | What it does |
+|---|---|---|
+| `GET` … `OPTIONS` | `..GET: url` | performs the request with this method |
+| `send` | `..send()` | performs the request with a previously set `..method:`/`..url:` |
+
+The method can be set up front — and can be anything:
+
+```python
+patch =
+    {'role': 'moderator'}
+    ..method: 'PATCH'                          # or from a variable
+    ..url: 'https://api.example.com/users/1'
+    ..send()
+    ..assert:
+        Response(status=200)
+```
+
+## Modifiers
+
+| Modifier | Example | What it does |
+|---|---|---|
+| `headers` | `..headers: {'X-Key': v}` | headers (repeats add keys) |
+| `query` | `..query: {'page': 2}` | URL query parameters (repeats add keys) |
+| `timeout` | `..timeout: 5.0` | request timeout, seconds |
+| `cookies` | `..cookies: {'sid': v}` | cookies |
+| `auth` | `..auth: ('user', 'pass')` | basic auth (any `httpx.Auth` works) |
+| `json` | `..json: {…}` | JSON body (takes precedence over the pipeline body) |
+| `method` | `..method: 'PATCH'` | method up front — for `..send()` |
+| `url` | `..url: 'https://…'` | URL up front — for `..send()` |
+
+## Installation
+
+```sh
+pip install httpee
+```
+
+From source:
+
+```sh
+git clone https://github.com/eel-lang/httpee
+pip install ./httpee
+```
+
+Requires CPython 3.15 + [eelang](https://github.com/eel-lang/eelang-py) to run `.eel`
+files — the package itself is plain Python, and httpx is its only dependency.
+Works under gevent (`gevent.monkey.patch_all()`).
+
+## Tests
+
+```sh
+python -m unittest discover -s tests
+```
+
+## License
+
+MIT (`LICENSE`).

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

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+httpee/__init__.py
+httpee.egg-info/PKG-INFO
+httpee.egg-info/SOURCES.txt
+httpee.egg-info/dependency_links.txt
+httpee.egg-info/requires.txt
+httpee.egg-info/top_level.txt
+tests/test_eelang.py
+tests/test_gevent.py
+tests/test_http.py
+tests/test_response.py
+tests/test_runner.py

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

@@ -0,0 +1 @@
+

httpee-0.1.0/httpee.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.27

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

@@ -0,0 +1 @@
+httpee

httpee-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "httpee"
+version = "0.1.0"
+description = "httpee — thin httpx wrapper for eelang pipelines"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["httpx>=0.27"]
+
+[tool.setuptools]
+packages = ["httpee"]

httpee-0.1.0/setup.cfg

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

httpee-0.1.0/tests/test_eelang.py

@@ -0,0 +1,155 @@
+"""Тесты eelang-слоя: пайплайны, ..assert:, ..match:, MatchError."""
+import unittest
+
+try:
+    import eelang
+    from eelang import MatchError
+except ImportError:
+    eelang = MatchError = None
+
+from tests._server import TestServer
+
+
+def run(source, ns=None):
+    """Парсим eelang-исходник C-парсером и исполняем."""
+    if ns is None:
+        ns = {}
+    mod = eelang.parse(source, '<httpee-test>')
+    exec(compile(mod, '<httpee-test>', 'exec'), ns)
+    return ns
+
+
+@unittest.skipIf(eelang is None, 'eelang не установлен')
+class EelangPipelineTests(unittest.TestCase):
+    def test_post_with_assert_pattern(self):
+        with TestServer() as srv:
+            ns = run(f'''
+from httpee import POST, headers, Response
+user =
+    {{'name': 'kenneth', 'role': 'admin'}}
+    ..headers: {{'X-Test': 'yes'}}
+    ..POST: '{srv.url}/users'
+    ..assert:
+        Response(status=200)
+''')
+            req = srv.requests[0]
+            self.assertEqual(req['body'], 'name=kenneth&role=admin')
+            self.assertEqual(req['headers']['X-Test'], 'yes')
+            self.assertEqual(ns['user'].json()['echo']['method'], 'POST')
+
+    def test_get_without_body(self):
+        with TestServer() as srv:
+            ns = run(f'''
+from httpee import GET, query, httpee, Response
+page =
+    httpee()
+    ..query: {{'page': 2}}
+    ..GET: '{srv.url}/users'
+    ..assert:
+        Response(status=200)
+''')
+            self.assertEqual(srv.requests[0]['path'], '/users?page=2')
+            self.assertEqual(ns['page'].status, 200)
+
+    def test_assert_failure_raises_matcherror(self):
+        with TestServer(status=404) as srv:
+            with self.assertRaises(MatchError):
+                run(f'''
+from httpee import GET, httpee, Response
+r =
+    httpee()
+    ..GET: '{srv.url}/missing'
+    ..assert:
+        Response(status=200)
+''')
+
+    def test_assert_binds_variables(self):
+        with TestServer() as srv:
+            ns = run(f'''
+from httpee import GET, httpee, Response
+r =
+    httpee()
+    ..GET: '{srv.url}/ok'
+    ..assert:
+        Response(status=s)
+doubled = s * 2
+''')
+            self.assertEqual(ns['doubled'], 400)
+
+    def test_match_branches_on_status(self):
+        with TestServer(status=418) as srv:
+            ns = run(f'''
+from httpee import GET, httpee, Response
+verdict =
+    httpee()
+    ..GET: '{srv.url}/teapot'
+    ..match:
+        case Response(status=200):
+            'ok'
+        case Response(status=418):
+            'teapot'
+        case Response(status=n):
+            f'HTTP {{n}}'
+''')
+            self.assertEqual(ns['verdict'], 'teapot')
+
+    def test_match_fallback_captures_status(self):
+        with TestServer(status=503) as srv:
+            ns = run(f'''
+from httpee import GET, httpee, Response
+verdict =
+    httpee()
+    ..GET: '{srv.url}/down'
+    ..match:
+        case Response(status=200):
+            'ok'
+        case Response(status=n):
+            f'HTTP {{n}}'
+''')
+            self.assertEqual(ns['verdict'], 'HTTP 503')
+
+    def test_send_with_dynamic_method(self):
+        with TestServer() as srv:
+            ns = run(f'''
+from httpee import send, method, url, Response
+m = 'PATCH'
+r =
+    {{'v': 1}}
+    ..method: m
+    ..url: '{srv.url}/thing'
+    ..send()
+    ..assert:
+        Response(status=200)
+''')
+            self.assertEqual(srv.requests[0]['method'], 'PATCH')
+            self.assertEqual(srv.requests[0]['body'], 'v=1')
+
+    def test_json_modifier_in_pipeline(self):
+        with TestServer() as srv:
+            ns = run(f'''
+from httpee import POST, json, httpee, Response
+r =
+    httpee()
+    ..json: {{'nested': [1, 2]}}
+    ..POST: '{srv.url}/j'
+    ..assert:
+        Response(status=200)
+''')
+            self.assertEqual(srv.requests[0]['body'], '{"nested":[1,2]}')
+
+    def test_body_as_initial_value_like_readme(self):
+        with TestServer() as srv:
+            ns = run(f'''
+from httpee import GET, headers, Response
+r =
+    {{'some': 'json'}}
+    ..headers: {{'X-A': '1'}}
+    ..GET: '{srv.url}/form'
+    ..assert:
+        Response(status=200)
+''')
+            self.assertEqual(srv.requests[0]['body'], 'some=json')
+
+
+if __name__ == '__main__':
+    unittest.main()

httpee-0.1.0/tests/test_gevent.py

@@ -0,0 +1,50 @@
+"""Проверка под gevent: monkey-patch в изолированном подпроцессе.
+
+patch_all() глобально меняет потоки/сокеты процесса, поэтому проверка идёт
+в отдельном подпроцессе и не влияет на остальные тесты.
+"""
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+try:
+    import gevent  # noqa: F401
+except ImportError:
+    gevent = None
+
+from tests._server import TestServer
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+@unittest.skipUnless(gevent is not None, 'gevent не установлен')
+class GeventTests(unittest.TestCase):
+    def test_get_under_gevent_monkeypatch(self):
+        with TestServer() as srv:
+            script = '''\
+import gevent.monkey
+gevent.monkey.patch_all()
+import sys
+from httpee import GET, Response
+r = GET(sys.argv[1], None)
+assert isinstance(r, Response)
+print('status', r.status)
+'''
+            with tempfile.TemporaryDirectory() as tmp:
+                path = os.path.join(tmp, 'gevent_smoke.py')
+                with open(path, 'w', encoding='utf-8') as f:
+                    f.write(script)
+                env = dict(os.environ)
+                env['PYTHONPATH'] = REPO_ROOT + os.pathsep + env.get('PYTHONPATH', '')
+                proc = subprocess.run(
+                    [sys.executable, path, srv.url + '/g'],
+                    capture_output=True, text=True, env=env)
+                self.assertEqual(proc.returncode, 0, proc.stderr)
+                self.assertIn('status 200', proc.stdout)
+                self.assertEqual(srv.requests[0]['path'], '/g')
+
+
+if __name__ == '__main__':
+    unittest.main()

httpee-0.1.0/tests/test_http.py

@@ -0,0 +1,159 @@
+"""Тесты глаголов, модификаторов и send на чистом Python (без eelang)."""
+import unittest
+
+import httpx
+
+from httpee import (GET, POST, PATCH, HEAD, send, httpee, headers, query,
+                      timeout, cookies, auth, json, method, url, Response)
+from tests._server import TestServer
+
+
+class VerbTests(unittest.TestCase):
+    def test_get_executes_and_returns_response(self):
+        with TestServer() as srv:
+            r = GET(srv.url + '/x', None)
+            self.assertIsInstance(r, Response)
+            self.assertIsInstance(r, httpx.Response)
+            self.assertEqual(r.status, 200)
+            self.assertEqual(srv.requests[0]['method'], 'GET')
+            self.assertEqual(srv.requests[0]['path'], '/x')
+
+    def test_all_verbs(self):
+        with TestServer() as srv:
+            for verb, path in [(GET, '/a'), (POST, '/b'), (PATCH, '/c')]:
+                r = verb(srv.url + path, None)
+                self.assertEqual(r.status, 200)
+                self.assertEqual(srv.requests[-1]['method'], verb.__name__)
+
+    def test_head(self):
+        with TestServer() as srv:
+            r = HEAD(srv.url + '/h', None)
+            self.assertEqual(r.status, 200)
+            self.assertEqual(srv.requests[0]['method'], 'HEAD')
+
+    def test_httpee_empty_request(self):
+        with TestServer() as srv:
+            r = GET(srv.url + '/e', httpee())
+            self.assertIsInstance(r, Response)
+            self.assertEqual(r.status, 200)
+            self.assertEqual(srv.requests[0]['method'], 'GET')
+
+    def test_non_2xx_does_not_raise(self):
+        with TestServer(status=404) as srv:
+            r = GET(srv.url + '/missing', None)
+            self.assertEqual(r.status, 404)
+
+    def test_connect_error_propagates(self):
+        # Порт занят локальным сервером, но сервер закрыт — соединение разорвётся.
+        with TestServer() as srv:
+            port = srv.port
+        with self.assertRaises(httpx.ConnectError):
+            GET(f'http://127.0.0.1:{port}/x', None)
+
+    def test_timeout_propagates(self):
+        with TestServer(delay=1.0) as srv:
+            with self.assertRaises(httpx.TimeoutException):
+                GET(srv.url + '/slow', timeout(0.05, None))
+
+    def test_verb_after_verb_type_error(self):
+        with TestServer() as srv:
+            r = GET(srv.url + '/x', None)
+            with self.assertRaises(TypeError):
+                GET(srv.url + '/y', r)
+
+
+class BodyTests(unittest.TestCase):
+    def test_dict_body_is_form_encoded(self):
+        with TestServer() as srv:
+            POST(srv.url + '/f', {'a': 1, 'b': 'два'})
+            body = srv.requests[0]['body']
+            self.assertIn('a=1', body)
+            self.assertIn('%D0%B4%D0%B2%D0%B0', body)  # urlencoded utf-8
+            self.assertIn('application/x-www-form-urlencoded',
+                          srv.requests[0]['headers']['Content-Type'])
+
+    def test_str_body_is_raw_text(self):
+        with TestServer() as srv:
+            POST(srv.url + '/t', 'привет')
+            self.assertEqual(srv.requests[0]['body'], 'привет')
+
+    def test_bytes_body_is_raw(self):
+        with TestServer() as srv:
+            POST(srv.url + '/b', b'\x00\x01raw')
+            self.assertEqual(srv.requests[0]['body'], '\x00\x01raw')
+
+    def test_json_modifier_wins_over_body(self):
+        with TestServer() as srv:
+            POST(srv.url + '/j', json({'x': [1, 2]}, {'ignored': 'body'}))
+            self.assertEqual(srv.requests[0]['body'], '{"x":[1,2]}')
+            self.assertIn('application/json',
+                          srv.requests[0]['headers']['Content-Type'])
+
+    def test_unsupported_body_type_error(self):
+        with self.assertRaises(TypeError):
+            GET('http://127.0.0.1:1/x', 123)
+
+
+class ModifierTests(unittest.TestCase):
+    def test_headers_and_query_merge_and_repeat(self):
+        with TestServer() as srv:
+            v = headers({'X-A': '1'}, None)
+            v = headers({'X-B': '2'}, v)
+            v = query({'page': 2}, v)
+            v = query({'size': 10}, v)
+            r = GET(srv.url + '/users', v)
+            self.assertEqual(r.status, 200)
+            req = srv.requests[0]
+            self.assertEqual(req['path'], '/users?page=2&size=10')
+            self.assertEqual(req['headers']['X-A'], '1')
+            self.assertEqual(req['headers']['X-B'], '2')
+
+    def test_cookies(self):
+        with TestServer() as srv:
+            r = GET(srv.url + '/c', cookies({'sid': 'abc'}, None))
+            self.assertEqual(srv.requests[0]['headers']['Cookie'], 'sid=abc')
+            self.assertEqual(r.status, 200)
+
+    def test_auth_basic(self):
+        with TestServer() as srv:
+            GET(srv.url + '/auth', auth(('user', 'pass'), None))
+            auth_header = srv.requests[0]['headers'].get('Authorization')
+            self.assertIsNotNone(auth_header)
+            self.assertTrue(auth_header.startswith('Basic '))
+
+    def test_modifier_after_verb_type_error(self):
+        with TestServer() as srv:
+            r = GET(srv.url + '/x', None)
+            with self.assertRaises(TypeError):
+                headers({'X': '1'}, r)
+
+
+class SendTests(unittest.TestCase):
+    def test_send_with_dynamic_method(self):
+        with TestServer() as srv:
+            m = 'PATCH'
+            v = method(m, {'v': 1})
+            v = url(srv.url + '/thing', v)
+            r = send(v)
+            self.assertEqual(r.status, 200)
+            self.assertEqual(srv.requests[0]['method'], 'PATCH')
+            self.assertEqual(srv.requests[0]['body'], 'v=1')
+
+    def test_send_defaults_to_get(self):
+        with TestServer() as srv:
+            r = send(url(srv.url + '/g', None))
+            self.assertEqual(r.status, 200)
+            self.assertEqual(srv.requests[0]['method'], 'GET')
+
+    def test_send_without_url_type_error(self):
+        with self.assertRaises(TypeError):
+            send(method('POST', None))
+
+    def test_method_is_uppercased(self):
+        with TestServer() as srv:
+            send(url(srv.url + '/u', method('post', None)))
+            self.assertEqual(srv.requests[0]['method'], 'POST')
+
+
+if __name__ == '__main__':
+    unittest.main()

httpee-0.1.0/tests/test_response.py

@@ -0,0 +1,32 @@
+"""Тесты Response — подкласс httpx.Response со свойством status."""
+import unittest
+
+import httpx
+
+from httpee import Response
+
+
+class ResponseTests(unittest.TestCase):
+    def test_subclass_of_httpx(self):
+        self.assertTrue(issubclass(Response, httpx.Response))
+
+    def test_status_property(self):
+        r = Response(201, content=b'{}', headers={'content-type': 'application/json'})
+        self.assertEqual(r.status, 201)
+        self.assertEqual(r.status_code, 201)
+
+    def test_httpx_api_intact(self):
+        r = Response(200, content=b'{"k": "v"}',
+                     headers={'content-type': 'application/json'})
+        self.assertEqual(r.json(), {'k': 'v'})
+        self.assertIn('application/json', r.headers['content-type'])
+        self.assertEqual(r.status, 200)
+
+    def test_raise_for_status_still_available(self):
+        r = Response(500, content=b'', request=httpx.Request('GET', 'http://x/'))
+        with self.assertRaises(httpx.HTTPStatusError):
+            r.raise_for_status()
+
+
+if __name__ == '__main__':
+    unittest.main()

httpee-0.1.0/tests/test_runner.py

@@ -0,0 +1,64 @@
+"""Smoke-тесты: настоящий .eel-скрипт через python -m eelang."""
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+try:
+    import eelang  # noqa: F401 — наличие eelang обязательно для runner'а
+except ImportError:
+    eelang = None
+
+from tests._server import TestServer
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def run_script(source, env=None):
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, 'smoke.eel')
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(source)
+        full_env = dict(os.environ)
+        full_env['PYTHONPATH'] = REPO_ROOT + os.pathsep + full_env.get('PYTHONPATH', '')
+        if env:
+            full_env.update(env)
+        return subprocess.run(
+            [sys.executable, '-m', 'eelang', path],
+            capture_output=True, text=True, env=full_env)
+
+
+@unittest.skipIf(eelang is None, 'eelang не установлен')
+class RunnerTests(unittest.TestCase):
+    def test_eel_script_ok(self):
+        with TestServer() as srv:
+            proc = run_script(f'''
+from httpee import GET, httpee, Response
+r =
+    httpee()
+    ..GET: '{srv.url}/runner'
+    ..assert:
+        Response(status=200)
+print('status', r.status)
+''')
+            self.assertEqual(proc.returncode, 0, proc.stderr)
+            self.assertIn('status 200', proc.stdout)
+            self.assertEqual(srv.requests[0]['path'], '/runner')
+
+    def test_eel_script_match_error(self):
+        with TestServer(status=500) as srv:
+            proc = run_script(f'''
+from httpee import GET, httpee, Response
+r =
+    httpee()
+    ..GET: '{srv.url}/broken'
+    ..assert:
+        Response(status=200)
+''')
+            self.assertNotEqual(proc.returncode, 0)
+            self.assertIn('MatchError', proc.stderr)
+
+
+if __name__ == '__main__':
+    unittest.main()