doc = ezdxf.readfile(filename)

doc = ezdxf.readzip(zipfilename[, filename])

doc.saveas('new_name.dxf')

doc.save()

doc = ezdxf.new()

doc = ezdxf.new('R12')

doc = ezdxf.new(setup=True)

msp = doc.modelspace()

psp = doc.layout('Layout1')

blk = doc.blocks.get('NAME')

my_block = doc.blocks.new('MyBlock')

lines = msp.query('LINE[layer=="MyLayer"]')

all_lines_by_color = msp.query('LINE').groupby('color')
lines_with_color_1 = all_lines_by_color.get(1, [])

layer = entity.dxf.layer  # default is '0'
color = entity.dxf.color  # default is 256 = BYLAYER

entity.dxf.hasattr('true_color')

entity.dxf.get('true_color', 0)

msp = doc.modelspace()
msp.add_line((0, 0), (1, 0), dxfattribs={'layer': 'MyLayer'})

msp.add_blockref('MyBlock')

my_layer = doc.layer.new('MyLayer')

my_layer.color = 1

my_layer.off()

line = msp.add_line((0, 0), (1, 0))
msp.delete_entity(line)

line.destroy()

doc = ezdxf.new('R2007', setup=True)

# circle is an DXF entity with extrusion != (0, 0, 1)
ocs = circle.ocs()
wcs_center = ocs.to_wcs(circle.dxf.center)

Az = Vector(entity.dxf.extrusion).normalize()  # normal (extrusion) vector
# Extrusion vector normalization should not be necessary, but don't rely on any DXF content
if (abs(Az.x) < 1/64.) and (abs(Az.y) < 1/64.):


     Ax = Vector(0, 1, 0).cross(Az).normalize()  # the cross-product operator
else:


     Ax = Vector(0, 0, 1).cross(Az).normalize()  # the cross-product operator
Ay = Az.cross(Ax).normalize()

def wcs_to_ocs(point):


    px, py, pz = Vector(point)  # point in WCS


    x = px * Ax.x + py * Ax.y + pz * Ax.z


    y = px * Ay.x + py * Ay.y + pz * Ay.z


    z = px * Az.x + py * Az.y + pz * Az.z


    return Vector(x, y, z)

Wx = wcs_to_ocs((1, 0, 0))
Wy = wcs_to_ocs((0, 1, 0))
Wz = wcs_to_ocs((0, 0, 1))
def ocs_to_wcs(point):


    px, py, pz = Vector(point)  # point in OCS


    x = px * Wx.x + py * Wx.y + pz * Wx.z


    y = px * Wy.x + py * Wy.y + pz * Wy.z


    z = px * Wz.x + py * Wz.y + pz * Wz.z


    return Vector(x, y, z)

import sys
import ezdxf
try:


    doc = ezdxf.readfile("your_dxf_file.dxf")
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
except ezdxf.DXFStructureError:


    print(f'Invalid or corrupted DXF file.')


    sys.exit(2)

# iterate over all entities in modelspace
msp = doc.modelspace()
for e in msp:


    if e.dxftype() == 'LINE':


        print_entity(e)
# entity query for all LINE entities in modelspace
for e in msp.query('LINE'):


    print_entity(e)
def print_entity(e):


    print("LINE on layer: %s\n" % e.dxf.layer)


    print("start point: %s\n" % e.dxf.start)


    print("end point: %s\n" % e.dxf.end)

e.dxf.layer  # layer of the entity as string
e.dxf.color  # color of the entity as integer

# If DXF attribute 'paperspace' does not exist, the entity defaults
# to modelspace:
p = e.get_dxf_attrib('paperspace', 0)

paperspace = doc.layout('layout0')

msp = doc.modelspace()
lines = msp.query('LINE')

construction_lines = lines.query('*[layer=="construction"]')

lines = msp.query('LINE[layer=="construction"]')

lines_and_circles = doc.entities.query('LINE CIRCLE[layer=="construction"]')

not_dashed_entities = msp.query('*[layer=="construction" and linetype!="DASHED"]')

from ezdxf.groupby import groupby
group = groupby(entities=msp, dxfattrib='layer')

group = msp.groupby(dxfattrib='layer')
for layer, entities in group.items():


    print(f'Layer "{layer}" contains following entities:')


    for entity in entities:


        print('    {}'.format(str(entity)))


    print('-'*40)

def layer_and_color_key(entity):


    # return None to exclude entities from result container


    if entity.dxf.layer == '0':  # exclude entities from default layer '0'


        return None


    else:


        return entity.dxf.layer, entity.dxf.color
group = msp.groupby(key=layer_and_color_key)
for key, entities in group.items():


    print(f'Grouping criteria "{key}" matches following entities:')


    for entity in entities:


        print('    {}'.format(str(entity)))


    print('-'*40)

import ezdxf
doc = ezdxf.new('R2010')  # create a new DXF R2010 drawing, official DXF version name: 'AC1024'
msp = doc.modelspace()  # add new entities to the modelspace
msp.add_line((0, 0), (10, 0))  # add a LINE entity
doc.saveas('line.dxf')

import ezdxf
doc = ezdxf.new(setup=True)  # setup required line types
msp = doc.modelspace()
doc.layers.new(name='MyLines', dxfattribs={'linetype': 'DASHED', 'color': 7})

msp.add_line((0, 0), (10, 0), dxfattribs={'layer': 'MyLines'})

my_lines = doc.layers.get('MyLines')

my_lines.is_off()  # True if layer is off
my_lines.is_on()   # True if layer is on
my_lines.is_locked()  # True if layer is locked
layer_name = my_lines.dxf.name  # get the layer name

# switch layer off, entities at this layer will not shown in CAD applications/viewers
my_lines.off()
# lock layer, entities at this layer are not editable in CAD applications
my_lines.lock()

my_lines.dxf.linetype = 'DOTTED'
my_lines.color = 13  # preserves on/off state of layer

# iteration
for layer in doc.layers:


    if layer.dxf.name != '0':


        layer.off()  # switch all layers off except layer '0'
# check for existing layer definition
if 'MyLines' in doc.layers:


    layer = doc.layers.get('MyLines')
layer_count = len(doc.layers) # total count of layer definitions

doc.layers.remove('MyLines')

import ezdxf
import random  # needed for random placing points
def get_random_point():


    """Returns random x, y coordinates."""


    x = random.randint(-100, 100)


    y = random.randint(-100, 100)


    return x, y
# Create a new drawing in the DXF format of AutoCAD 2010
doc = ezdxf.new('R2010')
# Create a block with the name 'FLAG'
flag = doc.blocks.new(name='FLAG')
# Add DXF entities to the block 'FLAG'.
# The default base point (= insertion point) of the block is (0, 0).
flag.add_lwpolyline([(0, 0), (0, 5), (4, 3), (0, 3)])  # the flag symbol as 2D polyline
flag.add_circle((0, 0), .4, dxfattribs={'color': 2})  # mark the base point with a circle

# Get the modelspace of the drawing.
msp = doc.modelspace()
# Get 50 random placing points.
placing_points = [get_random_point() for _ in range(50)]
for point in placing_points:


    # Every flag has a different scaling and a rotation of -15 deg.


    random_scale = 0.5 + random.random() * 2.0


    # Add a block reference to the block named 'FLAG' at the coordinates 'point'.


    msp.add_blockref('FLAG', point, dxfattribs={


        'xscale': random_scale,


        'yscale': random_scale,


        'rotation': -15


    })
# Save the drawing.
doc.saveas("blockref_tutorial.dxf")

for flag_ref in msp.query('INSERT[name=="FLAG"]'):


    print(str(flag_ref))

# Define some attributes for the block 'FLAG', placed relative
# to the base point, (0, 0) in this case.
flag.add_attdef('NAME', (0.5, -0.5), dxfattribs={'height': 0.5, 'color': 3})
flag.add_attdef('XPOS', (0.5, -1.0), dxfattribs={'height': 0.25, 'color': 4})
flag.add_attdef('YPOS', (0.5, -1.5), dxfattribs={'height': 0.25, 'color': 4})
# Get another 50 random placing points.
placing_points = [get_random_point() for _ in range(50)]
for number, point in enumerate(placing_points):


    # values is a dict with the attribute tag as item-key and


    # the attribute text content as item-value.


    values = {


        'NAME': "P(%d)" % (number + 1),


        'XPOS': "x = %.3f" % point[0],


        'YPOS': "y = %.3f" % point[1]


    }


    # Every flag has a different scaling and a rotation of +15 deg.


    random_scale = 0.5 + random.random() * 2.0


    blockref = msp.add_blockref('FLAG', point, dxfattribs={


        'rotation': 15


    }).set_scale(random_scale)


    blockref.add_auto_attribs(values)
# Save the drawing.
doc.saveas("auto_blockref_tutorial.dxf")

# Collect all anonymous block references starting with '*U'
anonymous_block_refs = modelspace.query('INSERT[name ? "^\*U.+"]')
# Collect real references to 'FLAG'
flag_refs = []
for block_ref in anonymous_block_refs:


    # Get the block layout of the anonymous block


    block = doc.blocks.get(block_ref.dxf.name)


    # Find all block references to 'FLAG' in the anonymous block


    flag_refs.extend(block.query('INSERT[name=="FLAG"]'))
# Evaluation example: collect all flag names.
flag_numbers = [flag.get_attrib_text('NAME') for flag in flag_refs if flag.has_attrib('NAME')]
print(flag_numbers)

for flag_ref in msp.query('INSERT[name=="FLAG"]'):


    flag_ref.explode()

for flag_ref in msp.query('INSERT[name=="FLAG"]'):


    for entity in flag_ref.virtual_entities():


        if entity.dxftype() == 'LWPOLYLINE':


            print(f'Found {str(entity)}.')

import ezdxf
doc = ezdxf.new('R2000')
msp = doc.modelspace()
points = [(0, 0), (3, 0), (6, 3), (6, 6)]
msp.add_lwpolyline(points)
doc.saveas("lwpolyline1.dxf")

doc = ezdxf.readfile("lwpolyline1.dxf")
msp = doc.modelspace()
line = msp.query('LWPOLYLINE')[0]  # take first LWPolyline
line.append_points([(8, 7), (10, 7)])
doc.saveas("lwpolyline2.dxf")

first_point = line[0]
x, y, start_width, end_width, bulge = first_point

