python-fasthtml 0.0.4__tar.gz → 0.0.6__tar.gz

{python-fasthtml-0.0.4/python_fasthtml.egg-info → python-fasthtml-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-fasthtml
-Version: 0.0.4
+Version: 0.0.6
 Summary: The fastest way to create an HTML app
 Home-page: https://github.com/AnswerDotAI/fasthtml
 Author: Jeremy Howard

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/fasthtml/__init__.py

@@ -1,5 +1,5 @@
-__version__ = "0.0.4"
+__version__ = "0.0.6"
 from .core import *
+from .authmw import *
 from .components import *
 from .xtend import *
-

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/fasthtml/_modidx.py

@@ -6,6 +6,7 @@ d = { 'settings': { 'branch': 'main',
                 'git_url': 'https://github.com/AnswerDotAI/fasthtml',
                 'lib_path': 'fasthtml'},
   'syms': { 'fasthtml.all': {},
+            'fasthtml.authmw': {},
             'fasthtml.components': { 'fasthtml.components._FindElems': ('components.html#_findelems', 'fasthtml/components.py'),
                                      'fasthtml.components._FindElems.__init__': ( 'components.html#_findelems.__init__',
                                                                                   'fasthtml/components.py'),

python-fasthtml-0.0.6/fasthtml/authmw.py

@@ -0,0 +1,45 @@
+import base64, binascii
+from fasthtml.core import *
+from fasthtml.starlette import *
+from typing import Mapping
+
+auth_hdrs = {'WWW-Authenticate': 'Basic realm="login"'}
+
+class BasicAuthMiddleware(MiddlewareBase):
+    def __init__(self, app, cb, skip=None): self.app,self.cb,self.skip = app,cb,skip or []
+
+    async def _resp(self, scope, receive, send, resp):
+        await (send({"type": "websocket.close", "code": 1000}) if scope["type"]=="websocket" else resp(scope, receive, send))
+
+    async def __call__(self, scope, receive, send) -> None:
+        conn = await super().__call__(scope, receive, send)
+        if not conn: return
+        request = Request(scope, receive)
+        if not any(re.match(o+'$', request.url.path) for o in self.skip):
+            res = await self.authenticate(conn)
+            if not res: res = Response('not authenticated', status_code=401, headers=auth_hdrs)
+            if isinstance(res, Response): return await self._resp(scope, receive, send, res)
+            scope["auth"] = res
+        await self.app(scope, receive, send)
+
+    async def authenticate(self, conn):
+        if "Authorization" not in conn.headers: return
+        auth = conn.headers["Authorization"]
+        try:
+            scheme, credentials = auth.split()
+            if scheme.lower() != 'basic': return
+            decoded = base64.b64decode(credentials).decode("ascii")
+        except (ValueError, UnicodeDecodeError, binascii.Error) as exc: raise AuthenticationError('Invalid credentials')
+        user, _, pwd = decoded.partition(":")
+        if self.cb(user,pwd): return user
+
+def user_pwd_auth(lookup=None, skip=None, **kwargs):
+    if isinstance(lookup,Mapping): kwargs = lookup | kwargs
+    def cb(u,p):
+        if u=='logout' or not u or not p: return
+        if callable(lookup): return lookup(u,p)
+        return kwargs.get(u,None) == p
+    return Middleware(BasicAuthMiddleware, cb=cb, skip=skip)
+
+def basic_logout(request):
+    return f'{request.url.scheme}://logout:logout@{request.headers["host"]}/'

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/fasthtml/core.py

@@ -1,4 +1,4 @@
-import json, dateutil, uuid
+import json,dateutil,uuid,inspect
 
 from fastcore.utils import *
 from fastcore.xml import *
@@ -95,6 +95,7 @@ async def _from_body(req, arg, p):
 
 async def _find_p(req, arg:str, p):
     anno = p.annotation
+    if arg.lower()=='auth': return req.scope['auth']
     if isinstance(anno, type):
         if issubclass(anno, Request): return req
         if issubclass(anno, HtmxHeaders): return _get_htmx(req)
@@ -110,11 +111,11 @@ async def _find_p(req, arg:str, p):
     if not res: res = req.query_params.get(arg, None)
     if not res: res = req.cookies.get(arg, None)
     if not res: res = req.headers.get(snake2hyphens(arg), None)
-    if not res: res = nested_idx(req.scope, 'session', arg)
-    if not res: res = p.default
+    if not res: res = nested_idx(req.scope, 'session', arg) or None
     if res is empty or res is None:
         body = await req.form()
         res = body.get(arg, None)
+    if not res: res = p.default
     if not isinstance(res, str) or anno is empty: return res
     return _fix_anno(anno)(res)
 
@@ -136,42 +137,49 @@ def _wrap_resp(req, resp, cls, hdrs, **bodykw):
     if isinstance(resp, Response): return resp
     if cls is not empty: return cls(resp)
     if isinstance(resp, (list,tuple)): return _xt_resp(req, resp, hdrs, **bodykw)
-    if isinstance(resp, str): cls = HTMLResponse 
-    elif isinstance(resp, Mapping): cls = JSONResponse 
+    if isinstance(resp, str): cls = HTMLResponse
+    elif isinstance(resp, Mapping): cls = JSONResponse
     else:
         resp = str(resp)
         cls = HTMLResponse
     return cls(resp)
 
-def _wrap_ep(f, hdrs, **bodykw):
+def _wrap_ep(f, hdrs, before, **bodykw):
     if not (isfunction(f) or ismethod(f)): return f
     sig = signature(f)
     params = sig.parameters
     cls = sig.return_annotation
 
     async def _f(req):
-        wreq = await _wrap_req(req, params)
-        resp = f(*wreq)
-        if is_async_callable(f): resp = await resp
+        resp = None
+        for b in before:
+            if not resp:
+                wreq = await _wrap_req(req, signature(b).parameters)
+                resp = b(*wreq)
+                if is_async_callable(b): resp = await resp
+        if not resp:
+            wreq = await _wrap_req(req, params)
+            resp = f(*wreq)
+            if is_async_callable(f): resp = await resp
         return _wrap_resp(req, resp, cls, hdrs, **bodykw)
     return _f
 
 class RouteX(Route):
     def __init__(self, path:str, endpoint, *, methods=None, name=None, include_in_schema=True, middleware=None,
-                hdrs=None, **bodykw):
-        super().__init__(path, _wrap_ep(endpoint, hdrs, **bodykw), methods=methods, name=name,
+                hdrs=None, before=None, **bodykw):
+        super().__init__(path, _wrap_ep(endpoint, hdrs, before, **bodykw), methods=methods, name=name,
                          include_in_schema=include_in_schema, middleware=middleware)
 
 class RouterX(Router):
     def __init__(self, routes=None, redirect_slashes=True, default=None, on_startup=None, on_shutdown=None,
-                 lifespan=None, *, middleware=None, hdrs=None, **bodykw):
+                 lifespan=None, *, middleware=None, hdrs=None, before=None, **bodykw):
         super().__init__(routes, redirect_slashes, default, on_startup, on_shutdown,
                  lifespan=lifespan, middleware=middleware)
-        self.hdrs,self.bodykw = hdrs or (),bodykw
+        self.hdrs,self.bodykw,self.before = hdrs or (),bodykw,before or ()
 
     def add_route( self, path: str, endpoint: callable, methods=None, name=None, include_in_schema=True):
         route = RouteX(path, endpoint=endpoint, methods=methods, name=name, include_in_schema=include_in_schema,
-                      hdrs=self.hdrs, **self.bodykw)
+                      hdrs=self.hdrs, before=self.before, **self.bodykw)
         self.routes = [o for o in self.routes if o.methods!=methods or o.path!=path]
         self.routes.append(route)
 
@@ -187,12 +195,14 @@ def get_key(key=None, fname='.sesskey'):
     fname.write_text(key)
     return key
 
+def _list(o): return [] if not o else o if isinstance(o, (tuple,list)) else [o]
+
 class FastHTML(Starlette):
     def __init__(self, debug=False, routes=None, middleware=None, exception_handlers=None,
-                 on_startup=None, on_shutdown=None, lifespan=None, hdrs=None,
+                 on_startup=None, on_shutdown=None, lifespan=None, hdrs=None, before=None,
                  secret_key=None, session_cookie='session_', max_age=365*24*3600, sess_path='/',
                  same_site='lax', sess_https_only=False, sess_domain=None, key_fname='.sesskey', **bodykw):
-        if not middleware: middleware = []
+        middleware,before = _list(middleware),_list(before)
         secret_key = get_key(secret_key, key_fname)
         sess = Middleware(SessionMiddleware, secret_key=secret_key, session_cookie=session_cookie,
                           max_age=max_age, path=sess_path, same_site=same_site,
@@ -200,7 +210,8 @@ class FastHTML(Starlette):
         middleware.append(sess)
         super().__init__(debug, routes, middleware, exception_handlers, on_startup, on_shutdown, lifespan=lifespan)
         hdrs = list([] if hdrs is None else hdrs) + [htmxscr]
-        self.router = RouterX(routes, on_startup=on_startup, on_shutdown=on_shutdown, lifespan=lifespan, hdrs=hdrs, **bodykw)
+        self.router = RouterX(routes, on_startup=on_startup, on_shutdown=on_shutdown, lifespan=lifespan, hdrs=hdrs,
+                              before=before, **bodykw)
 
     def route(self, path:str, methods=None, name=None, include_in_schema=True):
         def f(func):
@@ -220,3 +231,9 @@ def reg_re_param(m, s):
 reg_re_param("path", ".*?")
 reg_re_param("static", "ico|gif|jpg|jpeg|webm|css|js|woff|png|svg|mp4|webp|ttf|otf|eot|woff2|txt|xml")
 
+class MiddlewareBase:
+    async def __call__(self, scope, receive, send) -> None:
+        if scope["type"] not in ["http", "websocket"]:
+            await self.app(scope, receive, send)
+            return
+        return HTTPConnection(scope)

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/fasthtml/fastapp.py

@@ -16,12 +16,11 @@ def fast_app(db=None, render=None, hdrs=None, tbls=None, **kwargs):
     async def get(fname:str, ext:str): return FileResponse(f'{fname}.{ext}')
     if not db: return app
 
+    db = database(db)
     if not tbls: tbls={}
     if kwargs:
         kwargs['render'] = render
         tbls['items'] = kwargs
-    db = Database(db)
-    db.enable_wal()
     dbtbls = [get_tbl(db.t, k, v) for k,v in tbls.items()]
     if len(dbtbls)==1: dbtbls=dbtbls[0]
     return app,*dbtbls

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/fasthtml/starlette.py

@@ -2,10 +2,11 @@ from starlette.applications import Starlette
 from starlette.middleware import Middleware
 from starlette.middleware.sessions import SessionMiddleware
 from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.authentication import AuthCredentials, AuthenticationBackend, AuthenticationError, SimpleUser, requires
 from starlette.middleware.httpsredirect import HTTPSRedirectMiddleware
 from starlette.middleware.trustedhost import TrustedHostMiddleware
 from starlette.responses import Response, HTMLResponse, FileResponse, JSONResponse
-from starlette.requests import Request
+from starlette.requests import Request, HTTPConnection
 from starlette.staticfiles import StaticFiles
 from starlette.exceptions import HTTPException
 from starlette._utils import is_async_callable
@@ -15,4 +16,5 @@ from starlette.exceptions import HTTPException,WebSocketException
 from starlette.endpoints import HTTPEndpoint,WebSocketEndpoint
 from starlette.config import Config
 from starlette.datastructures import CommaSeparatedStrings, Secret
+from starlette.types import ASGIApp, Receive, Scope, Send
 

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/fasthtml/xtend.py

@@ -16,13 +16,13 @@ from .components import *
 try: from IPython import display
 except ImportError: display=None
 
-# %% ../nbs/02_xtend.ipynb 3
+# %% ../nbs/02_xtend.ipynb 4
 picocss = "https://cdn.jsdelivr.net/npm/@picocss/pico@latest/css/pico.min.css"
 picolink = Link(rel="stylesheet", href=picocss)
 picocondcss = "https://cdn.jsdelivr.net/npm/@picocss/pico@latest/css/pico.conditional.min.css"
 picocondlink = Link(rel="stylesheet", href=picocondcss)
 
-# %% ../nbs/02_xtend.ipynb 6
+# %% ../nbs/02_xtend.ipynb 7
 def set_pico_cls():
     js = """var sel = '.cell-output, .output_area';
 document.querySelectorAll(sel).forEach(e => e.classList.add('pico'));
@@ -40,23 +40,23 @@ new MutationObserver(ms => {
 }).observe(document.body, { childList: true, subtree: true });"""
     return display.Javascript(js)
 
-# %% ../nbs/02_xtend.ipynb 9
+# %% ../nbs/02_xtend.ipynb 10
 def Html(*c, doctype=True, **kwargs):
     res = xt('html', *c, **kwargs)
     if not doctype: return res
     return (xt('!DOCTYPE', html=True), res)
 
-# %% ../nbs/02_xtend.ipynb 10
+# %% ../nbs/02_xtend.ipynb 11
 @delegates(xt_hx, keep=True)
 def A(*c, hx_get=None, target_id=None, hx_swap=None, href='#', **kwargs):
     return xt_hx('a', *c, href=href, hx_get=hx_get, target_id=target_id, hx_swap=hx_swap, **kwargs)
 
-# %% ../nbs/02_xtend.ipynb 12
+# %% ../nbs/02_xtend.ipynb 13
 @delegates(xt_hx, keep=True)
 def AX(txt, hx_get=None, target_id=None, hx_swap=None, href='#', **kwargs):
     return xt_hx('a', txt, href=href, hx_get=hx_get, target_id=target_id, hx_swap=hx_swap, **kwargs)
 
-# %% ../nbs/02_xtend.ipynb 14
+# %% ../nbs/02_xtend.ipynb 15
 @delegates(xt_hx, keep=True)
 def Checkbox(checked:bool=False, label=None, value="1", **kwargs):
     if not checked: checked=None
@@ -64,36 +64,36 @@ def Checkbox(checked:bool=False, label=None, value="1", **kwargs):
     if label: res = Label(res, label)
     return res
 
-# %% ../nbs/02_xtend.ipynb 16
+# %% ../nbs/02_xtend.ipynb 17
 @delegates(xt_hx, keep=True)
 def Card(*c, header=None, footer=None, **kwargs):
     if header: c = (Header(header),) + c
     if footer: c += (Footer(footer),)
     return Article(*c, **kwargs)
 
-# %% ../nbs/02_xtend.ipynb 18
+# %% ../nbs/02_xtend.ipynb 19
 @delegates(xt_hx, keep=True)
 def Group(*c, **kwargs):
     return Fieldset(*c, role="group", **kwargs)
 
-# %% ../nbs/02_xtend.ipynb 20
+# %% ../nbs/02_xtend.ipynb 21
 @delegates(xt_hx, keep=True)
 def Search(*c, **kwargs):
     return Form(*c, role="search", **kwargs)
 
-# %% ../nbs/02_xtend.ipynb 22
+# %% ../nbs/02_xtend.ipynb 23
 @delegates(xt_hx, keep=True)
 def Grid(*c, cls='grid', **kwargs):
     c = tuple(o if isinstance(o,list) else Div(o) for o in c)
     return xt_hx('div', *c, cls=cls, **kwargs)
 
-# %% ../nbs/02_xtend.ipynb 24
+# %% ../nbs/02_xtend.ipynb 25
 @delegates(xt_hx, keep=True)
 def DialogX(*c, open=None, header=None, footer=None, id=None, **kwargs):
     card = Card(*c, header=header, footer=footer, **kwargs)
     return Dialog(card, open=open, id=id)
 
-# %% ../nbs/02_xtend.ipynb 26
+# %% ../nbs/02_xtend.ipynb 27
 @delegates(xt_hx, keep=True)
 def Hidden(value:str="", **kwargs):
     return Input(type="hidden", value=value, **kwargs)

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6/python_fasthtml.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-fasthtml
-Version: 0.0.4
+Version: 0.0.6
 Summary: The fastest way to create an HTML app
 Home-page: https://github.com/AnswerDotAI/fasthtml
 Author: Jeremy Howard

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/python_fasthtml.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ setup.py
 fasthtml/__init__.py
 fasthtml/_modidx.py
 fasthtml/all.py
+fasthtml/authmw.py
 fasthtml/components.py
 fasthtml/core.py
 fasthtml/fastapp.py

{python-fasthtml-0.0.4 → python-fasthtml-0.0.6}/settings.ini

@@ -1,12 +1,13 @@
 [DEFAULT]
 repo = fasthtml
 lib_name = fasthtml
-version = 0.0.4
+version = 0.0.6
 min_python = 3.10
 license = apache2
 requirements = fastcore python-dateutil starlette oauthlib itsdangerous uvicorn httpx fastlite
 dev_requirements = ipython lxml
 black_formatting = False
+conda_user = fastai
 doc_path = _docs
 lib_path = fasthtml
 nbs_path = nbs