primocode 10.16.0 → 10.17.0

package/editor/helpers/trilhas_humores.json

@@ -0,0 +1,66 @@
+{
+  "version": 1,
+  "about": "Humores da biblioteca de trilhas (helpers/trilhas.py) e o pedido pronto de cada um para o gen_music.py --humor. Só texto: nenhuma música vai junto com a skill.",
+  "moods": [
+    {
+      "id": "animada",
+      "label": "Animada",
+      "when": "energia, oferta, novidade",
+      "prompt": "Upbeat energetic instrumental for a social media ad, bright electronic pop with punchy drums, around 118 bpm, happy and exciting, steady energy from the first second, no vocals, leaves space for voiceover"
+    },
+    {
+      "id": "inspiradora",
+      "label": "Inspiradora",
+      "when": "conquista, virada de vida, motivação",
+      "prompt": "Inspiring motivational instrumental, uplifting piano and soft strings over a steady modern beat, around 95 bpm, hopeful and determined, builds gently, no vocals, leaves space for voiceover"
+    },
+    {
+      "id": "triste",
+      "label": "Triste",
+      "when": "dor, problema, desabafo",
+      "prompt": "Sad emotional instrumental, gentle solo piano with soft ambient pads, slow around 70 bpm, melancholic and reflective, sparse, no drums, no vocals, leaves space for voiceover"
+    },
+    {
+      "id": "tensa",
+      "label": "Tensa",
+      "when": "segredo, alerta, erro que as pessoas cometem",
+      "prompt": "Tense suspenseful instrumental, low pulsing synth bass and ticking percussion, dark cinematic atmosphere, around 90 bpm, mysterious and urgent, no vocals, leaves space for voiceover"
+    },
+    {
+      "id": "calma",
+      "label": "Calma",
+      "when": "explicação, tutorial, confiança",
+      "prompt": "Calm confident instrumental, soft lo-fi beat with warm electric piano, around 85 bpm, relaxed and trustworthy, steady, no vocals, leaves space for voiceover"
+    },
+    {
+      "id": "epica",
+      "label": "Épica",
+      "when": "revelação, resultado, grande virada",
+      "prompt": "Epic cinematic instrumental, big drums and rising orchestral strings, powerful and triumphant, around 100 bpm, dramatic build, no vocals, leaves space for voiceover"
+    },
+    {
+      "id": "divertida",
+      "label": "Divertida",
+      "when": "humor, bastidor, conteúdo leve",
+      "prompt": "Playful fun instrumental, quirky ukulele and light percussion with claps, around 110 bpm, cheerful and light, no vocals, leaves space for voiceover"
+    },
+    {
+      "id": "luxo",
+      "label": "Luxo",
+      "when": "produto premium, sofisticação",
+      "prompt": "Elegant sophisticated instrumental, smooth deep house groove with soft piano chords, around 120 bpm, premium and stylish, no vocals, leaves space for voiceover"
+    }
+  ],
+  "beats": {
+    "GANCHO": ["tensa", "animada"],
+    "PROBLEMA": ["triste", "tensa"],
+    "VIRADA": ["inspiradora", "epica"],
+    "PROVA": ["epica", "calma"],
+    "CHAMADA": ["animada", "inspiradora"],
+    "PASSO": ["calma"],
+    "RESULTADO": ["epica", "inspiradora"],
+    "CONTEXTO": ["calma", "triste"],
+    "EXPERIENCIA": ["inspiradora", "divertida"],
+    "RECOMENDACAO": ["animada", "calma"]
+  }
+}

package/editor/helpers/valores.py

