curlipie 0.0.0__tar.gz

curlipie-0.0.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: curlipie
+Version: 0.0.0
+Summary: Library to convert cURL command line to HTTPie
+Keywords: api,cli,conversion,curl,http,httpie
+Author-Email: =?utf-8?b?Tmd1eeG7hW4gSOG7k25nIFF1w6Ju?= <ng.hong.quan@gmail.com>
+Maintainer-Email: =?utf-8?b?Tmd1eeG7hW4gSOG7k25nIFF1w6Ju?= <ng.hong.quan@gmail.com>
+License-Expression: MPL-2.0
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: repository, https://github.com/hongquan/CurliPie.git
+Requires-Python: <4.0,>=3.14
+Requires-Dist: click>=8.5.0
+Requires-Dist: first>=2.0.2
+Requires-Dist: http-constants>=0.5.0
+Requires-Dist: kiss-headers>=2.5.0
+Requires-Dist: logbook>=1.10.1
+Requires-Dist: multidict>=6.9.1
+Requires-Dist: orjson>=3.12.0
+Requires-Dist: pydantic>=2.13.5
+Requires-Dist: pydantic-settings>=2.15.0
+Requires-Dist: typed-argument-parser>=1.12.0
+Requires-Dist: yarl>=1.25.1
+Description-Content-Type: text/x-rst
+
+========
+CurliPie
+========
+
+.. image:: https://madewithlove.vercel.app/vn?heart=true&colorA=%23ffcd00&colorB=%23da251d
+.. image:: https://badgen.net/pypi/v/curlipie
+   :target: https://pypi.org/project/curlipie
+
+Python library to convert `cURL`_ command to `HTTPie`_.
+
+It will convert
+
+.. code-block:: sh
+
+    curl -d name=admin -d shoesize=12 -d color=green&food=wet http://quan.hoabinh.vn
+
+to
+
+.. code-block:: sh
+
+    http -f http://quan.hoabinh.vn name=admin shoesize=12 color=green food=wet
+
+
+Motivation
+----------
+
+This library was born when I joined a project with a team of non-Linux, non-Python developers. Because the project didn't have proper documentation, the other team often shared API usage example to me in form of cURL command, generated from their daily-used Postman. Those cURL commands are usually ugly, like this:
+
+
+.. code-block:: sh
+
+    curl --location --request POST 'http://app-staging.dev/api' \
+    --header 'Content-Type: application/json' \
+    --data-raw '{
+        "userId": "abc-xyz",
+        "planAmount": 50000,
+        "isPromotion": false,
+        "createdAt": "2019-12-13 10:00:00"
+    }'
+
+I am more comfortable with HTTPie (shorter syntax, has highlighting and is a Python application), so I often converted it to HTTPie:
+
+.. code-block:: sh
+
+    http -F app-staging.dev/api userId=abc-xyz planAmount:=50000 isPromotion:=false createdAt='2019-12-13 10:00:00'
+
+Though Postman can generate HTTPie, it does result in even uglier command:
+
+.. code-block:: sh
+
+    printf '{
+        "userId": "abc-xyz",
+        "planAmount": 50000,
+        "isPromotion": false,
+        "createdAt": "2019-12-13 10:00:00"
+    }'| http  --follow --timeout 3600 POST app-staging.dev/api \
+    Content-Type:'application/json'
+
+Initially, I had to do conversion manually and quickly got tired from it. I tried to find a conversion tool but failed. There is an online tool `curl2httpie.online`_, but it failed with above example. So I decide to write my own tool.
+
+I don't bother to help fix the online tool above, because it is written in Go. The rich ecosystem of Python, with these built-in libraries, enable me to finish the job fast:
+
+- |shlex|_: Help parse the command line in form of shell language, handle the string escaping, quoting for me.
+- |argparse|_: Help parse cURL options and arguments. Note that, cURL arguments syntax follow GNU style, which is common in Linux (and Python) world but not popular in Go world (see `this tutorial <go_tutorial_>`_), so it feels more natural with Python.
+
+
+Usage
+-----
+
+Command-line
+~~~~~~~~~~~~
+
+When installed, CurliPie registers a ``curlipie`` command:
+
+.. code-block:: sh
+
+    # Pass the cURL command as an argument
+    curlipie "curl -X POST http://api.example.com -d 'name=admin'"
+
+    # Or pipe from stdin (handy with clipboard tools)
+    echo "curl http://example.com --user admin:secret" | curlipie
+
+    # Run with no arguments to enter interactive mode — paste your cURL command
+    # (including multi-line backslash-continued commands from Postman or Swagger),
+    # then press Enter twice or Ctrl-D to convert
+    curlipie
+
+    # Use long-form HTTPie options instead of short flags
+    curlipie --long "curl -L -X DELETE http://api.example.com/users/1"
+
+    # Show help
+    curlipie --help
+
+Python library
+~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    >>> from curlipie import curl_to_httpie
+
+    >>> curl = """curl -XPUT elastic.dev/movies/_doc/1 -d '{"director": "Burton, Tim", "year": 1996, "title": "Mars Attacks!"}' -H 'Content-Type: application/json'"""
+
+    >>> curl_to_httpie(curl)
+    ConversionResult(httpie="http PUT elastic.dev/movies/_doc/1 director='Burton, Tim' year:=1996 title='Mars Attacks!'", errors=[])
+
+    >>> result = curl_to_httpie(curl)
+
+    >>> result.httpie
+    "http PUT elastic.dev/movies/_doc/1 director='Burton, Tim' year:=1996 title='Mars Attacks!'"
+
+
+Online tool
+-----------
+
+CurliPie is not very usable if it stays in library form, so I made an online tool for you to use it quickly:
+
+https://curlipie.open-api.vn
+
+The site also provide HTTP API for you to develop a client for it.
+
+
+Development
+-----------
+
+This repo contains three components:
+
+- Python library ``curlipie``. This is the one `published`_ to PyPI.
+
+- An API server built with `FastAPI`_, playing role of backend for `curlipie.open-api.vn`_.
+
+- A minimal frontend app built with `AlpineJS`_ and `EncreCSS`_ (CSS class names following `TailwindCSS`_ convention).
+
+- Python dependencies are managed with `uv`_.
+
+To try running on localhost:
+
+- Run backend with:
+
+  .. code-block:: sh
+
+    uvicorn api.main:app
+
+- The front-end are just static files, served by backend also, so you can access it via http://localhost:8000/. The CSS is generated depending on which CSS classes are used.
+
+  .. code-block:: sh
+
+    ./tools/generate-css.sh
+
+
+Unit test:
+
+    .. code-block:: sh
+
+        pytest
+
+
+Credit
+------
+
+Brought to you by `Nguyễn Hồng Quân <author_>`_.
+
+
+.. _cURL: https://curl.haxx.se
+.. _HTTPie: https://httpie.org
+.. _curl2httpie.online: https://curl2httpie.online/
+.. |shlex| replace:: ``shlex``
+.. _shlex: https://docs.python.org/3/library/shlex.html
+.. |argparse| replace:: ``argparse``
+.. _argparse: https://docs.python.org/3/library/argparse.html
+.. _go_tutorial: https://gobyexample.com/command-line-flags
+.. _published: https://pypi.org/project/curlipie/
+.. _fastapi: https://github.com/tiangolo/fastapi
+.. _curlipie.open-api.vn: https://curlipie.open-api.vn/
+.. _vuejs: https://vuejs.org/
+.. _alpinejs: https://github.com/alpinejs/alpine
+.. _encrecss: https://encrecss.uk.to
+.. _tailwindcss: https://tailwindcss.com
+.. _uv: https://docs.astral.sh/uv/
+.. _author: https://quan.hoabinh.vn

