restiny 0.2.0__tar.gz → 0.2.1__tar.gz

{restiny-0.2.0 → restiny-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: restiny
-Version: 0.2.0
+Version: 0.2.1
 Summary: A minimalist HTTP client, no bullshit
 Author-email: Kalebe Chimanski de Almeida <kalebe.chi.almeida@gmail.com>
 License:                                  Apache License

restiny-0.2.1/restiny/__about__.py

@@ -0,0 +1 @@
+__version__ = '0.2.1'

restiny-0.2.1/restiny/core/app.py

@@ -0,0 +1,348 @@
+import asyncio
+import json
+import mimetypes
+from http import HTTPStatus
+from pathlib import Path
+
+import httpx
+import pyperclip
+from textual import on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.events import DescendantFocus
+from textual.widget import Widget
+from textual.widgets import Footer, Header
+
+from restiny.__about__ import __version__
+from restiny.assets import STYLE_TCSS
+from restiny.core import (
+    RequestArea,
+    RequestAreaData,
+    ResponseArea,
+    URLArea,
+    URLAreaData,
+)
+from restiny.core.response_area import ResponseAreaData
+from restiny.enums import BodyMode, BodyRawLanguage, ContentType
+from restiny.utils import build_curl_cmd
+
+
+class RESTinyApp(App, inherit_bindings=False):
+    TITLE = f'RESTiny v{__version__}'
+    SUB_TITLE = 'Minimal HTTP client, no bullshit'
+    ENABLE_COMMAND_PALETTE = False
+    CSS_PATH = STYLE_TCSS
+    BINDINGS = [
+        Binding(
+            key='escape', action='quit', description='Quit the app', show=True
+        ),
+        Binding(
+            key='f10',
+            action='maximize_or_minimize_area',
+            description='Maximize/Minimize area',
+            show=True,
+        ),
+        Binding(
+            key='f9',
+            action='copy_as_curl',
+            description='Copy as curl',
+            show=True,
+        ),
+    ]
+    theme = 'textual-dark'
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.current_request: asyncio.Task | None = None
+        self.last_focused_widget: Widget | None = None
+        self.last_focused_maximizable_area: Widget | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        with Vertical(id='main-content'):
+            with Horizontal(classes='h-auto'):
+                yield URLArea()
+            with Horizontal(classes='h-1fr'):
+                with Vertical():
+                    yield RequestArea()
+                with Vertical():
+                    yield ResponseArea()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.url_area = self.query_one(URLArea)
+        self.request_area = self.query_one(RequestArea)
+        self.response_area = self.query_one(ResponseArea)
+
+    def action_maximize_or_minimize_area(self) -> None:
+        if self.screen.maximized:
+            self.screen.minimize()
+        else:
+            self.screen.maximize(self.last_focused_maximizable_area)
+
+    def action_copy_as_curl(self) -> None:
+        url_area_data = self.url_area.get_data()
+        request_area_data = self.request_area.get_data()
+
+        method = url_area_data.method
+        url = url_area_data.url
+
+        headers = {}
+        for header in request_area_data.headers:
+            if not header.enabled:
+                continue
+
+            headers[header.key] = header.value
+
+        params = {}
+        for param in request_area_data.query_params:
+            if not param.enabled:
+                continue
+
+            params[param.key] = param.value
+
+        raw_body = None
+        form_urlencoded = {}
+        form_multipart = {}
+        files = None
+        if request_area_data.body.type == BodyMode.RAW:
+            raw_body = request_area_data.body.payload
+        elif request_area_data.body.type == BodyMode.FORM_URLENCODED:
+            form_urlencoded = {
+                form_field.key: form_field.value
+                for form_field in request_area_data.body.payload
+                if form_field.enabled
+            }
+        elif request_area_data.body.type == BodyMode.FORM_MULTIPART:
+            form_multipart = {
+                form_field.key: form_field.value
+                for form_field in request_area_data.body.payload
+                if form_field.enabled
+            }
+        elif request_area_data.body.type == BodyMode.FILE:
+            files = [request_area_data.body.payload]
+
+        curl_cmd = build_curl_cmd(
+            method=method,
+            url=url,
+            headers=headers,
+            params=params,
+            raw_body=raw_body,
+            form_urlencoded=form_urlencoded,
+            form_multipart=form_multipart,
+            files=files,
+        )
+        self.copy_to_clipboard(curl_cmd)
+        self.notify(
+            'Command CURL copied to clipboard',
+            severity='information',
+        )
+
+    def copy_to_clipboard(self, text: str) -> None:
+        super().copy_to_clipboard(text)
+        try:
+            # Also copy to the system clipboard (outside of the app)
+            pyperclip.copy(text)
+        except Exception:
+            pass
+
+    @on(DescendantFocus)
+    def _on_focus(self, event: DescendantFocus) -> None:
+        self.last_focused_widget = event.widget
+        last_focused_maximizable_area = self._find_maximizable_area_by_widget(
+            widget=event.widget
+        )
+        if last_focused_maximizable_area:
+            self.last_focused_maximizable_area = last_focused_maximizable_area
+
+    @on(URLArea.SendRequest)
+    def _on_send_request(self, message: URLArea.SendRequest) -> None:
+        self.current_request = asyncio.create_task(self._send_request())
+
+    @on(URLArea.CancelRequest)
+    def _on_cancel_request(self, message: URLArea.CancelRequest) -> None:
+        if self.current_request and not self.current_request.done():
+            self.current_request.cancel()
+
+    def _find_maximizable_area_by_widget(
+        self, widget: Widget
+    ) -> Widget | None:
+        while widget is not None:
+            if (
+                isinstance(widget, URLArea)
+                or isinstance(widget, RequestArea)
+                or isinstance(widget, ResponseArea)
+            ):
+                return widget
+            widget = widget.parent
+
+    async def _send_request(self) -> None:
+        url_area_data = self.url_area.get_data()
+        request_area_data = self.request_area.get_data()
+
+        self.response_area.set_data(data=None)
+        self.response_area.loading = True
+        self.url_area.request_pending = True
+        try:
+            async with httpx.AsyncClient(
+                timeout=request_area_data.options.timeout,
+                follow_redirects=request_area_data.options.follow_redirects,
+                verify=request_area_data.options.verify_ssl,
+            ) as http_client:
+                request = self._build_request(
+                    http_client=http_client,
+                    url_area_data=url_area_data,
+                    request_area_data=request_area_data,
+                )
+                response = await http_client.send(request=request)
+                self._display_response(response=response)
+                self.response_area.is_showing_response = True
+        except httpx.RequestError as error:
+            error_name = type(error).__name__
+            error_message = str(error)
+            if error_message:
+                self.notify(f'{error_name}: {error_message}', severity='error')
+            else:
+                self.notify(f'{error_name}', severity='error')
+            self.response_area.set_data(data=None)
+            self.response_area.is_showing_response = False
+        except asyncio.CancelledError:
+            self.response_area.set_data(data=None)
+            self.response_area.is_showing_response = False
+        finally:
+            self.response_area.loading = False
+            self.url_area.request_pending = False
+
+    def _build_request(
+        self,
+        http_client: httpx.Client,
+        url_area_data: URLAreaData,
+        request_area_data: RequestAreaData,
+    ) -> httpx.Request:
+        headers: dict[str, str] = {
+            header.key: header.value
+            for header in request_area_data.headers
+            if header.enabled
+        }
+        query_params: dict[str, str] = {
+            param.key: param.value
+            for param in request_area_data.query_params
+            if param.enabled
+        }
+
+        if not request_area_data.body.enabled:
+            return http_client.build_request(
+                method=url_area_data.method,
+                url=url_area_data.url,
+                headers=headers,
+                params=query_params,
+            )
+
+        if request_area_data.body.type == BodyMode.RAW:
+            raw_language_to_content_type = {
+                BodyRawLanguage.JSON: ContentType.JSON,
+                BodyRawLanguage.YAML: ContentType.YAML,
+                BodyRawLanguage.HTML: ContentType.HTML,
+                BodyRawLanguage.XML: ContentType.XML,
+                BodyRawLanguage.PLAIN: ContentType.TEXT,
+            }
+            headers['content-type'] = raw_language_to_content_type.get(
+                request_area_data.body.raw_language, ContentType.TEXT
+            )
+
+            raw = request_area_data.body.payload
+            if headers['content-type'] == ContentType.JSON:
+                try:
+                    raw = json.dumps(raw)
+                except Exception:
+                    pass
+
+            return http_client.build_request(
+                method=url_area_data.method,
+                url=url_area_data.url,
+                headers=headers,
+                params=query_params,
+                content=raw,
+            )
+        elif request_area_data.body.type == BodyMode.FILE:
+            file = request_area_data.body.payload
+            if 'content-type' not in headers:
+                headers['content-type'] = (
+                    mimetypes.guess_type(file.name)[0]
+                    or 'application/octet-stream'
+                )
+            return http_client.build_request(
+                method=url_area_data.method,
+                url=url_area_data.url,
+                headers=headers,
+                params=query_params,
+                content=file.read_bytes(),
+            )
+        elif request_area_data.body.type == BodyMode.FORM_URLENCODED:
+            form_urlencoded = {
+                form_item.key: form_item.value
+                for form_item in request_area_data.body.payload
+                if form_item.enabled
+            }
+            return http_client.build_request(
+                method=url_area_data.method,
+                url=url_area_data.url,
+                headers=headers,
+                params=query_params,
+                data=form_urlencoded,
+            )
+        elif request_area_data.body.type == BodyMode.FORM_MULTIPART:
+            form_multipart_str = {
+                form_item.key: form_item.value
+                for form_item in request_area_data.body.payload
+                if form_item.enabled and isinstance(form_item.value, str)
+            }
+            form_multipart_files = {
+                form_item.key: (
+                    form_item.value.name,
+                    form_item.value.read_bytes(),
+                    mimetypes.guess_type(form_item.value.name)[0]
+                    or 'application/octet-stream',
+                )
+                for form_item in request_area_data.body.payload
+                if form_item.enabled and isinstance(form_item.value, Path)
+            }
+            return http_client.build_request(
+                method=url_area_data.method,
+                url=url_area_data.url,
+                headers=headers,
+                params=query_params,
+                data=form_multipart_str,
+                files=form_multipart_files,
+            )
+
+    def _display_response(self, response: httpx.Response) -> None:
+        status = HTTPStatus(response.status_code)
+        size = response.num_bytes_downloaded
+        elapsed_time = round(response.elapsed.total_seconds(), 2)
+        headers = {
+            header_key: header_value
+            for header_key, header_value in response.headers.multi_items()
+        }
+        content_type_to_body_language = {
+            ContentType.TEXT: BodyRawLanguage.PLAIN,
+            ContentType.HTML: BodyRawLanguage.HTML,
+            ContentType.JSON: BodyRawLanguage.JSON,
+            ContentType.YAML: BodyRawLanguage.YAML,
+            ContentType.XML: BodyRawLanguage.XML,
+        }
+        body_raw_language = content_type_to_body_language.get(
+            response.headers.get('Content-Type'), BodyRawLanguage.PLAIN
+        )
+        body_raw = response.text
+        self.response_area.set_data(
+            data=ResponseAreaData(
+                status=status,
+                size=size,
+                elapsed_time=elapsed_time,
+                headers=headers,
+                body_raw_language=body_raw_language,
+                body_raw=body_raw,
+            )
+        )

{restiny-0.2.0 → restiny-0.2.1}/restiny/core/request_area.py

@@ -174,6 +174,7 @@ class RequestArea(Static):
                     yield Input(
                         '5.5',
                         placeholder='5.5',
+                        select_on_focus=False,
                         id='options-timeout',
                         classes='w-1fr',
                     )
@@ -214,8 +215,16 @@ class RequestArea(Static):
             '#options-verify-ssl', Switch
         )
 
