Hacker News Reader

pgjoneson Show HN: SQL-tString a t-string SQL builder in Python

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.

pgjoneson Show HN: SQL-tString a t-string SQL builder in Python

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

pgjoneson Show HN: SQL-tString a t-string SQL builder in Python

Sorry that is a typo, I meant,

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

pgjoneson Show HN: SQL-tString a t-string SQL builder in Python

Thank you! My Google foo did not find this.

pgjoneson Show HN: SQL-tString a t-string SQL builder in Python

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

pgjoneson Show HN: SQL-tString a t-string SQL builder in Python

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

pgjoneson PEP 750 – Template Strings

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.

pgjoneson What's up Python? Django get background tasks, a new REPL, bye bye gunicorn

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():
        ...

In addition Hypercorn, https://github.com/pgjones/hypercorn, (a ASGI and WSGI) also does not use gunicorn, having migrated many years ago.

pgjoneson Visualizing algorithms for rate limiting

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

pgjoneson Tell HN: Flask and Quart have now partially merged

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

pgjoneson Tell HN: Flask and Quart have now partially merged

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

pgjoneson Ask HN: Could you share your personal blog here?

https://pgjones.dev

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

pgjoneson Ask HN: What have you created that deserves a second chance on HN?

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.

pgjoneson There are no open issues or pull requests on Flask

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.

pgjoneson There are no open issues or pull requests on Flask

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.

pgjoneson Gunicorn

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

pgjoneson Show HN: OpenAPI fuzzer – fuzzing APIs based on OpenAPI specification

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.

pgjoneson QUIC and HTTP/3 Support Now in Firefox Nightly and Beta

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

(I'm the author of Hypercorn).

pgjoneson Show HN: Moneyed – be your own financial adviser – built with Quart and React

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.

pgjoneson Python Developers Survey 2019 Results

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

pgjoneson Comparing HTTP/3 vs. HTTP/2 Performance

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.

pgjoneson A QUIC look at HTTP/3

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).

pgjoneson Ask HN: Who is hiring? (February 2019)

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.

pgjoneson HTTP/1 should die; HTTP/2 can do everything HTTP/1 could, only faster

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

pgjoneson HTTP/1 should die; HTTP/2 can do everything HTTP/1 could, only faster

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?

pgjoneson HTTP/1 should die; HTTP/2 can do everything HTTP/1 could, only faster

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

Thanks for the comments.

pgjoneson Show HN: HTTP/2 Python-Asyncio Web Microframework

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.

pgjoneson Show HN: HTTP/2 Python-Asyncio Web Microframework

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

pgjoneson Show HN: HTTP/2 Python-Asyncio Web Microframework

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.

pgjoneson Show HN: HTTP/2 Python-Asyncio Web Microframework

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...)