Python Pyramid 개념 정리

1️⃣ Pyramid 기초

Pyramid는 유연하고 확장 가능한 파이썬 웹 프레임워크이다. 확장성과 모듈성에 중점을 둔 이 프레임워크는 간단한 애플리케이션부터 대규모 엔터프라이즈 수준의 웹 서비스까지 다양한 규모의 프로젝트에 적합하다.

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def hello_world(request):
    """단순한 Hello World 응답을 반환하는 뷰 함수"""
    return Response('Hello World!')

def create_user(request):
    """사용자 생성 API 엔드포인트"""
    user_data = request.json_body
    # 사용자 생성 로직
    return Response(json={'status': 'created', 'user_id': 123})

class PyramidApp:
    """Pyramid 애플리케이션을 설정하고 실행하는 클래스"""
    
    def __init__(self, host='0.0.0.0', port=6543):
        self.host = host
        self.port = port
        self.config = None
        self.app = None
    
    def setup(self):
        """애플리케이션 설정"""
        self.config = Configurator()
        
        # 기본 라우트 설정
        self.config.add_route('hello', '/')
        self.config.add_view(hello_world, route_name='hello')
        
        # API 라우트 설정
        self.config.add_route('users', '/users')
        self.config.add_view(create_user, route_name='users', 
                           request_method='POST', renderer='json')
        
        # 정적 파일 설정
        self.config.add_static_view('static', 'static', cache_max_age=3600)
        
        # WSGI 애플리케이션 생성
        self.app = self.config.make_wsgi_app()
        return self
    
    def serve(self):
        """서버 실행"""
        print(f"서버 시작: http://{self.host}:{self.port}")
        server = make_server(self.host, self.port, self.app)
        server.serve_forever()

if __name__ == '__main__':
    app = PyramidApp()
    app.setup().serve()

✅ 특징:

유연한 라우팅 설정
다양한 뷰 함수 정의 방식
WSGI 호환 서버 실행
확장성이 뛰어난 구조
설정 가능한 미들웨어
다양한 템플릿 엔진 지원
플러그인 기반 아키텍처

2️⃣ 라우팅과 뷰

Pyramid는 유연한 라우팅 시스템과 다양한 뷰 정의 방식을 제공하여 웹 애플리케이션의 URL 구조와 요청 처리를 효과적으로 관리할 수 있다.

from pyramid.view import view_config, view_defaults
from pyramid.response import Response
from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest

# 클래스 기반 뷰 정의
@view_defaults(route_name='users', renderer='json')
class UserViews:
    """사용자 관리를 위한 뷰 클래스"""
    
    def __init__(self, request):
        self.request = request
        self.user_db = {
            '1': {'id': '1', 'name': 'User 1', 'email': '[email protected]'},
            '2': {'id': '2', 'name': 'User 2', 'email': '[email protected]'}
        }
    
    @view_config(request_method='GET')
    def get_users(self):
        """모든 사용자 조회"""
        return {'users': list(self.user_db.values())}
    
    @view_config(request_method='POST')
    def create_user(self):
        """새 사용자 생성"""
        try:
            data = self.request.json_body
            if not all(k in data for k in ('name', 'email')):
                return HTTPBadRequest(json={'error': '필수 필드가 누락되었습니다'})
            
            # 간단한 ID 생성 (실제로는 UUID 등 사용)
            new_id = str(len(self.user_db) + 1)
            self.user_db[new_id] = {
                'id': new_id,
                'name': data['name'],
                'email': data['email']
            }
            return {'status': 'created', 'user': self.user_db[new_id]}
        except Exception as e:
            return HTTPBadRequest(json={'error': str(e)})

# 함수 기반 뷰 (패턴 매칭 사용)
@view_config(route_name='user', request_method='GET', renderer='json')
def get_user(request):
    """특정 사용자 정보 조회"""
    user_id = request.matchdict['id']
    user_db = {
        '1': {'id': '1', 'name': 'User 1', 'email': '[email protected]'},
        '2': {'id': '2', 'name': 'User 2', 'email': '[email protected]'}
    }
    
    if user_id not in user_db:
        raise HTTPNotFound(json={'error': f'User {user_id} not found'})
    
    return {'user': user_db[user_id]}

