restiny 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

restiny/core/request_area.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Literal
 
 from textual import on
 from textual.app import ComposeResult
@@ -15,10 +16,11 @@ from textual.widgets import (
     TabPane,
 )
 
-from restiny.enums import BodyMode, BodyRawLanguage
+from restiny.enums import AuthMode, BodyMode, BodyRawLanguage
 from restiny.widgets import (
     CustomTextArea,
     DynamicFields,
+    PasswordInput,
     PathChooser,
     TextDynamicField,
 )
@@ -33,7 +35,7 @@ class HeaderField:
 
 
 @dataclass
-class QueryParamField:
+class ParamField:
     enabled: bool
     key: str
     value: str
@@ -54,28 +56,64 @@ class FormMultipartField:
 
 
 @dataclass
-class RequestAreaData:
-    @dataclass
-    class Options:
-        timeout: int | float | None
-        follow_redirects: bool
-        verify_ssl: bool
-
-    @dataclass
-    class Body:
-        enabled: bool
-        raw_language: BodyRawLanguage | None
-        type: BodyMode
-        payload: (
-            str
-            | Path
-            | list[FormUrlEncodedField]
-            | list[FormMultipartField]
-            | None
-        )
+class BasicAuth:
+    username: str
+    password: str
+
+
+@dataclass
+class BearerAuth:
+    token: str
+
+
+@dataclass
+class APIKeyAuth:
+    key: str
+    value: str
+    where: Literal['header', 'param']
+
+
+@dataclass
+class DigestAuth:
+    username: str
+    password: str
+
+
+@dataclass
+class Options:
+    timeout: int | float | None
+    follow_redirects: bool
+    verify_ssl: bool
+
+
+@dataclass
+class Body:
+    enabled: bool
+    raw_language: BodyRawLanguage | None
+    mode: BodyMode
+    payload: (
+        str
+        | Path
+        | list[FormUrlEncodedField]
+        | list[FormMultipartField]
+        | None
+    )
+
+
+_AuthType = BasicAuth | BearerAuth | APIKeyAuth | DigestAuth
+
 
+@dataclass
+class Auth:
+    enabled: bool
+    value: _AuthType
+
+
+@dataclass
+class RequestAreaData:
     headers: list[HeaderField]
-    query_params: list[QueryParamField]
+    params: list[ParamField]
+    auth: Auth
     body: Body
     options: Options
 
@@ -101,11 +139,80 @@ class RequestArea(Static):
                     fields=[TextDynamicField(enabled=False, key='', value='')],
                     id='headers',
                 )
-            with TabPane('Query params'):
+            with TabPane('Params'):
                 yield DynamicFields(
                     fields=[TextDynamicField(enabled=False, key='', value='')],
                     id='params',
                 )
