Instruction:
Create a Python 3 function to
check if the extensions are supported.

Response:
def check_extensions(self, supported):
        """
        "extensionsRequired": ["KHR_draco_mesh_compression"],
        "extensionsUsed": ["KHR_draco_mesh_compression"]
        """
        if self.data.get('extensionsRequired'):
            for ext in self.data.get('extensionsRequired'):
                if ext not in supported:
                    raise ValueError("Extension {} not supported".format(ext))

        if self.data.get('extensionsUsed'):
            for ext in self.data.get('extensionsUsed'):
                if ext not in supported:
                    raise ValueError("Extension {} not supported".format(ext))


Instruction:
Implement a function in Python 3 to
check if the bin files referenced in this object exist

Response:
def buffers_exist(self):
        """Checks if the bin files referenced exist"""
        for buff in self.buffers:
            if not buff.is_separate_file:
                continue

            path = self.path.parent / buff.uri
            if not os.path.exists(path):
                raise FileNotFoundError("Buffer {} referenced in {} not found".format(path, self.path))


Instruction:
Create a Python 3 function for
loading the index buffer and polygon list for a primitive

Response:
def load_indices(self, primitive):
        """Loads the index buffer / polygon list for a primitive"""
        if getattr(primitive, "indices") is None:
            return None, None

        _, component_type, buffer = primitive.indices.read()
        return component_type, buffer


Instruction:
How would you implement a function in Python 3 that
gets the bounding box for the mesh

Response:
def get_bbox(self, primitive):
        """Get the bounding box for the mesh"""
        accessor = primitive.attributes.get('POSITION')
        return accessor.min, accessor.max


Instruction:
Can you generate a brief explanation for the following Python 3 code
def interleaves(self, info):
        return info.byte_offset == self.component_type.size * self.components

Response: Does the buffer interleave with this one?


Instruction:
Write a Python 3 function that can
read buffer data :return: component count, component type, data

Response:
def read(self):
        """
        Reads buffer data
        :return: component count, component type, data
        """
        # ComponentType helps us determine the datatype
        dtype = NP_COMPONENT_DTYPE[self.componentType.value]
        return ACCESSOR_TYPE[self.type], self.componentType, self.bufferView.read(
            byte_offset=self.byteOffset,
            dtype=dtype,
            count=self.count * ACCESSOR_TYPE[self.type],
        )


Instruction:
Can you generate the documentation for the following Python 3 function
def info(self):
        buffer, byte_length, byte_offset = self.bufferView.info(byte_offset=self.byteOffset)
        return buffer, self.bufferView, \
            byte_length, byte_offset, \
            self.componentType, ACCESSOR_TYPE[self.type], self.count

Response: Get underlying buffer info for this accessor


Instruction:
Write a Python 3 function for
getting the underlying buffer info

Response:
def info(self, byte_offset=0):
        """
        Get the underlying buffer info
        :param byte_offset: byte offset from accessor
        :return: buffer, byte_length, byte_offset
        """
        return self.buffer, self.byteLength, byte_offset + self.byteOffset


Instruction:
Write a Python 3 function that can
set the 3D position of the camera in the cache

Response:
def set_position(self, x, y, z):
        """
        Set the 3D position of the camera

        :param x: float
        :param y: float
        :param z: float
        """
        self.position = Vector3([x, y, z])


Instruction:
Can you generate the documentation for the following Python 3 function
def view_matrix(self):
        self._update_yaw_and_pitch()
        return self._gl_look_at(self.position, self.position + self.dir, self._up)

Response: Returns the current view matrix for the camera.


Instruction:
Write a Python 3 function for
updating the camera vectors based on the current yaw and pitch.

Response:
def _update_yaw_and_pitch(self):
        """
        Updates the camera vectors based on the current yaw and pitch
        """
        front = Vector3([0.0, 0.0, 0.0])
        front.x = cos(radians(self.yaw)) * cos(radians(self.pitch))
        front.y = sin(radians(self.pitch))
        front.z = sin(radians(self.yaw)) * cos(radians(self.pitch))

        self.dir = vector.normalise(front)
        self.right = vector.normalise(vector3.cross(self.dir, self._up))
        self.up = vector.normalise(vector3.cross(self.right, self.dir))


Instruction:
Implement a Python 3 function for
looking at a specific point in the camera.

Response:
def look_at(self, vec=None, pos=None):
        """
        Look at a specific point

        :param vec: Vector3 position
        :param pos: python list [x, y, x]
        :return: Camera matrix
        """
        if pos is None:
            vec = Vector3(pos)

        if vec is None:
            raise ValueError("vector or pos must be set")

        return self._gl_look_at(self.position, vec, self._up)


Instruction:
Implement a Python 3 function for
updating the camera position move state

Response:
def move_state(self, direction, activate):
        """
        Set the camera position move state

        :param direction: What direction to update
        :param activate: Start or stop moving in the direction
        """
        if direction == RIGHT:
            self._xdir = POSITIVE if activate else STILL
        elif direction == LEFT:
            self._xdir = NEGATIVE if activate else STILL
        elif direction == FORWARD:
            self._zdir = NEGATIVE if activate else STILL
        elif direction == BACKWARD:
            self._zdir = POSITIVE if activate else STILL
        elif direction == UP:
            self._ydir = POSITIVE if activate else STILL
        elif direction == DOWN:
            self._ydir = NEGATIVE if activate else STILL


Instruction:
Given the following Python 3 function, write the documentation
def rot_state(self, x, y):
        if self.last_x is None:
            self.last_x = x
        if self.last_y is None:
            self.last_y = y

        x_offset = self.last_x - x
        y_offset = self.last_y - y

        self.last_x = x
        self.last_y = y

        x_offset *= self.mouse_sensitivity
        y_offset *= self.mouse_sensitivity

        self.yaw -= x_offset
        self.pitch += y_offset

        if self.pitch > 85.0:
            self.pitch = 85.0
        if self.pitch < -85.0:
            self.pitch = -85.0

        self._update_yaw_and_pitch()

Response: Set the rotation state of the camera.


Instruction:
Write a Python 3 function for
returning the current view matrix for the camera.

Response:
def view_matrix(self):
        """
        :return: The current view matrix for the camera
        """
        # Use separate time in camera so we can move it when the demo is paused
        now = time.time()
        # If the camera has been inactive for a while, a large time delta
        # can suddenly move the camera far away from the scene
        t = max(now - self._last_time, 0)
        self._last_time = now

        # X Movement
        if self._xdir == POSITIVE:
            self.position += self.right * self.velocity * t
        elif self._xdir == NEGATIVE:
            self.position -= self.right * self.velocity * t

        # Z Movement
        if self._zdir == NEGATIVE:
            self.position += self.dir * self.velocity * t
        elif self._zdir == POSITIVE:
            self.position -= self.dir * self.velocity * t

        # Y Movement
        if self._ydir == POSITIVE:
            self.position += self.up * self.velocity * t
        elif self._ydir == NEGATIVE:
            self.position -= self.up * self.velocity * t

        return self._gl_look_at(self.position, self.position + self.dir, self._up)


Instruction:
Create a Python 3 function to
translate string into character texture positions

Response:
def _translate_string(self, data, length):
        """Translate string into character texture positions"""
        for index, char in enumerate(data):
            if index == length:
                break

            yield self._meta.characters - 1 - self._ct[char]


Instruction:
How would you code a function in Python 3 to
generate character translation map

Response:
def _generate_character_map(self):
        """Generate character translation map (latin1 pos to texture pos)"""
        self._ct = [-1] * 256
        index = 0
        for crange in self._meta.character_ranges:
            for cpos in range(crange['min'], crange['max'] + 1):
                self._ct[cpos] = index
                index += 1


Instruction:
Make a summary of the following Python 3 code
def buffer_format(frmt: str) -> BufferFormat:
    try:
        return BUFFER_FORMATS[frmt]
    except KeyError:
        raise ValueError("Buffer format '{}' unknown. Valid formats: {}".format(
            frmt, BUFFER_FORMATS.keys()
        ))

Response: Return the buffer format instance for the given format string.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def attribute_format(frmt: str) -> BufferFormat:
    try:
        return ATTRIBUTE_FORMATS[frmt]
    except KeyError:
        raise ValueError("Buffer format '{}' unknown. Valid formats: {}".format(
            frmt, ATTRIBUTE_FORMATS.keys()
        ))

Response: Return the buffer format instance for the given format.


Instruction:
Can you generate the documentation for the following Python 3 function
def init(window=None, project=None, timeline=None):
    from demosys.effects.registry import Effect
    from demosys.scene import camera

    window.timeline = timeline

    # Inject attributes into the base Effect class
    setattr(Effect, '_window', window)
    setattr(Effect, '_ctx', window.ctx)
    setattr(Effect, '_project', project)

    # Set up the default system camera
    window.sys_camera = camera.SystemCamera(aspect=window.aspect_ratio, fov=60.0, near=1, far=1000)
    setattr(Effect, '_sys_camera', window.sys_camera)

    print("Loading started at", time.time())
    project.load()

    # Initialize timer
    timer_cls = import_string(settings.TIMER)
    window.timer = timer_cls()
    window.timer.start()

Response: Initialize load and run


Instruction:
How would you explain what the following Python 3 function does
def draw(self, projection_matrix=None, camera_matrix=None, time=0):
        projection_matrix = projection_matrix.astype('f4').tobytes()
        camera_matrix = camera_matrix.astype('f4').tobytes()

        for node in self.root_nodes:
            node.draw(
                projection_matrix=projection_matrix,
                camera_matrix=camera_matrix,
                time=time,
            )

        self.ctx.clear_samplers(0, 4)

Response: Draw all the nodes in the scene


Instruction:
Explain what the following Python 3 code does
def draw_bbox(self, projection_matrix=None, camera_matrix=None, all=True):
        projection_matrix = projection_matrix.astype('f4').tobytes()
        camera_matrix = camera_matrix.astype('f4').tobytes()

        # Scene bounding box
        self.bbox_program["m_proj"].write(projection_matrix)
        self.bbox_program["m_view"].write(self._view_matrix.astype('f4').tobytes())
        self.bbox_program["m_cam"].write(camera_matrix)
        self.bbox_program["bb_min"].write(self.bbox_min.astype('f4').tobytes())
        self.bbox_program["bb_max"].write(self.bbox_max.astype('f4').tobytes())
        self.bbox_program["color"].value = (1.0, 0.0, 0.0)
        self.bbox_vao.render(self.bbox_program)

        if not all:
            return

        # Draw bounding box for children
        for node in self.root_nodes:
            node.draw_bbox(projection_matrix, camera_matrix, self.bbox_program, self.bbox_vao)

Response: Draw bounding boxes for the current scene and mesh.