@@ -0,0 +1,187 @@
+"""valores.py: reads numbers and money said in Portuguese (PT-BR speech and on-screen text).
+
+Library used by motion_sugerir.py. Normalizes accents and case (`norm`) and parses numbers written or spoken
+("1.200", "vinte e cinco") and money ("R$ 5 mil", "10k", "cinco mil reais", "meio milhão", "dois mil e
+quinhentos", the slang "milão", "seis dígitos"). Counts are not money: "10 mil seguidores" is a count.
+
+    norm(text) -> str                         lower case, no accents
+    parse_number("1.200") -> 1200.0           a plain number (digits or words)
+    parse_money("R$ 5 mil") -> 5000.0         the value of a money expression
+    find_money(norm(text)) -> [Money]         money spans in normalized text (start, end, value, bare)
+
+The regex pieces (DIGITS_RE, WORDNUM_RE, MULT_RE, CUR_RE) are public so detectors can build on them.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from dataclasses import dataclass
+
+# ------------------------------------------------------------------ normalization
+
+_PUNCT_MAP = {
+    "‘": "'", "’": "'", "´": "'", "`": "'",
+    "“": '"', "”": '"', "–": "-", "—": "-",
+    " ": " ", " ": " ", "…": "...", "*": "",
+}
+
+
+def normalize(text: str) -> tuple[str, list[int]]:
+    """Lowercase + strip accents. Returns (normalized, index map norm_pos -> original_pos)."""
+    out: list[str] = []
+    index: list[int] = []
+    for i, ch in enumerate(text):
+        mapped = _PUNCT_MAP.get(ch)
+        pieces = mapped if mapped is not None else unicodedata.normalize("NFKD", ch)
+        for piece in pieces:
+            if unicodedata.combining(piece):
+                continue
+            for c in piece.lower():
+                out.append(c)
+                index.append(i)
+    return "".join(out), index
+
+
+def norm(text: str) -> str:
+    return normalize(text)[0]
+
+
+# ------------------------------------------------------------------ numbers & money
+
+WORD_NUMBERS = {
+    "um": 1, "uma": 1, "dois": 2, "duas": 2, "tres": 3, "quatro": 4, "cinco": 5, "seis": 6,
+    "sete": 7, "oito": 8, "nove": 9, "dez": 10, "onze": 11, "doze": 12, "treze": 13,
+    "quatorze": 14, "catorze": 14, "quinze": 15, "dezesseis": 16, "dezessete": 17,
+    "dezoito": 18, "dezenove": 19, "vinte": 20, "trinta": 30, "quarenta": 40,
+    "cinquenta": 50, "sessenta": 60, "setenta": 70, "oitenta": 80, "noventa": 90,
+    "cem": 100, "cento": 100, "duzentos": 200, "duzentas": 200, "trezentos": 300,
+    "quatrocentos": 400, "quinhentos": 500, "seiscentos": 600, "setecentos": 700,
+    "oitocentos": 800, "novecentos": 900, "meio": 0.5, "meia": 0.5,
+}
+# "milão" is spoken slang for one million ("tá fazendo milão")
+MULTIPLIERS = {"mil": 1_000, "k": 1_000, "milhao": 1_000_000, "milhoes": 1_000_000, "milao": 1_000_000,
+               "miloes": 1_000_000, "mi": 1_000_000, "bilhao": 1_000_000_000, "bilhoes": 1_000_000_000,
+               "bi": 1_000_000_000}
+
+_WORDNUM_ALT = "|".join(sorted(WORD_NUMBERS, key=len, reverse=True))
+WORDNUM_RE = rf"(?:{_WORDNUM_ALT})(?:\s+e\s+(?:{_WORDNUM_ALT}))*"
+DIGITS_RE = r"\d{1,3}(?:\.\d{3})+(?:,\d{1,2})?|\d+(?:[.,]\d{1,2})?"
+NUM_RE = rf"(?:{DIGITS_RE}|\b{WORDNUM_RE})"
+MULT_RE = r"(?:mil|k|milhao|milhoes|milao|miloes|mi|bilhao|bilhoes|bi)"
+CUR_RE = r"(?:reais|real|contos?|pilas?|dolares|dolar|euros?|usd|brl)"
+# spoken compound amounts: "dois mil e quinhentos", "um milhão e meio", "um milhão e 200 mil"
+_COMPOUND_TAIL = rf"(?:\s+e\s+(?:meio|meia|(?:{WORDNUM_RE}|\d{{1,3}})(?:\s+mil\b)?))?"
+# "seis dígitos de faturamento": the number of digits of an amount
+DIGIT_COUNT_RE = r"(?:cinco|seis|sete|oito|nove|5|6|7|8|9)\s+digitos\b"
+
+MONEY_RE = (
+    rf"(?:(?:r\$|us\$|u\$|\$|€)\s*(?:{DIGITS_RE})(?:\s*{MULT_RE}\b)?(?:\s+(?:de\s+)?{CUR_RE}\b)?"
+    rf"|(?<![\w$]){NUM_RE}\s*{MULT_RE}\b{_COMPOUND_TAIL}(?:\s+(?:de\s+)?{CUR_RE}\b)?"
+    rf"|(?<![\w$]){NUM_RE}\s+(?:de\s+)?{CUR_RE}\b"
+    rf"|\bmil\s+e\s+(?:{WORDNUM_RE}|\d{{1,3}})\b(?:\s+(?:de\s+)?{CUR_RE}\b)?"
+    rf"|\bmil\s+(?:de\s+)?{CUR_RE}\b"
+    rf"|(?<![\w$]){DIGIT_COUNT_RE}"
+    rf"|\b(?:mil\s+)?milh?(?:ao|oes)\b{_COMPOUND_TAIL}(?:\s+(?:de\s+)?{CUR_RE}\b)?)"
+)
+_MONEY_COMPILED = re.compile(MONEY_RE)
+
+# Nouns that make a bare "10 mil" a count, not money.
+NON_MONEY_NOUNS = re.compile(
+    r"\s*(?:de\s+)?(?:seguidor\w*|inscrit\w*|visualiza\w*|views?|curtidas?|likes?|pessoas?|alun\w*|"
+    r"clientes?|leads?|vendas?|pedidos?|unidades?|produtos?|pecas?|metros?|km|quilos?|kg|horas?|"
+    r"minutos?|dias?|anos?|mensage\w*|comentarios?|compartilhament\w*|downloads?|acessos?|cliques?|"
+    r"impress\w*|membros?|usuari\w*|contatos?|numeros?|videos?|posts?|lojas?|fornecedor\w*|itens|"
+    r"copias?|livros?|pacotes?|caixas?|vezes|passos|reels|stories|grupos?|mulheres|homens|familias?)\b"
+)
+
+
+@dataclass
+class Money:
+    start: int
+    end: int
+    value: float | None
+    bare: bool  # no currency marker (R$, reais...): needs context to count as money
+
+
+def parse_number(token: str) -> float | None:
+    token = token.strip()
+    if not token:
+        return None
+    if re.fullmatch(r"\d{1,3}(?:\.\d{3})+(?:,\d{1,2})?", token):
+        return float(token.replace(".", "").replace(",", "."))
+    if re.fullmatch(r"\d+(?:[.,]\d{1,2})?", token):
+        return float(token.replace(",", "."))
+    words = [w for w in re.split(r"\s+e\s+|\s+", token) if w]
+    if words and all(w in WORD_NUMBERS for w in words):
+        return float(sum(WORD_NUMBERS[w] for w in words))
+    return None
+
+
+def _parse_compound(t: str) -> float | None:
+    """'dois mil e quinhentos' -> 2500, 'mil e quinhentos' -> 1500, 'um milhão e meio' -> 1.5e6."""
+    m = re.fullmatch(r"(?:(.+?)\s+)?(mil|milhao|milhoes|milao|miloes)\s+e\s+(meio|meia|.+?)(?:\s+(mil))?", t)
+    if not m:
+        return None
+    unit = float(MULTIPLIERS[m.group(2)])
+    head = parse_number(m.group(1)) if m.group(1) else 1.0
+    if head is None:
+        return None
+    if m.group(3) in ("meio", "meia"):
+        return head * unit + unit / 2
+    tail = parse_number(m.group(3))
+    if tail is None:
+        return None
+    tail *= 1000.0 if m.group(4) else 1.0
+    return head * unit + tail if tail < unit else None
+
+
+def parse_money(text: str) -> float | None:
+    """Value in currency units of a money expression. '5 mil' -> 5000, 'R$ 1.500,00' -> 1500."""
+    t = norm(text)
+    t = re.sub(r"(?:r\$|us\$|u\$|\$|€)", " ", t)
+    t = re.sub(rf"\b(?:de\s+)?{CUR_RE}\b", " ", t).strip()
+    digits = re.fullmatch(DIGIT_COUNT_RE, t)
+    if digits:
+        n = WORD_NUMBERS.get(t.split()[0]) or float(t.split()[0])
+        return float(10 ** (int(n) - 1))
+    compound = _parse_compound(" ".join(t.split()))
+    if compound is not None:
+        return compound
+    mult = 1.0
+    m = re.search(rf"({MULT_RE})\s*$", t)
+    if m and (m.start(1) == 0 or not t[m.start(1) - 1].isalpha()):
+        mult = float(MULTIPLIERS[m.group(1)])
+        t = t[: m.start(1)].strip()
+    if not t:
+        return mult if mult > 1 else None
+    if t == "mil":  # "mil reais" -> 1000 · "mil milhão" (speech slip) -> 1 milhão
+        return 1_000.0 if mult == 1.0 else mult
+    base = parse_number(t)
+    if base is None:
+        return None
+    return base * mult
+
+
+def find_money(ntext: str) -> list[Money]:
+    """Money spans in normalized text."""
+    found: list[Money] = []
+    for m in _MONEY_COMPILED.finditer(ntext):
+        s = m.group(0).rstrip()
+        start, end = m.start(), m.start() + len(s)
+        bare = not re.search(rf"(?:r\$|\$|€|\b{CUR_RE}\b)", s)
+        if re.search(r"digitos$", s):
+            if re.search(r"\b(?:senha|codigo|numero|pin|token|cep|cpf|cnpj|telefone|celular|chave)\s+(?:\w+\s+)?(?:de|com)\s+$",
+                         ntext[max(0, start - 30):start]):
+                continue  # "senha de 6 dígitos"
+            bare = False
+        counted = NON_MONEY_NOUNS.match(ntext, end) if bare else None
+        if counted and not re.match(r"\s+(?:passad[oa]|retrasad[oa]|atras)\b", ntext[counted.end():]):
+            continue  # "10 mil seguidores" is a count ("1 milhão ano passado" is still money)
+        if bare and re.fullmatch(r"\d+\s*(?:mi|bi)", s):  # "5 mi" is too ambiguous alone
+            continue
+        if s in ("milao", "miloes") and re.search(r"\b(?:em|de|para|pra|pro|a|ao|da|do|na|no|via|ate)\s+$",
+                                                  ntext[max(0, start - 8):start]):
+            continue  # "fui pra Milão": the city, not the slang
+        found.append(Money(start, end, parse_money(s), bare))
+    return found