+            with TabPane('Auth'):
+                with Horizontal(classes='h-auto'):
+                    yield Switch(tooltip='Enabled', id='auth-enabled')
+                    yield Select(
+                        (
+                            ('Basic', AuthMode.BASIC),
+                            ('Bearer', AuthMode.BEARER),
+                            ('API Key', AuthMode.API_KEY),
+                            ('Digest', AuthMode.DIGEST),
+                        ),
+                        allow_blank=False,
+                        tooltip='Auth mode',
+                        id='auth-mode',
+                    )
+                with ContentSwitcher(
+                    initial='auth-basic', id='auth-mode-switcher'
+                ):
+                    with Horizontal(id='auth-basic', classes='mt-1'):
+                        yield Input(
+                            placeholder='Username',
+                            select_on_focus=False,
+                            classes='w-1fr',
+                            id='auth-basic-username',
+                        )
+                        yield PasswordInput(
+                            placeholder='Password',
+                            select_on_focus=False,
+                            classes='w-2fr',
+                            id='auth-basic-password',
+                        )
+                    with Horizontal(id='auth-bearer', classes='mt-1'):
+                        yield PasswordInput(
+                            placeholder='Token',
+                            select_on_focus=False,
+                            id='auth-bearer-token',
+                        )
+                    with Horizontal(id='auth-api-key', classes='mt-1'):
+                        yield Select(
+                            (('Header', 'header'), ('Param', 'param')),
+                            allow_blank=False,
+                            tooltip='Where',
+                            classes='w-1fr',
+                            id='auth-api-key-where',
+                        )
+                        yield Input(
+                            placeholder='Key',
+                            classes='w-2fr',
+                            id='auth-api-key-key',
+                        )
+                        yield PasswordInput(
+                            placeholder='Value',
+                            classes='w-3fr',
+                            id='auth-api-key-value',
+                        )
+
+                    with Horizontal(id='auth-digest', classes='mt-1'):
+                        yield Input(
+                            placeholder='Username',
+                            select_on_focus=False,
+                            classes='w-1fr',
+                            id='auth-digest-username',
+                        )
+                        yield PasswordInput(
+                            placeholder='Password',
+                            select_on_focus=False,
+                            classes='w-2fr',
+                            id='auth-digest-password',
+                        )
+
             with TabPane('Body'):
                 with Horizontal(classes='h-auto'):
                     yield Switch(id='body-enabled', tooltip='Send body?')
@@ -117,7 +224,7 @@ class RequestArea(Static):
                             ('Form (multipart)', BodyMode.FORM_MULTIPART),
                         ),
                         allow_blank=False,
