I am working on a rudimentary Breakout clone, and I was doing the wall collision. I have a function that I initially treated as a Boolean, but I changed it to return a different value depending on which wall the ball hit. I used the walrus operator to capture this value while still treating the function like a bool. I probably could have just defined a variable as the function's return value, then used it in an if statement. But it felt good to use this new thing I'd only heard about, and didn't really understand what it did. I was honestly kind of surprised when it actually worked like I was expecting it to! Pretty cool.

Events

• 14 October
  • CLEpy meetup - via https://fosstodon.org/@clepy/113311328924148486

Releases

• 14 October
  • pyparsing 3.2.0 - via https://fosstodon.org/@ptmcg/113302603878074247
• 15 October
  • eve 2.2 - via https://fosstodon.org/@nicola/113310333550705121
  • pillow 11.0.0 - via https://mastodon.social/@hugovk/113312137194438039 (and https://fosstodon.org/@pillow/113312110767354794)
  • validate-pyproject 0.21 - via https://fosstodon.org/@henryiii/113312246938821428

Via https://mamot.fr/@fp/113311994869600315

Via https://fosstodon.org/@quentinpradet/113311962538364238

(For context, I'm basically referring to Python 3.12 "multiprocessing.Pool Vs. concurrent.futures.ThreadPoolExecutor"...)

Today I read that multiple cores (parallelism) help in CPU bound operations. Meanwhile, multiple threads (concurrency) is due when the tasks are I/O bound.

Is this correct? Anyone cares to elaborate for me?

At least from a theorethical standpoint. Of course, many real work has a mix of both, and I'd better start with profiling where the bottlenecks really are.

If serves of anything having a concrete "algorithm". Let's say, I have a function that applies a map-reduce strategy reading data chunks from a file on disk, and I'm computing some averages from these data, and saving to a new file.

Hi,

I'm already using

from smtplib import SMTP_SSL
from email.message import EmailMessage

To send emails.

Now I would like to be able to encrypt them with the public key of the recipient. ( PublicKey.asc )

import smtplib
from email.message import EmailMessage
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

# Load the ECC public key from the .asc file
with open('recipient_public_key.asc', 'rb') as key_file:
    public_key_bytes = key_file.read()
public_key = ec.EllipticCurvePublicKey.from_public_bytes(
    ec.SECP384R1(),
    public_key_bytes
)

# Create the email message
msg = EmailMessage()
msg.set_content('This is the encrypted email.')
msg['Subject'] = 'Encrypted Email'
msg['From'] = '[email protected]'
msg['To'] = '[email protected]'

# Encrypt the email message using the ECC public key
nonce = bytes.fromhex('000102030405060708090a0b0c0d0e0f')
cipher = AESGCM(public_key.public_key().secret_key_bytes)
ciphertext = cipher.encrypt(nonce, msg.as_bytes(), None)

# Send the encrypted email
server = smtplib.SMTP('smtp.example.com')
server.send_message(msg, from_addr='[email protected]', to_addr='[email protected]')
server.quit()

# Save the encrypted email to a file
with open('encrypted_email.bin', 'wb') as f:
    f.write(ciphertext)

I like the approach, only one "low level" import cryptography

but the code seem wrong. if the body has been encrypted as ciphertext I don't see this one included while sending the email.

How are you doing it ? or do you have good tutorial, documentations ? because I found nothing "pure and simple" meaning not with of unnecessary stuff.

Thanks.

via https://mstdn.social/@miguelgrinberg/113266572735273155

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