curlipie-0.0.0/README.rst

@@ -0,0 +1,179 @@
+========
+CurliPie
+========
+
+.. image:: https://madewithlove.vercel.app/vn?heart=true&colorA=%23ffcd00&colorB=%23da251d
+.. image:: https://badgen.net/pypi/v/curlipie
+   :target: https://pypi.org/project/curlipie
+
+Python library to convert `cURL`_ command to `HTTPie`_.
+
+It will convert
+
+.. code-block:: sh
+
+    curl -d name=admin -d shoesize=12 -d color=green&food=wet http://quan.hoabinh.vn
+
+to
+
+.. code-block:: sh
+
+    http -f http://quan.hoabinh.vn name=admin shoesize=12 color=green food=wet
+
+
+Motivation
+----------
+
+This library was born when I joined a project with a team of non-Linux, non-Python developers. Because the project didn't have proper documentation, the other team often shared API usage example to me in form of cURL command, generated from their daily-used Postman. Those cURL commands are usually ugly, like this:
+
+
+.. code-block:: sh
+
+    curl --location --request POST 'http://app-staging.dev/api' \
+    --header 'Content-Type: application/json' \
+    --data-raw '{
+        "userId": "abc-xyz",
+        "planAmount": 50000,
+        "isPromotion": false,
+        "createdAt": "2019-12-13 10:00:00"
+    }'
+
+I am more comfortable with HTTPie (shorter syntax, has highlighting and is a Python application), so I often converted it to HTTPie:
+
+.. code-block:: sh
+
+    http -F app-staging.dev/api userId=abc-xyz planAmount:=50000 isPromotion:=false createdAt='2019-12-13 10:00:00'
+
+Though Postman can generate HTTPie, it does result in even uglier command:
+
+.. code-block:: sh
+
+    printf '{
+        "userId": "abc-xyz",
+        "planAmount": 50000,
+        "isPromotion": false,
+        "createdAt": "2019-12-13 10:00:00"
+    }'| http  --follow --timeout 3600 POST app-staging.dev/api \
+    Content-Type:'application/json'
+
+Initially, I had to do conversion manually and quickly got tired from it. I tried to find a conversion tool but failed. There is an online tool `curl2httpie.online`_, but it failed with above example. So I decide to write my own tool.
+
+I don't bother to help fix the online tool above, because it is written in Go. The rich ecosystem of Python, with these built-in libraries, enable me to finish the job fast:
+
+- |shlex|_: Help parse the command line in form of shell language, handle the string escaping, quoting for me.
+- |argparse|_: Help parse cURL options and arguments. Note that, cURL arguments syntax follow GNU style, which is common in Linux (and Python) world but not popular in Go world (see `this tutorial <go_tutorial_>`_), so it feels more natural with Python.
+
+
+Usage
+-----
+
+Command-line
+~~~~~~~~~~~~
+
+When installed, CurliPie registers a ``curlipie`` command:
+
+.. code-block:: sh
+
+    # Pass the cURL command as an argument
+    curlipie "curl -X POST http://api.example.com -d 'name=admin'"
+
+    # Or pipe from stdin (handy with clipboard tools)
+    echo "curl http://example.com --user admin:secret" | curlipie
+
+    # Run with no arguments to enter interactive mode — paste your cURL command
+    # (including multi-line backslash-continued commands from Postman or Swagger),
+    # then press Enter twice or Ctrl-D to convert
+    curlipie
+
+    # Use long-form HTTPie options instead of short flags
+    curlipie --long "curl -L -X DELETE http://api.example.com/users/1"
+
+    # Show help
+    curlipie --help
+
+Python library
+~~~~~~~~~~~~~~
+
+.. code-block:: python
+
+    >>> from curlipie import curl_to_httpie
+
+    >>> curl = """curl -XPUT elastic.dev/movies/_doc/1 -d '{"director": "Burton, Tim", "year": 1996, "title": "Mars Attacks!"}' -H 'Content-Type: application/json'"""
+
+    >>> curl_to_httpie(curl)
+    ConversionResult(httpie="http PUT elastic.dev/movies/_doc/1 director='Burton, Tim' year:=1996 title='Mars Attacks!'", errors=[])
+
+    >>> result = curl_to_httpie(curl)
+
+    >>> result.httpie
+    "http PUT elastic.dev/movies/_doc/1 director='Burton, Tim' year:=1996 title='Mars Attacks!'"
+
+
+Online tool
+-----------
+
+CurliPie is not very usable if it stays in library form, so I made an online tool for you to use it quickly:
+
+https://curlipie.open-api.vn
+
+The site also provide HTTP API for you to develop a client for it.
+
+
+Development
+-----------
+
+This repo contains three components:
+
+- Python library ``curlipie``. This is the one `published`_ to PyPI.
+
+- An API server built with `FastAPI`_, playing role of backend for `curlipie.open-api.vn`_.
+
+- A minimal frontend app built with `AlpineJS`_ and `EncreCSS`_ (CSS class names following `TailwindCSS`_ convention).
+
+- Python dependencies are managed with `uv`_.
+
+To try running on localhost:
+
+- Run backend with:
+
+  .. code-block:: sh
+
+    uvicorn api.main:app
+
+- The front-end are just static files, served by backend also, so you can access it via http://localhost:8000/. The CSS is generated depending on which CSS classes are used.
+
+  .. code-block:: sh
+
+    ./tools/generate-css.sh
+
+
+Unit test:
+
+    .. code-block:: sh
+
+        pytest
+
+
+Credit
+------
+
+Brought to you by `Nguyễn Hồng Quân <author_>`_.
+
+
+.. _cURL: https://curl.haxx.se
+.. _HTTPie: https://httpie.org
+.. _curl2httpie.online: https://curl2httpie.online/
+.. |shlex| replace:: ``shlex``
+.. _shlex: https://docs.python.org/3/library/shlex.html
+.. |argparse| replace:: ``argparse``
+.. _argparse: https://docs.python.org/3/library/argparse.html
+.. _go_tutorial: https://gobyexample.com/command-line-flags
+.. _published: https://pypi.org/project/curlipie/
+.. _fastapi: https://github.com/tiangolo/fastapi
+.. _curlipie.open-api.vn: https://curlipie.open-api.vn/
+.. _vuejs: https://vuejs.org/
+.. _alpinejs: https://github.com/alpinejs/alpine
+.. _encrecss: https://encrecss.uk.to
+.. _tailwindcss: https://tailwindcss.com
+.. _uv: https://docs.astral.sh/uv/
+.. _author: https://quan.hoabinh.vn