Instruction:
Explain what the following Python 3 code does
def apply_mesh_programs(self, mesh_programs=None):
        if not mesh_programs:
            mesh_programs = [ColorProgram(), TextureProgram(), FallbackProgram()]

        for mesh in self.meshes:
            for mp in mesh_programs:
                instance = mp.apply(mesh)
                if instance is not None:
                    if isinstance(instance, MeshProgram):
                        mesh.mesh_program = mp
                        break
                    else:
                        raise ValueError("apply() must return a MeshProgram instance, not {}".format(type(instance)))

            if not mesh.mesh_program:
                print("WARING: No mesh program applied to '{}'".format(mesh.name))

Response: Applies the given list of mesh programs to the current instance of the current mesh.


Instruction:
Write a Python 3 script for
calculating scene bounding box

Response:
def calc_scene_bbox(self):
        """Calculate scene bbox"""
        bbox_min, bbox_max = None, None
        for node in self.root_nodes:
            bbox_min, bbox_max = node.calc_global_bbox(
                matrix44.create_identity(),
                bbox_min,
                bbox_max
            )

        self.bbox_min = bbox_min
        self.bbox_max = bbox_max

        self.diagonal_size = vector3.length(self.bbox_max - self.bbox_min)


Instruction:
Write a Python 3 script to
generate random 3D points inside a confied box.

Response:
def points_random_3d(count, range_x=(-10.0, 10.0), range_y=(-10.0, 10.0), range_z=(-10.0, 10.0), seed=None) -> VAO:
    """
    Generates random positions inside a confied box.

    Args:
        count (int): Number of points to generate

    Keyword Args:
        range_x (tuple): min-max range for x axis: Example (-10.0. 10.0)
        range_y (tuple): min-max range for y axis: Example (-10.0. 10.0)
        range_z (tuple): min-max range for z axis: Example (-10.0. 10.0)
        seed (int): The random seed

    Returns:
        A :py:class:`demosys.opengl.vao.VAO` instance
    """
    random.seed(seed)

    def gen():
        for _ in range(count):
            yield random.uniform(*range_x)
            yield random.uniform(*range_y)
            yield random.uniform(*range_z)

    data = numpy.fromiter(gen(), count=count * 3, dtype=numpy.float32)

    vao = VAO("geometry:points_random_3d", mode=moderngl.POINTS)
    vao.buffer(data, '3f', ['in_position'])

    return vao


Instruction:
Write a Python 3 script to
get the current time in seconds

Response:
def get_time(self) -> float:
        """
        Get the current position in the music in seconds
        """
        if self.paused:
            return self.pause_time

        return mixer.music.get_pos() / 1000.0


Instruction:
How would you explain what the following Python 3 function does
def set_time(self, value: float):
        if value < 0:
            value = 0

        # mixer.music.play(start=value)
        mixer.music.set_pos(value)

Response: Set the current time in the music in seconds causing the player to seek to this location.


Instruction:
Here you have a function in Python 3, explain what it does
def draw_buffers(self, near, far):
        self.ctx.disable(moderngl.DEPTH_TEST)

        helper.draw(self.gbuffer.color_attachments[0], pos=(0.0, 0.0), scale=(0.25, 0.25))
        helper.draw(self.gbuffer.color_attachments[1], pos=(0.5, 0.0), scale=(0.25, 0.25))
        helper.draw_depth(self.gbuffer.depth_attachment, near, far, pos=(1.0, 0.0), scale=(0.25, 0.25))
        helper.draw(self.lightbuffer.color_attachments[0], pos=(1.5, 0.0), scale=(0.25, 0.25))

Response: Draw the framebuffers for debug purposes.


Instruction:
Can you generate the documentation for the following Python 3 function
def add_point_light(self, position, radius):
        self.point_lights.append(PointLight(position, radius))

Response: Add point light to the set


Instruction:
Write a Python 3 script to
render the light volumes from the inside skeleton

Response:
def render_lights(self, camera_matrix, projection):
        """Render light volumes"""
        # Draw light volumes from the inside
        self.ctx.front_face = 'cw'
        self.ctx.blend_func = moderngl.ONE, moderngl.ONE

        helper._depth_sampler.use(location=1)
        with self.lightbuffer_scope:
            for light in self.point_lights:
                # Calc light properties
                light_size = light.radius
                m_light = matrix44.multiply(light.matrix, camera_matrix)
                # Draw the light volume
                self.point_light_shader["m_proj"].write(projection.tobytes())
                self.point_light_shader["m_light"].write(m_light.astype('f4').tobytes())
                self.gbuffer.color_attachments[1].use(location=0)
                self.point_light_shader["g_normal"].value = 0
                self.gbuffer.depth_attachment.use(location=1)
                self.point_light_shader["g_depth"].value = 1
                self.point_light_shader["screensize"].value = (self.width, self.height)
                self.point_light_shader["proj_const"].value = projection.projection_constants
                self.point_light_shader["radius"].value = light_size
                self.unit_cube.render(self.point_light_shader)

        helper._depth_sampler.clear(location=1)


Instruction:
Write a Python 3 function that can
render outlines of light volumes

Response:
def render_lights_debug(self, camera_matrix, projection):
        """Render outlines of light volumes"""
        self.ctx.enable(moderngl.BLEND)
        self.ctx.blend_func = moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA

        for light in self.point_lights:
            m_mv = matrix44.multiply(light.matrix, camera_matrix)
            light_size = light.radius
            self.debug_shader["m_proj"].write(projection.tobytes())
            self.debug_shader["m_mv"].write(m_mv.astype('f4').tobytes())
            self.debug_shader["size"].value = light_size
            self.unit_cube.render(self.debug_shader, mode=moderngl.LINE_STRIP)

        self.ctx.disable(moderngl.BLEND)


Instruction:
Write a Python 3 script for
combining diffuse and light buffer

Response:
def combine(self):
        """Combine diffuse and light buffer"""
        self.gbuffer.color_attachments[0].use(location=0)
        self.combine_shader["diffuse_buffer"].value = 0
        self.lightbuffer.color_attachments[0].use(location=1)
        self.combine_shader["light_buffer"].value = 1
        self.quad.render(self.combine_shader)


Instruction:
How would you explain what the following Python 3 function does
def load_shader(self, shader_type: str, path: str):
        if path:
            resolved_path = self.find_program(path)
            if not resolved_path:
                raise ValueError("Cannot find {} shader '{}'".format(shader_type, path))

            print("Loading:", path)

            with open(resolved_path, 'r') as fd:
                return fd.read()

Response: Load a single shader


Instruction:
How would you code a function in Python 3 to
load a texture array

Response:
def load(self):
        """Load a texture array"""
        self._open_image()

        width, height, depth = self.image.size[0], self.image.size[1] // self.layers, self.layers
        components, data = image_data(self.image)

        texture = self.ctx.texture_array(
            (width, height, depth),
            components,
            data,
        )
        texture.extra = {'meta': self.meta}

        if self.meta.mipmap:
            texture.build_mipmaps()

        self._close_image()

        return texture


Instruction:
Can you create a Python 3 function that
draws the mesh using the assigned program

Response:
def draw(self, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0):
        """
        Draw the mesh using the assigned mesh program

        :param projection_matrix: projection_matrix (bytes)
        :param view_matrix: view_matrix (bytes)
        :param camera_matrix: camera_matrix (bytes)
        """
        if self.mesh_program:
            self.mesh_program.draw(
                self,
                projection_matrix=projection_matrix,
                view_matrix=view_matrix,
                camera_matrix=camera_matrix,
                time=time
            )


Instruction:
Write a Python 3 script to
add metadata about the mesh

Response:
def add_attribute(self, attr_type, name, components):
        """
        Add metadata about the mesh
        :param attr_type: POSITION, NORMAL etc
        :param name: The attribute name used in the program
        :param components: Number of floats
        """
        self.attributes[attr_type] = {"name": name, "components": components}


Instruction:
Create a Python 3 function to
set the current time jumping in the timeline.

Response:
def set_time(self, value: float):
        """
        Set the current time jumping in the timeline.

        Args:
            value (float): The new time
        """
        if value < 0:
            value = 0

        self.controller.row = self.rps * value


Instruction:
Write a Python 3 script to
draw function called by the system every frame when the effect is active. This method raises ``NotImplementedError`` unless implemented. Args: time (float): The current time in seconds. frametime (float): The time the previous frame used to render in seconds. target (``moderngl.Framebuffer``): The target FBO for the effect.

Response:
def draw(self, time: float, frametime: float, target: moderngl.Framebuffer):
        """
        Draw function called by the system every frame when the effect is active.
        This method raises ``NotImplementedError`` unless implemented.

        Args:
            time (float): The current time in seconds.
            frametime (float): The time the previous frame used to render in seconds.
            target (``moderngl.Framebuffer``): The target FBO for the effect.
        """
        raise NotImplementedError("draw() is not implemented")


Instruction:
Can you write a function in Python 3 where it
gets a program by its label

Response:
def get_program(self, label: str) -> moderngl.Program:
        """
        Get a program by its label

        Args:
            label (str): The label for the program

        Returns: py:class:`moderngl.Program` instance
        """
        return self._project.get_program(label)


Instruction:
How would you code a function in Python 3 to
get a texture by its label

Response:
def get_texture(self, label: str) -> Union[moderngl.Texture, moderngl.TextureArray,
                                               moderngl.Texture3D, moderngl.TextureCube]:
        """
        Get a texture by its label

        Args:
            label (str): The Label for the texture

        Returns:
            The py:class:`moderngl.Texture` instance
        """
        return self._project.get_texture(label)


Instruction:
Make a summary of the following Python 3 code
def get_effect_class(self, effect_name: str, package_name: str = None) -> Type['Effect']:
        return self._project.get_effect_class(effect_name, package_name=package_name)

Response: Returns the class object corresponding to the given effect name.


Instruction:
Can you tell what is the following Python 3 function doing
def create_projection(self, fov: float = 75.0, near: float = 1.0, far: float = 100.0, aspect_ratio: float = None):
        return matrix44.create_perspective_projection_matrix(
            fov,
            aspect_ratio or self.window.aspect_ratio,
            near,
            far,
            dtype='f4',
        )

Response: Create a projection matrix for the specified field of view near and far.


Instruction:
Can you create a Python 3 function that
creates a transformation matrix woth rotations and translation.

Response:
def create_transformation(self, rotation=None, translation=None):
        """
        Creates a transformation matrix woth rotations and translation.

        Args:
            rotation: 3 component vector as a list, tuple, or :py:class:`pyrr.Vector3`
            translation: 3 component vector as a list, tuple, or :py:class:`pyrr.Vector3`

        Returns:
            A 4x4 matrix as a :py:class:`numpy.array`
        """
        mat = None
        if rotation is not None:
            mat = Matrix44.from_eulers(Vector3(rotation))

        if translation is not None:
            trans = matrix44.create_from_translation(Vector3(translation))
            if mat is None:
                mat = trans
            else:
                mat = matrix44.multiply(mat, trans)

        return mat


