```python
import bpy
import math
from mathutils import Vector

# Clear the default scene
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete(use_global=False)
for datablocks in (bpy.data.meshes, bpy.data.curves, bpy.data.materials, bpy.data.cameras, bpy.data.lights):
    pass

# -------------------------------------------------------------------
# Materials
# -------------------------------------------------------------------
cube_mat = bpy.data.materials.new("Pleasant Ceramic Blue")
cube_mat.diffuse_color = (0.12, 0.34, 0.48, 1.0)
cube_mat.use_nodes = True
bsdf = cube_mat.node_tree.nodes.get("Principled BSDF")
bsdf.inputs["Base Color"].default_value = (0.075, 0.28, 0.42, 1.0)
bsdf.inputs["Roughness"].default_value = 0.26
bsdf.inputs["Metallic"].default_value = 0.0
bsdf.inputs["Specular IOR Level"].default_value = 0.42

floor_mat = bpy.data.materials.new("Warm Neutral Floor")
floor_mat.diffuse_color = (0.16, 0.18, 0.20, 1.0)
floor_mat.use_nodes = True
floor_bsdf = floor_mat.node_tree.nodes.get("Principled BSDF")
floor_bsdf.inputs["Base Color"].default_value = (0.115, 0.135, 0.15, 1.0)
floor_bsdf.inputs["Roughness"].default_value = 0.72

# -------------------------------------------------------------------
# Main 2-meter cube
# -------------------------------------------------------------------
bpy.ops.mesh.primitive_cube_add(location=(0.0, 0.0, 0.0))
cube = bpy.context.object
cube.name = "Two Meter Cube With Through Channel"
cube.dimensions = (2.0, 2.0, 2.0)
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
cube.data.materials.append(cube_mat)

# Cylinder: 1 meter diameter, passing fully through top and bottom
bpy.ops.mesh.primitive_cylinder_add(
    vertices=96,
    radius=0.5,
    depth=2.6,
    location=(0.0, 0.0, 0.0)
)
cutter = bpy.context.object
cutter.name = "Through Hole Cutter"

# Apply exact boolean subtraction
bpy.context.view_layer.objects.active = cube
cube.select_set(True)
cutter.select_set(False)

boolean = cube.modifiers.new("Clean Open Through Channel", 'BOOLEAN')
boolean.operation = 'DIFFERENCE'
boolean.solver = 'EXACT'
boolean.object = cutter
bpy.ops.object.modifier_apply(modifier=boolean.name)

# Remove cutter so the saved scene contains a single finished cube mesh
bpy.data.objects.remove(cutter, do_unlink=True)

# -------------------------------------------------------------------
# Small, even bevel on outer edges and both channel rims
# -------------------------------------------------------------------
bevel = cube.modifiers.new("Small Even Edge And Rim Bevel", 'BEVEL')
bevel.width = 0.055
bevel.segments = 4
bevel.limit_method = 'ANGLE'
bevel.angle_limit = math.radians(18.0)
bevel.miter_outer = 'MITER_ARC'
bevel.harden_normals = True
bpy.context.view_layer.objects.active = cube
bpy.ops.object.modifier_apply(modifier=bevel.name)

# Weighted normals preserve broad planar faces while keeping bevels smooth
for poly in cube.data.polygons:
    poly.use_smooth = True

weighted = cube.modifiers.new("Artifact Free Weighted Shading", 'WEIGHTED_NORMAL')
weighted.keep_sharp = True
weighted.weight = 50
bpy.ops.object.modifier_apply(modifier=weighted.name)

# Ensure the finished object is the only cube mesh
cube.select_set(True)
bpy.context.view_layer.objects.active = cube

# -------------------------------------------------------------------
# Ground plane, deliberately below the cube so the channel remains open
# -------------------------------------------------------------------
bpy.ops.mesh.primitive_plane_add(size=14.0, location=(0.0, 0.0, -1.42))
ground = bpy.context.object
ground.name = "Low Ground Plane"
ground.data.materials.append(floor_mat)

# Slight bevel on ground is unnecessary; keep it simple and large.

# -------------------------------------------------------------------
# Lighting
# -------------------------------------------------------------------
world = bpy.context.scene.world
world.use_nodes = True
world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.018, 0.028, 0.042, 1.0)
world.node_tree.nodes["Background"].inputs["Strength"].default_value = 0.28

def add_area(name, location, energy, size, color):
    data = bpy.data.lights.new(name=name, type='AREA')
    data.energy = energy
    data.shape = 'DISK'
    data.size = size
    data.color = color
    obj = bpy.data.objects.new(name, data)
    bpy.context.collection.objects.link(obj)
    obj.location = location
    return obj

def point_at(obj, target):
    direction = Vector(target) - obj.location
    obj.rotation_euler = direction.to_track_quat('-Z', 'Y').to_euler()

key = add_area(
    "Large Soft Key",
    (4.5, -4.5, 6.0),
    850.0,
    4.0,
    (1.0, 0.86, 0.70)
)
point_at(key, (0, 0, 0))

fill = add_area(
    "Cool Front Fill",
    (-4.0, -3.0, 2.8),
    500.0,
    3.5,
    (0.56, 0.72, 1.0)
)
point_at(fill, (0, 0, 0.1))

rim = add_area(
    "Top Rim Light",
    (0.0, 3.5, 5.5),
    700.0,
    3.0,
    (0.72, 0.84, 1.0)
)
point_at(rim, (0, 0, 0.4))

# Gentle light into the channel
inner = add_area(
    "Channel Soft Light",
    (0.0, 0.0, 3.5),
    180.0,
    1.8,
    (1.0, 0.78, 0.58)
)
point_at(inner, (0, 0, -0.4))

# -------------------------------------------------------------------
# Camera: elevated three-quarter view showing the top rim and channel
# -------------------------------------------------------------------
cam_data = bpy.data.cameras.new("Presentation Camera")
camera = bpy.data.objects.new("Presentation Camera", cam_data)
bpy.context.collection.objects.link(camera)
bpy.context.scene.camera = camera

camera.location = (4.0, -5.2, 3.25)
target = Vector((0.0, 0.0, -0.05))
camera.rotation_euler = (target - camera.location).to_track_quat('-Z', 'Y').to_euler()
cam_data.lens =  fifty = 52.0
cam_data.sensor_width = 36.0

# -------------------------------------------------------------------
# Render and color management
# -------------------------------------------------------------------
scene = bpy.context.scene
scene.render.engine = 'BLENDER_EEVEE_NEXT'
scene.render.resolution_x = 1536
scene.render.resolution_y = 1536
scene.render.resolution_percentage = 100
scene.render.image_settings.file_format = 'PNG'
scene.render.film_transparent = False
scene.render.filepath = "//cube_through_channel.png"

scene.render.image_settings.color_mode = 'RGBA'
scene.view_settings.look = 'AgX - Medium High Contrast'
scene.view_settings.exposure = 0.0
scene.view_settings.gamma = 1.0

# High-quality viewport/render defaults; benchmark may override engine and samples
scene.render.image_settings.color_depth = '8'
scene.camera.data.dof.use_dof = False

# Organize object selection and save the complete scene
bpy.ops.object.select_all(action='DESELECT')
cube.select_set(True)
bpy.context.view_layer.objects.active = cube

# Save the finished Blender file
bpy.ops.wm.save_as_mainfile(filepath="//through_channel_cube.blend")
```