curlipie-0.0.0/curlipie/__init__.py

@@ -0,0 +1,4 @@
+from .pie import curl_to_httpie, ConversionResult  # NOQA
+
+
+__version__ = '0.10.0'

curlipie-0.0.0/curlipie/cli.py

@@ -0,0 +1,60 @@
+import sys
+
+import click
+
+from .pie import curl_to_httpie
+
+
+PROMPT = 'Paste your cURL command (press Enter twice or Ctrl-D when done):'
+
+
+def _read_interactive() -> str:
+    """Prompt the user to paste a cURL command, reading until a blank line or EOF."""
+    click.echo(PROMPT, err=True)
+    lines: list[str] = []
+    try:
+        while True:
+            line = input()
+            if line == '' and lines:
+                break
+            lines.append(line)
+    except EOFError:
+        click.echo(err=True)
+    except KeyboardInterrupt:
+        click.echo(err=True)
+    return '\n'.join(lines)
+
+
+@click.command('curlipie')
+@click.argument('curl_command', required=False, default=None)
+@click.option(
+    '-l',
+    '--long',
+    'long_option',
+    is_flag=True,
+    help='Use long-form HTTPie options (e.g. --follow instead of -F).',
+)
+@click.version_option()
+def main(curl_command: str | None, long_option: bool) -> None:
+    """Convert a cURL command to an HTTPie command."""
+    if curl_command is not None:
+        curl_cmd = curl_command.strip()
+    elif not sys.stdin.isatty():
+        curl_cmd = sys.stdin.read().strip()
+    else:
+        curl_cmd = _read_interactive().strip()
+
+    if not curl_cmd:
+        return
+
+    result = curl_to_httpie(curl_cmd, long_option=long_option)
+
+    if result.errors:
+        for err in result.errors:
+            click.echo(f'Warning: {err}', err=True)
+
+    click.echo(result.httpie)
+
+
+if __name__ == '__main__':
+    main()

curlipie-0.0.0/curlipie/curly.py

