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.

import cv2
img = cv2.imread('input.jpg', cv2.IMREAD_GRAYSCALE)
blur = cv2.GaussianBlur(img, (5,5), 0)
edges = cv2.Canny(blur, 50, 150)
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, contours, -1, (255,0,0), 2)
cv2.imwrite('contours.jpg', img)

Contexto Herez: usado em projeto de inspeção visual para detectar defeitos em peças industriais; pipeline em produção disponível nos repositórios Herez.

import mahotas as mh
import numpy as np
img = mh.imread('input.png', as_grey=True)
textures = mh.features.haralick(img).mean(axis=0)
print('Haralick features:', textures)

Contexto Herez: extração de descritores para classificação de texturas em imagens de satélite; versão otimizada em C++ integrada ao pipeline de análise.

from skimage import io, filters, morphology
img = io.imread('input.jpg', as_gray=True)
denoised = filters.gaussian(img, sigma=1)
th = filters.threshold_otsu(denoised)
mask = denoised > th
clean = morphology.remove_small_objects(mask, min_size=500)
io.imsave('segmented.png', clean.astype('uint8')*255)

Contexto Herez: usado em projetos de análise de imagens biológicas para segmentar células; notebooks com experimentos estão nos repositórios Herez.

from pgmagick import Image
img = Image('input.tif')
img.resize('800x600')
img.quality(85)
img.write('output.jpg')

Contexto Herez: pipeline de geração de thumbnails e otimização de imagens para portais de conteúdo; scripts de conversão em lote disponíveis nos repositórios Herez.

import SimpleITK as sitk
fixed = sitk.ReadImage('fixed.nii')
moving = sitk.ReadImage('moving.nii')
initial_transform = sitk.CenteredTransformInitializer(fixed, moving, sitk.Euler3DTransform())
registration = sitk.ImageRegistrationMethod()
registration.SetMetricAsMeanSquares()
registration.SetOptimizerAsRegularStepGradientDescent(learningRate=1.0, minStep=1e-6, numberOfIterations=200)
registration.SetInitialTransform(initial_transform, inPlace=False)
final_transform = registration.Execute(fixed, moving)
resampled = sitk.Resample(moving, fixed, final_transform, sitk.sitkLinear, 0.0, moving.GetPixelID())
sitk.WriteImage(resampled, 'registered.nii')

Contexto Herez: aplicado em projeto de análise de imagens médicas para alinhar séries temporais; pipelines e exemplos clínicos estão documentados nos repositórios Herez.