import requests

url = 'https://example.com'
resp = requests.get(url, timeout=10)
if resp.status_code == 200:
    with open('example.html', 'w', encoding='utf-8') as f:
        f.write(resp.text)
    print('Página salva em example.html')
else:
    print('Erro', resp.status_code)

Contexto Herez: usado como etapa inicial em pipelines para baixar páginas antes de parse; scripts de download em lote estão nos repositórios Herez.

import requests
from bs4 import BeautifulSoup

url = 'https://example.com/news'
resp = requests.get(url, timeout=10)
soup = BeautifulSoup(resp.text, 'lxml')
articles = []
for item in soup.select('article h2 a'):
    title = item.get_text(strip=True)
    link = item['href']
    articles.append({'title': title, 'link': link})
print(articles)

Contexto Herez: usado em projetos de monitoramento de notícias; pipelines com normalização e deduplicação estão nos repositórios Herez.

# myspider.py
import scrapy

class NewsSpider(scrapy.Spider):
    name = 'news'
    start_urls = ['https://example.com/news']

    def parse(self, response):
        for article in response.css('article'):
            yield {
                'title': article.css('h2 a::text').get(),
                'link': article.css('h2 a::attr(href)').get()
            }

Executar: scrapy runspider myspider.py -o results.json

Contexto Herez: usado para crawlers periódicos com politeness, rotação de user agents e integração com pipelines de armazenamento; projetos completos estão nos repositórios Herez.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from bs4 import BeautifulSoup

options = Options()
options.add_argument('--headless')
driver = webdriver.Chrome(options=options)
driver.get('https://example.com/dynamic')
html = driver.page_source
soup = BeautifulSoup(html, 'lxml')
titles = [h.get_text(strip=True) for h in soup.select('.post-title')]
print(titles)
driver.quit()

Contexto Herez: usado para páginas que carregam conteúdo via JavaScript e para fluxos autenticados; exemplos com login e captura de screenshots estão nos repositórios Herez.

import requests
from lxml import html

resp = requests.get('https://example.com/catalog', timeout=10)
doc = html.fromstring(resp.content)
items = []
for node in doc.xpath('//div[@class="product"]'):
    name = node.xpath('.//h3/text()')[0].strip()
    price = node.xpath('.//span[@class="price"]/text()')[0].strip()
    items.append({'name': name, 'price': price})
print(items)

Contexto Herez: usado quando seletores CSS não são suficientes; pipelines com XPath e validação de schema estão nos repositórios Herez.

import pygame, random, sys
pygame.init()
W, H = 640, 480
screen = pygame.display.set_mode((W,H))
clock = pygame.time.Clock()
player = pygame.Rect(W//2-25, H-60, 50, 50)
balls = []
score = 0
FONT = pygame.font.SysFont(None, 36)

while True:
    for e in pygame.event.get():
        if e.type == pygame.QUIT:
            pygame.quit(); sys.exit()
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]: player.x -= 5
    if keys[pygame.K_RIGHT]: player.x += 5
    if random.random() < 0.02:
        balls.append(pygame.Rect(random.randint(0,W-20), -20, 20, 20))
    for b in balls[:]:
        b.y += 5
        if b.colliderect(player):
            score += 1; balls.remove(b)
        elif b.y > H:
            balls.remove(b)
    screen.fill((30,30,40))
    pygame.draw.rect(screen, (200,50,50), player)
    for b in balls: pygame.draw.ellipse(screen, (50,200,50), b)
    screen.blit(FONT.render(f'Score: {score}', True, (255,255,255)), (10,10))
    pygame.display.flip()
    clock.tick(60)

Contexto Herez: versão usada em workshops internos para ensinar game loop, colisões e input; projeto completo com assets e testes está nos repositórios Herez.

import pyglet, random
window = pyglet.window.Window(640,480)
batch = pyglet.graphics.Batch()
player = pyglet.shapes.Rectangle(300,20,40,40,color=(50,150,255),batch=batch)
asteroids = []
label = pyglet.text.Label('Score: 0', x=10, y=450)
score = 0

@window.event
def on_draw():
    window.clear()
    batch.draw()
    label.draw()

def update(dt):
    global score
    if random.random() < 0.02:
        asteroids.append(pyglet.shapes.Circle(random.randint(0,640),480,10,color=(200,50,50),batch=batch))
    for a in asteroids[:]:
        a.y -= 200*dt
        if a.y < 0:
            asteroids.remove(a)
            a.delete()
        if a.x > player.x and a.x < player.x+40 and a.y < 60:
            score += 1
            asteroids.remove(a)
            a.delete()
    label.text = f'Score: {score}'

pyglet.clock.schedule_interval(update, 1/60.0)
pyglet.app.run()

Contexto Herez: usado em protótipos que exigiam integração OpenGL simples; código e variações estão nos repositórios Herez.

from OpenGL.GL import *
from OpenGL.GLUT import *
angle = 0.0

def display():
    global angle
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()
    glRotatef(angle, 0, 0, 1)
    glBegin(GL_TRIANGLES)
    glColor3f(1,0,0); glVertex2f(0,0.6)
    glColor3f(0,1,0); glVertex2f(-0.6,-0.6)
    glColor3f(0,0,1); glVertex2f(0.6,-0.6)
    glEnd()
    glutSwapBuffers()
    angle += 0.5