@@ -0,0 +1,208 @@
+import collections.abc
+from dataclasses import dataclass, field
+from collections import OrderedDict, deque
+from typing import cast
+from urllib.parse import parse_qsl
+
+import yarl
+import orjson
+from tap import Tap
+from logbook import Logger
+from kiss_headers import parse_it, get_polymorphic, ContentType, Accept, BasicAuthorization
+from kiss_headers import Headers, Header
+from http_constants.headers import HttpHeaders as HH
+
+
+logger = Logger(__name__)
+
+
+@dataclass
+class DataArgParseResult:
+    data: deque[tuple[str, str]] = field(default_factory=deque)
+    errors: deque[str] = field(default_factory=deque)
+
+
+# Ref: https://helpmanual.io/help/curl/
+class CURLArgumentParser(Tap):
+    url: str
+    verbose: bool = False
+    include: bool = False
+    location: bool = False
+    append: bool = False
+    silent: bool = False
+    fail: bool = False
+    show_error: bool = False
+    globoff: bool = False
+    insecure: bool = False
+    http1_0: bool = False
+    tlsv1: bool = False
+    sslv2: bool = False
+    sslv3: bool = False
+    netrc: bool = False
+    proxytunnel: bool = False
+    use_ascii: bool = False
+    no_buffer: bool = False
+    remote_name: bool = False
+    remote_time: bool = False
+    remote_header_name: bool = False
+    max_redirs: int = 0
+    max_time: float = 0
+    request: str | None = None
+    proxy: str | None = None
+    user: str | None = None
+    cert: str | None = None
+    cacert: str | None = None
+    header: list[str] = []
+    form: list[str] = []
+    data: list[str] = []
+    data_raw: list[str] = []
+    data_binary: list[str] = []
+    user_agent: str | None = None
+    head: bool = False
+    get: bool = False
+    output: str | None = None
+    http2: bool = False
+    # Intermediate converted data
+    _url: str = ''
+    _auth: BasicAuthorization | None = None
+    _params: deque[tuple[str, str]] = field(default_factory=deque)
+    _data: deque[tuple[str, str]] = field(default_factory=deque)
+    _headers: Headers
+    _request_json: bool = False
+    _accept_json: bool = False
+    _errors: list[str] = []
+
+    def _get_class_variables(self, exclude_tap_ignores: bool = True) -> OrderedDict[str, str]:
+        """Overide to exclude our private variables"""
+        all_variables = super()._get_class_variables(exclude_tap_ignores)
+        return OrderedDict((k, v) for k, v in all_variables.items() if not k.startswith('_'))
+
+    def configure(self) -> None:
+        self.add_argument('url')
+        self.add_argument('-v', '--verbose')
+        self.add_argument('-i', '--include')
+        self.add_argument('-L', '--location')
+        self.add_argument('-a', '--append')
+        self.add_argument('-s', '--silent')
+        self.add_argument('-f', '--fail')
+        self.add_argument('-S', '--show-error')
+        self.add_argument('-g', '--globoff')
+        self.add_argument('-k', '--insecure')
+        self.add_argument('-0', '--http1.0', dest='http1_0')
+        self.add_argument('-1', '--tlsv1')
+        self.add_argument('-2', '--sslv2')
+        self.add_argument('-3', '--sslv3')
+        self.add_argument('-n', '--netrc')
+        self.add_argument('-p', '--proxytunnel')
+        self.add_argument('-B', '--use-ascii')
+        self.add_argument('-N', '--no-buffer')
+        self.add_argument('-O', '--remote-name')
+        self.add_argument('-R', '--remote-time')
+        self.add_argument('-J', '--remote-header-name')
+        self.add_argument('-X', '--request')
+        self.add_argument('-m', '--max-time')
+        self.add_argument('-x', '--proxy', nargs='?')
+        self.add_argument('-u', '--user')
+        self.add_argument('-E', '--cert')
+        self.add_argument('--cacert')
+        self.add_argument('-H', '--header', nargs='?', action='append')
+        self.add_argument('-d', '--data', nargs='?', action='append')
+        self.add_argument('--data-raw', nargs='?', action='append', default=[])
+        self.add_argument('--data-binary', nargs='?', action='append')
+        self.add_argument('-F', '--form', nargs='?', action='append')
+        self.add_argument('-A', '--user-agent')
+        self.add_argument('-I', '--head')
+        self.add_argument('-G', '--get')
+        self.add_argument('-o', '--output')
+        self._headers = Headers()
+
+    def process_args(self) -> None:
+        u = yarl.URL(self.url)
+        # Clean fragment, if exist
+        url = str(u.with_fragment(None).with_query(None))
+        # Strip leading "http://" to be short
+        self._url = url[7:] if u.scheme == 'http' else url
+        self._params = deque(u.query.items())
+        self._data = deque()
+        for dstring in self.data:
+            result = parse_post_data(dstring)
+            self._data.extend(result.data)
+            self._errors.extend(result.errors)
+        for dstring in self.data_raw:
+            result = parse_post_data(dstring, ignore_at=True)
+            self._data.extend(result.data)
+            self._errors.extend(result.errors)
+        for dstring in self.form:
+            result = parse_post_data(dstring)
+            self._data.extend(result.data)
+            self._errors.extend(result.errors)
+        for h in self.header:
+            headers = parse_it(h)
+            if not headers:
+                continue
+            if HH.CONTENT_TYPE in headers:
+                hx = cast(ContentType | None, get_polymorphic(headers, ContentType))
+                if hx and hx.get_mime() == HH.CONTENT_TYPE_VALUES.json:
+                    self._request_json = True
+                    continue
+            elif HH.ACCEPT in headers:
+                hx = cast(Accept | None, get_polymorphic(headers, Accept))
+                if hx and hx.has(HH.CONTENT_TYPE_VALUES.json):
+                    self._accept_json = True
+                    continue
+            elif HH.AUTHORIZATION in headers:
+                auth_header = cast(Header, headers.authorization)
+                if auth_header.content.startswith('Basic '):
+                    hx = cast(BasicAuthorization | None, get_polymorphic(headers, BasicAuthorization))
+                    self._auth = hx
+                    continue
+            # kiss-header doesn't prevent duplicate, so we have to check ourselve
+            # Please note the behavior of kiss-headers: The "Accept-Encoding: gzip, deflate"
+            # will be parsed to two Header objects, to get all the "value" side, we have to
+            # convert the parse result to dict.
+            first_header = cast(Header, headers[0])
+            name = first_header.pretty_name
+            if self._headers.has(name):
+                del self._headers[name]
+            value = headers.to_dict()[name]
+            self._headers += Header(name, value)
+
+    def error(self, message: str) -> None:  # type: ignore[override]
+        # Override to prevent parser from terminating our program
+        pass
+
+
+def parse_post_data(string: str, ignore_at: bool = False) -> DataArgParseResult:
+    # https://ec.haxx.se/http/http-post
+    if not string:
+        return DataArgParseResult()
+    data = deque(parse_qsl(string))
+    if data:
+        return DataArgParseResult(data=data)
+    # Standard parse_qsl failed to parse it
+    if not ignore_at and '@' in string and not string.startswith('@'):
+        # cURL spec says that the filename should already be url-encoded.
+        key, filename = string.split('@')[:2]
+        return DataArgParseResult(data=deque([(key, filename)]))
+    # HTTPie doesn't support sending raw content as request body
+    # (though it allows to specify raw content as the value for a field),
+    # so we can ignore cURL "content", "=content", "@filename" syntaxes.
+    errors: deque[str] = deque()
+    if string.startswith('@'):
+        errors.append('@filename syntax (without field name) is not supported')
+        return DataArgParseResult(data, errors)
+    if string.startswith('='):
+        errors.append('=content syntax (without field name) is not supported')
+        return DataArgParseResult(data, errors)
+    # Maybe JSON?
+    try:
+        jsdata = orjson.loads(string.encode())
+    except orjson.JSONDecodeError:
+        # Not JSON
+        errors.append('Cannot guess post data format')
+        return DataArgParseResult(data, errors)
+    if isinstance(jsdata, collections.abc.Mapping):
+        data = deque(jsdata.items())
+        return DataArgParseResult(data, errors)
+    errors.append('JSON content does not represent an object')
+    return DataArgParseResult(errors=errors)