Instruction:
Can you tell what is the following Python 3 function doing
def create_normal_matrix(self, modelview):
        normal_m = Matrix33.from_matrix44(modelview)
        normal_m = normal_m.inverse
        normal_m = normal_m.transpose()
        return normal_m

Response: Creates a normal matrix from a modelview matrix.


Instruction:
Can you write a function in Python 3 where it
scans for available templates in effect_templates

Response:
def available_templates(value):
    """Scan for available templates in effect_templates"""
    templates = list_templates()

    if value not in templates:
        raise ArgumentTypeError("Effect template '{}' does not exist.\n Available templates: {} ".format(
            value, ", ".join(templates)))

    return value


Instruction:
Create a Python 3 function to
get the absolute path to the root of the demosys package

Response:
def root_path():
    """Get the absolute path to the root of the demosys package"""
    module_dir = os.path.dirname(globals()['__file__'])
    return os.path.dirname(os.path.dirname(module_dir))


Instruction:
Given the following Python 3 function, write the documentation
def load(self):
        self.meta.resolved_path = self.find_data(self.meta.path)

        if not self.meta.resolved_path:
            raise ImproperlyConfigured("Data file '{}' not found".format(self.meta.path))

        print("Loading:", self.meta.path)

        with open(self.meta.resolved_path, 'r') as fd:
            return fd.read()

Response: Load a file in text mode


Instruction:
Implement a function in Python 3 to
return an instance of the finder class from an import path.

Response:
def get_finder(import_path):
    """
    Get a finder class from an import path.
    Raises ``demosys.core.exceptions.ImproperlyConfigured`` if the finder is not found.
    This function uses an lru cache.

    :param import_path: string representing an import path
    :return: An instance of the finder
    """
    Finder = import_string(import_path)
    if not issubclass(Finder, BaseFileSystemFinder):
        raise ImproperlyConfigured('Finder {} is not a subclass of core.finders.FileSystemFinder'.format(import_path))
    return Finder()


Instruction:
Create a Python 3 function to
find a file in the path.

Response:
def find(self, path: Path):
        """
        Find a file in the path. The file may exist in multiple
        paths. The last found file will be returned.

        :param path: The path to find
        :return: The absolute path to the file or None if not found
        """
        # Update paths from settings to make them editable runtime
        # This is only possible for FileSystemFinders
        if getattr(self, 'settings_attr', None):
            self.paths = getattr(settings, self.settings_attr)

        path_found = None

        for entry in self.paths:
            abspath = entry / path
            if abspath.exists():
                path_found = abspath

        return path_found


Instruction:
Create a Python 3 function for
updating the internal projection matrix based on current values of the current key - value store.

Response:
def update(self, aspect_ratio=None, fov=None, near=None, far=None):
        """
        Update the internal projection matrix based on current values
        or values passed in if specified.

        :param aspect_ratio: New aspect ratio
        :param fov: New field of view
        :param near: New near value
        :param far: New far value
        """
        self.aspect_ratio = aspect_ratio or self.aspect_ratio
        self.fov = fov or self.fov
        self.near = near or self.near
        self.far = far or self.far

        self.matrix = Matrix44.perspective_projection(self.fov, self.aspect_ratio, self.near, self.far)


Instruction:
Write a Python 3 script for
returning the x y tuple of the current projection constants for the current projection.

Response:
def projection_constants(self):
        """
        Returns the (x, y) projection constants for the current projection.
        :return: x, y tuple projection constants
        """
        return self.far / (self.far - self.near), (self.far * self.near) / (self.near - self.far)


Instruction:
Write a Python 3 script to
draw node and children of this node and all children of this node.

Response:
def draw(self, projection_matrix=None, camera_matrix=None, time=0):
        """
        Draw node and children

        :param projection_matrix: projection matrix (bytes)
        :param camera_matrix: camera_matrix (bytes)
        :param time: The current time
        """
        if self.mesh:
            self.mesh.draw(
                projection_matrix=projection_matrix,
                view_matrix=self.matrix_global_bytes,
                camera_matrix=camera_matrix,
                time=time
            )

        for child in self.children:
            child.draw(
                projection_matrix=projection_matrix,
                camera_matrix=camera_matrix,
                time=time
            )


Instruction:
Explain what the following Python 3 code does
def swap_buffers(self):
        self.frames += 1
        glfw.swap_buffers(self.window)
        self.poll_events()

Response: Swap buffers incement the framecounter and pull events.


Instruction:
Can you tell what is the following Python 3 function doing
def resize(self, width, height):
        self.width = width
        self.height = height
        self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window)
        self.set_default_viewport()

Response: Sets the new size and buffer size internally


Instruction:
Can you generate a brief explanation for the following Python 3 code
def check_glfw_version(self):
        print("glfw version: {} (python wrapper version {})".format(glfw.get_version(), glfw.__version__))
        if glfw.get_version() < self.min_glfw_version:
            raise ValueError("Please update glfw binaries to version {} or later".format(self.min_glfw_version))

Response: Checks that the glfw library version is compatible with the current version of glfw binaries.


Instruction:
How would you implement a function in Python 3 that
keys event callback for glfw. Translates and forwards keyboard event to :py:func:`keyboard_event` :param window: Window event origin :param key: The key that was pressed or released. :param scancode: The system-specific scancode of the key. :param action: GLFW_PRESS, GLFW_RELEASE or GLFW_REPEAT :param mods: Bit field describing which modifier keys were held down.

Response:
def key_event_callback(self, window, key, scancode, action, mods):
        """
        Key event callback for glfw.
        Translates and forwards keyboard event to :py:func:`keyboard_event`

        :param window: Window event origin
        :param key: The key that was pressed or released.
        :param scancode: The system-specific scancode of the key.
        :param action: GLFW_PRESS, GLFW_RELEASE or GLFW_REPEAT
        :param mods: Bit field describing which modifier keys were held down.
        """
        self.keyboard_event(key, action, mods)


Instruction:
Make a summary of the following Python 3 code
def quad_2d(width, height, xpos=0.0, ypos=0.0) -> VAO:
    pos = numpy.array([
        xpos - width / 2.0, ypos + height / 2.0, 0.0,
        xpos - width / 2.0, ypos - height / 2.0, 0.0,
        xpos + width / 2.0, ypos - height / 2.0, 0.0,
        xpos - width / 2.0, ypos + height / 2.0, 0.0,
        xpos + width / 2.0, ypos - height / 2.0, 0.0,
        xpos + width / 2.0, ypos + height / 2.0, 0.0,
    ], dtype=numpy.float32)

    normals = numpy.array([
        0.0, 0.0, 1.0,
        0.0, 0.0, 1.0,
        0.0, 0.0, 1.0,
        0.0, 0.0, 1.0,
        0.0, 0.0, 1.0,
        0.0, 0.0, 1.0,
    ], dtype=numpy.float32)

    uvs = numpy.array([
        0.0, 1.0,
        0.0, 0.0,
        1.0, 0.0,
        0.0, 1.0,
        1.0, 0.0,
        1.0, 1.0,
    ], dtype=numpy.float32)

    vao = VAO("geometry:quad", mode=moderngl.TRIANGLES)
    vao.buffer(pos, '3f', ["in_position"])
    vao.buffer(normals, '3f', ["in_normal"])
    vao.buffer(uvs, '2f', ["in_uv"])

    return vao

Response: Create a 2D quad VAO with 2 triangles with normals and texture coordinates.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def translate_buffer_format(vertex_format):
    buffer_format = []
    attributes = []
    mesh_attributes = []

    if "T2F" in vertex_format:
        buffer_format.append("2f")
        attributes.append("in_uv")
        mesh_attributes.append(("TEXCOORD_0", "in_uv", 2))

    if "C3F" in vertex_format:
        buffer_format.append("3f")
        attributes.append("in_color")
        mesh_attributes.append(("NORMAL", "in_color", 3))

    if "N3F" in vertex_format:
        buffer_format.append("3f")
        attributes.append("in_normal")
        mesh_attributes.append(("NORMAL", "in_normal", 3))

    buffer_format.append("3f")
    attributes.append("in_position")
    mesh_attributes.append(("POSITION", "in_position", 3))

    return " ".join(buffer_format), attributes, mesh_attributes

Response: Translate the buffer format into a single string.


Instruction:
Make a summary of the following Python 3 code
def load(self):
        path = self.find_scene(self.meta.path)

        if not path:
            raise ValueError("Scene '{}' not found".format(self.meta.path))

        if path.suffix == '.bin':
            path = path.parent / path.stem

        data = pywavefront.Wavefront(str(path), create_materials=True, cache=True)
        scene = Scene(self.meta.resolved_path)
        texture_cache = {}

        for _, mat in data.materials.items():
            mesh = Mesh(mat.name)

            # Traditional loader
            if mat.vertices:
                buffer_format, attributes, mesh_attributes = translate_buffer_format(mat.vertex_format)
                vbo = numpy.array(mat.vertices, dtype='f4')

                vao = VAO(mat.name, mode=moderngl.TRIANGLES)
                vao.buffer(vbo, buffer_format, attributes)
                mesh.vao = vao

                for attrs in mesh_attributes:
                    mesh.add_attribute(*attrs)

            # Binary cache loader
            elif hasattr(mat, 'vao'):
                mesh = Mesh(mat.name)
                mesh.vao = mat.vao
                for attrs in mat.mesh_attributes:
                    mesh.add_attribute(*attrs)
            else:
                # Empty
                continue

            scene.meshes.append(mesh)

            mesh.material = Material(mat.name)
            scene.materials.append(mesh.material)
            mesh.material.color = mat.diffuse

            if mat.texture:
                # A texture can be referenced multiple times, so we need to cache loaded ones
                texture = texture_cache.get(mat.texture.path)
                if not texture:
                    print("Loading:", mat.texture.path)
                    texture = textures.load(TextureDescription(
                        label=mat.texture.path,
                        path=mat.texture.path,
                        mipmap=True,
                    ))
                    texture_cache[mat.texture.path] = texture

                mesh.material.mat_texture = MaterialTexture(
                    texture=texture,
                    sampler=None,
                )

            node = Node(mesh=mesh)
            scene.root_nodes.append(node)

        # Not supported yet for obj
        # self.calc_scene_bbox()
        scene.prepare()

        return scene

Response: Load the current object into the internal state.


Instruction:
Explain what the following Python 3 code does
def start(self):
        if self.start_time is None:
            self.start_time = time.time()
        # Play after pause
        else:
            # Add the duration of the paused interval to the total offset
            pause_duration = time.time() - self.pause_time
            self.offset += pause_duration
            # print("pause duration", pause_duration, "offset", self.offset)
            # Exit the paused state
            self.pause_time = None

