pgjones

The `sql_context` feature is meant to protect against SQL injection. I think for your usecase you would need to supply all columns, but you could used nested t-strings included based on whatever logic you need.

It does parse the SQL. At the moment an expression is defined as all the text between the appropriate separators given the clause.

Sorry that is a typo, I meant,

    with sql_context(columns={"x"}):

Thank you! My Google foo did not find this.

The presence of Absent removes the entire expression, and if that removal results in an empty clause (or group) it will remove that as well. For example if `a = Absent` `WHERE a = {a}` will remove everything, whereas `WHERE a = {a} AND b = {b}` will result in `WHERE b = {b}`.

Do you support templating a sql tstring into an sql tstring for composition?

Yep

Thanks, do you have a reference for SQL grammar - I've had no success finding an official source.

If you want to see a usage for this I've built, and use, [SQL-tString](https://github.com/pgjones/sql-tstring) as an SQL builder.

Quart, the ASGI version of Flask, also has background tasks, https://quart.palletsprojects.com/en/latest/how_to_guides/ba..., and there is an extension Quart-Tasks, https://github.com/pgjones/quart-tasks, to run them on a schedule. Via

    @tasks.cron("*/5 * * * *")  # every 5 minutes
    async def infrequent_task():
        ...

It is a shame GCRA is not more well known and used for rate limiting. It is, in my view, a better algorithm.

https://medium.com/smarkets/implementing-gcra-in-python-5df1... https://en.m.wikipedia.org/wiki/Generic_cell_rate_algorithm

Yes, I've written about this comparison in detail https://pgjones.dev/blog/fastapi-flask-quart-2022/.

There are new logos for all the Pallets projects and Pallets itself, based on a common theme.

https://pgjones.dev

I blog mostly about Python web developed, especially Flask, Quart and Hypercorn related aspects.

I've three things :),

1. Quart, https://quart.palletsprojects.com, an ASGI (async/await) re-implementation of the Python web MicroFramework Flask. It is now maintained alongside, by the same people, as Flask.

2. Hypercorn, https://hypercorn.readthedocs.io, an ASGI/WSGI server that supports HTTP/1, HTTP/2, and HTTP/3.

3. My book "A Blueprint for Production-Ready Web Applications", which uses both of the above and shows a beginner how to build a full stack app (React frontend) running on AWS. See https://pgjones.dev/tozo/ for details, code, and link to the example app.

It is also easier to manage for Flask - it is very mature and we fixed most of the issues present in FastAPI many years ago.

Flask supports async, see https://flask.palletsprojects.com/en/2.1.x/async-await/.

Also see Quart https://github.com/pgjones/quart (which is Flask re-implemented with async-await) and Quart-Schema, https://github.com/pgjones/quart-schema for swagger docs.

Or Hypercorn https://gitlab.com/pgjones/hypercorn if you want HTTP/1, HTTP/2, and HTTP/3.

You can already do this using Hypothesis with the Pydantic plugin, https://pydantic-docs.helpmanual.io/hypothesis_plugin/. Here is an example for Quart-Schema (similar setup to FastAPI) https://pgjones.dev/blog/automatic-api-testing-2021.

Hypercorn a Python ASGI server supports HTTP/3 built on aioquic which is a Python library supports QUIC.