doc = ezdxf.readfile("lwpolyline2.dxf")
msp = doc.modelspace()
line = msp.query('LWPOLYLINE').first # take first LWPolyline, 'first' was introduced with v0.10
with line.points('xyseb') as points:


    # points is a standard python list


    # existing points are 5-tuples, but new points can be


    # set as (x, y, [start_width, [end_width, [bulge]]]) tuple


    # set start_width, end_width to 0 to be ignored (x, y, 0, 0, bulge).


    del points[-2:]  # delete last 2 points


    points.extend([(4, 7), (0, 7)])  # adding 2 other points


    # the same as one command


    # points[-2:] = [(4, 7), (0, 7)]
doc.saveas("lwpolyline3.dxf")

doc = ezdxf.new('R2000')
msp = doc.modelspace()
# point format = (x, y, [start_width, [end_width, [bulge]]])
# set start_width, end_width to 0 to be ignored (x, y, 0, 0, bulge).
points = [(0, 0, .1, .15), (3, 0, .2, .25), (6, 3, .3, .35), (6, 6)]
msp.add_lwpolyline(points)
doc.saveas("lwpolyline4.dxf")

del line.dxf.const_width # no exception will be raised if const_width is already unset

doc = ezdxf.new('R2000')
msp = doc.modelspace()
# point format = (x, y, [start_width, [end_width, [bulge]]])
# set start_width, end_width to 0 to be ignored (x, y, 0, 0, bulge).
points = [(0, 0, 0, .05), (3, 0, .1, .2, -.5), (6, 0, .1, .05), (9, 0)]
msp.add_lwpolyline(points)
doc.saveas("lwpolyline5.dxf")

msp.add_lwpolyline([(0, 0, 0), (10, 0, 1), (20, 0, 0)], format='xyb')
msp.add_lwpolyline([(0, 10, 0), (10, 10, .5), (20, 10, 0)], format='xyb')

import ezdxf
# TEXT is a basic entity and is supported by every DXF version.
# Argument setup=True for adding standard linetypes and text styles.
doc = ezdxf.new('R12', setup=True)
msp = doc.modelspace()
# use set_pos() for proper TEXT alignment:
# The relations between DXF attributes 'halign', 'valign',
# 'insert' and 'align_point' are tricky.
msp.add_text("A Simple Text").set_pos((2, 3), align='MIDDLE_RIGHT')
# Using a text style
msp.add_text("Text Style Example: Liberation Serif",


             dxfattribs={


                 'style': 'LiberationSerif',


                 'height': 0.35}


             ).set_pos((2, 6), align='LEFT')
doc.saveas("simple_text.dxf")

doc = ezdxf.new('R12', setup=True)

doc.styles.new('myStandard', dxfattribs={'font' : 'OpenSans-Regular.ttf'})

import ezdxf
doc = ezdxf.new('R2007', setup=True)
msp = doc.modelspace()
lorem_ipsum = """
Lorem ipsum dolor sit amet, consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit
esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia
deserunt mollit anim id est laborum.
"""

# store MText entity for additional manipulations
mtext = msp.add_mtext(lorem_ipsum, dxfattribs={'style': 'OpenSans'})

mtext.text += 'Append additional text to the MText entity.'
# even shorter with __iadd__() support:
mtext += 'Append additional text to the MText entity.'

mtext.dxf.char_height = 0.5

mtext.dxf.width = 60

mtext.text = "{\\C1red text} - {\\C3green text} - {\\C5blue text}"

# the space ' ' in front of 'Lower' anr the ';' behind 'Lower' are necessary
# combined with vertical center alignment
mtext.text = "\\A1\\SUpper^ Lower; - \\SUpper/ Lower;} - \\SUpper# Lower;"

mtext.set_bg_color(2, scale=1.5)

doc = ezdxf.new('R2000')
fit_points = [(0, 0, 0), (750, 500, 0), (1750, 500, 0), (2250, 1250, 0)]
msp = doc.modelspace()
spline = msp.add_spline(fit_points)

# fit_points, control_points, knots and weights are list-like containers:
spline.fit_points.append((2250, 2500, 0))

doc = ezdxf.readfile("AutoCAD_generated.dxf")
msp = doc.modelspace()
spline = msp.query('SPLINE').first
# fit_points, control_points, knots and weights are list-like objects:
spline.fit_points.append((2250, 2500, 0))

# current control points do not match spline defined by fit points
spline.control_points = []
# count of knots is not correct:
# count of knots = count of control points + degree + 1
spline.knots = []
# same for weights, count of weights == count of control points
spline.weights = []

msp.add_spline_control_frame(fit_points, method='uniform', dxfattribs={'color': 1})
msp.add_spline_control_frame(fit_points, method='chord', dxfattribs={'color': 3})
msp.add_spline_control_frame(fit_points, method='centripetal', dxfattribs={'color': 5})

control_points = [(0, 0, 0), (1250, 1560, 0), (3130, 610, 0), (2250, 1250, 0)]
msp.add_open_spline(control_points)

msp.add_closed_spline(control_points)

msp.add_closed_rational_spline(control_points, weights=[3, 1, 1, 1])

if spline.closed:


    # this spline is closed


    pass
# close spline
spline.closed = True
# open spline
spline.closed = False

spline.dxf.start_tangent = (0, 1, 0)  # in y-axis
spline.dxf.end_tangent = (1, 0, 0)  # in x-axis

count = spline.dxf.n_fit_points
count = spline.dxf.n_control_points
count = spline.dxf.n_knots

count = spline.fit_point_count
count = spline.control_point_count
count = spline.knot_count

import ezdxf
# 8 corner vertices
cube_vertices = [


    (0, 0, 0),


    (1, 0, 0),


    (1, 1, 0),


    (0, 1, 0),


    (0, 0, 1),


    (1, 0, 1),


    (1, 1, 1),


    (0, 1, 1),
]
# 6 cube faces
cube_faces = [


    [0, 1, 2, 3],


    [4, 5, 6, 7],


    [0, 1, 5, 4],


    [1, 2, 6, 5],


    [3, 2, 6, 7],


    [0, 3, 7, 4]
]
doc = ezdxf.new('R2000')  # MESH requires DXF R2000 or later
msp = doc.modelspace()
mesh = msp.add_mesh()
mesh.dxf.subdivision_levels = 0  # do not subdivide cube, 0 is the default value
with mesh.edit_data() as mesh_data:


    mesh_data.vertices = cube_vertices


    mesh_data.faces = cube_faces
doc.saveas("cube_mesh_1.dxf")

import ezdxf
# 8 corner vertices
p = [


    (0, 0, 0),


    (1, 0, 0),


    (1, 1, 0),


    (0, 1, 0),


    (0, 0, 1),


    (1, 0, 1),


    (1, 1, 1),


    (0, 1, 1),
]
doc = ezdxf.new('R2000')  # MESH requires DXF R2000 or later
msp = doc.modelspace()
mesh = msp.add_mesh()
with mesh.edit_data() as mesh_data:


    mesh_data.add_face([p[0], p[1], p[2], p[3]])


    mesh_data.add_face([p[4], p[5], p[6], p[7]])


    mesh_data.add_face([p[0], p[1], p[5], p[4]])


    mesh_data.add_face([p[1], p[2], p[6], p[5]])


    mesh_data.add_face([p[3], p[2], p[6], p[7]])


    mesh_data.add_face([p[0], p[3], p[7], p[4]])


    mesh_data.optimize()  # optional, minimizes vertex count
doc.saveas("cube_mesh_2.dxf")

import ezdxf
doc = ezdxf.new('R2000')  # hatch requires the DXF R2000 (AC1015) format or later
msp = doc.modelspace()  # adding entities to the model space
hatch = msp.add_hatch(color=2)  # by default a solid fill hatch with fill color=7 (white/black)
# every boundary path is always a 2D element
# vertex format for the polyline path is: (x, y[, bulge])
# there are no bulge values in this example
hatch.paths.add_polyline_path([(0, 0), (10, 0), (10, 10), (0, 10)], is_closed=1)
doc.saveas("solid_hatch_polyline_path.dxf")

import ezdxf
doc = ezdxf.new('R2000')  # hatch requires the DXF R2000 (AC1015) format or later
msp = doc.modelspace()  # adding entities to the model space
hatch = msp.add_hatch(color=2)  # by default a solid fill hatch with fill color=7 (white/black)
# every boundary path is always a 2D element
# vertex format for the polyline path is: (x, y[, bulge])
# bulge value 1 = an arc with diameter=10 (= distance to next vertex * bulge value)
# bulge value > 0 ... arc is right of line
# bulge value < 0 ... arc is left of line
hatch.paths.add_polyline_path([(0, 0, 1), (10, 0), (10, 10, -0.5), (0, 10)], is_closed=1)
doc.saveas("solid_hatch_polyline_path_with_bulge.dxf")

import ezdxf
doc = ezdxf.new('R2000')  # hatch requires the DXF R2000 (AC1015) format or later
msp = doc.modelspace()  # adding entities to the model space
# important: major axis >= minor axis (ratio <= 1.)
# minor axis length = major axis length * ratio
msp.add_ellipse((0, 0), major_axis=(0, 10), ratio=0.5)
# by default a solid fill hatch with fill color=7 (white/black)
hatch = msp.add_hatch(color=2)
# every boundary path is always a 2D element
edge_path = hatch.paths.add_edge_path()
# each edge path can contain line arc, ellipse and spline elements
# important: major axis >= minor axis (ratio <= 1.)
edge_path.add_ellipse((0, 0), major_axis=(0, 10), ratio=0.5)
doc.saveas("solid_hatch_ellipse.dxf")

hatch = msp.add_hatch(color=1, dxfattribs={


    'hatch_style': 0,


    # 0 = nested


    # 1 = outer


    # 2 = ignore
})
# The first path has to set flag: 1 = external
# flag const.BOUNDARY_PATH_POLYLINE is added (OR) automatically
hatch.paths.add_polyline_path([(0, 0), (10, 0), (10, 10), (0, 10)], is_closed=1, flags=1)

# The second path has to set flag: 16 = outermost
hatch.paths.add_polyline_path([(1, 1), (9, 1), (9, 9), (1, 9)], is_closed=1, flags=16)

# The third path has to set flag: 0 = default
hatch.paths.add_polyline_path([(2, 2), (8, 2), (8, 8), (2, 8)], is_closed=1, flags=0)