# 라우트 설정을 위한 함수
def includeme(config):
    """라우트 설정을 중앙화하는 함수"""
    # 기본 라우트
    config.add_route('home', '/')
    config.add_view(lambda r: Response('Welcome to Pyramid!'), route_name='home')
    
    # RESTful API 라우트
    config.add_route('users', '/api/users')
    config.add_route('user', '/api/users/{id}')
    
    # 스캔하여 데코레이터로 정의된 뷰 등록
    config.scan('.')

✅ 특징:

클래스 기반 뷰 지원
함수 기반 뷰 지원
URL 패턴 매칭 (경로 변수)
데코레이터를 통한 뷰 설정
다양한 HTTP 메서드 처리
JSON 및 다양한 렌더러 지원
HTTP 예외 처리 메커니즘
중첩 라우팅 구조 지원

3️⃣ 데이터베이스 통합

Pyramid는 SQLAlchemy와 같은 ORM 라이브러리와 쉽게 통합되어 데이터베이스 작업을 효율적으로 처리할 수 있다.

from sqlalchemy import create_engine, Column, Integer, String, DateTime, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship, scoped_session
from pyramid.config import Configurator
from pyramid.response import Response
from pyramid.view import view_config
from datetime import datetime
import transaction

# SQLAlchemy 모델 정의
Base = declarative_base()

