django-shellcraft 0.1.0__py3-none-any.whl

django_shellcraft-0.1.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: django-shellcraft
+Version: 0.1.0
+Summary: Rails-style console ergonomics for Django — pretty printing, model shortcuts, and schema inspection
+Author-email: Siva <sivanandam03@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Siva
+        
+        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.
+License-File: LICENSE
+Keywords: console,developer-tools,django,orm,rails,shell
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: django>=3.2
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest-django>=4.8; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# django-shellcraft
+
+Rails-style console ergonomics for Django — pretty printing, model shortcuts, and schema inspection.
+
+Built for developers migrating from Ruby on Rails who miss the `rails console` experience.
+
+---
+
+## Installation
+
+```bash
+pip install django-shellcraft
+```
+
+Add to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "shellcraft",
+]
+```
+
+## Usage
+
+```bash
+python manage.py shellcraft
+```
+
+All models are auto-imported into the shell namespace. IPython is used when available, falling back to the standard Python REPL.
+
+> **Note:** shellcraft refuses to start when `DEBUG = False` as a production safety guard.
+
+---
+
+## Features
+
+### Model shortcuts
+
+All shortcuts are injected as classmethods/instance methods at shell startup. Raw `User.objects.all()` is unchanged — pretty printing only happens through shellcraft methods.
+
+| Method | Equivalent |
+|---|---|
+| `User.find(1)` | `User.objects.get(pk=1)` |
+| `User.all()` | `User.objects.all()` + pretty print |
+| `User.where(is_active=True)` | `User.objects.filter(...)` + pretty print |
+| `User.first()` | `User.objects.first()` + pretty print |
+| `User.last()` | `User.objects.last()` + pretty print |
+| `User.count()` | `User.objects.count()` |
+| `user.update(email="x@y.com")` | sets attrs + `save()` |
+| `user.destroy()` | `user.delete()` |
+| `User.fields()` | colored schema inspection |
+| `tables()` | list all models across all apps |
+
+### Pretty printing
+
+Single record:
+
+```
+#<User:0x7f3a> {
+    :id         => 1,
+    :username   => "siva",
+    :email      => "siva@example.com",
+    :is_active  => true,
+    :created_at => 2024-01-15 10:30:00,
+}
+```
+
+Multiple records:
+
+```
+[
+    [0] #<User:0x7f3a> {
+            :id       => 1,
+            :username => "siva",
+        },
+    [1] #<User:0x7f3b> {
+            :id       => 2,
+            :username => "kumar",
+        }
+]
+2 records
+```
+
+Color mapping:
+
+| Type | Color |
+|---|---|
+| `int`, `float` | blue |
+| `str` | yellow |
+| `True` | green |
+| `False`, `None` | red |
+| `datetime`, `date` | cyan |
+| field types | cyan |
+| record index `[0]` | gray |
+
+### Schema inspection
+
+```python
+User.fields()
+```
+
+```
+User {
+    :id          AutoField
+    :username    CharField
+    :email       CharField
+    :is_active   BooleanField
+    :created_at  DateTimeField
+    :group_id    ForeignKey     null: true
+}
+```
+
+### List all tables
+
+```python
+tables()
+```
+
+```
+  auth.User
+  auth.Group
+  auth.Permission
+  myapp.Post
+  myapp.Comment
+
+5 tables
+```
+
+### Manual pretty printing
+
+`ap()` is available directly for any model instance or queryset:
+
+```python
+ap(User.objects.filter(is_staff=True))
+```
+
+---
+
+## Requirements
+
+- Python 3.8+
+- Django 3.2, 4.0, 4.1, 4.2, or 5.0
+- django-extensions >= 3.0
+
+Optional: `ipython` for an enhanced shell experience.
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/yourusername/django-shellcraft
+cd django-shellcraft
+pip install -e ".[dev]"
+pytest
+```
+
+---
+
+## License
+
+MIT

