ivoflipse

I was going to comment the same thing, rather than push off harder, I'd hope it help brace for impact and relieve some of the weaker muscles.

Yes, I should perhaps be doing strength training, but I have limited hours to exercise and I'd prefer to spend them running rather than training so that eventually I could be running.

Another thing that happens is that your technique gets worse during longer runs, making you more prone to injuries. Maybe a device like this could either support you so you can run longer runs or compensate to make sure you don't hurt yourself.

So if this device helps with reducing running based injuries, I'm all for it

I have an electric cargo bike that I put in one of the lowest settings, if I cycle at the top speed it doesn't help much if at all. But accelerating from a dead stop is nice. This could be similar

Not today, it requires wgpu-py to support running on WASM / pyodide, which it doesn't yet (unfortunately)

This library builds upon pygfx and wgpu-py. Unfortunately, the latter doesn't support running on WASM, pyscript or pyodide yet, but there's an issue about it:

https://github.com/pygfx/wgpu-py/issues/407

PRs welcome though :-)

Fastplotlib definitely works in Jupyterlab through jupyter-rfb https://github.com/vispy/jupyter_rfb

I believe the performance is pretty decent, especially if you run the kernel locally

Their docs also cover this as mentioned by @clewis7 below: https://www.fastplotlib.org/ver/dev/user_guide/faq.html#what...

In related news, their ISO 27001 certificate just expired. Seems in line with their overall security posture then https://img1.wsimg.com//Sitecore/6/1/registrar-iso27001-cert...

His Google Tech Talk made me really appreciate his groups work, even though I have no need for time series analysis

https://youtu.be/vzPgHF7gcUQ?si=rKQvOjK_qjiSSvKE

This is actively being discussed https://discuss.python.org/t/publish-linux-installer-on-pyth...

A big holdup seems to be who would maintain this in the CPython project. Perhaps some Astral folks could become core devs as well and maintain it upstream

The Faster CPython team at least is aware of the paper and probably will look into it

https://github.com/faster-cpython/ideas/issues/707

I reckon you're aware of it, but they're actively discussing a lock file format PEP and I'm quite hopeful this time it will actually get accepted

https://discuss.python.org/t/pep-751-now-with-graphs/69721

If you've submitted a 510k for your medical device, you can advertise it as "510k pending".

There is a risk that you never receive the clearance or approval, but in this case Apple probably knew they had already addressed any feedback the FDA had so it was very likely there would be no further stumbling blocks

Learned Optimism has a similar style of explaining the author's work over many years in an accessible manner

Did they provide you with Instructions for Use as a lay person? This might contain the legalese on what is or isn't permissible.

The company is required to have a complaint handling process, such that you making them aware of these vulnerabilities would mean they have to at least handle the feedback.

Maybe your findings can be rephrased in a way that don't require you to show how vulnerable their servers are, but that you suspect it's unsafe.

You can participate in the latest iteration of discussing this feature here: https://discuss.python.org/t/introducing-a-safe-navigation-o...

It helps that in the Netherlands we subtitle rather than dub foreign (and thus most English) speaking content. I was surprised when watching Forest Gump to hear that "Shit happens" is translated to "Scheisse passiert" and my German speaking friends didn't even know the English version. Ironically, I think most German speakers are more familiar with Arnold Schwarzenegger's voice actor, than his own voice while being from Austria.

Our music also contains more English music than German, which doesn't seem to be the case in Germany.

So in the Netherlands, we're exposed to English a lot more than German, French or Spanish speaking countries. I bet the same applies to the Nordic countries, which also have great English speaking ability

