OpenGL SuperBible ex RotatingCube

[Windspar]

It would be cool if someone on the Help forum could actually try to run this
and help me out a bit. I'm wanting to learn python and a little opengl at the
same time.

Sorry. Your could is to scary to run. It needs to be restructure.
sample

import pygame
import ctypes
import numpy as np
from OpenGL.GL import *
import OpenGL.GL.shaders as shaders

def shader_data(source):
    data = ''
    for line in source:
        data += line + '\n'

    return data

def create_shader():
    vertex_data = shader_data(("#version 330 core",
        "layout (location = 0) in vec3 position;",
        "void main()",
        "{",
            "gl_Position = vec4(position, 1.0);",
        "}"
    ))

    fragment_data = shader_data(("#version 330 core",
        "void main()",
        "{",
            "gl_FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);",
        "}"
    ))

    return shaders.compileProgram(
        shaders.compileShader(vertex_data, GL_VERTEX_SHADER),
        shaders.compileShader(fragment_data, GL_FRAGMENT_SHADER)
    )

class Triangle:
    def __init__(self):
        self.triangle()
        self.vao = glGenVertexArrays(1)
        self.vbo = glGenBuffers(1)
        #glGenVertexArrays(1, self.vao)
        #glGenBuffers(1, self.vbo)
        glBindVertexArray(self.vao)
        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
        glBufferData(GL_ARRAY_BUFFER, self.vertices.nbytes, self.vertices, GL_STATIC_DRAW)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
        glEnableVertexAttribArray(0)
        glBindVertexArray(0)
        self.program = create_shader()

    def render(self):
        glUseProgram(self.program)
        glBindVertexArray(self.vao)
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glBindVertexArray(0)

    def triangle(self):
        self.vertices = np.array([
            -0.5, -0.5, 0.0,
            0.5, -0.5, 0.0,
            0.0, 0.5, 0.0 ], np.float32)

    def clean_up(self):
        glDeleteBuffers(1, vbo)
        glDeleteVertexArrays(1, vao)

class Screen:
    def __init__(self):
        # pygame setup
        pygame.display.set_caption("Rotating Cube")
        self.surface = pygame.display.set_mode((800,600), pygame.OPENGL | pygame.DOUBLEBUF)
        self.clock = pygame.time.Clock()
        self.running = False
        # opengl setup
        glClearColor(0.1, 0.0, 0.0, 1.0);

    def loop(self, fps):
        triangle = Triangle()
        self.running = True
        while self.running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False

            glClear(GL_COLOR_BUFFER_BIT)
            triangle.render()
            pygame.display.flip()
            self.clock.tick(fps)

def main():
    pygame.init()
    screen = Screen()
    screen.loop(30)

main()