django_shellcraft-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+shellcraft/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+shellcraft/mixins.py,sha256=h8OfST2Y01UwBtr8zT58PC9r0dARUvZeKK775h3qokY,4477
+shellcraft/printer.py,sha256=IJnPFpfJ1tQgtf-5I51FR4kbAVWAIud68fQREyfw6wc,7255
+shellcraft/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shellcraft/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shellcraft/management/commands/shellcraft.py,sha256=UGItbw7fy2tfPric0D-VRZcNPafKcm82ET2GLlCTaUI,3535
+django_shellcraft-0.1.0.dist-info/METADATA,sha256=7OAA-4YLHy82VgZXEzb9n-djqRwRGMr2gpeqkClvQQg,5517
+django_shellcraft-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+django_shellcraft-0.1.0.dist-info/licenses/LICENSE,sha256=F24jcS4eawjwevYk9Q8FL_pYRDzLHV5whzfN1n9DNJA,1061
+django_shellcraft-0.1.0.dist-info/RECORD,,

django_shellcraft-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_shellcraft-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Siva
+
+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.

shellcraft/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

shellcraft/management/commands/shellcraft.py

@@ -0,0 +1,95 @@
+import warnings
+
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+BANNER = """\
+shellcraft {version} — Rails-style Django shell
+  User.find(1)          User.all()        User.where(active=True)
+  User.first()          User.last()       User.count()
+  user.update(k=v)      user.destroy()
+  User.fields()         tables()
+"""
+
+
+class Command(BaseCommand):
+    help = "Rails-style Django shell with pretty printing and model shortcuts"
+
+    def handle(self, *_args, **_options):
+        # Use CommandError instead of SystemExit so Django's management
+        # framework can format the message via stderr and return a proper
+        # non-zero exit code.  SystemExit would skip that pipeline entirely.
+        if not settings.DEBUG:
+            raise CommandError(
+                "shellcraft: refusing to run with DEBUG=False (production guard)"
+            )
+
+        from shellcraft.mixins import inject
+
+        inject()
+
+        namespace = self._build_namespace()
+        self._start_shell(namespace)
+
+    def _build_namespace(self):
+        from django.apps import apps
+
+        from shellcraft.printer import CYAN, RESET, ap
+
+        def tables():
+            all_models = apps.get_models()
+            for model in all_models:
+                label = model._meta.app_label
+                self.stdout.write(f"  {CYAN}{label}{RESET}.{model.__name__}")
+            self.stdout.write(f"\n{len(all_models)} tables")
+
+        namespace = {
+            "ap": ap,
+            "tables": tables,
+        }
+
+        # Build model-name → model mapping, warning when two apps define a
+        # model with the same class name.  Without the warning the second
+        # model silently shadows the first, which is a confusing footgun when
+        # working with multi-app projects (e.g. two apps both define `Profile`).
+        seen: dict = {}
+        for model in apps.get_models():
+            name = model.__name__
+            if name in seen:
+                warnings.warn(
+                    f"shellcraft: model name conflict — '{name}' exists in both "
+                    f"'{seen[name]._meta.app_label}' and '{model._meta.app_label}'. "
+                    f"The '{model._meta.app_label}.{name}' version is used in the "
+                    "shell namespace.  Access the other via "
+                    "apps.get_model('<app_label>', '<ModelName>').",
+                    stacklevel=2,
+                )
+            seen[name] = model
+            namespace[name] = model
+
+        return namespace
+
+    def _start_shell(self, namespace):
+        from shellcraft import __version__
+
+        banner = BANNER.format(version=__version__)
+        self.stdout.write(banner)
+
+        # Detect which shell is available before entering it, so that
+        # code.interact is never called inside an `except` block.  If it were,
+        # Python would set __context__ on every shell exception to the
+        # ModuleNotFoundError, producing spurious "During handling of the above
+        # exception" noise on every traceback the user sees.
+        use_ipython = False
+        try:
+            import IPython  # noqa: F401
+            use_ipython = True
+        except ImportError:
+            self.stdout.write("(IPython not found — using standard Python shell)\n")
+
+        if use_ipython:
+            import IPython
+            IPython.start_ipython(argv=["--no-banner"], user_ns=namespace)
+        else:
+            import code
+            code.interact(banner="", local=namespace)

shellcraft/mixins.py

