Ezarpenak batzuk daude:
- gehitu audio=0 audioa kentzeko
- gehitu header=0 titulua kentzeko
- gehitu tabs=0 partitura nagusia bakarrik ikusteko. Bestela dantza-ren partitura guztiak agertuko dira, webgunean bezala
... ]]>
Oso erraza da scrtipa erabiltzea:
$ ./guau.py https://guau.eus/s/ainguratuak#!/usr/bin/env python3
"""
Guau-ko podcasteko audio atalak deskargatzen ditu honetatik:
- sailaren orria: https://guau.eus/s/<slug>
- RSS jario zuzena: https://guau.eus/series/<id>/rss.xml
Guau-ren RSS jarioak normalean sail bereko denboraldi guztiak biltzen ditu
(itunes:season etiketa anitz, jario berean).
Mendeko liburutegia: Python liburutegi estandarra soilik.
"""
from __future__ import annotations
import argparse
import re
import ssl
import sys
import urllib.error
import urllib.request
import xml.etree.ElementTree as ET
from pathlib import Path
from urllib.parse import urlparse, urlunparse
GUAU_HOSTS = ("guau.eus", "www.guau.eus")
ITUNES_NS = {"itunes": "http://www.itunes.com/dtds/podcast-1.0.dtd"}
DEFAULT_UA = (
"Mozilla/5.0 (compatible; GuauPodcastFetcher/1.0; +https://guau.eus/)"
)
def _parse_itunes_int(el: ET.Element | None) -> int | None:
if el is None or not el.text:
return None
t = str(el.text).strip()
if t.lstrip("-").isdigit():
n = int(t)
return n if n >= 0 else None
return None
def fetch(url: str, timeout: int, user_agent: str) -> bytes:
req = urllib.request.Request(
url,
headers={"User-Agent": user_agent, "Accept": "*/*"},
)
ctx = ssl.create_default_context()
with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
return resp.read()
def normalize_guau_url(url: str) -> str:
p = urlparse(url.strip())
if not p.scheme:
p = urlparse("https://" + url.strip().lstrip("/"))
if p.netloc.lower() in ("guau.eus", "www.guau.eus") and not p.scheme:
p = p._replace(scheme="https")
return urlunparse(p)
def discover_rss_url(series_page_html: str) -> str | None:
# Lehenengo /series/<id>/rss.xml esteka erakusten den sailari dagokio
# (orrialdearen hydratazioa, erlazionatutako «related» blokeak baino lehen).
matches = re.findall(
r"https://guau\.eus/series/(\d+)/rss\.xml",
series_page_html,
)
if not matches:
return None
sid = matches[0]
return f"https://guau.eus/series/{sid}/rss.xml"
def parse_rss_items(
rss_xml: bytes,
) -> list[tuple[str, str, int | None, int | None, int | None]]:
"""Itzultzen du (izenburua, mp3_url, byte_kopurua, denboraldia, atala) <item> bakoitzeko.
byte_kopurua: RSS-ko length atributua. denboraldia / atala: itunes:season, itunes:episode.
"""
root = ET.fromstring(rss_xml)
channel = root.find("channel")
if channel is None:
return []
out: list[tuple[str, str, int | None, int | None, int | None]] = []
for item in channel.findall("item"):
title_el = item.find("title")
title = (title_el.text or "").strip() if title_el is not None else ""
enc = item.find("enclosure")
if enc is None:
continue
mp3 = enc.get("url") or ""
if not mp3:
continue
raw_len = enc.get("length")
length: int | None = None
if raw_len and str(raw_len).strip().isdigit():
length = int(str(raw_len).strip())
if length <= 0:
length = None
season = _parse_itunes_int(item.find("itunes:season", ITUNES_NS))
episode = _parse_itunes_int(item.find("itunes:episode", ITUNES_NS))
out.append((title, mp3, length, season, episode))
return out
def multi_season_feed(items: list[tuple[str, str, int | None, int | None, int | None]]) -> bool:
"""True, RSS-ak bi denboraldi edo gehiago baditu, edo 1 baino handiago den denboraldi bat (SxxEyy)."""
seasons = {s for _, _, _, s, _ in items if s is not None}
if len(seasons) > 1:
return True
if seasons and max(seasons) > 1:
return True
return False
def http_head_content_length(url: str, timeout: int, user_agent: str) -> int | None:
req = urllib.request.Request(
url,
method="HEAD",
headers={"User-Agent": user_agent, "Accept": "*/*"},
)
ctx = ssl.create_default_context()
try:
with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
cl = resp.headers.get("Content-Length")
if cl and str(cl).strip().isdigit():
n = int(str(cl).strip())
return n if n > 0 else None
except (urllib.error.HTTPError, urllib.error.URLError, OSError, ValueError):
pass
return None
def resolved_expected_bytes(
mp3_url: str,
rss_length: int | None,
timeout: int,
user_agent: str,
) -> int | None:
if rss_length is not None:
return rss_length
return http_head_content_length(mp3_url, timeout, user_agent)
def safe_filename(
title: str,
index: int,
season: int | None,
episode: int | None,
use_season_prefix: bool,
) -> str:
title_part = re.sub(r'[<>:"/\\|?*\x00-\x1f]', "_", title).strip()
title_part = re.sub(r"\s+", " ", title_part)
if not title_part:
title_part = f"episode_{index:02d}"
prefix = ""
if use_season_prefix and season is not None and episode is not None:
prefix = f"S{season:02d}E{episode:02d} - "
elif use_season_prefix and season is not None:
prefix = f"S{season:02d} - "
elif use_season_prefix and episode is not None:
prefix = f"E{episode:02d} - "
base = prefix + title_part
if not base.lower().endswith(".mp3"):
base += ".mp3"
return base
def download_file(url: str, dest: Path, timeout: int, user_agent: str) -> None:
dest.parent.mkdir(parents=True, exist_ok=True)
req = urllib.request.Request(
url,
headers={"User-Agent": user_agent, "Accept": "*/*"},
)
ctx = ssl.create_default_context()
tmp = dest.with_suffix(dest.suffix + ".part")
try:
with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
total = int(resp.headers.get("Content-Length") or 0)
chunk = 1024 * 256
got = 0
with open(tmp, "wb") as f:
while True:
buf = resp.read(chunk)
if not buf:
break
f.write(buf)
got += len(buf)
if total and sys.stderr.isatty():
pct = 100.0 * got / total
sys.stderr.write(f"\r {pct:5.1f}% ({got // (1024 * 1024)} MiB)")
if sys.stderr.isatty():
sys.stderr.write("\n")
tmp.replace(dest)
finally:
if tmp.exists():
tmp.unlink(missing_ok=True)
def main() -> int:
ap = argparse.ArgumentParser(
description="Deskargatu MP3ak guau.eus-etik (/s/…) edo RSS ofizialetik."
)
ap.add_argument(
"url",
help="Sailaren orria (https://guau.eus/s/slug) edo RSS jarioa (/series/<id>/rss.xml)",
)
ap.add_argument(
"-o",
"--output-dir",
type=Path,
default=Path("."),
help="Helburuko karpeta (lehenetsia: uneko direktorioa)",
)
ap.add_argument(
"-n",
"--dry-run",
action="store_true",
help="Erakutsi atalak deskargatu gabe",
)
ap.add_argument(
"--timeout",
type=int,
default=120,
help="HTTP denbora-muga segundotan (lehenetsia: 120)",
)
ap.add_argument(
"--user-agent",
default=DEFAULT_UA,
help="HTTP eskaeretarako User-Agent",
)
args = ap.parse_args()
raw = normalize_guau_url(args.url)
parsed = urlparse(raw)
rss_url: str | None = None
if re.search(r"/series/\d+/rss\.xml$", parsed.path or "", re.I):
rss_url = raw.split("?", 1)[0]
elif re.search(r"/series/[^/]+/rss\.xml$", parsed.path or "", re.I):
# Adib. /series/ainguratuak/rss.xml 500 itzuli dezake; saihesten da.
print(
"Erabili /s/<slug> orrialdearen URLa edo /series/<zenbaki id>/rss.xml.",
file=sys.stderr,
)
return 1
elif (parsed.netloc.lower().removesuffix(":443") in GUAU_HOSTS or not parsed.netloc) and (
parsed.path or ""
).startswith("/s/"):
try:
html = fetch(raw, args.timeout, args.user_agent).decode(
"utf-8", errors="replace"
)
except urllib.error.HTTPError as e:
print(f"HTTP errorea orrialdea kargatzean: {e}", file=sys.stderr)
return 1
except Exception as e:
print(f"Sareko errorea: {e}", file=sys.stderr)
return 1
rss_url = discover_rss_url(html)
if not rss_url:
print(
"Ezin izan da RSS jarioa aurkitu orrian (series/<id>/rss.xml).",
file=sys.stderr,
)
return 1
print(f"RSS jarioa: {rss_url}")
else:
print(
"URL ezezaguna. Espero daitekeena: https://guau.eus/s/<slug> "
"edo https://guau.eus/series/<id>/rss.xml",
file=sys.stderr,
)
return 1
try:
rss_body = fetch(rss_url, args.timeout, args.user_agent)
except urllib.error.HTTPError as e:
print(f"HTTP errorea RSS-ean: {e}", file=sys.stderr)
return 1
except Exception as e:
print(f"Sareko errorea (RSS): {e}", file=sys.stderr)
return 1
items = parse_rss_items(rss_body)
if not items:
print("Ez dago enclosure duen atalik RSS-ean.", file=sys.stderr)
return 1
use_season_prefix = multi_season_feed(items)
out_dir: Path = args.output_dir.resolve()
print(f"{len(items)} atal — karpeta: {out_dir}")
if use_season_prefix:
seasons = sorted({s for _, _, _, s, _ in items if s is not None})
if seasons:
print(
f"Hainbat denboraldi jario berean (denboraldiak: {', '.join(map(str, seasons))}) "
"— SxxEyy aurrizkia fitxategi-izenetan."
)
for i, (title, mp3_url, rss_length, season, episode) in enumerate(items, start=1):
name = safe_filename(title, i, season, episode, use_season_prefix)
dest = out_dir / name
print(f"[{i}/{len(items)}] {name}")
if args.dry_run:
continue
expected = resolved_expected_bytes(
mp3_url, rss_length, args.timeout, args.user_agent
)
if dest.exists() and dest.is_file():
local_sz = dest.stat().st_size
if expected is not None:
if local_sz == expected:
print(f" badago eta osatuta ({local_sz} B), saltatua")
continue
if local_sz > 0:
print(
f" osatu gabe edo zaharkitua ({local_sz}/{expected} B), berriro deskargatzen"
)
else:
if local_sz > 0:
print(
" fitxategia badago, tamaina ezezaguna (RSS-ko length gabe, HEAD-k "
f"Content-Length gabe) — saltatua: {dest}"
)
continue
try:
download_file(mp3_url, dest, args.timeout, args.user_agent)
except urllib.error.HTTPError as e:
print(f" HTTP hutsegitea: {e}", file=sys.stderr)
return 1
except Exception as e:
print(f" hutsegitea: {e}", file=sys.stderr)
return 1
print(f" OK → {dest}")
return 0
if __name__ == "__main__":
sys.exit(main())
Ezarpenak batzuk daude:
... ]]>
Metrikak denborarekin lotutako zenbakiak dira. Hau da, sistema baten ezaugarri bat neurtzen duzunean, balioa eta denbora-zigilua gordetzen du.
Adibidez, CPU metrika batean zenbaki horiek izango ditugu:
CPU erabilera: 5% - Noiz? 2026-01-02 10:02:00-an
CPU erabilera: 7% - Noiz? 2026-01-02 10:02:20-an
CPU erabilera: 5.5% - Noiz? 2026-01-02 10:05:00-an
Prometheus zerbitzari bat da metrikak bildu eta gordetzeko. Adibidez, zure cpu kontsumoa neurtu nahi baldin baduzu, prometheus erabiliko duzu datuak segundu bakoitzean gordetzeko.
Grafana tresna bat da metriketan oinarritutako grafikoak eta panelak sortzeko. Horrez gain, metrika horietan oinarritutako jakinarazpenak konfiguratzeko aukera ematen du.
Baina kontuz, Grafanak ez du metrikak sortzen ezta gordetzen: Iturriak irakurtzen ditu grafikoak sortzeko.
Erakurri duzun bezala, Prometheusek metrikak kudeatzen ditu, baina ezin ditu log-daturik gorde. Behar hori asetzeko sortu zuten loki: logak bildu, kudeatu, eta gordetzeko.
Alloy grafanaren zerbitzari bat da datuak irakurri, kudeatu, eta gordetzeko.
Serbitzari hauek guztiak instalatzeko docker-compose.yml artxiboa erabiliko dugu docker irudiak sortzeko. Zerbitzari bakoitza bere dockera izango du horrela.
networks:
frontend:
driver: bridge
services:
# Grafana basic
grafana:
container_name: grafana
image: grafana/grafana-enterprise
hostname: grafana
volumes:
- grafana_data:/var/lib/grafana
networks:
- frontend
# Node exporter ,for Metrics from the server
node-exporter:
container_name: node-exporter
image: prom/node-exporter
restart: unless-stopped
hostname: node-exporter
volumes:
- /proc:/host/proc:ro
- /sys:/host/sys:ro
- /:/rootfs:ro
expose:
- 9100
networks:
- frontend
command:
- '--path.procfs=/host/proc'
- '--path.rootfs=/rootfs'
- '--path.sysfs=/host/sys'
- '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
# Prometheus to read node-exporter logs and send
prometheus:
container_name: prometheus
image: prom/prometheus
hostname: prometheus
volumes:
- ./data/prometheus.yml:/etc/prometheus/prometheus.yml
- prometheus_data:/prometheus
networks:
- frontend
# Grafana loki , to receive log files
loki:
container_name: loki
image: grafana/loki
hostname: loki
volumes:
- loki_data:/loki
networks:
- frontend
# Alloy - to send logs to Loki
alloy:
container_name: alloy
image: grafana/alloy
hostname: alloy
volumes:
- ./data/config.alloy:/etc/alloy/config.alloy
- alloy_data:/var/lib/alloy/data
- /var/log:/var/log/:ro
networks:
- frontend
volumes:
prometheus_data:
grafana_data:
loki_data:
alloy_data:
<?php
$destination = "/home/tfe/Nextcloud/Musika/Badok";
if(!is_dir($destination))
{
mkdir($destination, 0755, true);
}
$url = "https://www.badok.eus/azken-kantuak";
$content = file_get_contents($url);
preg_match_all("/<a.*?data-mp3=\"mp3\".*?><\/a>/", $content, $matches);
foreach($matches[0] as $link)
{
$tid = preg_replace("/.*data-tid=\"(.*?)\".*/", "$1", $link);
$image = preg_replace("/.*data-uimg=\"(.*?)\".*/", "$1", $link);
trim($image);
$artist = preg_replace("/.*data-artist=\"(.*?)\".*/", "$1", $link);
trim($artist);
$artist = preg_replace("/[^a-zA-Z0-9]/", "_", $artist);
$album = "";
$izena = preg_replace("/.*data-izena=\"(.*?)\".*/", "$1", $link);
trim($izena);
$izena = preg_replace("/[^a-zA-Z0-9]/", "_", $izena);
if(preg_match("/(.*) - (.*)/", $izena, $matches))
{
$album = $matches[1];
$izena = $matches[2];
}
$artist_folder = "$destination/$artist";
if(!is_dir($artist_folder))
{
mkdir($artist_folder, 0755, true);
}
$destination_file = "$destination/$artist/$album/$izena.mp3";
if(!file_exists($destination_file))
{
$destination_image = "$destination/$artist/$album/$izena.jpg";
file_put_contents($destination_image, file_get_contents($image));
echo "[$artist] $izena ($tid)\n";
$dl_url = json_decode(file_get_contents("https://www.badok.eus/wp-content/plugins/badok/server_processing.php?play_mp3=" . $tid),true);
echo "Deskargatzen [$artist] $izena ($tid) - $destination_file\n";
file_put_contents($destination_file, file_get_contents($dl_url["url"]));
echo "OK\n";
exec("eyeD3 --artist \"$artist\" --album \"$album\" --title \"$izena\" --add-image $destination_image:FRONT_COVER $destination_file");
}
else {
echo "[$artist] $izena ($tid) Dagoeneko egina dago.\n";
}
}
... ]]>
Mermaid empresa bat da, eta berak garatu zuen grafikoak sortzeko javascript liburutegi bat.
Berrezitasun da grafikoa sortzen dira deskribapen bidez.
Adibidez: deskribapen honekin:
flowchart TD
A[Gabonak] -->|Dirua lortu| B(Dendara joan)
B --> C{Asmatu oparia}
C -->|500€| D[Ordenagailu bat]
C -->|200€| E[Mugikor bat ]
C -->|10000€| F[fa:Auto bat]
Grafiko hori lor dezakezue:
Noski, edozein motako grafiko sor dezakezue honekin. Horiek ezagutzeko, gonbidatzen zaitugu mermaid.live webgunera joatera.
Askotariko pluginak exisititzen dira: Confluence, Jira, edo Github webguneetarako adibidez.
... ]]>
Dena den: hemen dago emaitza: elhuyar_ahotsa.py.
Ideia da:
[
"aldagaia.1" => "bat",
"aldagaia.2" => "bi"
]
Baina EZ!
Php-ri ezker (https://www.php.net/manual/en/language.variables.external.php#language.variables.external.dot-in-names) puntuak azpimarraz ordezkatzen dira!
[
"aldagaia1" => "bat",
"aldagaia_2" => "bi"
]
Momentuz, ez dago saihesteko konponbiderik, eta benetako parametroak bilatzeko funtzio bat sortu behar dugu:
function realGET($data)
{
$data = preg_replace_callback('/(?:^|(?<=&))[^=[]+/', function($match) {
return bin2hex(urldecode($match[0]));
}, $data);
parse_str($data, $values);
return array_combine(array_map('hex2bin', array_keys($values)), $values);
}
$newGET = realGET($_SERVER['QUERY_STRING']);
Azalpenak eman baino lehen, hemen duzu behar duzun fitxategia jokoa euskaraz izateko:
Linuxen:
Deskargatu shadowtactics-eu.sh fitxategia, eta:
$ chmod +x shadowtactics-eu.sh
$ ./shadowtactics-eu.sh
Windowsen:
Deskargatu shadow_tactics_euskaraz.exe eta exekutatu.
Eskerrik asko ibaios!
Instalatu ondoren:
Aukeratu ezkuntza "Español" :
Azalpenak:
UABEA erabiliz, edozein datuak irakur ditzake bideojokotik.
resources.assets fitxategia irekitzean, datu asko daude ikusgai, besteak beste:
Jokoa itzultzeko, script bat sortu dut, datu horietatik 3 CSV fitxategi sortzeko:
Eta hori esker 3 csv fitxategi sortu ditut:
Fitxategiak testu guztiak dituzte, eta google translator bidez itzulpen arraunt bat egin dut.
Gero, lerroz-lerro irakuri dut googlen itzulpena, eta saiatu naiz aurkitu ditudan akatzak konpontzen.
... ]]>
Antzekoak diren komandoak:$ cd /home/$USER$ cd ~ $ cd
Laburpenak:$ !vi # Exekutatu "vi"-rekin hasten den azken komandoa .
Adibide bat:$ cd src/project$ vi source.c$ make build$ ....$ !v # vi irekitzeko$ !m # make build exekutatzeko
Nire lehen proba "Pid" jokoareakin egin dut.
Instalatu ondoren, "Eusaraz itulpena.exe" programa erabil dezakezue, bideo-jokoa euskaraz izateko.
Oharra: Baliteke akats izatea, itzultzaile neuronalea baten bidez itzulita dagoelako.