+    def get_data(self) -> RequestAreaData:
+        return RequestAreaData(
+            headers=self._get_headers(),
+            query_params=self._get_query_params(),
+            body=self._get_body(),
+            options=self._get_options(),
+        )
+
     @on(Select.Changed, '#body-mode')
-    def on_change_body_type(self, message: Select.Changed) -> None:
+    def _on_change_body_type(self, message: Select.Changed) -> None:
         if message.value == BodyMode.FILE:
             self.body_mode_switcher.current = 'body-mode-file'
         elif message.value == BodyMode.RAW:
@@ -226,27 +235,27 @@ class RequestArea(Static):
             self.body_mode_switcher.current = 'body-mode-form-multipart'
 
     @on(Select.Changed, '#body-raw-language')
-    def on_change_body_text_language(self, message: Select.Changed) -> None:
+    def _on_change_body_raw_language(self, message: Select.Changed) -> None:
         self.body_raw_editor.language = message.value
 
     @on(DynamicFields.FieldFilled, '#body-form-urlencoded')
-    def on_form_filled(self, message: DynamicFields.FieldFilled) -> None:
+    def _on_form_filled(self, message: DynamicFields.FieldFilled) -> None:
         self.body_enabled_switch.value = True
 
     @on(DynamicFields.FieldEmpty, '#body-form-urlencoded')