curlipie-0.0.0/curlipie/pie.py

@@ -0,0 +1,154 @@
+import re
+import shlex
+import logging
+from shlex import quote
+from collections import deque
+
+import orjson
+from first import first
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.config import JsonValue
+from http_constants.headers import HttpHeaders as HH
+from .curly import CURLArgumentParser
+
+
+REGEX_SINGLE_OPT = re.compile(r'^-\w+$')
+REGEX_SHELL_LINEBREAK = re.compile(r'\\\s+')
+logger = logging.getLogger(__name__)
+EXAMPLE: JsonValue = {'httpie': 'http -fa admin:xxx quan.hoabinh.vn/api/users name=meow', 'errors': []}
+
+
+class ConversionResult(BaseModel):
+    model_config = ConfigDict(json_schema_extra={'example': EXAMPLE})
+    httpie: str
+    errors: deque[str] = Field(default_factory=deque)
+
+
+def join_previous_arg(cmds: deque[str], name: str) -> None:
+    prev_arg = cmds[-1]
+    if REGEX_SINGLE_OPT.match(prev_arg):
+        cmds[-1] += name
+    else:
+        cmds.append(f'-{name}')
+
+
+def clean_curl(cmd: str) -> str:
+    """Remove slash-escaped newlines and normal newlines from curl command."""
+    stripped = REGEX_SHELL_LINEBREAK.sub(' ', cmd)
+    return ' '.join(stripped.splitlines())
+
+
+def curl_to_httpie(cmd: str, long_option: bool = False) -> ConversionResult:
+    # The cmd can be multiline string, with escape symbols, shlex doesn't support it, so
+    # we should convert it to one-line first.
+    oneline = clean_curl(cmd)
+    try:
+        cargs = shlex.split(oneline)
+    except ValueError as e:
+        logger.error('Failed to parse as shell command. Error: %s', e)
+        return ConversionResult(httpie='', errors=deque([str(e)]))
+    if not cargs:
+        return ConversionResult(httpie='')
+    if cargs[0] == 'curl':
+        cargs = cargs[1:]
+        if not cargs:
+            return ConversionResult(httpie='http')
+    args = CURLArgumentParser().parse_args(cargs)
+    cmds = deque(['http'])
+    if args.verbose:
+        cmds.append('--verbose' if long_option else '-v')
+    if args.location:
+        if long_option:
+            cmds.append('--follow')
+        else:
+            join_previous_arg(cmds, 'F')
+    if args.remote_name:
+        if long_option:
+            cmds.append('--download')
+        else:
+            join_previous_arg(cmds, 'd')
+    if args._data and not args._request_json:
+        if long_option:
+            cmds.append('--form')
+        else:
+            join_previous_arg(cmds, 'f')
+    elif not args._data and (args._request_json or args._accept_json):
+        if long_option:
+            cmds.append('--json')
+        else:
+            join_previous_arg(cmds, 'j')
+    if args.proxy:
+        cmds.extend(('--proxy', args.proxy))
+    user = args.user if args.user else (':'.join(args._auth.get_username_password()) if args._auth else None)
+    if user:
+        if long_option:
+            cmds.extend(('--auth', quote(user)))
+        else:
+            join_previous_arg(cmds, 'a')
+            cmds.append(quote(user))
+
+    if args.include:
+        cmds.append('--all')
+    if args.insecure:
+        cmds.extend(('--verify', 'no'))
+    elif args.cacert:
+        cmds.extend(('--verify', args.cacert))
+    if args.cert:
+        cmds.extend(('--cert', quote(args.cert)))
+    if args.max_redirs:
+        cmds.extend(('--max-redirects', str(args.max_redirs)))
+    if args.max_time:
+        cmds.extend(('--timeout', str(args.max_time)))
+    if args.head:
+        cmds.append('HEAD')
+    elif args.request and not (args._data and args.request == 'POST'):
+        cmds.append(args.request)
+    # URL
+    cmds.append(args._url)
+    # Headers
+    for k, v in args._headers.to_dict().items():
+        cmds.append(f'{quote(k)}:{quote(v)}')
+    if args.user_agent:
+        cmds.append(f'{HH.USER_AGENT}:{quote(args.user_agent)}')
+    # Params
+    for k, v in args._params:
+        if k.startswith('-'):
+            cmds.append('--')
+        k = k.replace('=', r'\=')
+        cmds.append(f'{quote(k)}=={quote(v)}')
+    # Data
+    for p, v in args._data:
+        p = str(p)
+        if p.startswith('-'):
+            cmds.append('--')
+        p = p.replace('=', r'\=')
+        qp = quote(p)
+        # Syntax for uploading file
+        if isinstance(v, str) and v.startswith('@') and not args._request_json:
+            # Strip beginning @
+            filepath = v[1:]
+            cmds.append(f'{qp}@{quote(filepath)}')
+            continue
+        # Not uploading file
+        # Python shlex's quote will turn bool value to empty string, that is not we want
+        if isinstance(v, bool):
+            js_bool = str(v).lower()
+            cmds.append(f'{qp}:={js_bool}' if not args.get else f'{qp}=={str(v)}')
+            continue
+        try:
+            qv = quote(v)
+            cmds.append(f'{qp}={qv}' if not args.get else f'{qp}=={qv}')
+        except TypeError:  # v is not string, normally after parsed from JSON
+            if isinstance(v, (list, dict)):
+                v = quote(orjson.dumps(v).decode())
+            cmds.append(f'{qp}:={v}' if not args.get else f'{qp}=={quote(str(v))}')
+    if args.data_binary:
+        fn = first(v for v in args.data_binary if v and v.startswith('@'))
+        if fn:
+            # Strip @
+            fn = fn[1:]
+            cmds.append(f'@{quote(fn)}')
+    if args.output:
+        param = '-o' if not long_option else '--output'
+        cmds.extend((param, quote(args.output)))
+    return ConversionResult(httpie=' '.join(cmds), errors=deque(frozenset(args._errors)))

curlipie-0.0.0/pyproject.toml