# The forth path has to set flag: 0 = default, and so on
hatch.paths.add_polyline_path([(3, 3), (7, 3), (7, 7), (3, 7)], is_closed=1, flags=0)

hatch = msp.add_hatch(color=1)
# 1. polyline path
hatch.paths.add_polyline_path([


    (240, 210, 0),


    (0, 210, 0),


    (0, 0, 0.),


    (240, 0, 0),
],


    is_closed=1,


    flags=1,
)
# 2. edge path
edge_path = hatch.paths.add_edge_path(flags=16)
edge_path.add_spline(


    control_points=[


        (126.658105895725, 177.0823706957212),


        (141.5497003747484, 187.8907860433995),


        (205.8997365206943, 154.7946313459515),


        (113.0168862297068, 117.8189380884978),


        (202.9816918983783, 63.17222935389572),


        (157.363511042264, 26.4621294342132),


        (144.8204003260554, 28.4383294369643)


    ],


    knot_values=[


        0.0, 0.0, 0.0, 0.0, 55.20174685732758, 98.33239645153571,


        175.1126541251052, 213.2061566683142, 213.2061566683142,


        213.2061566683142, 213.2061566683142


    ],
)
edge_path.add_arc(


    center=(152.6378550678883, 128.3209356351659),


    radius=100.1880612627354,


    start_angle=94.4752130054052,


    end_angle=177.1345242028005,
)
edge_path.add_line(


    (52.57506282464041, 123.3124200796114),


    (126.658105895725, 177.0823706957212)
)

# Create base geometry
lwpolyline = msp.add_lwpolyline(


    [(0, 0, 0), (10, 0, .5), (10, 10, 0), (0, 10, 0)],


    format='xyb',


    dxfattribs={'closed': True},
)
hatch = msp.add_hatch(color=1)
path = hatch.paths.add_polyline_path(


    # get path vertices from associated LWPOLYLINE entity


    lwpolyline.get_points(format='xyb'),


    # get closed state also from associated LWPOLYLINE entity


    is_closed=lwpolyline.closed,
)
# Set association between boundary path and LWPOLYLINE
hatch.associate(path, [lwpolyline])

hatch.set_pattern_fill('ANSI31', scale=0.5)

import ezdxf
doc = ezdxf.new('AC1015')  # image requires the DXF R2000 format or later
my_image_def = doc.add_image_def(filename='mycat.jpg', size_in_pixel=(640, 360))
# The IMAGEDEF entity is like a block definition, it just defines the image
msp = doc.modelspace()
# add first image
msp.add_image(insert=(2, 1), size_in_units=(6.4, 3.6), image_def=my_image_def, rotation=0)
# The IMAGE entity is like the INSERT entity, it creates an image reference,
# and there can be multiple references to the same picture in a drawing.
msp.add_image(insert=(4, 5), size_in_units=(3.2, 1.8), image_def=my_image_def, rotation=30)
# get existing image definitions, Important: IMAGEDEFs resides in the objects section
image_defs = doc.objects.query('IMAGEDEF')  # get all image defs in drawing
doc.saveas("dxf_with_cat.dxf")

import ezdxf
doc = ezdxf.new('AC1015')  # underlay requires the DXF R2000 format or later
my_underlay_def = doc.add_underlay_def(filename='my_underlay.pdf', name='1')
# The (PDF)DEFINITION entity is like a block definition, it just defines the underlay
# 'name' is misleading, because it defines the page/sheet to be displayed
# PDF: name is the page number to display
# DGN: name='default' ???
# DWF: ????
msp = doc.modelspace()
# add first underlay
msp.add_underlay(my_underlay_def, insert=(2, 1, 0), scale=0.05)
# The (PDF)UNDERLAY entity is like the INSERT entity, it creates an underlay reference,
# and there can be multiple references to the same underlay in a drawing.
msp.add_underlay(my_underlay_def, insert=(4, 5, 0), scale=.5, rotation=30)
# get existing underlay definitions, Important: UNDERLAYDEFs resides in the objects section
pdf_defs = doc.objects.query('PDFDEFINITION')  # get all pdf underlay defs in drawing
doc.saveas("dxf_with_underlay.dxf")

elements = [total_pattern_length, elem1, elem2, ...]

import ezdxf
from ezdxf.tools.standards import linetypes  # some predefined line types
doc = ezdxf.new()
msp = modelspace()
my_line_types = [


    ("DOTTED", "Dotted .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .", [0.2, 0.0, -0.2]),


    ("DOTTEDX2", "Dotted (2x) .    .    .    .    .    .    .    . ", [0.4, 0.0, -0.4]),


    ("DOTTED2", "Dotted (.5) . . . . . . . . . . . . . . . . . . . ", [0.1, 0.0, -0.1]),
]
for name, desc, pattern in my_line_types:


    if name not in doc.linetypes:


        doc.linetypes.new(name=name, dxfattribs={'description': desc, 'pattern': pattern})

for name, desc, pattern in linetypes():


    if name not in doc.linetypes:


        doc.linetypes.new(name=name, dxfattribs={'description': desc, 'pattern': pattern})

# iteration
print('available line types:')
for linetype in doc.linetypes:


    print('{}: {}'.format(linetype.dxf.name, linetype.dxf.description))
# check for existing line type
if 'DOTTED' in doc.linetypes:


    pass
count = len(doc.linetypes) # total count of linetypes

doc.layers.remove('DASHED')

doc = ezdxf.new('R2018')  # DXF R13 or later is required
doc.linetypes.new('GASLEITUNG2', dxfattribs={


    'description': 'Gasleitung2 ----GAS----GAS----GAS----GAS----GAS----GAS--',


    'length': 1,  # required for complex line types


    # line type definition in acadlt.lin:


    'pattern': 'A,.5,-.2,["GAS",STANDARD,S=.1,U=0.0,X=-0.1,Y=-.05],-.25',
})

doc.linetypes.new('GRENZE2', dxfattribs={


    'description': 'Grenze eckig ----[]-----[]----[]-----[]----[]--',


    'length': 1.45,  # required for complex line types


    # line type definition in acadlt.lin:


    # A,.25,-.1,[BOX,ltypeshp.shx,x=-.1,s=.1],-.1,1


    # replacing BOX by shape index 132 (got index from an AutoCAD file),


    # ezdxf can't get shape index from ltypeshp.shx


    'pattern': 'A,.25,-.1,[132,ltypeshp.shx,x=-.1,s=.1],-.1,1',
})

This edition shows the hard way to accomplish the transformations by low level operations.

import ezdxf
from ezdxf.math import OCS
doc = ezdxf.new('R2010')
msp = doc.modelspace()
# For this example the OCS is rotated around x-axis about 45 degree
# OCS z-axis: x=0, y=1, z=1
# extrusion vector must not normalized here
ocs = OCS((0, 1, 1))
msp.add_circle(


    # You can place the 2D circle in 3D space


    # but you have to convert WCS into OCS


    center=ocs.from_wcs((0, 2, 2)),


    # center in OCS: (0.0, 0.0, 2.82842712474619)


    radius=1,


    dxfattribs={


        # here the extrusion vector should be normalized,


        # which is granted by using the ocs.uz


        'extrusion': ocs.uz,


        'color': 1,


    })
# mark center point of circle in WCS
msp.add_point((0, 2, 2), dxfattribs={'color': 1})

# The center of the pentagon should be (0, 2, 2), and the shape is
# rotated around x-axis about 45 degree, to accomplish this I use an
# UCS with z-axis (0, 1, 1) and an x-axis parallel to WCS x-axis.
ucs = UCS(


    origin=(0, 2, 2),  # center of pentagon


    ux=(1, 0, 0),  # x-axis parallel to WCS x-axis


    uz=(0, 1, 1),  # z-axis
)
# calculating corner points in local (UCS) coordinates
points = [Vector.from_deg_angle((360 / 5) * n) for n in range(5)]
# converting UCS into OCS coordinates
ocs_points = list(ucs.points_to_ocs(points))
# LWPOLYLINE accepts only 2D points and has an separated DXF attribute elevation.
# All points have the same z-axis (elevation) in OCS!
elevation = ocs_points[0].z
msp.add_lwpolyline(


    points=ocs_points,


    format='xy',  # ignore z-axis


    dxfattribs={


        'elevation': elevation,


        'extrusion': ucs.uz,


        'closed': True,


        'color': 1,


    })

# Using an UCS simplifies 3D operations, but UCS definition can happen later
# calculating corner points in local (UCS) coordinates without Vector class
angle = math.radians(360 / 5)
corners_ucs = [(math.cos(angle * n), math.sin(angle * n), 0) for n in range(5)]
# let's do some transformations
tmatrix = Matrix44.chain(  # creating a transformation matrix


    Matrix44.z_rotate(math.radians(15)),  # 1. rotation around z-axis


    Matrix44.translate(0, .333, .333),  # 2. translation
)
transformed_corners_ucs = tmatrix.transform_vertices(corners_ucs)
# transform UCS into WCS
ucs = UCS(


    origin=(0, 2, 2),  # center of pentagon


    ux=(1, 0, 0),  # x-axis parallel to WCS x-axis


    uz=(0, 1, 1),  # z-axis
)
corners_wcs = list(ucs.points_to_wcs(transformed_corners_ucs))
msp.add_polyline3d(


    points=corners_wcs,


    dxfattribs={


        'closed': True,


        'color': 1,


    })
# add lines from center to corners
center_wcs = ucs.to_wcs((0, .333, .333))
for corner in corners_wcs:


    msp.add_line(center_wcs, corner, dxfattribs={'color': 1})

# Thickness for text works only with shx fonts not with true type fonts
doc.styles.new('TXT', dxfattribs={'font': 'romans.shx'})
ucs = UCS(origin=(0, 2, 2), ux=(1, 0, 0), uz=(0, 1, 1))
# calculation of text direction as angle in OCS:
# convert text rotation in degree into a vector in UCS
text_direction = Vector.from_deg_angle(-45)
# transform vector into OCS and get angle of vector in xy-plane
rotation = ucs.to_ocs(text_direction).angle_deg
text = msp.add_text(


    text="TEXT",


    dxfattribs={


        # text rotation angle in degrees in OCS


        'rotation': rotation,


        'extrusion': ucs.uz,


        'thickness': .333,


        'color': 1,


        'style': 'TXT',


    })
# set text position in OCS
text.set_pos(ucs.to_ocs((0, 0, 0)), align='MIDDLE_CENTER')

