steboxing 1.0.0__tar.gz

steboxing-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stefano Mazzuka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

steboxing-1.0.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: steboxing
+Version: 1.0.0
+Summary: Put your text in a stylish box.
+Author: Cangreho
+License: MIT
+Project-URL: Homepage, https://github.com/StefanoMazzuka/steboxing
+Project-URL: Repository, https://github.com/StefanoMazzuka/steboxing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# steboxing
+
+A Python library for drawing Unicode text boxes around strings — supports 36 border styles using thin, bold, double, and round line characters.
+
+## Installation
+
+```bash
+pip install steboxing
+```
+
+## Usage
+
+```python
+from steboxing import boxing
+
+print(boxing("Hello, World!", box_type="thin"))
+```
+
+```
+┌───────────────┐
+│ Hello, World! │
+└───────────────┘
+```
+
+Multi-line strings are supported:
+
+```python
+print(boxing("Line one\nLine two\nLine three", box_type="double"))
+```
+
+```
+╔════════════╗
+║ Line one   ║
+║ Line two   ║
+║ Line three ║
+╚════════════╝
+```
+
+`box_type` defaults to `"thin"` if omitted.
+
+## Box styles
+
+| `box_type`                | Preview                                        |
+|---------------------------|------------------------------------------------|
+| `thin`                    | `┌───────┐`<br>`│ lines │`<br>`└───────┘`      |
+| `double`                  | `╔═══════╗`<br>`║ lines ║`<br>`╚═══════╝`      |
+| `bold`                    | `┏━━━━━━━┓`<br>`┃ lines ┃`<br>`┗━━━━━━━┛`      |
+| `round`                   | `╭───────╮`<br>`│ lines │`<br>`╰───────╯`      |
+| `bold_top_and_bottom`     | `┍━━━━━━━┑`<br>`│ lines │`<br>`┕━━━━━━━┙`      |
+| `double_top_and_bottom`   | `╒═══════╕`<br>`│ lines │`<br>`╘═══════╛`      |
+| `bold_left_and_right`     | `┎───────┒`<br>`┃ lines ┃`<br>`┖───────┚`      |
+| `double_left_and_right`   | `╓───────╖`<br>`║ lines ║`<br>`╙───────╜`      |
+| `bold_top_only`           | `┍━━━━━━━┑`<br>`│ lines │`<br>`└───────┘`      |
+| `double_top_only`         | `╒═══════╕`<br>`│ lines │`<br>`└───────┘`      |
+| `bold_bottom_only`        | `┌───────┐`<br>`│ lines │`<br>`┕━━━━━━━┙`      |
+| `double_bottom_only`      | `┌───────┐`<br>`│ lines │`<br>`╘═══════╛`      |
+| `bold_right_only`         | `┌───────┒`<br>`│ lines ┃`<br>`└───────┚`      |
+| `double_right_only`       | `┌───────╖`<br>`│ lines ║`<br>`└───────╜`      |
+| `bold_left_only`          | `┎───────┐`<br>`┃ lines │`<br>`┖───────┘`      |
+| `double_left_only`        | `╓───────┐`<br>`║ lines │`<br>`╙───────┘`      |
+| `bold_left_and_top`       | `┏━━━━━━━┑`<br>`┃ lines │`<br>`┖───────┘`      |
+| `double_left_and_top`     | `╔═══════╕`<br>`║ lines │`<br>`╙───────┘`      |
+| `bold_right_and_top`      | `┍━━━━━━━┓`<br>`│ lines ┃`<br>`└───────┚`      |
+| `double_right_and_top`    | `╒═══════╗`<br>`│ lines ║`<br>`└───────╜`      |
+| `bold_right_and_bottom`   | `┌───────┒`<br>`│ lines ┃`<br>`┕━━━━━━━┛`      |
+| `double_right_and_bottom` | `┌───────╖`<br>`│ lines ║`<br>`╘═══════╝`      |
+| `bold_left_and_bottom`    | `┎───────┐`<br>`┃ lines │`<br>`┗━━━━━━━┙`      |
+| `double_left_and_bottom`  | `╓───────┐`<br>`║ lines │`<br>`╚═══════╛`      |
+| `bold_but_bottom`         | `┏━━━━━━━┓`<br>`┃ lines ┃`<br>`┖───────┚`      |
+| `double_but_bottom`       | `╔═══════╗`<br>`║ lines ║`<br>`╙───────╜`      |
+| `bold_but_left`           | `┍━━━━━━━┓`<br>`│ lines ┃`<br>`┕━━━━━━━┛`      |
+| `double_but_left`         | `╒═══════╗`<br>`│ lines ║`<br>`╘═══════╝`      |
+| `bold_but_top`            | `┎───────┒`<br>`┃ lines ┃`<br>`┗━━━━━━━┛`      |
+| `double_but_top`          | `╓───────╖`<br>`║ lines ║`<br>`╚═══════╝`      |
+| `bold_but_right`          | `┏━━━━━━━┑`<br>`┃ lines │`<br>`┗━━━━━━━┙`      |
+| `double_but_right`        | `╔═══════╕`<br>`║ lines │`<br>`╚═══════╛`      |
+| `bold_corners_only`       | `┏───────┓`<br>`│ lines │`<br>`┗───────┛`      |
+| `double_corners_only`     | `╔───────╗`<br>`│ lines │`<br>`╚───────╝`      |
+| `bold_chain`              | `┏─━─━─━─┓`<br>`│ lines │`<br>`┗─━─━─━─┛`      |
+| `double_chain`            | `╔─═─═─═─╗`<br>`│ lines │`<br>`╚─═─═─═─╝`      |
+
+## Error handling
+
+Passing an invalid `box_type` raises a `ValueError` listing all valid options:
+
+```python
+boxing("text", box_type="unknown")
+# ValueError: box_type not supported: unknown. Use one of: thin, double, bold, ...
+```
+
+## License
+
+MIT

