U :vh5F @sRdZddlZddlZddlZddlZddlmZddlmZddl m Z ddl m Z m Z mZddlmZmZmZmZmZmZmZdd lmZmZdd lmZd d iZd d ZeddZeee ej!fZ"ee ej!fZ#e$dZ%e$dZ&e$dZ'e(dZ)dddddddddZ*GdddeZ+dd!d"Z,d#d$Z-d%d&Z.Gd'd(d(e d(d)e"fd*e"fd+e"fd,e e"fgZ/d ed-<d.ed/<d0ed1<d2ed3<d4ed5<Gd6d7d7e d7d*e"fd,e e"fgZ0d ed8<d9ed:<d4ed;<Gde"fd?e"fd@e"fdAe"fd,e e"fgZ1d edB<dCedD<dEedF<dGedH<dIedJ<d4edK<ddLdMZ2ddNdOZ3ddQdRZ4ddSdTZ5dUdVZ6dWdXZ7GdYdZdZe Z8Gd[d\d\e Z9d ed]<d ed^<d ed_<d ed`<d eda<d edb<GdcddddZ:dedfZ;dgdhZGdmdndne Z?Gdodpdpe Z@Gdqdrdre ZAGdsdtdte ZBGdudvdve ZCGdwdxdxe ZDGdydzdze ZEGd{d|d|e ZFGd}d~d~e ZGGddde ZHGddde ZIGddde ZJGddde ZKGddde ZLGddde ZMGddde ZNGddde ZOGddde ZPGdddZQGdddZRGdddeRZSGdddZTdS)a  Vector drawing: managing colors, graphics states, paths, transforms... The contents of this module are internal to fpdf2, and not part of the public API. They may change at any time without prior warning or any deprecation period, in non-backward-compatible ways. N) OrderedDict)Sequence)contextmanager)Optional NamedTupleUnion) BlendModeClippingPathIntersectionRuleIntersectionRule PathPaintRuleStrokeCapStyleStrokeJoinStyle PDFStyleKeys)NameRaw) escape_parensforce_nodocumentFcCsdt|j<|S)zQA decorator that forces pdoc not to document the decorated item (class or method)F__pdoc__ __qualname__itemr0/tmp/pip-unpacked-wheel-dvf6lv8i/fpdf/drawing.pyrs cCsdt|j<|S)zMA decorator that forces pdoc to document the decorated item (class or method)Trrrrrforce_document%s rz z z ()<>[]{}/%z[\n\r\t\b\f()\\]z\nz\rz\tz\bz\fz\(z\)z\\)    ()\c@seZdZdZddddZdS)GraphicsStateDictRegistryzZ A container providing deduplication of graphics state dictionaries across a PDF. GraphicsStylestylecCsN|}|sdSz ||WStk r.YnXtdt|}|||<|S)NZGS) serializeKeyErrorrlen)selfr'Zsdictnamerrrregister_styleKs z(GraphicsStateDictRegistry.register_styleN)__name__ __module__r__doc__r-rrrrr$Fsr$?cCs4||kr|ks0nt|d|d|d|S)Nz not in range [z, ]) ValueError)valueZminimummaximumrrr _check_range]sr7cCs|dddS)z Convert a decimal number to a minimal string representation (no trailing 0 or .). Args: number (Number): the number to be converted to a string. Returns: The number's string representation. z.4f0.)rstrip)numberrrr number_to_strds r<cCsBt|tr|Stt|ddr*|}n|dkr:d}nt|trVdt|d}nt|trrd|d}nt|t rdd g|}nt|t rt |}nt|t t frd d d d |Dd}npt|tr,g}|D]4\}}t|tstd|t|d t|qdd|d}ntd|t|S)a Render a Python value as a PDF primitive type. Container types (tuples/lists and dicts) are rendered recursively. This supports values of the type Name, str, bytes, numbers, booleans, list/tuple, and dict. Any custom type can be passed in as long as it provides a `serialize` method that takes no arguments and returns a string. The primitive object is returned directly if it is an instance of the `Raw` class. Otherwise, The existence of the `serialize` method is checked before any other type checking is performed, so, for example, a `dict` subclass with a `serialize` method would be converted using its `pdf_repr` method rather than the built-in `dict` conversion process. Args: primitive: the primitive value to convert to its PDF representation. Returns: Raw-wrapped str of the PDF representation. Raises: ValueError: if a dictionary key is not a Name. TypeError: if `primitive` does not have a known conversion to a PDF representation. r(Nnullr!r"<>falsetrue[ css|]}t|VqdSN)render_pdf_primitive.0valrrr sz'render_pdf_primitive..r3zdict keys must be Namesz<< rz >>z,cannot produce PDF representation for value ) isinstancercallablegetattrr(strrbyteshexbool NumberClassr<listtuplejoindictitemsrr4appendrE TypeError)Z primitiveoutputZ item_listkeyrHrrrrEts6         rEcsLeZdZdZdZd fdd ZeddZedd Ze d d d Z Z S) DeviceRGBz+A class representing a PDF DeviceRGB color.ZrgNcs0|dk rt|t|t|t|t||SrDr7super__new__)clsrgba __class__rrr^szDeviceRGB.__new__cCs |ddS)zVThe color components as a tuple in order `(r, g, b)` with alpha omitted, in range 0-1.Nrr+rrrcolorsszDeviceRGB.colorscCstdd|jDS)XThe color components as a tuple in order `(r, g, b)` with alpha omitted, in range 0-255.css|]}d|VqdSNrrGvrrrrIsz&DeviceRGB.colors255..rSrhrgrrr colors255szDeviceRGB.colors255returncCs"ddd|jDd|jS)NrCcss|]}t|VqdSrDr<rFrrrrIsz&DeviceRGB.serialize..rTrhOPERATORrgrrrr(szDeviceRGB.serialize)N r.r/rr0rtr^propertyrhrorMr( __classcell__rrrdrr[s  r[r`rarbrczDeviceRGB.OPERATORz8The red color component. Must be in the interval [0, 1].z DeviceRGB.rz:The green color component. Must be in the interval [0, 1].z DeviceRGB.gz9The blue color component. Must be in the interval [0, 1].z DeviceRGB.baD The alpha color component (i.e. opacity). Must be `None` or in the interval [0, 1]. An alpha value of 0 makes the color fully transparent, and a value of 1 makes it fully opaque. If `None`, the color will be interpreted as not specifying a particular transparency rather than specifying fully transparent or fully opaque. z DeviceRGB.acsLeZdZdZdZd fdd ZeddZedd Ze d d d Z Z S) DeviceGrayz,A class representing a PDF DeviceGray color.raNcs$|dk rt|t|t||SrDr\)r_rarcrdrrr^szDeviceGray.__new__cCs|j|j|jfS)zTThe color components as a tuple in order (r, g, b) with alpha omitted, in range 0-1.)rargrrrrhszDeviceGray.colorscCstdd|jDS)ricss|]}d|VqdSrjrrlrrrrIsz'DeviceGray.colors255..rnrgrrrro szDeviceGray.colors255rpcCst|jd|jS)NrC)r<rartrgrrrr(szDeviceGray.serialize)Nrurrrdrrxs  rxzDeviceGray.OPERATORz} The gray color component. Must be in the interval [0, 1]. A value of 0 represents black and a value of 1 represents white. z DeviceGray.gz DeviceGray.acs@eZdZdZdZd fdd ZeddZedd d Z Z S) DeviceCMYKz,A class representing a PDF DeviceCMYK color.kNcs6|dk rt|t|t|t|t|t||SrDr\)r_cmyrzrcrdrrr^<szDeviceCMYK.__new__cCs |ddS)zWThe color components as a tuple in order (c, m, y, k) with alpha omitted, in range 0-1.NrfrrgrrrrhDszDeviceCMYK.colorsrpcCs"ddd|jDd|jS)NrCcss|]}t|VqdSrDrrrFrrrrIJsz'DeviceCMYK.serialize..rsrgrrrr(IszDeviceCMYK.serialize)N) r.r/rr0rtr^rvrhrMr(rwrrrdrry+s   ryr{r|r}rzzDeviceCMYK.OPERATORz9The cyan color component. Must be in the interval [0, 1].z DeviceCMYK.czsz)color_from_hex_string..rNrccSsg|]}t|dddqSrrrrrrrscs$g|]}t||dddqSrrrGidxhexstrrrrsr cs$g|]}t||dddqSrrrrrrrsz0 could not be interpreted as a RGB(A) hex string)rJrMrXrr4r*rrange)rZhlenrrrrs$   rcCst|tst|d|dd}|dr8|dsFt|d|dd}|d }t|d krt d d |Dd diSt|dkrt dd |DSt|ddS)z Parse an RGB color from a css-style rgb(R, G, B, A) color string. Args: rgbstr (str): of the form `rgb(R, G, B)` or `rgb(R, G, B, A)`. Returns: DeviceRGB representation of the color. rrCzrgb(r"z- does not follow the expected rgb(...) formatrrf,cSsg|] }t|qSrrrGr{rrrrsz)color_from_rgb_string..rcNcSsg|] }t|qSrrrrrrrsz6 could not be interpreted as a rgb(R, G, B[, A]) color) rJrMrXreplacerendswithr4splitr*r)Zrgbstrrhrrrcolor_from_rgb_strings      rc@seZdZUdZeed<eed<ddZddZdd Zd d Z e d d Z e ddZ e ddZ e ddZeZe ddZe ddZe ddZddZdS)PointzM An x-y coordinate pair within the two-dimensional coordinate frame. xr}cCst|jdt|jS)z=Render the point to the string `"x y"` for emitting to a PDF.rCr<rr}rgrrrrendersz Point.rendercCs0t|tstd||j|j|j|jS)a( Compute the dot product of two points. Args: other (Point): the point with which to compute the dot product. Returns: The scalar result of the dot product computation. Raises: TypeError: if `other` is not a `Point`. zcannot dot with )rJrrXrr}r+otherrrrdot s z Point.dotcCsjt|tstd||j|j|j|j}|dk|dk}|tt||| | dS)a Compute the angle between two points (interpreted as vectors from the origin). The return value is in the interval (-pi, pi]. Sign is dependent on ordering, with clockwise angle travel considered to be positive due to the orientation of the coordinate frame basis vectors (i.e. the angle between `(1, 0)` and `(0, 1)` is `+pi/2`, the angle between `(1, 0)` and `(0, -1)` is `-pi/2`, and the angle between `(0, -1)` and `(1, 0)` is `+pi/2`). Args: other (Point): the point to compute the angle sweep toward. Returns: The scalar angle between the two points **in radians**. Raises: TypeError: if `other` is not a `Point`. zcannot compute angle with r) rJrrXrr}mathacosroundrmag)r+rZ signifiersignrrrangles  z Point.anglecCs|jd|jddS)a Compute the Cartesian distance from this point to the origin This is the same as computing the magnitude of the vector represented by this point. Returns: The scalar result of the distance computation. r?rr}rgrrrr7s z Point.magcCs*t|tr&t|j|j|j|jdStS)an Produce the sum of two points. Adding two points is the same as translating the source point by interpreting the other point's x and y coordinates as distances. Args: other (Point): right-hand side of the infix addition operation Returns: A Point which is the sum of the two source points. rrJrrr}NotImplementedrrrr__add__Ds z Point.__add__cCs*t|tr&t|j|j|j|jdStS)a0 Produce the difference between two points. Unlike addition, this is not a commutative operation! Args: other (Point): right-hand side of the infix subtraction operation Returns: A Point which is the difference of the two source points. rrrrrr__sub__Ws z Point.__sub__cCst|j |j dS)z Produce a point by negating this point's coordinates. Returns: A Point whose coordinates are this points coordinates negated. r)rrr}rgrrr__neg__isz Point.__neg__cCs$t|tr t|j||j|StS)a  Multiply a point by a scalar value. Args: other (Number): the scalar value by which to multiply the point's coordinates. Returns: A Point whose coordinates are the result of the multiplication. rJrQrrr}rrrrr__mul__ss z Point.__mul__cCs$t|tr t|j||j|StS)a Divide a point by a scalar value. .. note:: Because division is not commutative, `Point / scalar` is implemented, but `scalar / Point` is nonsensical and not implemented. Args: other (Number): the scalar value by which to divide the point's coordinates. Returns: A Point whose coordinates are the result of the division. rrrrr __truediv__s zPoint.__truediv__cCs$t|tr t|j||j|StS)a Divide a point by a scalar value using integer division. .. note:: Because division is not commutative, `Point // scalar` is implemented, but `scalar // Point` is nonsensical and not implemented. Args: other (Number): the scalar value by which to divide the point's coordinates. Returns: A Point whose coordinates are the result of the division. rrrrr __floordiv__s zPoint.__floordiv__cCsNt|trJt|j|j|j|j|j|j|j|j |j|j dSt S)a Transform a point with the given transform matrix. .. note:: This operator is only implemented for Transforms. This transform is not commutative, so `Point @ Transform` is implemented, but `Transform @ Point` is not implemented (technically speaking, the current implementation is commutative because of the way points and transforms are represented, but if that representation were to change this operation could stop being commutative) Args: other (Transform): the transform to apply to the point Returns: A Point whose coordinates are the result of applying the transform. r) rJ Transformrrcrr{r}erbdfrrrrr __matmul__s  zPoint.__matmul__cCsdt|jdt|jdS)Nz(x=z, y=r"rrgrrr__str__sz Point.__str__N)r.r/rr0Number__annotations__rrrrrrrrr__rmul__rrrrrrrrrs.         rc@seZdZUdZeed<eed<eed<eed<eed<eed<edd Zed d Zed)d dZ eddZ eddZ ed*ddZ ddZ d+ddZddZddZd,ddZdd Zed!d"ZeZed#d$Zd%d&Zd'd(Zd S)-rax A representation of an affine transformation matrix for 2D shapes. The actual matrix is: ``` [ a b 0 ] [x' y' 1] = [x y 1] [ c d 0 ] [ e f 1 ] ``` Complex transformation operations can be composed via a sequence of simple transformations by performing successive matrix multiplication of the simple transformations. For example, scaling a set of points around a specific center point can be represented by a translation-scale-translation sequence, where the first translation translates the center to the origin, the scale transform scales the points relative to the origin, and the second translation translates the points back to the specified center point. Transform multiplication is performed using python's dedicated matrix multiplication operator, `@` The semantics of this representation mean composed transformations are specified left-to-right in order of application (some other systems provide transposed representations, in which case the application order is right-to-left). For example, to rotate the square `(1,1) (1,3) (3,3) (3,1)` 45 degrees clockwise about its center point (which is `(2,2)`) , the translate-rotate-translate process described above may be applied: ```python rotate_centered = ( Transform.translation(-2, -2) @ Transform.rotation_d(45) @ Transform.translation(2, 2) ) ``` Instances of this class provide a chaining API, so the above transform could also be constructed as follows: ```python rotate_centered = Transform.translation(-2, -2).rotate_d(45).translate(2, 2) ``` Or, because the particular operation of performing some transformations about a specific point is pretty common, ```python rotate_centered = Transform.rotation_d(45).about(2, 2) ``` By convention, this class provides class method constructors following noun-ish naming (`translation`, `scaling`, `rotation`, `shearing`) and instance method manipulations following verb-ish naming (`translate`, `scale`, `rotate`, `shear`). rcrbr{rrrcCs|ddddddS)zu Create a transform representing the identity transform. The identity transform is a no-op. rrr)r_rrridentityszTransform.identitycCs|dddd||S)aF Create a transform that performs translation. Args: x (Number): distance to translate points along the x (horizontal) axis. y (Number): distance to translate points along the y (vertical) axis. Returns: A Transform representing the specified translation. rrrr_rr}rrr translation"s zTransform.translationNcCs|dkr |}||dd|ddS)a Create a transform that performs scaling. Args: x (Number): scaling ratio in the x (horizontal) axis. A value of 1 results in no scale change in the x axis. y (Number): optional scaling ratio in the y (vertical) axis. A value of 1 results in no scale change in the y axis. If this value is omitted, it defaults to the value provided to the `x` argument. Returns: A Transform representing the specified scaling. Nrrrrrrscaling1szTransform.scalingcCs,|t|t|t| t|ddS)a# Create a transform that performs rotation. Args: theta (Number): the angle **in radians** by which to rotate. Positive values represent clockwise rotations. Returns: A Transform representing the specified rotation. r)rcossin)r_thetarrrrotationEs  zTransform.rotationcCs|t|S)a4 Create a transform that performs rotation **in degrees**. Args: theta_d (Number): the angle **in degrees** by which to rotate. Positive values represent clockwise rotations. Returns: A Transform representing the specified rotation. )rrradians)r_theta_drrr rotation_dVs zTransform.rotation_dcCs|dkr |}|d||dddS)a Create a transform that performs shearing (not of sheep). Args: x (Number): The amount to shear along the x (horizontal) axis. y (Number): Optional amount to shear along the y (vertical) axis. If omitted, this defaults to the value provided to the `x` argument. Returns: A Transform representing the specified shearing. NrrrrrrrshearingeszTransform.shearingcCs|t||S)a Produce a transform by composing the current transform with a translation. .. note:: Transforms are immutable, so this returns a new transform rather than mutating self. Args: x (Number): distance to translate points along the x (horizontal) axis. y (Number): distance to translate points along the y (vertical) axis. Returns: A Transform representing the composed transform. rrr+rr}rrr translatewszTransform.translatecCs|t||S)a Produce a transform by composing the current transform with a scaling. .. note:: Transforms are immutable, so this returns a new transform rather than mutating self. Args: x (Number): scaling ratio in the x (horizontal) axis. A value of 1 results in no scale change in the x axis. y (Number): optional scaling ratio in the y (vertical) axis. A value of 1 results in no scale change in the y axis. If this value is omitted, it defaults to the value provided to the `x` argument. Returns: A Transform representing the composed transform. )rrrrrrscaleszTransform.scalecCs|t|S)a Produce a transform by composing the current transform with a rotation. .. note:: Transforms are immutable, so this returns a new transform rather than mutating self. Args: theta (Number): the angle **in radians** by which to rotate. Positive values represent clockwise rotations. Returns: A Transform representing the composed transform. )rr)r+rrrrrotateszTransform.rotatecCs|t|S)a Produce a transform by composing the current transform with a rotation **in degrees**. .. note:: Transforms are immutable, so this returns a new transform rather than mutating self. Args: theta_d (Number): the angle **in degrees** by which to rotate. Positive values represent clockwise rotations. Returns: A Transform representing the composed transform. )rr)r+rrrrrotate_dszTransform.rotate_dcCs|t||S)a% Produce a transform by composing the current transform with a shearing. .. note:: Transforms are immutable, so this returns a new transform rather than mutating self. Args: x (Number): The amount to shear along the x (horizontal) axis. y (Number): Optional amount to shear along the y (vertical) axis. If omitted, this defaults to the value provided to the `x` argument. Returns: A Transform representing the composed transform. )rrrrrrshearszTransform.shearcCs t| | |t||S)a Bracket the given transform in a pair of translations to make it appear about a point that isn't the origin. This is a useful shorthand for performing a transform like a rotation around the center point of an object that isn't centered at the origin. .. note:: Transforms are immutable, so this returns a new transform rather than mutating self. Args: x (Number): the point along the x (horizontal) axis about which to transform. y (Number): the point along the y (vertical) axis about which to transform. Returns: A Transform representing the composed transform. rrrrraboutszTransform.aboutcCsFt|trBt|j||j||j||j||j||j|dSt S)z Multiply the individual transform parameters by a scalar value. Args: other (Number): the scalar value by which to multiply the parameters Returns: A Transform with the modified parameters. rcrbr{rrr) rJrQrrcrbr{rrrrrrrrrs  zTransform.__mul__c Cst|tr|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|j|jdSt S)z Compose two transforms into a single transform. Args: other (Transform): the right-hand side transform of the infix operator. Returns: A Transform representing the composed transform. r) rJrrercrbr{rrrrrrrrrs  zTransform.__matmul__c CsPt|jdt|jdt|jdt|jdt|jdt|jd |fS)z Render the transform to its PDF output representation. Args: last_item: the last path element this transform applies to Returns: A tuple of `(str, last_item)`. `last_item` is returned unchanged. rCz cmr<rcrbr{rrr)r+ last_itemrrrrs JzTransform.renderc CsNdt|jdt|jdt|jdt|jdt|jdt|jd S)Nz transform: [rCz 0; z 1]rrgrrrr(sLzTransform.__str__)N)N)N)N)r.r/rr0rr classmethodrrrrrrrrrrrrrrrrrrrrrrrs@ 9           rz Transform.az Transform.bz Transform.cz Transform.dz Transform.ez Transform.fcseZdZdZdZdZejjej jej jfZ ddeDZ e ieje dheje dejheje dejheje ddejheje ddejhejiZedd Zd d Zd d ZfddZeddZej fddZeddZ!e!j fddZ!eddZ"e"j fddZ"eddZ#e#j fddZ#eddZ$e$j fddZ$edd Z%e%j fd!d Z%ed"d#Z&e&j fd$d#Z&ed%d&Z'e'j fd'd&Z'ed(d)Z(e(j fd*d)Z(ed+d,Z)e)j fd-d,Z)ed.d/Z*e*j fd0d/Z*ed1d2Z+e+j fd3d2Z+ed4d5Z,e,j fd6d5Z,ed7d8Z-e-j fd9d8Z-ed:d;Z.e.j fdZ/e0d?d@Z1Z2S)Ar%a A class representing various style attributes that determine drawing appearance. This class uses the convention that the global Python singleton ellipsis (`...`) is exclusively used to represent values that are inherited from the parent style. This is to disambiguate the value None which is used for several values to signal an explicitly disabled style. An example of this is the fill/stroke color styles, which use None as hints to the auto paint style detection code. .) paint_ruleallow_transparency auto_closeintersection_rule fill_color fill_opacity stroke_colorstroke_opacity blend_mode stroke_widthstroke_cap_stylestroke_join_stylestroke_miter_limitstroke_dash_patternstroke_dash_phaseccs|]}|tjk r|jVqdSrD)rSTROKE_DASH_PATTERNr5)rGrzrrrrIds zGraphicsStyle.strokefillcCsJ|}|jD]8}t||}||jkr8t||t||q t|||q |S)aA Merge parent and child into a single GraphicsStyle. The result contains the properties of the parent as overridden by any properties explicitly set on the child. If both the parent and the child specify to inherit a given property, that property will preserve the inherit value. )MERGE_PROPERTIESrLINHERITsetattr)r_parentchildnewpropcvalrrrmergevs    zGraphicsStyle.mergecCs||j|_|j|_|j|_|j|_|j|_|j|_|j|_|j|_|j|_ |j|_ |j|_ |j|_ |j|_ |j|_|j|_dSrD)rrrrrrrrrrrrrrrrrgrrr__init__szGraphicsStyle.__init__cCs*|}|jD]}t||t||q|SrD)rerrrL)r+memocopiedrrrr __deepcopy__s zGraphicsStyle.__deepcopy__cs4t|j|s"t|jd|dt||dS)Nz does not have style "z " (a typo?))hasattrreAttributeErrorr] __setattr__)r+r,r5rdrrrs  zGraphicsStyle.__setattr__cCs|jSrD)_allow_transparencyrgrrrrsz GraphicsStyle.allow_transparencycstd|S)Nr)r]rr+rrdrrrscCs|jS)z*The paint rule to use for this path/group.) _paint_rulergrrrrszGraphicsStyle.paint_rulecsL|dkrtdtjn.||jkr4td|ntdt|dS)Nr)r]rr DONT_PAINTrcoercerrdrrrs  cCs|jS)zEIf True, unclosed paths will be automatically closed before stroking.) _auto_closergrrrrszGraphicsStyle.auto_closecs0|dd|jhkrtd|td|dS)NTFz/auto_close must be a bool or self.INHERIT, not r)rrXr]rrrdrrrscCs|jS)z2The desired intersection rule for this path/group.)_intersection_rulergrrrrszGraphicsStyle.intersection_rulecs2||jkrtd|ntdt|dS)Nr)rr]rr rrrdrrrs cCs|jS)z The desired fill color for this path/group. When setting this property, if the color specifies an opacity value, that will be used to set the fill_opacity property as well. ) _fill_colorrgrrrrszGraphicsStyle.fill_colorcsxt|trt|}t|tttfrDtd||jdk rt|j|_ n0|dksV||j krftd|nt |ddS)Nr" doesn't look like a drawing color) rJrMrr[rxryr]rrcrrrXr+colorrdrrrs   cCst|tjjS)z-The desired fill opacity for this path/group.)rLr FILL_ALPHAr5rgrrrrszGraphicsStyle.fill_opacitycs,|d|jhkrt|ttjj|dSrD)rr7r]rrrr5rrdrrrscCs|jS)z The desired stroke color for this path/group. When setting this property, if the color specifies an opacity value, that will be used to set the fill_opacity property as well. ) _stroke_colorrgrrrrszGraphicsStyle.stroke_colorcst|trt|}t|tttfrVtd||jdk rB|j|_ |j |j krd|_ n0|dksh||j krxtd|nt |ddS)Nr rr) rJrMrr[rxryr]rrcrrrrXrrdrrr s   cCst|tjjS)z/The desired stroke opacity for this path/group.)rLr STROKE_ALPHAr5rgrrrrszGraphicsStyle.stroke_opacitycs,|d|jhkrt|ttjj|dSrD)rr7r]rrr r5rrdrrr$scCst|tjjS)z+The desired blend mode for this path/group.)rLr BLEND_MODEr5rgrrrr+szGraphicsStyle.blend_modecs<||jkrttjj|nttjjt|jdSrD)rr]rrr r5r rr+r5rdrrr0s   cCst|tjjS)z-The desired stroke width for this path/group.)rLr STROKE_WIDTHr5rgrrrr9szGraphicsStyle.stroke_widthcsHt|tttjtdt|jfs2tdt|t t j j |dS)Nz#stroke_width must be a number, not ) rJrfloatdecimalDecimaltyperrXr]rrr r5)r+widthrdrrr>s cCst|tjjS)z1The desired stroke cap style for this path/group.)rLrSTROKE_CAP_STYLEr5rgrrrrHszGraphicsStyle.stroke_cap_stylecs:||jkrttjj|nttjjt|dSrD)rr]rrrr5r rr rdrrrMs  cCst|tjjS)z2The desired stroke join style for this path/group.)rLrSTROKE_JOIN_STYLEr5rgrrrrVszGraphicsStyle.stroke_join_stylecs:||jkrttjj|nttjjt|dSrD)rr]rrrr5rrr rdrrr[s  cCst|tjjS)z3The desired stroke miter limit for this path/group.)rLrSTROKE_MITER_LIMITr5rgrrrresz GraphicsStyle.stroke_miter_limitcs:||jkst|tr(ttjj|nt|ddS)Nz is not a number) rrJrQr]rrrr5rXr rdrrrjscCs|jS)z4The desired stroke dash pattern for this path/group.)_stroke_dash_patternrgrrrrqsz!GraphicsStyle.stroke_dash_patterncs|dkrd}n||jkr|}nvt|tr0|f}ndz6g}|D](}t|tsXtd|d||q:Wn&tk rtd|ddYnX|}td|dS)Nrzstroke_dash_pattern z sequence has non-numeric valuez( must be a number or sequence of numbersr)rrJrQrXrWr]r)r+r5resultaccumrrdrrrvs,     cCs|jS)zAThe desired stroke dash pattern phase offset for this path/group.)_stroke_dash_phasergrrrrszGraphicsStyle.stroke_dash_phasecs4||jkst|tr"td|St|ddS)Nrz( isn't a number or GraphicsStyle.INHERIT)rrJrQr]rrXr rdrrrscCst}|jD],}t|||j}||jk r |dk r |||<q |jr`|j|jk r`|j|jg|tjj<|j dkr|j D]}||krp||=qp|rt d}t d||<|j |ddt |SdS)z Convert this style object to a PDF dictionary with appropriate style keys. Only explicitly specified values are emitted. NFTypeZ ExtGState)last)rPDF_STYLE_KEYSrLrrrrrr5rTRANSPARENCY_KEYSr move_to_endrE)r+rrZr5 type_namerrrr(s&      zGraphicsStyle.serializecCs|jtjkrt}|jdk r0|jdk r0|d|jdk r^|d|jdk sRt ||jz|j t |}Wqt k rtj }YqXn|j|jkrtj }n|j}|S)z Resolve `PathPaintRule.AUTO` to a real paint rule based on this style. Returns: the resolved `PathPaintRule`. Nrr)rr AUTOsetrraddrrAssertionError_PAINT_RULE_LOOKUP frozensetr)STROKE_FILL_NONZEROr)r+ZwantZrulerrrresolve_paint_rules       z GraphicsStyle.resolve_paint_rule)3r.r/rr0rrrrr5r r rrr%r rZSTROKEr NONZEROZ FILL_NONZEROZEVENODDZ FILL_EVENODDr&ZSTROKE_FILL_EVENODDr$rrrrrrvrsetterrrrrrrrrrrrrrrr(rr'rwrrrdrr%9s                         *r%cCs|dS)Nz mrptrrr _render_movesr-cCs|dS)Nz lr*r+rrr _render_linesr.cCs"|d|d|dS)NrCz cr*)ctrl1ctrl2endrrr _render_curvesr2c@s>eZdZUdZeed<eddZeddZ eddZ d S) Movez A path move element. If a path has been created but not yet painted, this will create a new subpath. See: `PaintedPath.move_to` r,cCs|jSz#The end point of this path element.r+rgrrr end_pointszMove.end_pointcCst|j||jfSa Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is `self` )r-r,r+ gsd_registryr'r initial_pointrrrrsz Move.renderc Cs2|||||\}}}|t|d|||fS)a0 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `Move.render`. rrwriterM r+r8r'rr9 debug_streampfxrenderedZresolvedrrr render_debugs zMove.render_debugN r.r/rr0rrrvr5rrr@rrrrr3s   r3c@s2eZdZUdZeed<eddZeddZdS) RelativeMovez A path move element with an end point relative to the end of the previous path element. If a path has been created but not yet painted, this will create a new subpath. See: `PaintedPath.move_relative` r,cCs|j|j}t|t||fS)a Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is the resolved `Move` )r5r,r-r3r+r8r'rr9pointrrrrGs zRelativeMove.renderc Cs6|||||\}}}||d|d|||fS)a8 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RelativeMove.render`. resolved to rrr;r<rrrr@[s zRelativeMove.render_debugN r.r/rr0rrrrr@rrrrrB:s   rBc@s>eZdZUdZeed<eddZeddZ eddZ d S) Linez A path line element. This draws a straight line from the end point of the previous path element to the point specified by `pt`. See: `PaintedPath.line_to` r,cCs|jSr4r+rgrrrr5szLine.end_pointcCst|j||fSr6)r.r,r7rrrrsz Line.renderc Cs2|||||\}}}|t|d|||fS)a0 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `Line.render`. rr:r<rrrr@s zLine.render_debugNrArrrrrH{s    rHc@s2eZdZUdZeed<eddZeddZdS) RelativeLinead A path line element with an endpoint relative to the end of the previous element. This draws a straight line from the end point of the previous path element to the point specified by `last_item.end_point + pt`. The absolute coordinates of the end point are resolved during the rendering process. See: `PaintedPath.line_relative` r,cCs|j|j}t|t||fS) Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is the resolved `Line`. )r5r,r.rHrCrrrrs zRelativeLine.renderc Cs6|||||\}}}||d|d|||fS)a8 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RelativeLine.render`. rErrFr<rrrr@s zRelativeLine.render_debugNrGrrrrrIs   rIc@s2eZdZUdZeed<eddZeddZdS)HorizontalLinez A path line element that takes its ordinate from the end of the previous element. See: `PaintedPath.horizontal_line_to` rcCs$t|j|jjd}t|t||fSrJr)rrr5r}r.rHr+r8r'rr9r5rrrr szHorizontalLine.renderc Cs6|||||\}}}||d|d|||fS)a: Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `HorizontalLine.render`. rErrFr<rrrr@s zHorizontalLine.render_debugN r.r/rr0rrrrr@rrrrrKs  rKc@s2eZdZUdZeed<eddZeddZdS)RelativeHorizontalLinez A path line element that takes its ordinate from the end of the previous element and computes its abscissa offset from the end of that element. See: `PaintedPath.horizontal_line_relative` rcCs,t|jj|j|jjd}t|t||fSrLrr5rr}r.rHrMrrrrMszRelativeHorizontalLine.renderc Cs6|||||\}}}||d|d|||fS)aB Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RelativeHorizontalLine.render`. rErrFr<rrrr@as z#RelativeHorizontalLine.render_debugNrNrrrrrO?s  rOc@s2eZdZUdZeed<eddZeddZdS) VerticalLinez A path line element that takes its abscissa from the end of the previous element. See: `PaintedPath.vertical_line_to` r}cCs$t|jj|jd}t|t||fSrLrPrMrrrrszVerticalLine.renderc Cs6|||||\}}}||d|d|||fS)a8 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `VerticalLine.render`. rErrFr<rrrr@s zVerticalLine.render_debugNrNrrrrrQs  rQc@s2eZdZUdZeed<eddZeddZdS)RelativeVerticalLinez A path line element that takes its abscissa from the end of the previous element and computes its ordinate offset from the end of that element. See: `PaintedPath.vertical_line_relative` r}cCs,t|jj|jj|jd}t|t||fSrLrPrMrrrrszRelativeVerticalLine.renderc Cs6|||||\}}}||d|d|||fS)a@ Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RelativeVerticalLine.render`. rErrFr<rrrr@s z!RelativeVerticalLine.render_debugNrNrrrrrRs  rRc@sNeZdZUdZeed<eed<eed<eddZeddZ ed d Z d S) BezierCurveu A cubic Bézier curve path element. This draws a Bézier curve parameterized by the end point of the previous path element, two off-curve control points, and an end point. See: `PaintedPath.curve_to` c1c2r1cCs|jSr4r1rgrrrr5szBezierCurve.end_pointcCst|j|j|j||fSr6)r2rTrUr1r7rrrrszBezierCurve.renderc Cs2|||||\}}}|t|d|||fS)a7 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `BezierCurve.render`. rr:r<rrrr@)s zBezierCurve.render_debugNrArrrrrSs    rSc@sBeZdZUdZeed<eed<eed<eddZeddZd S) RelativeBezierCurveu A cubic Bézier curve path element whose points are specified relative to the end point of the previous path element. See: `PaintedPath.curve_relative` rTrUr1c Cs@|j}||j}||j}||j}t|||t|||d|fS)a  Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is the resolved `BezierCurve`. )rTrUr1)r5rTrUr1r2rS) r+r8r'rr9 last_pointrTrUr1rrrr\s     zRelativeBezierCurve.renderc Cs6|||||\}}}||d|d|||fS)a? Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RelativeBezierCurve.render`. rErrFr<rrrr@ys z RelativeBezierCurve.render_debugNrGrrrrrWIs  rWc@sNeZdZUdZeed<eed<eddZddZe dd Z e d d Z d S) QuadraticBezierCurveu A quadratic Bézier curve path element. This draws a Bézier curve parameterized by the end point of the previous path element, one off-curve control point, and an end point. See: `PaintedPath.quadratic_curve_to` ctrlr1cCs|jSr4rVrgrrrr5szQuadraticBezierCurve.end_pointcCs|j}|j}t|jd|j|jd|jd|j|jdd}t|jd|j|jd|jd|j|jdd}t|||S)Nrrr)rZr1rrr}rS)r+Z start_pointrZr1r/r0rrrto_cubic_curvesz#QuadraticBezierCurve.to_cubic_curvecCs"||j||||d||fS)a Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is `self`. r)r[r5rr7rrrrs zQuadraticBezierCurve.renderc Cs>|||||\}}}||d||jd|||fS)a@ Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `QuadraticBezierCurve.render`. rErrr;r[r5r<rrrr@s z!QuadraticBezierCurve.render_debugN) r.r/rr0rrrvr5r[rrr@rrrrrYs    rYc@s:eZdZUdZeed<eed<eddZeddZdS) RelativeQuadraticBezierCurveu A quadratic Bézier curve path element whose points are specified relative to the end point of the previous path element. See: `PaintedPath.quadratic_curve_relative` rZr1c Cs6|j}||j}||j}t||d}|||||S)a Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is the resolved `QuadraticBezierCurve`. )rZr1)r5rZr1rYr) r+r8r'rr9rXrZr1absoluterrrr s    z#RelativeQuadraticBezierCurve.renderc CsD|||||\}}}||d|d||jd|||fS)aH Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RelativeQuadraticBezierCurve.render`. rEz then to rr\r<rrrr@ s z)RelativeQuadraticBezierCurve.render_debugNrGrrrrr]s  r]c@sjeZdZUdZeed<eed<eed<eed<eed<ee ddZ d d Z e d d Z e d dZ dS)Arcz An elliptical arc path element. The arc is drawn from the end of the current path element to its specified end point using a number of parameters to determine how it is constructed. See: `PaintedPath.arc_to` radiirlargesweepr1ccst|}|}tjd}t||}||}t|}t|}dt|d}td|}t||||||} t||} t|D]6} ||} t | } || | | | | fV||8}qdS)uq A generator that subdivides a swept angle into segments no larger than a quarter turn. Any sweep that is larger than a quarter turn is subdivided into as many equally sized segments as necessary to prevent any individual segment from being larger than a quarter turn. This is used for approximating a circular curve segment using cubic Bézier curves. This computes the parameters used for the Bézier approximation up front, as well as the transform necessary to place the segment in the correct position. Args: sweep_angle (Number): the angle to subdivide. Yields: A tuple of (ctrl1, ctrl2, end) representing the control and end points of the cubic Bézier curve approximating the segment as a unit circle centered at the origin. rgUUUUUU?rrN) absrpiceilrrtanrrrr)Z sweep_angleZ sweep_leftZ quarterturnchunksZ sweep_segmentZcos_tZsin_tkappar/r0r1_offset transformrrrsubdivde_sweepT s        zArc.subdivde_sweepcCs\|j}t|j }t|j}|j|jd|}|j|jd|j|jd}|dkr|t|d|j|d|jd}|j|j k|j|j k}|j|jd}|j|jd} |j|jd} |t t || | d| | t|j|j|j|j |j|jd} | ||j|jd} t|j| j|j|j| j|jd} t|j | j|j|j | j|jd}tdd | }| |}|j dkr|dkr|t j8}n |j dkr|dkr|t j7}|dk|dk}tjd|d||j|j|j| j| j}g}||D]*\}}}|t||||||q,|S) z Approximate this arc with a sequence of `BezierCurve`. Args: last_item: the previous path element (used for its end point) Returns: a list of `BezierCurve`. rrrrrrFT)r`rrr5r1rr}rrarbrsqrtrrtaurrrrrlrWrS)r+rr`reverseZforwardprimeZlam_darZrxry2Zrxpy2Zrypx2Z centerprimecenterZarcstartZarcendrZ deltathetaZ sweep_signZfinal_tfcurvesr/r0r1rrr_approximate_arc sl        zArc._approximate_arccsP||}|sd|fSdfddt|f|dd|D|dfS) Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is a resolved `BezierCurve`. rrCc3s&|]\}}||dVqdSrNr*rGprevcurver8r9r'rrrI szArc.render..Nrf)rsrTzip)r+r8r'rr9rrrryrr s z Arc.renderc s||}||d|s4||dd|fS|g}|ddD]$} || ||d| dqF||d|ddd fd d t||D|dfS) a/ Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `Arc.render`.  resolved to:  └─ nothing rNrf ├─ r └─ rCc3s&|]\}}||dVqdSrur*rvryrrrI sz#Arc.render_debug..)rsr;rWrTrz) r+r8r'rr9r=r>rrpreviousrxrryrr@ s   zArc.render_debugN)r.r/rr0rrrrP staticmethodrrlrsrr@rrrrr_= s   -I r_c@sReZdZUdZeed<eed<eed<eed<eed<eddZ ed d Z d S) RelativeArcz An elliptical arc path element. The arc is drawn from the end of the current path element to its specified end point using a number of parameters to determine how it is constructed. See: `PaintedPath.arc_relative` r`rrarbr1cCs,t|j|j|j|j|j|j||||S)rt)r_r`rrarbr5r1rr7rrrr/ s zRelativeArc.rendercCs@||dt|j|j|j|j|j|j||||||S)a7 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RelativeArc.render`. rE) r;r_r`rrarbr5r1r@r+r8r'rr9r=r>rrrr@G s zRelativeArc.render_debugN) r.r/rr0rrrrPrrr@rrrrr s   rc@s:eZdZUdZeed<eed<eddZeddZdS) RectanglezA pdf primitive rectangle.orgsizecCs(|jd|jdt|j|fS)a Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is a `Line` back to the rectangle's origin. rCz re)rrrrHr7rrrrr szRectangle.renderc Cs6|||||\}}}||d|d|||fS)a5 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `Rectangle.render`. rErrFr<rrrr@ s zRectangle.render_debugNrGrrrrrj s  rc@sJeZdZUdZeed<eed<eed<ddZeddZed d Z d S) RoundedRectanglezM A rectangle with rounded corners. See: `PaintedPath.rectangle` rr corner_radiic Csjg}|jjdkr |jjdkr nF|jjdks8|jjdkrn|t|j|t|j|j|tn|jjdks|jjdkr|t |j|jn|j\}}|j\}}|j\}}|jjdk|jjdk}|jjdk|jjdk} t |t |kr|jj}t |t |kr |jj}|t |}| t |}t ||} |tt ||||tt |||||t | dddt |||||tt ||||||t | dddt ||||||tt |||||t | dddt |||||tt ||||t | dddt ||||t|SNrFT) rrr}rWr3rrHCloserrrcrr_) r+rVrr}whrxryZ sign_widthZ sign_heightarc_radrrr _decompose s@      $ ($  zRoundedRectangle._decomposec CsX|}|sd|fSg}|D]$}|||||\}}}||qd|t|j|fS)a Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is a resolved `Line`. rrC)rrrWrTrHr r+r8r'rr9 components render_listrr?rrrr s  zRoundedRectangle.renderc Cs|}||d|s2||dd|fSg}|ddD]:} | ||||\} }}||d| d|| qB|d||||\} }}||d|dd|| d |t|j|fS) a< Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `RoundedRectangle.render`. r{r|rNrfr}rr~rC)rr;rrWrTrHr r+r8r'rr9r=r>rrrr?rrrr@ s0    zRoundedRectangle.render_debugN r.r/rr0rrrrrr@rrrrr s ) rc@sBeZdZUdZeed<eed<ddZeddZedd Z d S) Ellipsez5 An ellipse. See: `PaintedPath.ellipse` r`rqc Csg}t|jj}t|jj}|j\}}t||}|dkr|dkr|tt||||t|dddt||||t|dddt||||t|dddt||||t|dddt||||t |Sr) rcr`rr}rqrrWr3r_r)r+rVrrcxcyrrrrr: s         zEllipse._decomposec CsX|}|sd|fSg}|D]$}|||||\}}}||qd|t|j|fS)a Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is a resolved `Move` to the center of the ellipse. rrC)rrrWrTr3rqrrrrrO s  zEllipse.renderc Cs|}||d|s2||dd|fSg}|ddD]:} | ||||\} }}||d| d|| qB|d||||\} }}||d|dd|| d |t|j|fS) a3 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `Ellipse.render`. r{r|rNrfr}rr~rC)rr;rrWrTr3rqrrrrr@m s0    zEllipse.render_debugNrrrrrr. s  rc@s(eZdZdZeddZeddZdS) ImplicitClosezw A path close element that is conditionally rendered depending on the value of `GraphicsStyle.auto_close`. cCs|jrd||fSd||fS) Render this path element to its PDF representation. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command Returns: a tuple of `(str, new_last_item)`, where `new_last_item` is whatever the old last_item was. rr)rr7rrrr s zImplicitClose.renderc Cs6|||||\}}}||d|d|||fS)a9 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `ImplicitClose.render`. rErrFr<rrrr@ s zImplicitClose.render_debugNr.r/rr0rrr@rrrrr s  rc@s(eZdZdZeddZeddZdS)rz A path close element. Instructs the renderer to draw a straight line from the end of the last path element to the start of the current path. See: `PaintedPath.close` cCsdt||fS)rr)r3r7rrrr sz Close.renderc Cs2|||||\}}}|t|d|||fS)a1 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `Close.render`. rr:r<rrrr@ s zClose.render_debugNrrrrrr s   rc@s>eZdZdZddZdddZeddZd d Zd d Z d S)DrawingContextz Base context for a drawing in a PDF This context is not stylable and is mainly responsible for transforming path drawing coordinates into user coordinates (i.e. it ensures that the output drawing is correctly scaled). cCs g|_dSrD) _subitemsrgrrrr szDrawingContext.__init__TcCs:t|ttfst|d|r*t|}|j|dS)a Append an item to this drawing context Args: item (GraphicsContext, PaintedPath): the item to be appended. _copy (bool): if true (the default), the item will be copied before being appended. This prevents modifications to a referenced object from "retroactively" altering its style/shape and should be disabled with caution. z# doesn't belong in a DrawingContextN)rJGraphicsContext PaintedPathrXcopydeepcopyrrWr+r_copyrrradd_item# s  zDrawingContext.add_itemcCs\d|_tj|_tj|_t|}tj dddj d|dd | |\}}d|g}|||fS)NTrrfrrrq) rr r rr r(rr3rrrrr)r' first_pointrheightrrrrr_setup_render_prereqs7 sz$DrawingContext._setup_render_prereqsc Cs|js dS|||||\}}}|jD](} | ||||\} }}| r&|| q&t|dkr`dS||} | dk r|dt| d|dt|jdt |j d|dd |S) a Render the drawing context to PDF format. Args: gsd_registry (GraphicsStateDictRegistry): the parent document's graphics state registry. first_point (Point): the starting point to use if the first path element is a relative element. scale (Number): the scale factor to convert from PDF pt units into the document's semantic units (e.g. mm or in). height (Number): the page height. This is used to remap the coordinates to be from the top-left corner of the page (matching fpdf's behavior) instead of the PDF native behavior of bottom-left. starting_style (GraphicsStyle): the base style for this drawing context, derived from the document's current style defaults. Returns: A string composed of the PDF representation of all the paths and groups in this context (an empty string is returned if there are no paths or groups) rrN gsrrC dQ) rrrrWr*r-insertrErr<rrT) r+r8rrrstarting_stylerr'rrr?style_dict_namerrrrI s<       zDrawingContext.renderc Cs|||||\}}} |d|jddD]2} |d| ||| |d\} } | r.|| q.|jr|d|jd||| ||d\} } }| r|| t|dkrd S||} | dk r|dt| d |d t|j d t |j d |dd |Sd S)a Render the drawing context to PDF format. Args: gsd_registry (GraphicsStateDictRegistry): the parent document's graphics state registry. first_point (Point): the starting point to use if the first path element is a relative element. scale (Number): the scale factor to convert from PDF pt units into the document's semantic units (e.g. mm or in). height (Number): the page height. This is used to remap the coordinates to be from the top-left corner of the page (matching fpdf's behavior) instead of the PDF native behavior of bottom-left. starting_style (GraphicsStyle): the base style for this drawing context, derived from the document's current style defaults. debug_stream (TextIO): a text stream to which a debug representation of the drawing structure will be written. Returns: A string composed of the PDF representation of all the paths and groups in this context (an empty string is returned if there are no paths or groups) zROOT Nrfr} │ r~ rrrrrCrr) rr;rr@rWr*r-rrErr<rrT) r+r8rrrrr=rr'rrr?rrrrr@~ sX            zDrawingContext.render_debugN)T) r.r/rr0rrrrrr@rrrrr s  5rc@sneZdZdZdIddZddZeddZed d Zej d d Zed d Z e j dd Z eddZ e j ddZ eddZ e j ddZ e dJddZe ddZdKddZddZdLddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Z dd?Z"d@dAZ#dBdCZ$dMdEdFZ%dGdHZ&dDS)Nrab A path to be drawn by the PDF renderer. A painted path is defined by a style and an arbitrary sequence of path elements, which include the primitive path elements (`Move`, `Line`, `BezierCurve`, ...) as well as arbitrarily nested `GraphicsContext` containing their own sequence of primitive path elements and `GraphicsContext`. rcCs2t|_|j|_d|_|j|_tt|||_dS)NT)r_root_graphics_context_graphics_context_closed_close_contextr3r _starter_moverrrrr s zPaintedPath.__init__cCsP|j|jk rtd|d|}t|j||_|j|_|j|_|j|_|S)Nzcannot copy path z while it is being modified)rr RuntimeErrorrerrrrr+rrrrrr s zPaintedPath.__deepcopy__cCs|jjS)z9The `GraphicsStyle` applied to all elements of this path.)rr'rgrrrr' szPaintedPath.stylecCs|jjS)zAThe `Transform` that applies to all of the elements of this path.rrkrgrrrrk szPaintedPath.transformcCs ||j_dSrDrr+tfrrrrk scCs|jjS)zDIf true, the path should automatically close itself before painting.r'rrgrrrr szPaintedPath.auto_closecCs ||j_dSrDr)r+Zshouldrrrr scCs|jjS)zCManually specify the `PathPaintRule` to use for rendering the path.r'rrgrrrr szPaintedPath.paint_rulecCs ||j_dSrDr)r+r'rrrr scCs|jjS)z$Set the clipping path for this path.r clipping_pathrgrrrr szPaintedPath.clipping_pathcCs ||j_dSrDrr+Z new_clipathrrrr sTccs8|j}t}||_z|V|r(||W5||_XdSrD)rrr)r+Z_attachZold_graphics_contextZnew_graphics_contextrrr_new_graphics_context sz!PaintedPath._new_graphics_contextc cs$|}||_|VW5QRXdS)zY Apply the provided `Transform` to all points added within this context. N)rrk)r+rkZctxtrrrtransform_group s zPaintedPath.transform_groupcCsD|jdk r0d|_|jj|jdd|j|_d|_|jj||ddS)a Add the given element as a path item of this path. Args: item: the item to add to this path. _copy (bool): if true (the default), the item will be copied before being appended. This prevents modifications to a referenced object from "retroactively" altering its style/shape and should be disabled with caution. NFr)rrrrrrrrradd_path_element! s zPaintedPath.add_path_elementcCs|jdSrD)rremove_last_itemrgrrrremove_last_path_element4 sz$PaintedPath.remove_last_path_elementcCsF||jtt||t||t||ddd|_||||S)a Append a rectangle as a closed subpath to the current path. If the width or the height are 0, the rectangle will be collapsed to a line (unless they're both 0, in which case it's collapsed to nothing). Args: x (Number): the abscissa of the starting corner of the rectangle. y (Number): the ordinate of the starting corner of the rectangle. w (Number): the width of the rectangle (if 0, the rectangle will be rendered as a vertical line). h (Number): the height of the rectangle (if 0, the rectangle will be rendered as a horizontal line). rx (Number): the x-radius of the rectangle rounded corner (if 0 the corners will not be rounded). ry (Number): the y-radius of the rectangle rounded corner (if 0 the corners will not be rounded). Returns: The path, to allow chaining method calls. FrT)_insert_implicit_close_if_openrrrrmove_to)r+rr}rrrrrrr rectangle7 s zPaintedPath.rectanglecCs|||||S)a[ Append a circle as a closed subpath to the current path. Args: cx (Number): the abscissa of the circle's center point. cy (Number): the ordinate of the circle's center point. r (Number): the radius of the circle. Returns: The path, to allow chaining method calls. )ellipse)r+rrr`rrrcircleW s zPaintedPath.circlecCs>||jtt||t||ddd|_||||S)a Append an ellipse as a closed subpath to the current path. Args: cx (Number): the abscissa of the ellipse's center point. cy (Number): the ordinate of the ellipse's center point. rx (Number): the x-radius of the ellipse. ry (Number): the y-radius of the ellipse. Returns: The path, to allow chaining method calls. FrT)rrrrrr)r+rrrrrrrre s   zPaintedPath.ellipsecCs|tt|||_|S)a Start a new subpath or move the path starting point. If no path elements have been added yet, this will change the path starting point. If path elements have been added, this will insert an implicit close in order to start a new subpath. Args: x (Number): abscissa of the (sub)path starting point. y (Number): ordinate of the (sub)path starting point. Returns: The path, to allow chaining method calls. )rr3rrrrrrry szPaintedPath.move_tocCsF||jdk r2d|_|jj|jdd|j|_tt|||_|S)a Start a new subpath or move the path start point relative to the previous point. If no path elements have been added yet, this will change the path starting point. If path elements have been added, this will insert an implicit close in order to start a new subpath. This will overwrite an absolute move_to as long as no non-move path items have been appended. The relative position is resolved from the previous item when the path is being rendered, or from 0, 0 if it is the first item. Args: x (Number): abscissa of the (sub)path starting point relative to the. y (Number): ordinate of the (sub)path starting point relative to the. NFr)rrrrrrrBrrrrr move_relative s zPaintedPath.move_relativecCs|jtt||dd|S)z Append a straight line to this path. Args: x (Number): abscissa the line's end point. y (Number): ordinate of the line's end point. Returns: The path, to allow chaining method calls. Fr)rrHrrrrrline_to s zPaintedPath.line_tocCs|jtt||dd|S)a Append a straight line whose end is computed as an offset from the end of the previous path element. Args: x (Number): abscissa the line's end point relative to the end point of the previous path element. y (Number): ordinate of the line's end point relative to the end point of the previous path element. Returns: The path, to allow chaining method calls. Fr)rrIr)r+dxdyrrr line_relative szPaintedPath.line_relativecCs|jt|dd|S)a. Append a straight horizontal line to the given abscissa. The ordinate is retrieved from the end point of the previous path element. Args: x (Number): abscissa of the line's end point. Returns: The path, to allow chaining method calls. Fr)rrK)r+rrrrhorizontal_line_to s zPaintedPath.horizontal_line_tocCs|jt|dd|S)a Append a straight horizontal line to the given offset from the previous path element. The ordinate is retrieved from the end point of the previous path element. Args: x (Number): abscissa of the line's end point relative to the end point of the previous path element. Returns: The path, to allow chaining method calls. Fr)rrO)r+rrrrhorizontal_line_relative s z$PaintedPath.horizontal_line_relativecCs|jt|dd|S)a, Append a straight vertical line to the given ordinate. The abscissa is retrieved from the end point of the previous path element. Args: y (Number): ordinate of the line's end point. Returns: The path, to allow chaining method calls. Fr)rrQ)r+r}rrrvertical_line_to s zPaintedPath.vertical_line_tocCs|jt|dd|S)a Append a straight vertical line to the given offset from the previous path element. The abscissa is retrieved from the end point of the previous path element. Args: y (Number): ordinate of the line's end point relative to the end point of the previous path element. Returns: The path, to allow chaining method calls. Fr)rrR)r+rrrrvertical_line_relative s z"PaintedPath.vertical_line_relativec Cs8t||}t||}t||} |jt||| dd|S)u Append a cubic Bézier curve to this path. Args: x1 (Number): abscissa of the first control point y1 (Number): ordinate of the first control point x2 (Number): abscissa of the second control point y2 (Number): ordinate of the second control point x3 (Number): abscissa of the end point y3 (Number): ordinate of the end point Returns: The path, to allow chaining method calls. Fr)rrrS) r+x1y1x2y2Zx3Zy3r/r0r1rrrcurve_to s    zPaintedPath.curve_toc Cs8t||}t||}t||} |jt||| dd|S)u Append a cubic Bézier curve whose points are expressed relative to the end point of the previous path element. E.g. with a start point of (0, 0), given (1, 1), (2, 2), (3, 3), the output curve would have the points: (0, 0) c1 (1, 1) c2 (3, 3) e (6, 6) Args: dx1 (Number): abscissa of the first control point relative to the end point of the previous path element dy1 (Number): ordinate of the first control point relative to the end point of the previous path element dx2 (Number): abscissa offset of the second control point relative to the end point of the previous path element dy2 (Number): ordinate offset of the second control point relative to the end point of the previous path element dx3 (Number): abscissa offset of the end point relative to the end point of the previous path element dy3 (Number): ordinate offset of the end point relative to the end point of the previous path element Returns: The path, to allow chaining method calls. Fr)rrrW) r+dx1dy1dx2dy2Zdx3Zdy3Zc1dZc2dr1rrrcurve_relatives    zPaintedPath.curve_relativecCs,t||}t||}|jt||dd|S)u Append a cubic Bézier curve mimicking the specified quadratic Bézier curve. Args: x1 (Number): abscissa of the control point y1 (Number): ordinate of the control point x2 (Number): abscissa of the end point y2 (Number): ordinate of the end point Returns: The path, to allow chaining method calls. Fr)rrrY)r+rrrrrZr1rrrquadratic_curve_to7s  zPaintedPath.quadratic_curve_tocCs,t||}t||}|jt||dd|S)u Append a cubic Bézier curve mimicking the specified quadratic Bézier curve. Args: dx1 (Number): abscissa of the control point relative to the end point of the previous path element dy1 (Number): ordinate of the control point relative to the end point of the previous path element dx2 (Number): abscissa offset of the end point relative to the end point of the previous path element dy2 (Number): ordinate offset of the end point relative to the end point of the previous path element Returns: The path, to allow chaining method calls. Fr)rrr])r+rrrrrZr1rrrquadratic_curve_relativeIs  z$PaintedPath.quadratic_curve_relativec Csp|dks|dkr|||Stt|t|}t|}t|}t|}t||} |jt||||| dd|S)u Append an elliptical arc from the end of the previous path point to the specified end point. The arc is approximated using Bézier curves, so it is not perfectly accurate. However, the error is small enough to not be noticeable at any reasonable (and even most unreasonable) scales, with a worst-case deviation of around 3‱. Notes: - The signs of the radii arguments (`rx` and `ry`) are ignored (i.e. their absolute values are used instead). - If either radius is 0, then a straight line will be emitted instead of an arc. - If the radii are too small for the arc to reach from the current point to the specified end point (`x` and `y`), then they will be proportionally scaled up until they are big enough, which will always result in a half-ellipse arc (i.e. an 180 degree sweep) Args: rx (Number): radius in the x-direction. ry (Number): radius in the y-direction. rotation (Number): angle (in degrees) that the arc should be rotated clockwise from the principle axes. This parameter does not have a visual effect in the case that `rx == ry`. large_arc (bool): if True, the arc will cover a sweep angle of at least 180 degrees. Otherwise, the sweep angle will be at most 180 degrees. positive_sweep (bool): if True, the arc will be swept over a positive angle, i.e. clockwise. Otherwise, the arc will be swept over a negative angle. x (Number): abscissa of the arc's end point. y (Number): ordinate of the arc's end point. rFr)rrrcrPrrrr_) r+rrr large_arcpositive_sweeprr}r`r1rrrarc_to_s"   zPaintedPath.arc_toc Csp|dks|dkr|||Stt|t|}t|}t|}t|}t||} |jt||||| dd|S)un Append an elliptical arc from the end of the previous path point to an offset point. The arc is approximated using Bézier curves, so it is not perfectly accurate. However, the error is small enough to not be noticeable at any reasonable (and even most unreasonable) scales, with a worst-case deviation of around 3‱. Notes: - The signs of the radii arguments (`rx` and `ry`) are ignored (i.e. their absolute values are used instead). - If either radius is 0, then a straight line will be emitted instead of an arc. - If the radii are too small for the arc to reach from the current point to the specified end point (`x` and `y`), then they will be proportionally scaled up until they are big enough, which will always result in a half-ellipse arc (i.e. an 180 degree sweep) Args: rx (Number): radius in the x-direction. ry (Number): radius in the y-direction. rotation (Number): angle (in degrees) that the arc should be rotated clockwise from the principle axes. This parameter does not have a visual effect in the case that `rx == ry`. large_arc (bool): if True, the arc will cover a sweep angle of at least 180 degrees. Otherwise, the sweep angle will be at most 180 degrees. positive_sweep (bool): if True, the arc will be swept over a positive angle, i.e. clockwise. Otherwise, the arc will be swept over a negative angle. dx (Number): abscissa of the arc's end point relative to the end point of the previous path element. dy (Number): ordinate of the arc's end point relative to the end point of the previous path element. rFr)rrrcrPrrrr) r+rrrrrrrr`r1rrr arc_relatives#   zPaintedPath.arc_relativecCs&|jtddd|_|dddS)z9 Explicitly close the current (sub)path. FrTrN)rrrrrgrrrcloseszPaintedPath.closecCs*|js&|jjtdd|j|_d|_dS)NFrT)rrrrrrgrrrrsz*PaintedPath._insert_implicit_close_if_openNc CsT||j||||||\}}}t||j}|d|jd |||fS)NrfrC) rrbuild_render_listr%rr'r'rr5rT) r+r8r'rr9r=r>rrrrrrs zPaintedPath.rendercCs|||||||S)a7 Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `PaintedPath.render`. r*rrrrr@szPaintedPath.render_debug)rr)T)T)rr)NN)'r.r/rr0rrrvr'rkr)rrrrrrrrrrrrrrrrrrrrrrrrrrrrr@rrrrr sd              "01 rcs4eZdZdZd fdd Zd ddZdd ZZS) ClippingPatha3 The PaintedPath API but to be used to create clipping paths. .. warning:: Unless you really know what you're doing, changing attributes of the clipping path style is likely to produce unexpected results. This is because the clipping path styles override implicit style inheritance of the `PaintedPath` it applies to. For example, `clippath.style.stroke_width = 2` can unexpectedly override `paintpath.style.stroke_width = GraphicsStyle.INHERIT` and cause the painted path to be rendered with a stroke of 2 instead of what it would have normally inherited. Because a `ClippingPath` can be painted like a normal `PaintedPath`, it would be overly restrictive to remove the ability to style it, so instead this warning is here. rcstj||dtj|_dS)Nr)r]rr rrrrdrrrszClippingPath.__init__Nc Cs|r|d|jj||||||dd\}}}t||j}|j} | |jkrTtj } n t| j } | } | | j | | j d|||fS)Nz F _push_stackrC)r;rrr%rr'rrr r(r,r'rWr5rT) r+r8r'rr9r=r>r merged_stylerrrrrrs4      zClippingPath.rendercCs|||||||S)a Render this path element to its PDF representation and produce debug information. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). Returns: The same tuple as `ClippingPath.render`. r*rrrrr@HszClippingPath.render_debug)rr)NN)r.r/rr0rrr@rwrrrdrrs  ,rc@seZdZddZddZeddZejddZedd Zejd d Zdd d Z ddZ ddZ e dddZ dedddZdedddZdS)rcCst|_g|_d|_d|_dSrD)r%r' path_items _transform_clipping_pathrgrrrrcszGraphicsContext.__init__cCsL|}t|j||_t|j||_t|j||_t|j||_|SrD) rerrr'rrkrrrrrrrrjs zGraphicsContext.__deepcopy__cCs|jSrDrrgrrrrktszGraphicsContext.transformcCs ||_dSrDrrrrrrkxscCs|jS)z-The `ClippingPath` for this graphics context.rrgrrrr|szGraphicsContext.clipping_pathcCs ||_dSrDrrrrrrsTcCs|rt|}|j|dS)a Add a path element to this graphics context. Args: item: the path element to add. May be a primitive element or another `GraphicsContext` or a `PaintedPath`. _copy (bool): if true (the default), the item will be copied before being appended. This prevents modifications to a referenced object from "retroactively" altering its style/shape and should be disabled with caution. N)rrrrWrrrrrs  zGraphicsContext.add_itemcCs |jd=dS)Nrf)rrgrrrrsz GraphicsContext.remove_last_itemcCs|j|jdS)z:Copy another `GraphicsContext`'s path items into this one.N)rextend)r+Z other_contextrrrrszGraphicsContext.mergeNc Csg}|jr|dk r$||jj|j||j} |dk r|jrX|d|jdg} | jD]L} t| | } | | j k rbt|j| | j krd} nd} | | d| | qb| r|d| D]&}||d|||d q||d n |d d| j h}|j}| j |jj kr8t |j}| j |_ | j}| j}||jks\||jkr||jkrrt |}||_||_||f}nd}||}|dk r| t|d |jj}|jj}||kr| |||kr| ||dk r,| t|d d t|dd|r|jdk r|||d|j|| ||||d\}}}|r|| ||jddD]B}||d||| ||||d\}}}|r| |q||d|jd|| ||||d\}}}|rz| |nh|jdk rF|j|| ||\}}}|rF| ||jD],}||| ||\}}}|rL| |qL|jdk r|d |j|d |r|d d| d|||fS)a Build a list composed of all all the individual elements rendered. This is used by `PaintedPath` and `ClippingPath` to reuse the `GraphicsContext` rendering process while still being able to inject some path specific items (e.g. the painting directive) before the render is collapsed into a single string. Args: gsd_registry (GraphicsStateDictRegistry): the owner's graphics state dictionary registry. style (GraphicsStyle): the current resolved graphics style last_item: the previous path element. initial_point: last position set by a "M" or "m" command debug_stream (io.TextIO): the stream to which the debug output should be written. This is not guaranteed to be seekable (e.g. it may be stdout or stderr). pfx (str): the current debug output prefix string (only needed if emitting more than one line). _push_stack (bool): if True, wrap the resulting render list in a push/pop graphics stack directive pair. Returns: `tuple[list[str], last_item]` where `last_item` is the past path element in this `GraphicsContext` Nr!r"z (inherited)rz: z { rru}┐ rrrCrrr}rrfr~rr)rr;rer.rr'rrrLrrWrrrrrr-rErrr(lowerupperr<rr@rrkr)r+r8r'rr9r=r>rrrZ styles_dbgattrrHZ inheritedZstyle_dbg_lineZ NO_EMIT_SETZ emit_styleZ dash_patternZ dash_phaseZ emit_dashrrrZrendered_cpathri__rr?rrrrs%                                   z!GraphicsContext.build_render_listr&c Cs.|j|||||||d\}}}d|||fS)NrrC)rrT) r+r8r'rr9r=r>rrrrrrUs  zGraphicsContext.renderc Cs|j|||||||dS)Nrr*)r+r8r'rr9r=r>rrrrr@ks zGraphicsContext.render_debug)T)NNT)NNT)T)r.r/rrrrvrkr)rrrrrrrrr@rrrrrbs:       > r)r1r2)N)N)rfrf)N)Ur0rrrre collectionsrcollections.abcr contextlibrtypingrrrenumsr r r r r rrZsyntaxrrutilrrrrrrrrrQr% WHITESPACEZ EOL_CHARSZ DELIMITERScompileZSTR_ESCZ STR_ESC_MAPr$r7r<rEr[rxryrrrrrrrrr%r-r.r2r3rBrHrIrKrOrQrRrSrWrYr]r_rrrrrrrrrrrrrrs    $       C /    "   (Xb5CADB>B>BHP\H\R@n=>+?f