ucs = UCS(origin=(0, 2, 2), ux=(1, 0, 0), uz=(0, 1, 1))
msp.add_arc(


    center=ucs.to_ocs((0, 0)),


    radius=1,


    start_angle=ucs.to_ocs_angle_deg(45),


    end_angle=ucs.to_ocs_angle_deg(270),


    dxfattribs={


        'extrusion': ucs.uz,


        'color': 1,


    })
center = ucs.to_wcs((0, 0))
msp.add_line(


    start=center,


    end=ucs.to_wcs(Vector.from_deg_angle(45)),


    dxfattribs={'color': 1},
)
msp.add_line(


    start=center,


    end=ucs.to_wcs(Vector.from_deg_angle(270)),


    dxfattribs={'color': 1},
)

# rotate UCS around an arbitrary axis:
def ucs_rotation(ucs: UCS, axis: Vector, angle: float):


    # new in ezdxf v0.11: UCS.rotate(axis, angle)


    t = Matrix44.axis_rotate(axis, math.radians(angle))


    ux, uy, uz = t.transform_vertices([ucs.ux, ucs.uy, ucs.uz])


    return UCS(origin=ucs.origin, ux=ux, uy=uy, uz=uz)
doc = ezdxf.new('R2010', setup=True)
blk = doc.blocks.new('CSYS')
setup_csys(blk)
msp = doc.modelspace()
ucs = ucs_rotation(UCS(), axis=Y_AXIS, angle=90)
# transform insert location to OCS
insert = ucs.to_ocs((0, 0, 0))
# rotation angle about the z-axis (= WCS x-axis)
rotation = ucs.to_ocs_angle_deg(15)
msp.add_blockref('CSYS', insert, dxfattribs={


   'extrusion': ucs.uz,


   'rotation': rotation,
})

# t is a transformation matrix to rotate 15 degree around the x-axis
t = Matrix44.axis_rotate(axis=X_AXIS, angle=math.radians(15))
# transform block z-axis into new UCS z-axis (= extrusion vector)
uz = Vector(t.transform(Z_AXIS))
# create new UCS at the insertion point, because we are rotating around the x-axis,
# ux is the same as the WCS x-axis and uz is the rotated z-axis.
ucs = UCS(origin=(1, 2, 0), ux=X_AXIS, uz=uz)
# transform insert location to OCS, block base_point=(0, 0, 0)
insert = ucs.to_ocs((0, 0, 0))
# for this case a rotation around the z-axis is not required
rotation = 0
blockref = msp.add_blockref('CSYS', insert, dxfattribs={


    'extrusion': ucs.uz,


    'rotation': rotation,
})

# translate a block references with an established OCS
translation = Vector(-3, -1, 1)
# get established OCS
ocs = blockref.ocs()
# get insert location in WCS
actual_wcs_location = ocs.to_wcs(blockref.dxf.insert)
# translate location
new_wcs_location = actual_wcs_location + translation
# convert WCS location to OCS location
blockref.dxf.insert = ocs.from_wcs(new_wcs_location)

# rotate a block references with an established OCS around the block y-axis about 90 degree
ocs = blockref.ocs()
# convert block y-axis (= rotation axis) into WCS vector
rotation_axis = ocs.to_wcs((0, 1, 0))
# convert local z-axis (=extrusion vector) into WCS vector
local_z_axis = ocs.to_wcs((0, 0, 1))

# build transformation matrix
t = Matrix44.axis_rotate(axis=rotation_axis, angle=math.radians(-90))
uz = t.transform(local_z_axis)
uy = rotation_axis
# the block reference origin stays at the same location, no rotation needed
wcs_insert = ocs.to_wcs(blockref.dxf.insert)
# build new UCS to convert WCS locations and angles into OCS
ucs = UCS(origin=wcs_insert, uy=uy, uz=uz)

# set new OCS
blockref.dxf.extrusion = ucs.uz
# set new insert
blockref.dxf.insert = ucs.to_ocs((0, 0, 0))
# set new rotation: we do not rotate the block reference around the local z-axis,
# but the new block x-axis (0 deg) differs from OCS x-axis and has to be adjusted
blockref.dxf.rotation = ucs.to_ocs_angle_deg(0)

import math
import ezdxf
from ezdxf.math import UCS
doc = ezdxf.new('R2010')
msp = doc.modelspace()
ucs = UCS()  # New default UCS
# All rotation angles in radians, and rotation
# methods always return a new UCS.
ucs = ucs.rotate_local_x(math.radians(-45))
circle = msp.add_circle(


    # Use UCS coordinates to place the 2d circle in 3d space


    center=(0, 0, 2),


    radius=1,


    dxfattribs={'color': 1}
)
circle.transform(ucs.matrix)
# mark center point of circle in WCS
msp.add_point((0, 0, 2), dxfattribs={'color': 1}).transform(ucs.matrix)

# The center of the pentagon should be (0, 2, 2), and the shape is
# rotated around x-axis about -45 degree
ucs = UCS(origin=(0, 2, 2)).rotate_local_x(math.radians(-45))
msp.add_lwpolyline(


    # calculating corner points in UCS coordinates


    points=(Vector.from_deg_angle((360 / 5) * n) for n in range(5)),


    format='xy',  # ignore z-axis


    dxfattribs={


        'closed': True,


        'color': 1,


    }
).transform(ucs.matrix)

# using an UCS simplifies 3D operations, but UCS definition can happen later
# calculating corner points in local (UCS) coordinates without Vector class
angle = math.radians(360 / 5)
corners_ucs = [(math.cos(angle * n), math.sin(angle * n), 0) for n in range(5)]
# let's do some transformations by UCS
transformation_ucs = UCS().rotate_local_z(math.radians(15))  # 1. rotation around z-axis
transformation_ucs.shift((0, .333, .333))  # 2. translation (inplace)
corners_ucs = list(transformation_ucs.points_to_wcs(corners_ucs))
location_ucs = UCS(origin=(0, 2, 2)).rotate_local_x(math.radians(-45))
msp.add_polyline3d(


    points=corners_ucs,


    dxfattribs={


        'closed': True,


        'color': 1,


    }
).transform(location_ucs.matrix)
# Add lines from the center of the POLYLINE to the corners
center_ucs = transformation_ucs.to_wcs((0, 0, 0))
for corner in corners_ucs:


    msp.add_line(


        center_ucs, corner, dxfattribs={'color': 1}


    ).transform(location_ucs.matrix)

# thickness for text works only with shx fonts not with true type fonts
doc.styles.new('TXT', dxfattribs={'font': 'romans.shx'})
ucs = UCS(origin=(0, 2, 2)).rotate_local_x(math.radians(-45))
text = msp.add_text(


    text="TEXT",


    dxfattribs={


        # text rotation angle in degrees in UCS


        'rotation': -45,


        'thickness': .333,


        'color': 1,


        'style': 'TXT',


    }
)
# set text position in UCS
text.set_pos((0, 0, 0), align='MIDDLE_CENTER')
text.transform(ucs.matrix)

ucs = UCS(origin=(0, 2, 2)).rotate_local_x(math.radians(-45))
CENTER = (0, 0)
START_ANGLE = 45
END_ANGLE = 270
msp.add_arc(


    center=CENTER,


    radius=1,


    start_angle=START_ANGLE,


    end_angle=END_ANGLE,


    dxfattribs={'color': 6},
).transform(ucs.matrix)
msp.add_line(


    start=CENTER,


    end=Vector.from_deg_angle(START_ANGLE),


    dxfattribs={'color': 6},
).transform(ucs.matrix)
msp.add_line(


    start=CENTER,


    end=Vector.from_deg_angle(END_ANGLE),


    dxfattribs={'color': 6},
).transform(ucs.matrix)

doc = ezdxf.new('R2010', setup=True)
blk = doc.blocks.new('CSYS')
setup_csys(blk)
msp = doc.modelspace()
ucs = UCS().rotate_local_y(angle=math.radians(90))
msp.add_blockref(


    'CSYS',


    insert=(0, 0),


    # rotation around the block z-axis (= WCS x-axis)


    dxfattribs={'rotation': 15},
).transform(ucs.matrix)

ucs = UCS(origin=(1, 2, 0)).rotate_local_x(math.radians(15))
blockref = msp.add_blockref('CSYS', insert=(0, 0, 0))
blockref.transform(ucs.matrix)

# New UCS at the translated location, axis aligned to the WCS
ucs = UCS((-3, -1, 1))
# Transform an already placed block reference, including
# the transformation of the established OCS.
blockref.transform(ucs.matrix)

# Get UCS at the block reference insert location, UCS axis aligned
# to the block axis.
ucs = blockref.ucs()
# Rotate UCS around the local y-axis.
ucs = ucs.rotate_local_y(math.radians(-90))

# Reset block reference parameters to place block reference in
# UCS origin, without any rotation and OCS.
blockref.reset_transformation()
# Transform block reference from UCS to WCS
blockref.transform(ucs.matrix)

import ezdxf
# Argument setup=True setups the default dimension styles
doc = ezdxf.new('R2010', setup=True)
# Add new dimension entities to the modelspace
msp = doc.modelspace()
# Add a LINE entity, not required
msp.add_line((0, 0), (3, 0))
# Add a horizontal dimension, default dimension style is 'EZDXF'
dim = msp.add_linear_dim(base=(3, 2), p1=(0, 0), p2=(3, 0))
# Necessary second step, to create the BLOCK entity with the dimension geometry.
# Additional processing of the dimension line could happen between adding and
# rendering call.
dim.render()
doc.saveas('dim_linear_horiz.dxf')

# assignment to dim is not necessary, if no additional processing happens
msp.add_linear_dim(base=(3, 2), p1=(0, 0), p2=(3, 0), angle=-30).render()
doc.saveas('dim_linear_rotated.dxf')

msp.add_line((0, 2), (3, 0))
dim = msp.add_aligned_dim(p1=(0, 2), p2=(3, 0), distance=1)
doc.saveas('dim_linear_aligned.dxf')

msp.add_linear_dim(base=(3, 2), p1=(0, 0), p2=(3, 0), override={'dimjust': 1}).render()

msp.add_linear_dim(base=(3, 2), p1=(0, 0), p2=(3, 0), override={'dimtad': 4}).render()

dim = msp.add_linear_dim(base=(3, 2), p1=(0, 0), p2=(3, 0))
dim.set_text_align(halign='left', valign='center')
dim.render()

msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0), location=(4, 4)).render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.set_location(location=(-1, 1), leader=True, relative=True)
dim.render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.shift_text(dh=1, dv=1)
dim.render()

msp.add_linear_dim(


    base=(3, 2), p1=(3, 0), p2=(6, 0),


    override={


        'dimtxsty': 'Standard',


        'dimtxt': 0.35,


        'dimclrt': 1,


    }).render()

msp.add_linear_dim(


    base=(3, 2), p1=(3, 0), p2=(6, 0),


    override={


        'dimtfill': 2,


        'dimtfillclr': 1,


    }).render()

msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0), text='>1m').render()

msp.add_linear_dim(


    base=(3, 2), p1=(3, 0), p2=(6, 0),


    override={


        'dimclrd': 1,  # red


        'dimdle': 0.25,


        'dimltype': 'DASHED2',


        'dimlwd': 35,  # 0.35mm line weight


    }).render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.set_dimline_format(color=1, linetype='DASHED2', lineweight=35, extension=0.25)
dim.render()

msp.add_linear_dim(


    base=(3, 2), p1=(3, 0), p2=(6, 0),


    override={


        'dimclre': 1,   # red


        'dimltex1': 'DASHED2',


        'dimltex2': 'CENTER2',


        'dimlwe': 35,   # 0.35mm line weight


        'dimexe': 0.3,  # length above dimension line


        'dimexo': 0.1,  # offset from measurement point


    }).render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.set_extline_format(color=1, lineweight=35, extension=0.3, offset=0.1)
dim.set_extline1(linetype='DASHED2')
dim.set_extline2(linetype='CENTER2')
dim.render()

msp.add_linear_dim(


    base=(3, 2), p1=(3, 0), p2=(6, 0),


    override={


        'dimfxlon': 1,  # fixed length extension lines


        'dimexe': 0.2,  # length above dimension line


        'dimfxl': 0.4,  # length below dimension line


    }).render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.set_extline_format(extension=0.2, fixed_length=0.4)
dim.render()

msp.add_linear_dim(


    base=(3, 2), p1=(3, 0), p2=(6, 0),


    override={


        'dimse1': 1,  # suppress first extension line


        'dimse2': 1,  # suppress second extension line


        'dimblk': ezdxf.ARROWS.closed_filled,  # arrows just looks better


    }).render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.set_arrows(blk=ezdxf.ARROWS.closed_filled)
dim.set_extline1(disable=True)
dim.set_extline2(disable=True)
dim.render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.set_tick(size=0.25)
dim.render()

dim = msp.add_linear_dim(base=(3, 2), p1=(3, 0), p2=(6, 0))
dim.set_arrow(blk="OPEN_30", size=0.25)
dim.render()

msp.add_linear_dim(


    base=(3, 2), p1=(3, 0), p2=(6, 0),


    override={


        'dimtsz': 0,  # set tick size to 0 to enable arrow usage


        'dimasz': 0.25,  # arrow size in drawing units


        'dimblk': "OPEN_30",  # arrow block name


    }).render()

dim = msp.add_linear_dim(base=(0, 3), p1=(3, 0), p2=(6.5, 0))
dim.set_tolerance(.1, hfactor=.4, align="top", dec=2)
dim.render()

dim = msp.add_linear_dim(base=(0, 3), p1=(3, 0), p2=(6.5, 0))
dim.set_tolerance(upper=.1, lower=.15, hfactor=.4, align="middle", dec=2)
dim.render()

dim = msp.add_linear_dim(base=(0, 3), p1=(3, 0), p2=(6.5, 0))
dim.set_limits(upper=.1, lower=.15, hfactor=.4, dec=2)
dim.render()

import ezdxf
# DXF R2010 drawing, official DXF version name: 'AC1024',
# setup=True setups the default dimension styles
doc = ezdxf.new('R2010', setup=True)
msp = doc.modelspace()  # add new dimension entities to the modelspace
msp.add_circle((0, 0), radius=3)  # add a CIRCLE entity, not required
# add default radius dimension, measurement text is located outside
dim = msp.add_radius_dim(center=(0, 0), radius=3, angle=45, dimstyle='EZ_RADIUS')
# necessary second step, to create the BLOCK entity with the dimension geometry.
dim.render()
doc.saveas('radius_dimension.dxf')

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, angle=45,


                         dimstyle='EZ_RADIUS'


                         )
dim.render()  # required, but not shown in the following examples

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, angle=45,


                         dimstyle='EZ_RADIUS',


                         override={'dimtoh': 1}


                         )

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, angle=45,


                         dimstyle='EZ_RADIUS_INSIDE'


                         )

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, angle=45,


                         dimstyle='EZ_RADIUS_INSIDE',


                         override={'dimtih': 1}


                         )

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, location=(4, 4),


                         dimstyle='EZ_RADIUS'


                         )

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, location=(4, 4),


                         dimstyle='EZ_RADIUS',


                         override={'dimtoh': 1}


                         )

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, location=(1, 1),


                         dimstyle='EZ_RADIUS'


                         )

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, location=(1, 1),


                         dimstyle='EZ_RADIUS',


                         override={'dimtih': 1},


                         )

dim = msp.add_radius_dim(center=(0, 0), radius=2.5, angle=45,


                         dimstyle='EZ_RADIUS',


                         override={'dimcen': 0.25},


                         )

import ezdxf
# setup=True setups the default dimension styles
doc = ezdxf.new('R2010', setup=True)
msp = doc.modelspace()  # add new dimension entities to the modelspace
msp.add_circle((0, 0), radius=3)  # add a CIRCLE entity, not required
# add default diameter dimension, measurement text is located outside
dim = msp.add_diameter_dim(center=(0, 0), radius=3, angle=45, dimstyle='EZ_RADIUS')
dim.render()
doc.saveas('diameter_dimension.dxf')

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, angle=45,


                           dimstyle='EZ_RADIUS')
dim.render()  # required, but not shown in the following examples

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, angle=45,


                          dimstyle='EZ_RADIUS',


                          override={'dimtoh': 1}


                          )

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, angle=45,


                           dimstyle='EZ_RADIUS_INSIDE'


                           )

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, angle=45,


                           dimstyle='EZ_RADIUS_INSIDE',


                           override={'dimtih': 1}


                           )

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, location=(4, 4),


                           dimstyle='EZ_RADIUS'


                          )

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, location=(4, 4),


                           dimstyle='EZ_RADIUS',


                           override={'dimtoh': 1}


                          )

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, location=(1, 1),


                           dimstyle='EZ_RADIUS'


                          )

dim = msp.add_diameter_dim(center=(0, 0), radius=2.5, location=(1, 1),


                           dimstyle='EZ_RADIUS',


                           override={'dimtih': 1},


                           )

Parameters

Parameters

Raises

Parameters

stream – input text stream opened with correct encoding

Raises

DXFStructureError – for invalid or corrupted DXF structures

Parameters

Raises

Parameters

Raises

dxfversion

Actual DXF version like 'AC1009', set by ezdxf.new() or ezdxf.readfile().

For supported DXF versions see dwgmanagement

acad_release

The AutoCAD release name like 'R12' or 'R2000' for actual dxfversion.

encoding

Text encoding of Drawing, the default encoding for new drawings is 'cp1252'. Starting with DXF R2007 (AC1021), DXF files are written as UTF-8 encoded text files, regardless of the attribute encoding. Text encoding can be changed to encodings listed below.

see also: dxf file encoding

supported	encodings
'cp874'	Thai
'cp932'	Japanese
'gbk'	UnifiedChinese
'cp949'	Korean
'cp950'	TradChinese
'cp1250'	CentralEurope
'cp1251'	Cyrillic
'cp1252'	WesternEurope
'cp1253'	Greek
'cp1254'	Turkish
'cp1255'	Hebrew
'cp1256'	Arabic
'cp1257'	Baltic
'cp1258'	Vietnam

output_encoding

Returns required output encoding for saving to filesystem or encoding to binary data.

New in version 0.11.

filename

Drawing filename, if loaded by ezdxf.readfile() else None.

rootdict

Reference to the root dictionary of the OBJECTS section.

header

Reference to the HeaderSection, get/set drawing settings as header variables.

entities

Reference to the EntitySection of the drawing, where all graphical entities are stored, but only from modelspace and the active paperspace layout. Just for your information: Entities of other paperspace layouts are stored as BlockLayout in the BlocksSection.

objects

Reference to the objects section, see also ObjectsSection.

blocks

Reference to the blocks section, see also BlocksSection.

tables

Reference to the tables section, see also TablesSection.

classes

Reference to the classes section, see also ClassesSection.

layouts

Reference to the layout manager, see also Layouts.

groups

Collection of all groups, see also GroupCollection.

requires DXF R13 or later

layers

Shortcut for Drawing.tables.layers

Reference to the layers table, where you can create, get and remove layers, see also Table and Layer

styles

Shortcut for Drawing.tables.styles

Reference to the styles table, see also Style.

dimstyles

Shortcut for Drawing.tables.dimstyles

Reference to the dimstyles table, see also DimStyle.

linetypes

Shortcut for Drawing.tables.linetypes

Reference to the linetypes table, see also Linetype.

views

Shortcut for Drawing.tables.views

Reference to the views table, see also View.

viewports

Shortcut for Drawing.tables.viewports

Reference to the viewports table, see also Viewport.

ucs

Shortcut for Drawing.tables.ucs

Reference to the ucs table, see also UCS.

appids

Shortcut for Drawing.tables.appids

Reference to the appids table, see also AppID.

materials

MaterialCollection of all Material objects.

mline_styles

MLineStyleCollection of all MLineStyle objects.

mleader_styles

MLeaderStyleCollection of all MLeaderStyle objects.

save(encoding: str = None, fmt: str = 'asc') -> None

Write drawing to file-system by using the filename attribute as filename. Override file encoding by argument encoding, handle with care, but this option allows you to create DXF files for applications that handles file encoding different than AutoCAD.

saveas(filename: str, encoding: str = None, fmt: str = 'asc') -> None

Set Drawing attribute filename to filename and write drawing to the file system. Override file encoding by argument encoding, handle with care, but this option allows you to create DXF files for applications that handles file encoding different than AutoCAD.

write(stream: Union[TextIO, BinaryIO], fmt: str = 'asc') -> None