-    def on_form_empty(self, message: DynamicFields.FieldEmpty) -> None:
+    def _on_form_empty(self, message: DynamicFields.FieldEmpty) -> None:
         if not message.control.filled_fields:
             self.body_enabled_switch.value = False
 
     @on(CustomTextArea.Changed, '#body-raw')
-    def on_change_body_text(self, message: CustomTextArea.Changed) -> None:
+    def _on_change_body_raw(self, message: CustomTextArea.Changed) -> None:
         if self.body_raw_editor.text == '':
             self.body_enabled_switch.value = False
         else:
             self.body_enabled_switch.value = True
 
     @on(Input.Changed, '#options-timeout')
-    def on_change_timeout(self, message: Input.Changed) -> None:
+    def _on_change_timeout(self, message: Input.Changed) -> None:
         new_value = message.value
 
         if new_value == '':
@@ -259,80 +268,70 @@ class RequestArea(Static):
                 self.options_timeout_input.value[:-1]
             )
 
-    def get_data(self) -> RequestAreaData:
-        def get_headers() -> list[HeaderField]:
-            return [
-                HeaderField(
-                    enabled=header_field['enabled'],
-                    key=header_field['key'],
-                    value=header_field['value'],
-                )
-                for header_field in self.header_fields.values
-            ]
-
-        def get_query_params() -> list[QueryParamField]:
-            return [
-                QueryParamField(
-                    enabled=query_param_field['enabled'],
-                    key=query_param_field['key'],
-                    value=query_param_field['value'],
-                )
-                for query_param_field in self.param_fields.values
-            ]
-
-        def get_body() -> RequestAreaData.Body:
-            body_send: bool = self.body_enabled_switch.value
-            body_type: str = BodyMode(self.body_mode_select.value)
-
-            payload = None
-            if body_type == BodyMode.RAW:
-                payload = self.body_raw_editor.text
-            elif body_type == BodyMode.FILE:
-                payload = self.body_file_path_chooser.path
-            elif body_type == BodyMode.FORM_URLENCODED:
-                payload = []
-                for form_item in self.body_form_urlencoded_fields.values:
-                    payload.append(
-                        FormUrlEncodedField(
-                            enabled=form_item['enabled'],
-                            key=form_item['key'],
-                            value=form_item['value'],
-                        )
+    def _get_headers(self) -> list[HeaderField]:
+        return [
+            HeaderField(
+                enabled=header_field['enabled'],
+                key=header_field['key'],
+                value=header_field['value'],
+            )
+            for header_field in self.header_fields.values
+        ]
+
+    def _get_query_params(self) -> list[QueryParamField]:
+        return [
+            QueryParamField(
+                enabled=query_param_field['enabled'],
+                key=query_param_field['key'],
+                value=query_param_field['value'],
+            )
+            for query_param_field in self.param_fields.values
+        ]
+
+    def _get_body(self) -> RequestAreaData.Body:
+        body_send: bool = self.body_enabled_switch.value
+        body_type: str = BodyMode(self.body_mode_select.value)
+
+        payload = None
+        if body_type == BodyMode.RAW:
+            payload = self.body_raw_editor.text
+        elif body_type == BodyMode.FILE:
+            payload = self.body_file_path_chooser.path
+        elif body_type == BodyMode.FORM_URLENCODED:
+            payload = []
+            for form_item in self.body_form_urlencoded_fields.values:
+                payload.append(
+                    FormUrlEncodedField(
+                        enabled=form_item['enabled'],
+                        key=form_item['key'],
+                        value=form_item['value'],
                     )
-            elif body_type == BodyMode.FORM_MULTIPART:
-                payload = []
-                for form_item in self.body_form_multipart_fields.values:
-                    payload.append(
-                        FormMultipartField(
-                            enabled=form_item['enabled'],
-                            key=form_item['key'],
-                            value=form_item['value'],
-                        )
+                )
+        elif body_type == BodyMode.FORM_MULTIPART:
+            payload = []
+            for form_item in self.body_form_multipart_fields.values:
+                payload.append(
+                    FormMultipartField(
+                        enabled=form_item['enabled'],
+                        key=form_item['key'],
+                        value=form_item['value'],
                     )
+                )
 
-            return RequestAreaData.Body(
-                enabled=body_send,
-                raw_language=BodyRawLanguage(
-                    self.body_raw_language_select.value
-                ),
-                type=body_type,
-                payload=payload,
-            )
-
-        def get_options() -> RequestAreaData.Options:
-            timeout = None
-            if self.options_timeout_input.value:
-                timeout = float(self.options_timeout_input.value)
+        return RequestAreaData.Body(
+            enabled=body_send,
+            raw_language=BodyRawLanguage(self.body_raw_language_select.value),
+            type=body_type,
+            payload=payload,
+        )
 
-            return RequestAreaData.Options(
-                timeout=timeout,
-                follow_redirects=self.options_follow_redirects_switch.value,
-                verify_ssl=self.options_verify_ssl_switch.value,
-            )
+    def _get_options(self) -> RequestAreaData.Options:
+        timeout = None
+        if self.options_timeout_input.value:
+            timeout = float(self.options_timeout_input.value)
 
-        return RequestAreaData(
-            headers=get_headers(),
-            query_params=get_query_params(),
-            body=get_body(),
-            options=get_options(),
+        return RequestAreaData.Options(
+            timeout=timeout,
+            follow_redirects=self.options_follow_redirects_switch.value,
+            verify_ssl=self.options_verify_ssl_switch.value,
         )

{restiny-0.2.0 → restiny-0.2.1}/restiny/core/response_area.py

@@ -1,6 +1,9 @@
+from dataclasses import dataclass
+from http import HTTPStatus
+
 from textual import on
 from textual.app import ComposeResult
-from textual.reactive import Reactive
+from textual.containers import VerticalScroll
 from textual.widgets import (
     ContentSwitcher,
     DataTable,
@@ -15,6 +18,16 @@ from restiny.enums import BodyRawLanguage
 from restiny.widgets import CustomTextArea
 
 
+@dataclass
+class ResponseAreaData:
+    status: HTTPStatus
+    size: int
+    elapsed_time: float | int
+    headers: dict
+    body_raw_language: BodyRawLanguage
+    body_raw: str
+
+
 # TODO: Implement 'Trace' tab pane
 class ResponseArea(Static):
     ALLOW_MAXIMIZE = True
@@ -38,8 +51,6 @@ class ResponseArea(Static):
 
     """
 
-    has_response: bool = Reactive(False, layout=True, init=True)
-
     def compose(self) -> ComposeResult:
         with ContentSwitcher(id='response-switcher', initial='no-content'):
             yield Label(
@@ -49,7 +60,8 @@ class ResponseArea(Static):
 
             with TabbedContent(id='content'):
                 with TabPane('Headers'):
-                    yield DataTable(show_cursor=False, id='headers')
+                    with VerticalScroll():
+                        yield DataTable(show_cursor=False, id='headers')
                 with TabPane('Body'):
                     yield Select(
                         (
@@ -60,11 +72,11 @@ class ResponseArea(Static):
                             ('XML', BodyRawLanguage.XML),
                         ),
                         allow_blank=False,
-                        tooltip='Body type',
-                        id='body-type',
+                        tooltip='Syntax highlighting for the response body',
+                        id='body-raw-language',
                     )
                     yield CustomTextArea.code_editor(
-                        id='body', read_only=True, classes='mt-1'
+                        id='body-raw', read_only=True, classes='mt-1'
                     )
 
     def on_mount(self) -> None:
@@ -73,25 +85,46 @@ class ResponseArea(Static):
         )
 
         self.headers_data_table = self.query_one('#headers', DataTable)
-        self.body_type_select = self.query_one('#body-type', Select)
-        self.body_text_area = self.query_one('#body', CustomTextArea)
+        self.body_raw_language_select = self.query_one(
+            '#body-raw-language', Select
+        )
+        self.body_raw_editor = self.query_one('#body-raw', CustomTextArea)
 
         self.headers_data_table.add_columns('Key', 'Value')
 
-    @on(Select.Changed, '#body-type')
-    def on_body_type_changed(self, message: Select.Changed) -> None:
-        self.body_text_area.language = self.body_type_select.value
+    def set_data(self, data: ResponseAreaData | None) -> None:
+        self.border_title = self.BORDER_TITLE
+        self.border_subtitle = ''
+        self.headers_data_table.clear()
+        self.body_raw_language_select.value = BodyRawLanguage.PLAIN
+        self.body_raw_editor.clear()
 
-    def watch_has_response(self, value: bool) -> None:
+        if data is None:
+            return
+
+        self.border_title = f'Response - {data.status} {data.status.phrase}'
+        self.border_subtitle = (
+            f'{data.size} bytes in {data.elapsed_time} seconds'
+        )
+        for header_key, header_value in data.headers.items():
+            self.headers_data_table.add_row(header_key, header_value)
+        self.body_raw_language_select.value = data.body_raw_language
+        self.body_raw_editor.text = data.body_raw
+
+    @property
+    def is_showing_response(self) -> bool:
+        if self._response_switcher.current == 'content':
+            return True
+        elif self._response_switcher.current == 'no-content':
+            return False
+
+    @is_showing_response.setter
+    def is_showing_response(self, value: bool) -> None:
         if value is True:
             self._response_switcher.current = 'content'
         elif value is False:
             self._response_switcher.current = 'no-content'
-            self.reset_response()
 
-    def reset_response(self) -> None:
-        self.border_title = self.BORDER_TITLE
-        self.border_subtitle = ''
-        self.headers_data_table.clear()
-        self.body_type_select.value = BodyRawLanguage.PLAIN
-        self.body_text_area.clear()
+    @on(Select.Changed, '#body-raw-language')
+    def _on_body_raw_language_changed(self, message: Select.Changed) -> None:
+        self.body_raw_editor.language = self.body_raw_language_select.value