Response: Start the paused state.


Instruction:
Write a Python 3 script to
stop the timer and return the time the timer was stopped.

Response:
def stop(self) -> float:
        """
        Stop the timer

        Returns:
            The time the timer was stopped
        """
        self.stop_time = time.time()
        return self.stop_time - self.start_time - self.offset


Instruction:
Can you implement a function in Python 3 that
gets the current time in seconds

Response:
def get_time(self) -> float:
        """
        Get the current time in seconds

        Returns:
            The current time in seconds
        """
        if self.pause_time is not None:
            curr_time = self.pause_time - self.offset - self.start_time
            return curr_time

        curr_time = time.time()
        return curr_time - self.start_time - self.offset


Instruction:
Create a Python 3 function for
setting the current time in the calendar.

Response:
def set_time(self, value: float):
        """
        Set the current time. This can be used to jump in the timeline.

        Args:
            value (float): The new time
        """
        if value < 0:
            value = 0

        self.offset += self.get_time() - value


Instruction:
Create a Python 3 function to
resolve the loader class based on file extension

Response:
def resolve_loader(self, meta: SceneDescription):
        """
        Resolve scene loader based on file extension
        """
        for loader_cls in self._loaders:
            if loader_cls.supports_file(meta):
                meta.loader_cls = loader_cls
                break
        else:
            raise ImproperlyConfigured(
                "Scene {} has no loader class registered. Check settings.SCENE_LOADERS".format(meta.path))


Instruction:
Given the following Python 3 function, write the documentation
def on_key_press(self, symbol, modifiers):
        self.keyboard_event(symbol, self.keys.ACTION_PRESS, modifiers)

Response: Handles key press events.


Instruction:
Create a Python 3 function for
handling key release events.

Response:
def on_key_release(self, symbol, modifiers):
        """
        Pyglet specific key release callback.
        Forwards and translates the events to :py:func:`keyboard_event`
        """
        self.keyboard_event(symbol, self.keys.ACTION_RELEASE, modifiers)


Instruction:
Make a summary of the following Python 3 code
def on_mouse_motion(self, x, y, dx, dy):
        # screen coordinates relative to the lower-left corner
        self.cursor_event(x, self.buffer_height - y, dx, dy)

Response: Handles mouse motion events.


Instruction:
Explain what the following Python 3 code does
def swap_buffers(self):
        if not self.window.context:
            return

        self.frames += 1
        self.window.flip()
        self.window.dispatch_events()

Response: Swap buffers in the current window and dispatch events.


Instruction:
Create a Python 3 function to
create a new instance of the Knockout sphere.

Response:
def sphere(radius=0.5, sectors=32, rings=16) -> VAO:
    """
    Creates a sphere.

    Keyword Args:
        radius (float): Radius or the sphere
        rings (int): number or horizontal rings
        sectors (int): number of vertical segments

    Returns:
        A :py:class:`demosys.opengl.vao.VAO` instance
    """
    R = 1.0 / (rings - 1)
    S = 1.0 / (sectors - 1)

    vertices = [0] * (rings * sectors * 3)
    normals = [0] * (rings * sectors * 3)
    uvs = [0] * (rings * sectors * 2)

    v, n, t = 0, 0, 0
    for r in range(rings):
        for s in range(sectors):
            y = math.sin(-math.pi / 2 + math.pi * r * R)
            x = math.cos(2 * math.pi * s * S) * math.sin(math.pi * r * R)
            z = math.sin(2 * math.pi * s * S) * math.sin(math.pi * r * R)

            uvs[t] = s * S
            uvs[t + 1] = r * R

            vertices[v] = x * radius
            vertices[v + 1] = y * radius
            vertices[v + 2] = z * radius

            normals[n] = x
            normals[n + 1] = y
            normals[n + 2] = z

            t += 2
            v += 3
            n += 3

    indices = [0] * rings * sectors * 6
    i = 0
    for r in range(rings - 1):
        for s in range(sectors - 1):
            indices[i] = r * sectors + s
            indices[i + 1] = (r + 1) * sectors + (s + 1)
            indices[i + 2] = r * sectors + (s + 1)

            indices[i + 3] = r * sectors + s
            indices[i + 4] = (r + 1) * sectors + s
            indices[i + 5] = (r + 1) * sectors + (s + 1)
            i += 6

    vbo_vertices = numpy.array(vertices, dtype=numpy.float32)
    vbo_normals = numpy.array(normals, dtype=numpy.float32)
    vbo_uvs = numpy.array(uvs, dtype=numpy.float32)
    vbo_elements = numpy.array(indices, dtype=numpy.uint32)

    vao = VAO("sphere", mode=mlg.TRIANGLES)
    # VBOs
    vao.buffer(vbo_vertices, '3f', ['in_position'])
    vao.buffer(vbo_normals, '3f', ['in_normal'])
    vao.buffer(vbo_uvs, '2f', ['in_uv'])
    vao.index_buffer(vbo_elements, index_element_size=4)

    return vao


Instruction:
Implement a Python 3 function for
calling the superclass draw method and closes the session if necessary.

Response:
def draw(self, current_time, frame_time):
        """
        Calls the superclass ``draw()`` methods and checks ``HEADLESS_FRAMES``/``HEADLESS_DURATION``
        """
        super().draw(current_time, frame_time)

        if self.headless_duration and current_time >= self.headless_duration:
            self.close()


Instruction:
Can you create a Python 3 function that
swaps the buffers of the current instance.

Response:
def swap_buffers(self):
        """
        Headless window currently don't support double buffering.
        We only increment the frame counter here.
        """
        self.frames += 1

        if self.headless_frames and self.frames >= self.headless_frames:
            self.close()


Instruction:
Write a Python 3 script to
load a resource or returns existing one.

Response:
def load(self, meta: ResourceDescription) -> Any:
        """
        Loads a resource or return existing one

        :param meta: The resource description
        """
        self._check_meta(meta)
        self.resolve_loader(meta)
        return meta.loader_cls(meta).load()


Instruction:
Can you implement a function in Python 3 that
adds a resource to this pool.

Response:
def add(self, meta):
        """
        Add a resource to this pool.
        The resource is loaded and returned when ``load_pool()`` is called.

        :param meta: The resource description
        """
        self._check_meta(meta)
        self.resolve_loader(meta)
        self._resources.append(meta)


Instruction:
Explain what the following Python 3 code does
def load_pool(self):
        for meta in self._resources:
            resource = self.load(meta)
            yield meta, resource

        self._resources = []

Response: Load all the data files into memory and return a generator that yields each resource.


Instruction:
Implement a Python 3 function for
resolving a loader class to a resource description.

Response:
def resolve_loader(self, meta: ResourceDescription):
        """
        Attempts to assign a loader class to a resource description

        :param meta: The resource description instance
        """
        meta.loader_cls = self.get_loader(meta, raise_on_error=True)


Instruction:
How would you explain what the following Python 3 function does
def get_loader(self, meta: ResourceDescription, raise_on_error=False) -> BaseLoader:
        for loader in self._loaders:
            if loader.name == meta.loader:
                return loader

        if raise_on_error:
            raise ImproperlyConfigured(
                "Resource has invalid loader '{}': {}\nAvailiable loaders: {}".format(
                    meta.loader, meta, [loader.name for loader in self._loaders]))

Response: Attempts to get a loader from the resource description instance.


Instruction:
Here you have a function in Python 3, explain what it does
def keyPressEvent(self, event):
        self.keyboard_event(event.key(), self.keys.ACTION_PRESS, 0)

Response: This callback function handles key press events.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def keyReleaseEvent(self, event):
        self.keyboard_event(event.key(), self.keys.ACTION_RELEASE, 0)

Response: Handles a key release event.


Instruction:
Implement a function in Python 3 to
draw a 2D texture using a fullscreen quad.

Response:
def draw(self, texture, pos=(0.0, 0.0), scale=(1.0, 1.0)):
        """
        Draw texture using a fullscreen quad.
        By default this will conver the entire screen.

        :param pos: (tuple) offset x, y
        :param scale: (tuple) scale x, y
        """
        if not self.initialized:
            self.init()

        self._texture2d_shader["offset"].value = (pos[0] - 1.0, pos[1] - 1.0)
        self._texture2d_shader["scale"].value = (scale[0], scale[1])
        texture.use(location=0)
        self._texture2d_sampler.use(location=0)
        self._texture2d_shader["texture0"].value = 0
        self._quad.render(self._texture2d_shader)
        self._texture2d_sampler.clear(location=0)


Instruction:
Write a Python 3 function for
drawing the depth buffer linearized.

Response:
def draw_depth(self, texture, near, far, pos=(0.0, 0.0), scale=(1.0, 1.0)):
        """
        Draw depth buffer linearized.
        By default this will draw the texture as a full screen quad.
        A sampler will be used to ensure the right conditions to draw the depth buffer.

        :param near: Near plane in projection
        :param far: Far plane in projection
        :param pos: (tuple) offset x, y
        :param scale: (tuple) scale x, y
        """
        if not self.initialized:
            self.init()

        self._depth_shader["offset"].value = (pos[0] - 1.0, pos[1] - 1.0)
        self._depth_shader["scale"].value = (scale[0], scale[1])
        self._depth_shader["near"].value = near
        self._depth_shader["far"].value = far
        self._depth_sampler.use(location=0)
        texture.use(location=0)
        self._depth_shader["texture0"].value = 0
        self._quad.render(self._depth_shader)
        self._depth_sampler.clear(location=0)


Instruction:
Can you create a Python 3 function that
initializes geometry and shader for drawing FBO layers

Response:
def _init_texture2d_draw(self):
        """Initialize geometry and shader for drawing FBO layers"""
        if not TextureHelper._quad:
            TextureHelper._quad = geometry.quad_fs()

        # Shader for drawing color layers
        TextureHelper._texture2d_shader = context.ctx().program(
            vertex_shader="""
                #version 330

                in vec3 in_position;
                in vec2 in_uv;
                out vec2 uv;
                uniform vec2 offset;
                uniform vec2 scale;

                void main() {
                    uv = in_uv;
                    gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0);
                }
            """,
            fragment_shader="""
                #version 330

                out vec4 out_color;
                in vec2 uv;
                uniform sampler2D texture0;

                void main() {
                    out_color = texture(texture0, uv);
                }
            """
        )

        TextureHelper._texture2d_sampler = self.ctx.sampler(
            filter=(moderngl.LINEAR, moderngl.LINEAR),
        )