@@ -0,0 +1,144 @@
+[project]
+name = "curlipie"
+description = "Library to convert cURL command line to HTTPie"
+authors = [
+    { name = "Nguyễn Hồng Quân", email = "ng.hong.quan@gmail.com" },
+]
+maintainers = [
+    { name = "Nguyễn Hồng Quân", email = "ng.hong.quan@gmail.com" },
+]
+dynamic = []
+readme = "README.rst"
+license = "MPL-2.0"
+requires-python = "<4.0,>=3.14"
+dependencies = [
+    "click>=8.5.0",
+    "first>=2.0.2",
+    "http-constants>=0.5.0",
+    "kiss-headers>=2.5.0",
+    "logbook>=1.10.1",
+    "multidict>=6.9.1",
+    "orjson>=3.12.0",
+    "pydantic>=2.13.5",
+    "pydantic-settings>=2.15.0",
+    "typed-argument-parser>=1.12.0",
+    "yarl>=1.25.1",
+]
+classifiers = [
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+keywords = [
+    "api",
+    "cli",
+    "conversion",
+    "curl",
+    "http",
+    "httpie",
+]
+version = "0.0.0"
+
+[project.scripts]
+curlipie = "curlipie.cli:main"
+
+[project.urls]
+repository = "https://github.com/hongquan/CurliPie.git"
+
+[dependency-groups]
+dev = [
+    "aiofiles>=25.1.0",
+    "devtools>=0.12.2",
+    "fastapi>=0.141.1",
+    "jinja2>=3.1.6",
+    "uvicorn>=0.53.0",
+]
+lint = [
+    "ruff>=0.16.8",
+]
+test = [
+    "mypy>=2.3.1",
+    "pytest>=9.1.1",
+    "pytest-mock>=3.15.1",
+    "pytest-mypy>=1.0.1",
+    "types-first>=2.0.5.20260408",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.mypy]
+python_version = "3.12"
+allow_redefinition = true
+plugins = [
+    "pydantic.mypy",
+]
+follow_imports = "silent"
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+
+[[tool.mypy.overrides]]
+module = [
+    "devtools.*",
+    "logbook.*",
+    "http_constants.headers.*",
+]
+ignore_missing_imports = true
+
+[tool.pydantic-mypy]
+init_typed = true
+init_forbid_extra = true
+warn_required_dynamic_aliases = true
+
+[tool.pytest]
+addopts = [
+    "--mypy",
+]
+testpaths = [
+    "tests",
+    "curlipie",
+]
+
+[tool.ruff]
+line-length = 120
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+target-version = "py314"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "UP",
+    "ANN",
+]
+ignore = []
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+quote-style = "single"

curlipie-0.0.0/tests/test_cli.py

@@ -0,0 +1,67 @@
+from click.testing import CliRunner
+from pytest_mock import MockerFixture
+
+from curlipie.cli import main
+
+
+runner = CliRunner()
+
+
+def test_simple_get() -> None:
+    result = runner.invoke(main, ['curl http://example.com'])
+    assert result.exit_code == 0
+    assert result.output.strip() == 'http example.com'
+
+
+def test_post_form() -> None:
+    result = runner.invoke(main, ["curl -X POST http://example.com -d 'name=admin&size=12'"])
+    assert result.exit_code == 0
+    assert result.output.strip() == 'http -f example.com name=admin size=12'
+
+
+def test_long_options() -> None:
+    result = runner.invoke(main, ['--long', 'curl -L http://example.com'])
+    assert result.exit_code == 0
+    assert '--follow' in result.output
+    assert '-F' not in result.output
+
+
+def test_stdin_input() -> None:
+    result = runner.invoke(main, input='curl http://example.com')
+    assert result.exit_code == 0
+    assert result.output.strip() == 'http example.com'
+
+
+def test_empty_stdin_exits_ok() -> None:
+    # Piping empty input exits 0 silently.
+    result = runner.invoke(main, input='')
+    assert result.exit_code == 0
+
+
+def test_warnings_go_to_stderr() -> None:
+    # A parse error (unterminated quote) should print a warning to stderr
+    # and still exit cleanly (exit 0), printing whatever httpie output exists.
+    result = runner.invoke(main, ["curl 'unterminated"])
+    assert result.exit_code == 0
+    assert 'Warning' in result.output
+
+
+def test_pipe_multiline_curl() -> None:
+    curl = (
+        'curl -X POST \\\nhttp://example.com/api \\\n-H \'Content-Type: application/json\' \\\n-d \'{"name": "bob"}\''
+    )
+    result = runner.invoke(main, input=curl)
+    assert result.exit_code == 0
+    assert 'example.com/api' in result.output
+    assert 'name=bob' in result.output
+
+
+def test_interactive_input(mocker: MockerFixture) -> None:
+    # When stdin looks like a TTY, the CLI prompts and reads interactive input.
+    stdin = mocker.patch('curlipie.cli.sys.stdin')
+    stdin.isatty.return_value = True
+    stdin.read.return_value = ''
+
+    result = runner.invoke(main, input='curl http://example.com\n')
+    assert result.exit_code == 0
+    assert result.output.strip() == 'http example.com'

curlipie-0.0.0/tests/test_curlipie.py

