django-launch-editor 1.0.0__py3-none-any.whl

django_launch_editor/__init__.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import itertools
+import linecache
+from pathlib import Path
+from typing import Any
+
+from django.conf import settings
+from django.http import HttpRequest
+from django.urls import NoReverseMatch, reverse
+from django.utils.html import format_html, json_script
+from django.utils.safestring import SafeString, mark_safe
+from django.views.debug import ExceptionReporter
+
+from django_launch_editor.tokens import make_token
+
+SCRIPT = (Path(__file__).parent / "launch-editor.js").read_text(encoding="utf-8")
+
+STYLE = """
+button.django-launch-editor {
+  background: none; border: none; padding: 0; margin: 0;
+  font: inherit; color: inherit; text-align: inherit;
+  text-decoration: underline; cursor: pointer;
+  &:hover { text-decoration-thickness: 2px; }
+  & .fname { user-select: text; }
+  &:disabled { cursor: progress; }
+}
+.django-launch-editor-status {
+  color: #666;
+  &.error { color: #c00; }
+}
+dialog.django-launch-editor-dialog {
+  margin: auto; max-width: 40em; padding: 1.5em;
+  border: 1px solid #ccc; border-radius: 6px;
+  &::backdrop { background: rgba(0, 0, 0, 0.4); }
+  & h2 { margin: 0 0 0.5em; }
+  & p { margin: 0 0 0.5em; }
+  & code {
+    display: flow-root; padding: 0.5em; background: #f0f0f0;
+    overflow-wrap: anywhere; user-select: all;
+    &[hidden] { display: none; }
+  }
+  & .django-launch-editor-copy {
+    float: left; margin: 0 0.5em 0 0; padding: 0.4em;
+    line-height: 0; cursor: pointer;
+  }
+  & form {
+    clear: both; margin-top: 1em; text-align: right;
+    & button { padding: 0.4em 1.2em; font: inherit; cursor: pointer; }
+  }
+}
+"""
+
+BANNER_STYLE = """
+#django-launch-editor-banner { padding: 10px 20px; background: #fec; border-bottom: 1px solid #ccc; }
+#django-launch-editor-banner code { font-size: 100%; }
+"""
+
+
+class LaunchEditorExceptionReporter(ExceptionReporter):
+    """
+    Exception reporter that makes file locations on the debug error page into
+    links that open them in the user’s editor.
+    """
+
+    def get_traceback_data(self) -> dict[str, Any]:
+        data = super().get_traceback_data()
+        # Keep the data for get_traceback_html(), rather than computing it
+        # twice.
+        self._launch_editor_data: dict[str, Any] = data
+        return data
+
+    def get_traceback_html(self) -> SafeString:
+        html = super().get_traceback_html()
+        return self.add_launch_editor(html, self._launch_editor_data)
+
+    def add_launch_editor(self, html: SafeString, data: dict[str, Any]) -> SafeString:
+        # Never add links to error emails, or when DEBUG is off, since the
+        # view will not work then.
+        if not settings.DEBUG or self.is_email or self.request is None:
+            return html
+
+        frames = [
+            make_token(frame["filename"], frame["lineno"], frame_column(frame))
+            if frame["tb"] is not None
+            else None
+            for frame in data["frames"]
+        ]
+
+        template_info = data["template_info"]
+        if template_info:
+            template = make_token(template_info["name"], template_info["line"])
+        else:
+            template = None
+
+        return add_launch_editor(
+            html, self.request, {"frames": frames, "template": template}
+        )
+
+
+def frame_column(frame: dict[str, Any]) -> int | None:
+    """
+    Return the 1-based column where the frame’s current expression starts, if
+    it’s on the frame’s line.
+    """
+    tb = frame["tb"]
+    start_line, _, start_column, _ = next(
+        itertools.islice(tb.tb_frame.f_code.co_positions(), tb.tb_lasti // 2, None),
+        (None, None, None, None),
+    )
+    if start_line != frame["lineno"] or start_column is None:
+        return None
+
+    # Positions are UTF-8 byte offsets, but editors count characters.
+    source_line = linecache.getline(frame["filename"], frame["lineno"])
+    if not source_line:
+        return None
+    prefix = source_line.encode()[:start_column]
+    return len(prefix.decode(errors="replace")) + 1
+
+
+def add_launch_editor(
+    html: SafeString, request: HttpRequest, config: dict[str, Any]
+) -> SafeString:
+    """
+    Add the script that makes file locations into links to a debug page, or a
+    banner explaining how to install the URLs if they’re missing.
+    """
+    try:
+        url = reverse("django_launch_editor:launch")
+    except NoReverseMatch:
+        return insert(html, "</header>", banner_html(request), before=False)
+
+    config = {"url": url, "frames": [], "template": None, **config}
+    return insert(
+        html,
+        "</body>",
+        f"<style>{STYLE}</style>"
+        + json_script(config, "django-launch-editor-data")
+        + f"<script>{SCRIPT}</script>",
+        before=True,
+    )
+
+
+def banner_html(request: HttpRequest) -> str:
+    urlconf = getattr(request, "urlconf", None) or settings.ROOT_URLCONF
+    if not isinstance(urlconf, str):
+        urlconf = urlconf.__name__
+    return format_html(
+        "<style>{}</style>"
+        + '<div id="django-launch-editor-banner" role="note">'
+        + "<strong>django-launch-editor</strong> cannot make file locations "
+        + "into links, because its URLs are not installed. Add "
+        + '<code>path("__launch_editor__/", '
+        + 'include("django_launch_editor.urls"))</code> '
+        + "to <code>urlpatterns</code> in <code>{}</code>."
+        + "</div>",
+        mark_safe(BANNER_STYLE),
+        urlconf,
+    )
+
+
+def insert(html: SafeString, marker: str, extra: str, *, before: bool) -> SafeString:
+    """
+    Insert extra HTML before the last occurrence of marker, or after the first
+    one, or return the HTML unchanged if marker is not found.
+    """
+    if before:
+        head, found, tail = html.rpartition(marker)
+        if found:
+            return mark_safe(head + extra + found + tail)
+    else:
+        head, found, tail = html.partition(marker)
+        if found:
+            return mark_safe(head + found + extra + tail)
+    return html

django_launch_editor/launch-editor.js

@@ -0,0 +1,201 @@
+(function () {
+  'use strict'
+
+  const data = JSON.parse(
+    document.getElementById('django-launch-editor-data').textContent
+  )
+
+  async function openInEditor (button, status, token) {
+    button.disabled = true
+    status.className = 'django-launch-editor-status'
+    status.textContent = 'Opening…'
+
+    const body = new FormData()
+    body.append('token', token)
+    let error = null
+    try {
+      const response = await fetch(data.url, {
+        method: 'POST',
+        body,
+        mode: 'same-origin',
+        credentials: 'same-origin'
+      })
+      const contentType = response.headers.get('Content-Type') ?? ''
+      const json = contentType.startsWith('application/json')
+        ? await response.json()
+        : {}
+      if (response.status === 200 && typeof json.location === 'string') {
+        // No editor was found, so the location to copy was sent instead.
+        showLocation(json)
+      } else if (response.status !== 204) {
+        if (typeof json.error === 'string') {
+          error = json.error
+        } else if (response.redirected) {
+          error = `Request was redirected to ${response.url}.`
+        } else {
+          error = `Request failed with status ${response.status}.`
+        }
+      }
+    } catch (exc) {
+      error = `Request failed: ${exc.message}`
+    }
+
+    button.disabled = false
+    if (error === null) {
+      status.textContent = ''
+    } else {
+      status.classList.add('error')
+      status.textContent = error
+    }
+  }
+
+  const COPY_ICON =
+    '<svg viewBox="0 0 24 24" width="16" height="16" fill="none" ' +
+    'stroke="currentColor" stroke-width="2" stroke-linecap="round" ' +
+    'stroke-linejoin="round" aria-hidden="true">' +
+    '<path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>' +
+    '<rect width="13" height="13" x="9" y="9" rx="2"/>' +
+    '</svg>'
+
+  let dialog = null
+
+  function getDialog () {
+    if (dialog === null) {
+      dialog = document.createElement('dialog')
+      dialog.className = 'django-launch-editor-dialog'
+      dialog.setAttribute('closedby', 'any')
+      dialog.setAttribute('aria-labelledby', 'django-launch-editor-title')
+
+      const title = document.createElement('h2')
+      title.id = 'django-launch-editor-title'
+      title.textContent = 'Running editor not detected'
+
+      const copyButton = document.createElement('button')
+      copyButton.type = 'button'
+      copyButton.className = 'django-launch-editor-copy'
+      copyButton.title = 'Copy to clipboard'
+      copyButton.setAttribute('aria-label', 'Copy to clipboard')
+      copyButton.innerHTML = COPY_ICON
+      copyButton.addEventListener('click', async () => {
+        const code = dialog.querySelector('code')
+        // Called directly from the click, so browsers like Safari allow it.
+        try {
+          await navigator.clipboard.writeText(code.textContent)
+        } catch {
+          window.getSelection().selectAllChildren(code)
+        }
+      })
+
+      const form = document.createElement('form')
+      form.method = 'dialog'
+      const button = document.createElement('button')
+      button.textContent = 'OK'
+      button.autofocus = true
+      form.append(button)
+
+      dialog.append(
+        title,
+        document.createElement('p'),
+        copyButton,
+        document.createElement('code'),
+        form
+      )
+      document.body.append(dialog)
+    }
+    return dialog
+  }
+
+  async function showLocation ({ location, relative }) {
+    let copied = false
+    try {
+      await navigator.clipboard.writeText(location)
+      copied = true
+    } catch {
+      // The clipboard is unavailable, for example on an insecure origin.
+    }
+
+    const description = relative ? 'Relative path' : 'Path'
+    const dialog = getDialog()
+    dialog.querySelector('p').textContent = copied
+      ? `${description} with line number copied to clipboard.`
+      : `Copy the ${description.toLowerCase()} with line number:`
+    const code = dialog.querySelector('code')
+    code.textContent = location
+    code.hidden = copied
+    dialog.querySelector('.django-launch-editor-copy').hidden = copied
+    dialog.showModal()
+  }
+
+  // Wrap the given nodes, such as the filename and line number, in a
+  // button. Show the status after any text that follows, such as “, in view”.
+  function addButton (nodes, token) {
+    if (token === null) {
+      return
+    }
+
+    const button = document.createElement('button')
+    button.type = 'button'
+    button.className = 'django-launch-editor'
+    button.title = 'Open in editor'
+    nodes[0].before(button)
+    button.append(...nodes)
+
+    const status = document.createElement('span')
+    status.className = 'django-launch-editor-status'
+    status.setAttribute('role', 'status')
+    const rest = button.nextSibling
+    if (rest?.nodeType === Node.TEXT_NODE) {
+      rest.textContent = rest.textContent.trimEnd()
+      rest.after(' ', status)
+    } else {
+      button.after(' ', status)
+    }
+
+    button.addEventListener('click', (event) => {
+      event.stopPropagation()
+      openInEditor(button, status, token)
+    })
+  }
+
+  // Return the filename element plus the following “, line 12” text.
+  function filenameAndLine (element) {
+    const text = element.nextSibling
+    if (text?.nodeType === Node.TEXT_NODE) {
+      const match = text.textContent.match(/^, line \d+/)
+      if (match !== null) {
+        text.splitText(match[0].length)
+        return [element, text]
+      }
+    }
+    return [element]
+  }
+
+  const frames = document.querySelectorAll('#browserTraceback li.frame')
+  // Frames are matched up by position, so give up if Django’s template has
+  // changed in a way that breaks that.
+  if (frames.length === data.frames.length) {
+    frames.forEach((frame, index) => {
+      const fname = frame.querySelector(':scope > code.fname')
+      if (fname !== null) {
+        addButton(filenameAndLine(fname), data.frames[index])
+      }
+    })
+    const fname = document.querySelector('#summary .fname')
+    if (fname !== null && data.frames.length > 0) {
+      addButton(filenameAndLine(fname), data.frames[data.frames.length - 1])
+    }
+  }
+
+  // Template errors read “In template <code>name</code>, error at line
+  // <strong>12</strong>”.
+  const templateName = document.querySelector('#template p > code')
+  if (templateName !== null) {
+    const nodes = [templateName]
+    const text = templateName.nextSibling
+    const line = text?.nextSibling
+    if (text?.nodeType === Node.TEXT_NODE && line?.nodeName === 'STRONG') {
+      nodes.push(text, line)
+    }
+    addButton(nodes, data.template)
+  }
+})()

django_launch_editor/tokens.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import os
+
+from django.core import signing
+
+SALT = "django_launch_editor"
+
+# Tokens are only valid for this long, to limit how long a leaked one can be
+# used for.
+MAX_AGE = 60 * 60 * 24  # seconds
+
+
+def make_token(filename: str, line: int, column: int | None = None) -> str | None:
+    """
+    Return a signed token that allows opening the given file at the given
+    line and column, or None if the file cannot be opened.
+    """
+    if not os.path.isfile(filename):
+        return None
+    return signing.dumps([filename, line, column], salt=SALT)
+
+
+def load_token(token: str) -> tuple[str, int, int | None]:
+    """
+    Return the filename, line, and column from a token made by make_token().
+    Raises django.core.signing.BadSignature if the token is invalid or has
+    expired.
+    """
+    payload = signing.loads(token, salt=SALT, max_age=MAX_AGE)
+    try:
+        filename, line, column = payload
+    except (TypeError, ValueError) as exc:
+        # Such as a token from an older version, without a column.
+        raise signing.BadSignature("Invalid token payload.") from exc
+    return filename, line, column

django_launch_editor/urls.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from django.urls import path
+
+from django_launch_editor import views
+
+app_name = "django_launch_editor"
+
+urlpatterns = [
+    path("launch/", views.launch, name="launch"),
+]

django_launch_editor/views.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import os
+from http import HTTPStatus
+
+from django.conf import settings
+from django.contrib.auth.decorators import login_not_required
+from django.core.signing import BadSignature
+from django.http import Http404, HttpRequest, HttpResponse, JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_POST
+from launch_editor import LaunchEditorError, guess_editor, launch_editor
+
+from django_launch_editor.tokens import load_token
+
+
+# Exempt from CsrfViewMiddleware, since its cookie may not have been set on
+# the error page, such as for errors raised in middleware before it. Instead,
+# cross-site requests are blocked with is_same_origin().
+@csrf_exempt
+@login_not_required
+def launch(request: HttpRequest) -> HttpResponse:
+    # Check DEBUG first, so nothing else about the view is revealed when it’s
+    # off.
+    if not settings.DEBUG:
+        raise Http404()
+    return _launch(request)
+
+
+@require_POST
+def _launch(request: HttpRequest) -> HttpResponse:
+    if not is_same_origin(request):
+        return JsonResponse(
+            {"error": "Cross-origin requests are not allowed."},
+            status=HTTPStatus.FORBIDDEN,
+        )
+
+    # Only files and lines that were signed when rendering a debug page can
+    # be opened, rather than any file the client asks for.
+    try:
+        filename, line, column = load_token(request.POST.get("token", ""))
+    except BadSignature:
+        return JsonResponse(
+            {"error": "Invalid or expired token. Reload the page and try again."},
+            status=HTTPStatus.BAD_REQUEST,
+        )
+
+    # Skip terminal editors, which would take over the server’s terminal.
+    editor = guess_editor(terminal=False)
+    if not editor:
+        # Send the location back, for the page to copy to the clipboard.
+        location = relative_path(filename)
+        return JsonResponse(
+            {
+                "location": f"{location}:{line}",
+                "relative": not os.path.isabs(location),
+            }
+        )
+
+    try:
+        launch_editor(filename, line, column, editor=editor)
+    except LaunchEditorError as exc:
+        return JsonResponse(
+            {"error": str(exc)},
+            status=HTTPStatus.INTERNAL_SERVER_ERROR,
+        )
+
+    return HttpResponse(status=HTTPStatus.NO_CONTENT)
+
+
+def relative_path(filename: str) -> str:
+    """
+    Return the filename relative to the current directory, which is normally
+    the project root, or unchanged if it’s outside it.
+    """
+    try:
+        relative = os.path.relpath(filename)
+    except ValueError:  # On a different drive on Windows
+        return filename
+    if relative.startswith(os.pardir + os.sep):
+        return filename
+    return relative
+
+
+def is_same_origin(request: HttpRequest) -> bool:
+    """
+    Check the request came from a page on the same origin, using headers that
+    browsers set and pages cannot forge. Browsers send Sec-Fetch-Site on all
+    requests, and Origin on all POST requests, so require one of them.
+    """
+    sec_fetch_site = request.headers.get("Sec-Fetch-Site")
+    if sec_fetch_site is not None:
+        return sec_fetch_site == "same-origin"
+
+    origin = request.headers.get("Origin")
+    if origin is not None:
+        return origin == f"{request.scheme}://{request.get_host()}"
+
+    return False

django_launch_editor-1.0.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: django-launch-editor
+Version: 1.0.0
+Summary: Open files from Django’s debug error page in your editor.
+Keywords: Django,editor,launch-editor,open-in-editor
+Author: Adam Johnson
+Author-email: Adam Johnson <me@adamj.eu>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Typing :: Typed
+Requires-Dist: django>=5.2
+Requires-Dist: launch-editor-py>=1
+Requires-Python: >=3.11
+Project-URL: Changelog, https://github.com/adamchainz/django-launch-editor/blob/main/CHANGELOG.rst
+Project-URL: Funding, https://adamj.eu/books/
+Project-URL: Repository, https://github.com/adamchainz/django-launch-editor
+Description-Content-Type: text/x-rst
+
+====================
+django-launch-editor
+====================
+
+.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/django-launch-editor/main.yml.svg?branch=main&style=for-the-badge
+   :target: https://github.com/adamchainz/django-launch-editor/actions?workflow=CI
+
+.. image:: https://img.shields.io/badge/Coverage-100%25-success?style=for-the-badge
+   :target: https://github.com/adamchainz/django-launch-editor/actions?workflow=CI
+
+.. image:: https://img.shields.io/pypi/v/django-launch-editor.svg?style=for-the-badge
+   :target: https://pypi.org/project/django-launch-editor/
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge
+   :target: https://github.com/psf/black
+
+.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge
+   :target: https://github.com/pre-commit/pre-commit
+   :alt: pre-commit
+
+----
+
+Open files from Django’s debug error page in your editor.
+
+Makes the file locations on Django’s debug error page, like “/path/to/views.py, line 8”, into links that open the file at that line in your editor, using `launch-editor-py <https://github.com/adamchainz/launch-editor-py>`__.
+
+
+.. figure:: https://raw.githubusercontent.com/adamchainz/django-launch-editor/main/screenshot.png
+   :alt: django-launch-editor screenshot
+
+----
+
+**Improve your Django and Git skills** with `my books <https://adamj.eu/books/>`__.
+
+----
+
+Requirements
+------------
+
+Python 3.11 to 3.15 supported.
+
+Django 5.2 to 6.1 supported.
+
+Installation
+------------
+
+1. Install with **pip**:
+
+   .. code-block:: sh
+
+       python -m pip install django-launch-editor
+
+2. Set Django’s exception reporter class, in your settings file:
+
+   .. code-block:: python
+
+       DEFAULT_EXCEPTION_REPORTER = "django_launch_editor.LaunchEditorExceptionReporter"
+
+   If you already use a custom exception reporter, make it subclass ``LaunchEditorExceptionReporter``.
+
+3. Include the app URLs in your root URLconf:
+
+   .. code-block:: python
+
+       from django.urls import include, path
+
+       urlpatterns = [
+           ...,
+           path("__launch_editor__/", include("django_launch_editor.urls")),
+       ]
+
+   You can use another prefix if required.
+
+That’s it! 🎉
+
+Trigger an error while you have ``DEBUG = True``, and click the file location of any traceback frame, or template error, to open it in your editor.
+Where Python knows it, the editor opens at the column of the expression that failed, too.
+
+Editor selection
+----------------
+
+django-launch-editor attempts to detect a running non-terminal editor with `launch-editor-py <https://github.com/adamchainz/launch-editor-py>`__.
+If none is detected, it falls back to showing a dialog for copying the clicked file path to your clipboard.
+
+Because django-launch-editor runs within the Django server, it can only launch an editor when you run Django on your development machine, not in a container or on a remote server.
+Similarly, it must skip terminal editors like Vim, since they would take over the terminal running Django.
+
+For information on how the editor is picked, or how to override it, see `the launch-editor-py documentation <https://github.com/adamchainz/launch-editor-py>`__.
+
+If no editor is found, django-launch-editor falls back to showing a dialog headed “Running editor not detected”, and copying the file location to your clipboard:
+
+
+.. figure:: https://raw.githubusercontent.com/adamchainz/django-launch-editor/main/screenshot-dialog-copied.png
+   :alt: Screenshot showing dialog with copied file location
+
+The location has the form ``path:line``, such as ``myapp/views.py:8``.
+
+If the browser blocks the automatic copy, the dialog shows a copy icon button to the left of the location:
+
+.. figure:: https://raw.githubusercontent.com/adamchainz/django-launch-editor/main/screenshot-dialog-manual.png
+   :alt: Screenshot showing dialog with manual fallback
+
+
+Security
+--------
+
+Opening files runs a program on the server, so the package takes several precautions:
+
+* The whole process only works when ``DEBUG`` is ``True``.
+
+* Links are never added to error emails.
+
+* The view only accepts ``POST`` requests from pages on the same origin, checked with the ``Sec-Fetch-Site`` or ``Origin`` headers that browsers send.
+  This blocks cross-site request forgery without relying on ``CsrfViewMiddleware``’s cookie, which may not be set on the error page.
+
+* The view doesn’t accept arbitrary file paths.
+  Instead, each link carries a token, signed with your ``SECRET_KEY``, for a file and line that appeared on a debug page.
+  Tokens are only made for files that exist, and expire after 24 hours.
+
+Example project
+---------------
+
+To try django-launch-editor, there is an example project included in the repository.
+Open |the example directory|__, follow the instructions in its README, and try it out.
+
+.. |the example directory| replace:: the ``example/`` directory
+__ https://github.com/adamchainz/django-launch-editor/tree/main/example
+
+How it works
+------------
+
+``LaunchEditorExceptionReporter`` extends Django’s ``ExceptionReporter`` to add a small script to the HTML debug page, along with signed tokens for each traceback frame.
+The script turns file locations into buttons, styled as links, that ``POST`` a token to the view, which checks it and calls ``launch_editor()``.

django_launch_editor-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+django_launch_editor/__init__.py,sha256=F87_13vscnk6C6NBlNdUqA_lMbBFk8ndIjyHB1efMDE,5920
+django_launch_editor/launch-editor.js,sha256=suIQNARtH9TLImCBsGllIVawdAKbnckagpYDNUu4cMg,6574
+django_launch_editor/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_launch_editor/tokens.py,sha256=GoKbGCLtlM9TcA42k7mAzs5lfAxwsiMJMXDMpzzx1BE,1156
+django_launch_editor/urls.py,sha256=-ArRi3vpUuX1RBSQ9205FCKOtObG8a0k9IqBWp_Az90,209
+django_launch_editor/views.py,sha256=-6kZUQrRPw28cX4GOKFa3e7DVdlSOnIoj6ujobOxId8,3373
+django_launch_editor-1.0.0.dist-info/licenses/LICENSE,sha256=blVuFA7Qdp2_CcTyGXLxA4CsHsAjAquxVc4O6ODqye4,1069
+django_launch_editor-1.0.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+django_launch_editor-1.0.0.dist-info/METADATA,sha256=aledvjgXBQofgKhj7D5b3uNjM-DcrsiairnGxoOKkIA,6737
+django_launch_editor-1.0.0.dist-info/RECORD,,

django_launch_editor-1.0.0.dist-info/WHEEL

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

django_launch_editor-1.0.0.dist-info/licenses/LICENSE

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