```python
import bpy
import math
import mathutils

# ==============================================================================
# 1. INITIAL SCENE CLEANUP & SETUP
# ==============================================================================
# Ensure starting with a completely blank scene
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete()

# Set up Cycles renderer with high-quality settings
bpy.context.scene.render.engine = 'CYCLES'
bpy.context.scene.cycles.samples = 64
bpy.context.scene.cycles.use_denoising = True
bpy.context.scene.view_settings.view_transform = 'AgX'
bpy.context.scene.view_settings.look = 'Medium High Contrast'

# Create a master focal camera target empty
cam_target = bpy.data.objects.new("CameraTarget", None)
bpy.context.scene.collection.objects.link(cam_target)
cam_target.location = (0.0, -0.22, 1.10)

# ==============================================================================
# 2. DEFINING THE GRECO-ROMAN CLASSICAL BUST (Procedurally generated)
# ==============================================================================
# Establish a grid of metaballs to define classical anatomical features
mball_data = bpy.data.metaballs.new("BustMetaball")
mball_obj = bpy.data.objects.new("Classical_Bust", mball_data)
bpy.context.scene.collection.objects.link(mball_obj)

# Fine resolution for seamless conversion to a high-fidelity mesh
mball_data.resolution = 0.015
mball_data.threshold = 0.6

# Setup elements with classic anatomical coordinates and proportions
elements = [
    # (Co, Radius, Stiffness)
    # Skull
    ((0.0, 0.05, 1.15), 0.38, 1.0),
    ((0.0, 0.15, 1.25), 0.35, 1.0), # occipital protrusion
    # Jaw
    ((0.0, -0.08, 0.95), 0.28, 1.0),
    ((0.0, -0.15, 0.88), 0.24, 1.0),
    # Neck and trunk pillar
    ((0.0, -0.03, 0.70), 0.20, 1.0),
    ((0.0, -0.03, 0.55), 0.20, 1.0),
    # Shoulders (Bust truncation base)
    ((0.0, -0.05, 0.30), 0.35, 1.0),
    ((0.25, -0.05, 0.25), 0.25, 1.0),
    ((-0.25, -0.05, 0.25), 0.25, 1.0),
    # Strongly defined brow ridge
    ((0.0, -0.26, 1.25), 0.12, 1.0),
    ((0.08, -0.24, 1.25), 0.10, 1.0),
    ((-0.08, -0.24, 1.25), 0.10, 1.0),
    # Idealized classical Greek straight nose
    ((0.0, -0.28, 1.20), 0.08, 1.0),
    ((0.0, -0.32, 1.13), 0.07, 1.0),
    ((0.0, -0.36, 1.06), 0.07, 1.0), # nose tip
    # Crisp cheekbones
    ((0.15, -0.18, 1.14), 0.13, 1.0),
    ((-0.15, -0.18, 1.14), 0.13, 1.0),
    # Strong heroic chin
    ((0.0, -0.28, 0.76), 0.11, 1.0),
    # Strong classical lips (philtrum area)
    ((0.0, -0.29, 0.93), 0.08, 1.0),
    ((0.0, -0.28, 0.87), 0.08, 1.0),
    # Sculpted negative eye sockets
    ((0.11, -0.22, 1.19), 0.11, -1.0),
    ((-0.11, -0.22, 1.19), 0.11, -1.0),
    # Blank antique eyeballs
    ((0.11, -0.20, 1.19), 0.07, 1.0),
    ((-0.11, -0.20, 1.19), 0.07, 1.0),
    # Ears
    ((0.34, 0.05, 1.10), 0.11, 1.0),
    ((-0.34, 0.05, 1.10), 0.11, 1.0),
]

# Generate structured curls of hair with real clumped mass
# Fringe & temples
elements.append(((0.0, -0.28, 1.36), 0.09, 1.0))
elements.append(((0.10, -0.26, 1.34), 0.09, 1.0))
elements.append(((-0.10, -0.26, 1.34), 0.09, 1.0))
elements.append(((0.22, -0.22, 1.30), 0.10, 1.0))
elements.append(((-0.22, -0.22, 1.30), 0.10, 1.0))

# Cascading side locks
elements.append(((0.28, -0.15, 1.20), 0.10, 1.0))
elements.append(((-0.28, -0.15, 1.20), 0.10, 1.0))
elements.append(((0.30, -0.06, 1.08), 0.10, 1.0))
elements.append(((-0.30, -0.06, 1.08), 0.10, 1.0))

# Crown arrays defining stylized locks around the head
for angle in [0, 45, 90, 135, 180, 225, 270, 315]:
    rad = math.radians(angle)
    x = math.sin(rad) * 0.28
    y = math.cos(rad) * 0.28 + 0.05
    elements.append(((x, y, 1.40), 0.11, 1.0))
    elements.append(((x * 0.6, y * 0.6, 1.48), 0.10, 1.0))

# Populate the metaball object
for co, radius, stiffness in elements:
    mel = mball_data.elements.new(type='BALL')
    mel.co = co
    mel.radius = radius
    mel.stiffness = stiffness

# Force viewport/scene update to compute the generated geometry
bpy.context.view_layer.update()

# ==============================================================================
# 3. CONVERSION TO MESH & SURFACING CLEANUP (Bust Slicing)
# ==============================================================================
# Convert the active metaball to a beautiful mesh
bpy.context.view_layer.objects.active = mball_obj
mball_obj.select_set(True)
bpy.ops.object.convert(target='MESH')
bust_mesh = bpy.context.view_layer.objects.active

# Create a temporary Boolean cube to cleanly slice the bottom of the bust
bpy.ops.mesh.primitive_cube_add(location=(0.0, 0.0, -0.05))
slice_box = bpy.context.view_layer.objects.active
slice_box.scale = (1.5, 1.5, 0.5) # creates top cut plane at exactly Z=0.45

# Process clean shoulder-base truncation
bpy.context.view_layer.objects.active = bust_mesh
slice_mod = bust_mesh.modifiers.new(name="BustSlice", type='BOOLEAN')
slice_mod.operation = 'DIFFERENCE'
slice_mod.object = slice_box
bpy.ops.object.modifier_apply(modifier="BustSlice")

# Delete temporary slicing geometry
bpy.data.objects.remove(slice_box, do_unlink=True)

# Add smoothing/topology modifiers to blend features and give an organic feel
remesh_mod = bust_mesh.modifiers.new(name="VoxelRemesh", type='REMESH')
remesh_mod.mode = 'VOXEL'
remesh_mod.voxel_size = 0.012
remesh_mod.use_smooth_shade = True

smooth_mod = bust_mesh.modifiers.new(name="AnatomySmooth", type='SMOOTH')
smooth_mod.factor = 1.0
smooth_mod.iterations = 18

subdiv_mod = bust_mesh.modifiers.new(name="Subdiv", type='SUBSURF')
subdiv_mod.levels = 1
subdiv_mod.render_levels = 2

# Apply smooth shading across the sculpture
bpy.ops.object.shade_smooth()

# ==============================================================================
# 4. PEDESTAL & BACKDROP (Atelier setting)
# ==============================================================================
# Clean classical architectural pedestal
# Top Cap
bpy.ops.mesh.primitive_cube_add(location=(0.0, 0.0, 0.32))
ped_cap = bpy.context.view_layer.objects.active
ped_cap.name = "Pedestal_Cap"
ped_cap.scale = (0.28, 0.28, 0.08)

# Center Column Pillar
bpy.ops.mesh.primitive_cylinder_add(radius=0.18, depth=0.74, location=(0.0, 0.0, -0.09))
ped_pillar = bpy.context.view_layer.objects.active
ped_pillar.name = "Pedestal_Pillar"

# Base Platform
bpy.ops.mesh.primitive_cube_add(location=(0.0, 0.0, -0.61))
ped_base = bpy.context.view_layer.objects.active
ped_base.name = "Pedestal_Base"
ped_base.scale = (0.35, 0.35, 0.15)

# Join components into a single stately pedestal
bpy.ops.object.select_all(action='DESELECT')
ped_cap.select_set(True)
ped_pillar.select_set(True)
ped_base.select_set(True)
bpy.context.view_layer.objects.active = ped_cap
bpy.ops.object.join()

ped_obj = ped_cap
ped_obj.name = "Classical_Pedestal"
bpy.ops.object.shade_smooth()

# Give pedestal edges a beautiful architectural chamfer/bevel
bev_mod = ped_obj.modifiers.new(name="PedestalBevel", type='BEVEL')
bev_mod.width = 0.015
bev_mod.segments = 4

# Elegant curves for a physical studio cyclorama backdrop
back_mesh = bpy.data.meshes.new("StudioBackdrop")
back_obj = bpy.data.objects.new("StudioBackdrop", back_mesh)
bpy.context.scene.collection.objects.link(back_obj)

import bmesh
bm = bmesh.new()
bmesh.ops.create_grid(bm, x_segments=16, y_segments=16, size=5.0)
# Bend grid mathematically to create a soft, clean photography curve in the back
for v in bm.verts:
    v.co.x *= 2.0
    if v.co.y > -0.5:
        progress = (v.co.y + 0.5) / 2.0
        v.co.z += (progress ** 2) * 3.2
        v.co.y -= (progress ** 2) * 0.4
    v.co.z -= 0.95 # Aligned precisely beneath the pedestal base
bm.to_mesh(back_mesh)
bm.free()

bpy.context.view_layer.objects.active = back_obj
back_obj.select_set(True)
bpy.ops.object.shade_smooth()

# ==============================================================================
# 5. PROCEDURAL CAST PLASTER SHADER (With depth, mold seams, SSS, and dust)
# ==============================================================================
mat_plaster = bpy.data.materials.new(name="Atelier_Plaster")
mat_plaster.use_nodes = True
nodes = mat_plaster.node_tree.nodes
links = mat_plaster.node_tree.links
nodes.clear()

# Output Node
node_out = nodes.new('ShaderNodeOutputMaterial')
node_out.location = (850, 0)

# Principled BSDF for core plaster material
node_bsdf = nodes.new('ShaderNodeBsdfPrincipled')
node_bsdf.location = (500, 0)
node_bsdf.inputs['Base Color'].default_value = (0.91, 0.90, 0.88, 1.0)
node_bsdf.inputs['Roughness'].default_value = 0.72
node_bsdf.inputs['Specular IOR Level'].default_value = 0.25
# Subsurface scattering properties for plaster depth
node_bsdf.inputs['Subsurface Weight'].default_value = 0.18
node_bsdf.inputs['Subsurface Color'].default_value = (0.95, 0.91, 0.86, 1.0)
node_bsdf.inputs['Subsurface Radius'].default_value = (0.12, 0.09, 0.07)
node_bsdf.inputs['Subsurface Scale'].default_value = 0.08
links.new(node_bsdf.outputs['BSDF'], node_out.inputs['Surface'])

# Ambient Occlusion node for 'dust-grey' inside folds & crevices
node_ao = nodes.new('ShaderNodeAmbientOcclusion')
node_ao.location = (-100, 150)
node_ao.inputs['Distance'].default_value = 0.12

node_ao_ramp = nodes.new('ShaderNodeValToColor')
node_ao_ramp.location = (150, 150)
node_ao_ramp.color_ramp.elements[0].position = 0.0
node_ao_ramp.color_ramp.elements[0].color = (0.56, 0.54, 0.51, 1.0) # Dusty grey
node_ao_ramp.color_ramp.elements[1].position = 0.45
node_ao_ramp.color_ramp.elements[1].color = (0.91, 0.90, 0.88, 1.0) # White plaster
links.new(node_ao.outputs['Color'], node_ao_ramp.inputs['Fac'])
links.new(node_ao_ramp.outputs['Color'], node_bsdf.inputs['Base Color'])

# Tactile plaster texture bump
node_fine_noise = nodes.new('ShaderNodeTexNoise')
node_fine_noise.location = (-100, -150)
node_fine_noise.inputs['Scale'].default_value = 450.0
node_fine_noise.inputs['Detail'].default_value = 12.0
node_fine_noise.inputs['Roughness'].default_value = 0.65

# Mold Seam implementation (linear seam down X=0 with subtle hand-carved wobble)
node_tex_coord = nodes.new('ShaderNodeTexCoord')
node_tex_coord.location = (-750, -400)

node_wobble_noise = nodes.new('ShaderNodeTexNoise')
node_wobble_noise.location = (-550, -400)
node_wobble_noise.inputs['Scale'].default_value = 10.0
node_wobble_noise.inputs['Detail'].default_value = 2.0

node_wobble_scale = nodes.new('ShaderNodeVectorMath')
node_wobble_scale.location = (-350, -550)
node_wobble_scale.operation = 'SCALE'
node_wobble_scale.inputs[3].default_value = 0.004

node_vec_math = nodes.new('ShaderNodeVectorMath')
node_vec_math.location = (-150, -400)
node_vec_math.operation = 'ADD'

node_separate = nodes.new('ShaderNodeSeparateXYZ')
node_separate.location = (50, -400)

node_math_abs = nodes.new('ShaderNodeMath')
node_math_abs.location = (250, -400)
node_math_abs.operation = 'ABSOLUTE'

node_seam_ramp = nodes.new('ShaderNodeValToColor')
node_seam_ramp.location = (450, -400)
node_seam_ramp.color_ramp.elements[0].position = 0.0
node_seam_ramp.color_ramp.elements[0].color = (1.0, 1.0, 1.0, 1.0)
node_seam_ramp.color_ramp.elements[1].position = 0.003
node_seam_ramp.color_ramp.elements[1].color = (0.0, 0.0, 0.0, 1.0)

# Connect Mold Seam Nodes
links.new(node_tex_coord.outputs['Object'], node_vec_math.inputs[0])
links.new(node_wobble_noise.outputs['Color'], node_wobble_scale.inputs[0])
links.new(node_wobble_scale.outputs['Vector'], node_vec_math.inputs[1])
links.new(node_vec_math.outputs['Vector'], node_separate.inputs['Vector'])
links.new(node_separate.outputs['X'], node_math_abs.inputs[0])
links.new(node_math_abs.outputs['Value'], node_seam_ramp.inputs['Fac'])

# Multi-bump Normal maps (combining fine tactile texture and mold seam)
node_bump_fine = nodes.new('ShaderNodeBump')
node_bump_fine.location = (150, -150)
node_bump_fine.inputs['Strength'].default_value = 0.015
node_bump_fine.inputs['Scale'].default_value = 0.08
links.new(node_fine_noise.outputs['Fac'], node_bump_fine.inputs['Height'])

node_bump_seam = nodes.new('ShaderNodeBump')
node_bump_seam.location = (350, -150)
node_bump_seam.inputs['Strength'].default_value = 0.18
node_bump_seam.inputs['Scale'].default_value = 1.0
links.new(node_seam_ramp.outputs['Value'], node_bump_seam.inputs['Height'])

links.new(node_bump_fine.outputs['Normal'], node_bump_seam.inputs['Normal'])
links.new(node_bump_seam.outputs['Normal'], node_bsdf.inputs['Normal'])

# Assign Material to bust
bust_mesh.data.materials.append(mat_plaster)

# Dark Slate-like Material for the pedestal to contrast the sculpture
mat_pedestal = bpy.data.materials.new(name="PedestalStone")
mat_pedestal.use_nodes = True
p_nodes = mat_pedestal.node_tree.nodes
p_links = mat_pedestal.node_tree.links
p_nodes.clear()

p_out = p_nodes.new('ShaderNodeOutputMaterial')
p_bsdf = p_nodes.new('ShaderNodeBsdfPrincipled')
p_bsdf.inputs['Base Color'].default_value = (0.16, 0.15, 0.15, 1.0)
p_bsdf.inputs['Roughness'].default_value = 0.55
p_bsdf.inputs['Specular IOR Level'].default_value = 0.35
p_links.new(p_bsdf.outputs['BSDF'], p_out.inputs['Surface'])

p_noise = p_nodes.new('ShaderNodeTexNoise')
p_noise.inputs['Scale'].default_value = 200.0
p_bump = p_nodes.new('ShaderNodeBump')
p_bump.inputs['Strength'].default_value = 0.04
p_links.new(p_noise.outputs['Fac'], p_bump.inputs['Height'])
p_links.new(p_bump.outputs['Normal'], p_bsdf.inputs['Normal'])

ped_obj.data.materials.append(mat_pedestal)

# Matte deep gray paper backdrop material
mat_backdrop = bpy.data.materials.new(name="BackdropMat")
mat_backdrop.use_nodes = True
b_nodes = mat_backdrop.node_tree.nodes
b_nodes.clear()

b_out = b_nodes.new('ShaderNodeOutputMaterial')
b_bsdf = b_nodes.new('ShaderNodeBsdfPrincipled')
b_bsdf.inputs['Base Color'].default_value = (0.07, 0.07, 0.08, 1.0)
b_bsdf.inputs['Roughness'].default_value = 0.98   # matte surface to diffuse reflections
b_bsdf.inputs['Specular IOR Level'].default_value = 0.0
b_mat_tree = mat_backdrop.node_tree
b_mat_tree.links.new(b_bsdf.outputs['BSDF'], b_out.inputs['Surface'])

back_obj.data.materials.append(mat_backdrop)

# ==============================================================================
# 6. STUDIO LIGHTING (Drawing academy setup)
# ==============================================================================
# Soft key light casting a dramatic terminator line
key_light_data = bpy.data.lights.new(name="KeyLight", type='AREA')
key_light_data.energy = 180.0
key_light_data.size = 0.9
key_light_data.color = (1.0, 0.98, 0.96)
key_light_obj = bpy.data.objects.new(name="KeyLight", object_data=key_light_data)
bpy.context.scene.collection.objects.link(key_light_obj)
key_light_obj.location = (1.6, -1.8, 2.3)

track_key = key_light_obj.constraints.new(type='TRACK_TO')
track_key.target = cam_target
track_key.track_axis = 'TRACK_NEGATIVE_Z'
track_key.up_axis = 'UP_Y'

# Delicate bounce fill light keeping details visible on the shaded side
fill_light_data = bpy.data.lights.new(name="FillLight", type='AREA')
fill_light_data.energy = 22.0
fill_light_data.size = 1.6
fill_light_data.color = (0.92, 0.95, 1.0)
fill_light_obj = bpy.data.objects.new(name="FillLight", object_data=fill_light_data)
bpy.context.scene.collection.objects.link(fill_light_obj)
fill_light_obj.location = (-1.8, -1.4, 0.9)

track_fill = fill_light_obj.constraints.new(type='TRACK_TO')
track_fill.target = cam_target
track_fill.track_axis = 'TRACK_NEGATIVE_Z'
track_fill.up_axis = 'UP_Y'

# Rim light for clean silhouette separation against the dark backdrop
rim_light_data = bpy.data.lights.new(name="RimLight", type='AREA')
rim_light_data.energy = 30.0
rim_light_data.size = 0.8
rim_light_data.color = (1.0, 1.0, 1.0)
rim_light_obj = bpy.data.objects.new(name="RimLight", object_data=rim_light_data)
bpy.context.scene.collection.objects.link(rim_light_obj)
rim_light_obj.location = (-0.9, 1.6, 1.8)

track_rim = rim_light_obj.constraints.new(type='TRACK_TO')
track_rim.target = cam_target
track_rim.track_axis = 'TRACK_NEGATIVE_Z'
track_rim.up_axis = 'UP_Y'

# ==============================================================================
# 7. PORTRAIT CAMERA & RENDERING COMPOSITION
# ==============================================================================
cam_data = bpy.data.cameras.new(name="AtelierPortraitCam")
cam_obj = bpy.data.objects.new(name="AtelierPortraitCam", object_data=cam_data)
bpy.context.scene.collection.objects.link(cam_obj)

# Camera positioned at portrait eye level in three-quarter view
cam_obj.location = (0.82, -2.05, 1.22)
cam_data.lens = 95.0 # Noble portrait lenses representation to keep ratios flat

# Constraint to always focus on face center
track_cam = cam_obj.constraints.new(type='TRACK_TO')
track_cam.target = cam_target
track_cam.track_axis = 'TRACK_NEGATIVE_Z'
track_cam.up_axis = 'UP_Y'

# Shallow Depth of Field for realistic catalog photorealism
cam_data.dof.use_dof = True
cam_data.dof.focus_object = cam_target
cam_data.dof.aperture_fstop = 5.0

# Set active camera
bpy.context.scene.camera = cam_obj
```