@@ -0,0 +1,138 @@
+import warnings
+
+_INJECTED = False
+
+
+def inject():
+    """Inject Rails-style class/instance methods onto Django's base Model.
+
+    Safe to call multiple times — idempotent after first call.
+    Only call this from the shellcraft management command.
+
+    Raises RuntimeError when DEBUG is False so that an accidental import of
+    this module in a production Celery worker or WSGI request cannot
+    activate the shell shortcuts on every model in the process.
+    """
+    global _INJECTED
+    if _INJECTED:
+        return
+
+    # Belt-and-suspenders production guard.  The management command also
+    # checks DEBUG before calling inject(), but inject() is a public function
+    # and could be called from user code (e.g. a custom management command
+    # that wraps shellcraft).  Checking here ensures the guard can never be
+    # bypassed simply by calling inject() directly.
+    from django.conf import settings
+    if not settings.DEBUG:
+        raise RuntimeError(
+            "shellcraft.inject() must not be called when DEBUG=False. "
+            "The shellcraft shell is a development-only tool."
+        )
+
+    _INJECTED = True
+
+    from django.db import models
+
+    from shellcraft.printer import ap, format_fields
+
+    def _find(cls, pk):
+        return cls.objects.get(pk=pk)
+
+    def _all(cls):
+        # Return the queryset so callers can assign: `users = User.all()`.
+        # Printing and returning are both useful; returning None was a silent
+        # footgun for anyone who stored the result.
+        qs = cls.objects.all()
+        ap(qs)
+        return qs
+
+    def _where(cls, **kwargs):
+        qs = cls.objects.filter(**kwargs)
+        ap(qs)
+        return qs
+
+    def _first(cls):
+        obj = cls.objects.first()
+        if obj is not None:
+            ap(obj)
+        return obj
+
+    def _last(cls):
+        obj = cls.objects.last()
+        if obj is not None:
+            ap(obj)
+        return obj
+
+    def _count(cls):
+        return cls.objects.count()
+
+    def _fields(cls):
+        print(format_fields(cls))
+
+    def _update(self, **kwargs):
+        # Block dunder and private-attribute keys outright.  Allowing
+        # user.update(__class__=X) or user.update(__dict__={...}) would let
+        # shell users overwrite Python internals, bypassing Django's field
+        # validation entirely and corrupting the object in memory.
+        for key in kwargs:
+            if key.startswith("_"):
+                raise ValueError(
+                    f"shellcraft: cannot update private or dunder attribute '{key}'. "
+                    "Pass only model field names."
+                )
+
+        # Warn (don't raise) for keys that don't correspond to any known field
+        # on this model.  Django's save() will silently ignore them, which is
+        # confusing during interactive development.
+        valid_fields = {f.attname for f in self.__class__._meta.concrete_fields}
+        valid_fields.update(f.name for f in self.__class__._meta.concrete_fields)
+        valid_fields.update(f.name for f in self.__class__._meta.many_to_many)
+
+        for key in kwargs:
+            if key not in valid_fields:
+                warnings.warn(
+                    f"shellcraft: '{key}' is not a recognised field on "
+                    f"{self.__class__.__name__} — the attribute will be set "
+                    "but will not be persisted by Django's save().",
+                    stacklevel=2,
+                )
+
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+        self.save()
+        return self
+
+    def _destroy(self):
+        return self.delete()
+
+    class_methods = {
+        'find':   _find,
+        'all':    _all,
+        'where':  _where,
+        'first':  _first,
+        'last':   _last,
+        'count':  _count,
+        'fields': _fields,
+    }
+    instance_methods = {
+        'update':  _update,
+        'destroy': _destroy,
+    }
+
+    for name, fn in class_methods.items():
+        _safe_inject(models.Model, name, classmethod(fn))
+
+    for name, fn in instance_methods.items():
+        _safe_inject(models.Model, name, fn)
+
+
+def _safe_inject(cls, name, method):
+    if hasattr(cls, name):
+        existing = getattr(cls, name)
+        warnings.warn(
+            f"shellcraft: '{name}' already exists on {cls.__name__} "
+            f"(defined in {getattr(existing, '__module__', '?')}) — skipping injection",
+            stacklevel=3,
+        )
+        return
+    setattr(cls, name, method)