glutInit()
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA)
glutInitWindowSize(600,600)
glutCreateWindow(b'Rotating Triangle')
glutDisplayFunc(display)
glutIdleFunc(display)
glutMainLoop()

Contexto Herez: usado para prototipar shaders e efeitos gráficos; exemplos de integração com engines estão nos repositórios Herez.

import arcade
SCREEN_W, SCREEN_H = 800, 600

class MyGame(arcade.Window):
    def __init__(self):
        super().__init__(SCREEN_W, SCREEN_H, "Space Shooter")
        self.player = arcade.SpriteSolidColor(50,30,arcade.color.BLUE)
        self.player.center_x = SCREEN_W//2; self.player.center_y = 50
        self.bullets = arcade.SpriteList()
    def on_draw(self):
        arcade.start_render()
        self.player.draw()
        self.bullets.draw()
    def on_update(self, dt):
        self.bullets.update()
        for b in self.bullets:
            b.center_y += 5
            if b.center_y > SCREEN_H: b.kill()
    def on_key_press(self, key, modifiers):
        if key == arcade.key.SPACE:
            bullet = arcade.SpriteSolidColor(5,10,arcade.color.YELLOW)
            bullet.center_x = self.player.center_x; bullet.center_y = self.player.center_y+20
            self.bullets.append(bullet)

if __name__ == '__main__':
    game = MyGame()
    arcade.run()

Contexto Herez: usado para protótipos educacionais e jogos 2D com física simples; projetos completos com assets estão nos repositórios Herez.

from direct.showbase.ShowBase import ShowBase
from panda3d.core import AmbientLight, DirectionalLight

class MyApp(ShowBase):
    def __init__(self):
        super().__init__()
        self.scene = self.loader.loadModel('models/box')
        self.scene.reparentTo(self.render)
        self.scene.setPos(0, 10, 0)
        self.taskMgr.add(self.spin, 'spinTask')
    def spin(self, task):
        self.scene.setH(task.time * 60 % 360)
        return task.cont

app = MyApp()
app.run()

Contexto Herez: usado em protótipos 3D e simulações interativas; cenas, modelos e scripts de build estão nos repositórios Herez.

# views.py
from django.shortcuts import render
from .models import Article

def index(request):
    articles = Article.objects.order_by('-published')[:10]
    return render(request, 'blog/index.html', {'articles': articles})

Contexto Herez: usado em portal de conteúdo com CMS customizado; o admin do Django foi estendido para workflows editoriais. Código e scripts de deploy estão nos repositórios Herez.

from flask import Flask, jsonify, request
app = Flask(__name__)

@app.route('/api/predict', methods=['POST'])
def predict():
    data = request.json
    result = model.predict(data['features'])
    return jsonify({'prediction': result.tolist()})

Contexto Herez: microserviço de inferência para modelos de ML; containerizado e integrado ao gateway de API da Herez.

from bottle import route, run, request, response

@route('/hello')
def hello():
    return "Hello from Bottle"

run(host='0.0.0.0', port=8080)

Contexto Herez: usado em protótipos rápidos e ferramentas internas; exemplos de scripts estão nos repositórios Herez.

import cherrypy

class Hello:
    @cherrypy.expose
    def index(self):
        return "Hello CherryPy"

cherrypy.quickstart(Hello())

Contexto Herez: serviço interno de processamento de arquivos com servidor embutido; configuração de threads e logging ajustada para produção.

from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    return Response('Hello Pyramid')

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('hello', '/')
        config.add_view(hello_world, route_name='hello')
        app = config.make_wsgi_app()

Contexto Herez: usado em projetos que exigem migração incremental de monólitos para serviços modulares; exemplos de configuração e testes estão nos repositórios Herez.

# controller default.py
def index():
    rows = db(db.article).select(orderby=~db.article.created_on)
    return dict(rows=rows)

Contexto Herez: protótipos de aplicações internas e ferramentas administrativas; exemplos de modelos e controllers estão nos repositórios Herez.

# controller example
from tg import expose, TGController

class RootController(TGController):
    @expose('json')
    def index(self):
        return {'status': 'ok'}

Contexto Herez: aplicações modulares com camadas separadas de serviço e apresentação; padrões de projeto e testes disponíveis nos repositórios Herez.

# esquema e views são definidos por componentes; exemplo simplificado
# define entidades e relações, depois gere views automaticamente

Contexto Herez: usado em projetos de catalogação de dados e repositórios semânticos; modelos e scripts de ingestão estão nos repositórios Herez.

import dash
from dash import html, dcc
import plotly.express as px

app = dash.Dash(__name__)
df = px.data.iris()
fig = px.scatter(df, x='sepal_width', y='sepal_length', color='species')

app.layout = html.Div([
    dcc.Graph(figure=fig)
])

if __name__ == '__main__':
    app.run_server(debug=True)

Contexto Herez: dashboards de monitoramento de modelos e painéis de métricas; aplicações com autenticação e deploy em containers estão nos repositórios Herez.

import falcon
import json

class Resource:
    def on_get(self, req, resp):
        resp.media = {'status': 'ok'}

app = falcon.App()
app.add_route('/health', Resource())

Contexto Herez: APIs de baixa latência para serviços de autenticação e ingestão; exemplos de integração com gateways e testes de carga estão nos repositórios Herez.