Write drawing as ASCII DXF to a text stream or as Binary DXF to a binary stream. For DXF R2004 (AC1018) and prior open stream with drawing encoding and mode='wt'. For DXF R2007 (AC1021) and later use encoding='utf-8', or better use the later added Drawing property output_encoding which returns the correct encoding automatically. The correct and required error handler is errors='dxfreplace'!

If writing to a StringIO stream, use Drawing.encode() to encode the result string from StringIO.get_value():

binary = doc.encode(stream.get_value())

encode_base64() -> bytes

Returns DXF document as base64 encoded binary data.

encode(s: str) -> bytes

Encode string s with correct encoding and error handler.

query(query: str = '*') -> ezdxf.query.EntityQuery

Entity query over all layouts and blocks, excluding the OBJECTS section.

SEE ALSO:

groupby(dxfattrib='', key=None) -> dict

Groups DXF entities of all layouts and blocks (excluding the OBJECTS section) by a DXF attribute or a key function.

SEE ALSO:

modelspace() -> ezdxf.layouts.layout.Modelspace

Returns the modelspace layout, displayed as 'Model' tab in CAD applications, defined by block record named '*Model_Space'.

layout(name: str = None) -> Layout

Returns paperspace layout name or returns first layout in tab order if name is None.

active_layout() -> Layout

Returns the active paperspace layout, defined by block record name '*Paper_Space'.

layout_names() -> Iterable[str]

Returns all layout names (modelspace 'Model' included) in arbitrary order.

layout_names_in_taborder() -> Iterable[str]

Returns all layout names (modelspace included, always first name) in tab order.

new_layout(name, dxfattribs=None) -> Layout

Create a new paperspace layout name. Returns a Layout object. DXF R12 (AC1009) supports only one paperspace layout, only the active paperspace layout is saved, other layouts are dismissed.

delete_layout(name: str) -> None

Delete paper space layout name and all entities owned by this layout. Available only for DXF R2000 or later, DXF R12 supports only one paperspace and it can’t be deleted.

add_image_def(filename: str, size_in_pixel: Tuple[int, int], name=None)

Add an image definition to the objects section.

Add an ImageDef entity to the drawing (objects section). filename is the image file name as relative or absolute path and size_in_pixel is the image size in pixel as (x, y) tuple. To avoid dependencies to external packages, ezdxf can not determine the image size by itself. Returns a ImageDef entity which is needed to create an image reference. name is the internal image name, if set to None, name is auto-generated.

Absolute image paths works best for AutoCAD but not really good, you have to update external references manually in AutoCAD, which is not possible in TrueView. If the drawing units differ from 1 meter, you also have to use: set_raster_variables().

SEE ALSO:

set_raster_variables(frame: int = 0, quality: int = 1, units: str = 'm')

Set raster variables.

set_wipeout_variables(frame=0)

Set wipeout variables.

add_underlay_def(filename: str, format: str = 'ext', name: str = None)

Add an UnderlayDef entity to the drawing (OBJECTS section). filename is the underlay file name as relative or absolute path and format as string (pdf, dwf, dgn). The underlay definition is required to create an underlay reference.

SEE ALSO:

add_xref_def(filename: str, name: str, flags: int = 20)

Add an external reference (xref) definition to the blocks section.

layouts_and_blocks() -> Iterable[GenericLayoutType]

Iterate over all layouts (modelspace and paperspace) and all block definitions.

chain_layouts_and_blocks() -> Iterable[DXFEntity]

Chain entity spaces of all layouts and blocks. Yields an iterator for all entities in all layouts and blocks.

reset_fingerprint_guid()

Reset fingerprint GUID.

reset_version_guid()

Reset version GUID.

set_modelspace_vport(height, center=(0, 0)) -> VPort

Set initial view/zoom location for the modelspace, this replaces the current “*Active” viewport configuration.

audit() -> Auditor

Checks document integrity and fixes all fixable problems, not fixable problems are stored in Auditor.errors.

If you are messing around with internal structures, call this method before saving to be sure to export valid DXF documents, but be aware this is a long running task.

validate(print_report=True) -> bool

Simple way to run an audit process. Fixes all fixable problems, return False if not fixable errors occurs, to get more information about not fixable errors use audit() method instead.

Returns: True if no errors occurred

import sys
import ezdxf
from ezdxf import recover
try:


    doc, auditor = recover.readfile("messy.dxf")
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
except ezdxf.DXFStructureError:


    print(f'Invalid or corrupted DXF file.')


    sys.exit(2)
# DXF file can still have unrecoverable errors, but this is maybe just
# a problem when saving the recovered DXF file.
if auditor.has_errors:


    auditor.print_error_report()

Writing such files back with ezdxf may create invalid DXF files, or at least some information will be lost - handle with care!

To avoid this problem use recover.readfile(filename, errors='strict') which raises an UnicodeDecodeError exception for such binary data. Catch the exception and handle this DXF files as unrecoverable.

try:


    doc = ezdxf.readfile(name)
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
except ezdxf.DXFStructureError:


    print(f'Invalid or corrupted DXF file: {name}.')


    sys.exit(2)

try:


    doc = ezdxf.readfile(name)
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
except ezdxf.DXFStructureError:


    print(f'Invalid or corrupted DXF file: {name}.')


    sys.exit(2)
auditor = doc.audit()
if auditor.has_errors:


    auditor.print_error_report()

try:  # Fast path:


    doc = ezdxf.readfile(name)
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
# Catch all DXF errors:
except ezdxf.DXFError:


    try:  # Slow path including fixing low level structures:


        doc, auditor = recover.readfile(name)


    except ezdxf.DXFStructureError:


        print(f'Invalid or corrupted DXF file: {name}.')


        sys.exit(2)
# DXF file can still have unrecoverable errors, but this is maybe
# just a problem when saving the recovered DXF file.
if auditor.has_errors:


    print(f'Found unrecoverable errors in DXF file: {name}.')


    auditor.print_error_report()

try:  # Slow path including fixing low level structures:


    doc, auditor = recover.readfile(name)
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
except ezdxf.DXFStructureError:


    print(f'Invalid or corrupted DXF file: {name}.')


    sys.exit(2)
# DXF file can still have unrecoverable errors, but this is maybe
# just a problem when saving the recovered DXF file.
if auditor.has_errors:


    print(f'Found unrecoverable errors in DXF file: {name}.')


    auditor.print_error_report()

try:


    doc, auditor = recover.readfile(name, errors='strict')
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
except ezdxf.DXFStructureError:


    print(f'Invalid or corrupted DXF file: {name}.')


    sys.exit(2)
except UnicodeDecodeError:


    print(f'Decoding error in DXF file: {name}.')


    sys.exit(3)

try:


    doc, auditor = recover.readfile(name, errors='ignore')
except IOError:


    print(f'Not a DXF file or a generic I/O error.')


    sys.exit(1)
except ezdxf.DXFStructureError:


    print(f'Invalid or corrupted DXF file: {name}.')


    sys.exit(2)
if auditor.has_errors:


    auditor.print_report()

Parameters

Raises

Parameters

Raises

custom_vars

Stores the custom drawing properties in a CustomVars object.

__len__() -> int

Returns count of header variables.

__contains__(key) -> bool

Returns True if header variable key exist.

varnames() -> KeysView

Returns an iterable of all header variable names.

get(key: str, default: Any = None) -> Any

Returns value of header variable key if exist, else the default value.

__getitem__(key: str) -> Any

Get header variable key by index operator like: drawing.header['$ACADVER']

__setitem__(key: str, value: Any) -> None

Set header variable key to value by index operator like: drawing.header['$ANGDIR'] = 1

__delitem__(key: str) -> None

Delete header variable key by index operator like: del drawing.header['$ANGDIR']

properties

List of custom drawing properties, stored as string tuples (tag, value). Multiple occurrence of the same custom tag is allowed, but not well supported by the interface. This is a standard python list and it is save to change this list as long you store just tuples of strings in the format (tag, value).

__len__() -> int

Count of custom properties.

__iter__() -> Iterable[Tuple[str, str]]

Iterate over all custom properties as (tag, value) tuples.

clear() -> None

Remove all custom properties.

get(tag: str, default: str = None)

Returns the value of the first custom property tag.

has_tag(tag: str) -> bool

Returns True if custom property tag exist.

append(tag: str, value: str) -> None

Add custom property as (tag, value) tuple.

replace(tag: str, value: str) -> None

Replaces the value of the first custom property tag by a new value. Raises DXFValueError if tag does not exist.

remove(tag: str, all: bool = False) -> None