class User(Base):
    """사용자 모델"""
    __tablename__ = 'users'
    
    id = Column(Integer, primary_key=True)
    username = Column(String(50), unique=True, nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    posts = relationship('Post', back_populates='author', cascade='all, delete-orphan')
    
    def __repr__(self):
        return f"<User(username='{self.username}', email='{self.email}')>"
    
    def to_dict(self):
        return {
            'id': self.id,
            'username': self.username,
            'email': self.email,
            'created_at': self.created_at.isoformat(),
            'post_count': len(self.posts)
        }

class Post(Base):
    """게시물 모델"""
    __tablename__ = 'posts'
    
    id = Column(Integer, primary_key=True)
    title = Column(String(100), nullable=False)
    content = Column(String, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
    
    author = relationship('User', back_populates='posts')
    
    def to_dict(self):
        return {
            'id': self.id,
            'title': self.title,
            'content': self.content,
            'created_at': self.created_at.isoformat(),
            'user_id': self.user_id,
            'author_username': self.author.username
        }

# 데이터베이스 세션 관리
def get_db_session(request):
    """요청 객체에 데이터베이스 세션을 추가하는 팩토리 함수"""
    session = request.registry.dbmaker()
    
    def cleanup(request):
        if request.exception is not None:
            transaction.abort()
            session.rollback()
        else:
            try:
                transaction.commit()
            except:
                transaction.abort()
                session.rollback()
                raise
        session.close()
    
    request.add_finished_callback(cleanup)
    return session

# 데이터베이스 초기화 함수
def initialize_db(settings):
    """데이터베이스 초기화 및 세션 팩토리 생성"""
    engine = create_engine(settings['sqlalchemy.url'])
    Base.metadata.create_all(engine)
    
    session_factory = sessionmaker(bind=engine)
    return scoped_session(session_factory)

# 뷰 함수 예제
@view_config(route_name='users', request_method='POST', renderer='json')
def create_user(request):
    """새 사용자 생성 API"""
    session = request.db
    
    try:
        user_data = request.json_body
        
        # 사용자 생성
        user = User(
            username=user_data['username'],
            email=user_data['email']
        )
        
        session.add(user)
        session.flush()  # ID 생성을 위해 플러시
        
        return user.to_dict()
    except Exception as e:
        session.rollback()
        return {'error': str(e)}

@view_config(route_name='user_posts', request_method='POST', renderer='json')
def create_post(request):
    """사용자의 새 게시물 생성 API"""
    session = request.db
    user_id = int(request.matchdict['user_id'])
    
    try:
        # 사용자 존재 여부 확인
        user = session.query(User).filter_by(id=user_id).first()
        if not user:
            return {'error': 'User not found'}
        
        post_data = request.json_body
        post = Post(
            title=post_data['title'],
            content=post_data['content'],
            user_id=user_id
        )
        
        session.add(post)
        session.flush()
        
        return post.to_dict()
    except Exception as e:
        session.rollback()
        return {'error': str(e)}

# Pyramid 애플리케이션 설정
def main(global_config, **settings):
    """WSGI 애플리케이션 팩토리"""
    config = Configurator(settings=settings)
    
    # 데이터베이스 초기화
    dbmaker = initialize_db(settings)
    config.registry.dbmaker = dbmaker
    config.add_request_method(get_db_session, 'db', reify=True)
    
    # 라우트 설정
    config.add_route('users', '/api/users')
    config.add_route('user', '/api/users/{id}')
    config.add_route('user_posts', '/api/users/{user_id}/posts')
    
    config.scan()
    return config.make_wsgi_app()

✅ 특징:

SQLAlchemy ORM 통합
트랜잭션 관리
세션 라이프사이클 관리
모델 정의 및 관계 설정
요청별 데이터베이스 세션
예외 처리와 롤백 메커니즘
JSON 응답 직렬화
다양한 데이터베이스 지원

4️⃣ 인증과 권한

from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.security import (
    Allow,
    Everyone,
    Authenticated,
    ALL_PERMISSIONS
)

class RootFactory(object):
    __acl__ = [
        (Allow, Everyone, 'view'),
        (Allow, Authenticated, 'create'),
        (Allow, 'admin', ALL_PERMISSIONS)
    ]
    
    def __init__(self, request):
        pass

def groupfinder(userid, request):
    user = request.db.query(User).filter_by(id=userid).first()
    if user:
        return ['group:' + g.name for g in user.groups]

@view_config(route_name='secure', permission='view')
def secure_view(request):
    return Response('This is a secure view')

✅ 특징:

인증 정책
권한 관리
ACL 설정
유연한 보안 모델
역할 기반 접근 제어
세션 관리 옵션
보안 정책 통합

5️⃣ 템플릿 및 프론트엔드 통합

Pyramid는 다양한 템플릿 엔진을 지원하고 정적 파일 제공 기능을 통해 프론트엔드 프레임워크와 쉽게 통합된다.

from pyramid.view import view_config
from pyramid.renderers import render_to_response
import json

# Jinja2 템플릿 사용 예제
@view_config(route_name='home', renderer='templates/home.jinja2')
def home_view(request):
    """Jinja2 템플릿을 사용하는 홈 페이지 뷰"""
    return {
        'title': 'Pyramid 애플리케이션',
        'message': '환영합니다!',
        'features': [
            '유연한 라우팅',
            '강력한 보안 모델',
            '데이터베이스 통합',
            '다양한 템플릿 지원'
        ]
    }

# Chameleon 템플릿 사용 예제
@view_config(route_name='dashboard', renderer='templates/dashboard.pt')
def dashboard_view(request):
    """Chameleon 템플릿을 사용하는 대시보드 뷰"""
    # 데이터베이스에서 통계 데이터 로드 (예시)
    stats = {
        'users': 1250,
        'posts': 5432,
        'comments': 18345,
        'active_users': 328
    }
    
    # 최근 활동 데이터 (예시)
    recent_activities = [
        {'user': 'user1', 'action': '게시물 작성', 'time': '5분 전'},
        {'user': 'user2', 'action': '댓글 작성', 'time': '10분 전'},
        {'user': 'user3', 'action': '로그인', 'time': '15분 전'}
    ]
    
    return {
        'title': '관리자 대시보드',
        'stats': stats,
        'activities': recent_activities
    }

# API와 프론트엔드 통합
@view_config(route_name='app', renderer='templates/app.jinja2')
def spa_view(request):
    """SPA(Single Page Application) 프론트엔드를 위한 진입점"""
    # 초기 상태 데이터 준비
    initial_state = {
        'user': request.user.to_dict() if hasattr(request, 'user') else None,
        'config': {
            'apiUrl': request.route_url('api_root'),
            'staticUrl': request.static_url('myapp:static/'),
            'debug': request.registry.settings.get('debug', False)
        }
    }
    
    return {
        'title': 'Pyramid SPA',
        'initial_state': json.dumps(initial_state)
    }

# 정적 파일 설정
def configure_static(config):
    """정적 파일 설정"""
    # 기본 정적 파일 경로
    config.add_static_view('static', 'static', cache_max_age=3600)
    
    # 빌드된 프론트엔드 애셋 (예: React, Vue 등)
    config.add_static_view('assets', 'assets', cache_max_age=3600)
    
    # 파비콘 설정
    config.add_route('favicon', '/favicon.ico')
    config.add_view(
        lambda r: FileResponse('static/favicon.ico', request=r),
        route_name='favicon'
    )

# 템플릿 설정
def configure_templates(config):
    """템플릿 엔진 설정"""
    # Jinja2 설정
    config.include('pyramid_jinja2')
    config.add_jinja2_renderer('.html')
    config.add_jinja2_search_path('templates', name='.html')
    
    # Chameleon 설정
    config.include('pyramid_chameleon')
    
    # 공통 템플릿 변수
    config.add_renderer_globals_subscriber(add_renderer_globals)

def add_renderer_globals(event):
    """모든 템플릿에 전역 변수 추가"""
    request = event.get('request')
    if request is None:
        return
    
    event['site_name'] = 'Pyramid 애플리케이션'
    event['current_year'] = datetime.now().year
    event['debug'] = request.registry.settings.get('debug', False)
    
    # 인증된 사용자 정보
    if hasattr(request, 'user'):
        event['user'] = request.user

✅ 특징:

다양한 템플릿 엔진 지원 (Jinja2, Chameleon 등)
정적 파일 제공 및 캐싱
SPA 프레임워크와 통합 (React, Vue, Angular 등)
국제화 및 지역화 지원
자산 번들링 통합
템플릿 확장 및 상속
템플릿 헬퍼 함수
전역 템플릿 변수

주요 팁

✅ 모범 사례:

패키지 구조화: 확장성을 위한 모듈식 설계 적용
라우팅 최적화: 체계적인 URL 패턴 설계로 유지보수성 향상
보안 강화: CSRF 보호, XSS 방지, 안전한 인증 구현
데이터베이스 설계: 관계형 모델 설계와 마이그레이션 전략 수립
캐싱 전략: 서버 부하 감소와 응답 시간 개선을 위한 캐싱 적용
로깅 구현: 구조화된 로깅으로 문제 진단 및 모니터링 용이화
테스트 자동화: 단위 테스트, 통합 테스트, 기능 테스트 작성
배포 자동화: CI/CD 파이프라인 구축 및 컨테이너화 적용
확장성 설계: 플러그인 아키텍처 활용 및 이벤트 시스템 도입
성능 최적화: 프로파일링 및 병목 현상 식별/해결
문서화: API 문서와 개발자 가이드 작성

KR_Pyramid - somaz94/python-study GitHub Wiki

Python Pyramid 개념 정리

1️⃣ Pyramid 기초

2️⃣ 라우팅과 뷰

3️⃣ 데이터베이스 통합

4️⃣ 인증과 권한

5️⃣ 템플릿 및 프론트엔드 통합

주요 팁

⚠️ GitHub.com Fallback ⚠️

KR_Pyramid - somaz94/python-study GitHub Wiki

Python Pyramid 개념 정리

1️⃣ Pyramid 기초

2️⃣ 라우팅과 뷰

3️⃣ 데이터베이스 통합

4️⃣ 인증과 권한

5️⃣ 템플릿 및 프론트엔드 통합

주요 팁

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️