steboxing-1.0.0/README.md

@@ -0,0 +1,93 @@
+# steboxing
+
+A Python library for drawing Unicode text boxes around strings — supports 36 border styles using thin, bold, double, and round line characters.
+
+## Installation
+
+```bash
+pip install steboxing
+```
+
+## Usage
+
+```python
+from steboxing import boxing
+
+print(boxing("Hello, World!", box_type="thin"))
+```
+
+```
+┌───────────────┐
+│ Hello, World! │
+└───────────────┘
+```
+
+Multi-line strings are supported:
+
+```python
+print(boxing("Line one\nLine two\nLine three", box_type="double"))
+```
+
+```
+╔════════════╗
+║ Line one   ║
+║ Line two   ║
+║ Line three ║
+╚════════════╝
+```
+
+`box_type` defaults to `"thin"` if omitted.
+
+## Box styles
+
+| `box_type`                | Preview                                        |
+|---------------------------|------------------------------------------------|
+| `thin`                    | `┌───────┐`<br>`│ lines │`<br>`└───────┘`      |
+| `double`                  | `╔═══════╗`<br>`║ lines ║`<br>`╚═══════╝`      |
+| `bold`                    | `┏━━━━━━━┓`<br>`┃ lines ┃`<br>`┗━━━━━━━┛`      |
+| `round`                   | `╭───────╮`<br>`│ lines │`<br>`╰───────╯`      |
+| `bold_top_and_bottom`     | `┍━━━━━━━┑`<br>`│ lines │`<br>`┕━━━━━━━┙`      |
+| `double_top_and_bottom`   | `╒═══════╕`<br>`│ lines │`<br>`╘═══════╛`      |
+| `bold_left_and_right`     | `┎───────┒`<br>`┃ lines ┃`<br>`┖───────┚`      |
+| `double_left_and_right`   | `╓───────╖`<br>`║ lines ║`<br>`╙───────╜`      |
+| `bold_top_only`           | `┍━━━━━━━┑`<br>`│ lines │`<br>`└───────┘`      |
+| `double_top_only`         | `╒═══════╕`<br>`│ lines │`<br>`└───────┘`      |
+| `bold_bottom_only`        | `┌───────┐`<br>`│ lines │`<br>`┕━━━━━━━┙`      |
+| `double_bottom_only`      | `┌───────┐`<br>`│ lines │`<br>`╘═══════╛`      |
+| `bold_right_only`         | `┌───────┒`<br>`│ lines ┃`<br>`└───────┚`      |
+| `double_right_only`       | `┌───────╖`<br>`│ lines ║`<br>`└───────╜`      |
+| `bold_left_only`          | `┎───────┐`<br>`┃ lines │`<br>`┖───────┘`      |
+| `double_left_only`        | `╓───────┐`<br>`║ lines │`<br>`╙───────┘`      |
+| `bold_left_and_top`       | `┏━━━━━━━┑`<br>`┃ lines │`<br>`┖───────┘`      |
+| `double_left_and_top`     | `╔═══════╕`<br>`║ lines │`<br>`╙───────┘`      |
+| `bold_right_and_top`      | `┍━━━━━━━┓`<br>`│ lines ┃`<br>`└───────┚`      |
+| `double_right_and_top`    | `╒═══════╗`<br>`│ lines ║`<br>`└───────╜`      |
+| `bold_right_and_bottom`   | `┌───────┒`<br>`│ lines ┃`<br>`┕━━━━━━━┛`      |
+| `double_right_and_bottom` | `┌───────╖`<br>`│ lines ║`<br>`╘═══════╝`      |
+| `bold_left_and_bottom`    | `┎───────┐`<br>`┃ lines │`<br>`┗━━━━━━━┙`      |
+| `double_left_and_bottom`  | `╓───────┐`<br>`║ lines │`<br>`╚═══════╛`      |
+| `bold_but_bottom`         | `┏━━━━━━━┓`<br>`┃ lines ┃`<br>`┖───────┚`      |
+| `double_but_bottom`       | `╔═══════╗`<br>`║ lines ║`<br>`╙───────╜`      |
+| `bold_but_left`           | `┍━━━━━━━┓`<br>`│ lines ┃`<br>`┕━━━━━━━┛`      |
+| `double_but_left`         | `╒═══════╗`<br>`│ lines ║`<br>`╘═══════╝`      |
+| `bold_but_top`            | `┎───────┒`<br>`┃ lines ┃`<br>`┗━━━━━━━┛`      |
+| `double_but_top`          | `╓───────╖`<br>`║ lines ║`<br>`╚═══════╝`      |
+| `bold_but_right`          | `┏━━━━━━━┑`<br>`┃ lines │`<br>`┗━━━━━━━┙`      |
+| `double_but_right`        | `╔═══════╕`<br>`║ lines │`<br>`╚═══════╛`      |
+| `bold_corners_only`       | `┏───────┓`<br>`│ lines │`<br>`┗───────┛`      |
+| `double_corners_only`     | `╔───────╗`<br>`│ lines │`<br>`╚───────╝`      |
+| `bold_chain`              | `┏─━─━─━─┓`<br>`│ lines │`<br>`┗─━─━─━─┛`      |
+| `double_chain`            | `╔─═─═─═─╗`<br>`│ lines │`<br>`╚─═─═─═─╝`      |
+
+## Error handling
+
+Passing an invalid `box_type` raises a `ValueError` listing all valid options:
+
+```python
+boxing("text", box_type="unknown")
+# ValueError: box_type not supported: unknown. Use one of: thin, double, bold, ...
+```
+
+## License
+
+MIT

