curlifier 0.1.0__tar.gz

curlifier-0.1.0/LICENSE

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

curlifier-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.3
+Name: curlifier
+Version: 0.1.0
+Summary: Converts Request objects to curl string
+License: MIT
+Keywords: curl,curlify,python requests to curl,curlifier
+Author: Timur Valiev
+Author-email: cptchunk@yandex.ru
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: requests (>=2.30,<3.0)
+Project-URL: Homepage, https://github.com/imtoopunkforyou/curlifier
+Description-Content-Type: text/markdown
+
+# curlifier
+```
+░█████╗░██╗░░░██╗██████╗░██╗░░░░░██╗███████╗██╗███████╗██████╗░
+██╔══██╗██║░░░██║██╔══██╗██║░░░░░██║██╔════╝██║██╔════╝██╔══██╗
+██║░░╚═╝██║░░░██║██████╔╝██║░░░░░██║█████╗░░██║█████╗░░██████╔╝
+██║░░██╗██║░░░██║██╔══██╗██║░░░░░██║██╔══╝░░██║██╔══╝░░██╔══██╗
+╚█████╔╝╚██████╔╝██║░░██║███████╗██║██║░░░░░██║███████╗██║░░██║
+░╚════╝░░╚═════╝░╚═╝░░╚═╝╚══════╝╚═╝╚═╝░░░░░╚═╝╚══════╝╚═╝░░╚═╝
+```
+
+Curlifier converts the [Request](https://requests.readthedocs.io/en/latest/api/#requests.Response) and [PreparedRequest](https://requests.readthedocs.io/en/latest/api/#requests.PreparedRequest) objects of the [Requests](https://pypi.org/project/requests/) library into an executable [curl](https://curl.se/) command.
+
+## Installation
+Curlifier is available on PyPI:
+```bash
+pip install curlifier
+```
+
+### Dependencies
+- `python (>=3.12, <4.0)`
+- `requests (>=2.30.3, <3.0.0)`
+
+## Usage
+All you need is to import `curlify`.  
+For example:
+```python
+>>> import requests
+>>> from curlifier import curlify
+>>> body = {'id': 1, 'name': 'Tima', 'age': 28}
+>>> r = requests.post('https://httpbin.org/', json=body)
+>>> curlify(r)
+curl --request POST 'https://httpbin.org/' --header 'User-Agent: python-requests/2.32.3' --header 'Accept-Encoding: gzip, deflate' --header 'Accept: */*' --header 'Connection: keep-alive' --header 'Content-Type: application/json' --data '{"id": 1, "name": "Tima", "age": 28}'
+```
+If you use `PraparedRequest`, you can also specify it instead of the `Response` object:
+```python
+>>> req = requests.Request('POST', 'https://httpbin.org/')
+>>> r = req.prepare()
+>>> curlify(prepared_request=r)
+curl --request POST 'https://httpbin.org/'
+```
+If you want a short version of the curl command, you can specify it:
+```python
+>>> body = {'id': 1, 'name': 'Tima', 'age': 28}
+>>> r = requests.post('https://httpbin.org/', json=body)
+>>> curlify(r, shorted=True)
+curl -X POST 'https://httpbin.org/' -H 'User-Agent: python-requests/2.32.3' -H 'Accept-Encoding: gzip, deflate' -H 'Accept: */*' -H 'Connection: keep-alive' -H 'Content-Type: application/json' -d '{"id": 1, "name": "Tima", "age": 28}'
+```
+You can also specify the configuration when forming the curl command:
+```python
+>>> curlify(r, location=True, verbose=True, silent=True, insecure=True, include=True)
+curl --request POST 'https://httpbin.org/' --header 'User-Agent: python-requests/2.32.3' --header 'Accept-Encoding: gzip, deflate' --header 'Accept: */*' --header 'Connection: keep-alive' --header 'Content-Type: application/json' --data '{"id": 1, "name": "Tima", "age": 28}' --location --verbose --silent --insecure --include
+```
+- **location** (bool) - Follow redirects (default: False)
+- **verbose** (bool) - Verbose output (default: False)
+- **silent** (bool) - Silent mode (default: False)
+- **insecure** (bool) - Allow insecure connections (default: False)
+- **include** (bool) - Include protocol headers (default: False)
+
+## License
+Curlifier is released under the MIT License. See the bundled [LICENSE](LICENSE) file for details.
+
+## **Want to Help?** ❤️ 
+Feel free to pick any task from this list and contribute!  
+1. Check if an [issue](https://github.com/imtoopunkforyou/curlifier/issues) exists for the task you want to work on
+2. If not, [open a new issue](https://github.com/imtoopunkforyou/curlifier/issues/new) to discuss
+3. Fork the repo and create a pull request when ready

curlifier-0.1.0/README.md

@@ -0,0 +1,66 @@
+# curlifier
+```
+░█████╗░██╗░░░██╗██████╗░██╗░░░░░██╗███████╗██╗███████╗██████╗░
+██╔══██╗██║░░░██║██╔══██╗██║░░░░░██║██╔════╝██║██╔════╝██╔══██╗
+██║░░╚═╝██║░░░██║██████╔╝██║░░░░░██║█████╗░░██║█████╗░░██████╔╝
+██║░░██╗██║░░░██║██╔══██╗██║░░░░░██║██╔══╝░░██║██╔══╝░░██╔══██╗
+╚█████╔╝╚██████╔╝██║░░██║███████╗██║██║░░░░░██║███████╗██║░░██║
+░╚════╝░░╚═════╝░╚═╝░░╚═╝╚══════╝╚═╝╚═╝░░░░░╚═╝╚══════╝╚═╝░░╚═╝
+```
+
+Curlifier converts the [Request](https://requests.readthedocs.io/en/latest/api/#requests.Response) and [PreparedRequest](https://requests.readthedocs.io/en/latest/api/#requests.PreparedRequest) objects of the [Requests](https://pypi.org/project/requests/) library into an executable [curl](https://curl.se/) command.
+
+## Installation
+Curlifier is available on PyPI:
+```bash
+pip install curlifier
+```
+
+### Dependencies
+- `python (>=3.12, <4.0)`
+- `requests (>=2.30.3, <3.0.0)`
+
+## Usage
+All you need is to import `curlify`.  
+For example:
+```python
+>>> import requests
+>>> from curlifier import curlify
+>>> body = {'id': 1, 'name': 'Tima', 'age': 28}
+>>> r = requests.post('https://httpbin.org/', json=body)
+>>> curlify(r)
+curl --request POST 'https://httpbin.org/' --header 'User-Agent: python-requests/2.32.3' --header 'Accept-Encoding: gzip, deflate' --header 'Accept: */*' --header 'Connection: keep-alive' --header 'Content-Type: application/json' --data '{"id": 1, "name": "Tima", "age": 28}'
+```
+If you use `PraparedRequest`, you can also specify it instead of the `Response` object:
+```python
+>>> req = requests.Request('POST', 'https://httpbin.org/')
+>>> r = req.prepare()
+>>> curlify(prepared_request=r)
+curl --request POST 'https://httpbin.org/'
+```
+If you want a short version of the curl command, you can specify it:
+```python
+>>> body = {'id': 1, 'name': 'Tima', 'age': 28}
+>>> r = requests.post('https://httpbin.org/', json=body)
+>>> curlify(r, shorted=True)
+curl -X POST 'https://httpbin.org/' -H 'User-Agent: python-requests/2.32.3' -H 'Accept-Encoding: gzip, deflate' -H 'Accept: */*' -H 'Connection: keep-alive' -H 'Content-Type: application/json' -d '{"id": 1, "name": "Tima", "age": 28}'
+```
+You can also specify the configuration when forming the curl command:
+```python
+>>> curlify(r, location=True, verbose=True, silent=True, insecure=True, include=True)
+curl --request POST 'https://httpbin.org/' --header 'User-Agent: python-requests/2.32.3' --header 'Accept-Encoding: gzip, deflate' --header 'Accept: */*' --header 'Connection: keep-alive' --header 'Content-Type: application/json' --data '{"id": 1, "name": "Tima", "age": 28}' --location --verbose --silent --insecure --include
+```
+- **location** (bool) - Follow redirects (default: False)
+- **verbose** (bool) - Verbose output (default: False)
+- **silent** (bool) - Silent mode (default: False)
+- **insecure** (bool) - Allow insecure connections (default: False)
+- **include** (bool) - Include protocol headers (default: False)
+
+## License
+Curlifier is released under the MIT License. See the bundled [LICENSE](LICENSE) file for details.
+
+## **Want to Help?** ❤️ 
+Feel free to pick any task from this list and contribute!  
+1. Check if an [issue](https://github.com/imtoopunkforyou/curlifier/issues) exists for the task you want to work on
+2. If not, [open a new issue](https://github.com/imtoopunkforyou/curlifier/issues/new) to discuss
+3. Fork the repo and create a pull request when ready

curlifier-0.1.0/curlifier/__init__.py

@@ -0,0 +1,5 @@
+from curlifier.api import curlify
+
+__all__ = (
+    'curlify',
+)

curlifier-0.1.0/curlifier/__version__.py

@@ -0,0 +1,31 @@
+# ░█████╗░██╗░░░██╗██████╗░██╗░░░░░██╗███████╗██╗███████╗██████╗░
+# ██╔══██╗██║░░░██║██╔══██╗██║░░░░░██║██╔════╝██║██╔════╝██╔══██╗
+# ██║░░╚═╝██║░░░██║██████╔╝██║░░░░░██║█████╗░░██║█████╗░░██████╔╝
+# ██║░░██╗██║░░░██║██╔══██╗██║░░░░░██║██╔══╝░░██║██╔══╝░░██╔══██╗
+# ╚█████╔╝╚██████╔╝██║░░██║███████╗██║██║░░░░░██║███████╗██║░░██║
+# ░╚════╝░░╚═════╝░╚═╝░░╚═╝╚══════╝╚═╝╚═╝░░░░░╚═╝╚══════╝╚═╝░░╚═╝
+
+from importlib.metadata import PackageMetadata, metadata
+from pathlib import Path
+from typing import Final
+
+pkg_name: Final[str] = str(Path(__file__).parent.name)
+pkg_data: PackageMetadata = metadata(pkg_name)
+
+NAME: Final[str] = pkg_data['Name']
+VERSION: Final[str] = pkg_data['Version']
+AUTHOR: Final[str] = pkg_data['Author']
+AUTHOR_EMAIL: Final[str] = pkg_data['Author-email']
+LICENSE: Final[str] = pkg_data['License']
+
+
+def get_package_information() -> dict[str, str]:
+    pkg_info = {
+        'name': NAME,
+        'version': VERSION,
+        'author': AUTHOR,
+        'author_email': AUTHOR_EMAIL,
+        'license': LICENSE,
+    }
+
+    return pkg_info

curlifier-0.1.0/curlifier/api.py

@@ -0,0 +1,60 @@
+from typing import Unpack
+
+from requests.models import PreparedRequest, Response
+
+from curlifier.curl import CurlBuilder
+from curlifier.structures.types import CurlifyConfigure
+
+
+def curlify(
+    response: Response | None = None,
+    *,
+    prepared_request: PreparedRequest | None = None,
+    shorted: bool = False,
+    **config: Unpack[CurlifyConfigure],
+) -> str:
+    """
+    The only correct entry point of the `curlifier` library.
+
+    :param response: The `requests` library Response object.
+                     Must be specified if the `prepared_request` argument is not specified.
+    :type response: Response | None, optional
+
+    :param prepared_request: The `requests` library `PreparedRequest` object.
+                             Must be specified if the `response` argument is not specified.
+    :type prepared_request: PreparedRequest | None, optional
+
+    :param shorted: Specify `True` if you want to build the curl command in a shortened form.
+                    Otherwise `False`. Defaults to `False`.
+    :type shorted: bool
+
+    :param config: Additional configuration options for curl command:
+        - **location** (bool) - Follow redirects (default: False)
+        - **verbose** (bool) - Verbose output (default: False)
+        - **silent** (bool) - Silent mode (default: False)
+        - **insecure** (bool) - Allow insecure connections (default: False)
+        - **include** (bool) - Include protocol headers (default: False)
+    :type config: Unpack[CurlifyConfigure]
+
+    :return: Executable curl command.
+    :rtype: str
+
+    >>> import requests
+    >>> from curlifier import curlify
+    >>> r = requests.get('https://example.com/')
+    >>> curlify(r, shorted=True)
+    "curl -X GET 'https://example.com/' -H 'User-Agent: python-requests/2.32.3' <...>"
+    """
+    curl_builder = CurlBuilder(
+        response=response,
+        prepared_request=prepared_request,
+        build_short=shorted,
+        location=config.pop('location', False),
+        verbose=config.pop('verbose', False),
+        silent=config.pop('silent', False),
+        insecure=config.pop('insecure', False),
+        include=config.pop('include', False),
+    )
+    curl: str = curl_builder.build()
+
+    return curl

curlifier-0.1.0/curlifier/configurator.py

@@ -0,0 +1,136 @@
+from typing import Generator, Self
+
+from curlifier.structures.commands import CommandsConfigureEnum
+from curlifier.structures.types import CurlCommand, EmptyStr
+
+
+class Config:
+    """Parameters for curl command configuration."""
+
+    __slots__ = (
+        '_location',
+        '_verbose',
+        '_silent',
+        '_insecure',
+        '_include',
+    )
+
+    def __init__(
+        self: Self,
+        location: bool,
+        verbose: bool,
+        silent: bool,
+        insecure: bool,
+        include: bool,
+    ) -> None:
+        self._location = location
+        self._verbose = verbose
+        self._silent = silent
+        self._insecure = insecure
+        self._include = include
+
+    @property
+    def location(self: Self) -> bool:
+        """Follow redirects."""
+        return self._location
+
+    @property
+    def verbose(self: Self) -> bool:
+        """Make the operation more talkative."""
+        return self._verbose
+
+    @property
+    def silent(self: Self) -> bool:
+        """Silent mode."""
+        return self._silent
+
+    @property
+    def insecure(self: Self) -> bool:
+        """Allow insecure server connections."""
+        return self._insecure
+
+    @property
+    def include(self: Self) -> bool:
+        """Include protocol response headers in the output."""
+        return self._include
+
+
+class ConfigBuilder(Config):
+    """Builds a curl command configuration line."""
+
+    __slots__ = (
+        'build_short',
+    )
+
+    def __init__(
+        self: Self,
+        build_short: bool = False,
+        **kwargs: bool,
+    ) -> None:
+        self.build_short = build_short
+        super().__init__(**kwargs)
+
+    def build(self: Self) -> str:
+        """
+        Collects all parameters into the resulting string.
+
+        If `build_short` is `True` will be collected short version.
+
+        >>> from curlifier.configurator import ConfigBuilder
+        >>> conf = ConfigBuilder(
+            location=True,
+            verbose=True,
+            silent=False,
+            insecure=True,
+            include=False,
+            build_short=False,
+        )
+        >>> conf.build()
+        '--location --verbose --insecure'
+        """
+        commands: tuple[CurlCommand | EmptyStr, ...] = (
+            self.get_location_command(),
+            self.get_verbose_command(),
+            self.get_silent_command(),
+            self.get_insecure_command(),
+            self.get_include_command(),
+        )
+        cleaned_commands: Generator[CurlCommand, None, None] = (
+            command for command in commands if command
+        )
+
+        return ' '.join(cleaned_commands)
+
+    def get_location_command(self: Self) -> CurlCommand | EmptyStr:
+        if self.location:
+            command = CommandsConfigureEnum.LOCATION.get(shorted=self.build_short)
+            return command
+
+        return ''
+
+    def get_verbose_command(self: Self) -> CurlCommand | EmptyStr:
+        if self.verbose:
+            command = CommandsConfigureEnum.VERBOSE.get(shorted=self.build_short)
+            return command
+        return ''
+
+    def get_silent_command(self: Self) -> CurlCommand | EmptyStr:
+        if self.silent:
+            command = CommandsConfigureEnum.SILENT.get(shorted=self.build_short)
+            return command
+
+        return ''
+
+    def get_insecure_command(self: Self) -> CurlCommand | EmptyStr:
+        if self.insecure:
+            command = CommandsConfigureEnum.INSECURE.get(shorted=self.build_short)
+            return command
+
+        return ''
+
+    def get_include_command(self: Self) -> CurlCommand | EmptyStr:
+        if self.include:
+            command = CommandsConfigureEnum.INCLUDE.get(shorted=self.build_short)
+            return command
+
+        return ''

curlifier-0.1.0/curlifier/curl.py

@@ -0,0 +1,72 @@
+from typing import Self
+
+from requests.models import PreparedRequest, Response
+
+from curlifier.configurator import ConfigBuilder
+from curlifier.transmitter import TransmitterBuilder
+
+
+class CurlBuilder:
+    """Builds the executable curl command."""
+
+    curl_command = 'curl'
+
+    def __init__(  # noqa: WPS211
+        self: Self,
+        location: bool,
+        verbose: bool,
+        silent: bool,
+        insecure: bool,
+        include: bool,
+        build_short: bool,
+        response: Response | None = None,
+        prepared_request: PreparedRequest | None = None,
+
+    ) -> None:
+        self.build_short = build_short
+        self.config = ConfigBuilder(
+            build_short=self.build_short,
+            location=location,
+            verbose=verbose,
+            silent=silent,
+            insecure=insecure,
+            include=include,
+        )
+        self.transmitter = TransmitterBuilder(
+            response=response,
+            prepared_request=prepared_request,
+            build_short=self.build_short,
+        )
+
+    def build(self: Self) -> str:
+        """
+        Collects all parameters into the resulting string.
+
+        If `build_short` is `True` will be collected short version.
+
+        >>> from curlifier.curl import CurlBuilder
+        >>> import requests
+        >>> r = requests.get('https://example.com/')
+        >>> curl_builder = CurlBuilder(
+            response=r,
+            location=True,
+            build_short=True,
+            verbose=False,
+            silent=False,
+            insecure=False,
+            include=False,
+        )
+        >>> curl_builder.build()
+        "curl -X GET 'https://example.com/' -H 'Accept-Encoding: gzip, deflate' -H 'Accept: */*' <...> -L"
+        """
+        builded_config: str = self.config.build()
+        builded_transmitter: str = self.transmitter.build()
+        builded: str = ' '.join(
+            (
+                self.curl_command,
+                builded_transmitter,
+                builded_config,
+            ),
+        )
+
+        return builded

curlifier-0.1.0/curlifier/structures/commands.py

@@ -0,0 +1,71 @@
+import enum
+from typing import Self
+
+from curlifier.structures.types import (
+    CurlCommand,
+    CurlCommandLong,
+    CurlCommandShort,
+)
+
+
+class CommandsEnum(enum.Enum):
+    """
+    Base class of the command curl structure.
+    When initialized, it will take two values: short and long.
+    """
+
+    def __init__(self: Self, short: CurlCommandShort, long: CurlCommandLong) -> None:
+        self.short = short
+        self.long = long
+
+    def get(self: Self, *, shorted: bool) -> CurlCommand:
+        """
+        Returns curl command.
+
+        :param shorted: `True` if you need a short version of the command. Otherwise `False`.
+        :type shorted: bool
+
+        :return: Curl command.
+        :rtype: CurlCommand
+        """
+        return self.short if shorted else self.long
+
+    def __str__(self: Self) -> CurlCommandLong:
+        return self.long
+
+
+@enum.unique
+class CommandsConfigureEnum(CommandsEnum):
+    """Curl configuration commands."""
+
+    VERBOSE = ('-v', '--verbose')
+    """Make the operation more talkative."""
+
+    SILENT = ('-s', '--silent')
+    """Silent mode."""
+
+    INSECURE = ('-k', '--insecure')
+    """Allow insecure server connections."""
+
+    LOCATION = ('-L', '--location')
+    """Follow redirects."""
+
+    INCLUDE = ('-i', '--include')
+    """Include protocol response headers in the output."""
+
+
+@enum.unique
+class CommandsTransferEnum(CommandsEnum):
+    """Curl transfer commands."""
+
+    SEND_DATA = ('-d', '--data')
+    """HTTP data (body)."""
+
+    HEADER = ('-H', '--header')
+    """Pass custom header(s) to server."""
+
+    REQUEST = ('-X', '--request')
+    """Specify request method to use."""
+
+    FORM = ('-F', '--form')
+    """Specify multipart MIME data."""

curlifier-0.1.0/curlifier/structures/http_methods.py

@@ -0,0 +1,36 @@
+import enum
+from typing import Self
+
+from curlifier.structures.types import HttpMethod
+
+
+@enum.unique
+class HttpMethodsEnum(enum.Enum):
+    """Supported HTTP methods."""
+
+    GET = 'GET'
+    OPTIONS = 'OPTIONS'
+    HEAD = 'HEAD'
+    POST = 'POST'
+    PUT = 'PUT'
+    PATCH = 'PATCH'
+    DELETE = 'DELETE'
+
+    @classmethod
+    def get_methods_without_body(cls: type[Self]) -> tuple[HttpMethod, HttpMethod, HttpMethod, HttpMethod]:
+        """HTTP methods methods that have a body in the structure."""
+        return (
+            cls.GET.value,
+            cls.HEAD.value,
+            cls.DELETE.value,
+            cls.OPTIONS.value,
+        )
+
+    @classmethod
+    def get_methods_with_body(cls: type[Self]) -> tuple[HttpMethod, HttpMethod, HttpMethod]:
+        """HTTP methods that do not have a body in the structure"""
+        return (
+            cls.POST.value,
+            cls.PUT.value,
+            cls.PATCH.value,
+        )

curlifier-0.1.0/curlifier/structures/types.py

@@ -0,0 +1,26 @@
+from typing import Any, Literal, TypedDict
+
+from requests.structures import CaseInsensitiveDict
+
+
+class CurlifyConfigure(TypedDict, total=False):
+    location: bool
+    verbose: bool
+    silent: bool
+    insecure: bool
+    include: bool
+
+
+type HeaderKey = str
+type HeaderValue = str
+type CurlCommandShort = str
+type CurlCommandLong = str
+type CurlCommand = CurlCommandShort | CurlCommandLong
+type HttpMethod = str
+type PreReqHttpMethod = str | Any | None
+type PreReqHttpBody = bytes | str | Any | None
+type PreReqHttpHeaders = CaseInsensitiveDict
+type PreReqHttpUrl = str | Any | None
+type FileNameWithExtension = str
+type FileFieldName = str
+type EmptyStr = Literal['']

curlifier-0.1.0/curlifier/transmitter.py

@@ -0,0 +1,184 @@
+import copy
+import re
+from typing import Self
+
+from requests import PreparedRequest, Response
+
+from curlifier.structures.commands import CommandsTransferEnum
+from curlifier.structures.http_methods import HttpMethodsEnum
+from curlifier.structures.types import (
+    EmptyStr,
+    FileFieldName,
+    FileNameWithExtension,
+    HeaderKey,
+    PreReqHttpBody,
+    PreReqHttpHeaders,
+    PreReqHttpMethod,
+    PreReqHttpUrl,
+)
+
+
+class PreparedTransmitter:
+    """
+    Prepares request data for processing.
+
+    Works on a copy of the request object. The original object will not be modified.
+    """
+
+    def __init__(
+        self: Self,
+        response: Response | None = None,
+        *,
+        prepared_request: PreparedRequest | None = None,
+    ) -> None:
+        if sum(arg is not None for arg in (response, prepared_request)) != 1:
+            raise ValueError("Only one argument must be specified: `response` or `prepared_request`")
+        self._pre_req: PreparedRequest = (
+            prepared_request.copy() if response is None  # type: ignore [union-attr]
+            else response.request.copy()
+        )
+
+        self._method: PreReqHttpMethod = self._pre_req.method
+        self._body: PreReqHttpBody = self._pre_req.body
+        self._headers: PreReqHttpHeaders = self._pre_req.headers
+        self._url: PreReqHttpUrl = self._pre_req.url
+
+    @property
+    def url(self: Self) -> PreReqHttpUrl:
+        return self._url
+
+    @property
+    def method(self: Self) -> PreReqHttpMethod:
+        return self._method
+
+    @property
+    def body(self: Self) -> PreReqHttpBody:
+        return self._body
+
+    @property
+    def headers(self: Self) -> PreReqHttpHeaders:
+        cleared_headers = copy.deepcopy(self._headers)
+        trash_headers: tuple[HeaderKey] = (
+            'Content-Length',
+        )
+        for header in trash_headers:
+            cleared_headers.pop(header, None)
+
+        if 'boundary=' in cleared_headers.get('Content-Type', ''):
+            cleared_headers['Content-Type'] = 'multipart/form-data'
+
+        return cleared_headers
+
+    @property
+    def has_body(self: Self) -> bool:
+        if self._pre_req.method in HttpMethodsEnum.get_methods_with_body():
+            return True
+
+        return False
+
+
+class TransmitterBuilder(PreparedTransmitter):
+    """Builds a curl command transfer line."""
+
+    executable_part = '{request_command} {method} \'{url}\' {request_headers} {request_data}'
+    executable_request_data = '{command} \'{request_data}\''
+    executable_header = '{command} \'{key}: {value}\''
+    executable_request_files = '{command} \'{field_name}=@{file_name}\''
+
+    def __init__(
+        self: Self,
+        build_short: bool,
+        response: Response | None = None,
+        prepared_request: PreparedRequest | None = None,
+    ) -> None:
+        self.build_short = build_short
+        super().__init__(response, prepared_request=prepared_request)
+
+    def build(self: Self) -> str:
+        """
+        Collects all parameters into the resulting string.
+
+        If `build_short` is `True` will be collected short version.
+
+        >>> from curlifier.transmitter import TransmitterBuilder
+        >>> import requests
+        >>> r = requests.get('https://example.com/')
+        >>> t = TransmitterBuilder(response=r, build_short=False)
+        >>> t.build()
+        "--request GET 'https://example.com/' --header 'User-Agent: python-requests/2.32.3' <...>"
+        """
+        request_command = CommandsTransferEnum.REQUEST.get(shorted=self.build_short)
+        request_headers = self._build_executable_headers()
+        request_data = self._build_request_data()
+
+        return self.executable_part.format(
+            request_command=request_command,
+            method=self.method,
+            url=self.url,
+            request_headers=request_headers,
+            request_data=request_data,
+        )
+
+    def _build_executable_headers(self: Self) -> str:
+        return ' '.join(
+            self.executable_header.format(
+                command=CommandsTransferEnum.HEADER.get(shorted=self.build_short),
+                key=header_key,
+                value=header_value,
+            ) for header_key, header_value in self.headers.items()
+        )
+
+    def _decode_files(self: Self) -> tuple[tuple[FileFieldName, FileNameWithExtension], ...] | None:
+        re_expression = rb'name="([^"]+).*?filename="([^"]+)'
+        matches = re.findall(
+            re_expression,
+            self.body,  # type: ignore [arg-type]
+            flags=re.DOTALL
+        )
+
+        return tuple(
+            (
+                field_name.decode(),
+                file_name.decode(),
+            ) for field_name, file_name in matches
+        )
+
+    def _decode_raw(self: Self) -> str:
+        re_expression = r'\s+'
+
+        return re.sub(re_expression, ' ', str(self.body)).strip()
+
+    def _decode_body(
+        self: Self,
+    ) -> None | tuple[tuple[FileFieldName, FileNameWithExtension], ...] | str:
+        if isinstance(self.body, bytes):
+            try:
+                return self.body.decode('utf-8')
+            except UnicodeDecodeError:
+                return self._decode_files()
+        elif isinstance(self.body, str):
+            return self._decode_raw()
+
+        return None
+
+    def _build_request_data(
+        self: Self,
+    ) -> str | EmptyStr:
+        if self.has_body:
+            decode_body = self._decode_body()
+            if isinstance(decode_body, str):
+                return self.executable_request_data.format(
+                    command=CommandsTransferEnum.SEND_DATA.get(shorted=self.build_short),
+                    request_data=decode_body,
+                )
+            elif isinstance(decode_body, tuple):
+                executable_files: str = ' '.join(
+                    self.executable_request_files.format(
+                        command=CommandsTransferEnum.FORM.get(shorted=self.build_short),
+                        field_name=field_name,
+                        file_name=file_name,
+                    ) for field_name, file_name in decode_body
+                )
+                return executable_files
+
+        return ''

curlifier-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "curlifier"
+version = "0.1.0"
+description = "Converts Request objects to curl string"
+authors = [
+    "Timur Valiev <cptchunk@yandex.ru>"
+]
+license = "MIT"
+readme = "README.md"
+
+homepage = "https://github.com/imtoopunkforyou/curlifier"
+
+keywords = [
+  "curl",
+  "curlify",
+  "python requests to curl",
+  "curlifier",
+]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+requests = "^2.30"
+
+
+[tool.poetry.group.lint.dependencies]
+wemake-python-styleguide = "^1.1.0"
+mypy = "^1.15.0"
+isort = "^6.0.1"
+types-requests = "^2.32.0.20250328"
+darglint = "^1.8.1"
+
+
+[tool.poetry.group.dev.dependencies]
+nitpick = "^0.35.0"
+ipython = "^9.1.0"
+
+
+[tool.poetry.group.tests.dependencies]
+pytest = "^8.3.5"
+faker = "^37.1.0"
+pytest-cov = "^6.1.1"
+
+[tool.nitpick]
+style = "https://raw.githubusercontent.com/imtoopunkforyou/itpfy-style/refs/heads/main/py/imtoopunkforyou.toml"