(I'm the author of Hypercorn).

Hi Hacker News,

I’ve reached an age now where I need to start thinking about my retirement, in addition to buying a house, saving for a wedding, starting a family, affording to pay for childcare, amongst other things. Frustratingly, it is really hard to know if I’m saving enough, or even how much I should be aiming to save. The best tools to solve my problem model cash flows and are only available through expensive financial advisors. I’ve built Moneyed to solve my own, and many other people’s, problem.

Moneyed, at the core, takes into account personalised financial goals and models cash flows i.e. the growth of assets, savings rates, and spending. Difficulties arise in the details, especially taking into account tax rules, and building a plan that is fully optimised (i.e. one where you minimise the amount you save whilst still being tax efficient and meeting your goals).

Moneyed also utilises Open Banking to give a full financial overview (UK current accounts, credit cards, savings, investments, pensions), to understand current spending, and to make it easy to know if you’re on track.

The backend of the app is built in Quart, an async version of Flask (Python), and utilises React for the frontend. The site also uses Quart for the backend but uses Svelte for the frontend. I’m the author of Quart, so it is an obvious choice for me. As for the frontend, React works really well for the app given the complexity, but I find it too heavy for the site. Fortunately Svelte exists, which I think is perfect for the site.

To build an optimised financial plan, we’re implementing SciPy’s minimize function as it enables us to model both linear and non-linear constraints and is relatively quick to solve (provided the initial first guess is good). We’re planning on leveraging more data science techniques: building a recommender engine to help people decide where to save/invest and cohort analysis to give for social validation and insights.

As for our go-to-market, we’re targeting young professionals working in tech as part of their employer’s benefits and wellbeing strategy as this enables us to create a “trigger” to get people thinking about their financial future.

Potentially soon for Flask, https://github.com/pallets/flask/pull/3412. Also see Quart, https://gitlab.com/pgjones/quart

It is possible to compare HTTP/3 to HTTP/2 & HTTP/1 using Python, as Hypercorn (via aioquic for HTTP/3) supports all three.

When I compared late last year I found HTTP/3 to be noticeably slower, https://pgjones.dev/blog/early-look-at-http3-2019/ however my test was much less comprehensive than the one here.

I took an early look at the performance (using Python) in November which may also be of interest. https://pgjones.dev/blog/early-look-at-http3-2019/

(That site is also served over HTTP/3 if you want to try it out).

Octopus Wealth | Full-time in London, UK | ONSITE | https://octopuswealth.com/

We are a wealth management company, here to blow away the cobwebs and breathe new life into personal finance. We believe that getting help should be a positive and uplifting experience: an aspiration, not an anxiety.

We’re developing technology that’ll create a new type of user experience for clients of financial advisers. It’ll also be the key to lowering our costs, helping us bring the benefits of tailored financial advice to more and more people.

Our tech stack is based on Python and Typescript utilizing the Quart and React frameworks respectively. We practice continuous deployment via docker containers to a k8s environment.

Current positions,

- Software engineer, 40 - 70k pa | https://medium.com/octopus-wealth/software-engineer-2be03a48...

- Senior software engineer, 70 - 100k pa | https://medium.com/octopus-wealth/senior-software-engineer-c...

- Design lead, 50 - 70k pa | https://medium.com/octopus-wealth/design-lead-4ef23c5ea445

We offer a comprehensive benefits package, including generous holiday allowance, private healthcare and a host of workplace rewards.

This is now possible, the article talks about what impact HTTP/2 WebSockets can make. (See also RFC 8441).

I think my articles in the past have been too dull; I think people would like to read something interesting and entertaining so I'm trying to improve in this regard. Was the article a good read or did the title put you off?

Wow, any chance you could write up the throughput gain? It would be great to see some real production numbers.

Thanks for the comments.

Have you any experience with GINO (https://github.com/fantix/gino) or Peewee-Async (https://github.com/05bit/peewee-async)? These look to be feasible alternatives.

It isn't compared with other languages, however Quart sits well in the Python ecosystem, especially with uvloop. I wrote some of this up https://hackernoon.com/3x-faster-than-flask-8e89bfbe8e4f

I like the open source nature of gitlab, and its feature set. There is a mirror on github as well, mostly as people tend to look on github first.

Sanic is Flask-like, whereas Quart is the Flask-API (some Flask extensions work with Quart https://pgjones.gitlab.io/quart/flask_extensions.html#suppor...).

The key part I wanted to highlight here though is that Quart serves HTTP/2, which I think sets it apart from most of the other Python frameworks. (I know Twisted also does this https://medium.com/python-pandemonium/how-to-serve-http-2-us...)