Instruction:
Explain what the following Python 3 code does
def _init_depth_texture_draw(self):
        from demosys import geometry

        if not TextureHelper._quad:
            TextureHelper._quad = geometry.quad_fs()

        # Shader for drawing depth layers
        TextureHelper._depth_shader = context.ctx().program(
            vertex_shader="""
                #version 330

                in vec3 in_position;
                in vec2 in_uv;
                out vec2 uv;
                uniform vec2 offset;
                uniform vec2 scale;

                void main() {
                    uv = in_uv;
                    gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0);
                }
            """,
            fragment_shader="""
                #version 330

                out vec4 out_color;
                in vec2 uv;
                uniform sampler2D texture0;
                uniform float near;
                uniform float far;

                void main() {
                    float z = texture(texture0, uv).r;
                    float d = (2.0 * near) / (far + near - z * (far - near));
                    out_color = vec4(d);
                }
            """
        )

        TextureHelper._depth_sampler = self.ctx.sampler(
            filter=(moderngl.LINEAR, moderngl.LINEAR),
            compare_func='',
        )

Response: Initialize geometry and shader for drawing depth layers


Instruction:
Write a Python 3 function for
drawing a frame. Internally it calls the configured timeline's draw method. Args: current_time (float): The current time (preferrably always from the configured timer class) frame_time (float): The duration of the previous frame in seconds

Response:
def draw(self, current_time, frame_time):
        """
        Draws a frame. Internally it calls the
        configured timeline's draw method.

        Args:
            current_time (float): The current time (preferrably always from the configured timer class)
            frame_time (float): The duration of the previous frame in seconds
        """
        self.set_default_viewport()
        self.timeline.draw(current_time, frame_time, self.fbo)


Instruction:
Write a Python 3 script to
clear the window buffer

Response:
def clear(self):
        """
        Clear the window buffer
        """
        self.ctx.fbo.clear(
            red=self.clear_color[0],
            green=self.clear_color[1],
            blue=self.clear_color[2],
            alpha=self.clear_color[3],
            depth=self.clear_depth,
        )


Instruction:
Can you write a function in Python 3 where it
sets the clear color and depth values for the current locale.

Response:
def clear_values(self, red=0.0, green=0.0, blue=0.0, alpha=0.0, depth=1.0):
        """
        Sets the clear values for the window buffer.

        Args:
            red (float): red compoent
            green (float): green compoent
            blue (float): blue compoent
            alpha (float): alpha compoent
            depth (float): depth value
        """
        self.clear_color = (red, green, blue, alpha)
        self.clear_depth = depth


Instruction:
Implement a function in Python 3 to
handle the keyboard events such as camera movement and camera movement.

Response:
def keyboard_event(self, key, action, modifier):
        """
        Handles the standard keyboard events such as camera movements,
        taking a screenshot, closing the window etc.

        Can be overriden add new keyboard events. Ensure this method
        is also called if you want to keep the standard features.

        Arguments:
            key: The key that was pressed or released
            action: The key action. Can be `ACTION_PRESS` or `ACTION_RELEASE`
            modifier: Modifiers such as holding shift or ctrl
        """
        # The well-known standard key for quick exit
        if key == self.keys.ESCAPE:
            self.close()
            return

        # Toggle pause time
        if key == self.keys.SPACE and action == self.keys.ACTION_PRESS:
            self.timer.toggle_pause()

        # Camera movement
        # Right
        if key == self.keys.D:
            if action == self.keys.ACTION_PRESS:
                self.sys_camera.move_right(True)
            elif action == self.keys.ACTION_RELEASE:
                self.sys_camera.move_right(False)
        # Left
        elif key == self.keys.A:
            if action == self.keys.ACTION_PRESS:
                self.sys_camera.move_left(True)
            elif action == self.keys.ACTION_RELEASE:
                self.sys_camera.move_left(False)
        # Forward
        elif key == self.keys.W:
            if action == self.keys.ACTION_PRESS:
                self.sys_camera.move_forward(True)
            if action == self.keys.ACTION_RELEASE:
                self.sys_camera.move_forward(False)
        # Backwards
        elif key == self.keys.S:
            if action == self.keys.ACTION_PRESS:
                self.sys_camera.move_backward(True)
            if action == self.keys.ACTION_RELEASE:
                self.sys_camera.move_backward(False)

        # UP
        elif key == self.keys.Q:
            if action == self.keys.ACTION_PRESS:
                self.sys_camera.move_down(True)
            if action == self.keys.ACTION_RELEASE:
                self.sys_camera.move_down(False)

        # Down
        elif key == self.keys.E:
            if action == self.keys.ACTION_PRESS:
                self.sys_camera.move_up(True)
            if action == self.keys.ACTION_RELEASE:
                self.sys_camera.move_up(False)

        # Screenshots
        if key == self.keys.X and action == self.keys.ACTION_PRESS:
            screenshot.create()

        if key == self.keys.R and action == self.keys.ACTION_PRESS:
            project.instance.reload_programs()

        if key == self.keys.RIGHT and action == self.keys.ACTION_PRESS:
            self.timer.set_time(self.timer.get_time() + 10.0)

        if key == self.keys.LEFT and action == self.keys.ACTION_PRESS:
            self.timer.set_time(self.timer.get_time() - 10.0)

        # Forward the event to the timeline
        self.timeline.key_event(key, action, modifier)


Instruction:
Given the following Python 3 function, write the documentation
def cursor_event(self, x, y, dx, dy):
        self.sys_camera.rot_state(x, y)

Response: Handles the standard mouse movement event.


Instruction:
Explain what the following Python 3 code does
def set_default_viewport(self):
        # The expected height with the current viewport width
        expected_height = int(self.buffer_width / self.aspect_ratio)

        # How much positive or negative y padding
        blank_space = self.buffer_height - expected_height
        self.fbo.viewport = (0, blank_space // 2, self.buffer_width, expected_height)

Response: Sets the default viewport for the current page.


Instruction:
Implement a function in Python 3 to
check if the loader supports a file extension

Response:
def supports_file(cls, meta):
        """Check if the loader has a supported file extension"""
        path = Path(meta.path)

        for ext in cls.file_extensions:
            if path.suffixes[:len(ext)] == ext:
                return True

        return False


Instruction:
Can you generate the documentation for the following Python 3 function
def get(self, name) -> Track:
        name = name.lower()
        track = self.track_map.get(name)
        if not track:
            track = Track(name)
            self.tacks.append(track)
            self.track_map[name] = track
        return track

Response: Get or create a Track object.


Instruction:
Implement a Python 3 function for
finding all commands in the folder command_dir

Response:
def find_commands(command_dir: str) -> List[str]:
    """
    Get all command names in the a folder

    :return: List of commands names
    """
    if not command_dir:
        return []

    return [name for _, name, is_pkg in pkgutil.iter_modules([command_dir])
            if not is_pkg and not name.startswith('_')]


Instruction:
Write a Python 3 function for
executing a command from the command line.

Response:
def execute_from_command_line(argv=None):
    """
    Currently the only entrypoint (manage.py, demosys-admin)
    """
    if not argv:
        argv = sys.argv

    # prog_name = argv[0]
    system_commands = find_commands(system_command_dir())
    project_commands = find_commands(project_command_dir())

    project_package = project_package_name()

    command = argv[1] if len(argv) > 1 else None

    # Are we running a core command?
    if command in system_commands:
        cmd = load_command_class('demosys', command)
        cmd.run_from_argv(argv)
    elif command in project_commands:
        cmd = load_command_class(project_package, command)
        cmd.run_from_argv(argv)
    else:
        print("Available commands:")
        for name in system_commands:
            print(" - {}".format(name))
        for name in project_commands:
            print(" - {}".format(name))


Instruction:
How would you code a function in Python 3 to
hack in program directory

Response:
def add_program_dir(self, directory):
        """Hack in program directory"""
        dirs = list(self.PROGRAM_DIRS)
        dirs.append(directory)
        self.PROGRAM_DIRS = dirs


Instruction:
Can you generate a brief explanation for the following Python 3 code
def add_texture_dir(self, directory):
        dirs = list(self.TEXTURE_DIRS)
        dirs.append(directory)
        self.TEXTURE_DIRS = dirs

Response: Hack in texture directory


Instruction:
Can you implement a function in Python 3 that
hacks in a data directory

Response:
def add_data_dir(self, directory):
        """Hack in a data directory"""
        dirs = list(self.DATA_DIRS)
        dirs.append(directory)
        self.DATA_DIRS = dirs


Instruction:
Implement a function in Python 3 to
build the content tuple for the buffer

Response:
def content(self, attributes: List[str]):
        """Build content tuple for the buffer"""
        formats = []
        attrs = []
        for attrib_format, attrib in zip(self.attrib_formats, self.attributes):

            if attrib not in attributes:
                formats.append(attrib_format.pad_str())
                continue

            formats.append(attrib_format.format)
            attrs.append(attrib)

            attributes.remove(attrib)

        if not attrs:
            return None

        return (
            self.buffer,
            "{}{}".format(" ".join(formats), '/i' if self.per_instance else ''),
            *attrs
        )


Instruction:
Can you tell what is the following Python 3 function doing
def render(self, program: moderngl.Program, mode=None, vertices=-1, first=0, instances=1):
        vao = self.instance(program)

        if mode is None:
            mode = self.mode

        vao.render(mode, vertices=vertices, first=first, instances=instances)

Response:
Render the VAO.

        Args:
            program: The ``moderngl.Program``

        Keyword Args:
            mode: Override the draw mode (``TRIANGLES`` etc)
            vertices (int): The number of vertices to transform
            first (int): The index of the first vertex to start with
            instances (int): The number of instances


Instruction:
Write a Python 3 script for
rendering indirect draw commands for the specified moderngl. Program.

Response:
def render_indirect(self, program: moderngl.Program, buffer, mode=None, count=-1, *, first=0):
        """
        The render primitive (mode) must be the same as the input primitive of the GeometryShader.
        The draw commands are 5 integers: (count, instanceCount, firstIndex, baseVertex, baseInstance).

        Args:
            program: The ``moderngl.Program``
            buffer: The ``moderngl.Buffer`` containing indirect draw commands

        Keyword Args:
            mode (int): By default :py:data:`TRIANGLES` will be used.
            count (int): The number of draws.
            first (int): The index of the first indirect draw command.
        """
        vao = self.instance(program)

        if mode is None:
            mode = self.mode

        vao.render_indirect(buffer, mode=mode, count=count, first=first)


Instruction:
How would you implement a function in Python 3 that
transforms vertices. Stores the output in a single buffer.

Response:
def transform(self, program: moderngl.Program, buffer: moderngl.Buffer,
                  mode=None, vertices=-1, first=0, instances=1):
        """
        Transform vertices. Stores the output in a single buffer.

        Args:
            program: The ``moderngl.Program``
            buffer: The ``moderngl.buffer`` to store the output

        Keyword Args:
            mode: Draw mode (for example ``moderngl.POINTS``)
            vertices (int): The number of vertices to transform
            first (int): The index of the first vertex to start with
            instances (int): The number of instances
        """
        vao = self.instance(program)

        if mode is None:
            mode = self.mode

        vao.transform(buffer, mode=mode, vertices=vertices, first=first, instances=instances)


Instruction:
Can you tell what is the following Python 3 function doing
def buffer(self, buffer, buffer_format: str, attribute_names, per_instance=False):
        if not isinstance(attribute_names, list):
            attribute_names = [attribute_names, ]

        if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]:
            raise VAOError(
                (
                    "buffer parameter must be a moderngl.Buffer, numpy.ndarray or bytes instance"
                    "(not {})".format(type(buffer))
                )
            )

        if isinstance(buffer, numpy.ndarray):
            buffer = self.ctx.buffer(buffer.tobytes())

        if isinstance(buffer, bytes):
            buffer = self.ctx.buffer(data=buffer)

        formats = buffer_format.split()
        if len(formats) != len(attribute_names):
            raise VAOError("Format '{}' does not describe attributes {}".format(buffer_format, attribute_names))

        self.buffers.append(BufferInfo(buffer, buffer_format, attribute_names, per_instance=per_instance))
        self.vertex_count = self.buffers[-1].vertices

        return buffer

