cloudru-qa-httpx-curlify 1.0.0__tar.gz

cloudru_qa_httpx_curlify-1.0.0/.gitignore

@@ -0,0 +1,26 @@
+/docs/plans/
+.venv/
+.venvs/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.hypothesis/
+.coverage
+coverage.xml
+htmlcov/
+report*.xml
+allure-results/
+allure-report/
+.allure/
+logs/
+*.log
+.env
+.env.*
+.DS_Store
+dist/
+build/
+*.egg-info/
+/packages/*/api/
+.claude/settings.local.json

cloudru_qa_httpx_curlify-1.0.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

cloudru_qa_httpx_curlify-1.0.0/PKG-INFO

@@ -0,0 +1,244 @@
+Metadata-Version: 2.5
+Name: cloudru-qa-httpx-curlify
+Version: 1.0.0
+Summary: Преобразование запросов httpx.Request в команды curl
+Project-URL: Repository, https://github.com/cloud-ru-tech/qa-libraries
+Project-URL: Issues, https://github.com/cloud-ru-tech/qa-libraries/issues
+Author-email: Алексей Кирютин <ayukiryutin@cloud.ru>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: glom>=24.11.0
+Requires-Dist: httpx<0.29,>=0.28.1
+Description-Content-Type: text/markdown
+
+# httpx-curlify
+
+[![PyPI](https://img.shields.io/pypi/v/cloudru-qa-httpx-curlify)](https://pypi.org/project/cloudru-qa-httpx-curlify/)
+[![Python](https://img.shields.io/pypi/pyversions/cloudru-qa-httpx-curlify)](https://pypi.org/project/cloudru-qa-httpx-curlify/)
+[![License](https://img.shields.io/pypi/l/cloudru-qa-httpx-curlify)](https://github.com/cloud-ru-tech/qa-libraries/blob/master/LICENSE)
+
+English | [Русский](README.ru.md)
+
+Convert HTTP requests from `httpx.Request` to curl commands. Useful for debugging, logging, and documenting API requests.
+
+- [httpx-curlify](#httpx-curlify)
+  - [Installation](#installation)
+  - [Skills for AI agents](#skills-for-ai-agents)
+  - [Usage](#usage)
+    - [Basic usage](#basic-usage)
+    - [Masking sensitive data](#masking-sensitive-data)
+    - [JSON formatting](#json-formatting)
+  - [Development](#development)
+
+## Installation
+
+Requires Python 3.13 or later.
+
+```shell
+pip install cloudru-qa-httpx-curlify
+```
+
+Import the library as the module `httpx_curlify`.
+
+## Skills for AI agents
+
+This library does not have its own skill yet. If your project uses other
+libraries from this suite with [skills for AI agents](https://github.com/cloud-ru-tech/qa-libraries#skills-for-ai-agents),
+select and enable them from your project root (requires [`uv`](https://docs.astral.sh/uv/)):
+
+```shell
+uvx library-skills
+```
+
+For Claude Code, add `--claude`.
+
+## Usage
+
+### Basic usage
+
+Convert a GET request:
+
+```python
+import httpx
+from httpx_curlify import to_curl
+
+request = httpx.Request("GET", "https://example.com/api/users")
+curl_command = to_curl(request)
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X GET \
+  -H 'host: example.com' \
+  https://example.com/api/users
+```
+
+A POST request with JSON:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/users",
+    json={"name": "John", "age": 30},
+)
+curl_command = to_curl(request)
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-length: 24' \
+  -H 'content-type: application/json' \
+  --json '{"name": "John", "age": 30}' \
+  https://example.com/api/users
+```
+
+A request with headers:
+
+```python
+request = httpx.Request(
+    "GET",
+    "https://example.com/api/data",
+    headers={
+        "Authorization": "Bearer token123",
+        "X-Custom-Header": "custom-value",
+    },
+)
+curl_command = to_curl(request)
+print(curl_command)
+```
+
+### Masking sensitive data
+
+Mask sensitive data in headers and JSON request bodies using [glom](https://glom.readthedocs.io/en/latest/) syntax:
+
+Mask headers:
+
+```python
+request = httpx.Request(
+    "GET",
+    "https://example.com/api/data",
+    headers={
+        "Authorization": "Bearer secret_token",
+        "X-Api-Key": "api_key_value",
+    },
+)
+curl_command = to_curl(request, sanitize_keys=["authorization", "x-api-key"])
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X GET \
+  -H 'host: example.com' \
+  -H 'authorization: ****' \
+  -H 'x-api-key: ****' \
+  https://example.com/api/data
+```
+
+Mask JSON data:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/login",
+    json={"username": "john", "password": "secret123"},
+)
+curl_command = to_curl(request, sanitize_keys=["password"])
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-type: application/json' \
+  --json '{"username": "john", "password": "****"}' \
+  https://example.com/api/login
+```
+
+Mask nested data:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/data",
+    json={"user": {"name": "John", "password": "secret"}},
+)
+curl_command = to_curl(request, sanitize_keys=["user.password"])
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-type: application/json' \
+  --json '{"user": {"name": "John", "password": "****"}}' \
+  https://example.com/api/data
+```
+
+### JSON formatting
+
+Pass additional options to `json.dumps`:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/data",
+    json={"name": "John", "age": 30},
+)
+curl_command = to_curl(request, json_dumps_kwargs={"indent": 2})
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-type: application/json' \
+  --json '{
+    "name": "John",
+    "age": 30
+  }' \
+  https://example.com/api/data
+```
+
+## Development
+
+This library is developed in the [qa-libraries](https://github.com/cloud-ru-tech/qa-libraries) monorepo
+alongside the other `cloudru-qa-*` libraries. You need [`uv`](https://docs.astral.sh/uv/), GNU Make
+and [`checkmake`](https://github.com/checkmake/checkmake);
+run the commands from the repository root:
+
+```shell
+make sync                      # dependencies for all libraries from uv.lock
+make test-httpx-curlify        # tests for this library
+make typecheck-httpx-curlify   # mypy for this library
+make lint-fix                  # safe Ruff fixes
+make check                     # formatting, Ruff, mypy, and tests for the whole suite
+```
+
+Update snapshots with:
+
+```shell
+make test-httpx-curlify PYTEST_ARGS=--snapshot-update
+```
+
+Tests run on Python 3.13 and 3.14. Each version uses a separate environment:
+`make sync test-httpx-curlify PYTHON_VERSION=3.14`.
+
+Create a release with the Git tag `httpx-curlify/v<version>`. The tag version must match the version
+in `packages/httpx-curlify/pyproject.toml`.

cloudru_qa_httpx_curlify-1.0.0/README.md

@@ -0,0 +1,222 @@
+# httpx-curlify
+
+[![PyPI](https://img.shields.io/pypi/v/cloudru-qa-httpx-curlify)](https://pypi.org/project/cloudru-qa-httpx-curlify/)
+[![Python](https://img.shields.io/pypi/pyversions/cloudru-qa-httpx-curlify)](https://pypi.org/project/cloudru-qa-httpx-curlify/)
+[![License](https://img.shields.io/pypi/l/cloudru-qa-httpx-curlify)](https://github.com/cloud-ru-tech/qa-libraries/blob/master/LICENSE)
+
+English | [Русский](README.ru.md)
+
+Convert HTTP requests from `httpx.Request` to curl commands. Useful for debugging, logging, and documenting API requests.
+
+- [httpx-curlify](#httpx-curlify)
+  - [Installation](#installation)
+  - [Skills for AI agents](#skills-for-ai-agents)
+  - [Usage](#usage)
+    - [Basic usage](#basic-usage)
+    - [Masking sensitive data](#masking-sensitive-data)
+    - [JSON formatting](#json-formatting)
+  - [Development](#development)
+
+## Installation
+
+Requires Python 3.13 or later.
+
+```shell
+pip install cloudru-qa-httpx-curlify
+```
+
+Import the library as the module `httpx_curlify`.
+
+## Skills for AI agents
+
+This library does not have its own skill yet. If your project uses other
+libraries from this suite with [skills for AI agents](https://github.com/cloud-ru-tech/qa-libraries#skills-for-ai-agents),
+select and enable them from your project root (requires [`uv`](https://docs.astral.sh/uv/)):
+
+```shell
+uvx library-skills
+```
+
+For Claude Code, add `--claude`.
+
+## Usage
+
+### Basic usage
+
+Convert a GET request:
+
+```python
+import httpx
+from httpx_curlify import to_curl
+
+request = httpx.Request("GET", "https://example.com/api/users")
+curl_command = to_curl(request)
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X GET \
+  -H 'host: example.com' \
+  https://example.com/api/users
+```
+
+A POST request with JSON:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/users",
+    json={"name": "John", "age": 30},
+)
+curl_command = to_curl(request)
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-length: 24' \
+  -H 'content-type: application/json' \
+  --json '{"name": "John", "age": 30}' \
+  https://example.com/api/users
+```
+
+A request with headers:
+
+```python
+request = httpx.Request(
+    "GET",
+    "https://example.com/api/data",
+    headers={
+        "Authorization": "Bearer token123",
+        "X-Custom-Header": "custom-value",
+    },
+)
+curl_command = to_curl(request)
+print(curl_command)
+```
+
+### Masking sensitive data
+
+Mask sensitive data in headers and JSON request bodies using [glom](https://glom.readthedocs.io/en/latest/) syntax:
+
+Mask headers:
+
+```python
+request = httpx.Request(
+    "GET",
+    "https://example.com/api/data",
+    headers={
+        "Authorization": "Bearer secret_token",
+        "X-Api-Key": "api_key_value",
+    },
+)
+curl_command = to_curl(request, sanitize_keys=["authorization", "x-api-key"])
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X GET \
+  -H 'host: example.com' \
+  -H 'authorization: ****' \
+  -H 'x-api-key: ****' \
+  https://example.com/api/data
+```
+
+Mask JSON data:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/login",
+    json={"username": "john", "password": "secret123"},
+)
+curl_command = to_curl(request, sanitize_keys=["password"])
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-type: application/json' \
+  --json '{"username": "john", "password": "****"}' \
+  https://example.com/api/login
+```
+
+Mask nested data:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/data",
+    json={"user": {"name": "John", "password": "secret"}},
+)
+curl_command = to_curl(request, sanitize_keys=["user.password"])
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-type: application/json' \
+  --json '{"user": {"name": "John", "password": "****"}}' \
+  https://example.com/api/data
+```
+
+### JSON formatting
+
+Pass additional options to `json.dumps`:
+
+```python
+request = httpx.Request(
+    "POST",
+    "https://example.com/api/data",
+    json={"name": "John", "age": 30},
+)
+curl_command = to_curl(request, json_dumps_kwargs={"indent": 2})
+print(curl_command)
+```
+
+Output:
+```bash
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-type: application/json' \
+  --json '{
+    "name": "John",
+    "age": 30
+  }' \
+  https://example.com/api/data
+```
+
+## Development
+
+This library is developed in the [qa-libraries](https://github.com/cloud-ru-tech/qa-libraries) monorepo
+alongside the other `cloudru-qa-*` libraries. You need [`uv`](https://docs.astral.sh/uv/), GNU Make
+and [`checkmake`](https://github.com/checkmake/checkmake);
+run the commands from the repository root:
+
+```shell
+make sync                      # dependencies for all libraries from uv.lock
+make test-httpx-curlify        # tests for this library
+make typecheck-httpx-curlify   # mypy for this library
+make lint-fix                  # safe Ruff fixes
+make check                     # formatting, Ruff, mypy, and tests for the whole suite
+```
+
+Update snapshots with:
+
+```shell
+make test-httpx-curlify PYTEST_ARGS=--snapshot-update
+```
+
+Tests run on Python 3.13 and 3.14. Each version uses a separate environment:
+`make sync test-httpx-curlify PYTHON_VERSION=3.14`.
+
+Create a release with the Git tag `httpx-curlify/v<version>`. The tag version must match the version
+in `packages/httpx-curlify/pyproject.toml`.

cloudru_qa_httpx_curlify-1.0.0/httpx_curlify/__init__.py

@@ -0,0 +1,3 @@
+from .curlify import to_curl
+
+__all__ = ["to_curl"]

cloudru_qa_httpx_curlify-1.0.0/httpx_curlify/curlify.py

@@ -0,0 +1,89 @@
+import json
+from collections.abc import Callable, Sequence
+from shlex import quote
+from typing import TypedDict, Unpack, cast
+
+import httpx
+
+from .sanitaizer import sanitize
+
+
+class JsonDumpsOptions(TypedDict, total=False):
+    """JSON serialization options passed to ``json.dumps``."""
+
+    skipkeys: bool
+    ensure_ascii: bool
+    check_circular: bool
+    allow_nan: bool
+    indent: int | str | None
+    separators: tuple[str, str] | None
+    default: Callable[[object], object] | None
+    cls: type[json.JSONEncoder] | None
+    sort_keys: bool
+
+
+def to_curl(
+    request: httpx.Request,
+    sanitize_keys: Sequence[str] = (),
+    json_dumps_kwargs: JsonDumpsOptions | None = None,
+) -> str:
+    """Serialize an HTTP request to a curl command string.
+
+    :param request: HTTP request
+    :param sanitize_keys: Keys for masking secrets in the request
+    :param json_dumps_kwargs: Options for json.dumps when the request has content-type = application/json
+    :return: Curl command string
+    """
+    command = ["-X " + quote(request.method)]
+
+    content_type: str | None = None
+
+    headers = sanitize(dict(request.headers), sanitize_keys)
+    for key, value in headers.items():
+        if value:
+            command.append("-H " + quote(f"{key}: {value}"))
+        else:
+            command.append("-H " + quote(f"{key};"))
+
+        if key.lower() == "content-type":
+            content_type = value.lower()
+
+    if content_type:
+        request_body = request.read()
+        try:
+            payload = request_body.decode("utf-8")
+        except UnicodeDecodeError:
+            payload = f"<binary data {len(request_body)} bytes>"
+
+        if content_type.startswith("application/json"):
+            if json_dumps_kwargs is None:
+                json_dumps_kwargs = {}
+
+            command.append(f"--json {quote(_format_json(payload, sanitize_keys, **json_dumps_kwargs))}")
+        else:
+            command.append(f"--data {quote(payload)}")
+
+    command.append(quote(str(request.url)))
+
+    return "curl " + " \\\n  ".join(command)
+
+
+def _format_json(payload: str, sanitize_keys: Sequence[str], **kwargs: Unpack[JsonDumpsOptions]) -> str:
+    """Format a JSON string for readable output in a curl command.
+
+    :param payload: JSON string
+    :param sanitize_keys: Keys for masking secrets in JSON
+    :param kwargs: Options for json.dumps
+    :return: Formatted JSON string
+    """
+    json_payload = sanitize(cast("object", json.loads(payload)), sanitize_keys)
+
+    formatted_payload = json.dumps(json_payload, **kwargs)
+
+    lines = formatted_payload.split("\n")
+    formatted_lines = lines[:1]
+
+    for line in lines[1:]:
+        formatted_lines.append(f"  {line}")
+
+    return "\n".join(formatted_lines)

cloudru_qa_httpx_curlify-1.0.0/httpx_curlify/py.typed

@@ -0,0 +1 @@
+This marker file indicates that the package supports type checking under PEP 561

cloudru_qa_httpx_curlify-1.0.0/httpx_curlify/sanitaizer.py

@@ -0,0 +1,38 @@
+from collections.abc import Sequence
+from copy import deepcopy
+
+import glom
+
+
+def sanitize[T](
+    value_to_sanitize: T,
+    sensitive_keys: Sequence[str],
+) -> T:
+    """Create a new dictionary with sensitive data masked.
+
+    :param value_to_sanitize: Dictionary or list to process.
+    :param sensitive_keys: Keys in [glom](https://glom.readthedocs.io/en/latest/) format, to mask.
+    :returns: New dictionary or list with sensitive data masked.
+
+    #### Examples:
+    >>> result = sanitize({"d": {"password": "123123"}, "v": 123123}, ["d.password"])
+    >>> assert result == {'d': {'password': '****'}, "v": 123123}
+
+    >>> result = sanitize([{"d": {"passwd": "123123"}, "v": 123123}], ["*.d.passwd"])
+    >>> assert result == [{'d': {'passwd': '****'}, "v": 123123}]
+
+    >>> result = sanitize({"d": [{"passwd": "123123"}, {"passwd": "123123"}]}, ["d.*.passwd"])
+    >>> assert result == {"d": [{"passwd": "****"}, {"passwd": "****"}]}
+    """
+    if len(sensitive_keys) == 0:
+        return value_to_sanitize
+
+    value = deepcopy(value_to_sanitize)
+
+    for sensitive_key in sensitive_keys:
+        if glom.glom(value, sensitive_key, default=None) is None:
+            continue
+
+        glom.assign(value, sensitive_key, "****")
+
+    return value

cloudru_qa_httpx_curlify-1.0.0/pyproject.toml

@@ -0,0 +1,61 @@
+[project]
+name = "cloudru-qa-httpx-curlify"
+version = "1.0.0"
+description = "Преобразование запросов httpx.Request в команды curl"
+authors = [
+    { name = "Алексей Кирютин", email = "ayukiryutin@cloud.ru" },
+]
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "glom>=24.11.0",
+    "httpx>=0.28.1,<0.29",
+]
+license = "Apache-2.0"
+license-files = [
+    "LICENSE",
+]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Repository = "https://github.com/cloud-ru-tech/qa-libraries"
+Issues = "https://github.com/cloud-ru-tech/qa-libraries/issues"
+
+[build-system]
+requires = [
+    "hatchling>=1.33.0,<2",
+]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = [
+    "httpx_curlify",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/httpx_curlify",
+    "/tests",
+    "/README.md",
+    "/LICENSE",
+    "/pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"
+testpaths = [
+    "tests",
+]
+addopts = "--strict-markers --strict-config"
+filterwarnings = [
+    "error",
+]

cloudru_qa_httpx_curlify-1.0.0/tests/__init__.py

@@ -0,0 +1 @@
+# Module for unit tests

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_delete_request.raw

@@ -0,0 +1,3 @@
+curl -X DELETE \
+  -H 'host: example.com' \
+  https://example.com/api/users/123

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_multiline_format.raw

@@ -0,0 +1,7 @@
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'authorization: Bearer token' \
+  -H 'content-length: 15' \
+  -H 'content-type: application/json' \
+  --json '{"key": "value"}' \
+  https://example.com/api/data

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_post_request_with_form_data.raw

@@ -0,0 +1,6 @@
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-length: 27' \
+  -H 'content-type: application/x-www-form-urlencoded' \
+  --data 'field1=value1&field2=value2' \
+  https://example.com/api/form

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_post_request_with_json.raw

@@ -0,0 +1,6 @@
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-length: 24' \
+  -H 'content-type: application/json' \
+  --json '{"name": "John", "age": 30}' \
+  https://example.com/api/users

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_put_request.raw

@@ -0,0 +1,6 @@
+curl -X PUT \
+  -H 'host: example.com' \
+  -H 'content-length: 23' \
+  -H 'content-type: application/json' \
+  --json '{"name": "Updated Name"}' \
+  https://example.com/api/users/123

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_simple_get_request.raw

@@ -0,0 +1,3 @@
+curl -X GET \
+  -H 'host: example.com' \
+  https://example.com/api/users

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_binary_data.raw

@@ -0,0 +1,6 @@
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-type: application/octet-stream' \
+  -H 'content-length: 4' \
+  --data '<binary data 4 bytes>' \
+  https://example.com/api/upload

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_custom_headers.raw

@@ -0,0 +1,5 @@
+curl -X GET \
+  -H 'host: example.com' \
+  -H 'authorization: Bearer token123' \
+  -H 'x-custom-header: custom-value' \
+  https://example.com/api/data

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_empty_header_value.raw

@@ -0,0 +1,4 @@
+curl -X GET \
+  -H 'host: example.com' \
+  -H 'x-empty;' \
+  https://example.com/api/data

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_json_dumps_kwargs.raw

@@ -0,0 +1,9 @@
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-length: 24' \
+  -H 'content-type: application/json' \
+  --json '{
+    "name": "John",
+    "age": 30
+  }' \
+  https://example.com/api/data

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_nested_sanitize_keys.raw

@@ -0,0 +1,6 @@
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-length: 44' \
+  -H 'content-type: application/json' \
+  --json '{"user": {"name": "John", "password": "****"}}' \
+  https://example.com/api/data

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_query_parameters.raw

@@ -0,0 +1,3 @@
+curl -X GET \
+  -H 'host: example.com' \
+  'https://example.com/api/search?q=test+query&page=1'

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_sanitize_keys_in_headers.raw

@@ -0,0 +1,5 @@
+curl -X GET \
+  -H 'host: example.com' \
+  -H 'authorization: ****' \
+  -H 'x-api-key: ****' \
+  https://example.com/api/data

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_sanitize_keys_in_json.raw

@@ -0,0 +1,6 @@
+curl -X POST \
+  -H 'host: example.com' \
+  -H 'content-length: 42' \
+  -H 'content-type: application/json' \
+  --json '{"username": "john", "password": "****"}' \
+  https://example.com/api/login

cloudru_qa_httpx_curlify-1.0.0/tests/__snapshots__/test_curlify/test_to_curl_with_special_characters_in_url.raw

@@ -0,0 +1,3 @@
+curl -X GET \
+  -H 'host: example.com' \
+  'https://example.com/api/search?q=test&filter=name'

cloudru_qa_httpx_curlify-1.0.0/tests/conftest.py

@@ -0,0 +1,16 @@
+import pytest
+from syrupy.assertion import SnapshotAssertion
+from syrupy.extensions.single_file import SingleFileSnapshotExtension, WriteMode
+
+
+class TextSnapshotExtension(SingleFileSnapshotExtension):
+    """Extension for creating snapshots as separate text files."""
+
+    _file_extension = "txt"
+    _write_mode = WriteMode.TEXT
+
+
+@pytest.fixture()
+def snapshot(snapshot: SnapshotAssertion) -> SnapshotAssertion:
+    """Fixture for text snapshots."""
+    return snapshot.use_extension(TextSnapshotExtension)

cloudru_qa_httpx_curlify-1.0.0/tests/test_curlify.py

@@ -0,0 +1,219 @@
+import httpx
+from assertpy import assert_that
+from httpx_curlify import to_curl
+from syrupy.assertion import SnapshotAssertion
+
+
+def test_to_curl_simple_get_request(snapshot: SnapshotAssertion) -> None:
+    """Convert a simple GET request."""
+    request = httpx.Request("GET", "https://example.com/api/users")
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_post_request_with_json(snapshot: SnapshotAssertion) -> None:
+    """Convert a POST request with a JSON body."""
+    request = httpx.Request(
+        "POST",
+        "https://example.com/api/users",
+        json=dict[str, object]({"name": "John", "age": 30}),
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_custom_headers(snapshot: SnapshotAssertion) -> None:
+    """Convert a request with custom headers."""
+    request = httpx.Request(
+        "GET",
+        "https://example.com/api/data",
+        headers={
+            "Authorization": "Bearer token123",
+            "X-Custom-Header": "custom-value",
+        },
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_empty_header_value(snapshot: SnapshotAssertion) -> None:
+    """Convert a request with an empty header value."""
+    request = httpx.Request(
+        "GET",
+        "https://example.com/api/data",
+        headers={"X-Empty": ""},
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_post_request_with_form_data(snapshot: SnapshotAssertion) -> None:
+    """Convert a POST request with form data."""
+    request = httpx.Request(
+        "POST",
+        "https://example.com/api/form",
+        data=dict[str, object]({"field1": "value1", "field2": "value2"}),
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_sanitize_keys_in_headers(snapshot: SnapshotAssertion) -> None:
+    """Convert a request while masking sensitive header data."""
+    request = httpx.Request(
+        "GET",
+        "https://example.com/api/data",
+        headers={
+            "Authorization": "Bearer secret_token",
+            "X-Api-Key": "api_key_value",
+        },
+    )
+
+    result = to_curl(request, sanitize_keys=["authorization", "x-api-key"])
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_sanitize_keys_in_json(snapshot: SnapshotAssertion) -> None:
+    """Convert a request while masking sensitive JSON data."""
+    request = httpx.Request(
+        "POST",
+        "https://example.com/api/login",
+        json=dict[str, object]({"username": "john", "password": "secret123"}),
+    )
+
+    result = to_curl(request, sanitize_keys=["password"])
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_nested_sanitize_keys(snapshot: SnapshotAssertion) -> None:
+    """Convert a request while masking nested sensitive data."""
+    request = httpx.Request(
+        "POST",
+        "https://example.com/api/data",
+        json=dict[str, object]({"user": {"name": "John", "password": "secret"}}),
+    )
+
+    result = to_curl(request, sanitize_keys=["user.password"])
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_json_dumps_kwargs(snapshot: SnapshotAssertion) -> None:
+    """Convert a request with JSON formatting options."""
+    request = httpx.Request(
+        "POST",
+        "https://example.com/api/data",
+        json=dict[str, object]({"name": "John", "age": 30}),
+    )
+
+    result = to_curl(request, json_dumps_kwargs={"indent": 2})
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_put_request(snapshot: SnapshotAssertion) -> None:
+    """Convert a PUT request."""
+    request = httpx.Request(
+        "PUT",
+        "https://example.com/api/users/123",
+        json=dict[str, object]({"name": "Updated Name"}),
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_delete_request(snapshot: SnapshotAssertion) -> None:
+    """Convert a DELETE request."""
+    request = httpx.Request("DELETE", "https://example.com/api/users/123")
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_query_parameters(snapshot: SnapshotAssertion) -> None:
+    """Convert a request with query parameters."""
+    request = httpx.Request(
+        "GET",
+        "https://example.com/api/search",
+        params={"q": "test query", "page": "1"},
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_binary_data(snapshot: SnapshotAssertion) -> None:
+    """Convert a request with binary data."""
+    binary_data = b"\x80\x81\x82\x83"
+    request = httpx.Request(
+        "POST",
+        "https://example.com/api/upload",
+        content=binary_data,
+        headers={"Content-Type": "application/octet-stream"},
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_multiline_format(snapshot: SnapshotAssertion) -> None:
+    """Check that the result contains line breaks."""
+    request = httpx.Request(
+        "POST",
+        "https://example.com/api/data",
+        json=dict[str, object]({"key": "value"}),
+        headers={"Authorization": "Bearer token"},
+    )
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_to_curl_with_special_characters_in_url(snapshot: SnapshotAssertion) -> None:
+    """Convert a request with special characters in its URL."""
+    request = httpx.Request("GET", "https://example.com/api/search?q=test&filter=name")
+
+    result = to_curl(request)
+
+    assert_that(result).is_equal_to(snapshot)
+
+
+def test_sanitization_preserves_request_body() -> None:
+    request = httpx.Request(
+        "POST", "https://example.com/private", json=dict[str, object]({"password": "keep-original"})
+    )
+    original = request.read()
+
+    to_curl(request, sanitize_keys=["password"])
+
+    assert_that(request.read()).is_equal_to(original)
+
+
+def test_hides_secrets_inside_json_arrays() -> None:
+    request = httpx.Request(
+        "POST",
+        "https://example.com/keys",
+        json=dict[str, object]({"users": [dict[str, object]({"token": "array-secret"})]}),
+    )
+
+    command = to_curl(request, sanitize_keys=["users.*.token"])
+
+    assert_that(command).contains("****").does_not_contain("array-secret")