Python è così dinamico che è possibile accedere a tutti i nomi (variabili, funzioni, ecc) attraverso stringhe (esempio obj.__dict__['attr']).

Peccato però che non ha una funzione built-in nameof() come C#...
(esempio nameof(my_var) → 'my_var').

Le implicazioni?
1. In un refactoring c'è il grosso rischio di non includere anche quelle stringhe inserite a mano
2. Non c'è alcun obbligo di esistenza di quel nome: se a un certo punto la variabile puntata cambia nome, quella stringa rimarrà così com'è e niente (ne interprete, ne IDE) segnerà errore.
3. Non poter usare tutte le funzionalità dell'IDE quali ad esempio Find Usages

Cursed python

>>> __builtins__['dict'] = list
>>> a = dict()
>>> a += [4]
>>> a
[4]

Potrebbe tornare utile per fare monkey-patching di cose built-in dato che non è possibile modificarne direttamente i nomi tipo dict.__getattr__ = ...

>>> class js_dict(dict):
    # Useful to use attribute names instead of strings

    def __getattr__(self, key):
        if not key in self:
            return
        return self.__getitem__(key)

    def __setattr__(self, key, value):
        self.__setitem__(key, value)

    def __delattr__(self, key):
        self.__delitem__(key)

>>> __builtins__['dict'] = js_dict  # noqa
>>> a = dict(name='my', value=3)
>>> a.name
'my'

Molto bene 😎
Edit: https://docs.python.org/3/reference/executionmodel.html#builtins-and-restricted-execution

Ho appena scoperto che da Python 3.8 esiste typing.Protocol: una classe da estendere molto base non istanziabile, per creare stub utilizzabili negli static-type checkers.

In questo modo è possibile ottenere dei warning nel caso in cui si stiano facendo stronzate, pur mantenendo la dinamicità di python ❤️

Esiste pure il decorator @typing.runtime_checkable che permette ai Protocol di essere usati in controlli runtime isinstance() e issubclass() come se fossero vere classi

https://docs.python.org/3/library/typing.html#typing.Protocol

Python non finisce mai di stupirmi
https://docs.python.org/3/howto/denoscriptor.html

Quando cerchi la soluzione ottimale, ma Python è buggato:
get_type_hints() non trova i tipi dichiarati in seguito nel codice, neanche con from __future__ import annotations
(come in C quando vengono dichiarate delle funzioni in ordine sbagliato e non si vedono)

https://bugs.python.org/issue44926

*cries*

Dato che
1. nameof non esiste
2. Non voglio dipendere da un'altra libreria varname
3. In ogni caso non posso fare riferimento ad un'annotazione (perché l'attributo non esiste)

...ho creato un nuovo metodo 😃
Semplicemente va a recuperare l'ultimo nome dalle annotazioni dello scope precedente.

import inspect
from typing import List

def last_name() -> str:
prev_scope = inspect.currentframe().f_back
a = prev_scope.f_locals.get('__annotations__')
if not a:
raise AttributeError(
"At least one annotation must be defined."
)
return next(reversed(a.keys()))

class Dummy:
id: str
K_ID = last_name()
library: List
K_LIB = last_name()

assert Dummy.K_ID == 'id'
assert Dummy.K_LIB == 'library'

GBoard stava andando così lenta che mi stava aggiungendo ben 200ms a carattere wtf (anche a cancellare)

Il router:

(per fortuna non lo sento)

Ma se non usa le cose in cache allora a che serve...

Go ahead, make firefox crash
about:cache?storage=disk

:)
https://youtrack.jetbrains.com/issue/PY-46814

Possibile workaround

class A:
    @classmethod
    def m(cls):
        return cls()

class B(A):
    @classmethod
    def m(cls) -> B: ...
    del m

Edit: ricordavo male... un decorator non può cancellare un metodo...
Edit2: basta cancellarlo a mano lol

Ah yes, scrollbar in stile chromium

Altro bug 😭

Il metodo typing.get_args dovrebbe ritornare gli argomenti del tipo generico passato:

assert typing.get_args(Dict[int, str]) == (int, str)

Peccato che quando si fa from __future__ import annotations, tutte le annotazioni di tipi diventano stringhe per permettere forward-references, e quel metodo non funziona sulle stringhe............

https://stackoverflow.com/questions/62871524/is-pep-585-unusable-at-runtime-under-python-3-7-and-3-8

Hmm, a quanto pare il problema emerge solo con quel
from __future__ import annotations

ancora lui...

Edit: no, l'IDE non mostrava nulla ma a runtime esplode per via della f.r.

E ovviamente senza quell'import bisogna definire le singole forward-references a mano come stringhe

Stavo pensando...
Ma se è così una palla tenere aggiornate le app FOSS su android non-root... perché non sfruttare ADB?
Si tiene un software su PC che, collegato il telefono, controlla le versioni e invia i comandi per installare gli aggiornamenti.

Non ci sono popup fastidiosi con installazioni da ADB giusto?

Edit: magari non viene neanche fuori l'odioso popup ricorrente (→ dark pattern) AtTtiVa pLAY PrOtEcT!!1!

Confermo, non ci sono popup fastidiosi con installazioni da ADB ✅

(Motorola E7 plus, android 10 stock)

Stavo risistemando i miei bookmarks su firefox, quando ho ritrovato questa pagina che mi ero salvato parecchi anni fa per curiosità
http://mrmms.blogspot.it/

Se avete qualche idea su cosa potrebbe contenere fatemelo sapere 😂