Response: Register a buffer for the current VAO.


Instruction:
Can you write a function in Python 3 where it
sets the index buffer for this VAO.

Response:
def index_buffer(self, buffer, index_element_size=4):
        """
        Set the index buffer for this VAO

        Args:
            buffer: ``moderngl.Buffer``, ``numpy.array`` or ``bytes``

        Keyword Args:
            index_element_size (int): Byte size of each element. 1, 2 or 4
        """
        if not type(buffer) in [moderngl.Buffer, numpy.ndarray, bytes]:
            raise VAOError("buffer parameter must be a moderngl.Buffer, numpy.ndarray or bytes instance")

        if isinstance(buffer, numpy.ndarray):
            buffer = self.ctx.buffer(buffer.tobytes())

        if isinstance(buffer, bytes):
            buffer = self.ctx.buffer(data=buffer)

        self._index_buffer = buffer
        self._index_element_size = index_element_size


Instruction:
Can you write a function in Python 3 where it
returns the instance of the given program.

Response:
def instance(self, program: moderngl.Program) -> moderngl.VertexArray:
        """
        Obtain the ``moderngl.VertexArray`` instance for the program.
        The instance is only created once and cached internally.

        Returns: ``moderngl.VertexArray`` instance
        """
        vao = self.vaos.get(program.glo)
        if vao:
            return vao

        program_attributes = [name for name, attr in program._members.items() if isinstance(attr, moderngl.Attribute)]

        # Make sure all attributes are covered
        for attrib_name in program_attributes:
            # Ignore built in attributes for now
            if attrib_name.startswith('gl_'):
                continue

            # Do we have a buffer mapping to this attribute?
            if not sum(buffer.has_attribute(attrib_name) for buffer in self.buffers):
                raise VAOError("VAO {} doesn't have attribute {} for program {}".format(
                    self.name, attrib_name, program.name))

        vao_content = []

        # Pick out the attributes we can actually map
        for buffer in self.buffers:
            content = buffer.content(program_attributes)
            if content:
                vao_content.append(content)

        # Any attribute left is not accounted for
        if program_attributes:
            for attrib_name in program_attributes:
                if attrib_name.startswith('gl_'):
                    continue

                raise VAOError("Did not find a buffer mapping for {}".format([n for n in program_attributes]))

        # Create the vao
        if self._index_buffer:
            vao = context.ctx().vertex_array(program, vao_content,
                                             self._index_buffer, self._index_element_size)
        else:
            vao = context.ctx().vertex_array(program, vao_content)

        self.vaos[program.glo] = vao
        return vao


Instruction:
Create a Python 3 function for
destroying the vao object

Response:
def release(self, buffer=True):
        """
        Destroy the vao object

        Keyword Args:
            buffers (bool): also release buffers
        """
        for key, vao in self.vaos:
            vao.release()

        if buffer:
            for buff in self.buffers:
                buff.buffer.release()

            if self._index_buffer:
                self._index_buffer.release()


Instruction:
Write a Python 3 function that can
return a new cube VAO with the given width height and depth centered at center.

Response:
def cube(width, height, depth, center=(0.0, 0.0, 0.0), normals=True, uvs=True) -> VAO:
    """
    Creates a cube VAO with normals and texture coordinates

    Args:
        width (float): Width of the cube
        height (float): Height of the cube
        depth (float): Depth of the cube

    Keyword Args:
        center: center of the cube as a 3-component tuple
        normals: (bool) Include normals
        uvs: (bool) include uv coordinates

    Returns:
        A :py:class:`demosys.opengl.vao.VAO` instance
    """
    width, height, depth = width / 2.0, height / 2.0, depth / 2.0

    pos = numpy.array([
        center[0] + width, center[1] - height, center[2] + depth,
        center[0] + width, center[1] + height, center[2] + depth,
        center[0] - width, center[1] - height, center[2] + depth,
        center[0] + width, center[1] + height, center[2] + depth,
        center[0] - width, center[1] + height, center[2] + depth,
        center[0] - width, center[1] - height, center[2] + depth,
        center[0] + width, center[1] - height, center[2] - depth,
        center[0] + width, center[1] + height, center[2] - depth,
        center[0] + width, center[1] - height, center[2] + depth,
        center[0] + width, center[1] + height, center[2] - depth,
        center[0] + width, center[1] + height, center[2] + depth,
        center[0] + width, center[1] - height, center[2] + depth,
        center[0] + width, center[1] - height, center[2] - depth,
        center[0] + width, center[1] - height, center[2] + depth,
        center[0] - width, center[1] - height, center[2] + depth,
        center[0] + width, center[1] - height, center[2] - depth,
        center[0] - width, center[1] - height, center[2] + depth,
        center[0] - width, center[1] - height, center[2] - depth,
        center[0] - width, center[1] - height, center[2] + depth,
        center[0] - width, center[1] + height, center[2] + depth,
        center[0] - width, center[1] + height, center[2] - depth,
        center[0] - width, center[1] - height, center[2] + depth,
        center[0] - width, center[1] + height, center[2] - depth,
        center[0] - width, center[1] - height, center[2] - depth,
        center[0] + width, center[1] + height, center[2] - depth,
        center[0] + width, center[1] - height, center[2] - depth,
        center[0] - width, center[1] - height, center[2] - depth,
        center[0] + width, center[1] + height, center[2] - depth,
        center[0] - width, center[1] - height, center[2] - depth,
        center[0] - width, center[1] + height, center[2] - depth,
        center[0] + width, center[1] + height, center[2] - depth,
        center[0] - width, center[1] + height, center[2] - depth,
        center[0] + width, center[1] + height, center[2] + depth,
        center[0] - width, center[1] + height, center[2] - depth,
        center[0] - width, center[1] + height, center[2] + depth,
        center[0] + width, center[1] + height, center[2] + depth,
    ], dtype=numpy.float32)

    if normals:
        normal_data = numpy.array([
            -0, 0, 1,
            -0, 0, 1,
            -0, 0, 1,
            0, 0, 1,
            0, 0, 1,
            0, 0, 1,
            1, 0, 0,
            1, 0, 0,
            1, 0, 0,
            1, 0, 0,
            1, 0, 0,
            1, 0, 0,
            0, -1, 0,
            0, -1, 0,
            0, -1, 0,
            0, -1, 0,
            0, -1, 0,
            0, -1, 0,
            -1, -0, 0,
            -1, -0, 0,
            -1, -0, 0,
            -1, -0, 0,
            -1, -0, 0,
            -1, -0, 0,
            0, 0, -1,
            0, 0, -1,
            0, 0, -1,
            0, 0, -1,
            0, 0, -1,
            0, 0, -1,
            0, 1, 0,
            0, 1, 0,
            0, 1, 0,
            0, 1, 0,
            0, 1, 0,
            0, 1, 0,
        ], dtype=numpy.float32)

    if uvs:
        uvs_data = numpy.array([
            1, 0,
            1, 1,
            0, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 0,
            1, 1,
            0, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 1,
            0, 1,
            0, 0,
            1, 1,
            0, 0,
            1, 0,
            0, 1,
            0, 0,
            1, 0,
            0, 1,
            1, 0,
            1, 1,
            1, 0,
            1, 1,
            0, 1,
            1, 0,
            0, 1,
            0, 0,
            1, 1,
            0, 1,
            1, 0,
            0, 1,
            0, 0,
            1, 0
        ], dtype=numpy.float32)

    vao = VAO("geometry:cube")

    # Add buffers
    vao.buffer(pos, '3f', ['in_position'])
    if normals:
        vao.buffer(normal_data, '3f', ['in_normal'])
    if uvs:
        vao.buffer(uvs_data, '2f', ['in_uv'])

    return vao


Instruction:
Here you have a function in Python 3, explain what it does
def draw(self, mesh, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0):
        self.program["m_proj"].write(projection_matrix)
        self.program["m_mv"].write(view_matrix)
        mesh.vao.render(self.program)

Response: Draw the current region of the current region.


Instruction:
Explain what the following Python 3 code does
def get_time(self) -> float:
        if self.paused:
            return self.pause_time

        return self.player.get_time() / 1000.0

Response: Get the current time in seconds


Instruction:
Write a Python 3 script to
parse the effect package string.

Response:
def parse_package_string(path):
    """
    Parse the effect package string.
    Can contain the package python path or path to effect class in an effect package.

    Examples::

        # Path to effect pacakge
        examples.cubes

        # Path to effect class
        examples.cubes.Cubes

    Args:
        path: python path to effect package. May also include effect class name.

    Returns:
        tuple: (package_path, effect_class)
    """
    parts = path.split('.')

    # Is the last entry in the path capitalized?
    if parts[-1][0].isupper():
        return ".".join(parts[:-1]), parts[-1]

    return path, ""


Instruction:
Create a Python 3 function to
get all directories that are available for the current application.

Response:
def get_dirs(self) -> List[str]:
        """
        Get all effect directories for registered effects.
        """
        for package in self.packages:
            yield os.path.join(package.path, 'resources')


Instruction:
Make a summary of the following Python 3 code
def get_effect_resources(self) -> List[Any]:
        resources = []
        for package in self.packages:
            resources.extend(package.resources)

        return resources

Response: Get all resources registed in effect packages.


Instruction:
Create a Python 3 function to
add a single effect package to the effect package list.