Removes the first occurrence of custom property tag, removes all occurrences if all is True. Raises :class:`DXFValueError if tag does not exist.

classes

Storage of all DXFClass objects, they are not stored in the entities database, because CLASS has no handle attribute.

register(classes: Iterable[DXFClass])

add_class(name: str)

Register a known class by name.

get(name: str) -> DXFClass

Returns the first class matching name.

Storage key is the (name, cpp_class_name) tuple, because there are some classes with the same name but different cpp_class_names.

add_required_classes(name: str) -> DXFClass

Add all required CLASS definitions for dxfversion.

update_instance_counters() -> None

Update CLASS instance counter for all registered classes, requires DXF R2004+.

dxf.name

Class DXF record name.

dxf.cpp_class_name

C++ class name. Used to bind with software that defines object class behavior.

dxf.app_name

Application name. Posted in Alert box when a class definition listed in this section is not currently loaded.

dxf.flags

Proxy capabilities flag

0	No operations allowed (0)
1	Erase allowed (0x1)
2	Transform allowed (0x2)
4	Color change allowed (0x4)
8	Layer change allowed (0x8)
16	Linetype change allowed (0x10)
32	Linetype scale change allowed (0x20)
64	Visibility change allowed (0x40)
128	Cloning allowed (0x80)
256	Lineweight change allowed (0x100)
512	Plot Style Name change allowed (0x200)
895	All operations except cloning allowed (0x37F)
1023	All operations allowed (0x3FF)
1024	Disables proxy warning dialog (0x400)
32768	R13 format proxy (0x8000)

dxf.instance_count

Instance count for a custom class.

dxf.was_a_proxy

Set to 1 if class was not loaded when this DXF file was created, and 0 otherwise.

dxf.is_an_entity

Set to 1 if class was derived from the DXFGraphic class and can reside in layouts. If 0, instances may appear only in the OBJECTS section.

key

Unique name as (name, cpp_class_name) tuple.

layers

LayerTable object for Layer objects

linetypes

Generic Table object for Linetype objects

styles

StyleTable object for Textstyle objects

dimstyles

Generic Table object for DimStyle objects

appids

Generic Table object for AppID objects

ucs

Generic Table object for UCSTable objects

views

Generic Table object for View objects

viewports

ViewportTable object for VPort objects

block_records

Generic Table object for BlockRecord objects

__iter__() -> Iterable[BlockLayout]

Iterable of all BlockLayout objects.

__contains__(name: str) -> bool

Returns True if BlockLayout name exist.

__getitem__(name: str) -> BlockLayout

Returns BlockLayout name, raises DXFKeyError if name not exist.

__delitem__(name: str) -> None

Deletes BlockLayout name and all of its content, raises DXFKeyError if name not exist.

get(self, name: str, default=None) -> BlockLayout

Returns BlockLayout name, returns default if name not exist.

new(name: str, base_point: Sequence[float] = (0, 0), dxfattribs: dict = None) -> BlockLayout

Create and add a new BlockLayout, name is the BLOCK name, base_point is the insertion point of the BLOCK.

new_anonymous_block(type_char: str = 'U', base_point: Sequence[float] = (0, 0)) -> BlockLayout

Create and add a new anonymous BlockLayout, type_char is the BLOCK type, base_point is the insertion point of the BLOCK.

rename_block(old_name: str, new_name: str) -> None

Rename BlockLayout old_name to new_name

delete_block(name: str, safe: bool = True) -> None

Delete block. If save is True, check if block is still referenced.

delete_all_blocks()

Delete all blocks without references except modelspace- or paperspace layout blocks, special arrow- and anonymous blocks (DIMENSION, ACAD_TABLE).

WARNING:

Changed in version 0.14: removed unsafe mode

purge()

Delete all unused blocks like delete_all_blocks(), but also removes unused anonymous blocks.

WARNING:

__iter__() -> Iterable[DXFEntity]

Iterable for all entities of modelspace and active paperspace.

__len__() -> int

Returns count of all entities of modelspace and active paperspace.

rootdict

Root dictionary.

__len__() -> int

Returns count of DXF objects.

__iter__() -> Iterable[DXFObject]

Returns iterable of all DXF objects in the OBJECTS section.

__getitem__(index) -> DXFObject

Get entity at index.

The underlying data structure for storing DXF objects is organized like a standard Python list, therefore index can be any valid list indexing or slicing term, like a single index objects[-1] to get the last entity, or an index slice objects[:10] to get the first 10 or less objects as List[DXFObject].

__contains__(entity: Union[DXFObject, str]) -> bool

Returns True if entity stored in OBJECTS section.

query(query: str = '*') -> ezdxf.query.EntityQuery

Get all DXF objects matching the entity query string.

add_dictionary(owner: str = '0', hard_owned: bool = False) -> ezdxf.entities.dictionary.Dictionary

Add new Dictionary object.

add_dictionary_with_default(owner='0', default='0', hard_owned: bool = False) -> DictionaryWithDefault

Add new DictionaryWithDefault object.

add_dictionary_var(owner: str = '0', value: str = '') -> DictionaryVar

Add a new DictionaryVar object.

add_geodata(owner: str = '0', dxfattribs: dict = None) -> GeoData

Creates a new GeoData entity and replaces existing ones. The GEODATA entity resides in the OBJECTS section and NOT in the layout entity space and it is linked to the layout by an extension dictionary located in BLOCK_RECORD of the layout.

The GEODATA entity requires DXF version R2010+. The DXF Reference does not document if other layouts than model space supports geo referencing, so getting/setting geo data may only make sense for the model space layout, but it is also available in paper space layouts.

add_image_def(filename: str, size_in_pixel: Tuple[int, int], name=None) -> ImageDef

Add an image definition to the objects section.

Add an ImageDef entity to the drawing (objects section). filename is the image file name as relative or absolute path and size_in_pixel is the image size in pixel as (x, y) tuple. To avoid dependencies to external packages, ezdxf can not determine the image size by itself. Returns a ImageDef entity which is needed to create an image reference. name is the internal image name, if set to None, name is auto-generated.

Absolute image paths works best for AutoCAD but not really good, you have to update external references manually in AutoCAD, which is not possible in TrueView. If the drawing units differ from 1 meter, you also have to use: set_raster_variables().

add_placeholder(owner: str = '0') -> Placeholder

Add a new Placeholder object.

add_underlay_def(filename: str, format: str = 'pdf', name: str = None) -> UnderlayDef

Add an UnderlayDef entity to the drawing (OBJECTS section). filename is the underlay file name as relative or absolute path and format as string (pdf, dwf, dgn). The underlay definition is required to create an underlay reference.

add_xrecord(owner: str = '0') -> XRecord

Add a new XRecord object.

set_raster_variables(frame: int = 0, quality: int = 1, units: str = 'm') -> None

Set raster variables.

(internal API), public interface set_raster_variables()

set_wipeout_variables(frame: int = 0) -> None

Set wipeout variables.

(internal API), public interface set_wipeout_variables()

static key(entity: Union[str, DXFEntity]) -> str

Unified table entry key.

has_entry(name: Union[str, DXFEntity]) -> bool

Returns True if an table entry name exist.

__contains__(name: Union[str, DXFEntity]) -> bool

Returns True if an table entry name exist.

__len__() -> int

Count of table entries.

__iter__() -> Iterable[DXFEntity]

Iterable of all table entries.

new(name: str, dxfattribs: dict = None) -> DXFEntity

Create a new table entry name.

get(name: str) -> DXFEntity

Get table entry name (case insensitive). Raises DXFValueError if table entry does not exist.

remove(name: str) -> None

Removes table entry name. Raises DXFValueError if table-entry does not exist.

duplicate_entry(name: str, new_name: str) -> DXFEntity

Returns a new table entry new_name as copy of name, replaces entry new_name if already exist.

get_shx(shxname: str) -> Textstyle

Get existing shx entry, or create a new entry.

find_shx(shxname: str) -> Optional[Textstyle]

Find .shx shape file table entry, by a case insensitive search.

A .shx shape file table entry has no name, so you have to search by the font attribute.

get_config(self, name: str) -> List[Viewport]

Returns a list of Viewport objects, for the multi-viewport configuration name.

delete_config(name: str) -> None

Delete all Viewport objects of the multi-viewport configuration name.

dxf.handle

DXF handle (feature for experts)

dxf.owner

Handle to owner (LayerTable).

dxf.name

Layer name, case insensitive and can not contain any of this characters: <>/\":;?*|=` (str)

dxf.flags

Layer flags (bit-coded values, feature for experts)

1	Layer is frozen; otherwise layer is thawed; use is_frozen(), freeze() and thaw()
2	Layer is frozen by default in new viewports
4	Layer is locked; use is_locked(), lock(), unlock()
16	If set, table entry is externally dependent on an xref
32	If both this bit and bit 16 are set, the externally dependent xref has been successfully resolved
64	If set, the table entry was referenced by at least one entity in the drawing the last time the drawing was edited. (This flag is for the benefit of AutoCAD commands. It can be ignored by most programs that read DXF files and need not be set by programs that write DXF files)

dxf.color

Layer color, but use property Layer.color to get/set color value, because color is negative for layer status off (int)

dxf.true_color

Layer true color value as int, use property Layer.rgb to set/get true color value as (r, g, b) tuple.

(requires DXF R2004)

dxf.linetype

Name of line type (str)

dxf.plot

Plot flag (int). Whether entities belonging to this layer should be drawn when the document is exported (plotted) to pdf. Does not affect visibility inside the CAD application itself.

1	plot layer (default value)
0	don’t plot layer

dxf.lineweight

Line weight in mm times 100 (e.g. 0.13mm = 13). Smallest line weight is 13 and biggest line weight is 200, values outside this range prevents AutoCAD from loading the file.

ezdxf.lldxf.const.LINEWEIGHT_DEFAULT for using global default line weight.

(requires DXF R13)

dxf.plotstyle_handle

Handle to plot style name?

(requires DXF R13)

dxf.material_handle

Handle to default Material.

(requires DXF R13)

rgb

Get/set DXF attribute dxf.true_color as (r, g, b) tuple, returns None if attribute dxf.true_color is not set.

layer.rgb = (30, 40, 50)
r, g, b = layer.rgb

This is the recommend method to get/set RGB values, when ever possible do not use the DXF low level attribute dxf.true_color.

New in version 0.10.

color

Get/set layer color, preferred method for getting the layer color, because dxf.color is negative for layer status off.

New in version 0.10.

description

Get/set layer description as string

New in version 0.10.

transparency

Get/set layer transparency as float value in the range from 0 to 1. 0 for no transparency (opaque) and 1 for 100% transparency.

New in version 0.10.

is_frozen() -> bool

Returns True if layer is frozen.

freeze() -> None

Freeze layer.

thaw() -> None

Thaw layer.

is_locked() -> bool

Returns True if layer is locked.

lock() -> None

Lock layer, entities on this layer are not editable - just important in CAD applications.

unlock() -> None

Unlock layer, entities on this layer are editable - just important in CAD applications.

is_off() -> bool

Returns True if layer is off.

is_on() -> bool

Returns True if layer is on.

on() -> None

Switch layer on (visible).

off() -> None

Switch layer off (invisible).

get_color() -> int

Use property Layer.color instead.

set_color(value: int) -> None

Use property Layer.color instead.

rename(name: str) -> None

Rename layer and all known (documented) references to this layer.

WARNING:

dxf.handle

DXF handle (feature for experts).

dxf.owner

Handle to owner (StyleTable).

dxf.name

Style name (str)

dxf.flags

Style flags (feature for experts).

1	If set, this entry describes a shape
4	Vertical text
16	If set, table entry is externally dependent on an xref
32	If both this bit and bit 16 are set, the externally dependent xref has been successfully resolved
64	If set, the table entry was referenced by at least one entity in the drawing the last time the drawing was edited. (This flag is only for the benefit of AutoCAD)commands. It can be ignored by most programs that read DXF files and need not be set by programs that write DXF files)

dxf.height

Fixed height in drawing units, 0 for not fixed (float).

dxf.width

Width factor (float), default is 1.

dxf.oblique

Oblique angle in degrees, 0 is vertical (float).

dxf.generation_flags

Text generations flags (int)

2	text is backward (mirrored in X)
4	text is upside down (mirrored in Y)

dxf.last_height

Last height used in drawing units (float).

dxf.font

Primary font file name (str).

dxf.bigfont