-                        tooltip='Body type',
+                        tooltip='Body mode',
                         id='body-mode',
                     )
                 with ContentSwitcher(
@@ -174,8 +281,11 @@ class RequestArea(Static):
                     yield Input(
                         '5.5',
                         placeholder='5.5',
-                        id='options-timeout',
+                        select_on_focus=False,
+                        type='number',
+                        valid_empty=True,
                         classes='w-1fr',
+                        id='options-timeout',
                     )
                 with Horizontal(classes='mt-1 h-auto'):
                     yield Switch(id='options-follow-redirects')
@@ -189,6 +299,36 @@ class RequestArea(Static):
 
         self.param_fields = self.query_one('#params', DynamicFields)
 
+        self.auth_enabled_switch = self.query_one('#auth-enabled', Switch)
+        self.auth_mode_switcher = self.query_one(
+            '#auth-mode-switcher', ContentSwitcher
+        )
+        self.auth_mode_select = self.query_one('#auth-mode', Select)
+        self.auth_basic_username_input = self.query_one(
+            '#auth-basic-username', Input
+        )
+        self.auth_basic_password_input = self.query_one(
+            '#auth-basic-password', PasswordInput
+        )
+        self.auth_bearer_token_input = self.query_one(
+            '#auth-bearer-token', PasswordInput
+        )
+        self.auth_api_key_key_input = self.query_one(
+            '#auth-api-key-key', Input
+        )
+        self.auth_api_key_value_input = self.query_one(
+            '#auth-api-key-value', PasswordInput
+        )
+        self.auth_api_key_where_select = self.query_one(
+            '#auth-api-key-where', Select
+        )
+        self.auth_digest_username_input = self.query_one(
+            '#auth-digest-username', Input
+        )
+        self.auth_digest_password_input = self.query_one(
+            '#auth-digest-password', PasswordInput
+        )
+
         self.body_enabled_switch = self.query_one('#body-enabled', Switch)
         self.body_mode_select = self.query_one('#body-mode', Select)
         self.body_mode_switcher = self.query_one(
@@ -214,8 +354,28 @@ class RequestArea(Static):
             '#options-verify-ssl', Switch
         )
 
+    def get_data(self) -> RequestAreaData:
+        return RequestAreaData(
+            headers=self._get_headers(),
+            params=self._get_params(),
+            auth=self._get_auth(),
+            body=self._get_body(),
+            options=self._get_options(),
+        )
+
+    @on(Select.Changed, '#auth-mode')
+    def _on_change_auth_mode(self, message: Select.Changed) -> None:
+        if message.value == 'basic':
+            self.auth_mode_switcher.current = 'auth-basic'
+        elif message.value == 'bearer':
+            self.auth_mode_switcher.current = 'auth-bearer'
+        elif message.value == 'api_key':
+            self.auth_mode_switcher.current = 'auth-api-key'
+        elif message.value == 'digest':
+            self.auth_mode_switcher.current = 'auth-digest'
+
     @on(Select.Changed, '#body-mode')
-    def on_change_body_type(self, message: Select.Changed) -> None:
+    def _on_change_body_mode(self, message: Select.Changed) -> None:
         if message.value == BodyMode.FILE:
             self.body_mode_switcher.current = 'body-mode-file'
         elif message.value == BodyMode.RAW:
@@ -226,113 +386,122 @@ 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:
-        new_value = message.value
-
-        if new_value == '':
-            return
-
-        try:
-            float(new_value)
-        except Exception:
-            self.options_timeout_input.value = (
-                self.options_timeout_input.value[:-1]
+    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_params(self) -> list[ParamField]:
+        return [
+            ParamField(
+                enabled=param_field['enabled'],
+                key=param_field['key'],
+                value=param_field['value'],
+            )
+            for param_field in self.param_fields.values
+        ]
+
+    def _get_auth(self) -> _AuthType:
+        if self.auth_mode_select.value == AuthMode.BASIC:
+            return Auth(
+                enabled=self.auth_enabled_switch.value,
+                value=BasicAuth(
+                    username=self.auth_basic_username_input.value,
+                    password=self.auth_basic_password_input.value,
+                ),
+            )
+        elif self.auth_mode_select.value == AuthMode.BEARER:
+            return Auth(
+                enabled=self.auth_enabled_switch.value,
+                value=BearerAuth(token=self.auth_bearer_token_input.value),
+            )
+        elif self.auth_mode_select.value == AuthMode.API_KEY:
+            return Auth(
+                enabled=self.auth_enabled_switch.value,
+                value=APIKeyAuth(
+                    key=self.auth_api_key_key_input.value,
+                    value=self.auth_api_key_value_input.value,
+                    where=self.auth_api_key_where_select.value,
+                ),
+            )
+        elif self.auth_mode_select.value == AuthMode.DIGEST:
+            return Auth(
+                enabled=self.auth_enabled_switch.value,
+                value=DigestAuth(
+                    username=self.auth_digest_username_input.value,
+                    password=self.auth_digest_password_input.value,
+                ),
             )
 
-    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_body(self) -> Body:
+        body_send: bool = self.body_enabled_switch.value
+        body_mode: str = BodyMode(self.body_mode_select.value)
+
+        payload = None
+        if body_mode == BodyMode.RAW:
+            payload = self.body_raw_editor.text
+        elif body_mode == BodyMode.FILE:
+            payload = self.body_file_path_chooser.path
+        elif body_mode == 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_mode == 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,
-            )
+        return Body(
+            enabled=body_send,
+            raw_language=BodyRawLanguage(self.body_raw_language_select.value),
+            mode=body_mode,
+            payload=payload,
+        )
 
-        def get_options() -> RequestAreaData.Options:
+    def _get_options(self) -> Options:
+        try:
+            timeout = float(self.options_timeout_input.value)
+        except ValueError:
             timeout = None
-            if self.options_timeout_input.value:
-                timeout = float(self.options_timeout_input.value)
 
-            return RequestAreaData.Options(
-                timeout=timeout,
-                follow_redirects=self.options_follow_redirects_switch.value,
-                verify_ssl=self.options_verify_ssl_switch.value,
-            )
-
-        return RequestAreaData(
-            headers=get_headers(),
-            query_params=get_query_params(),
-            body=get_body(),
-            options=get_options(),
+        return Options(
+            timeout=timeout,
+            follow_redirects=self.options_follow_redirects_switch.value,
+            verify_ssl=self.options_verify_ssl_switch.value,
         )

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