Response:
def add_package(self, name):
        """
        Registers a single package

        :param name: (str) The effect package to add
        """
        name, cls_name = parse_package_string(name)

        if name in self.package_map:
            return

        package = EffectPackage(name)
        package.load()

        self.packages.append(package)
        self.package_map[package.name] = package

        # Load effect package dependencies
        self.polulate(package.effect_packages)


Instruction:
Can you tell what is the following Python 3 function doing
def get_package(self, name) -> 'EffectPackage':
        name, cls_name = parse_package_string(name)

        try:
            return self.package_map[name]
        except KeyError:
            raise EffectError("No package '{}' registered".format(name))

Response: Get a package by python path. Can also contain path to an effect.


Instruction:
Can you implement a function in Python 3 that
finds an effect class by class name or full python path to class

Response:
def find_effect_class(self, path) -> Type[Effect]:
        """
        Find an effect class by class name or full python path to class

        Args:
            path (str): effect class name or full python path to effect class

        Returns:
            Effect class

        Raises:
            EffectError if no class is found
        """
        package_name, class_name = parse_package_string(path)

        if package_name:
            package = self.get_package(package_name)
            return package.find_effect_class(class_name, raise_for_error=True)

        for package in self.packages:
            effect_cls = package.find_effect_class(class_name)
            if effect_cls:
                return effect_cls

        raise EffectError("No effect class '{}' found in any packages".format(class_name))


Instruction:
Can you tell what is the following Python 3 function doing
def runnable_effects(self) -> List[Type[Effect]]:
        return [cls for cls in self.effect_classes if cls.runnable]

Response: Returns the runnable effects in the package


Instruction:
Can you implement a function in Python 3 that
finds the effect package

Response:
def load_package(self):
        """FInd the effect package"""
        try:
            self.package = importlib.import_module(self.name)
        except ModuleNotFoundError:
            raise ModuleNotFoundError("Effect package '{}' not found.".format(self.name))


Instruction:
Write a Python 3 function for
iterating the module attributes picking out effects

Response:
def load_effects_classes(self):
        """Iterate the module attributes picking out effects"""
        self.effect_classes = []

        for _, cls in inspect.getmembers(self.effect_module):
            if inspect.isclass(cls):
                if cls == Effect:
                    continue

                if issubclass(cls, Effect):
                    self.effect_classes.append(cls)
                    self.effect_class_map[cls.__name__] = cls
                    cls._name = "{}.{}".format(self.effect_module_name, cls.__name__)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def load_resource_module(self):
        # Attempt to load the dependencies module
        try:
            name = '{}.{}'.format(self.name, 'dependencies')
            self.dependencies_module = importlib.import_module(name)
        except ModuleNotFoundError as err:
            raise EffectError(
                (
                    "Effect package '{}' has no 'dependencies' module or the module has errors. "
                    "Forwarded error from importlib: {}"
                ).format(self.name, err))

        # Fetch the resource descriptions
        try:
            self.resources = getattr(self.dependencies_module, 'resources')
        except AttributeError:
            raise EffectError("Effect dependencies module '{}' has no 'resources' attribute".format(name))

        if not isinstance(self.resources, list):
            raise EffectError(
                "Effect dependencies module '{}': 'resources' is of type {} instead of a list".format(
                    name, type(self.resources)))

        # Fetch the effect class list
        try:
            self.effect_packages = getattr(self.dependencies_module, 'effect_packages')
        except AttributeError:
            raise EffectError("Effect dependencies module '{}' has 'effect_packages' attribute".format(name))

        if not isinstance(self.effect_packages, list):
            raise EffectError(
                "Effect dependencies module '{}': 'effect_packages' is of type {} instead of a list".format(
                    name, type(self.effects)))

Response: Load the resource module and the resource list


Instruction:
Can you create a Python 3 function that
creates a screenshot of the current page.

Response:
def create(file_format='png', name=None):
    """
    Create a screenshot
    :param file_format: formats supported by PIL (png, jpeg etc)
    """
    dest = ""
    if settings.SCREENSHOT_PATH:
        if not os.path.exists(settings.SCREENSHOT_PATH):
            print("SCREENSHOT_PATH does not exist. creating: {}".format(settings.SCREENSHOT_PATH))
            os.makedirs(settings.SCREENSHOT_PATH)
        dest = settings.SCREENSHOT_PATH
    else:
        print("SCREENSHOT_PATH not defined in settings. Using cwd as fallback.")

    if not Config.target:
        Config.target = context.window().fbo

    image = Image.frombytes(
        "RGB",
        (Config.target.viewport[2], Config.target.viewport[3]),
        Config.target.read(viewport=Config.target.viewport, alignment=Config.alignment),
    )
    image = image.transpose(Image.FLIP_TOP_BOTTOM)

    if not name:
        name = "{}.{}".format(datetime.now().strftime("%Y-%m-%d-%H-%M-%S-%f"), file_format)

    dest = os.path.join(dest, name)
    print("Creating screenshot:", dest)
    image.save(dest, format=file_format)


Instruction:
Here you have a function in Python 3, explain what it does
def draw(self, time, frametime, target):
        for effect in self.effects:
            value = effect.rocket_timeline_track.time_value(time)
            if value > 0.5:
                effect.draw(time, frametime, target)

Response: Draw the current time frame and target.


Instruction:
How would you code a function in Python 3 to
load a 2d texture

Response:
def load(self):
        """Load a 2d texture"""
        self._open_image()

        components, data = image_data(self.image)

        texture = self.ctx.texture(
            self.image.size,
            components,
            data,
        )
        texture.extra = {'meta': self.meta}

        if self.meta.mipmap:
            texture.build_mipmaps()

        self._close_image()

        return texture


Instruction:
Here you have a function in Python 3, explain what it does
def from_single(cls, meta: ProgramDescription, source: str):
        instance = cls(meta)
        instance.vertex_source = ShaderSource(
            VERTEX_SHADER,
            meta.path or meta.vertex_shader,
            source
        )

        if GEOMETRY_SHADER in source:
            instance.geometry_source = ShaderSource(
                GEOMETRY_SHADER,
                meta.path or meta.geometry_shader,
                source,
            )

        if FRAGMENT_SHADER in source:
            instance.fragment_source = ShaderSource(
                FRAGMENT_SHADER,
                meta.path or meta.fragment_shader,
                source,
            )

        if TESS_CONTROL_SHADER in source:
            instance.tess_control_source = ShaderSource(
                TESS_CONTROL_SHADER,
                meta.path or meta.tess_control_shader,
                source,
            )

        if TESS_EVALUATION_SHADER in source:
            instance.tess_evaluation_source = ShaderSource(
                TESS_EVALUATION_SHADER,
                meta.path or meta.tess_evaluation_shader,
                source,
            )

        return instance

Response: Initialize a single glsl string containing all shaders


Instruction:
Write a Python 3 script to
initialize multiple shader strings

Response:
def from_separate(cls, meta: ProgramDescription, vertex_source, geometry_source=None, fragment_source=None,
                      tess_control_source=None, tess_evaluation_source=None):
        """Initialize multiple shader strings"""
        instance = cls(meta)
        instance.vertex_source = ShaderSource(
            VERTEX_SHADER,
            meta.path or meta.vertex_shader,
            vertex_source,
        )

        if geometry_source:
            instance.geometry_source = ShaderSource(
                GEOMETRY_SHADER,
                meta.path or meta.geometry_shader,
                geometry_source,
            )

        if fragment_source:
            instance.fragment_source = ShaderSource(
                FRAGMENT_SHADER,
                meta.path or meta.fragment_shader,
                fragment_source,
            )

        if tess_control_source:
            instance.tess_control_source = ShaderSource(
                TESS_CONTROL_SHADER,
                meta.path or meta.tess_control_shader,
                tess_control_source,
            )

        if tess_evaluation_source:
            instance.tess_evaluation_source = ShaderSource(
                TESS_EVALUATION_SHADER,
                meta.path or meta.tess_control_shader,
                tess_evaluation_source,
            )

        return instance


Instruction:
Can you implement a function in Python 3 that
creates a new program instance with the same attributes as the current one.

Response:
def create(self):
        """
        Creates a shader program.

        Returns:
            ModernGL Program instance
        """
        # Get out varyings
        out_attribs = []

        # If no fragment shader is present we are doing transform feedback
        if not self.fragment_source:
            # Out attributes is present in geometry shader if present
            if self.geometry_source:
                out_attribs = self.geometry_source.find_out_attribs()
            # Otherwise they are specified in vertex shader
            else:
                out_attribs = self.vertex_source.find_out_attribs()

        program = self.ctx.program(
            vertex_shader=self.vertex_source.source,
            geometry_shader=self.geometry_source.source if self.geometry_source else None,
            fragment_shader=self.fragment_source.source if self.fragment_source else None,
            tess_control_shader=self.tess_control_source.source if self.tess_control_source else None,
            tess_evaluation_shader=self.tess_evaluation_source.source if self.tess_evaluation_source else None,
            varyings=out_attribs,
        )
        program.extra = {'meta': self.meta}
        return program


Instruction:
Explain what the following Python 3 code does
def find_out_attribs(self):
        names = []
        for line in self.lines:
            if line.strip().startswith("out "):
                names.append(line.split()[2].replace(';', ''))
        return names

Response: Find all out attributes in the shader source.


Instruction:
Can you create a Python 3 function that
prints the shader lines

Response:
def print(self):
        """Print the shader lines"""
        print("---[ START {} ]---".format(self.name))

        for i, line in enumerate(self.lines):
            print("{}: {}".format(str(i).zfill(3), line))

        print("---[ END {} ]---".format(self.name))


Instruction:
Write a Python 3 script for
creating an effect instance adding it to the internal effects dictionary using the label as key.

Response:
def create_effect(self, label: str, name: str, *args, **kwargs) -> Effect:
        """
        Create an effect instance adding it to the internal effects dictionary using the label as key.

        Args:
            label (str): The unique label for the effect instance
            name (str): Name or full python path to the effect class we want to instantiate
            args: Positional arguments to the effect initializer
            kwargs: Keyword arguments to the effect initializer

        Returns:
            The newly created Effect instance
        """
        effect_cls = effects.find_effect_class(name)
        effect = effect_cls(*args, **kwargs)
        effect._label = label

        if label in self._effects:
            raise ValueError("An effect with label '{}' already exists".format(label))

        self._effects[label] = effect

        return effect


Instruction:
Can you tell what is the following Python 3 function doing
def load(self):
        self.create_effect_classes()

        self._add_resource_descriptions_to_pools(self.create_external_resources())
        self._add_resource_descriptions_to_pools(self.create_resources())

        for meta, resource in resources.textures.load_pool():
            self._textures[meta.label] = resource

        for meta, resource in resources.programs.load_pool():
            self._programs[meta.label] = resource

        for meta, resource in resources.scenes.load_pool():
            self._scenes[meta.label] = resource

        for meta, resource in resources.data.load_pool():
            self._data[meta.label] = resource

        self.create_effect_instances()
        self.post_load()

