,hdZddlmZddlZGddeZGddeZGdd eZGd d eZGd d eZ GddeZ GddeZ Gdde Z y)zUtility functions and classes.)divisionNceZdZdZdZdZdZdZdZdZ e dZ e d Z e d Z e d Ze d Ze d Zy)Lengthz Base class for length classes Inches, Emu, Cm, Mm, Pt, and Px. Provides properties for converting length values to convenient units. i i@~ii1c.tj||SN)int__new__clsemus K/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/pptx/util.pyr zLength.__new__s{{3$$c2|t|jz S)z1 Floating point length in inches )float_EMUS_PER_INCHselfs rinchesz Length.inchess eD//000rc ||jzS)z Integer length in hundredths of a point (1/7200 inch). Used internally because PowerPoint stores font size in centipoints. )_EMUS_PER_CENTIPOINTrs r centipointszLength.centipoints s t0000rc2|t|jz S)z6 Floating point length in centimeters )r _EMUS_PER_CMrs rcmz Length.cm( eD--...rc|S)z8 Integer length in English Metric Units rs rr z Length.emu/s  rc2|t|jz S)z6 Floating point length in millimeters )r _EMUS_PER_MMrs rmmz Length.mm6rrc2|t|jz S)z1 Floating point length in points )r _EMUS_PER_PTrs rptz Length.pt=rrN)__name__ __module__ __qualname____doc__rrrr r#r propertyrrrr r!r$rrrrr s NLLL%11 11//  // //rrceZdZdZdZy)Inchesz6 Convenience constructor for length in inches cft|tjz}tj||Sr)r rrr )r rr s rr zInches.__new__Js(&60001~~c3''rNr%r&r'r(r rrrr+r+E (rr+ceZdZdZdZy) CentipointszE Convenience constructor for length in hundredths of a point cft|tjz}tj||Sr)r rrr )r rr s rr zCentipoints.__new__Ts(+ ; ;;<~~c3''rNr-rrrr0r0Or.rr0ceZdZdZdZy)Cmz; Convenience constructor for length in centimeters cft|tjz}tj||Sr)r rrr )r rr s rr z Cm.__new__^("v***+~~c3''rNr-rrrr3r3Yr.rr3ceZdZdZdZy)EmuzD Convenience constructor for length in english metric units c@tj|t|Sr)rr r r s rr z Emu.__new__hs~~c3s8,,rNr-rrrr7r7cs -rr7ceZdZdZdZy)Mmz; Convenience constructor for length in millimeters cft|tjz}tj||Sr)r rr r )r r!r s rr z Mm.__new__qr5rNr-rrrr:r:lr.rr:ceZdZdZdZy)PtzC Convenience value class for specifying a length in points cft|tjz}tj||Sr)r rr#r )r pointsr s rr z Pt.__new__{s(&6.../~~c3''rNr-rrrr=r=vr.rr=c$eZdZdZdZddZdZy) lazypropertya@Decorator like @property, but evaluated only on first access. Like @property, this can only be used to decorate methods having only a `self` parameter, and is accessed like an attribute on an instance, i.e. trailing parentheses are not used. Unlike @property, the decorated method is only evaluated on first access; the resulting value is cached and that same value returned on second and later access without re-evaluation of the method. Like @property, this class produces a *data descriptor* object, which is stored in the __dict__ of the *class* under the name of the decorated method ('fget' nominally). The cached value is stored in the __dict__ of the *instance* under that same name. Because it is a data descriptor (as opposed to a *non-data descriptor*), its `__get__()` method is executed on each access of the decorated attribute; the __dict__ item of the same name is "shadowed" by the descriptor. While this may represent a performance improvement over a property, its greater benefit may be its other characteristics. One common use is to construct collaborator objects, removing that "real work" from the constructor, while still only executing once. It also de-couples client code from any sequencing considerations; if it's accessed from more than one location, it's assured it will be ready whenever needed. Loosely based on: https://stackoverflow.com/a/6849299/1902513. A lazyproperty is read-only. There is no counterpart to the optional "setter" (or deleter) behavior of an @property. This is critically important to maintaining its immutability and idempotence guarantees. Attempting to assign to a lazyproperty raises AttributeError unconditionally. The parameter names in the methods below correspond to this usage example:: class Obj(object) @lazyproperty def fget(self): return 'some result' obj = Obj() Not suitable for wrapping a function (as opposed to a method) because it is not callable. c>||_tj||y)aY*fget* is the decorated method (a "getter" function). A lazyproperty is read-only, so there is only an *fget* function (a regular @property can also have an fset and fdel function). This name was chosen for consistency with Python's `property` class which uses this name for the corresponding parameter. N)_fget functoolsupdate_wrapper)rfgets r__init__zlazyproperty.__init__s   t,rNc||S|jj|j}|*|j|}||j|j<|S)aCalled on each access of 'fget' attribute on class or instance. *self* is this instance of a lazyproperty descriptor "wrapping" the property method it decorates (`fget`, nominally). *obj* is the "host" object instance when the attribute is accessed from an object instance, e.g. `obj = Obj(); obj.fget`. *obj* is None when accessed on the class, e.g. `Obj.fget`. *type* is the class hosting the decorated getter method (`fget`) on both class and instance attribute access. )__dict__getr%rC)robjtypevalues r__get__zlazyproperty.__get__sS ;K   / =JJsOE*/CLL ' rctd)aRaises unconditionally, to preserve read-only behavior. This decorator is intended to implement immutable (and idempotent) object attributes. For that reason, assignment to this property must be explicitly prevented. If this __set__ method was not present, this descriptor would become a *non-data descriptor*. That would be nice because the cached value would be accessed directly once set (__dict__ attrs have precedence over non-data descriptors on instance attribute lookup). The problem is, there would be nothing to stop assignment to the cached value, which would overwrite the result of `fget()` and break both the immutability and idempotence guarantees of this decorator. The performance with this __set__() method in place was roughly 0.4 usec per access when measured on a 2.8GHz development machine; so quite snappy and probably not a rich target for optimization efforts. zcan't set attribute)AttributeError)rrKrMs r__set__zlazyproperty.__set__s&233rr)r%r&r'r(rGrNrQrrrrArAs/b -84rrA)r( __future__rrDr rr+r0r3r7r:r=objectrArrrrTss%8/S8/v(V((&(((-&-((((n46n4r