@@ -0,0 +1,171 @@
+import pytest
+
+from devtools import debug
+from curlipie.pie import curl_to_httpie
+
+
+test_data = (
+    ("curl -d 'name=admin&shoesize=12' http://quan.hoabinh.vn", 'http -f quan.hoabinh.vn name=admin shoesize=12'),
+    (
+        'curl -d name=admin -d shoesize=12 https://quan.hoabinh.vn',
+        'http -f https://quan.hoabinh.vn name=admin shoesize=12',
+    ),
+    (
+        'curl -d name=admin -d shoesize=12 -d color=green&food=wet quan.hoabinh.vn',
+        'http -f quan.hoabinh.vn name=admin shoesize=12 color=green food=wet',
+    ),
+    ('curl -I http://quan.hoabinh.vn', 'http HEAD quan.hoabinh.vn'),
+    ('curl http://quan.hoabinh.vn --user username:password', 'http -a username:password quan.hoabinh.vn'),
+    (
+        "curl --header 'Content-Type: application/json' --header 'Host: quan.hoabinh.vn' http://103.92.28.225",
+        'http -j 103.92.28.225 Host:quan.hoabinh.vn',
+    ),
+    ('curl --request DELETE http://quan.hoabinh.vn/users/1', 'http DELETE quan.hoabinh.vn/users/1'),
+    (
+        "curl -X POST http://quan.hoabinh.vn -d 'username=yourusername&password=yourpassword'",
+        'http -f quan.hoabinh.vn username=yourusername password=yourpassword',
+    ),
+    (
+        'curl -X POST http://quan.hoabinh.vn/api/users --user admin:xxx -d name=meow',
+        'http -fa admin:xxx quan.hoabinh.vn/api/users name=meow',
+    ),
+    (
+        'curl -sL "https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x2EE0EA64E40A89B84B2DF73499E82A75642AC823"',
+        'http -F https://keyserver.ubuntu.com/pks/lookup op==get search==0x2EE0EA64E40A89B84B2DF73499E82A75642AC823',
+    ),
+    (
+        'curl -u "$USER:$PASS" "https://analysiscenter.veracode.com/api/5.0/uploadlargefile.do?'
+        'app_id=$APP_ID&filename=file.bca" --cacert ~/Desktop/cert.pem',
+        "http -a '$USER:$PASS' --verify ~/Desktop/cert.pem "
+        "https://analysiscenter.veracode.com/api/5.0/uploadlargefile.do app_id=='$APP_ID' filename==file.bca",
+    ),
+    (
+        'curl --data-binary "@build/veracode.bca" -H "Content-Type: binary/octet-stream" '
+        'https://analysiscenter.veracode.com/api/5.0/uploadlargefile.do',
+        'http https://analysiscenter.veracode.com/api/5.0/uploadlargefile.do '
+        'Content-Type:binary/octet-stream @build/veracode.bca',
+    ),
+    ('curl -F file=@~/path/image.png http://quan.hoabinh.vn', "http -f quan.hoabinh.vn file@'~/path/image.png'"),
+)
+
+
+@pytest.mark.parametrize('curl, expected', test_data)
+def test_converting(curl: str, expected: str) -> None:
+    httpie = curl_to_httpie(curl).httpie
+    assert httpie == expected
+
+
+def test_json_form() -> None:
+    curl = (
+        """curl -XPUT elastic.dev/movies/_doc/1 -d '{"director": "Burton, Tim", """
+        """ "year": 1996, "title": "Mars Attacks!"}' -H 'Content-Type: application/json'"""
+    )
+    output = curl_to_httpie(curl).httpie
+    assert output == (
+        """http PUT elastic.dev/movies/_doc/1 director='Burton, Tim' """
+        """year:=1996 title='Mars Attacks!'"""
+    )
+
+
+def test_json_value_not_primitive() -> None:
+    curl = (
+        """curl -XPUT elastic.dev/movies/_doc/1 -d '{"genre": ["Comedy", "Sci-Fi"],"""
+        """ "actor": ["Jack Nicholson","Pierce Brosnan","Sarah Jessica Parker"]}' """
+        """-H 'Content-Type: application/json'"""
+    )
+    output = curl_to_httpie(curl).httpie
+    debug(output)
+    assert output == (
+        """http PUT elastic.dev/movies/_doc/1 genre:='["Comedy","Sci-Fi"]' """
+        """actor:='["Jack Nicholson","Pierce Brosnan","Sarah Jessica Parker"]'"""
+    )
+
+
+def test_curl_postman_generated() -> None:
+    curl = (
+        """curl --location --request POST 'http://stupid.site/sync-info' \\"""
+        """--header 'Content-Type: application/json' \\"""
+        "--data-raw '{"
+        '    "userId": "4-abc-xyz",'
+        '    "planAmount": 50000,'
+        '    "isPromotion": false,'
+        '    "createdAt": "2019-12-13 10:00:00"'
+        "}'"
+    )
+    httpie = curl_to_httpie(curl).httpie
+    assert httpie == (
+        """http -F stupid.site/sync-info userId=4-abc-xyz planAmount:=50000 """
+        """isPromotion:=false createdAt='2019-12-13 10:00:00'"""
+    )
+
+
+def test_multi_line() -> None:
+    curl = (
+        """curl -X POST \\\nhttp://172.16.0.19/api/access-cards/2392919198/call-elevator \\\n-H 'Accept: */*' """
+        """\\\n-H 'Accept-Encoding: gzip, deflate' \\\n-H 'Authorization: """
+        """Basic dXNlcjp4eHg=' \\\n-H 'Cache-Control: no-cache' """
+        """\\\n-H 'Connection: keep-alive' \\\n-H 'Content-Length: 407' \\\n"""
+        """-H 'Content-Type: multipart/form-data; boundary=--------------------------539724411903816199149731' """
+        """\\\n-H 'Host: 172.16.0.19' \\\n-H 'Postman-Token: 24e4f6f7' \\\n"""
+        """-H 'User-Agent: PostmanRuntime/7.19.0' """
+        """\\\n-H 'cache-control: no-cache' \\\n-H 'content-type: multipart/form-data; """
+        """boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW' \\\n"""
+        """-F boarding_floor=1 \\\n-F destination_floor=9 \\\n-F elevator_bank_number=3"""
+    )
+    httpie = curl_to_httpie(curl).httpie
+    debug(httpie)
+    assert httpie == (
+        """http -fa user:xxx 172.16.0.19/api/access-cards/2392919198/call-elevator """
+        """Accept:'*/*' Accept-Encoding:'gzip, deflate' """
+        """Connection:keep-alive Content-Length:407 """
+        """Host:172.16.0.19 Postman-Token:24e4f6f7 User-Agent:PostmanRuntime/7.19.0 """
+        """Cache-Control:no-cache Content-Type:'multipart/form-data; """
+        """boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW' """
+        """boarding_floor=1 destination_floor=9 elevator_bank_number=3"""
+    )
+
+
+def test_escaped_linebreak() -> None:
+    curl = r"""curl -H 'Content-Type: application/json' \
+            -X POST http://127.0.0.1:5984/demo \
+            -d '{"company": "Example, Inc."}'"""
+    httpie = curl_to_httpie(curl).httpie
+    assert httpie == "http 127.0.0.1:5984/demo company='Example, Inc.'"
+
+
+def test_json_with_quote_escape() -> None:
+    curl = (
+        'curl --url http://localhost:3000/posts -H "Content-Type: application/json;charset=UTF-8" '
+        r'-d "{\"title\":\"murat\",\"author\":\"öner\"}"'
+    )
+    httpie = curl_to_httpie(curl).httpie
+    debug(httpie)
+    assert httpie == "http localhost:3000/posts title=murat author='öner'"
+
+
+def test_user_query_json_accept_and_content_type() -> None:
+    curl = (
+        "curl -X 'POST' \\\n"
+        "  'https://orch.foobar.com/rest/environments/4/deprecate' \\\n"
+        "  -H 'accept: application/json' \\\n"
+        "  -H 'Content-Type: application/json' \\\n"
+        "  -d '{\n"
+        '  "replacementEnvironmentId": "1493"\n'
+        "}'"
+    )
+    httpie = curl_to_httpie(curl).httpie
+    assert httpie == 'http https://orch.foobar.com/rest/environments/4/deprecate replacementEnvironmentId=1493'
+
+
+def test_accept_json_without_data() -> None:
+    curl = "curl -H 'Accept: application/json' https://api.example.com/items"
+    httpie = curl_to_httpie(curl).httpie
+    assert httpie == 'http -j https://api.example.com/items'
+    httpie_long = curl_to_httpie(curl, long_option=True).httpie
+    assert httpie_long == 'http --json https://api.example.com/items'
+
+
+def test_accept_json_with_flags_compound() -> None:
+    curl = "curl -L -u user:pass -H 'Accept: application/json' https://api.example.com/items"
+    httpie = curl_to_httpie(curl).httpie
+    assert httpie == 'http -Fja user:pass https://api.example.com/items'

