mirror of
https://github.com/Significant-Gravitas/AutoGPT.git
synced 2026-02-11 23:35:25 -05:00
3ca2387631
## Summary
Implements a `TextEncoderBlock` that encodes plain text into escape
sequences (the reverse of `TextDecoderBlock`).
## Changes
### Block Implementation
- Added `encoder_block.py` with `TextEncoderBlock` in
`autogpt_platform/backend/backend/blocks/`
- Uses `codecs.encode(text, "unicode_escape").decode("utf-8")` for
encoding
- Mirrors the structure and patterns of the existing `TextDecoderBlock`
- Categorised as `BlockCategory.TEXT`
### Documentation
- Added Text Encoder section to
`docs/integrations/block-integrations/text.md` (the auto-generated docs
file for TEXT category blocks)
- Expanded "How it works" with technical details on the encoding method,
validation, and edge cases
- Added 3 structured use cases per docs guidelines: JSON payload
preparation, Config/ENV generation, Snapshot fixtures
- Added Text Encoder to the overview table in
`docs/integrations/README.md`
- Removed standalone `encoder_block.md` (TEXT category blocks belong in
`text.md` per `CATEGORY_FILE_MAP` in `generate_block_docs.py`)
### Documentation Formatting (CodeRabbit feedback)
- Added blank lines around markdown tables (MD058)
- Added `text` language tags to fenced code blocks (MD040)
- Restructured use case section with bold headings per coding guidelines
## How Docs Were Synced
The `check-docs-sync` CI job runs `poetry run python
scripts/generate_block_docs.py --check` which expects blocks to be
documented in category-grouped files. Since `TextEncoderBlock` uses
`BlockCategory.TEXT`, the `CATEGORY_FILE_MAP` maps it to `text.md` — not
a standalone file. The block entry was added to `text.md` following the
exact format used by the generator (with `<!-- MANUAL -->` markers for
hand-written sections).
## Related Issue
Fixes #11111
---------
Co-authored-by: Otto <otto@agpt.co>
Co-authored-by: lif <19658300+majiayu000@users.noreply.github.com>
Co-authored-by: Aryan Kaul <134673289+aryancodes1@users.noreply.github.com>
Co-authored-by: Nicholas Tindle <nicholas.tindle@agpt.co>
Co-authored-by: Nick Tindle <nick@ntindle.com>
78 lines
2.5 KiB
Python
78 lines
2.5 KiB
Python
"""Text encoding block for converting special characters to escape sequences."""
|
|
|
|
import codecs
|
|
|
|
from backend.data.block import (
|
|
Block,
|
|
BlockCategory,
|
|
BlockOutput,
|
|
BlockSchemaInput,
|
|
BlockSchemaOutput,
|
|
)
|
|
from backend.data.model import SchemaField
|
|
|
|
|
|
class TextEncoderBlock(Block):
|
|
"""
|
|
Encodes a string by converting special characters into escape sequences.
|
|
|
|
This block is the inverse of TextDecoderBlock. It takes text containing
|
|
special characters (like newlines, tabs, etc.) and converts them into
|
|
their escape sequence representations (e.g., newline becomes \\n).
|
|
"""
|
|
|
|
class Input(BlockSchemaInput):
|
|
"""Input schema for TextEncoderBlock."""
|
|
|
|
text: str = SchemaField(
|
|
description="A string containing special characters to be encoded",
|
|
placeholder="Your text with newlines and quotes to encode",
|
|
)
|
|
|
|
class Output(BlockSchemaOutput):
|
|
"""Output schema for TextEncoderBlock."""
|
|
|
|
encoded_text: str = SchemaField(
|
|
description="The encoded text with special characters converted to escape sequences"
|
|
)
|
|
error: str = SchemaField(description="Error message if encoding fails")
|
|
|
|
def __init__(self):
|
|
super().__init__(
|
|
id="5185f32e-4b65-4ecf-8fbb-873f003f09d6",
|
|
description="Encodes a string by converting special characters into escape sequences",
|
|
categories={BlockCategory.TEXT},
|
|
input_schema=TextEncoderBlock.Input,
|
|
output_schema=TextEncoderBlock.Output,
|
|
test_input={
|
|
"text": """Hello
|
|
World!
|
|
This is a "quoted" string."""
|
|
},
|
|
test_output=[
|
|
(
|
|
"encoded_text",
|
|
"""Hello\\nWorld!\\nThis is a "quoted" string.""",
|
|
)
|
|
],
|
|
)
|
|
|
|
async def run(self, input_data: Input, **kwargs) -> BlockOutput:
|
|
"""
|
|
Encode the input text by converting special characters to escape sequences.
|
|
|
|
Args:
|
|
input_data: The input containing the text to encode.
|
|
**kwargs: Additional keyword arguments (unused).
|
|
|
|
Yields:
|
|
The encoded text with escape sequences, or an error message if encoding fails.
|
|
"""
|
|
try:
|
|
encoded_text = codecs.encode(input_data.text, "unicode_escape").decode(
|
|
"utf-8"
|
|
)
|
|
yield "encoded_text", encoded_text
|
|
except Exception as e:
|
|
yield "error", f"Encoding error: {str(e)}"
|