shellcraft/printer.py

@@ -0,0 +1,200 @@
+import datetime
+import re
+from decimal import Decimal
+
+# ANSI color codes
+BLUE   = '\033[34m'
+YELLOW = '\033[33m'
+GREEN  = '\033[32m'
+RED    = '\033[31m'
+CYAN   = '\033[36m'
+GRAY   = '\033[90m'
+RESET  = '\033[0m'
+
+_FIELD_TYPE_COLORS = {
+    'AutoField': CYAN, 'BigAutoField': CYAN, 'SmallAutoField': CYAN,
+    'IntegerField': BLUE, 'BigIntegerField': BLUE, 'SmallIntegerField': BLUE,
+    'FloatField': BLUE, 'DecimalField': BLUE,
+    'CharField': YELLOW, 'TextField': YELLOW, 'SlugField': YELLOW,
+    'EmailField': YELLOW, 'URLField': YELLOW,
+    'BooleanField': GREEN, 'NullBooleanField': GREEN,
+    'DateField': CYAN, 'DateTimeField': CYAN, 'TimeField': CYAN,
+    'ForeignKey': GRAY, 'OneToOneField': GRAY, 'ManyToManyField': GRAY,
+}
+
+# Matches any ANSI CSI escape sequence — covers colors, cursor movement,
+# clear-screen codes, etc.  Used to sanitize user-supplied string values
+# before they reach the terminal to prevent terminal injection.
+_ANSI_ESCAPE_RE = re.compile(r'\x1b\[[0-9;]*[A-Za-z]')
+
+
+def _strip_ansi(s: str) -> str:
+    """Remove ANSI escape sequences embedded in a user-supplied string value.
+
+    A database value such as ``"\\033[2J\\033[0;0H"`` would otherwise clear the
+    terminal when printed.  We strip rather than escape because the point is
+    display-only output; the raw data is unmodified in the database.
+    """
+    return _ANSI_ESCAPE_RE.sub('', s)
+
+
+def colorize(value):
+    """Return ANSI-colored string representation of a Python value."""
+    # bool must be checked before int because bool is a subclass of int.
+    if isinstance(value, bool):
+        return f"{GREEN}true{RESET}" if value else f"{RED}false{RESET}"
+    if isinstance(value, (int, float, Decimal)):
+        return f"{BLUE}{value}{RESET}"
+    if isinstance(value, str):
+        # Sanitize before wrapping in color codes so embedded escape sequences
+        # cannot bleed into the terminal (terminal injection prevention).
+        return f'{YELLOW}"{_strip_ansi(value)}"{RESET}'
+    if value is None:
+        return f"{RED}nil{RESET}"
+    # datetime.datetime is a subclass of datetime.date, so both are matched
+    # here.  datetime.time is a separate type and also colored cyan to match
+    # the field-type color for TimeField.
+    if isinstance(value, (datetime.datetime, datetime.date, datetime.time)):
+        return f"{CYAN}{value}{RESET}"
+    return str(value)
+
+
+def _get_fields(obj):
+    """Return list of (attname, value) for concrete fields of a model instance."""
+    return [
+        (field.attname, getattr(obj, field.attname, None))
+        for field in obj.__class__._meta.concrete_fields
+    ]
+
+
+def _format_record(obj):
+    """Format a single model instance as an awesome_print-style string."""
+    cls = obj.__class__
+    header = f"#<{cls.__name__}:{hex(id(obj))}>"
+    fields = _get_fields(obj)
+
+    max_key_len = max((len(name) for name, _ in fields), default=0)
+
+    lines = [f"{header} {{"]
+    for name, value in fields:
+        key = f":{name}".ljust(max_key_len + 1)
+        lines.append(f"    {key} => {colorize(value)},")
+    lines.append("}")
+    return '\n'.join(lines)
+
+
+def _is_queryset_like(obj) -> bool:
+    """Return True if *obj* is a Django QuerySet or a compatible iterable.
+
+    Design:
+    - We prefer a concrete ``isinstance`` check when Django is importable so
+      that objects such as ``ModelForm`` (which has both ``.__iter__`` and
+      ``.model``) are not mistakenly treated as querysets.
+    - A duck-typing fallback is kept so that lightweight test mocks (which
+      carry ``__iter__`` and ``.model`` but are not real QuerySet instances)
+      continue to work without requiring a live Django setup in every test.
+    - The ``not hasattr(obj, '_meta')`` guard prevents a single model
+      instance from being routed into the list path if it ever exposes
+      ``.model`` (uncommon, but possible with custom model mixins).
+    """
+    try:
+        from django.db.models.query import QuerySet
+        if isinstance(obj, QuerySet):
+            return True
+    except ImportError:
+        pass
+
+    # Duck-typing fallback for test mocks and custom queryset-like objects.
+    return (
+        hasattr(obj, '__iter__')
+        and hasattr(obj, 'model')
+        and not hasattr(obj, '_meta')
+    )
+
+
+def ap(obj):
+    """Pretty-print a model instance or queryset in awesome_print style."""
+    if obj is None:
+        print(colorize(None))
+        return
+
+    if _is_queryset_like(obj):
+        _print_queryset(list(obj))
+        return
+
+    # Single model instance
+    if hasattr(obj, '_meta'):
+        print(_format_record(obj))
+        return
+
+    print(repr(obj))
+
+
+def _print_queryset(records):
+    if not records:
+        print("[]")
+        return
+
+    if len(records) == 1:
+        print(_format_record(records[0]))
+        return
+
+    # Precompute the width of the widest index label (e.g. "[99]" = 4 chars)
+    # so that all headers and field lines stay aligned for any result count.
+    max_idx_width = len(f"[{len(records) - 1}]")
+    # Prefix for the record header line: "    [N…] "
+    content_start = 4 + max_idx_width + 1
+    # Field lines are indented 4 more chars than the header start (inside {}).
+    field_indent = " " * (content_start + 4)
+    close_indent = " " * content_start
+
+    print("[")
+    for i, record in enumerate(records):
+        is_last = i == len(records) - 1
+        fields = _get_fields(record)
+        cls = record.__class__
+        header = f"#<{cls.__name__}:{hex(id(record))}>"
+        max_key_len = max((len(name) for name, _ in fields), default=0)
+
+        # Pad the plain label before applying color so ljust counts visible
+        # characters only (ANSI codes are zero-width).
+        idx_label = f"[{i}]".ljust(max_idx_width)
+        idx_colored = f"{GRAY}{idx_label}{RESET}"
+
+        print(f"    {idx_colored} {header} {{")
+        for name, value in fields:
+            key = f":{name}".ljust(max_key_len + 1)
+            print(f"{field_indent}{key} => {colorize(value)},")
+        comma = "" if is_last else ","
+        print(f"{close_indent}}}{comma}")
+    print("]")
+    count = len(records)
+    print(f"{count} records")  # count is always >= 2 here; single records exit early above
+
+
+def format_fields(model_class):
+    """Return a colored schema summary for a model class."""
+    concrete = list(model_class._meta.concrete_fields)
+    m2m = list(model_class._meta.many_to_many)
+
+    all_names = [f.attname for f in concrete] + [f.name for f in m2m]
+    max_name_len = max((len(n) for n in all_names), default=0)
+
+    lines = [f"{CYAN}{model_class.__name__}{RESET} {{"]
+
+    for field in concrete:
+        type_name = field.__class__.__name__
+        color = _FIELD_TYPE_COLORS.get(type_name, RESET)
+        name = f":{field.attname}".ljust(max_name_len + 1)
+        nullable = getattr(field, 'null', False)
+        null_tag = f"  {GRAY}null: true{RESET}" if nullable else ""
+        lines.append(f"    {name}  {color}{type_name}{RESET}{null_tag}")
+
+    for field in m2m:
+        type_name = field.__class__.__name__
+        color = _FIELD_TYPE_COLORS.get(type_name, GRAY)
+        name = f":{field.name}".ljust(max_name_len + 1)
+        lines.append(f"    {name}  {color}{type_name}{RESET}")
+
+    lines.append("}")
+    return '\n'.join(lines)