Per tagliare con precisione pezzi di film da condividere per meme:

$ args=(
# taglio di precisione
--start=hh:mm:ss.ms
--end=hh:mm:ss.ms

# no sottotitoli
--sid=no

# amplificazione volume
--volume=150

--o=out.mp4
input.mkv
)
$ mpv "${args[@]}"

Articolo un po' vecchio trovato curiosando:
Non usate strings su files non fidati
https://lcamtuf.blogspot.com/2014/10/psa-dont-run-strings-on-untrusted-files.html

E da cui poi ho scoperto un fuzzer (tipi di software che scoprono bugs facendo brute force casuale - o con algoritmi genetici - sull'input di altri software)
https://en.wikipedia.org/wiki/American_fuzzy_lop_(fuzzer)

🗂 TI(re)L che su Dolphin si può cambiare cartella dalla barra di navigazione breadcrumb, tramite scroll su un certo livello di profondità

Java moment

https://stackoverflow.com/a/7847117
https://stackoverflow.com/a/38855689

Sostanzialmente i prodotti in java di IDEA salvano sulla clipboard di sistema degli oggetti serializzati. Altri programmi come MatLab e Netbeans recuperano questi oggetti e tentano di analizzarli, ma non trovano le classi, quindi stampano errori a caso ✅

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