Big font name, blank if none (str)

DXF Internals: ltype_table_internals

dxf.name

Linetype name (str).

dxf.owner

Handle to owner (Table).

dxf.description

Linetype description (str).

dxf.length

Total pattern length in drawing units (float).

dxf.items

Number of linetype elements (int).

dxf.owner

Handle to owner (Table).

dxf.name

Dimension style name.

dxf.flags

Standard flag values (bit-coded values):

16	If set, table entry is externally dependent on an xref
32	If both this bit and bit 16 are set, the externally dependent xref has been successfully resolved
64	If set, the table entry was referenced by at least one entity in the drawing the last time the drawing was edited. (This flag is only for the benefit of AutoCAD)

dxf.dimpost

Prefix/suffix for primary units dimension values.

dxf.dimapost

Prefix/suffix for alternate units dimensions.

dxf.dimblk

Block type to use for both arrowheads as name string.

dxf.dimblk1

Block type to use for first arrowhead as name string.

dxf.dimblk2

Block type to use for second arrowhead as name string.

dxf.dimscale

Global dimension feature scale factor. (default=1)

dxf.dimasz

Dimension line and arrowhead size. (default=0.25)

dxf.dimexo

Distance from origin points to extension lines. (default imperial=0.0625, default metric=0.625)

dxf.dimdli

Incremental spacing between baseline dimensions. (default imperial=0.38, default metric=3.75)

dxf.dimexe

Extension line distance beyond dimension line. (default imperial=0.28, default metric=2.25)

dxf.dimrnd

Rounding value for decimal dimensions. (default=0)

Rounds all dimensioning distances to the specified value, for instance, if DIMRND is set to 0.25, all distances round to the nearest 0.25 unit. If you set DIMRND to 1.0, all distances round to the nearest integer.

dxf.dimdle

Dimension line extension beyond extension lines. (default=0)

dxf.dimtp

Upper tolerance value for tolerance dimensions. (default=0)

dxf.dimtm

Lower tolerance value for tolerance dimensions. (default=0)

dxf.dimtxt

Size of dimension text. (default imperial=0.28, default metric=2.5)

dxf.dimcen

Controls placement of center marks or centerlines. (default imperial=0.09, default metric=2.5)

dxf.dimtsz

Controls size of dimension line tick marks drawn instead of arrowheads. (default=0)

dxf.dimaltf

Alternate units dimension scale factor. (default=25.4)

dxf.dimlfac

Scale factor for linear dimension values. (default=1)

dxf.dimtvp

Vertical position of text above or below dimension line if dimtad is 0. (default=0)

dxf.dimtfac

Scale factor for fractional or tolerance text size. (default=1)

dxf.dimgap

Gap size between dimension line and dimension text. (default imperial=0.09, default metric=0.625)

dxf.dimaltrnd

Rounding value for alternate dimension units. (default=0)

dxf.dimtol

Toggles creation of appended tolerance dimensions. (default imperial=1, default metric=0)

dxf.dimlim

Toggles creation of limits-style dimension text. (default=0)

dxf.dimtih

Orientation of text inside extension lines. (default imperial=1, default metric=0)

dxf.dimtoh

Orientation of text outside extension lines. (default imperial=1, default metric=0)

dxf.dimse1

Toggles suppression of first extension line. (default=0)

dxf.dimse2

Toggles suppression of second extension line. (default=0)

dxf.dimtad

Sets vertical text placement relative to dimension line. (default imperial=0, default metric=1)

0	center
1	above
2	outside, handled like above by ezdxf
3	JIS, handled like above by ezdxf
4	below

dxf.dimzin

Zero suppression for primary units dimensions. (default imperial=0, default metric=8)

Values 0-3 affect feet-and-inch dimensions only.

0	Suppresses zero feet and precisely zero inches
1	Includes zero feet and precisely zero inches
2	Includes zero feet and suppresses zero inches
3	Includes zero inches and suppresses zero feet
4	Suppresses leading zeros in decimal dimensions (for example, 0.5000 becomes .5000)
8	Suppresses trailing zeros in decimal dimensions (for example, 12.5000 becomes 12.5)
12	Suppresses both leading and trailing zeros (for example, 0.5000 becomes .5)

dxf.dimazin

Controls zero suppression for angular dimensions. (default=0)

0	Displays all leading and trailing zeros
1	Suppresses leading zeros in decimal dimensions (for example, 0.5000 becomes .5000)
2	Suppresses trailing zeros in decimal dimensions (for example, 12.5000 becomes 12.5)
3	Suppresses leading and trailing zeros (for example, 0.5000 becomes .5)

dxf.dimalt

Enables or disables alternate units dimensioning. (default=0)

dxf.dimaltd

Controls decimal places for alternate units dimensions. (default imperial=2, default metric=3)

dxf.dimtofl

Toggles forced dimension line creation. (default imperial=0, default metric=1)

dxf.dimsah

Toggles appearance of arrowhead blocks. (default=0)

dxf.dimtix

Toggles forced placement of text between extension lines. (default=0)

dxf.dimsoxd

Suppresses dimension lines outside extension lines. (default=0)

dxf.dimclrd

Dimension line, arrowhead, and leader line color. (default=0)

dxf.dimclre

Dimension extension line color. (default=0)

dxf.dimclrt

Dimension text color. (default=0)

dxf.dimadec

Controls the number of decimal places for angular dimensions.

dxf.dimunit

Obsolete, now use DIMLUNIT AND DIMFRAC

dxf.dimdec

Decimal places for dimension values. (default imperial=4, default metric=2)

dxf.dimtdec

Decimal places for primary units tolerance values. (default imperial=4, default metric=2)

dxf.dimaltu

Units format for alternate units dimensions. (default=2)

dxf.dimalttd

Decimal places for alternate units tolerance values. (default imperial=4, default metric=2)

dxf.dimaunit

Unit format for angular dimension values. (default=0)

dxf.dimfrac

Controls the fraction format used for architectural and fractional dimensions. (default=0)

dxf.dimlunit

Specifies units for all nonangular dimensions. (default=2)

dxf.dimdsep

Specifies a single character to use as a decimal separator. (default imperial = '.', default metric = ',') This is an integer value, use ord('.') to write value.

dxf.dimtmove

Controls the format of dimension text when it is moved. (default=0)

0	Moves the dimension line with dimension text
1	Adds a leader when dimension text is moved
2	Allows text to be moved freely without a leader

dxf.dimjust

Horizontal justification of dimension text. (default=0)

0	Center of dimension line
1	Left side of the dimension line, near first extension line
2	Right side of the dimension line, near second extension line
3	Over first extension line
4	Over second extension line

dxf.dimsd1

Toggles suppression of first dimension line. (default=0)

dxf.dimsd2

Toggles suppression of second dimension line. (default=0)

dxf.dimtolj

Vertical justification for dimension tolerance text. (default=1)

0	Align with bottom line of dimension text
1	Align vertical centered to dimension text
2	Align with top line of dimension text

dxf.dimtzin

Zero suppression for tolerances values, see DimStyle.dxf.dimzin

dxf.dimaltz

Zero suppression for alternate units dimension values. (default=0)

dxf.dimalttz

Zero suppression for alternate units tolerance values. (default=0)

dxf.dimfit

Obsolete, now use DIMATFIT and DIMTMOVE

dxf.dimupt

Controls user placement of dimension line and text. (default=0)

dxf.dimatfit

Controls placement of text and arrowheads when there is insufficient space between the extension lines. (default=3)

dxf.dimtxsty

Text style used for dimension text by name.

dxf.dimtxsty_handle

Text style used for dimension text by handle of STYLE entry. (use DimStyle.dxf.dimtxsty to get/set text style by name)

dxf.dimldrblk

Specify arrowhead used for leaders by name.

dxf.dimldrblk_handle

Specify arrowhead used for leaders by handle of referenced block. (use DimStyle.dxf.dimldrblk to get/set arrowhead by name)

dxf.dimblk_handle

Block type to use for both arrowheads, handle of referenced block. (use DimStyle.dxf.dimblk to get/set arrowheads by name)

dxf.dimblk1_handle

Block type to use for first arrowhead, handle of referenced block. (use DimStyle.dxf.dimblk1 to get/set arrowhead by name)

dxf.dimblk2_handle

Block type to use for second arrowhead, handle of referenced block. (use DimStyle.dxf.dimblk2 to get/set arrowhead by name)

dxf.dimlwd

Lineweight value for dimension lines. (default=-2, BYBLOCK)

dxf.dimlwe

Lineweight value for extension lines. (default=-2, BYBLOCK)

dxf.dimltype

Specifies the linetype used for the dimension line as linetype name, requires DXF R2007+

dxf.dimltype_handle

Specifies the linetype used for the dimension line as handle to LTYPE entry, requires DXF R2007+ (use DimStyle.dxf.dimltype to get/set linetype by name)

dxf.dimltex1

Specifies the linetype used for the extension line 1 as linetype name, requires DXF R2007+

dxf.dimlex1_handle

Specifies the linetype used for the extension line 1 as handle to LTYPE entry, requires DXF R2007+ (use DimStyle.dxf.dimltex1 to get/set linetype by name)

dxf.dimltex2

Specifies the linetype used for the extension line 2 as linetype name, requires DXF R2007+

dxf.dimlex2_handle

Specifies the linetype used for the extension line 2 as handle to LTYPE entry, requires DXF R2007+ (use DimStyle.dxf.dimltex2 to get/set linetype by name)

dxf.dimfxlon

Extension line has fixed length if set to 1, requires DXF R2007+

dxf.dimfxl

Length of extension line below dimension line if fixed (DimStyle.dxf.dimtfxlon == 1), DimStyle.dxf.dimexen defines the the length above the dimension line, requires DXF R2007+

dxf.dimtfill

Text fill 0=off; 1=background color; 2=custom color (see DimStyle.dxf.dimtfillclr), requires DXF R2007+

dxf.dimtfillclr

Text fill custom color as color index (1-255), requires DXF R2007+

copy_to_header(dwg: Drawing) -> None

Copy all dimension style variables to HEADER section of doc.

set_arrows(blk: str = '', blk1: str = '', blk2: str = '', ldrblk: str = '') -> None

Set arrows by block names or AutoCAD standard arrow names, set DIMTSZ to 0 which disables tick.

set_tick(size: float = 1) -> None

Set tick size, which also disables arrows, a tick is just an oblique stroke as marker.