(h5FSrSSKrSSKrSSKrSSKrSSKJr SSKJr SSK J r SSK J r J r Jr SSKJrJrJrJrJrJrJr SS KJrJr SS KJr S S 0rS r\S5r\\\ \RB4r"\\ \RB4r#\$"S5r%\$"S5r&\$"S5r'\RP"S5r)SSSSSSSSS.r*"SS\5r+SSjr,Sr-S r."S!S"\ "S"S#\"4S$\"4S%\"4S&\ \"4/55r/S \S''S(\S)'S*\S+'S,\S-'S.\S/'"S0S1\ "S1S$\"4S&\ \"4/55r0S \S2'S3\S4'S.\S5'"S6S7\ "S7S8\"4S9\"4S:\"4S;\"4S&\ \"4/55r1S \S<'S=\S>'S?\S@'SA\SB'SC\SD'S.\SE'SSFjr2SSGjr3SSHjr4SSIjr5SJr6SKr7"SLSM\ 5r8"SNSO\ 5r9S \SP'S \SQ'S \SR'S \SS'S \ST'S \SU'"SVSW5r:SXr;SYr"S]S^\ 5r?"S_S`\ 5r@"SaSb\ 5rA"ScSd\ 5rB"SeSf\ 5rC"SgSh\ 5rD"SiSj\ 5rE"SkSl\ 5rF"SmSn\ 5rG"SoSp\ 5rH"SqSr\ 5rI"SsSt\ 5rJ"SuSv\ 5rK"SwSx\ 5rL"SySz\ 5rM"S{S|\ 5rN"S}S~\ 5rO"SS\ 5rP"SS5rQ"SS5rR"SS\R5rS"SS5rTg)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_nodocumentFc,S[UR'U$)zQA decorator that forces pdoc not to document the decorated item (class or method)F__pdoc__ __qualname__items HC:\Users\13-19\Desktop\PokeDex\pokedex\Lib\site-packages\fpdf/drawing.pyrrs"'HT   Kc,S[UR'U$)zMA decorator that forces pdoc to document the decorated item (class or method)Trrs rforce_documentr%s#'HT   Krz z z ()<>[]{}/%z[\n\r\t\b\f()\\]z\nz\rz\tz\bz\fz\(z\)z\\)    ()\c"\rSrSrSrSSjrSrg)GraphicsStateDictRegistryFzR A container providing deduplication of graphics state dictionaries across a PDF. cUR5nU(dgX$![a Of=f[S[U535nX0U'U$)NGS) serializeKeyErrorrlen)selfstylesdictnames rregister_style(GraphicsStateDictRegistry.register_styleKsX! ;    bT $%U  s  ++N)r0 GraphicsStyle)__name__ __module__r__firstlineno____doc__r3__static_attributes__r5rrr(r(Fs rr(cJXs=::aU::dO [USUSUS35eU$)Nz not in range [z, ]) ValueError)valueminimummaximums r _check_rangerB]s0  &w &E7/'"WIQGHH LrcFUSRS5RS5$)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)numbers r number_to_strrHds$S\ ! !# & - -c 22rc[U[5(aU$[[USS55(aUR 5nGOpUcSnGOi[U[ 5(aS[ U5S3nGOC[U[5(aSUR5S3nGO[U[5(aSS /UnO[U[5(a [U5nO[U[[45(aS S RS U55-S -nO[U[5(a|/nUR!5HNup4[U["5(d [%S5eUR'[)U5S -[)U5-5 MP SSRU5-S-nO[+SU<35e[U5$)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[ c38# UHn[U5v M g7fN)render_pdf_primitive.0vals r 'render_pdf_primitive..sOYc 4S 9 9Yr=zdict keys must be Namesz<< rz >>z,cannot produce PDF representation for value ) isinstancercallablegetattrr,strrbyteshexbool NumberClassrHlisttuplejoindictitemsrr>appendrS TypeError) primitiveoutput item_listkeyrVs rrSrSts4)S!! ;566$$&   Is # #]9-.a0 Iu % %Y]]_%Q' It $ $6"9- I{ + +y) Ie} - -sxxOYOOORUU It $ $ !)HCc4(( !:;;   $S)C/2Fs2KK  *9--5FymTUU v;rcd^\rSrSrSrSrS U4Sjjr\S5r\S5r S\ 4Sjr S r U=r $) DeviceRGBz+A class representing a PDF DeviceRGB color.rgc|>Ub [U5 [TU] U[U5[U5[U5U5$rRrBsuper__new__)clsrgba __class__s rrtDeviceRGB.__new__s7 = Ow a,q/<?A  rc USS$)zVThe color components as a tuple in order `(r, g, b)` with alpha omitted, in range 0-1.Nr5r/s rcolorsDeviceRGB.colorsCRyrc:[SUR55$)XThe color components as a tuple in order `(r, g, b)` with alpha omitted, in range 0-255.c3,# UH nSU-v M g7fNr5rUvs rrW&DeviceRGB.colors255..2kS1Wkrcrr~s r colors255DeviceRGB.colors2552dkk222rreturncfSRSUR55SUR3-$)NrPc38# UHn[U5v M g7frRrHrTs rrW&DeviceRGB.serialize..Bks c**krYrdrOPERATORr~s rr,DeviceRGB.serialize+xxBdkkBBqEXXXrr5rRr7r8rr9r:rrtpropertyrrr]r,r; __classcell__rzs@rrnrnsS 6 HF 33Y3YYrrnrvrwrxryzDeviceRGB.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.acd^\rSrSrSrSrS U4Sjjr\S5r\S5r S\ 4Sjr S r U=r $) DeviceGrayz,A class representing a PDF DeviceGray color.rwcT>Ub [U5 [TU] U[U5U5$rRrr)rurwryrzs rrtDeviceGray.__new__s& = OwsLOQ77rcHURURUR4$)zTThe color components as a tuple in order (r, g, b) with alpha omitted, in range 0-1.)rwr~s rrDeviceGray.colorssvvtvvtvv%%rc:[SUR55$)rc3,# UH nSU-v M g7frr5rs rrW'DeviceGray.colors255..rrrr~s rrDeviceGray.colors255 rrrcJ[UR5SUR3$)NrP)rHrwrr~s rr,DeviceGray.serializes!'($--99rr5rRrrs@rrrsN 7HF8 &&33:3::rrzDeviceGray.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.acT^\rSrSrSrSrS U4Sjjr\S5rS\ 4Sjr Sr U=r $) DeviceCMYKi+z,A class representing a PDF DeviceCMYK color.kc >Ub [U5 [TU] U[U5[U5[U5[U5U5$rRrr)rucmyrryrzs rrtDeviceCMYK.__new__<s? = Ow a,q/<?LQROUV  rc USS$)zWThe color components as a tuple in order (c, m, y, k) with alpha omitted, in range 0-1.Nr}r5r~s rrDeviceCMYK.colorsDrrrcfSRSUR55SUR3-$)NrPc38# UHn[U5v M g7frRrrTs rrW'DeviceCMYK.serialize..JrrYrr~s rr,DeviceCMYK.serializeIrrr5rR) r7r8rr9r:rrtrrr]r,r;rrs@rrr+s=7HF Y3YYrrrrrrzDeviceCMYK.OPERATORz9The cyan color component. Must be in the interval [0, 1].z DeviceCMYK.czr.rintrange)hexstrhlencharidxs rrrsm fc " "6("5677   S ! !F8#9:;; v;D qyDc$(,DMMM qyDc$(,DEE qy=B1dA=N O=Ncc&sQw'b1=N O SW   qyU1dTUEVWEVcc&sQw/b9EVWXX xOP QQEEPXs%D/D4 D9D>c[U[5(d[US35eURSS5nUR S5(aUR S5(d[ US35eUSSnURS 5n[U5S :Xa%[UVs/sHn[U5PM snS S 06$[U5S:Xa"[UVs/sHn[U5PM sn6$[ US 35es snfs snf)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. rrPzrgb(r%z- does not follow the expected rgb(...) formatrr},ryNz6 could not be interpreted as a rgb(R, G, B[, A]) color) rZr]rhreplacerendswithr>splitr.rr)rgbstrrrs rcolor_from_rgb_stringrs fc " "6("5677 ^^C $F   V $ $FOOC,@,@F8#PQRR Ab\F \\# F 6{af-fc!ff-666 6{af-fc!ff-.. xUV WW ..s C9C>c\rSrSr%Sr\\S'\\S'SrSrSr Sr \ S 5r \ S 5r \ S 5r\ S 5r\r\ S 5r\ S5r\ S5rSrSrg)PointizE An x-y coordinate pair within the two-dimensional coordinate frame. xrc\[UR5S[UR53$)z=Render the point to the string `"x y"` for emitting to a PDF.rPrHrrr~s rrender Point.renders) '(-*?)@AArc[U[5(d[SU<35eURUR-URUR--$)z 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 )rZrrhrrr/others rdot Point.dot sI%''.ui89 9vv$&&577"222rc n[U[5(d[SU<35eURUR-URUR-- nUS:US:- nU[ R "[URU5UR5UR5-- S55-$)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) rZrrhrrmathacosroundrmag)r/r signifiersigns rangle Point.angles(%''8 BC CVVegg%$&&577*:; Q9q=1diidhhuoeiik9Q&RTU VWWWrcFURS-URS--S-$)z 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?rrr~s rr Point.mag7s$ DFFAI%#--rc[U[5(a8[URUR-URUR-S9$[$)a. 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. rrZrrrNotImplementedrs r__add__ Point.__add__Ds> eU # #466EGG+tvv/?@ @rc[U[5(a8[URUR- URUR- S9$[$)z 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. rrrs r__sub__ Point.__sub__Ws> eU # #466EGG+tvv/?@ @rcB[UR*UR*S9$)z Produce a point by negating this point's coordinates. Returns: A Point whose coordinates are this points coordinates negated. r)rrrr~s r__neg__ Point.__neg__isw466'**rc[U[5(a&[URU-URU-5$[ $)z 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. rZrarrrrrs r__mul__ Point.__mul__ss4 e[ ) )%%8 8rc[U[5(a&[URU- URU- 5$[ $)aV 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. rrs r __truediv__Point.__truediv__s4 e[ ) )%%8 8rc[U[5(a&[URU-URU-5$[ $)ao 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. rrs r __floordiv__Point.__floordiv__s4 e[ ) )5$&&E/: :rcD[U[5(a[URUR-UR UR --UR-URUR-URUR --UR-S9$[$)ad 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) rZ Transformrryrrrerxdfrrs r __matmul__Point.__matmul__s|& eY ' '''DFF"UWWtvv%55?''DFF"UWWtvv%55?  rc`S[UR5S[UR5S3$)Nz(x=z, y=r%rr~s r__str__ Point.__str__s+]466*+4 dff0E/FaHHrr5N)r7r8rr9r:Number__annotations__rrrrrrrrr__rmul__rr rrr;r5rrrrsI$ I$B 3$X6 .$"++ H(,4Irrc\rSrSr%Sr\\S'\\S'\\S'\\S'\\S'\\S'\S 5r\S 5r \SS j5r \S 5r \S5r \SSj5r SrSSjrSrSrSSjrSr\S5r\r\S5rSrSrSrg )r ia 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`). ryrxrrrrcU"SSSSSS5$)z] Create a transform representing the identity transform. The identity transform is a no-op. r rr5)rus ridentityTransform.identitys1aAq!$$rcU"SSSSX5$)a 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. r rr5rurrs r translationTransform.translation"s1aAq$$rNc&UcUnU"USSUSS5$)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. rr5rs rscalingTransform.scaling1s# 9A1aAq!$$rcU"[R"U5[R"U5[R"U5*[R"U5SS5$)z 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)ruthetas rrotationTransform.rotationEsC HHUOTXXe_txx.>QRTU  rcLUR[R"U55$)z 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. )r(rradians)rutheta_ds r rotation_dTransform.rotation_dVs||DLL122rc$UcUnU"SX!SSS5$)aX 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. r rr5rs rshearingTransform.shearinges! 9A1aAq!$$rc2U[RX5-$)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. r rr/rrs r translateTransform.translatewsi++A111rc2U[RX5-$)aH 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. )r r"r4s rscaleTransform.scales$i''---rc2U[RU5-$)ao 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. )r r()r/r's rrotateTransform.rotatesi((///rc2U[RU5-$)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. )r r-)r/r,s rrotate_dTransform.rotate_ds i**7333rc2U[RX5-$)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. )r r0r4s rshearTransform.shears i((...rcd[RU*U*5U-[RX5-$)aM 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. r3r4s raboutTransform.abouts0&$$aR!,t3i6K6KA6QQQrc [U[5(a\[URU-URU-UR U-UR U-URU-URU-S9$[$)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. ryrxrrrr) rZrar ryrxrrrrrrs rrTransform.__mul__sh e[ ) )&&5.&&5.&&5.&&5.&&5.&&5.  rc [U[5(GaTURURUR-URUR --URUR-URUR --UR UR-UR UR --UR UR-UR UR --URUR-URUR --UR-URUR-URUR --UR-S9$[$)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. rG) rZr rzryrxrrrrrrs rrTransform.__matmul__s  eY ' '>>&&577"TVVegg%55&&577"TVVegg%55&&577"TVVegg%55&&577"TVVegg%55&&577"TVVegg%55?&&577"TVVegg%55? " rc [UR5S[UR5S[UR5S[UR5S[UR 5S[UR 5S3 U4$)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. rPz cmrHryrxrrrr)r/ last_items rrTransform.renders|TVV$%Q}TVV'<&=QTVV$%Q}TVV'<&=QTVV$%Q}TVV'<&=S B    rcS[UR5S[UR5S[UR5S[UR5S[UR 5S[UR 5S3 $)Nz transform: [rPz 0; z 1]rLr~s rrTransform.__str__(ssTVV$%Q}TVV'<&=TTVV$%Q}TVV'<&=TTVV$%Q}TVV'<&=S B rr5rR)r7r8rr9r:rr classmethodrrr"r(r-r0r5r8r;r>rArDrrrrrrr;r5rrr r s7rI I I I I I%% % %%%&   3 3%%"2".(0"4$/$R*.H, " rr z Transform.az Transform.bz Transform.cz Transform.dz Transform.ez Transform.fc^\rSrSrSrSrSr\RR\RR\RR4r /S\5Q7r \"05\R \"S15\R"\"S\R&15\R(\"S\R*15\R,\"SS\R&15\R.\"SS\R*15\R00r\S5rS rS rU4S jr\S 5r \ RBU4S j5r \S5r"\"RBU4Sj5r"\S5r#\#RBU4Sj5r#\S5r$\$RBU4Sj5r$\S5r%\%RBU4Sj5r%\S5r&\&RBU4Sj5r&\S5r'\'RBU4Sj5r'\S5r(\(RBU4Sj5r(\S5r)\)RBU4Sj5r)\S5r*\*RBU4Sj5r*\S 5r+\+RBU4S!j5r+\S"5r,\,RBU4S#j5r,\S$5r-\-RBU4S%j5r-\S&5r.\.RBU4S'j5r.\S(5r/\/RBU4S)j5r/S*r0\1S+5r2S,r3U=r4$)-r6i9a 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_phasec#b# UH%o[RLdMURv M' g7frR)rSTROKE_DASH_PATTERNr?)rUrs rrWGraphicsStyle.ds! U[URU5(d[URSUS35e[TU]X5 g)Nz does not have style "z " (a typo?))hasattrrzAttributeErrorrs __setattr__)r/r2r?rzs rr}GraphicsStyle.__setattr__sFt~~t,, >>""8kJ  D(rcUR$rR)_allow_transparencyr~s rrT GraphicsStyle.allow_transparencys'''rc$>[TU]SU5$)Nr)rsr}r/rmrzs rrTrsw"#8#>>rcUR$)z*The paint rule to use for this path/group.) _paint_ruler~s rrSGraphicsStyle.paint_rulerc>Uc[TU]S[R5 gXRLa[TU]SU5 g[TU]S[R "U55 g)Nr)rsr}r DONT_PAINTricoercers rrSrsP ; G  }/G/G H LL G  s 3 G  }/C/CC/H IrcUR$)zEIf True, unclosed paths will be automatically closed before stroking.) _auto_closer~s rrUGraphicsStyle.auto_closerrch>USSUR1;a[SU35e[TU] SU5 g)NTFz/auto_close must be a bool or self.INHERIT, not r)rirhrsr}rs rrUrs8 tUDLL1 1McUST T M3/rcUR$)z2The desired intersection rule for this path/group.)_intersection_ruler~s rrVGraphicsStyle.intersection_rule&&&rc>XRLa[TU] SU5 g[TU] S[R"U55 g)Nr)rirsr}r rrs rrVrs; ,,  G  4c : G  46F6M6Mc6R SrcUR$)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_colorr~s rrWGraphicsStyle.fill_colorsrcD>[U[5(a [U5n[U[[[ 45(a0[ TU]SU5 URbURUl ggUbXRLa[ TU]SU5 g[US35e)Nr" doesn't look like a drawing color) rZr]rrnrrrsr}ryrXrirhr/colorrzs rrWrs eS ! !)%0E eiZ@ A A G  u 5ww"$)GG!#m,,!6 G  u 5ug%GHI IrcJ[U[RR5$)z-The desired fill opacity for this path/group.)r\r FILL_ALPHAr?r~s rrXGraphicsStyle.fill_opacityt\44::;;rc>USUR1;a [U5 [TU] [R R U5 grR)rirBrsr}rrr?rs rrXrs7 tT\\* *   L33993?rcUR$)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_colorr~s rrYGraphicsStyle.stroke_colors!!!rc>[U[5(a [U5n[U[[[ 45(aP[ TU]SU5 URbURUl URURLaSUl ggUbXRLa[ TU]SU5 g[US35e)Nrr r) rZr]rrnrrrsr}ryrZr\rirhrs rrYr s eS ! !)%0E eiZ@ A A G  7ww"&+gg#  DLL0$%!1m,,!6 G  7ug%GHI IrcJ[U[RR5$)z/The desired stroke opacity for this path/group.)r\r STROKE_ALPHAr?r~s rrZGraphicsStyle.stroke_opacityt\66<<==rc>USUR1;a [U5 [TU] [R R U5 grR)rirBrsr}rrr?rs rrZr$s7 tT\\* *   L55;;SArcJ[U[RR5$)z+The desired blend mode for this path/group.)r\r BLEND_MODEr?r~s rr[GraphicsStyle.blend_mode+rrc>XRLa)[TU] [RR U5 g[TU] [RR [ R"U5R 5 grR)rirsr}rrr?r rr/r?rzs rr[r0sW LL G  7 7 = =u E G ''--y/?/?/F/L/L rcJ[U[RR5$)z-The desired stroke width for this path/group.)r\r STROKE_WIDTHr?r~s rr\GraphicsStyle.stroke_width9rrc >[U[[[R[ S5[ UR 545(d[S[ U535e[TU]%[RRU5 g)Nz#stroke_width must be a number, not ) rZrfloatdecimalDecimaltyperirhrsr}rrr?)r/widthrzs rr\r>sf  %$t*d4<<6H I  A$u+OP P L55;;UCrcJ[U[RR5$)z1The desired stroke cap style for this path/group.)r\rSTROKE_CAP_STYLEr?r~s rr]GraphicsStyle.stroke_cap_styleHst\::@@AArc>XRLa)[TU] [RR U5 g[TU] [RR [ R"U55 grR)rirsr}rrr?rrrs rr]rMsQ LL G  = = C CU K G --33^5J5J55Q rcJ[U[RR5$)z2The desired stroke join style for this path/group.)r\rSTROKE_JOIN_STYLEr?r~s rr^GraphicsStyle.stroke_join_styleVst\;;AABBrc>XRLa)[TU] [RR U5 g[TU] [RR [ R"U55 grR)rirsr}rrr?rrrs rr^r[sR LL G  > > D De L G ..44&&u- rcJ[U[RR5$)z3The desired stroke miter limit for this path/group.)r\rSTROKE_MITER_LIMITr?r~s rr_ GraphicsStyle.stroke_miter_limitest\<<BBCCrc>XRLd[U[5(a)[TU][ R RU5 g[US35e)Nz is not a number) rirZrarsr}rrr?rhrs rr_rjsG \\ !j &D&D G  ? ? E Eu Mug%567 7rcUR$)z4The desired stroke dash pattern for this path/group.)_stroke_dash_patternr~s rr`!GraphicsStyle.stroke_dash_patternqs(((rcN>UcSnOpXRLaUnO_[U[5(aU4nOF/nUH8n[U[5(d[SUS35eUR U5 M: /UQ7n[ TU]SU5 g![a [SUS35Sef=f)Nr5zstroke_dash_pattern z sequence has non-numeric valuez( must be a number or sequence of numbersr)rirZrarhrgrsr})r/r?resultaccumrrzs rr`rvs =F ll "F { + +XF !D%dK88'25'9XYLL& "uYF 2F;  *5'1YZ s AB B$cUR$)zAThe desired stroke dash pattern phase offset for this path/group.)_stroke_dash_phaser~s rraGraphicsStyle.stroke_dash_phaserrc>XRLd[U[5(a[TU]SU5$[ US35e)Nrz( isn't a number or GraphicsStyle.INHERIT)rirZrarsr}rhrs rrars? LL Juk$B$B7&';UC C5'!IJKKrc [5nURH2n[XUR5nX0RLdM)UcM.X1U'M4 UR(aLURURLa3URUR /U[ RR'URSLaURH nX!;dM X M U(a3[S5n[S5X'URUSS9 [U5$g)z{ Convert this style object to a PDF dictionary with appropriate style keys. Only explicitly specified values are emitted. NFType ExtGState)last)rPDF_STYLE_KEYSr\rir`rarrcr?rTTRANSPARENCY_KEYSr move_to_endrS)r/rrlr? type_names rr,GraphicsStyle.serializes &&CDt||4E\\)0A$s '  # #(@(@ (T((&&>F<3399 :  " "e +--= . V I $[ 1F    yu  5'/ /rc UR[RLa[5nURbUR bUR S5 URb;UR S5 URceUR UR5 UR[U5nU$URURLa[RnU$URnU$![a [RnU$f=f)zt Resolve `PathPaintRule.AUTO` to a real paint rule based on this style. Returns: the resolved `PathPaintRule`. rerf)rSr AUTOsetr\rYaddrWrV_PAINT_RULE_LOOKUP frozensetr-STROKE_FILL_NONZEROri)r/wantrules rresolve_paint_rule GraphicsStyle.resolve_paint_rules ??m00 05D  ,1B1B1N"* --999//0 9..y? __ ,!44D  ??D  9%88  9sC//D  D )rTrUr[rWrXrVrSr]rYr`rar^r_rZr\)5r7r8rr9r:rirhrrr?rrrrrr rSTROKEr NONZERO FILL_NONZEROEVENODD FILL_EVENODDrSTROKE_FILL_EVENODDrrQrprsrxr}rrTsetterrSrUrVrWrXrYrZr[r\r]r^r_r`rar,rrr;rrs@rr6r69s&G]"V %%!!''%% S U< UNU " }//8*}336+3345}7Q7Q6+3345}7Q7Q v/77 8  , , v/77 8  , , :$.")((??   JJ  00 ''TT   J J<<@@ ""JJ">>BB <<>>DDBBCCDD88 ))< <0''LL (T""rr6c(UR5S3$)Nz mrpts r _render_moveriik]" rc(UR5S3$)Nz lrrs r _render_linerrrclUR5SUR5SUR5S3$)NrPz cr)ctrl1ctrl2ends r _render_curvers/lln Qu||~.a ~R @@rcV\rSrSr%Sr\\S'\S5r\ S5r \ S5r Sr g) Moveiz A path move element. If a path has been created but not yet painted, this will create a new subpath. See: `PaintedPath.move_to` rcUR$z#The end point of this path element.rr~s r end_pointMove.end_point wwrcD[UR5XR4$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` )rrr/ gsd_registryr0rM initial_points rr Move.renders DGG$dGG33rcnURXX45upxnUR[U5S-5 XxU4$)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 `Move.render`. rrwriter] r/rr0rMr debug_streampfxrenderedresolveds r render_debugMove.render_debug@0-1KK - )M 3t9t+,=00rr5N r7r8rr9r:rrrrrrr r;r5rrrrsK I% 44"11rrcF\rSrSr%Sr\\S'\S5r\S5r Sr g) RelativeMovei:z 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` rcbURUR-n[U5[U5U4$)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` )rrrrr/rr0rMrpoints rrRelativeMove.renderGs."##dgg-E"DK66rcbURXX45upxnURUSUS35 XxU4$)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 `RelativeMove.render`. resolved to rrrrs rr RelativeMove.render_debug[D0-1KK - )M dV= "=>=00rr5N r7r8rr9r:rrrrr r;r5rrrr:s7 I&77&11rrcV\rSrSr%Sr\\S'\S5r\ S5r \ S5r Sr g) Linei{z 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` rcUR$rrr~s rrLine.end_pointrrc0[UR5X4$r)rrrs rr Line.renders DGG$d99rcnURXX45upxnUR[U5S-5 XxU4$)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 `Line.render`. rrrs rr Line.render_debugr rr5Nr r5rrrr{sK I/ ::"11rrcF\rSrSr%Sr\\S'\S5r\S5r Sr g) RelativeLineiaL 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` rcbURUR-n[U5[U5U4$) 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`. )rrrrrs rrRelativeLine.renders."##dgg-E"DK>>rcbURXX45upxnURUSUS35 XxU4$)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 `RelativeLine.render`. rrrrs rr RelativeLine.render_debugrrr5Nrr5rrr#r#s7 II??&11rr#cF\rSrSr%Sr\\S'\S5r\S5r Sr g)HorizontalLineizz A path line element that takes its ordinate from the end of the previous element. See: `PaintedPath.horizontal_line_to` rc[URURRS9n[ U5[ U5U4$r%r)rrrrrrr/rr0rMrrs rrHorizontalLine.render s6"DFFi&9&9&;&;< I&YFFrcbURXX45upxnURUSUS35 XxU4$)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`. rrrrs rr HorizontalLine.render_debugrrr5N r7r8rr9r:rrrrr r;r5rrr*r*s9 I:GG&11rr*cF\rSrSr%Sr\\S'\S5r\S5r Sr g)RelativeHorizontalLinei?z 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` rc[URRUR-URRS9n[ U5[ U5U4$r,rrrrrrr-s rrRelativeHorizontalLine.renderMsG"I//11DFF:i>Q>Q>S>ST I&YFFrcbURXX45upxnURUSUS35 XxU4$)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 `RelativeHorizontalLine.render`. rrrrs rr #RelativeHorizontalLine.render_debugarrr5Nr1r5rrr3r3?=I GG&11rr3cF\rSrSr%Sr\\S'\S5r\S5r Sr g) VerticalLineizx A path line element that takes its abscissa from the end of the previous element. See: `PaintedPath.vertical_line_to` rc[URRURS9n[ U5[ U5U4$r,r5r-s rrVerticalLine.renders6"I//11TVV< I&YFFrcbURXX45upxnURUSUS35 XxU4$)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 `VerticalLine.render`. rrrrs rr VerticalLine.render_debugrrr5Nr1r5rrr;r;s9 I8GG&11rr;cF\rSrSr%Sr\\S'\S5r\S5r Sr g)RelativeVerticalLineiz 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` rc[URRURRUR-S9n[ U5[ U5U4$r,r5r-s rrRelativeVerticalLine.rendersG"I//11Y5H5H5J5JTVV5ST I&YFFrcbURXX45upxnURUSUS35 XxU4$)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`. rrrrs rr !RelativeVerticalLine.render_debugrrr5Nr1r5rrrArAr9rrAcn\rSrSr%Sr\\S'\\S'\\S'\S5r\ S5r \ S5r S r g ) BezierCurveiu 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` c1c2rcUR$rrr~s rrBezierCurve.end_point xxrc\[URURUR5X4$r)rrHrIrrs rrBezierCurve.renders$ TWWdggtxx8$MMrcnURXX45upxnUR[U5S-5 XxU4$)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 `BezierCurve.render`. rrrs rr BezierCurve.render_debug)r rr5Nr r5rrrGrGs] I* I+ J  NN"11rrGc^\rSrSr%Sr\\S'\\S'\\S'\S5r\S5r Sr g ) RelativeBezierCurveiIu 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` rHrIrcURnXPR-nXPR-nXPR-n[ XgU5[ XgUS9U4$)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`. )rHrIr)rrHrIrrrG) r/rr0rMr last_pointrHrIrs rrRelativeBezierCurve.render\sV"(( '' ! '' !88# "# & 2# .   rcbURXX45upxnURUSUS35 XxU4$)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`. rrrrs rr  RelativeBezierCurve.render_debugyrrr5Nrr5rrrSrSIsO I I JQ  811rrSch\rSrSr%Sr\\S'\\S'\S5rSr \ S5r \ S5r S r g ) QuadraticBezierCurveiu 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` ctrlrcUR$rrKr~s rrQuadraticBezierCurve.end_pointrMrcURnURn[URSURUR- -S- -URSURUR- -S- -S9n[URSURUR- -S- -URSURUR- -S- -S9n[ XEU5$)Nrrr)r[rrrrrG)r/ start_pointr[rrrs rto_cubic_curve#QuadraticBezierCurve.to_cubic_curvesyyhhmma466KMM#9:Q>>mma466KMM#9:Q>> eea466CEE>*Q..eea466CEE>*Q..  5--rcdURUR5RXX45SUU4$)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`rrrs rrQuadraticBezierCurve.rendersB    3 3 4 ; ;Y       rcURXX45upxnURUSURUR5S35 XxU4$)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`. rrrrr`rrs rr !QuadraticBezierCurve.render_debugs[0-1KK - )M fM$"5"5i6I6I"J!K2 N =00rr5N)r7r8rr9r:rrrrr`rrr r;r5rrrZrZsX K$ J   .  ,11rrZcR\rSrSr%Sr\\S'\\S'\S5r\S5r Sr g) RelativeQuadraticBezierCurveiu 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` r[rcURnXPR-nXPR-n[XgS9nUR XX45$)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`. )r[r)rr[rrZr) r/rr0rMrrUr[rabsolutes rr#RelativeQuadraticBezierCurve.render sB (( II%88#'T;|IMMrc URXX45upxnURUSUSURUR5S35 XxU4$)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 `RelativeQuadraticBezierCurve.render`. rz then to rrers rr )RelativeQuadraticBezierCurve.render_debug sh0-1KK - )M fM(,..y/B/BCDB H =00rr5Nrr5rrrhrhsA KU JQNN.11rrhc\rSrSr%Sr\\S'\\S'\\S'\\S'\\S'\ \ S55r S r \ S 5r \ S 5rS rg )Arci= z 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` radiir(largesweeprc## [U5nUn[RS- n[R"X- 5nX- n[R"U5n[R "U5nS[R "US- 5-n[SU5n[XWU--XgU-- 5n [XV5n [U5H-n X- n [RU 5n X-X-X-4v X-nM/ g7f)u 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?rr N) absrpiceilr%r&tanrrr r() sweep_angle sweep_left quarterturnchunks sweep_segmentcos_tsin_tkapparrr_offset transforms rsubdivde_sweepArc.subdivde_sweepT s0+&  ggk ;45#, ''!233aeem+UU]-BCE!vA -F!**62I#U%6G G  'J sC/C1c URn[RUR*5n[RUR5nURUR- S-U-nUR UR - S-UR UR - S--nUS:a*[US-UR -US-UR -S9nURUR:gURUR:H- nUR UR -S-nUR UR -S-n UR UR -S-n U[R"[X- U - S5X-- 5-[UR UR -UR - UR *UR -UR - S9-n X-URUR-S--n [UR U R - UR - UR U R - UR - S9n [UR *U R - UR - UR *U R - UR - S9n[SS5RU 5nU RU5nURSLaUS:aU[R-nO(URSLaUS:aU[R- nUS:US:- n[RSUS9R!U5R#UR UR 5R!UR5R%U R U R 5n/nUR'U5H,unnnUR)[+UU-UU-UU-55 M. U$) 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`. rrr rrrFT)rpr r(rrrrrrqrrrsqrtrrtaur"r;r8r5rrgrG)r/rMrpreverseforwardprimelam_darrxry2rxpy2rypx2 centerprimecenterarcstartarcendr' deltatheta sweep_signfinal_tfcurvesrrrs r_approximate_arcArc._approximate_arc sL $$dmm^4$$T]]3%%0C77B''EGG#)UWWuww->1,DD A:VS[EGG3 uww7NOE djj(TZZ4::-EF577"q(577"q(577"q( iieme3Q75=IJ K''EGG#egg-77(UWW$uww.  'Y-@-@488-Ks,RSww&%''1ww&%''1 x+--'5772x+--'5772  a !!(+^^F+ JJ% j1n $(( "JjjD zA~ $(( "J Ao*q.9   Z  0 VE] U577EGG $ VDMM " Yvxx * !%!4!4Z!@ E5# MMEH,eh.>hO "A  rc ^^^URU5nU(dSU4$SRUUU4Sj[U/USSQU555UST4$) 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`. rrPc3V># UHupURTTUT5Sv M g7frNrrUprevcurverrr0s rrWArc.render.. s.#IKD \5$ FqI#I&)Nr})rrdzip)r/rr0rMrrs `` ` rr Arc.render sh &&y1y=  HH#& '@F3BK'@&#I  2J    rc^^^URU5nURUS35 U(dURUS-5 SU4$U/nUSSH,n URU 5 URUSU S3-5 M. URUSUSS3-5 S RUUU4S j[ X555UST4$) 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 rNr} ├─ r └─ rPc3V># UHupURTTUT5Sv M g7frrrs rrW#Arc.render_debug.. s.#8KD \5$ FqI#8r)rrrgrdr) r/rr0rMrrrrpreviousrs `` ` rr Arc.render_debug s.&&y1dV?34   s%88 9y= ;CR[E OOE "   sxwb%99 :! 38F2J =!!Q&D,=,=,?,?1,D LL488TYY7 8: 788DA99DA&&FB))++*tyy{{Q?J99;;!+ a@K2wQYY[[2wQYY[[c"g%Bs2w&BBmG LLeAFA./ 0 LLeAEBJ23 4 LLWaeAE166JK L LLeAE152:67 8 LLWaeAEBJ6NO P LLeAFAE23 4 LLWaeA1urz6JK L LLeA2v./ 0 LLWaeAFA6FG H LL ! rcUR5nU(dSU4$/nUH)nURXX45upnURU5 M+ SRU5[ UR 5U4$)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`. rrP)rrrgrdrr r/rr0rMr components render_listrrs rrRoundedRectangle.render st __& y=  D15Y2 .H   x (  xx $d488nmCCrcUR5nURUS35 U(dURUS-5 SU4$/nUSSHAn U RXX45upnURUSU S3-5 URU 5 MC USRXX45upnURUSUSS3-5 URU 5 S R U5[ UR 5U4$) 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`. rrrNr}rrrrP)rrrrgrdrr r/rr0rMrrrrrrrs rr RoundedRectangle.render_debug s.__& dV?34   s%88 9y=  sOD15Y2 .H   sxvR%88 9   x ( $.8^-B-B . *] 38JrN+;2!>>?8$xx $d488nmCCrr5N r7r8rr9r:rrrrrr r;r5rrrr sT J/ K0-'RDD:+D+DrrcX\rSrSr%Sr\\S'\\S'Sr\S5r \S5r Sr g ) Ellipsei. z) An ellipse. See: `PaintedPath.ellipse` rprc /n[URR5n[URR5nURupE[ X#5nUS:waUS:waUR [[ XB-U555 UR [USSS[ XEU-555 UR [USSS[ XB- U555 UR [USSS[ XEU- 555 UR [USSS[ XB-U555 UR [55 U$r) rtrprrrrrgrror)r/rfrrcxcyrs rrEllipse._decompose: s    - !G"' LLeBGR01 2 LLWaeBR6HI J LLWaeBGR6HI J LLWaeBR6HI J LLWaeBGR6HI J LL ! rcUR5nU(dSU4$/nUH)nURXX45upnURU5 M+ SRU5[ UR 5U4$)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. rrP)rrrgrdrrrs rrEllipse.renderO su __& y=  D15Y2 .H   x (  xx $d4;;&7FFrcUR5nURUS35 U(dURUS-5 SU4$/nUSSHAn U RXX45upnURUSU S3-5 URU 5 MC USRXX45upnURUSUSS3-5 URU 5 S R U5[ UR 5U4$) 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 `Ellipse.render`. rrrNr}rrrrP)rrrrgrdrrrs rr Ellipse.render_debugm s.__& dV?34   s%88 9y=  sOD15Y2 .H   sxvR%88 9   x ( $.8^-B-B . *] 38JrN+;2!>>?8$xx $d4;;&7FFrr5Nrr5rrrr. sJ L+ M@*GG:+G+Grrc8\rSrSrSr\S5r\S5rSrg) ImplicitClosei zk A path close element that is conditionally rendered depending on the value of `GraphicsStyle.auto_close`. c4UR(aSX44$SX44$) 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)rUrs rrImplicitClose.render s#"    0 09++rcbURXX45upxnURUSUS35 XxU4$)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 `ImplicitClose.render`. rrrrs rr ImplicitClose.render_debug rrr5N r7r8rr9r:rrr r;r5rrrr s/ ,,*11rrc8\rSrSrSr\S5r\S5rSrg)ri z 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` cS[U5U4$)rr)rrs rr Close.render s"D'66rcnURXX45upxnUR[U5S-5 XxU4$)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 `Close.render`. rrrs rr Close.render_debug r rr5Nrr5rrrr s/77$11rrcD\rSrSrSrSrS Sjr\S5rSr Sr Sr g ) DrawingContexti z 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). c/UlgrR _subitemsr~s rrsDrawingContext.__init__ s rc[U[[45(d[US35eU(a[R "U5nUR RU5 g)ag 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)rZGraphicsContext PaintedPathrhcopydeepcopyrrgr/r_copys radd_itemDrawingContext.add_item# sL$+ >??tf$GHI I ==&D d#rcSUl[RUl[R Ul[U5n[RSSS9RSUS- S9RU5RU5up$SU/nXPU4$)NTr r}rrrq) rUr rrSr rrVrr r"rDr8r)r0 first_pointr8heightrMrs r_setup_render_prereqs$DrawingContext._setup_render_prereqs7 s(--"2":":%   R  ( UQ&1*U % U5\ VI  El 9,,rcUR(dgURXRX45upgnURH2n U RXX5upnU (dM!URU 5 M4 [ U5S:XagUR U5n U b]UR S[U 5S35 UR S[UR5S[UR5S3-5 URS5 SRU5$)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) rr gsrrP dQ) rrrrgr.r3insertrSr`rHrard) r/rrr8rstarting_stylerr0rMrrstyle_dict_names rrDrawingContext.renderI s*~~(,(B(B ) % INND/3{{Y0 ,Hx""8, # { q &55e<  &   q%9/%J$K3"O P   $U%>%>?mE$;$;<=R@A  3xx $$rcURXRX45upxn URS5 URSSHCn URS5 U RXXS5upU (dM2UR U 5 ME UR(aURS5 URSRXXUS5upnU (aUR U 5 [ U5S:Xag UR U5n U b]URS[U 5S 35 URS [UR5S [UR5S 3-5 UR S5 S RU5$g )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 Nr}r │ r rrrrrPrr) rrrr rgr.r3rrSr`rHrard) r/rrr8rrrrr0rMrlrrs rr DrawingContext.render_debug~ sv2)-(B(B ) % I 8$^^CR(E   z *"'"4"4Yh# Hx""8, ) >>   z */3~~b/A/N/NY\60 ,H""8,;1$*99%@O*""1)=o)N(Os&ST""()B)BC-(?(?@ADE   s #88K( (rrNT) r7r8rr9r:rsrrrrr r;r5rrrr s1$(--"3%j@rrc\rSrSrSrS)SjrSr\S5r\S5r \ RS5r \S5r \ RS 5r \S 5r \ RS 5r \S 5r \ RS 5r \S*Sj5r\S5rS*SjrSrS)SjrSrSrSrSrSrSrSrSrSrSrSrSrSr S r!S!r"S"r#S#r$S$r%S+S&jr&S'r'S(r(g%),ri aJ 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`. c[5UlURUlSUlURUl[ [ X55Ulg)NT)r_root_graphics_context_graphics_context_closed_close_contextrr _starter_mover4s rrsPaintedPath.__init__ sA&5&7#!%!,>e + L"&"8"8D !%D  ''':rc8URR5 grR)rremove_last_itemr~s rremove_last_path_element$PaintedPath.remove_last_path_element4 s //1rc UR5 UR[[X5[X45[XV55SS9 SUlUR X5 U$)aR 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. Fr>T)_insert_implicit_close_if_openr?rrrmove_to)r/rrrrrrs r rectanglePaintedPath.rectangle7 sW. ++-  U1[%+uR} EU    Q rc&URXX35$)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/rrrvs rcirclePaintedPath.circleW s||BA))rc UR5 UR[[X45[X55SS9 SUlUR X5 U$)aQ 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. Fr>T)rFr?rrrrG)r/rrrrs rrKPaintedPath.ellipsee sJ ++- geBmU2]C5Q  R rcXUR5 [[X55UlU$)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. )rFrrrr4s rrGPaintedPath.move_toy s& ++-!%+. rcUR5 URb<SUlURR URSS9 URUl[ [X55UlU$)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. Fr>)rFrrrrrrrr4s r move_relativePaintedPath.move_relative sf ++-    ) DL  " " + +D,>,>e + L"&"8"8D )%+6 rcJUR[[X55SS9 U$)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>)r?rrr4s rline_toPaintedPath.line_to s% d5;/u= rcJUR[[X55SS9 U$)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>)r?r#r)r/dxdys r line_relativePaintedPath.line_relative s% l5=9G rc8UR[U5SS9 U$)z 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>)r?r*)r/rs rhorizontal_line_toPaintedPath.horizontal_line_to s! nQ/u= rc8UR[U5SS9 U$)aR 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>)r?r3)r/rYs rhorizontal_line_relative$PaintedPath.horizontal_line_relative s" 4R8F rc8UR[U5SS9 U$)z 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>)r?r;)r/rs rvertical_line_toPaintedPath.vertical_line_to s  l1oU; rc8UR[U5SS9 U$)aP 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>)r?rA)r/rZs rvertical_line_relative"PaintedPath.vertical_line_relative s" 226eD rc|[X5n[X45n[XV5n UR[XxU 5SS9 U$)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>)rr?rG) r/x1y1x2y2x3y3rrrs rcurve_toPaintedPath.curve_to s>b b Bm k%)rr?rS) r/dx1dy1dx2dy2dx3dy3c1dc2drs rcurve_relativePaintedPath.curve_relatives?6CoCoCo 1#C@N rcd[X5n[X45nUR[XV5SS9 U$)uB 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>)rr?rZ)r/rjrkrlrmr[rs rquadratic_curve_toPaintedPath.quadratic_curve_to7s4R}Bm 24=UK rcd[X5n[X45nUR[XV5SS9 U$)uP 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>)rr?rh)r/rsrtrurvr[rs rquadratic_curve_relative$PaintedPath.quadratic_curve_relativeIs4"SCo :4EUS rc  US:XdUS:XaURXg5$[[U5[U55n[U5n[R "U5n[U5n[Xg5n UR [XXEU 5SS9 U$)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>)rVrrtr`rr+r?ro) r/rrr( large_arcpositive_sweeprrrprs rarc_toPaintedPath.arc_to_sD 7bAg<<% %c"gs2w'O <<)n-Ak  C @   rc  US:XdUS:XaURXg5$[[U5[U55n[U5n[R "U5n[U5n[Xg5n UR [XXEU 5SS9 U$)u~ 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>)r[rrtr`rr+r?r) r/rrr(rrrYrZrprs r arc_relativePaintedPath.arc_relativesF 7bAg%%b- -c"gs2w'O <<)n-Bm  C HPU   rcfUR[5SS9 SUlURSS5 g)z) Explicitly close the current (sub)path. Fr>TrN)r?rrrSr~s rclosePaintedPath.closes0 egU3  1a rcUR(d;URR[5SS9 URUlSUlgg)NFr>T)rrrrrr~s rrF*PaintedPath._insert_implicit_close_if_opens>||    ( ( ( F"&"8"8D DLrNcUR5 URRXX4XV5unnn[R X R 5R 5nURSUR5 SRU5X44$)Nr}rP) rFrbuild_render_listr6rpr0rrr?rd) r/rr0rMrrrrrSs rrPaintedPath.renders ++-  ' ' 9 9 <     #(( ;NNP 2z//0xx $i>>rc(URXX4XV5$)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 `PaintedPath.render`. rrs rr PaintedPath.render_debugs,{{ <  r)rrrrrrrr NN))r7r8rr9r:rsrxrr0rrrUrSr.rr7r;r?rCrHrLrKrGrSrVr[r^rardrgrpr{r~rrrrrFrr r;r5rrrr s/ 115533%%''%%&&99@@ : :;&2@ *(&0 "   , D$,.`/b! UY?& rrcB^\rSrSrSrSU4SjjrSSjrSrSrU=r $) ClippingPathia 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. cJ>[TU]XS9 [RUlg)Nr)rsrsr rrS)r/rrrzs rrsClippingPath.__init__s  1"'22rc U(aURS5 URRUUUUUUSS9unnn[R X R 5nUR n XRLa[Rn O[U Rn UR5n URU R5 URU R5 SRU5X44$)Nz F _push_stackrP)rrrr6rpr0rVrir rr2rrgr?rd) r/rr0rMrrrr merged_stylerVrSs rrClippingPath.renders    0 1  ' ' 9 9       :    %**5**= (::  4 4 4 < D D  <!&&! "446 ,223:++,xx $i>>rc(URXX4XV5$)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`. rrs rr ClippingPath.render_debugHs*{{ <  r)rSrr) r7r8rr9r:rsrr r;rrs@rrrs$63 UY*?X  rrc\rSrSrSrSr\S5r\RS5r\S5r \ RS5r SSjr S r S r \ SS j5rSS \4SjjrSS \4SjjrSrg )ribcL[5Ul/UlSUlSUlgrR)r6r0 path_items _transform_clipping_pathr~s rrsGraphicsContext.__init__cs!"_ "rcVUR5n[R"URU5Ul[R"URU5Ul[R"UR U5Ul[R"URU5UlU$rR) rzrrr0rrrr.rrs rrxGraphicsContext.__deepcopy__jsp!}}TZZ6  MM$//4@ MM$..$? $ d.@.@$ G rcUR$rRrr~s rrGraphicsContext.transformts rcXlgrRrr s rrrxsrcUR$)z-The `ClippingPath` for this graphics context.rr~s rr.GraphicsContext.clipping_path|s"""rcXlgrRrr1s rr.rs)rctU(a[R"U5nURRU5 g)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)rrrrgrs rrGraphicsContext.add_items' ==&D t$rcURS g)Nr})rr~s rrB GraphicsContext.remove_last_items OOB rcNURRUR5 g)z:Copy another `GraphicsContext`'s path items into this one.N)rextend)r/ other_contexts rrpGraphicsContext.merges }778rNc  /nUR(GaPUb&URURR5 URR X R 5n UGbUR (aURSUR S35 /n U RH^n [X5n XRLdM[UR U 5U RLaSn OSn U RU SU U 35 M` U (aeURS5 U H9nURUS-5 URU5 URS 5 M; URUS -5 OURS 5 SU R1nUR nU RUR R:wa1[R"UR 5nU RUl U RnU RnUUR:wdUUR:wa8UUR La[R"U5nUUlUUlUU4nOSnUR!U5nUbUR[#U5S 35 UR R$nUR R&nUU;a-URUR)5R+55 UU;a-URUR)5R-55 Ub0UR[#US 5S [/US5S3-5 U(GaUR0bSURUS-5 UR0R3UU UUUUS-5unnnU(aURU5 URSSHMnURUS-5 UR3UU UUUUS-5unp4U(dM<URU5 MO URUS-5 URSR3UU UUUUS-5unp4U(aURU5 OUR0b8UR0R5XX45unnnU(aURU5 URH2nUR5XX45unp4U(dM!URU5 M4 UR6b.UR9S UR6R5U5S 5 U(a#UR9S S5 URS5 XU4$)aL 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 { r ru}┐ rrrPr rrr r}rrr)rrrzr7rpr0rrhr\rirgrTrrr`rar3rSrWrYr,lowerupperrHr.r rrr)r/rr0rMrrrrrr styles_dbgattrrV inheritedstyle_dbg_line NO_EMIT_SET emit_style dash_pattern dash_phase emit_dashrrWrYrendered_cpathr__rrs rr!GraphicsContext.build_render_listsJ ???'""dnn&=&=%>@ ??00 CL'?? &&4??*;1'=> (99D!,5C"6"66"4::t4 8L8LL(6I(*I"))TF"SE)*EF: &&v.*4$**3<8$**>:$**40+5 !&&sX~6 &&t,!5!56KJ..$**2O2OO!]]4::6 0<0O0O - (;;L%77J 9 99e555+!%z!:J1= ./9 ,):6  *99*EO*""&:?&K%LC#PQ..J::22L,"":#7#7#9#?#?#AB;.""<#9#9#;#A#A#CD$""(16- ! 56b9: %%1 &&sZ'78,0,>,>,K,K$$!%$h -)NAr&#**>: OOCR0D &&sZ'789=9J9J$$!%$h :6Hi x#**841""3#3459__R5H5U5U  ! &L 62)&&x0%%1,0,>,>,E,E$I-)NAr&#**>: OOD9=$I:6Hi x#**84 ,~~)""1dnn&;&;I&Fq&IJ""1c*""3'}44rr0c XURUUUUUUUS9upnSRU5X44$)NrrP)rrd) r/rr0rMrrrrrs rrGraphicsContext.renderUsJ150F0F      #1G1 - xx $i>>rc ,URUUUUUUUS9$)Nrr)r/rr0rMrrrrs rr GraphicsContext.render_debugks/{{      #  r)rrrr0r )NNT)r7r8rr9rsrxrrrr.rrBrprrrrr r;r5rrrrbs###**%" 9 u5u5z ??<   rr)gg?rR)r}r})Ur:rrrre collectionsrcollections.abcr contextlibrtypingrrrenumsr r r r rrrsyntaxrrutilrrrrrrrrrar WHITESPACE EOL_CHARS DELIMITERScompileSTR_ESC STR_ESC_MAPr(rBrHrSrnrrrrrrrrrr r6rrrrrrr#r*r3r;rArGrSrZrhrorrrrrrrrrrr5rrrs@#$%..  &  sE7??* +E7??+ } % 0 f  9 | $ " **( )           . 3 9F,Y vf V}sHV#(   Y &M &M &M &M (6" #   YD#( VB YW 94$, 0E0%RPX1:>1BA1:A1H?1:?1D;1Z;1|?1Z?1D;1:;1|?1:?1DE1*E1PM1*M1`Y1:Y1xE1:E1PX *X vOY*OYd=1 =1@ADzADHkGjkG\:1J:1z;1J;1|ggTx x vc ;c L[ [ r