python-fasthtml 0.14.5__tar.gz → 0.14.7__tar.gz

python_fasthtml-0.14.7/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: python-fasthtml
+Version: 0.14.7
+Summary: The fastest way to create an HTML app
+Author-email: Jeremy Howard and contributors <github@jhoward.fastmail.fm>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/fasthtml
+Project-URL: Documentation, https://www.fastht.ml/docs/
+Keywords: nbdev,jupyter,notebook,python
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastcore>=2.1.2
+Requires-Dist: python-dateutil
+Requires-Dist: starlette>=1.0.1
+Requires-Dist: oauthlib
+Requires-Dist: itsdangerous
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: httpx2
+Requires-Dist: fastlite>=0.1.1
+Requires-Dist: python-multipart
+Requires-Dist: beautifulsoup4
+Provides-Extra: dev
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: lxml; extra == "dev"
+Requires-Dist: pysym2md>=0.0.6; extra == "dev"
+Requires-Dist: monsterui; extra == "dev"
+Requires-Dist: PyJWT; extra == "dev"
+Dynamic: license-file
+
+# FastHTML
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+Welcome to the official FastHTML documentation.
+
+FastHTML is a new next-generation web framework for fast, scalable web applications with minimal, compact code. It’s designed to be:
+
+- Powerful and expressive enough to build the most advanced, interactive web apps you can imagine.
+- Fast and lightweight, so you can write less code and get more done.
+- Easy to learn and use, with a simple, intuitive syntax that makes it easy to build complex apps quickly.
+
+FastHTML apps are just Python code, so you can use FastHTML with the full power of the Python language and ecosystem. FastHTML’s functionality maps 1:1 directly to HTML and HTTP, but allows them to be encapsulated using good software engineering practices—so you’ll need to understand these foundations to use this library fully. To understand how and why this works, please read this first: [fastht.ml/about](https://fastht.ml/about).
+
+## Installation
+
+Since `fasthtml` is a Python library, you can install it with:
+
+``` sh
+pip install python-fasthtml
+```
+
+In the near future, we hope to add component libraries that can likewise be installed via `pip`.
+
+## Usage
+
+For a minimal app, create a file “main.py” as follows:
+
+<div class="code-with-filename">
+
+**main.py**
+
+``` python
+from fasthtml.common import *
+
+app,rt = fast_app()
+
+@rt('/')
+def get(): return Div(P('Hello World!'), hx_get="/change")
+
+serve()
+```
+
+</div>
+
+Running the app with `python main.py` prints out a link to your running app: `http://localhost:5001`. Visit that link in your browser and you should see a page with the text “Hello World!”. Congratulations, you’ve just created your first FastHTML app!
+
+Adding interactivity is surprisingly easy, thanks to HTMX. Modify the file to add this function:
+
+<div class="code-with-filename">
+
+**main.py**
+
+``` python
+@rt('/change')
+def get(): return P('Nice to be here!')
+```
+
+</div>
+
+You now have a page with a clickable element that changes the text when clicked. When clicking on this link, the server will respond with an “HTML partial”—that is, just a snippet of HTML which will be inserted into the existing page. In this case, the returned element will replace the original P element (since that’s the default behavior of HTMX) with the new version returned by the second route.
+
+This “hypermedia-based” approach to web development is a powerful way to build web applications.
+
+### Getting help from AI
+
+Because FastHTML is newer than most LLMs, AI systems like Cursor, ChatGPT, Claude, and Copilot won’t give useful answers about it. To fix that problem, we’ve provided an LLM-friendly guide that teaches them how to use FastHTML. To use it, add this link for your AI helper to use:
+
+- [/llms-ctx.txt](https://www.fastht.ml/docs/llms-ctx.txt)
+
+This example is in a format based on recommendations from Anthropic for use with [Claude Projects](https://support.anthropic.com/en/articles/9517075-what-are-projects). This works so well that we’ve actually found that Claude can provide even better information than our own documentation! For instance, read through [this annotated Claude chat](https://gist.github.com/jph00/9559b0a563f6a370029bec1d1cc97b74) for some great getting-started information, entirely generated from a project using the above text file as context.
+
+If you use Cursor, type `@doc` then choose “*Add new doc*”, and use the /llms-ctx.txt link above. The context file is auto-generated from our [`llms.txt`](https://llmstxt.org/) (our proposed standard for providing AI-friendly information)—you can generate alternative versions suitable for other models as needed.
+
+## Next Steps
+
+Start with the official sources to learn more about FastHTML:
+
+- [About](https://fastht.ml/about): Learn about the core ideas behind FastHTML
+- [Documentation](https://www.fastht.ml/docs): Learn from examples how to write FastHTML code
+- [Idiomatic app](https://github.com/AnswerDotAI/fasthtml/blob/main/examples/adv_app.py): Heavily commented source code walking through a complete application, including custom authentication, JS library connections, and database use.
+
+We also have a 1-hour intro video:
+
+<https://www.youtube.com/embed/Auqrm7WFc0I>
+
+The capabilities of FastHTML are vast and growing, and not all the features and patterns have been documented yet. Be prepared to invest time into studying and modifying source code, such as the main FastHTML repo’s notebooks and the official FastHTML examples repo:
+
+- [FastHTML Examples Repo on GitHub](https://github.com/AnswerDotAI/fasthtml-example)
+- [FastHTML Repo on GitHub](https://github.com/AnswerDotAI/fasthtml)
+
+Then explore the small but growing third-party ecosystem of FastHTML tutorials, notebooks, libraries, and components:
+
+- [FastHTML Gallery](https://gallery.fastht.ml): Learn from minimal examples of components (ie chat bubbles, click-to-edit, infinite scroll, etc)
+- [Creating Custom FastHTML Tags for Markdown Rendering](https://isaac-flath.github.io/website/posts/boots/FasthtmlTutorial.html) by Isaac Flath
+- [How to Build a Simple Login System in FastHTML](https://blog.mariusvach.com/posts/login-fasthtml) by Marius Vach
+- Your tutorial here!
+
+Finally, join the FastHTML community to ask questions, share your work, and learn from others:
+
+- [Discord](https://discord.gg/qcXvcxMhdP)
+
+## Other languages and related projects
+
+If you’re not a Python user, or are keen to try out a new language, we’ll list here other projects that have a similar approach to FastHTML. (Please reach out if you know of any other projects that you’d like to see added.)
+
+- [htmgo](https://htmgo.dev/) (Go): “*htmgo is a lightweight pure go way to build interactive websites / web applications using go & htmx. By combining the speed & simplicity of go + hypermedia attributes (htmx) to add interactivity to websites, all conveniently wrapped in pure go, you can build simple, fast, interactive websites without touching javascript. All compiled to a single deployable binary*”
+
+If you’re just interested in functional HTML components, rather than a full HTMX server solution, consider:
+
+- [fastcore.xml.FT](https://fastcore.fast.ai/xml.html): This is actually what FastHTML uses behind the scenes
+- [htpy](https://htpy.dev/): Similar to [`fastcore.xml.FT`](https://fastcore.fast.ai/xml.html#ft), but with a somewhat different syntax
+- [elm-html](https://package.elm-lang.org/packages/elm/html/latest/): Elm’s built-in HTML library with a type-safe functional approach
+- [hiccup](https://github.com/weavejester/hiccup): Popular library for representing HTML in Clojure using vectors
+- [hiccl](https://github.com/garlic0x1/hiccl): HTML generation library for Common Lisp inspired by Clojure’s Hiccup
+- [Falco.Markup](https://github.com/pimbrouwers/Falco): F# HTML DSL and web framework with type-safe HTML generation
+- [Lucid](https://github.com/chrisdone/lucid): Type-safe HTML generation for Haskell using monad transformers
+- [dream-html](https://github.com/aantron/dream): Part of the Dream web framework for OCaml, provides type-safe HTML templating
+
+For other hypermedia application platforms, not based on HTMX, take a look at:
+
+- [Hotwire/Turbo](https://turbo.hotwired.dev/): Rails-oriented framework that similarly uses HTML-over-the-wire
+- [LiveView](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html): Phoenix framework’s solution for building interactive web apps with minimal JavaScript
+- [Unpoly](https://unpoly.com/): Another HTML-over-the-wire framework with progressive enhancement
+- [Livewire](https://laravel-livewire.com/): Laravel’s take on building dynamic interfaces with minimal JavaScript

python_fasthtml-0.14.7/README.md

@@ -0,0 +1,126 @@
+# FastHTML
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+Welcome to the official FastHTML documentation.
+
+FastHTML is a new next-generation web framework for fast, scalable web applications with minimal, compact code. It’s designed to be:
+
+- Powerful and expressive enough to build the most advanced, interactive web apps you can imagine.
+- Fast and lightweight, so you can write less code and get more done.
+- Easy to learn and use, with a simple, intuitive syntax that makes it easy to build complex apps quickly.
+
+FastHTML apps are just Python code, so you can use FastHTML with the full power of the Python language and ecosystem. FastHTML’s functionality maps 1:1 directly to HTML and HTTP, but allows them to be encapsulated using good software engineering practices—so you’ll need to understand these foundations to use this library fully. To understand how and why this works, please read this first: [fastht.ml/about](https://fastht.ml/about).
+
+## Installation
+
+Since `fasthtml` is a Python library, you can install it with:
+
+``` sh
+pip install python-fasthtml
+```
+
+In the near future, we hope to add component libraries that can likewise be installed via `pip`.
+
+## Usage
+
+For a minimal app, create a file “main.py” as follows:
+
+<div class="code-with-filename">
+
+**main.py**
+
+``` python
+from fasthtml.common import *
+
+app,rt = fast_app()
+
+@rt('/')
+def get(): return Div(P('Hello World!'), hx_get="/change")
+
+serve()
+```
+
+</div>
+
+Running the app with `python main.py` prints out a link to your running app: `http://localhost:5001`. Visit that link in your browser and you should see a page with the text “Hello World!”. Congratulations, you’ve just created your first FastHTML app!
+
+Adding interactivity is surprisingly easy, thanks to HTMX. Modify the file to add this function:
+
+<div class="code-with-filename">
+
+**main.py**
+
+``` python
+@rt('/change')
+def get(): return P('Nice to be here!')
+```
+
+</div>
+
+You now have a page with a clickable element that changes the text when clicked. When clicking on this link, the server will respond with an “HTML partial”—that is, just a snippet of HTML which will be inserted into the existing page. In this case, the returned element will replace the original P element (since that’s the default behavior of HTMX) with the new version returned by the second route.
+
+This “hypermedia-based” approach to web development is a powerful way to build web applications.
+
+### Getting help from AI
+
+Because FastHTML is newer than most LLMs, AI systems like Cursor, ChatGPT, Claude, and Copilot won’t give useful answers about it. To fix that problem, we’ve provided an LLM-friendly guide that teaches them how to use FastHTML. To use it, add this link for your AI helper to use:
+
+- [/llms-ctx.txt](https://www.fastht.ml/docs/llms-ctx.txt)
+
+This example is in a format based on recommendations from Anthropic for use with [Claude Projects](https://support.anthropic.com/en/articles/9517075-what-are-projects). This works so well that we’ve actually found that Claude can provide even better information than our own documentation! For instance, read through [this annotated Claude chat](https://gist.github.com/jph00/9559b0a563f6a370029bec1d1cc97b74) for some great getting-started information, entirely generated from a project using the above text file as context.
+
+If you use Cursor, type `@doc` then choose “*Add new doc*”, and use the /llms-ctx.txt link above. The context file is auto-generated from our [`llms.txt`](https://llmstxt.org/) (our proposed standard for providing AI-friendly information)—you can generate alternative versions suitable for other models as needed.
+
+## Next Steps
+
+Start with the official sources to learn more about FastHTML:
+
+- [About](https://fastht.ml/about): Learn about the core ideas behind FastHTML
+- [Documentation](https://www.fastht.ml/docs): Learn from examples how to write FastHTML code
+- [Idiomatic app](https://github.com/AnswerDotAI/fasthtml/blob/main/examples/adv_app.py): Heavily commented source code walking through a complete application, including custom authentication, JS library connections, and database use.
+
+We also have a 1-hour intro video:
+
+<https://www.youtube.com/embed/Auqrm7WFc0I>
+
+The capabilities of FastHTML are vast and growing, and not all the features and patterns have been documented yet. Be prepared to invest time into studying and modifying source code, such as the main FastHTML repo’s notebooks and the official FastHTML examples repo:
+
+- [FastHTML Examples Repo on GitHub](https://github.com/AnswerDotAI/fasthtml-example)
+- [FastHTML Repo on GitHub](https://github.com/AnswerDotAI/fasthtml)
+
+Then explore the small but growing third-party ecosystem of FastHTML tutorials, notebooks, libraries, and components:
+
+- [FastHTML Gallery](https://gallery.fastht.ml): Learn from minimal examples of components (ie chat bubbles, click-to-edit, infinite scroll, etc)
+- [Creating Custom FastHTML Tags for Markdown Rendering](https://isaac-flath.github.io/website/posts/boots/FasthtmlTutorial.html) by Isaac Flath
+- [How to Build a Simple Login System in FastHTML](https://blog.mariusvach.com/posts/login-fasthtml) by Marius Vach
+- Your tutorial here!
+
+Finally, join the FastHTML community to ask questions, share your work, and learn from others:
+
+- [Discord](https://discord.gg/qcXvcxMhdP)
+
+## Other languages and related projects
+
+If you’re not a Python user, or are keen to try out a new language, we’ll list here other projects that have a similar approach to FastHTML. (Please reach out if you know of any other projects that you’d like to see added.)
+
+- [htmgo](https://htmgo.dev/) (Go): “*htmgo is a lightweight pure go way to build interactive websites / web applications using go & htmx. By combining the speed & simplicity of go + hypermedia attributes (htmx) to add interactivity to websites, all conveniently wrapped in pure go, you can build simple, fast, interactive websites without touching javascript. All compiled to a single deployable binary*”
+
+If you’re just interested in functional HTML components, rather than a full HTMX server solution, consider:
+
+- [fastcore.xml.FT](https://fastcore.fast.ai/xml.html): This is actually what FastHTML uses behind the scenes
+- [htpy](https://htpy.dev/): Similar to [`fastcore.xml.FT`](https://fastcore.fast.ai/xml.html#ft), but with a somewhat different syntax
+- [elm-html](https://package.elm-lang.org/packages/elm/html/latest/): Elm’s built-in HTML library with a type-safe functional approach
+- [hiccup](https://github.com/weavejester/hiccup): Popular library for representing HTML in Clojure using vectors
+- [hiccl](https://github.com/garlic0x1/hiccl): HTML generation library for Common Lisp inspired by Clojure’s Hiccup
+- [Falco.Markup](https://github.com/pimbrouwers/Falco): F# HTML DSL and web framework with type-safe HTML generation
+- [Lucid](https://github.com/chrisdone/lucid): Type-safe HTML generation for Haskell using monad transformers
+- [dream-html](https://github.com/aantron/dream): Part of the Dream web framework for OCaml, provides type-safe HTML templating
+
+For other hypermedia application platforms, not based on HTMX, take a look at:
+
+- [Hotwire/Turbo](https://turbo.hotwired.dev/): Rails-oriented framework that similarly uses HTML-over-the-wire
+- [LiveView](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html): Phoenix framework’s solution for building interactive web apps with minimal JavaScript
+- [Unpoly](https://unpoly.com/): Another HTML-over-the-wire framework with progressive enhancement
+- [Livewire](https://laravel-livewire.com/): Laravel’s take on building dynamic interfaces with minimal JavaScript

python_fasthtml-0.14.7/fasthtml/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.14.7"
+from .core import *

{python_fasthtml-0.14.5 → python_fasthtml-0.14.7}/fasthtml/_modidx.py

@@ -94,6 +94,9 @@ d = { 'settings': { 'branch': 'main',
                                'fasthtml.core.RouteFuncs.__getattr__': ('api/core.html#routefuncs.__getattr__', 'fasthtml/core.py'),
                                'fasthtml.core.RouteFuncs.__init__': ('api/core.html#routefuncs.__init__', 'fasthtml/core.py'),
                                'fasthtml.core.RouteFuncs.__setattr__': ('api/core.html#routefuncs.__setattr__', 'fasthtml/core.py'),
+                               'fasthtml.core.StaticImmutable': ('api/core.html#staticimmutable', 'fasthtml/core.py'),
+                               'fasthtml.core.StaticImmutable.file_response': ( 'api/core.html#staticimmutable.file_response',
+                                                                                'fasthtml/core.py'),
                                'fasthtml.core.StaticNoCache': ('api/core.html#staticnocache', 'fasthtml/core.py'),
                                'fasthtml.core.StaticNoCache.file_response': ( 'api/core.html#staticnocache.file_response',
                                                                               'fasthtml/core.py'),
@@ -130,6 +133,7 @@ d = { 'settings': { 'branch': 'main',
                                'fasthtml.core._to_htmx_header': ('api/core.html#_to_htmx_header', 'fasthtml/core.py'),
                                'fasthtml.core._to_xml': ('api/core.html#_to_xml', 'fasthtml/core.py'),
                                'fasthtml.core._url_for': ('api/core.html#_url_for', 'fasthtml/core.py'),
+                               'fasthtml.core._vhash': ('api/core.html#_vhash', 'fasthtml/core.py'),
                                'fasthtml.core._wait_disconnect': ('api/core.html#_wait_disconnect', 'fasthtml/core.py'),
                                'fasthtml.core._wrap_call': ('api/core.html#_wrap_call', 'fasthtml/core.py'),
                                'fasthtml.core._wrap_ex': ('api/core.html#_wrap_ex', 'fasthtml/core.py'),
@@ -162,7 +166,8 @@ d = { 'settings': { 'branch': 'main',
                                'fasthtml.core.snake2hyphens': ('api/core.html#snake2hyphens', 'fasthtml/core.py'),
                                'fasthtml.core.unqid': ('api/core.html#unqid', 'fasthtml/core.py'),
                                'fasthtml.core.until_disconnect': ('api/core.html#until_disconnect', 'fasthtml/core.py'),
-                               'fasthtml.core.uri': ('api/core.html#uri', 'fasthtml/core.py')},
+                               'fasthtml.core.uri': ('api/core.html#uri', 'fasthtml/core.py'),
+                               'fasthtml.core.vurl': ('api/core.html#vurl', 'fasthtml/core.py')},
             'fasthtml.fastapp': {},
             'fasthtml.ft': {},
             'fasthtml.js': { 'fasthtml.js.HighlightJS': ('api/js.html#highlightjs', 'fasthtml/js.py'),
@@ -185,13 +190,10 @@ d = { 'settings': { 'branch': 'main',
                                   'fasthtml.jupyter.JupyUviAsync.start': ('api/jupyter.html#jupyuviasync.start', 'fasthtml/jupyter.py'),
                                   'fasthtml.jupyter.JupyUviAsync.stop': ('api/jupyter.html#jupyuviasync.stop', 'fasthtml/jupyter.py'),
                                   'fasthtml.jupyter.htmx_config_port': ('api/jupyter.html#htmx_config_port', 'fasthtml/jupyter.py'),
-                                  'fasthtml.jupyter.is_port_free': ('api/jupyter.html#is_port_free', 'fasthtml/jupyter.py'),
                                   'fasthtml.jupyter.nb_serve': ('api/jupyter.html#nb_serve', 'fasthtml/jupyter.py'),
                                   'fasthtml.jupyter.nb_serve_async': ('api/jupyter.html#nb_serve_async', 'fasthtml/jupyter.py'),
                                   'fasthtml.jupyter.render_ft': ('api/jupyter.html#render_ft', 'fasthtml/jupyter.py'),
                                   'fasthtml.jupyter.show': ('api/jupyter.html#show', 'fasthtml/jupyter.py'),
-                                  'fasthtml.jupyter.wait_port_free': ('api/jupyter.html#wait_port_free', 'fasthtml/jupyter.py'),
-                                  'fasthtml.jupyter.wait_port_free_async': ('api/jupyter.html#wait_port_free_async', 'fasthtml/jupyter.py'),
                                   'fasthtml.jupyter.ws_client': ('api/jupyter.html#ws_client', 'fasthtml/jupyter.py')},
             'fasthtml.live_reload': {},
             'fasthtml.oauth': { 'fasthtml.oauth.AppleAppClient': ('api/oauth.html#appleappclient', 'fasthtml/oauth.py'),

{python_fasthtml-0.14.5 → python_fasthtml-0.14.7}/fasthtml/core.py

@@ -11,11 +11,12 @@ __all__ = ['empty', 'htmx_hdrs', 'fh_cfg', 'htmx_resps', 'DEF_MAXPART', 'htmx_ex
            'JSONResponse', 'flat_xt', 'Beforeware', 'EventStream', 'signal_shutdown', 'uri', 'decode_uri', 'flat_tuple',
            'noop_body', 'respond', 'is_full_page', 'Redirect', 'get_key', 'qp', 'def_hdrs', 'Lifespan', 'FastHTML',
            'HostRoute', 'nested_name', 'serve', 'until_disconnect', 'cancel_on_disconnect', 'Client', 'RouteFuncs',
-           'APIRouter', 'cookie', 'reg_re_param', 'StaticNoCache', 'add_sig_param', 'into', 'MiddlewareBase',
-           'FtResponse', 'unqid']
+           'APIRouter', 'cookie', 'reg_re_param', 'StaticNoCache', 'StaticImmutable', 'vurl', 'add_sig_param', 'into',
+           'MiddlewareBase', 'FtResponse', 'unqid']
 
 # %% ../nbs/api/00_core.ipynb #23503b9e
-import json,uuid,inspect,types,asyncio,inspect,random,contextlib,itsdangerous
+import json,uuid,inspect,types,asyncio,inspect,random,contextlib,itsdangerous,hashlib
+from uuid import uuid5, NAMESPACE_URL
 
 from fastcore.utils import *
 from fastcore.xml import *
@@ -29,7 +30,7 @@ from dataclasses import dataclass
 from inspect import Parameter,get_annotations
 from functools import partialmethod, update_wrapper
 from http import cookies
-from urllib.parse import urlencode, parse_qs, quote, unquote
+from urllib.parse import urlencode, parse_qs, quote, unquote, urlsplit, urlunsplit
 from copy import deepcopy
 from warnings import warn
 from dateutil import parser as dtparse
@@ -964,6 +965,26 @@ class StaticNoCache(StaticFiles):
         resp.headers.setdefault("Cache-Control", "no-cache")
         return resp
 
+# %% ../nbs/api/00_core.ipynb #74801f94
+class StaticImmutable(StaticFiles):
+    "Like `StaticNoCache`, but marks responses as cacheable forever: for versioned URLs such as `vurl` links or content-hashed filenames"
+    def file_response(self, *args, **kwargs):
+        resp = super().file_response(*args, **kwargs)
+        resp.headers.setdefault("Cache-Control", "public, max-age=31536000, immutable")
+        return resp
+
+# %% ../nbs/api/00_core.ipynb #e38fd6c7
+@flexicache(mtime_policy(arg=0))
+def _vhash(p): return hashlib.blake2b(p.read_bytes(), digest_size=4).hexdigest()
+
+def vurl(path, root='.'):
+    "Return `path` as a URL with a `v` query param hashing the file's contents, so the URL changes when the file does"
+    u = urlsplit(str(path))
+    p = Path(root)/u.path.lstrip('/')
+    q = f'{u.query}&' if u.query else ''
+    return urlunsplit(u._replace(query=f'{q}v={_vhash(p)}'))
+
+
 # %% ../nbs/api/00_core.ipynb #7189daf8
 from functools import wraps
 from inspect import signature, isawaitable
@@ -1054,10 +1075,10 @@ devtools_loc = "/.well-known/appspecific/com.chrome.devtools.json"
 @patch
 def devtools_json(self:FastHTML, path=None, uuid=None):
     if not path: path = Path().absolute()
-    if not uuid: uuid = get_key()
+    if not uuid: uuid = str(uuid5(NAMESPACE_URL, str(path)))
     @self.route(devtools_loc)
     def devtools():
-        return dict(workspace=dict(root=path, uuid=uuid))
+        return dict(workspace=dict(root=str(path), uuid=uuid))
 
 # %% ../nbs/api/00_core.ipynb #e27908c0
 @patch

{python_fasthtml-0.14.5 → python_fasthtml-0.14.7}/fasthtml/jupyter.py

@@ -5,14 +5,14 @@ Docs: https://www.fastht.ml/docs/api/jupyter.html.md"""
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/api/06_jupyter.ipynb.
 
 # %% auto #0
-__all__ = ['nb_serve', 'nb_serve_async', 'is_port_free', 'wait_port_free', 'wait_port_free_async', 'show', 'render_ft',
-           'htmx_config_port', 'JupyUvi', 'JupyUviAsync', 'HTMX', 'ws_client']
+__all__ = ['nb_serve', 'nb_serve_async', 'show', 'render_ft', 'htmx_config_port', 'JupyUvi', 'JupyUviAsync', 'HTMX', 'ws_client']
 
 # %% ../nbs/api/06_jupyter.ipynb #2c69d9d0
-import asyncio, socket, time, uvicorn
+import asyncio, time, uvicorn
 from threading import Thread
 from fastcore.utils import *
 from fastcore.meta import delegates
+from fastcore.net import wait_port_free, wait_port_free_async
 from .common import *
 from .common import show as _show
 from fastcore.parallel import startthread
@@ -36,33 +36,6 @@ async def nb_serve_async(app, log_level="error", port=8000, host='0.0.0.0', **kw
     while not server.started: await asyncio.sleep(0.01)
     return server
 
-# %% ../nbs/api/06_jupyter.ipynb #508917bc
-def is_port_free(port, host='localhost'):
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    try:
-        sock.bind((host, port))
-        sock.listen(1)
-        return True
-    except OSError: return False
-    finally: sock.close()
-
-# %% ../nbs/api/06_jupyter.ipynb #1779cb76
-def wait_port_free(port, host='localhost', max_wait=20):
-    "Wait for `port` to be free on `host`"
-    start_time = time.time()
-    while not is_port_free(port, host):
-        if time.time() - start_time > max_wait: raise TimeoutError(f"Port {host}:{port} not free after {max_wait}s")
-        time.sleep(0.1)
-
-async def wait_port_free_async(port, host='localhost', max_wait=20):
-    "Async wait for `port` to be free on `host`"
-    start_time   = time.time()
-    while not is_port_free(port, host):
-        if time.time() - start_time > max_wait: raise TimeoutError(f"Port {host}:{port} not free after {max_wait}s")
-        await asyncio.sleep(0.1)
-
-
 # %% ../nbs/api/06_jupyter.ipynb #654b36bb
 @delegates(_show)
 def show(*s, **kwargs):

{python_fasthtml-0.14.5 → python_fasthtml-0.14.7}/pyproject.toml

@@ -12,7 +12,7 @@ license = {text = "Apache-2.0"}
 authors = [{name = "Jeremy Howard and contributors", email = "github@jhoward.fastmail.fm"}]
 keywords = ['nbdev', 'jupyter', 'notebook', 'python']
 classifiers = ["Natural Language :: English", "Intended Audience :: Developers", "Development Status :: 3 - Alpha", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only"]
-dependencies = ['fastcore>=1.14.2', 'python-dateutil', 'starlette>=1.0.1', 'oauthlib', 'itsdangerous', 'uvicorn[standard]>=0.30', 'httpx2', 'fastlite>=0.1.1', 'python-multipart', 'beautifulsoup4']
+dependencies = ['fastcore>=2.1.2', 'python-dateutil', 'starlette>=1.0.1', 'oauthlib', 'itsdangerous', 'uvicorn[standard]>=0.30', 'httpx2', 'fastlite>=0.1.1', 'python-multipart', 'beautifulsoup4']
 
 [project.urls]
 Repository = "https://github.com/AnswerDotAI/fasthtml"
@@ -22,7 +22,7 @@ Documentation = "https://www.fastht.ml/docs/"
 fasthtml = "fasthtml._modidx:d"
 
 [project.optional-dependencies]
-dev = ['ipython', 'lxml', 'pysymbol_llm', 'monsterui', 'PyJWT']
+dev = ['ipython', 'lxml', 'pysym2md>=0.0.6', 'monsterui', 'PyJWT']
 
 
 [project.scripts]
@@ -44,3 +44,5 @@ lib_path = "fasthtml"
 
 [tool.chkstyle]
 skip_paths = ["_modidx.py"]
+ignore = ["closing-bracket", "inefficient-multiline-signature", "inefficient-multiline-expression"]
+

python_fasthtml-0.14.7/python_fasthtml.egg-info/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: python-fasthtml
+Version: 0.14.7
+Summary: The fastest way to create an HTML app
+Author-email: Jeremy Howard and contributors <github@jhoward.fastmail.fm>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/AnswerDotAI/fasthtml
+Project-URL: Documentation, https://www.fastht.ml/docs/
+Keywords: nbdev,jupyter,notebook,python
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastcore>=2.1.2
+Requires-Dist: python-dateutil
+Requires-Dist: starlette>=1.0.1
+Requires-Dist: oauthlib
+Requires-Dist: itsdangerous
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: httpx2
+Requires-Dist: fastlite>=0.1.1
+Requires-Dist: python-multipart
+Requires-Dist: beautifulsoup4
+Provides-Extra: dev
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: lxml; extra == "dev"
+Requires-Dist: pysym2md>=0.0.6; extra == "dev"
+Requires-Dist: monsterui; extra == "dev"
+Requires-Dist: PyJWT; extra == "dev"
+Dynamic: license-file
+
+# FastHTML
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+Welcome to the official FastHTML documentation.
+
+FastHTML is a new next-generation web framework for fast, scalable web applications with minimal, compact code. It’s designed to be:
+
+- Powerful and expressive enough to build the most advanced, interactive web apps you can imagine.
+- Fast and lightweight, so you can write less code and get more done.
+- Easy to learn and use, with a simple, intuitive syntax that makes it easy to build complex apps quickly.
+
+FastHTML apps are just Python code, so you can use FastHTML with the full power of the Python language and ecosystem. FastHTML’s functionality maps 1:1 directly to HTML and HTTP, but allows them to be encapsulated using good software engineering practices—so you’ll need to understand these foundations to use this library fully. To understand how and why this works, please read this first: [fastht.ml/about](https://fastht.ml/about).
+
+## Installation
+
+Since `fasthtml` is a Python library, you can install it with:
+
+``` sh
+pip install python-fasthtml
+```
+
+In the near future, we hope to add component libraries that can likewise be installed via `pip`.
+
+## Usage
+
+For a minimal app, create a file “main.py” as follows:
+
+<div class="code-with-filename">
+
+**main.py**
+
+``` python
+from fasthtml.common import *
+
+app,rt = fast_app()
+
+@rt('/')
+def get(): return Div(P('Hello World!'), hx_get="/change")
+
+serve()
+```
+
+</div>
+
+Running the app with `python main.py` prints out a link to your running app: `http://localhost:5001`. Visit that link in your browser and you should see a page with the text “Hello World!”. Congratulations, you’ve just created your first FastHTML app!
+
+Adding interactivity is surprisingly easy, thanks to HTMX. Modify the file to add this function:
+
+<div class="code-with-filename">
+
+**main.py**
+
+``` python
+@rt('/change')
+def get(): return P('Nice to be here!')
+```
+
+</div>
+
+You now have a page with a clickable element that changes the text when clicked. When clicking on this link, the server will respond with an “HTML partial”—that is, just a snippet of HTML which will be inserted into the existing page. In this case, the returned element will replace the original P element (since that’s the default behavior of HTMX) with the new version returned by the second route.
+
+This “hypermedia-based” approach to web development is a powerful way to build web applications.
+
+### Getting help from AI
+
+Because FastHTML is newer than most LLMs, AI systems like Cursor, ChatGPT, Claude, and Copilot won’t give useful answers about it. To fix that problem, we’ve provided an LLM-friendly guide that teaches them how to use FastHTML. To use it, add this link for your AI helper to use:
+
+- [/llms-ctx.txt](https://www.fastht.ml/docs/llms-ctx.txt)
+
+This example is in a format based on recommendations from Anthropic for use with [Claude Projects](https://support.anthropic.com/en/articles/9517075-what-are-projects). This works so well that we’ve actually found that Claude can provide even better information than our own documentation! For instance, read through [this annotated Claude chat](https://gist.github.com/jph00/9559b0a563f6a370029bec1d1cc97b74) for some great getting-started information, entirely generated from a project using the above text file as context.
+
+If you use Cursor, type `@doc` then choose “*Add new doc*”, and use the /llms-ctx.txt link above. The context file is auto-generated from our [`llms.txt`](https://llmstxt.org/) (our proposed standard for providing AI-friendly information)—you can generate alternative versions suitable for other models as needed.
+
+## Next Steps
+
+Start with the official sources to learn more about FastHTML:
+
+- [About](https://fastht.ml/about): Learn about the core ideas behind FastHTML
+- [Documentation](https://www.fastht.ml/docs): Learn from examples how to write FastHTML code
+- [Idiomatic app](https://github.com/AnswerDotAI/fasthtml/blob/main/examples/adv_app.py): Heavily commented source code walking through a complete application, including custom authentication, JS library connections, and database use.
+
+We also have a 1-hour intro video:
+
+<https://www.youtube.com/embed/Auqrm7WFc0I>
+
+The capabilities of FastHTML are vast and growing, and not all the features and patterns have been documented yet. Be prepared to invest time into studying and modifying source code, such as the main FastHTML repo’s notebooks and the official FastHTML examples repo:
+
+- [FastHTML Examples Repo on GitHub](https://github.com/AnswerDotAI/fasthtml-example)
+- [FastHTML Repo on GitHub](https://github.com/AnswerDotAI/fasthtml)
+
+Then explore the small but growing third-party ecosystem of FastHTML tutorials, notebooks, libraries, and components:
+
+- [FastHTML Gallery](https://gallery.fastht.ml): Learn from minimal examples of components (ie chat bubbles, click-to-edit, infinite scroll, etc)
+- [Creating Custom FastHTML Tags for Markdown Rendering](https://isaac-flath.github.io/website/posts/boots/FasthtmlTutorial.html) by Isaac Flath
+- [How to Build a Simple Login System in FastHTML](https://blog.mariusvach.com/posts/login-fasthtml) by Marius Vach
+- Your tutorial here!
+
+Finally, join the FastHTML community to ask questions, share your work, and learn from others:
+
+- [Discord](https://discord.gg/qcXvcxMhdP)
+
+## Other languages and related projects
+
+If you’re not a Python user, or are keen to try out a new language, we’ll list here other projects that have a similar approach to FastHTML. (Please reach out if you know of any other projects that you’d like to see added.)
+
+- [htmgo](https://htmgo.dev/) (Go): “*htmgo is a lightweight pure go way to build interactive websites / web applications using go & htmx. By combining the speed & simplicity of go + hypermedia attributes (htmx) to add interactivity to websites, all conveniently wrapped in pure go, you can build simple, fast, interactive websites without touching javascript. All compiled to a single deployable binary*”
+
+If you’re just interested in functional HTML components, rather than a full HTMX server solution, consider:
+
+- [fastcore.xml.FT](https://fastcore.fast.ai/xml.html): This is actually what FastHTML uses behind the scenes
+- [htpy](https://htpy.dev/): Similar to [`fastcore.xml.FT`](https://fastcore.fast.ai/xml.html#ft), but with a somewhat different syntax
+- [elm-html](https://package.elm-lang.org/packages/elm/html/latest/): Elm’s built-in HTML library with a type-safe functional approach
+- [hiccup](https://github.com/weavejester/hiccup): Popular library for representing HTML in Clojure using vectors
+- [hiccl](https://github.com/garlic0x1/hiccl): HTML generation library for Common Lisp inspired by Clojure’s Hiccup
+- [Falco.Markup](https://github.com/pimbrouwers/Falco): F# HTML DSL and web framework with type-safe HTML generation
+- [Lucid](https://github.com/chrisdone/lucid): Type-safe HTML generation for Haskell using monad transformers
+- [dream-html](https://github.com/aantron/dream): Part of the Dream web framework for OCaml, provides type-safe HTML templating
+
+For other hypermedia application platforms, not based on HTMX, take a look at:
+
+- [Hotwire/Turbo](https://turbo.hotwired.dev/): Rails-oriented framework that similarly uses HTML-over-the-wire
+- [LiveView](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html): Phoenix framework’s solution for building interactive web apps with minimal JavaScript
+- [Unpoly](https://unpoly.com/): Another HTML-over-the-wire framework with progressive enhancement
+- [Livewire](https://laravel-livewire.com/): Laravel’s take on building dynamic interfaces with minimal JavaScript