Shameless plug for a similar project called Collagraph (https://github.com/fork-tongue/collagraph).

From the README: Write your Python interfaces in a declarative manner with plain render functions, component classes or even single-file components using Vue-like syntax, but with Python!

  - Reactivity (made possible by leveraging observ)
  - Function components
  - Class components with local state and life-cycle methods/hooks
  - Single-file components with Vue-like syntax (.cgx files)
  - Custom renderers

Currently there are two renderers:

PysideRenderer: for rendering PySide6 applications PygfxRenderer: for rendering 3D graphic scenes with Pygfx

It is possible to create a custom Renderer using the Renderer interface, to render to other UI frameworks, for instance wxPython, or even the browser DOM.

Checkout fastplotlib, which should be quite capable of what you're after and it works great in a Notebook https://github.com/kushalkolar/fastplotlib

Alternatively, try pygfx for ThreeJS graphics in Python leveraging wgpu. It works great in Notebooks through notebook-rfb. https://github.com/pygfx/pygfx

If you're adventurous, figure out how to make pygfx work with webgpu via wasm

Welcome to the problem the Scientific Python community has been struggling with for years. Providing binaries for a plurality of platforms brings challenges with it, but I reckon on the major platforms Pydantic will be fine as they won't have hard to compile parts.

But Rust isn't available everywhere, so surely someone will be losing out.

You could implement a HTML renderer with Collagraph (https://github.com/fork-tongue/collagraph).

From the README: Write your Python interfaces in a declarative manner with plain render functions, component classes or even single-file components using Vue-like syntax, but with Python!

  - Reactivity (made possible by leveraging observ)
  - Function components
  - Class components with local state and life-cycle methods/hooks
  - Single-file components with Vue-like syntax (.cgx files)
  - Custom renderers

If you use C-extensions or platform specific packages like pywin32, how would.you expect them to NOT be platform specific? Would you want it to only allow pure Python packages?

You could look into cibuildwheel, to have more control over what Python versions are used to build a wheel, but as the name implies not a great solution for running it locally.

Otherwise you'll have to be rather specific about what Python interpreter to use. For example using the python launcher for Linux (https://github.com/brettcannon/python-launcher).

Looking through the docs of pdm, Hatch or Poetry, I can't really find a definitive answer if they will use the Python version you specify. They all at least need to be able to locate the correct Python version in order to do so. It would be great if managing Python versions was something that came along with Python, so that these tools could rely on it more.

You're situation is related to this: https://pypackaging-native.github.io/key-issues/native-depen... Where it is incredibly hard to align various pieces of software spanning OSes, architectures, programming languages. The result is that you have to compile the whole universe for them to work together. In your case that universe is stuck on 2.7 and it will require a large effort to get everything up compatible with a recent Python version

Here's an entire website dedicated to these challenges: https://pypackaging-native.github.io/

Written by one of the maintainers of scipy

Another lucky winner: https://peps.python.org/pep-0668/

This PEP is meant to ensure you don't clobber your Linux distro's base environment and break key OS applications.

Also, this problem doesn't exist on e.g. Windows, where there is no OS installed python to clobber. Other folks have taught themselves to always use virtual environments for this very reason and therefore don't share your problem.

Hence, there are tutorials out there that don't talk about your problem and tools exist where the default behavior might be dangerous on your Linux distro.

Lucky for you, there's a new PEP proposing just that: https://discuss.python.org/t/pep-704-require-virtual-environ... Written by the author of this blog post no less!

However, you'll find that as with all packaging discussions there are people opposing it, because their workflow doesn't match yours and they don't want to change how they work. We, as a community, need a way to resolve such stalemates or I fear we won't make much headway

It’s a new website which attempts tot comprehensively describe the key problems scientific, data science, ML/AI and other native-code-using projects & authors have with PyPI, wheels and Python packaging. It is meant to serve as an up-to-date reference, which will hopefully help facilitate discussions around potential solutions and design changes in Python packaging related to any of these topics.

Rather than using matplotlib, you could try either pygfx (https://github.com/pygfx/pygfx) or fastplotlib (https://github.com/kushalkolar/fastplotlib) to make higher performance graphics using Python.

However, it won't solve your problem of Python not being fast enough doing the calculations.

For people who think electric heating is the solution, now replace it with 0.98 euro/kWh, which my current rate in the Netherlands since November. Though heating with gas is equally bad at 3.3 euro per me. I'm paying roughly 600 euro a month just to heat our home to 17 deg C

You'll like what we've done during my Hackathon https://github.com/fork-tongue/collagraph/pull/66

We added support for PyScript using Collagraph, which allows you to define single file components with a Vue-like syntax.

Excerpt from the project README:

Write your Python interfaces in a declarative manner with plain render functions, component classes or even single-file components using Vue-like syntax, but with Python!

- Reactivity (made possible by leveraging observ)

- Function components

- Class components with local state and life-cycle methods/hooks

-Single-file components with Vue-like syntax (.cgx files)

- Custom renderers (PySide, pygfx and now PyScript)

That Python dev (Mark Shannon) is part of the Microsoft team :-)

There you go: https://github.com/faster-cpython/ideas