Python

I am trying to follow this tutorial (Announcing py2wasm: A Python to Wasm compiler · Blog · Wasmer) and run py2wasm but I am getting this weird problem.

First is that I believe py2wasm might be just an executable like other pip packages I install, or a bat file. (I am fairly new to python and I just want to convert a python code to wasm). But when I head over to C:\Users\USER\AppData\Local\Programs\Python\Python312\Scripts where the pip packages are located, I can't seem to find any file related to py2wasm.

Running dir C:\Users\USER\AppData\Local\Programs\Python\Python312\Lib\site-packages\py2wasm* to check any related files about the py2wasm folder only leads to this

Directory: C:\Users\USER\AppData\Local\Programs\Python\Python312\Lib\site-packages

Mode LastWriteTime Length Name

***

d----- 04-10-2024 19:54 py2wasm-2.6.2.dist-info

Also, before you could ask yeah I could run other pip packages such as yt-dlp.

via https://fosstodon.org/@europython/113242551122295216

via https://mastodon.social/@treyhunner/113230504133387015

via https://mastodon.social/@hynek/113227146595211210

I've been writing code professionally for 24 years, 15 of which has been Python and 9 years of that with Docker. I got tired of running into the same complications every time I started a new job, so I wrote this. Maybe you'll find it useful, or it could even start a conversation, but this post has been a long time coming.

Update: I had a few requests for a demo repo as a companion to this post, so I wrote one today. It includes a very small Django demo user Docker, Compose, and GitLab CI.

A library for creating fully typed and declarative API clients, quickly and easily.

What would an API client with this library look like?

For a single API endpoint over HTTP GET, it could look something like this:

from dataclasses import dataclass
import quickapi


# An example type that will be part of the API response
@dataclass
class Fact:
    fact: str
    length: int


# What the API response should look like
@dataclass
class ResponseBody:
    current_page: int
    data: list[Fact]


# Now we can define our API
class MyApi(quickapi.BaseApi[ResponseBody]):
    url = "https://catfact.ninja/facts"
    response_body = ResponseBody

And you would use it like this:

response = MyApi().execute()

# That's it! Now `response` is fully typed (including IDE support) and conforms to our `ResponseBody` definition
assert isinstance(response.body, ResponseBody)
assert isinstance(response.body.data[0], Fact)

It also supports attrs or pydantic (or dataclasses as above) for your model/type definitions, including validation and types/data conversion.

I have a lot more examples (e.g. POST requests, query string params, authentication, error handling, model validation and conversion, multiple API endpoints) on the repo's README.

I've shared this one here before but it's been a while and I've added a lot of features since.

Github repo: https://github.com/martinn/quickapiclient

via https://fosstodon.org/@adamchainz/113158552844057284

via https://mastodon.social/@treyhunner/113150024938712511

via https://fosstodon.org/@dongheena/113126553653153451

via https://fedi.simonwillison.net/@simon/113102865356065670

New to CircuitPython, this feels like it should work according to the docs but it prints six Falses. Any ideas?

#!/usr/bin/env python
import board
import digitalio
import time

class body_controller:

  def __init__(self):
    SWDIO = board.D5
    self._reset_pin = digitalio.DigitalInOut(SWDIO)
    print(self._reset_pin.value)
    self._reset_pin.switch_to_output(True)
    print(self._reset_pin.value)

  def turn_on(self):
    print(self._reset_pin.value)
    self._reset_pin.value = False
    print(self._reset_pin.value)
    time.sleep(1)
    print(self._reset_pin.value)
    self._reset_pin.value = True
    print(self._reset_pin.value)

body = body_controller()
time.sleep(1)
body.turn_on()
time.sleep(1)

via https://mastodon.social/@hugovk/113097578994494173

Ive learned a decent bit of python from a trade school I was in and I am really interested in learning more and eventually do freelance work

And I'm looking for advice on ensuring I know enough to do that as well as some advice getting started

In this article we will explore some lesser known, but interesting and useful corners of Python standard library.

...

To provide more powerful containers for storing data in memory Python ships a collection module ...

Python has with keyword to create context manager that will auto-cleanup things within lexical scope ...

To address this problem, Python ships decimal module that allows us represent decimal numbers as Python objects with operator overloading ...

Likewise, we can run into problem when dealing with fractions - one third is not exactly equal to 0.333… Python ships with fractions module to represent them as Python objects with operator overloading ...

The standard Python installation ships with dis module that takes Python code units (e.g. a function) and disassembles the code into a kind of pseudo-assembler ...

Python statistics module provides a small toolkit of statistical algorithms for relatively simple applications where it is an overkill to use Pandas or Numpy: standard deviation, several kinds of average of numeric data, linear regression, correlation, normal distribution and others ...

To make this easier Python ships a webbrowser module with simple API to make a browser show a page ...

To make this less terrible Python ships zipapp module with CLI tool and Python API to package Python code into single file packages ...

Hi, folks!

I'd like to set up my emacs with lsp-mode and lsp-ui, but I am finding myself in some analysis paralysis. Ruling out the Palantir language server because it's deprecated and because it's Palantir, that still leaves me with five language server recommendations from lsp-mode.

Anybody have any opinions they'd like to share? Any really bad experiences I should avoid? How do I configure your favorite? (Feel free to assume I know very little about configuring emacs.)

If it makes a difference, I am a poetry user and a religious mypy --strict user.

Thanks in advance!

I'm currently doing Dr. Charles Severence's lessons on FreeCodeCamp to try to learn Python3. I'm on lesson exercise 02_03 and confused about multiplying floating-point and integer values.

The goal is to write a Python program multiplying hours worked by pay rate to come up with a pay quantity.

This is the code I wrote:

h = input("Enter hours: ")
r = input("Enter pay rate: ")
p = float(h) * r

I got a traceback error, and the video said the correct way to solve said error was change Line 3 from p = float(h) * r to p = float(h) * float(r).

However, what I'm confused about is why would I need to change r to a floating-point value when it's already a floating-point value (since it'd be a currency value like 5.00 or something once I typed it in per the input() command*?

What am I missing here?

*I can't remember: are the individual commands in a python line called "commands"?

Edit: Wrote plus signs in my post here instead of asterisks. Fixed.

EDIT: Thanks to @Labna@lemmy.world and @woop_woop@lemmy.world. I thought that the input() function was a string until the end-user types something in upon being prompted, and then becomes a floating-point value or integer value (or stays a string) according to what was typed.

This is incorrect: the value is a string regardless of what is typed unless it is then converted to another type.

I read some articles about using a virtual environment in Docker. Their argument are that the purpose of virtualization in Docker is to introduce isolation and limit conflicts with system packages etc.

However, aren't Docker and Python-based images (e.g., python:*) already doing the same thing?

Can someone eli5 this whole thing?

via https://mastodon.social/@hynek/113067230489781151

For every bytecode compiled language, the most interesting part of its implementation is its virtual machine (also referred to as the bytecode interpreter) where the bytecode execution takes place. Because this is such a crucial part of the language machinery, its implementation has to be highly performant. Even if you are not a compiler engineer, learning about such internal implementation can give you new performance tricks and insights that you may be able to use in other places of your job. And, if you are a compiler engineer then you should always look around how other languages are implemented to pickup implementation details that you may not be aware of.

In this article, we are going to be discussing the bytecode instruction format of CPython, followed by the implementation of the bytecode evaluation loop of the interpreter where the bytecode execution takes place.