curlipie-0.0.0/tests/test_parse_curl.py

@@ -0,0 +1,103 @@
+import shlex
+
+from devtools import debug
+from kiss_headers import Headers, Header
+from curlipie.curly import CURLArgumentParser
+
+
+def parsed_args(cmd_args_string: str) -> CURLArgumentParser:
+    return CURLArgumentParser().parse_args(shlex.split(cmd_args_string))
+
+
+def test_curl_form_data_single_urlencoded() -> None:
+    cmline = "-d 'name=admin&shoesize=12' http://quan.hoabinh.vn"
+    args = parsed_args(cmline)
+    assert args.data == ['name=admin&shoesize=12']
+    assert args.url == 'http://quan.hoabinh.vn'
+
+
+def test_curl_form_data_multi() -> None:
+    cmline = '-d name=admin -d shoesize=12 http://quan.hoabinh.vn'
+    args = parsed_args(cmline)
+    assert args.data == ['name=admin', 'shoesize=12']
+
+
+def test_curl_form_data_multi_mixed() -> None:
+    cmline = '-d name=admin -d shoesize=12 -d color=green&food=wet http://quan.hoabinh.vn'
+    args = parsed_args(cmline)
+    assert args.data == ['name=admin', 'shoesize=12', 'color=green&food=wet']
+    debug(args._data)
+    assert tuple(args._data) == (('name', 'admin'), ('shoesize', '12'), ('color', 'green'), ('food', 'wet'))
+
+
+def test_head() -> None:
+    cmline = '-I http://quan.hoabinh.vn'
+    args = parsed_args(cmline)
+    assert args.head
+
+
+def test_basic_auth() -> None:
+    cmline = 'http://quan.hoabinh.vn --user username:password'
+    args = parsed_args(cmline)
+    assert args.user == 'username:password'
+
+
+def test_headers() -> None:
+    cmline = "--header 'Content-Type: application/json' --header 'Host: quan.hoabinh.vn' http://103.92.28.225"
+    args = parsed_args(cmline)
+    debug(args.header)
+    assert args.header == ['Content-Type: application/json', 'Host: quan.hoabinh.vn']
+    debug(args._headers)
+    assert args._headers == Headers(Header('Host', 'quan.hoabinh.vn'))
+    assert args._request_json
+
+
+def test_accept_json_header() -> None:
+    cmline = "--header 'Accept: application/json' --header 'Host: quan.hoabinh.vn' http://103.92.28.225"
+    args = parsed_args(cmline)
+    assert args.header == ['Accept: application/json', 'Host: quan.hoabinh.vn']
+    assert args._headers == Headers(Header('Host', 'quan.hoabinh.vn'))
+    assert args._accept_json
+
+
+def test_method() -> None:
+    cmline = '--request DELETE http://quan.hoabinh.vn'
+    args = parsed_args(cmline)
+    assert args.request == 'DELETE'
+
+
+def test_post_data() -> None:
+    cmline = "-X POST http://quan.hoabinh.vn -d 'username=yourusername&password=yourpassword'"
+    args = parsed_args(cmline)
+    assert args.request == 'POST'
+    assert args.data == ['username=yourusername&password=yourpassword']
+
+
+def test_query_params() -> None:
+    cmline = '-sL "https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x2EE0EA64E40A89B84B2DF73499E82A75642AC823"'
+    args = parsed_args(cmline)
+    assert tuple(args._params) == (('op', 'get'), ('search', '0x2EE0EA64E40A89B84B2DF73499E82A75642AC823'))
+
+
+def test_upload() -> None:
+    cmline = 'curl -F file=@~/path/image.png http://quan.hoabinh.vn'
+    args = parsed_args(cmline)
+    assert tuple(args._data) == (('file', '@~/path/image.png'),)
+
+
+def test_data_raw() -> None:
+    cmline = """
+    --location --request POST 'https://quan.hoabinh.vn/searching?apikey=xxx'
+--header 'Content-Type: application/json'
+--data-raw '{
+    "title": "yyy",
+    "categories": [
+        "zzz"
+    ],
+    "domain": "quan.hoabinh.vn"
+}'
+    """
+    args = parsed_args(cmline)
+    assert args.header == ['Content-Type: application/json']
+    debug(args._data)
+    assert tuple(args._data) == (('title', 'yyy'), ('categories', ['zzz']), ('domain', 'quan.hoabinh.vn'))