diff --git a/README.md b/README.md index 6b596095..9e6a2e20 100644 --- a/README.md +++ b/README.md @@ -41,3 +41,9 @@ backups, and the firewall before running: ```bash docker compose up -d --build ``` + +To fill up the initial semana data (after confirming it right): + +```bash +docker compose exec backend python -m scripts.seed_semana_data +``` \ No newline at end of file diff --git a/backend/app/tests/semana/unit/test_seed_semana_data.py b/backend/app/tests/semana/unit/test_seed_semana_data.py new file mode 100644 index 00000000..03a76062 --- /dev/null +++ b/backend/app/tests/semana/unit/test_seed_semana_data.py @@ -0,0 +1,442 @@ +import csv +from contextlib import asynccontextmanager +from datetime import UTC, datetime +from types import SimpleNamespace +from zoneinfo import ZoneInfo + +import pytest + +from app.core.config import AppEnv, Settings +from app.semana.models import Semana +from scripts import seed_semana_data + +TSV_COLUMNS = [ + "Título da atividade", + "Descrição da atividade", + "Tipo de Atividade", + "Horas", + "Pontos", + "Localização", + "Horário Começo", + "Horário Término", + "Nomes dos palestrantes", + "Arquivos de Imagem", + "Descrições dos palestrantes", +] +VALID_ROW = { + "Título da atividade": "Test activity", + "Descrição da atividade": "Test description", + "Tipo de Atividade": "Palestra", + "Horas": "1", + "Pontos": "100", + "Localização": "Auditório", + "Horário Começo": "06/10/2026 13:00:00", + "Horário Término": "06/10/2026 14:00:00", + "Nomes dos palestrantes": "Test Speaker", + "Arquivos de Imagem": "speaker.jpg", + "Descrições dos palestrantes": "Test biography", +} + + +def write_schedule( + monkeypatch, tmp_path, rows, *, image_files=("speaker.jpg",), columns=None +): + image_dir = tmp_path / "imagens_palestrantes" + image_dir.mkdir(exist_ok=True) + for image_name in image_files: + image_path = image_dir / image_name + image_path.parent.mkdir(parents=True, exist_ok=True) + image_path.write_bytes(b"test image") + + schedule_path = tmp_path / "palestras.tsv" + fieldnames = columns or TSV_COLUMNS + with schedule_path.open("w", encoding="utf-8", newline="") as file: + writer = csv.DictWriter(file, fieldnames=fieldnames, delimiter="\t") + writer.writeheader() + writer.writerows(rows) + + monkeypatch.setattr(seed_semana_data, "SCHEDULE_FILE", schedule_path) + monkeypatch.setattr(seed_semana_data, "SPEAKER_IMAGES_DIR", image_dir) + + +def image_signature_matches_extension(path): + header = path.read_bytes()[:12] + suffix = path.suffix.lower() + if suffix in {".jpg", ".jpeg"}: + return header.startswith(b"\xff\xd8\xff") + if suffix == ".png": + return header.startswith(b"\x89PNG\r\n\x1a\n") + if suffix == ".webp": + return header.startswith(b"RIFF") and header[8:12] == b"WEBP" + return False + + +def test_load_schedule_reads_activities_and_speaker_photos(): + schedule = seed_semana_data.load_schedule() + + assert len(schedule) == 17 + speakers = [speaker for item in schedule for speaker in item["speakers"]] + assert len(speakers) == 20 + assert all( + speaker["nome"].strip() and speaker["sobre"].strip() for speaker in speakers + ) + assert all(speaker["image_path"].is_file() for speaker in speakers) + assert all( + speaker["image_path"].suffix.lower() + in seed_semana_data.SUPPORTED_IMAGE_EXTENSIONS + for speaker in speakers + ) + assert all( + 0 < speaker["image_path"].stat().st_size <= seed_semana_data.MAX_IMAGE_BYTES + for speaker in speakers + ) + image_paths = [speaker["image_path"].resolve() for speaker in speakers] + assert all(image_signature_matches_extension(path) for path in image_paths) + assert len(image_paths) == len(set(image_paths)) + referenced_images = set(image_paths) + supported_files = { + path.resolve() + for path in seed_semana_data.SPEAKER_IMAGES_DIR.iterdir() + if path.is_file() + and path.suffix.lower() in seed_semana_data.SUPPORTED_IMAGE_EXTENSIONS + } + assert referenced_images == supported_files + + tako_activity = next( + item for item in schedule if item["titulo"].startswith("Como a Tako") + ) + tako_images = { + speaker["nome"]: speaker["image_path"].name + for speaker in tako_activity["speakers"] + } + assert tako_images == { + "Bruno Cerejo": "bruno-cerejo.jpeg", + "André Spanguero": "andre-spanguero.jpg", + } + + +def test_schedule_rows_are_unique_valid_and_non_overlapping_by_location(): + schedule = seed_semana_data.load_schedule() + titles = [item["titulo"] for item in schedule] + + assert all(title and len(title) <= 255 for title in titles) + assert len(titles) == len(set(titles)) + for item in schedule: + assert item["comeca_as"].tzinfo == ZoneInfo("America/Sao_Paulo") + assert item["comeca_as"].year == item["termina_as"].year == 2026 + assert item["comeca_as"].month == item["termina_as"].month == 10 + assert 5 <= item["comeca_as"].day <= 9 + assert item["termina_as"] > item["comeca_as"] + assert item["horas"] >= 1 + assert item["pontos"] >= 0 + assert item["descricao"] is None or len(item["descricao"]) <= 5000 + assert item["local"] is None or len(item["local"]) <= 255 + + for index, first in enumerate(schedule): + for second in schedule[index + 1 :]: + if first["local"] and first["local"] == second["local"]: + assert ( + first["termina_as"] <= second["comeca_as"] + or second["termina_as"] <= first["comeca_as"] + ), (first["titulo"], second["titulo"]) + + +@pytest.mark.parametrize( + ("overrides", "images", "message"), + [ + ( + { + "Nomes dos palestrantes": "Speaker One|Speaker Two", + "Descrições dos palestrantes": "Bio one|Bio two", + }, + ("speaker.jpg",), + "Speaker columns have different counts", + ), + ({"Arquivos de Imagem": ""}, (), "Speaker image is missing"), + ( + {"Descrições dos palestrantes": ""}, + ("speaker.jpg",), + "Speaker bio is missing", + ), + ({"Nomes dos palestrantes": ""}, ("speaker.jpg",), "Speaker name is missing"), + ( + {"Arquivos de Imagem": "speaker.heic"}, + ("speaker.heic",), + "Unsupported speaker image type", + ), + ({"Arquivos de Imagem": "missing.jpg"}, (), "Speaker image not found"), + ({"Arquivos de Imagem": "../speaker.jpg"}, (), "Invalid speaker image path"), + ], +) +def test_load_schedule_rejects_invalid_speaker_data( + monkeypatch, tmp_path, overrides, images, message +): + row = {**VALID_ROW, **overrides} + write_schedule(monkeypatch, tmp_path, [row], image_files=images) + + with pytest.raises((ValueError, FileNotFoundError), match=message): + seed_semana_data.load_schedule() + + +@pytest.mark.parametrize( + ("overrides", "message"), + [ + ({"Tipo de Atividade": "Coffee break"}, "Invalid title or activity type"), + ({"Horário Término": "06/10/2026 13:00:00"}, "Invalid schedule"), + ({"Horário Começo": "06/10/2025 13:00:00"}, "outside the 2026 event"), + ({"Horas": "0"}, "Invalid hours or points"), + ({"Pontos": "-1"}, "Invalid hours or points"), + ({"Pontos": "one hundred"}, "Invalid date or numeric value"), + ({"Título da atividade": "T" * 256}, "Activity title is too long"), + ({"Descrição da atividade": "D" * 5001}, "Description is too long"), + ({"Localização": "L" * 256}, "Location is too long"), + ], +) +def test_load_schedule_rejects_invalid_activity_fields( + monkeypatch, tmp_path, overrides, message +): + write_schedule(monkeypatch, tmp_path, [{**VALID_ROW, **overrides}]) + + with pytest.raises(ValueError, match=message): + seed_semana_data.load_schedule() + + +def test_load_schedule_rejects_duplicate_titles(monkeypatch, tmp_path): + write_schedule(monkeypatch, tmp_path, [VALID_ROW, VALID_ROW]) + + with pytest.raises(ValueError, match="Duplicate activity title"): + seed_semana_data.load_schedule() + + +def test_load_schedule_rejects_missing_columns(monkeypatch, tmp_path): + columns = TSV_COLUMNS[:-1] + row = {key: value for key, value in VALID_ROW.items() if key in columns} + write_schedule(monkeypatch, tmp_path, [row], columns=columns) + + with pytest.raises(ValueError, match="Unexpected columns"): + seed_semana_data.load_schedule() + + +def test_load_schedule_rejects_duplicate_columns(monkeypatch, tmp_path): + columns = [*TSV_COLUMNS, "Título da atividade"] + write_schedule(monkeypatch, tmp_path, [VALID_ROW], columns=columns) + + with pytest.raises(ValueError, match="Duplicate columns"): + seed_semana_data.load_schedule() + + +@pytest.mark.parametrize("row_width", [len(TSV_COLUMNS) - 1, len(TSV_COLUMNS) + 1]) +def test_load_schedule_rejects_malformed_row_width(monkeypatch, tmp_path, row_width): + image_dir = tmp_path / "imagens_palestrantes" + image_dir.mkdir() + (image_dir / "speaker.jpg").write_bytes(b"test image") + schedule_path = tmp_path / "palestras.tsv" + values = [VALID_ROW[column] for column in TSV_COLUMNS] + values = values[:row_width] if row_width < len(values) else [*values, "unexpected"] + with schedule_path.open("w", encoding="utf-8", newline="") as file: + file.write("\t".join(TSV_COLUMNS) + "\n") + file.write("\t".join(values) + "\n") + + monkeypatch.setattr(seed_semana_data, "SCHEDULE_FILE", schedule_path) + monkeypatch.setattr(seed_semana_data, "SPEAKER_IMAGES_DIR", image_dir) + + with pytest.raises(ValueError, match="Invalid number of columns"): + seed_semana_data.load_schedule() + + +def test_load_schedule_rejects_oversized_image(monkeypatch, tmp_path): + write_schedule(monkeypatch, tmp_path, [VALID_ROW]) + image_path = seed_semana_data.SPEAKER_IMAGES_DIR / "speaker.jpg" + image_path.write_bytes(b"x" * (seed_semana_data.MAX_IMAGE_BYTES + 1)) + + with pytest.raises(ValueError, match="invalid size"): + seed_semana_data.load_schedule() + + +def test_load_schedule_rejects_empty_file(monkeypatch, tmp_path): + write_schedule(monkeypatch, tmp_path, []) + + with pytest.raises(ValueError, match="No activities found"): + seed_semana_data.load_schedule() + + +@pytest.mark.asyncio +async def test_main_runs_in_production_and_is_additive_on_repeated_runs( + monkeypatch, tmp_path +): + event_state = {"event": Semana(id=2026, nome="Edited event name", ano=2026)} + manually_edited = SimpleNamespace(titulo="Existing activity", descricao="Edited") + activities = [manually_edited] + created = [] + saved_images = [] + image_path = tmp_path / "speaker.jpg" + image_path.write_bytes(b"test image") + seed_item = { + "titulo": "New activity", + "tipo": seed_semana_data.TipoAtividade.PALESTRA, + "descricao": "Initial description", + "local": "Auditorium", + "comeca_as": datetime(2026, 10, 6, 10, tzinfo=UTC), + "termina_as": datetime(2026, 10, 6, 11, tzinfo=UTC), + "pontos": 100, + "horas": 1, + "speakers": [{"nome": "Speaker", "sobre": "Bio", "image_path": image_path}], + } + existing_seed_item = { + **seed_item, + "titulo": "Existing activity", + "descricao": "Do not overwrite this", + } + + class FakeSession: + def add(self, value): + event_state["event"] = value + + async def flush(self): + pass + + async def scalar(self, _statement): + return event_state["event"] + + async def scalars(self, _statement): + return SimpleNamespace(all=lambda: list(activities)) + + session = FakeSession() + + @asynccontextmanager + async def fake_session_scope(_settings): + yield session + + async def fake_save_bytes(contents, *, subdir, extension): + saved_images.append((contents, subdir, extension)) + return "palestrantes/speaker.jpg" + + async def fake_create_atividade(_session, _event, **fields): + activity = SimpleNamespace( + titulo=fields["titulo"], + descricao=fields["descricao"], + palestrantes=fields["palestrantes"], + ) + activities.append(activity) + created.append(activity) + return activity + + monkeypatch.setattr( + seed_semana_data, "get_settings", lambda: Settings(app_env=AppEnv.production) + ) + monkeypatch.setattr( + seed_semana_data, + "load_schedule", + lambda: [existing_seed_item, seed_item], + ) + monkeypatch.setattr(seed_semana_data, "session_scope", fake_session_scope) + monkeypatch.setattr(seed_semana_data, "save_bytes", fake_save_bytes) + monkeypatch.setattr(seed_semana_data, "create_atividade", fake_create_atividade) + + await seed_semana_data.main() + await seed_semana_data.main() + + assert len(created) == 1 + assert manually_edited.descricao == "Edited" + assert len(activities) == 2 + assert event_state["event"].nome == "Edited event name" + assert event_state["event"].ano == 2026 + assert created[0].palestrantes == [ + { + "nome": "Speaker", + "sobre": "Bio", + "foto": "/media/palestrantes/speaker.jpg", + } + ] + assert saved_images == [(b"test image", "palestrantes", "jpg")] + + +@pytest.mark.asyncio +async def test_main_deletes_saved_media_when_activity_creation_fails( + monkeypatch, tmp_path +): + event = Semana(id=2026, nome="Semana da Computação", ano=2026) + image_path = tmp_path / "speaker.jpg" + image_path.write_bytes(b"test image") + item = { + "titulo": "Activity", + "descricao": "Description", + "tipo": seed_semana_data.TipoAtividade.PALESTRA, + "local": "Auditorium", + "comeca_as": datetime(2026, 10, 6, 10, tzinfo=UTC), + "termina_as": datetime(2026, 10, 6, 11, tzinfo=UTC), + "pontos": 100, + "horas": 1, + "speakers": [{"nome": "Speaker", "sobre": "Bio", "image_path": image_path}], + } + session = SimpleNamespace( + scalar=lambda _statement: None, + scalars=lambda _statement: None, + ) + + async def scalar(_statement): + return event + + async def scalars(_statement): + return SimpleNamespace(all=list) + + session.scalar = scalar + session.scalars = scalars + deleted_media = [] + + @asynccontextmanager + async def fake_session_scope(_settings): + yield session + + async def fake_save_bytes(_contents, *, subdir, extension): + return f"{subdir}/new.{extension}" + + async def fail_create_atividade(_session, _event, **_fields): + raise RuntimeError("database write failed") + + monkeypatch.setattr( + seed_semana_data, "get_settings", lambda: Settings(app_env=AppEnv.production) + ) + monkeypatch.setattr(seed_semana_data, "load_schedule", lambda: [item]) + monkeypatch.setattr(seed_semana_data, "session_scope", fake_session_scope) + monkeypatch.setattr(seed_semana_data, "save_bytes", fake_save_bytes) + monkeypatch.setattr(seed_semana_data, "create_atividade", fail_create_atividade) + monkeypatch.setattr(seed_semana_data, "delete_file", deleted_media.append) + + with pytest.raises(RuntimeError, match="database write failed"): + await seed_semana_data.main() + + assert deleted_media == ["palestrantes/new.jpg"] + + +@pytest.mark.asyncio +async def test_main_creates_missing_event_in_production(monkeypatch): + event_state = {"event": None} + + class FakeSession: + def add(self, value): + event_state["event"] = value + + async def flush(self): + pass + + async def scalar(self, _statement): + return event_state["event"] + + async def scalars(self, _statement): + return SimpleNamespace(all=list) + + @asynccontextmanager + async def fake_session_scope(_settings): + yield FakeSession() + + monkeypatch.setattr( + seed_semana_data, "get_settings", lambda: Settings(app_env=AppEnv.production) + ) + monkeypatch.setattr(seed_semana_data, "load_schedule", list) + monkeypatch.setattr(seed_semana_data, "session_scope", fake_session_scope) + + await seed_semana_data.main() + + assert event_state["event"].nome == "Semana da Computação 2026" + assert event_state["event"].ano == 2026 diff --git a/backend/scripts/data/imagens_palestrantes/andre-spanguero.jpg b/backend/scripts/data/imagens_palestrantes/andre-spanguero.jpg new file mode 100644 index 00000000..f8ec66b3 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/andre-spanguero.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/bruno-cerejo.jpeg b/backend/scripts/data/imagens_palestrantes/bruno-cerejo.jpeg new file mode 100644 index 00000000..db646cf4 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/bruno-cerejo.jpeg differ diff --git a/backend/scripts/data/imagens_palestrantes/carlos-marques.jpg b/backend/scripts/data/imagens_palestrantes/carlos-marques.jpg new file mode 100644 index 00000000..ddb91724 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/carlos-marques.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/daniel-batista.jpeg b/backend/scripts/data/imagens_palestrantes/daniel-batista.jpeg new file mode 100644 index 00000000..5d07abc8 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/daniel-batista.jpeg differ diff --git a/backend/scripts/data/imagens_palestrantes/entanglion.jpeg b/backend/scripts/data/imagens_palestrantes/entanglion.jpeg new file mode 100644 index 00000000..fc444405 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/entanglion.jpeg differ diff --git a/backend/scripts/data/imagens_palestrantes/fabio-cozman.jpg b/backend/scripts/data/imagens_palestrantes/fabio-cozman.jpg new file mode 100644 index 00000000..eef0569d Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/fabio-cozman.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/flusp.jpg b/backend/scripts/data/imagens_palestrantes/flusp.jpg new file mode 100644 index 00000000..080be0cc Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/flusp.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/guilherme-mota.jpg b/backend/scripts/data/imagens_palestrantes/guilherme-mota.jpg new file mode 100644 index 00000000..0619beca Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/guilherme-mota.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/helena-maia.jpg b/backend/scripts/data/imagens_palestrantes/helena-maia.jpg new file mode 100644 index 00000000..410e69da Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/helena-maia.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/idian-capozzoli.jpg b/backend/scripts/data/imagens_palestrantes/idian-capozzoli.jpg new file mode 100644 index 00000000..6afd76fd Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/idian-capozzoli.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/laura-damaceno.jpg b/backend/scripts/data/imagens_palestrantes/laura-damaceno.jpg new file mode 100644 index 00000000..f16396b1 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/laura-damaceno.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/luiza-soezima.jpg b/backend/scripts/data/imagens_palestrantes/luiza-soezima.jpg new file mode 100644 index 00000000..344297d8 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/luiza-soezima.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/natalia-naomi.jpg b/backend/scripts/data/imagens_palestrantes/natalia-naomi.jpg new file mode 100644 index 00000000..3239bec6 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/natalia-naomi.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/nina-hirata.png b/backend/scripts/data/imagens_palestrantes/nina-hirata.png new file mode 100644 index 00000000..5f2b237c Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/nina-hirata.png differ diff --git a/backend/scripts/data/imagens_palestrantes/paulo-silveira.jpg b/backend/scripts/data/imagens_palestrantes/paulo-silveira.jpg new file mode 100644 index 00000000..23422b21 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/paulo-silveira.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/pedro-merino.jpg b/backend/scripts/data/imagens_palestrantes/pedro-merino.jpg new file mode 100644 index 00000000..a54db753 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/pedro-merino.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/renata-wasserman.jpg b/backend/scripts/data/imagens_palestrantes/renata-wasserman.jpg new file mode 100644 index 00000000..e41c1d60 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/renata-wasserman.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/roberto-hirata.jpeg b/backend/scripts/data/imagens_palestrantes/roberto-hirata.jpeg new file mode 100644 index 00000000..fb502cc0 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/roberto-hirata.jpeg differ diff --git a/backend/scripts/data/imagens_palestrantes/ronaldo-hashimoto.jpg b/backend/scripts/data/imagens_palestrantes/ronaldo-hashimoto.jpg new file mode 100644 index 00000000..80172d74 Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/ronaldo-hashimoto.jpg differ diff --git a/backend/scripts/data/imagens_palestrantes/yoshiharu-kohayakawa.jpg b/backend/scripts/data/imagens_palestrantes/yoshiharu-kohayakawa.jpg new file mode 100644 index 00000000..142fb1ac Binary files /dev/null and b/backend/scripts/data/imagens_palestrantes/yoshiharu-kohayakawa.jpg differ diff --git a/backend/scripts/data/palestras.tsv b/backend/scripts/data/palestras.tsv new file mode 100644 index 00000000..d9647667 --- /dev/null +++ b/backend/scripts/data/palestras.tsv @@ -0,0 +1,18 @@ +Título da atividade Descrição da atividade Tipo de Atividade Horas Pontos Localização Horário Começo Horário Término Nomes dos palestrantes Arquivos de Imagem Descrições dos palestrantes +Você não é pago para escrever código Nunca fomos medidos por linhas de código escritas. Não vai ser com a IA que isso vai mudar. O código sempre foi um byproduct de uma solução. O foco é no entendimento do problema e sua respectiva quebra em questões menores, que podem ser programadas. Comandar o computador continua e continuará chave. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 06/10/2026 13:40:00 06/10/2026 14:40:00 Paulo Silveira paulo-silveira.jpg Paulo Silveira é bacharel e mestre em Ciência da Computação. Cofundador da Alura e do grupo Alun, onde trabalha como líder de visão, coloborando com PM3, StartSe e FIAP. Paulo é host do principal podcast de tecnologia brasileiro, o Hipsters Ponto Tech, é investidor anjo em 41 startups e empreendedor Endeavor. +A construção da carreira em tecnologia na visão de uma jovem engenheira de software Nesta palestra vou contar os bastidores da minha trajetória em engenharia de software, do estágio até a posição atual de engenheira pleno no iFood. Quero compartilhar as lições que aprendi ao longo do caminho e o que eu faria diferente se tivesse que começar de novo: como enxergo oportunidades, o que pesa numa entrevista do outro lado da mesa e como aproveitar de verdade a fase de estágio pra construir a carreira que você quer. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 08/10/2026 15:10:00 08/10/2026 16:10:00 Natália Naomi Sumida natalia-naomi.jpg Engenheira de software no iFood, com mais de 4 anos de experiência na área de TI. Formada como Técnica em Informática pelo COTUCA e atualmente graduanda em Engenharia de Software pela PUC-Campinas. Me interesso pela intersecção entre engenharia, dados e produto, com foco em Busca, e gosto de compartilhar experiências que aprendi ao longo da minha trajetória. +Como treinar modelos de Machine Learning quando o mundo real não coopera O treinamento efetivo de modelos de Machine Learning e, em especial de redes neurais modernas, costuma exigir um volume massivo de dados rotulados. Embora a geração de dados seja abundante hoje, o mundo real impõe barreiras severas na prática. Nesta palestra, abordaremos três cenários críticos: quando não temos acesso aos dados (privacidade), quando os dados não possuem rótulos (custo de anotação) e quando os eventos não se repetem o suficiente (escassez). Para cada uma dessas situações, discutiremos as estratégias e arquiteturas criativas usadas na prática para alcançar um treinamento de alto desempenho. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 07/10/2026 15:10:00 07/10/2026 16:10:00 Nina S. T. Hirata nina-hirata.png Professora, IME/USP +Podemos confiar na IA? Como avaliar sistemas de Gen AI? Sistemas de IA generativa introduzem um desafio diferente dos modelos tradicionais: nem sempre existe uma única resposta correta. Então, como saber se uma aplicação de GenAI está realmente funcionando? Nesta palestra, vamos explorar estratégias para avaliar sistemas de GenAI ao longo de seu ciclo de desenvolvimento, passando por métricas, mapeamento de riscos e a tríade da validação. A ideia é entender como transformar “parece que funciona” em evidências de que o sistema é confiável para o contexto em que será utilizado. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 06/10/2026 12:30:00 06/10/2026 13:30:00 Laura Damaceno de Almeida laura-damaceno.jpg "Cientista de dados e Linkedin Top Voice. Mestre em ciências da computação com ênfase em IA, sendo uma das paixões como cientista e pesquisadora é desvendar histórias através dos dados. Co-autora do livro ""IA por Mulheres"", lançado em Harvard. Co-fundadora de uma comunidade que visa incluir e capacitar mulheres brasileiras em inteligência artificial e ciência de dados no Brasil, chamada AI Girls. Criadora de conteúdo no @laura_data_talks, cujo intuito é desmitificar a ciência de dados e IA para as pessoas" +Inteligência Artificial no Verão Tropical: Discutindo Possíveis Futuros da IA no Brasil Inteligência Artificial é um dos assuntos mais discutidos na sociedade no momento. Essa palestra tentará tatear por questões ligadas a ensino (de IA e por IA) e pesquisa (em IA e usando IA), especificamente pensando na realidade brasileira. É provável que o número de dúvidas seja maior do que o de respostas, mas é bom pelo menos organizar um pouco as ideias e procurar um caminho no meio desse avanço tecnológico avassalador. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 06/10/2026 15:10:00 06/10/2026 16:10:00 Fabio Gagliardi Cozman fabio-cozman.jpg Fabio G. Cozman é Professor Titular da Escola Politécnica da Universidade de São Paulo (USP), Diretor do Centro de Inteligência Artificial e Aprendizado de Máquina (CIAAM) da USP, com foco em aprendizado de máquina e representação de conhecimento e incerteza. Engenheiro pela Escola Politécnica USP e PhD pela Carnegie Mellon University (EUA), serviu, entre outras atividades, como Program e General Chair da Conference on Uncertainty in Artificial Intelligence, Area Chair da International Joint Conference on Artificial Intelligence, Associate Editor dos periódicos Artificial Intelligence, Journal of Artificial Intelligence Research, e Journal of Approximate Reasoning. Foi também coordenador do Comitê Especial em Inteligência Artificial da Sociedade Brasileira de Computação, e recebeu o Prêmio de Mérito Científico em Inteligência Artificial concedido por aquela sociedade. +Ameaças Invisíveis: Ataques Adversariais na Computação Clássica e Quântica Como pequenas alterações imperceptíveis aos olhos humanos podem enganar os sistemas de Inteligência Artificial mais avançados do mundo? Nesta palestra, exploraremos os fundamentos da inteligência artificial clássica e dos ataques adversariais através de um storytelling guiado por casos reais, desde falhas críticas no setor militar até os impactos no mundo corporativo. Após mapearmos as fragilidades e as ilusões digitais da computação clássica, faremos a ponte para a próxima fronteira tecnológica. Com o avanço do Quantum Machine Learning, responderemos a segunte provocação: a natureza complexa da computação quântica será a nossa salvação contra essas ameaças, ou a sua estrutura a tornará ainda mais frágil e vulnerável aos ataques adversariais? Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 08/10/2026 16:20:00 08/10/2026 17:20:00 Pedro Merino pedro-merino.jpg "Pedro é bacharel em Física pelo Instituto de Física da Universidade de São Paulo (IFUSP). Atualmente, cursa mestrado em Engenharia Eletrônica e de Computação no Instituto Tecnológico de Aeronáutica (ITA), onde sua pesquisa se concentra na investigação de ataques adversariais em sistemas de aprendizado de máquina quânticos. Paralelamente ao trabalho acadêmico, dedica parte do seu tempo à comunidade de computação quântica como voluntário do IBM Qiskit Advocate. Durante o último ano de graduação, realizou um projeto de pesquisa financiado pela FAPESP, intitulado ""Detecção e Classificação de Objetos Estelares Jovens com Métodos de Aprendizado de Máquina"", no qual desenvolveu uma rede neural utilizando dados fotométricos para detectar e classificar estrelas. Durante o ensino médio, obteve resultados excepcionais em competições acadêmicas, notadamente conquistando a Medalha de Ouro na Olimpíada Brasileira de Astronomia e Astronáutica (OBA) em 2021 e a Medalha de Bronze em 2020. Também recebeu uma Medalha de Prata na Olimpíada Nacional de Ciências em 2021 e uma Medalha de Bronze em 2020." +Hackeando a Pilha de Rede do Linux: Como eBPF e XDP Reprogramam o Kernel para Streaming de Vídeo de Ultra-Baixa Latência Com o passar dos anos, a Internet passou de uma rede voltada essencialmente ao transporte de texto para uma infraestrutura capaz de suportar áudio, vídeo, jogos e aplicações interativas. Diferentemente do texto, aplicações multimídia são muito sensíveis a atrasos, perdas e variações na rede (ninguém quer que o vídeo trave justamente no momento mais importante!) Nesta palestra, veremos que Redes de Computadores não são apenas protocolos isolados: o sistema operacional também tem um papel fundamental no tratamento dos pacotes e pode ser programado para modificar seu comportamento. Veremos na prática como eBPF e XDP permitem reprogramar parte do processamento de rede no kernel Linux e como essa capacidade pode ser utilizada para proteger um fluxo de vídeo em tempo real contra tráfego agressivo. Ao final, serão apresentadas questões que vão além da parte prática apresentada na palestra e que podem dar origem a projetos de iniciação científica e pesquisas avançadas em Redes de Computadores. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 08/10/2026 13:40:00 08/10/2026 14:40:00 Daniel Macêdo Batista daniel-batista.jpeg Daniel possui graduação em Ciência da Computação pela UFBA, mestrado em Ciência da Computação pela Unicamp e doutorado em Ciência da Computação também pela Unicamp. É professor do Departamento de Ciência da Computação do IME/USP desde fevereiro de 2011 onde ministra regularmente as disciplinas de Sistemas Operacionais e Redes de Computadores para o BCC. Sua principal área de pesquisa é Redes de Computadores e orienta trabalhos nessa área nos níveis de doutorado, mestrado e iniciação científica. +Sorria! Você está sendo filmado: Os Problemas e Problemas da Vigilância Automatizada Baseada em Vídeos Com o crescente número de câmeras instaladas nas cidades e o grande interesse em sistemas de inteligência artificial, discutir vigilância automatizada se torna imprescindível. Esta palestra irá introduzir o assunto, passando por conceitos fundamentais, possíveis aplicações e desafios. Também discutiremos os principais impactos dessas tecnologias. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 07/10/2026 12:30:00 07/10/2026 13:30:00 Helena de Almeida Maia helena-maia.jpg Helena Maia é professora no Instituto de Computação (IC) da Universidade Estadual de Campinas (UNICAMP). É membro do laboratório de inteligência artificial recod.ai, professora colaboradora no Hub de Inteligência Artificial e Arquiteturas Cognitivas (H.IAAC) e pesquisadora no projeto Linguagem Humana e Inteligência Artificial (LIA). Suas áreas de atuação incluem Ética e Letramento em Inteligência Artificial, Processamento de Linguagem Natural, Visão Computacional e Aprendizado de Máquina. Possui graduação e mestrado em Ciência da Computação pela Universidade Federal de Juiz de Fora (UFJF), e doutorado em Ciência da Computação pela UNICAMP. +Computação Quântica como você nunca viu "O imaginário popular enquadra a computação quântica como um bicho de sete cabeças impossível de ser compreendido por meros mortais. Mas será que precisa mesmo ser assim? Nós usaremos o jogo de tabuleiro ""Entanglion"", desenvolvido pela IBM, para que você entenda as bases deste novo campo da ciência de maneira natural, apresentando conceitos como entrelaçamento e superposição de forma intuitiva, sem perder o viés científico." Workshop 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 05/10/2026 13:40:00 05/10/2026 14:40:00 Projeto Entanglion entanglion.jpeg O Projeto Entanglion faz parte de uma AEX (Atividade Extensionista), organizada pelo prof. Dr. Marcos Chaim, que visa divulgar a computação quântica para o público geral. Fazemos isso promovendo oficinas práticas com partidas de Entanglion nas quais explicamos os conceitos teóricos por trás do jogo de tabuleiro desenvolvido pela IBM. Já promovemos estas oficinas em Board Games Houses, escolas, além de sermos correspondentes da Rede Iberoamericana para o Avanço da Engenharia de Software Quântico (RIPAISC) +Oficina de GIT O FLUSP dará seu melhor para letrar os interessados nos fundamentos do GIT... e aqueles com a guarda baixa sem dúvida serão recrutados para utilizarem os conhecimentos adquiridos no desenvolvimento de software livre! Workshop 1 250 CEC, IME-USP - Bloco B 05/10/2026 16:20:00 05/10/2026 17:20:00 FLUSP - Free, Libre, open source software na USP flusp.jpg Grupo de Extensão de software livre e aberto da USP +Modelagem Booleana de Redes Gênicas: da lógica ao comportamento celular Como valores binários e operadores AND, OR e NOT podem ajudar a compreender o comportamento de uma célula? Nesta palestra, veremos como redes Booleanas representam interações entre componentes celulares e como regras locais podem produzir diferentes comportamentos, como a divisão celular, a interrupção do ciclo ou a morte da célula. Conectaremos conceitos familiares à Computação — estados, transições e dinâmica de redes — a questões biológicas: como uma mesma rede pode apresentar comportamentos distintos? Como alterações em seus componentes afetam essa dinâmica? E o que podemos concluir a partir das previsões de um modelo? Com exemplos de aplicações em Biologia, discutiremos as possibilidades e os limites da modelagem Booleana. Os conceitos biológicos necessários serão introduzidos ao longo da apresentação, sem exigir conhecimento prévio de Biologia. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 07/10/2026 16:20:00 07/10/2026 17:20:00 Ronaldo Fumio Hashimoto ronaldo-hashimoto.jpg Ronaldo Fumio Hashimoto é professor do Instituto de Matemática, Estatística e Ciência da Computação da Universidade de São Paulo (IME-USP). Sua pesquisa abrange processamento de imagens, aprendizado de máquina e bioinformática. Em processamento de imagens, desenvolve métodos baseados em morfologia matemática e representações hierárquicas, com foco em algoritmos eficientes de filtragem e na integração de operadores morfológicos a redes neurais. Na interface entre Computação e Biologia, investiga aplicações de aprendizado de máquina em bioinformática, além da modelagem e inferência de redes de regulação gênica. +Como a Tako escalou com a mesma infraestrutura e desenvolveu um produto de IA muito além do chatbot Cases, conceitos e frameworks que fizeram a Tako escalar e se tornar um dos principais players de IA para RH do Brasil Palestra 1 450 Auditório Jacy Monteiro, IME-USP - Bloco B 09/10/2026 13:40:00 09/10/2026 14:40:00 Bruno Cerejo | André Spanguero bruno-cerejo.jpeg | andre-spanguero.jpg Bruno Cerejo é engenheiro de software na Tako, com mais de 12 anos em tecnologia e passagens por Nubank, Mercado Livre e Cielo. É formado em Análise e Desenvolvimento de Sistemas pela Fatec São Paulo. | André Spanguero é formado em Ciência da Computação pela USP e atua como engenheiro de software na Tako. Com mais de 10 anos de experiência em tecnologia e passagens por Google, Zé Delivery e RocketSeat. +Como colorir um grafo propriamente com menos cores que o mínimo possível O número cromático χ(G) de um grafo G é menor número de cores que podemos usar em uma coloração dos vértices de G de forma que a coloração seja própria, isto é, não haja arestas com suas duas pontas de cores iguais. Curiosamente, para certos grafos G, é possível encontrar tais colorações com menos cores que χ(G), caso admitamos colorações próprias quânticas. Discutiremos esse fenômeno nesta palestra, introduzindo, naturalmente, o que se entende por tais colorações quânticas. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 06/10/2026 16:20:00 06/10/2026 17:20:00 Yoshiharu Kohayakawa yoshiharu-kohayakawa.jpg Yoshiharu Kohayakawa é Professor Titular da Universidade de São Paulo desde 2004. Obteve seu título de doutor em matemática na Universidade de Cambridge (1991), sob a orientação de Béla Bollobás. Seus interesses concentram-se nas áreas de combinatória e teoria da computação. Suas linhas de pesquisa envolvem, entre outros, grafos aleatórios, teoria de Ramsey, problemas extremais, métodos probabilísticos, e o método da regularidade. +Quando as máquinas agem: agentes, trabalho e sociedade Nesta palestra eu vou falar sobre agentes, sua história, sua relação com os modelos de linguagem atuais, seu impacto no trabalho dos profissionais de computação e a questão mais importante, quem se responsabiliza pela ação dos agentes. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 07/10/2026 13:40:00 07/10/2026 14:40:00 Roberto Hirata Jr. roberto-hirata.jpeg Roberto é professor do Instituto de Matemática, Estatística e Ciência da Computação da Universidade de São Paulo. Suas áreas de pesquisa são visão computacional e aprendizado de máquina. +Computando no escuro: criptografia homomórfica e suas aplicações em privacidade Toda consulta a um serviço online revela algo. Ao buscar um sintoma num banco de dados hospitalar, verificar se uma senha foi vazada ou mesmo identificar um número desconhecido. Em todas as consultas, o usuário entrega ao servidor alguma informação que deseja saber. A criptografia tradicional protege essa consulta de quem observa a rede, mas não do próprio servidor, que precisa de fato ler a pergunta para respondê-la. entretatanto, muitas vezes, a pergunta revela mais do que a resposta... Seria possível obter uma informação sem revelar qual informação se procura? À primeira vista, isso exigiria algo impossível: que o servidor respondesse a uma pergunta que não consegue ler. Esse é o problema da recuperação privada de informação (Private Information Retrieval - PIR). Uma das possíveis técnica para resolver esse problema é através da criptografia homomórfica, que permite realizar cálculos sobre dados cifrados. Nesta palestra, veremos como é possível perguntar sem revelar a pergunta. Não é necessário conhecimento prévio de criptografia. Palestra 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 08/10/2026 12:30:00 08/10/2026 13:30:00 Luiza Soezima luiza-soezima.jpg Luiza é estudante de doutorado na Aarhus University (Dinamarca), com orientação de Diego F. Aranha e Peter Scholl. Sua pesquisa está na interseção entre criptografia aplicada e privacidade. Ela trabalha com primitivas como a recuperação privada de informação (PIR) e operações privadas sobre conjuntos, e com aplicações como comunicação segura e transações financeiras seguras. Graduou-se em 2024 no BCC e prosseguiu com um mestrado em computação com ênfase em Cybersecurity na Université Grenoble Alpes (França). +Roda de conversa & Dúvidas sobre carreira acadêmica e pós-graduação em computação Junte-se aos professores Renata Wasserman e Guilherme Oliveira Mota, ao lado de alunos de pós-graduação do IME-USP, como Carlos Marques e Idian Capozzoli, em uma conversa aberta e descontraída sobre os rumos da carreira acadêmica em Computação. O encontro abordará como funciona a pós-graduação, a escolha de áreas de pesquisa e as vivências reais de quem está em diferentes momentos da trajetória científica. Reunindo as perspectivas de docentes e pós-graduandos, o papo promete um panorama completo e autêntico sobre o universo da pesquisa. Esta é uma oportunidade única para tirar suas dúvidas, trocar ideias e entender de perto os próximos passos para o seu futuro acadêmico. Conversa 1 250 Auditório Jacy Monteiro, IME-USP - Bloco B 09/10/2026 16:20:00 09/10/2026 17:20:00 Renata Wasserman | Guilherme Oliveira Mota | Carlos Marques | Idian Capozzoli renata-wasserman.jpg | guilherme-mota.jpg | carlos-marques.jpg | idian-capozzoli.jpg Renata Wasserman é professora associada do Departamento de Ciência da Computação do Instituto de Matemática e Estatística da USP. E membro do grupo de pesquisa em Lógica, Inteligência Artificial e Métodos Formais (LIAMF), pesquisadora do Centro de Inteligência Artificial (C4AI) e integra o conselho diretor do Lawgorithm. | Guilherme Oliveira Mota é professor do Departamento de Ciência da Computação do Instituto de Matemática e Estatística da USP. É pesquisador na área de Combinatória e Teoria dos Grafos, atuando principalmente em combinatória extremal e probabilística, métodos probabilísticos e algoritmos em grafos. | Carlos Marques é graduado no BCC do IME-USP em 2025, atualmente é aluno de mestrado no Programa de Pós Graduação em Ciência da Computação do mesmo instituto, orientado pela Profª Nina S. T. Hirata. Membro do LEARN (Liga de Estudos em Aprendizado de Máquina e Redes Neurais), possui interesse em Graph Neural Networks. | Idian Capozzoli se graduou no BCC em 2025 e atualmente é estudante e bolsista FAPESP de mestrado no IME. É orientada por Yoshiko Wakabayashi, coorientada por Cristiane Sato e trabalha com otimização combinatória, em especial com problemas de coloração em grafos. Suas principais áreas de interesse são otimização, combinatória e teoria da computação. +Encerramento Para encerrar a XVI Semana da Computação, teremos uma tradicional roda de conversa com professores e ex-alunos do curso. O encontro será um espaço aberto para trocar experiências, relembrar histórias, discutir as transformações do mundo da computação e refletir sobre as mudanças tecnológicas e acadêmicas ao longo dos anos. Além de compartilhar trajetórias e perspectivas sobre o futuro da área, o evento também será uma oportunidade para os alunos atuais tirarem dúvidas e interagirem com quem já trilhou esse caminho. Encerrando a tarde, teremos um coffee break especial para celebrar o fim de mais uma Semana da Computação e fortalecer os laços entre gerações do curso. Encerramento 1 250 09/10/2026 17:40:00 09/10/2026 18:40:00 \ No newline at end of file diff --git a/backend/scripts/seed_semana_data.py b/backend/scripts/seed_semana_data.py new file mode 100644 index 00000000..86042b2c --- /dev/null +++ b/backend/scripts/seed_semana_data.py @@ -0,0 +1,279 @@ +"""Seed the initial Semana da Computacao 2026 schedule. + +Run from ``backend/`` with ``uv run python scripts/seed_semana_data.py`` after +configuring the environment for the intended database. +Existing events and activities are left unchanged; only missing records are added. +Activity details are read from ``scripts/data/palestras.tsv`` and speaker images +from ``scripts/data/imagens_palestrantes``. +""" + +import asyncio +import csv +from collections.abc import AsyncGenerator +from contextlib import asynccontextmanager +from datetime import datetime +from importlib import import_module +from pathlib import Path +from zoneinfo import ZoneInfo + +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.atividade.image import MAX_IMAGE_BYTES +from app.atividade.models import Atividade, StatusAtividade, TipoAtividade +from app.atividade.services import create_atividade +from app.core.config import Settings, get_settings +from app.core.database import create_database +from app.core.storage import delete_file, save_bytes +from app.semana.models import Semana + +import_module("app.challenges.models.challenge") +import_module("app.users.models") + +DATA_DIR = Path(__file__).resolve().parent / "data" +SCHEDULE_FILE = DATA_DIR / "palestras.tsv" +SPEAKER_IMAGES_DIR = DATA_DIR / "imagens_palestrantes" +LOCAL_TIMEZONE = ZoneInfo("America/Sao_Paulo") +SUPPORTED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp"} + +ACTIVITY_TYPES = { + "Palestra": TipoAtividade.PALESTRA, + "Workshop": TipoAtividade.WORKSHOP, + "Encerramento": TipoAtividade.ENCERRAMENTO, + "Conversa": TipoAtividade.CONVERSA, +} + + +@asynccontextmanager +async def session_scope(settings: Settings) -> AsyncGenerator[AsyncSession, None]: + engine, session_factory = create_database(settings) + try: + async with session_factory() as session: + try: + yield session + await session.commit() + except Exception: + await session.rollback() + raise + finally: + await engine.dispose() + + +def load_schedule() -> list[dict]: + required_columns = { + "Título da atividade", + "Descrição da atividade", + "Tipo de Atividade", + "Horas", + "Pontos", + "Localização", + "Horário Começo", + "Horário Término", + "Nomes dos palestrantes", + "Arquivos de Imagem", + "Descrições dos palestrantes", + } + with SCHEDULE_FILE.open(encoding="utf-8-sig", newline="") as file: + reader = csv.DictReader(file, delimiter="\t") + if reader.fieldnames is None or not required_columns.issubset( + reader.fieldnames + ): + raise ValueError(f"Unexpected columns in {SCHEDULE_FILE}.") + if len(reader.fieldnames) != len(set(reader.fieldnames)): + raise ValueError(f"Duplicate columns in {SCHEDULE_FILE}.") + + schedule = [] + seen_titles = set() + for line_number, row in enumerate(reader, start=2): + if None in row or any(value is None for value in row.values()): + raise ValueError( + f"Invalid number of columns on TSV line {line_number}." + ) + + title = row["Título da atividade"].strip() + activity_type = ACTIVITY_TYPES.get(row["Tipo de Atividade"].strip()) + if not title or activity_type is None: + raise ValueError( + f"Invalid title or activity type on TSV line {line_number}." + ) + if title in seen_titles: + raise ValueError(f"Duplicate activity title on TSV line {line_number}.") + if len(title) > 255: + raise ValueError( + f"Activity title is too long on TSV line {line_number}." + ) + + description = row["Descrição da atividade"].strip() or None + location = row["Localização"].strip() or None + if description is not None and len(description) > 5000: + raise ValueError(f"Description is too long on TSV line {line_number}.") + if location is not None and len(location) > 255: + raise ValueError(f"Location is too long on TSV line {line_number}.") + + try: + starts_at = datetime.strptime( + row["Horário Começo"].strip(), "%d/%m/%Y %H:%M:%S" + ).replace(tzinfo=LOCAL_TIMEZONE) + ends_at = datetime.strptime( + row["Horário Término"].strip(), "%d/%m/%Y %H:%M:%S" + ).replace(tzinfo=LOCAL_TIMEZONE) + hours = int(row["Horas"]) + points = int(row["Pontos"]) + except ValueError as error: + raise ValueError( + f"Invalid date or numeric value on TSV line {line_number}." + ) from error + if ends_at <= starts_at: + raise ValueError(f"Invalid schedule on TSV line {line_number}.") + if starts_at.year != 2026 or ends_at.year != 2026: + raise ValueError( + f"Schedule is outside the 2026 event on TSV line {line_number}." + ) + if hours < 1 or points < 0: + raise ValueError(f"Invalid hours or points on TSV line {line_number}.") + + speakers = [] + speaker_fields = [ + [value.strip() for value in row[field].split("|")] + for field in ( + "Nomes dos palestrantes", + "Arquivos de Imagem", + "Descrições dos palestrantes", + ) + ] + if len({len(values) for values in speaker_fields}) != 1: + raise ValueError( + f"Speaker columns have different counts on TSV line {line_number}." + ) + + for speaker_number, (name, image_name, bio) in enumerate( + zip(*speaker_fields, strict=True), start=1 + ): + name, image_name, bio = name.strip(), image_name.strip(), bio.strip() + if not any((name, image_name, bio)): + continue + if not name: + raise ValueError( + f"Speaker name is missing on TSV line {line_number}, " + f"speaker {speaker_number}." + ) + if not image_name: + raise ValueError( + f"Speaker image is missing on TSV line {line_number}, " + f"speaker {speaker_number}." + ) + if not bio: + raise ValueError( + f"Speaker bio is missing on TSV line {line_number}, " + f"speaker {speaker_number}." + ) + if Path(image_name).name != image_name or "\\" in image_name: + raise ValueError( + f"Invalid speaker image path on TSV line {line_number}." + ) + + image_path = SPEAKER_IMAGES_DIR / image_name if image_name else None + if image_path.suffix.lower() not in SUPPORTED_IMAGE_EXTENSIONS: + raise ValueError( + f"Unsupported speaker image type on TSV line {line_number}: " + f"{image_path.suffix}" + ) + if not image_path.is_file(): + raise FileNotFoundError( + f"Speaker image not found on TSV line {line_number}: {image_path}" + ) + if not 0 < image_path.stat().st_size <= MAX_IMAGE_BYTES: + raise ValueError( + f"Speaker image has an invalid size on TSV line {line_number}: " + f"{image_path}" + ) + speakers.append({"nome": name, "sobre": bio, "image_path": image_path}) + + schedule.append( + { + "tipo": activity_type, + "titulo": title, + "descricao": description, + "local": location, + "speakers": speakers, + "comeca_as": starts_at, + "termina_as": ends_at, + "pontos": points, + "horas": hours, + } + ) + seen_titles.add(title) + if not schedule: + raise ValueError(f"No activities found in {SCHEDULE_FILE}.") + return schedule + + +async def main() -> None: + settings = get_settings() + schedule = load_schedule() + stored_images = [] + created_count = 0 + skipped_count = 0 + try: + async with session_scope(settings) as session: + event = await session.scalar(select(Semana).where(Semana.ano == 2026)) + if event is None: + event = Semana(nome="Semana da Computação 2026", ano=2026) + session.add(event) + await session.flush() + + activities = await session.scalars( + select(Atividade).where(Atividade.semana_id == event.id) + ) + existing_titles = {activity.titulo for activity in activities.all()} + + for item in schedule: + if item["titulo"] in existing_titles: + skipped_count += 1 + continue + + speakers = [] + for speaker in item["speakers"]: + speaker_data = { + "nome": speaker["nome"], + "sobre": speaker["sobre"], + } + image_path = speaker["image_path"] + if image_path is not None: + extension = image_path.suffix.lstrip(".").lower() + relative_path = await save_bytes( + image_path.read_bytes(), + subdir="palestrantes", + extension=extension, + ) + stored_images.append(relative_path) + speaker_data["foto"] = f"/media/{relative_path}" + speakers.append(speaker_data) + + activity_fields = { + key: value for key, value in item.items() if key != "speakers" + } + await create_atividade( + session, + event, + **activity_fields, + palestrantes=speakers, + link_live=None, + status=StatusAtividade.CONFIRMADA, + ) + existing_titles.add(item["titulo"]) + created_count += 1 + except Exception: + for relative_path in stored_images: + delete_file(relative_path) + raise + + print(f"Semana: {event.id} ({event.nome} {event.ano})") + print( + f"Activities created: {created_count}; " + f"existing activities skipped: {skipped_count}." + ) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/frontend/src/features/attendance/components/attendance-page.tsx b/frontend/src/features/attendance/components/attendance-page.tsx index 1b806b58..abe801c2 100644 --- a/frontend/src/features/attendance/components/attendance-page.tsx +++ b/frontend/src/features/attendance/components/attendance-page.tsx @@ -132,7 +132,11 @@ export function AttendancePage() {
)} -