steboxing-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "steboxing"
+version = "1.0.0"
+description = "Put your text in a stylish box."
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.6"
+license = { text = "MIT" }
+authors = [
+  { name = "Cangreho" }
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/StefanoMazzuka/steboxing"
+Repository = "https://github.com/StefanoMazzuka/steboxing"
+
+[tool.setuptools.packages.find]
+include = ["steboxing", "steboxing.*"]

steboxing-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

steboxing-1.0.0/steboxing/__init__.py

@@ -0,0 +1,5 @@
+"""Public package exports for steboxing."""
+
+from .core import boxing
+
+__all__ = ["boxing"]

steboxing-1.0.0/steboxing/core.py

@@ -0,0 +1,235 @@
+from typing import Dict, List, Tuple
+
+_HORIZONTAL_CHARS = {
+    "thin": "─",
+    "bold": "━",
+    "double": "═",
+}
+
+_VERTICAL_CHARS = {
+    "thin": "│",
+    "bold": "┃",
+    "double": "║",
+}
+
+_CORNER_CHARS = {
+    "top_left": {
+        ("thin", "thin"): "┌",
+        ("bold", "bold"): "┏",
+        ("double", "double"): "╔",
+        ("bold", "thin"): "┍",
+        ("thin", "bold"): "┎",
+        ("double", "thin"): "╒",
+        ("thin", "double"): "╓",
+    },
+    "top_right": {
+        ("thin", "thin"): "┐",
+        ("bold", "bold"): "┓",
+        ("double", "double"): "╗",
+        ("bold", "thin"): "┑",
+        ("thin", "bold"): "┒",
+        ("double", "thin"): "╕",
+        ("thin", "double"): "╖",
+    },
+    "bottom_left": {
+        ("thin", "thin"): "└",
+        ("bold", "bold"): "┗",
+        ("double", "double"): "╚",
+        ("bold", "thin"): "┕",
+        ("thin", "bold"): "┖",
+        ("double", "thin"): "╘",
+        ("thin", "double"): "╙",
+    },
+    "bottom_right": {
+        ("thin", "thin"): "┘",
+        ("bold", "bold"): "┛",
+        ("double", "double"): "╝",
+        ("bold", "thin"): "┙",
+        ("thin", "bold"): "┚",
+        ("double", "thin"): "╛",
+        ("thin", "double"): "╜",
+    },
+}
+
+_ROUND_CORNERS = {
+    "top_left": "╭",
+    "top_right": "╮",
+    "bottom_left": "╰",
+    "bottom_right": "╯",
+}
+
+_SUPPORTED_BOX_TYPES = (
+    "thin",
+    "double",
+    "bold",
+    "round",
+    "bold_top_and_bottom",
+    "double_top_and_bottom",
+    "bold_left_and_right",
+    "double_left_and_right",
+    "bold_top_only",
+    "double_top_only",
+    "bold_bottom_only",
+    "double_bottom_only",
+    "bold_right_only",
+    "double_right_only",
+    "bold_left_only",
+    "double_left_only",
+    "bold_left_and_top",
+    "double_left_and_top",
+    "bold_right_and_top",
+    "double_right_and_top",
+    "bold_right_and_bottom",
+    "double_right_and_bottom",
+    "bold_left_and_bottom",
+    "double_left_and_bottom",
+    "bold_but_bottom",
+    "double_but_bottom",
+    "bold_but_left",
+    "double_but_left",
+    "bold_but_top",
+    "double_but_top",
+    "bold_but_right",
+    "double_but_right",
+    "bold_corners_only",
+    "double_corners_only",
+    "bold_chain",
+    "double_chain"
+)
+
+
+def _repeat_pattern(pattern: str, width: int) -> str:
+    if width <= 0:
+        return ""
+
+    repeats = (width // len(pattern)) + 1
+    return (pattern * repeats)[:width]
+
+
+def _resolve_sides(box_type: str) -> Dict[str, str]:
+    if box_type in {"thin", "round"}:
+        return {"top": "thin", "right": "thin", "bottom": "thin", "left": "thin"}
+
+    if box_type.startswith("bold"):
+        variant = "bold"
+    elif box_type.startswith("double"):
+        variant = "double"
+    else:
+        raise ValueError(f"box_type not supported: {box_type}")
+
+    if box_type == variant:
+        return {"top": variant, "right": variant, "bottom": variant, "left": variant}
+
+    suffix = box_type[len(variant) + 1 :]
+    sides = {"top": "thin", "right": "thin", "bottom": "thin", "left": "thin"}
+
+    if suffix == "top_and_bottom":
+        sides["top"]    = variant
+        sides["bottom"] = variant
+    elif suffix == "left_and_right":
+        sides["left"]  = variant
+        sides["right"] = variant
+    elif suffix == "top_only":
+        sides["top"] = variant
+    elif suffix == "bottom_only":
+        sides["bottom"] = variant
+    elif suffix == "right_only":
+        sides["right"] = variant
+    elif suffix == "left_only":
+        sides["left"] = variant
+    elif suffix == "left_and_top":
+        sides["left"] = variant
+        sides["top"]  = variant
+    elif suffix == "right_and_top":
+        sides["right"] = variant
+        sides["top"]   = variant
+    elif suffix == "right_and_bottom":
+        sides["right"]  = variant
+        sides["bottom"] = variant
+    elif suffix == "left_and_bottom":
+        sides["left"]   = variant
+        sides["bottom"] = variant
+    elif suffix == "but_bottom":
+        sides = {"top": variant, "right": variant, "bottom": "thin", "left": variant}
+    elif suffix == "but_left":
+        sides = {"top": variant, "right": variant, "bottom": variant, "left": "thin"}
+    elif suffix == "but_top":
+        sides = {"top": "thin", "right": variant, "bottom": variant, "left": variant}
+    elif suffix == "but_right":
+        sides = {"top": variant, "right": "thin", "bottom": variant, "left": variant}
+    elif suffix in {"corners_only", "chain"}:
+        pass
+    else:
+        raise ValueError(f"box_type not supported: {box_type}")
+
+    return sides
+
+
+def _build_standard_box(lines: List[str], max_len: int, box_type: str) -> Tuple[str, str, List[str]]:
+    width = max_len + 2
+    sides = _resolve_sides(box_type)
+
+    if box_type == "round":
+        top_left     = _ROUND_CORNERS["top_left"]
+        top_right    = _ROUND_CORNERS["top_right"]
+        bottom_left  = _ROUND_CORNERS["bottom_left"]
+        bottom_right = _ROUND_CORNERS["bottom_right"]
+    elif box_type.endswith("corners_only"):
+        variant      = "bold" if box_type.startswith("bold") else "double"
+        top_left     = _CORNER_CHARS["top_left"][(variant, variant)]
+        top_right    = _CORNER_CHARS["top_right"][(variant, variant)]
+        bottom_left  = _CORNER_CHARS["bottom_left"][(variant, variant)]
+        bottom_right = _CORNER_CHARS["bottom_right"][(variant, variant)]
+    else:
+        top_left     = _CORNER_CHARS["top_left"][(sides["top"], sides["left"])]
+        top_right    = _CORNER_CHARS["top_right"][(sides["top"], sides["right"])]
+        bottom_left  = _CORNER_CHARS["bottom_left"][(sides["bottom"], sides["left"])]
+        bottom_right = _CORNER_CHARS["bottom_right"][(sides["bottom"], sides["right"])]
+
+    top_border    = top_left + (_HORIZONTAL_CHARS[sides["top"]] * width) + top_right
+    bottom_border = bottom_left + (_HORIZONTAL_CHARS[sides["bottom"]] * width) + bottom_right
+    boxed_lines   = [
+        f"{_VERTICAL_CHARS[sides['left']]} {line.ljust(max_len)} {_VERTICAL_CHARS[sides['right']]}"
+        for line in lines
+    ]
+
+    return top_border, bottom_border, boxed_lines
+
+
+def _build_chain_box(lines: List[str], max_len: int, box_type: str) -> Tuple[str, str, List[str]]:
+    width = max_len + 2
+    variant = "bold" if box_type.startswith("bold") else "double"
+    top_border = (
+        _CORNER_CHARS["top_left"][(variant, variant)]
+        + _repeat_pattern(_HORIZONTAL_CHARS["thin"] + _HORIZONTAL_CHARS[variant], width)
+        + _CORNER_CHARS["top_right"][(variant, variant)]
+    )
+    bottom_border = (
+        _CORNER_CHARS["bottom_left"][(variant, variant)]
+        + _repeat_pattern(_HORIZONTAL_CHARS["thin"] + _HORIZONTAL_CHARS[variant], width)
+        + _CORNER_CHARS["bottom_right"][(variant, variant)]
+    )
+    boxed_lines = []
+
+    for index, line in enumerate(lines):
+        side_type = variant if index % 2 else "thin"
+        vertical  = _VERTICAL_CHARS[side_type]
+        boxed_lines.append(f"{vertical} {line.ljust(max_len)} {vertical}")
+
+    return top_border, bottom_border, boxed_lines
+
+
+def boxing(string: str, box_type: str = "thin") -> str:
+    if box_type not in _SUPPORTED_BOX_TYPES:
+        supported = ", ".join(_SUPPORTED_BOX_TYPES)
+        raise ValueError(f"box_type not supported: {box_type}. Use one of: {supported}")
+
+    lines   = string.splitlines() or [""]
+    max_len = max(len(line) for line in lines)
+
+    if box_type.endswith("chain"):
+        top_border, bottom_border, boxed_lines = _build_chain_box(lines, max_len, box_type)
+    else:
+        top_border, bottom_border, boxed_lines = _build_standard_box(lines, max_len, box_type)
+
+    return "\n".join([top_border] + boxed_lines + [bottom_border])

steboxing-1.0.0/steboxing.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: steboxing
+Version: 1.0.0
+Summary: Put your text in a stylish box.
+Author: Cangreho
+License: MIT
+Project-URL: Homepage, https://github.com/StefanoMazzuka/steboxing
+Project-URL: Repository, https://github.com/StefanoMazzuka/steboxing
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# steboxing
+
+A Python library for drawing Unicode text boxes around strings — supports 36 border styles using thin, bold, double, and round line characters.
+
+## Installation
+
+```bash
+pip install steboxing
+```
+
+## Usage
+
+```python
+from steboxing import boxing
+
+print(boxing("Hello, World!", box_type="thin"))
+```
+
+```
+┌───────────────┐
+│ Hello, World! │
+└───────────────┘
+```
+
+Multi-line strings are supported:
+
+```python
+print(boxing("Line one\nLine two\nLine three", box_type="double"))
+```
+
+```
+╔════════════╗
+║ Line one   ║
+║ Line two   ║
+║ Line three ║
+╚════════════╝
+```
+
+`box_type` defaults to `"thin"` if omitted.
+
+## Box styles
+
+| `box_type`                | Preview                                        |
+|---------------------------|------------------------------------------------|
+| `thin`                    | `┌───────┐`<br>`│ lines │`<br>`└───────┘`      |
+| `double`                  | `╔═══════╗`<br>`║ lines ║`<br>`╚═══════╝`      |
+| `bold`                    | `┏━━━━━━━┓`<br>`┃ lines ┃`<br>`┗━━━━━━━┛`      |
+| `round`                   | `╭───────╮`<br>`│ lines │`<br>`╰───────╯`      |
+| `bold_top_and_bottom`     | `┍━━━━━━━┑`<br>`│ lines │`<br>`┕━━━━━━━┙`      |
+| `double_top_and_bottom`   | `╒═══════╕`<br>`│ lines │`<br>`╘═══════╛`      |
+| `bold_left_and_right`     | `┎───────┒`<br>`┃ lines ┃`<br>`┖───────┚`      |
+| `double_left_and_right`   | `╓───────╖`<br>`║ lines ║`<br>`╙───────╜`      |
+| `bold_top_only`           | `┍━━━━━━━┑`<br>`│ lines │`<br>`└───────┘`      |
+| `double_top_only`         | `╒═══════╕`<br>`│ lines │`<br>`└───────┘`      |
+| `bold_bottom_only`        | `┌───────┐`<br>`│ lines │`<br>`┕━━━━━━━┙`      |
+| `double_bottom_only`      | `┌───────┐`<br>`│ lines │`<br>`╘═══════╛`      |
+| `bold_right_only`         | `┌───────┒`<br>`│ lines ┃`<br>`└───────┚`      |
+| `double_right_only`       | `┌───────╖`<br>`│ lines ║`<br>`└───────╜`      |
+| `bold_left_only`          | `┎───────┐`<br>`┃ lines │`<br>`┖───────┘`      |
+| `double_left_only`        | `╓───────┐`<br>`║ lines │`<br>`╙───────┘`      |
+| `bold_left_and_top`       | `┏━━━━━━━┑`<br>`┃ lines │`<br>`┖───────┘`      |
+| `double_left_and_top`     | `╔═══════╕`<br>`║ lines │`<br>`╙───────┘`      |
+| `bold_right_and_top`      | `┍━━━━━━━┓`<br>`│ lines ┃`<br>`└───────┚`      |
+| `double_right_and_top`    | `╒═══════╗`<br>`│ lines ║`<br>`└───────╜`      |
+| `bold_right_and_bottom`   | `┌───────┒`<br>`│ lines ┃`<br>`┕━━━━━━━┛`      |
+| `double_right_and_bottom` | `┌───────╖`<br>`│ lines ║`<br>`╘═══════╝`      |
+| `bold_left_and_bottom`    | `┎───────┐`<br>`┃ lines │`<br>`┗━━━━━━━┙`      |
+| `double_left_and_bottom`  | `╓───────┐`<br>`║ lines │`<br>`╚═══════╛`      |
+| `bold_but_bottom`         | `┏━━━━━━━┓`<br>`┃ lines ┃`<br>`┖───────┚`      |
+| `double_but_bottom`       | `╔═══════╗`<br>`║ lines ║`<br>`╙───────╜`      |
+| `bold_but_left`           | `┍━━━━━━━┓`<br>`│ lines ┃`<br>`┕━━━━━━━┛`      |
+| `double_but_left`         | `╒═══════╗`<br>`│ lines ║`<br>`╘═══════╝`      |
+| `bold_but_top`            | `┎───────┒`<br>`┃ lines ┃`<br>`┗━━━━━━━┛`      |
+| `double_but_top`          | `╓───────╖`<br>`║ lines ║`<br>`╚═══════╝`      |
+| `bold_but_right`          | `┏━━━━━━━┑`<br>`┃ lines │`<br>`┗━━━━━━━┙`      |
+| `double_but_right`        | `╔═══════╕`<br>`║ lines │`<br>`╚═══════╛`      |
+| `bold_corners_only`       | `┏───────┓`<br>`│ lines │`<br>`┗───────┛`      |
+| `double_corners_only`     | `╔───────╗`<br>`│ lines │`<br>`╚───────╝`      |
+| `bold_chain`              | `┏─━─━─━─┓`<br>`│ lines │`<br>`┗─━─━─━─┛`      |
+| `double_chain`            | `╔─═─═─═─╗`<br>`│ lines │`<br>`╚─═─═─═─╝`      |
+
+## Error handling
+
+Passing an invalid `box_type` raises a `ValueError` listing all valid options:
+
+```python
+boxing("text", box_type="unknown")
+# ValueError: box_type not supported: unknown. Use one of: thin, double, bold, ...
+```
+
+## License
+
+MIT

steboxing-1.0.0/steboxing.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+steboxing/__init__.py
+steboxing/core.py
+steboxing.egg-info/PKG-INFO
+steboxing.egg-info/SOURCES.txt
+steboxing.egg-info/dependency_links.txt
+steboxing.egg-info/top_level.txt
+tests/test_core.py

steboxing-1.0.0/steboxing.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

steboxing-1.0.0/steboxing.egg-info/top_level.txt

@@ -0,0 +1 @@
+steboxing

steboxing-1.0.0/tests/test_core.py

@@ -0,0 +1,695 @@
+import unittest
+from unittest import result
+from steboxing.core import boxing
+
+class TestBoxing(unittest.TestCase):
+    def test_wrong_box_type(self):
+        self.assertRaises(ValueError, lambda: boxing("hello\nworld!", box_type="wrong"))
+
+    def test_thin(self):
+        result_empty   = boxing("", box_type="thin")
+        result_correct = boxing("hello\nworld!", box_type="thin")
+
+        expected_empty = (
+            "┌──┐\n"
+            "│  │\n"
+            "└──┘"
+        )  
+        expected_correct = (
+            "┌────────┐\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "└────────┘"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+
+    def test_double(self):
+        result_empty   = boxing("", box_type="double")
+        result_correct = boxing("hello\nworld!", box_type="double")
+
+        expected_empty = (
+            "╔══╗\n"
+            "║  ║\n"
+            "╚══╝"
+        )  
+        expected_correct = (
+            "╔════════╗\n"
+            "║ hello  ║\n"
+            "║ world! ║\n"
+            "╚════════╝"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold(self):
+        result_empty   = boxing("", box_type="bold")
+        result_correct = boxing("hello\nworld!", box_type="bold")
+
+        expected_empty = (
+            "┏━━┓\n"
+            "┃  ┃\n"
+            "┗━━┛"
+        )  
+        expected_correct = (
+            "┏━━━━━━━━┓\n"
+            "┃ hello  ┃\n"
+            "┃ world! ┃\n"
+            "┗━━━━━━━━┛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_round(self):
+        result_empty   = boxing("", box_type="round")
+        result_correct = boxing("hello\nworld!", box_type="round")
+
+        expected_empty = (
+            "╭──╮\n"
+            "│  │\n"
+            "╰──╯"
+        )  
+        expected_correct = (
+            "╭────────╮\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "╰────────╯"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_top_and_bottom(self):
+        result_empty   = boxing("", box_type="bold_top_and_bottom")
+        result_correct = boxing("hello\nworld!", box_type="bold_top_and_bottom")
+
+        expected_empty = (
+            "┍━━┑\n"
+            "│  │\n"
+            "┕━━┙"
+        )  
+        expected_correct = (
+            "┍━━━━━━━━┑\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "┕━━━━━━━━┙"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_top_and_bottom(self):
+        result_empty   = boxing("", box_type="double_top_and_bottom")
+        result_correct = boxing("hello\nworld!", box_type="double_top_and_bottom")
+
+        expected_empty = (
+            "╒══╕\n"
+            "│  │\n"
+            "╘══╛"
+        )  
+        expected_correct = (
+            "╒════════╕\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "╘════════╛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_left_and_right(self):
+        result_empty   = boxing("", box_type="bold_left_and_right")
+        result_correct = boxing("hello\nworld!", box_type="bold_left_and_right")
+
+        expected_empty = (
+            "┎──┒\n"
+            "┃  ┃\n"
+            "┖──┚"
+        )  
+        expected_correct = (
+            "┎────────┒\n"
+            "┃ hello  ┃\n"
+            "┃ world! ┃\n"
+            "┖────────┚"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_left_and_right(self):
+        result_empty   = boxing("", box_type="double_left_and_right")
+        result_correct = boxing("hello\nworld!", box_type="double_left_and_right")
+
+        expected_empty = (
+            "╓──╖\n"
+            "║  ║\n"
+            "╙──╜"
+        )  
+        expected_correct = (
+            "╓────────╖\n"
+            "║ hello  ║\n"
+            "║ world! ║\n"
+            "╙────────╜"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_top_only(self):
+        result_empty   = boxing("", box_type="bold_top_only")
+        result_correct = boxing("hello\nworld!", box_type="bold_top_only")
+
+        expected_empty = (
+            "┍━━┑\n"
+            "│  │\n"
+            "└──┘"
+        )  
+        expected_correct = (
+            "┍━━━━━━━━┑\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "└────────┘"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_top_only(self):
+        result_empty   = boxing("", box_type="double_top_only")
+        result_correct = boxing("hello\nworld!", box_type="double_top_only")
+
+        expected_empty = (
+            "╒══╕\n"
+            "│  │\n"
+            "└──┘"
+        )  
+        expected_correct = (
+            "╒════════╕\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "└────────┘"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_bottom_only(self):
+        result_empty   = boxing("", box_type="bold_bottom_only")
+        result_correct = boxing("hello\nworld!", box_type="bold_bottom_only")
+
+        expected_empty = (
+            "┌──┐\n"
+            "│  │\n"
+            "┕━━┙"
+        )  
+        expected_correct = (
+            "┌────────┐\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "┕━━━━━━━━┙"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_bottom_only(self):
+        result_empty   = boxing("", box_type="double_bottom_only")
+        result_correct = boxing("hello\nworld!", box_type="double_bottom_only")
+
+        expected_empty = (
+            "┌──┐\n"
+            "│  │\n"
+            "╘══╛"
+        )  
+        expected_correct = (
+            "┌────────┐\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "╘════════╛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_right_only(self):
+        result_empty   = boxing("", box_type="bold_right_only")
+        result_correct = boxing("hello\nworld!", box_type="bold_right_only")
+
+        expected_empty = (
+            "┌──┒\n"
+            "│  ┃\n"
+            "└──┚"
+        )  
+        expected_correct = (
+            "┌────────┒\n"
+            "│ hello  ┃\n"
+            "│ world! ┃\n"
+            "└────────┚"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_right_only(self):
+        result_empty   = boxing("", box_type="double_right_only")
+        result_correct = boxing("hello\nworld!", box_type="double_right_only")
+
+        expected_empty = (
+            "┌──╖\n"
+            "│  ║\n"
+            "└──╜"
+        )  
+        expected_correct = (
+            "┌────────╖\n"
+            "│ hello  ║\n"
+            "│ world! ║\n"
+            "└────────╜"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_left_only(self):
+        result_empty   = boxing("", box_type="bold_left_only")
+        result_correct = boxing("hello\nworld!", box_type="bold_left_only")
+
+        expected_empty = (
+            "┎──┐\n"
+            "┃  │\n"
+            "┖──┘"
+        )  
+        expected_correct = (
+            "┎────────┐\n"
+            "┃ hello  │\n"
+            "┃ world! │\n"
+            "┖────────┘"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_left_only(self):
+        result_empty   = boxing("", box_type="double_left_only")
+        result_correct = boxing("hello\nworld!", box_type="double_left_only")
+
+        expected_empty = (
+            "╓──┐\n"
+            "║  │\n"
+            "╙──┘"
+        )  
+        expected_correct = (
+            "╓────────┐\n"
+            "║ hello  │\n"
+            "║ world! │\n"
+            "╙────────┘"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_left_and_top(self):
+        result_empty   = boxing("", box_type="bold_left_and_top")
+        result_correct = boxing("hello\nworld!", box_type="bold_left_and_top")
+
+        expected_empty = (
+            "┏━━┑\n"
+            "┃  │\n"
+            "┖──┘"
+        )  
+        expected_correct = (
+            "┏━━━━━━━━┑\n"
+            "┃ hello  │\n"
+            "┃ world! │\n"
+            "┖────────┘"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_left_and_top(self):
+        result_empty   = boxing("", box_type="double_left_and_top")
+        result_correct = boxing("hello\nworld!", box_type="double_left_and_top")
+
+        expected_empty = (
+            "╔══╕\n"
+            "║  │\n"
+            "╙──┘"
+        )  
+        expected_correct = (
+            "╔════════╕\n"
+            "║ hello  │\n"
+            "║ world! │\n"
+            "╙────────┘"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_right_and_top(self):
+        result_empty   = boxing("", box_type="bold_right_and_top")
+        result_correct = boxing("hello\nworld!", box_type="bold_right_and_top")
+
+        expected_empty = (
+            "┍━━┓\n"
+            "│  ┃\n"
+            "└──┚"
+        )  
+        expected_correct = (
+            "┍━━━━━━━━┓\n"
+            "│ hello  ┃\n"
+            "│ world! ┃\n"
+            "└────────┚"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_right_and_top(self):
+        result_empty   = boxing("", box_type="double_right_and_top")
+        result_correct = boxing("hello\nworld!", box_type="double_right_and_top")
+
+        expected_empty = (
+            "╒══╗\n"
+            "│  ║\n"
+            "└──╜"
+        )  
+        expected_correct = (
+            "╒════════╗\n"
+            "│ hello  ║\n"
+            "│ world! ║\n"
+            "└────────╜"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_right_and_bottom(self):
+        result_empty   = boxing("", box_type="bold_right_and_bottom")
+        result_correct = boxing("hello\nworld!", box_type="bold_right_and_bottom")
+
+        expected_empty = (
+            "┌──┒\n"
+            "│  ┃\n"
+            "┕━━┛"
+        )  
+        expected_correct = (
+            "┌────────┒\n"
+            "│ hello  ┃\n"
+            "│ world! ┃\n"
+            "┕━━━━━━━━┛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_right_and_bottom(self):
+        result_empty   = boxing("", box_type="double_right_and_bottom")
+        result_correct = boxing("hello\nworld!", box_type="double_right_and_bottom")
+
+        expected_empty = (
+            "┌──╖\n"
+            "│  ║\n"
+            "╘══╝"
+        )  
+        expected_correct = (
+            "┌────────╖\n"
+            "│ hello  ║\n"
+            "│ world! ║\n"
+            "╘════════╝"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_left_and_bottom(self):
+        result_empty   = boxing("", box_type="bold_left_and_bottom")
+        result_correct = boxing("hello\nworld!", box_type="bold_left_and_bottom")
+
+        expected_empty = (
+            "┎──┐\n"
+            "┃  │\n"
+            "┗━━┙"
+        )  
+        expected_correct = (
+            "┎────────┐\n"
+            "┃ hello  │\n"
+            "┃ world! │\n"
+            "┗━━━━━━━━┙"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_left_and_bottom(self):
+        result_empty   = boxing("", box_type="double_left_and_bottom")
+        result_correct = boxing("hello\nworld!", box_type="double_left_and_bottom")
+
+        expected_empty = (
+            "╓──┐\n"
+            "║  │\n"
+            "╚══╛"
+        )  
+        expected_correct = (
+            "╓────────┐\n"
+            "║ hello  │\n"
+            "║ world! │\n"
+            "╚════════╛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_but_bottom(self):
+        result_empty   = boxing("", box_type="bold_but_bottom")
+        result_correct = boxing("hello\nworld!", box_type="bold_but_bottom")
+
+        expected_empty = (
+            "┏━━┓\n"
+            "┃  ┃\n"
+            "┖──┚"
+        )  
+        expected_correct = (
+            "┏━━━━━━━━┓\n"
+            "┃ hello  ┃\n"
+            "┃ world! ┃\n"
+            "┖────────┚"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_but_bottom(self):
+        result_empty   = boxing("", box_type="double_but_bottom")
+        result_correct = boxing("hello\nworld!", box_type="double_but_bottom")
+
+        expected_empty = (
+            "╔══╗\n"
+            "║  ║\n"
+            "╙──╜"
+        )  
+        expected_correct = (
+            "╔════════╗\n"
+            "║ hello  ║\n"
+            "║ world! ║\n"
+            "╙────────╜"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_but_left(self):
+        result_empty   = boxing("", box_type="bold_but_left")
+        result_correct = boxing("hello\nworld!", box_type="bold_but_left")
+
+        expected_empty = (
+            "┍━━┓\n"
+            "│  ┃\n"
+            "┕━━┛"
+        )  
+        expected_correct = (
+            "┍━━━━━━━━┓\n"
+            "│ hello  ┃\n"
+            "│ world! ┃\n"
+            "┕━━━━━━━━┛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_but_left(self):
+        result_empty   = boxing("", box_type="double_but_left")
+        result_correct = boxing("hello\nworld!", box_type="double_but_left")
+
+        expected_empty = (
+            "╒══╗\n"
+            "│  ║\n"
+            "╘══╝"
+        )  
+        expected_correct = (
+            "╒════════╗\n"
+            "│ hello  ║\n"
+            "│ world! ║\n"
+            "╘════════╝"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_but_top(self):
+        result_empty   = boxing("", box_type="bold_but_top")
+        result_correct = boxing("hello\nworld!", box_type="bold_but_top")
+
+        expected_empty = (
+            "┎──┒\n"
+            "┃  ┃\n"
+            "┗━━┛"
+        )  
+        expected_correct = (
+            "┎────────┒\n"
+            "┃ hello  ┃\n"
+            "┃ world! ┃\n"
+            "┗━━━━━━━━┛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_but_top(self):
+        result_empty   = boxing("", box_type="double_but_top")
+        result_correct = boxing("hello\nworld!", box_type="double_but_top")
+
+        expected_empty = (
+            "╓──╖\n"
+            "║  ║\n"
+            "╚══╝"
+        )  
+        expected_correct = (
+            "╓────────╖\n"
+            "║ hello  ║\n"
+            "║ world! ║\n"
+            "╚════════╝"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_but_right(self):
+        result_empty   = boxing("", box_type="bold_but_right")
+        result_correct = boxing("hello\nworld!", box_type="bold_but_right")
+
+        expected_empty = (
+            "┏━━┑\n"
+            "┃  │\n"
+            "┗━━┙"
+        )  
+        expected_correct = (
+            "┏━━━━━━━━┑\n"
+            "┃ hello  │\n"
+            "┃ world! │\n"
+            "┗━━━━━━━━┙"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_but_right(self):
+        result_empty   = boxing("", box_type="double_but_right")
+        result_correct = boxing("hello\nworld!", box_type="double_but_right")
+
+        expected_empty = (
+            "╔══╕\n"
+            "║  │\n"
+            "╚══╛"
+        )  
+        expected_correct = (
+            "╔════════╕\n"
+            "║ hello  │\n"
+            "║ world! │\n"
+            "╚════════╛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_corners_only(self):
+        result_empty   = boxing("", box_type="bold_corners_only")
+        result_correct = boxing("hello\nworld!", box_type="bold_corners_only")
+
+        expected_empty = (
+            "┏──┓\n"
+            "│  │\n"
+            "┗──┛"
+        )  
+        expected_correct = (
+            "┏────────┓\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "┗────────┛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_corners_only(self):
+        result_empty   = boxing("", box_type="double_corners_only")
+        result_correct = boxing("hello\nworld!", box_type="double_corners_only")
+
+        expected_empty = (
+            "╔──╗\n"
+            "│  │\n"
+            "╚──╝"
+        )  
+        expected_correct = (
+            "╔────────╗\n"
+            "│ hello  │\n"
+            "│ world! │\n"
+            "╚────────╝"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_bold_chain(self):
+        result_empty   = boxing("", box_type="bold_chain")
+        result_correct = boxing("hello\nworld!", box_type="bold_chain")
+
+        expected_empty = (
+            "┏─━┓\n"
+            "│  │\n"
+            "┗─━┛"
+        )  
+        expected_correct = (
+            "┏─━─━─━─━┓\n"
+            "│ hello  │\n"
+            "┃ world! ┃\n"
+            "┗─━─━─━─━┛"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+    def test_double_chain(self):
+        result_empty   = boxing("", box_type="double_chain")
+        result_correct = boxing("hello\nworld!", box_type="double_chain")
+
+        expected_empty = (
+            "╔─═╗\n"
+            "│  │\n"
+            "╚─═╝"
+        )  
+        expected_correct = (
+            "╔─═─═─═─═╗\n"
+            "│ hello  │\n"
+            "║ world! ║\n"
+            "╚─═─═─═─═╝"
+        )
+
+        self.assertTrue(result_empty   == expected_empty)
+        self.assertTrue(result_correct == expected_correct)
+        
+
+if __name__ == "__main__":
+    unittest.main()