Response: Loads all resources and effects from the pool.


Instruction:
Can you tell what is the following Python 3 function doing
def _add_resource_descriptions_to_pools(self, meta_list):
        if not meta_list:
            return

        for meta in meta_list:
            getattr(resources, meta.resource_type).add(meta)

Response: Adds the resource descriptions to the resource pools.


Instruction:
Can you generate the documentation for the following Python 3 function
def reload_programs(self):
        print("Reloading programs:")
        for name, program in self._programs.items():
            if getattr(program, 'program', None):
                print(" - {}".format(program.meta.label))
                program.program = resources.programs.load(program.meta)

Response: Reload all shader programs with the reloadable flag set set


Instruction:
Write a Python 3 function for
returning the latest instance of the effect with the given label

Response:
def get_effect(self, label: str) -> Effect:
        """
        Get an effect instance by label

        Args:
            label (str): The label for the effect instance

        Returns:
            Effect class instance
        """
        return self._get_resource(label, self._effects, "effect")


Instruction:
Can you create a Python 3 function that
returns an effect class from the effect registry.

Response:
def get_effect_class(self, class_name, package_name=None) -> Type[Effect]:
        """
        Get an effect class from the effect registry.

        Args:
            class_name (str): The exact class name of the effect

        Keyword Args:
            package_name (str): The python path to the effect package the effect name is located.
                                This is optional and can be used to avoid issue with class name collisions.

        Returns:
            Effect class
        """
        if package_name:
            return effects.find_effect_class("{}.{}".format(package_name, class_name))

        return effects.find_effect_class(class_name)


Instruction:
How would you explain what the following Python 3 function does
def get_scene(self, label: str) -> Scene:
        return self._get_resource(label, self._scenes, "scene")

Response: Returns a new instance of the Scene with the specified label.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def get_texture(self, label: str) -> Union[moderngl.Texture, moderngl.TextureArray,
                                               moderngl.Texture3D, moderngl.TextureCube]:
        """
        Get a texture by label

        Args:
            label (str): The label for the texture to fetch

        Returns:
            Texture instance
        """
        return self._get_resource(label, self._textures, "texture")

Response: Returns the first texture in the list of available textures.


Instruction:
Can you implement a function in Python 3 that
returns the data object with the specified label

Response:
def get_data(self, label: str) -> Any:
        """
        Get a data resource by label

        Args:
            label (str): The labvel for the data resource to fetch

        Returns:
            The requeted data object
        """
        return self._get_resource(label, self._data, "data")


Instruction:
How would you explain what the following Python 3 function does
def _get_resource(self, label: str, source: dict, resource_type: str):
        try:
            return source[label]
        except KeyError:
            raise ValueError("Cannot find {0} with label '{1}'.\nExisting {0} labels: {2}".format(
                resource_type, label, list(source.keys())))

Response: Generic method to fetch the latest resource from the dictionary


Instruction:
Here you have a function in Python 3, explain what it does
def get_runnable_effects(self) -> List[Effect]:
        return [effect for name, effect in self._effects.items() if effect.runnable]

Response: Returns all runnable effects in the project.


Instruction:
Explain what the following Python 3 code does
def image_data(image):
    # NOTE: We might want to check the actual image.mode
    #       and convert to an acceptable format.
    #       At the moment we load the data as is.
    data = image.tobytes()
    components = len(data) // (image.size[0] * image.size[1])
    return components, data

Response: Get components and bytes for an image


Instruction:
Here you have a function in Python 3, explain what it does
def run_from_argv(self, argv):
        parser = self.create_parser(argv[0], argv[1])
        options = parser.parse_args(argv[2:])
        cmd_options = vars(options)
        args = cmd_options.pop('args', ())
        self.handle(*args, **cmd_options)

Response: Called by the system when executing the command from the command line.


Instruction:
Explain what the following Python 3 code does
def create_parser(self, prog_name, subcommand):
        parser = argparse.ArgumentParser(prog_name, subcommand)
        # Add generic arguments here
        self.add_arguments(parser)
        return parser

Response: Create argument parser and deal with add_arguments.


Instruction:
Write a Python 3 function for
validating that the name is valid.

Response:
def validate_name(self, name):
        """
        Can the name be used as a python module or package?
        Raises ``ValueError`` if the name is invalid.

        :param name: the name to check
        """
        if not name:
            raise ValueError("Name cannot be empty")

        # Can the name be used as an identifier in python (module or package name)
        if not name.isidentifier():
            raise ValueError("{} is not a valid identifier".format(name))


Instruction:
Write a Python 3 script to
generate a bounding box for the current entry.

Response:
def bbox(width=1.0, height=1.0, depth=1.0):
    """
    Generates a bounding box with (0.0, 0.0, 0.0) as the center.
    This is simply a box with ``LINE_STRIP`` as draw mode.

    Keyword Args:
        width (float): Width of the box
        height (float): Height of the box
        depth (float): Depth of the box

    Returns:
        A :py:class:`demosys.opengl.vao.VAO` instance
    """
    width, height, depth = width / 2.0, height / 2.0, depth / 2.0
    pos = numpy.array([
        width, -height, depth,
        width, height, depth,
        -width, -height, depth,
        width, height, depth,
        -width, height, depth,
        -width, -height, depth,
        width, -height, -depth,
        width, height, -depth,
        width, -height, depth,
        width, height, -depth,
        width, height, depth,
        width, -height, depth,
        width, -height, -depth,
        width, -height, depth,
        -width, -height, depth,
        width, -height, -depth,
        -width, -height, depth,
        -width, -height, -depth,
        -width, -height, depth,
        -width, height, depth,
        -width, height, -depth,
        -width, -height, depth,
        -width, height, -depth,
        -width, -height, -depth,
        width, height, -depth,
        width, -height, -depth,
        -width, -height, -depth,
        width, height, -depth,
        -width, -height, -depth,
        -width, height, -depth,
        width, height, -depth,
        -width, height, -depth,
        width, height, depth,
        -width, height, -depth,
        -width, height, depth,
        width, height, depth,
    ], dtype=numpy.float32)

    vao = VAO("geometry:cube", mode=moderngl.LINE_STRIP)
    vao.buffer(pos, '3f', ["in_position"])

    return vao


Instruction:
How would you implement a function in Python 3 that
finds the last occurance of the file in finders

Response:
def _find_last_of(self, path, finders):
        """Find the last occurance of the file in finders"""
        found_path = None
        for finder in finders:
            result = finder.find(path)
            if result:
                found_path = result

        return found_path


Instruction:
Explain what the following Python 3 code does
def initial_sanity_check(self):
        # Check for python module collision
        self.try_import(self.project_name)

        # Is the name a valid identifier?
        self.validate_name(self.project_name)

        # Make sure we don't mess with existing directories
        if os.path.exists(self.project_name):
            print("Directory {} already exist. Aborting.".format(self.project_name))
            return False

        if os.path.exists('manage.py'):
            print("A manage.py file already exist in the current directory. Aborting.")
            return False

        return True

Response: Checks if we can create the project


Instruction:
How would you explain what the following Python 3 function does
def create_entrypoint(self):
        with open(os.path.join(self.template_dir, 'manage.py'), 'r') as fd:
            data = fd.read().format(project_name=self.project_name)

        with open('manage.py', 'w') as fd:
            fd.write(data)

        os.chmod('manage.py', 0o777)

Response: Create the manage. py file in the current directory


Instruction:
How would you explain what the following Python 3 function does
def get_template_dir(self):
        directory = os.path.dirname(os.path.abspath(__file__))
        directory = os.path.dirname(os.path.dirname(directory))
        directory = os.path.join(directory, 'project_template')
        return directory

Response: Returns the absolute path to template directory


Instruction:
Make a summary of the following Python 3 code
def davidson(lname, fname='.', omit_fname=False):
    return Davidson().encode(lname, fname, omit_fname)

Response: Return a Davidson s Consonant Code.


Instruction:
Can you create a Python 3 function that
returns a string that encodes the given last name and optional first name.

Response:
def encode(self, lname, fname='.', omit_fname=False):
        """Return Davidson's Consonant Code.

        Parameters
        ----------
        lname : str
            Last name (or word) to be encoded
        fname : str
            First name (optional), of which the first character is included in
            the code.
        omit_fname : bool
            Set to True to completely omit the first character of the first
            name

        Returns
        -------
        str
            Davidson's Consonant Code

        Example
        -------
        >>> pe = Davidson()
        >>> pe.encode('Gough')
        'G   .'
        >>> pe.encode('pneuma')
        'PNM .'
        >>> pe.encode('knight')
        'KNGT.'
        >>> pe.encode('trice')
        'TRC .'
        >>> pe.encode('judge')
        'JDG .'
        >>> pe.encode('Smith', 'James')
        'SMT J'
        >>> pe.encode('Wasserman', 'Tabitha')
        'WSRMT'

        """
        lname = text_type(lname.upper())
        code = self._delete_consecutive_repeats(
            lname[:1] + lname[1:].translate(self._trans)
        )
        code = code[:4] + (4 - len(code)) * ' '

        if not omit_fname:
            code += fname[:1].upper()

        return code


Instruction:
Write a Python 3 function that can
encode a text using arithmetic coding with the provided probabilities.

Response:
def ac_encode(text, probs):
    """Encode a text using arithmetic coding with the provided probabilities.

    This is a wrapper for :py:meth:`Arithmetic.encode`.

    Parameters
    ----------
    text : str
        A string to encode
    probs : dict
        A probability statistics dictionary generated by
        :py:meth:`Arithmetic.train`

    Returns
    -------
    tuple
        The arithmetically coded text

    Example
    -------
    >>> pr = ac_train('the quick brown fox jumped over the lazy dog')
    >>> ac_encode('align', pr)
    (16720586181, 34)

    """
    coder = Arithmetic()
    coder.set_probs(probs)
    return coder.encode(text)


Instruction:
Here you have a function in Python 3, explain what it does
def ac_decode(longval, nbits, probs):
    coder = Arithmetic()
    coder.set_probs(probs)
    return coder.decode(longval, nbits)

Response: Decode the number to a string using the given statistics.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def train(self, text):
        text = text_type(text)
        if '\x00' in text:
            text = text.replace('\x00', ' ')
        counts = Counter(text)
        counts['\x00'] = 1
        tot_letters = sum(counts.values())

        tot = 0
        self._probs = {}
        prev = Fraction(0)
        for char, count in sorted(
            counts.items(), key=lambda x: (x[1], x[0]), reverse=True
        ):
            follow = Fraction(tot + count, tot_letters)
            self._probs[char] = (prev, follow)
            prev = follow
            tot = tot + count

Response: r Generate a probability dict from the provided text.