Add files using upload-large-folder tool

.venv/lib/python3.13/site-packages/instructor-1.14.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jason Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.venv/lib/python3.13/site-packages/reportlab/graphics/charts/dotbox.py

@@ -0,0 +1,165 @@
+from reportlab.lib.colors import _PCMYK_black
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.shapes import Circle, Drawing, Group, Line, Rect, String
+from reportlab.graphics.widgetbase import Widget
+from reportlab.lib.attrmap import *
+from reportlab.lib.validators import *
+from reportlab.lib.units import cm
+from reportlab.pdfbase.pdfmetrics import getFont
+from reportlab.graphics.charts.lineplots import _maxWidth
+
+class DotBox(Widget):
+    """Returns a dotbox widget."""
+
+    #Doesn't use TypedPropertyCollection for labels - this can be a later improvement
+    _attrMap = AttrMap(
+        xlabels = AttrMapValue(isNoneOrListOfNoneOrStrings,
+            desc="List of text labels for boxes on left hand side"),
+        ylabels = AttrMapValue(isNoneOrListOfNoneOrStrings,
+            desc="Text label for second box on left hand side"),
+        labelFontName = AttrMapValue(isString,
+            desc="Name of font used for the labels"),
+        labelFontSize = AttrMapValue(isNumber,
+            desc="Size of font used for the labels"),
+        labelOffset = AttrMapValue(isNumber,
+            desc="Space between label text and grid edge"),
+        strokeWidth = AttrMapValue(isNumber,
+            desc='Width of the grid and dot outline'),
+        gridDivWidth = AttrMapValue(isNumber,
+            desc="Width of each 'box'"),
+        gridColor = AttrMapValue(isColor,
+            desc='Colour for the box and gridding'),
+        dotDiameter = AttrMapValue(isNumber,
+            desc="Diameter of the circle used for the 'dot'"),
+        dotColor = AttrMapValue(isColor,
+            desc='Colour of the circle on the box'),
+        dotXPosition = AttrMapValue(isNumber,
+            desc='X Position of the circle'),
+        dotYPosition = AttrMapValue(isNumber,
+            desc='X Position of the circle'),
+        x = AttrMapValue(isNumber,
+            desc='X Position of dotbox'),
+        y = AttrMapValue(isNumber,
+            desc='Y Position of dotbox'),
+        )
+
+    def __init__(self):
+        self.xlabels=["Value", "Blend", "Growth"]
+        self.ylabels=["Small", "Medium", "Large"]
+        self.labelFontName = "Helvetica"
+        self.labelFontSize = 6
+        self.labelOffset = 5
+        self.strokeWidth = 0.5
+        self.gridDivWidth=0.5*cm
+        self.gridColor=colors.Color(25/255.0,77/255.0,135/255.0)
+        self.dotDiameter=0.4*cm
+        self.dotColor=colors.Color(232/255.0,224/255.0,119/255.0)
+        self.dotXPosition = 1
+        self.dotYPosition = 1
+        self.x = 30
+        self.y = 5
+
+
+    def _getDrawingDimensions(self):
+        leftPadding=rightPadding=topPadding=bottomPadding=5
+        #find width of grid
+        tx=len(self.xlabels)*self.gridDivWidth
+        #add padding (and offset)
+        tx=tx+leftPadding+rightPadding+self.labelOffset
+        #add in maximum width of text
+        tx=tx+_maxWidth(self.xlabels, self.labelFontName, self.labelFontSize)
+        #find height of grid
+        ty=len(self.ylabels)*self.gridDivWidth
+        #add padding (and offset)
+        ty=ty+topPadding+bottomPadding+self.labelOffset
+        #add in maximum width of text
+        ty=ty+_maxWidth(self.ylabels, self.labelFontName, self.labelFontSize)
+        #print (tx, ty)
+        return (tx,ty)
+
+    def demo(self,drawing=None):
+        if not drawing:
+            tx,ty=self._getDrawingDimensions()
+            drawing = Drawing(tx,ty)
+        drawing.add(self.draw())
+        return drawing
+
+    def draw(self):
+        g = Group()
+
+        #box
+        g.add(Rect(self.x,self.y,len(self.xlabels)*self.gridDivWidth,len(self.ylabels)*self.gridDivWidth,
+                   strokeColor=self.gridColor,
+                   strokeWidth=self.strokeWidth,
+                   fillColor=None))
+
+        #internal gridding
+        for f in range (1,len(self.ylabels)):
+            #horizontal
+            g.add(Line(strokeColor=self.gridColor,
+                       strokeWidth=self.strokeWidth,
+                       x1 = self.x,
+                       y1 = self.y+f*self.gridDivWidth,
+                       x2 = self.x+len(self.xlabels)*self.gridDivWidth,
+                       y2 = self.y+f*self.gridDivWidth))
+        for f in range (1,len(self.xlabels)):
+            #vertical
+            g.add(Line(strokeColor=self.gridColor,
+                       strokeWidth=self.strokeWidth,
+                       x1 = self.x+f*self.gridDivWidth,
+                       y1 = self.y,
+                       x2 = self.x+f*self.gridDivWidth,
+                       y2 = self.y+len(self.ylabels)*self.gridDivWidth))
+
+        # draw the 'dot'
+        g.add(Circle(strokeColor=self.gridColor,
+                     strokeWidth=self.strokeWidth,
+                     fillColor=self.dotColor,
+                     cx = self.x+(self.dotXPosition*self.gridDivWidth),
+                     cy = self.y+(self.dotYPosition*self.gridDivWidth),
+                     r = self.dotDiameter/2.0))
+
+        #used for centering y-labels (below)
+        ascent=getFont(self.labelFontName).face.ascent
+        if ascent==0:
+            ascent=0.718 # default (from helvetica)
+        ascent=ascent*self.labelFontSize # normalize
+
+        #do y-labels
+        if self.ylabels != None:
+            for f in range (len(self.ylabels)-1,-1,-1):
+                if self.ylabels[f]!= None:
+                    g.add(String(strokeColor=self.gridColor,
+                             text = self.ylabels[f],
+                             fontName = self.labelFontName,
+                             fontSize = self.labelFontSize,
+                             fillColor=_PCMYK_black,
+                             x = self.x-self.labelOffset,
+                             y = self.y+(f*self.gridDivWidth+(self.gridDivWidth-ascent)/2.0),
+                             textAnchor = 'end'))
+
+        #do x-labels
+        if self.xlabels != None:
+            for f in range (0,len(self.xlabels)):
+                if self.xlabels[f]!= None:
+                    l=Label()
+                    l.x=self.x+(f*self.gridDivWidth)+(self.gridDivWidth+ascent)/2.0
+                    l.y=self.y+(len(self.ylabels)*self.gridDivWidth)+self.labelOffset
+                    l.angle=90
+                    l.textAnchor='start'
+                    l.fontName = self.labelFontName
+                    l.fontSize = self.labelFontSize
+                    l.fillColor = _PCMYK_black
+                    l.setText(self.xlabels[f])
+                    l.boxAnchor = 'sw'
+                    l.draw()
+                    g.add(l)
+
+        return g
+
+
+
+
+if __name__ == "__main__":
+    d = DotBox()
+    d.demo().save(fnRoot="dotbox")

.venv/lib/python3.13/site-packages/reportlab/graphics/charts/linecharts.py

@@ -0,0 +1,801 @@
+#Copyright ReportLab Europe Ltd. 2000-2017
+#see license.txt for license details
+#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/graphics/charts/linecharts.py
+
+__version__='3.3.0'
+__doc__="""This modules defines a very preliminary Line Chart example."""
+
+from reportlab.lib import colors
+from reportlab.lib.validators import isNumber, isNumberOrNone, isColorOrNone, \
+                                    isListOfStringsOrNone, isBoolean, NoneOr, \
+                                    isListOfNumbersOrNone, isStringOrNone, OneOf, Percentage
+from reportlab.lib.attrmap import *
+from reportlab.lib.utils import flatten
+from reportlab.graphics.widgetbase import TypedPropertyCollection, PropHolder, tpcGetItem
+from reportlab.graphics.shapes import Line, Rect, Group, Drawing, Polygon, PolyLine
+from reportlab.graphics.widgets.signsandsymbols import NoEntry
+from reportlab.graphics.charts.axes import XCategoryAxis, YValueAxis, YCategoryAxis, XValueAxis
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.widgets.markers import uSymbol2Symbol, isSymbol, makeMarker
+from reportlab.graphics.charts.areas import PlotArea
+from reportlab.graphics.charts.legends import _objStr
+from .utils import FillPairedData
+
+class LineChartProperties(PropHolder):
+    _attrMap = AttrMap(
+        strokeWidth = AttrMapValue(isNumber, desc='Width of a line.'),
+        strokeColor = AttrMapValue(isColorOrNone, desc='Color of a line or border.'),
+        fillColor = AttrMapValue(isColorOrNone, desc='fill color of a bar.'),
+        strokeDashArray = AttrMapValue(isListOfNumbersOrNone, desc='Dash array of a line.'),
+        symbol = AttrMapValue(NoneOr(isSymbol), desc='Widget placed at data points.',advancedUsage=1),
+        shader = AttrMapValue(None, desc='Shader Class.',advancedUsage=1),
+        filler = AttrMapValue(None, desc='Filler Class.',advancedUsage=1),
+        name = AttrMapValue(isStringOrNone, desc='Name of the line.'),
+        lineStyle = AttrMapValue(NoneOr(OneOf('line','joinedLine','bar')), desc="What kind of plot this line is",advancedUsage=1),
+        barWidth = AttrMapValue(isNumberOrNone,desc="Percentage of available width to be used for a bar",advancedUsage=1),
+        inFill = AttrMapValue(isBoolean, desc='If true flood fill to x axis',advancedUsage=1),
+        )
+
+class AbstractLineChart(PlotArea):
+
+    def makeSwatchSample(self,rowNo, x, y, width, height):
+        baseStyle = self.lines
+        styleIdx = rowNo % len(baseStyle)
+        style = baseStyle[styleIdx]
+        color = style.strokeColor
+        yh2 = y+height/2.
+        lineStyle = getattr(style,'lineStyle',None)
+        if lineStyle=='bar':
+            dash = getattr(style, 'strokeDashArray', getattr(baseStyle,'strokeDashArray',None))
+            strokeWidth= getattr(style, 'strokeWidth', getattr(style, 'strokeWidth',None))
+            L = Rect(x,y,width,height,strokeWidth=strokeWidth,strokeColor=color,strokeLineCap=0,strokeDashArray=dash,fillColor=getattr(style,'fillColor',color))
+        elif self.joinedLines or lineStyle=='joinedLine':
+            dash = getattr(style, 'strokeDashArray', getattr(baseStyle,'strokeDashArray',None))
+            strokeWidth= getattr(style, 'strokeWidth', getattr(style, 'strokeWidth',None))
+            L = Line(x,yh2,x+width,yh2,strokeColor=color,strokeLineCap=0)
+            if strokeWidth: L.strokeWidth = strokeWidth
+            if dash: L.strokeDashArray = dash
+        else:
+            L = None
+
+        if hasattr(style, 'symbol'):
+            S = style.symbol
+        elif hasattr(baseStyle, 'symbol'):
+            S = baseStyle.symbol
+        else:
+            S = None
+
+        if S: S = uSymbol2Symbol(S,x+width/2.,yh2,color)
+        if S and L:
+            g = Group()
+            g.add(L)
+            g.add(S)
+            return g
+        return S or L
+
+    def getSeriesName(self,i,default=None):
+        '''return series name i or default'''
+        return _objStr(getattr(self.lines[i],'name',default))
+
+class LineChart(AbstractLineChart):
+    pass
+
+# This is conceptually similar to the VerticalBarChart.
+# Still it is better named HorizontalLineChart... :-/
+
+class HorizontalLineChart(LineChart):
+    """Line chart with multiple lines.
+
+    A line chart is assumed to have one category and one value axis.
+    Despite its generic name this particular line chart class has
+    a vertical value axis and a horizontal category one. It may
+    evolve into individual horizontal and vertical variants (like
+    with the existing bar charts).
+
+    Available attributes are:
+
+        x: x-position of lower-left chart origin
+        y: y-position of lower-left chart origin
+        width: chart width
+        height: chart height
+
+        useAbsolute: disables auto-scaling of chart elements (?)
+        lineLabelNudge: distance of data labels to data points
+        lineLabels: labels associated with data values
+        lineLabelFormat: format string or callback function
+        groupSpacing: space between categories
+
+        joinedLines: enables drawing of lines
+
+        strokeColor: color of chart lines (?)
+        fillColor: color for chart background (?)
+        lines: style list, used cyclically for data series
+
+        valueAxis: value axis object
+        categoryAxis: category axis object
+        categoryNames: category names
+
+        data: chart data, a list of data series of equal length
+    """
+    _flipXY = 0
+
+    _attrMap = AttrMap(BASE=LineChart,
+        useAbsolute = AttrMapValue(isNumber, desc='Flag to use absolute spacing values.',advancedUsage=1),
+        lineLabelNudge = AttrMapValue(isNumber, desc='Distance between a data point and its label.',advancedUsage=1),
+        lineLabels = AttrMapValue(None, desc='Handle to the list of data point labels.'),
+        lineLabelFormat = AttrMapValue(None, desc='Formatting string or function used for data point labels.'),
+        lineLabelArray = AttrMapValue(None, desc='explicit array of line label values, must match size of data if present.'),
+        groupSpacing = AttrMapValue(isNumber, desc='? - Likely to disappear.'),
+        joinedLines = AttrMapValue(isNumber, desc='Display data points joined with lines if true.'),
+        lines = AttrMapValue(None, desc='Handle of the lines.'),
+        valueAxis = AttrMapValue(None, desc='Handle of the value axis.'),
+        categoryAxis = AttrMapValue(None, desc='Handle of the category axis.'),
+        categoryNames = AttrMapValue(isListOfStringsOrNone, desc='List of category names.'),
+        data = AttrMapValue(None, desc='Data to be plotted, list of (lists of) numbers.'),
+        inFill = AttrMapValue(isBoolean, desc='Whether infilling should be done.',advancedUsage=1),
+        reversePlotOrder = AttrMapValue(isBoolean, desc='If true reverse plot order.',advancedUsage=1),
+        annotations = AttrMapValue(None, desc='list of callables, will be called with self, xscale, yscale.',advancedUsage=1),
+        )
+
+    def __init__(self):
+        LineChart.__init__(self)
+
+        # Allow for a bounding rectangle.
+        self.strokeColor = None
+        self.fillColor = None
+
+        # Named so we have less recoding for the horizontal one :-)
+        if self._flipXY:
+            self.categoryAxis = YCategoryAxis()
+            self.valueAxis = XValueAxis()
+        else:
+            self.categoryAxis = XCategoryAxis()
+            self.valueAxis = YValueAxis()
+
+        # This defines two series of 3 points.  Just an example.
+        self.data = [(100,110,120,130),
+                     (70, 80, 80, 90)]
+        self.categoryNames = ('North','South','East','West')
+
+        self.lines = TypedPropertyCollection(LineChartProperties)
+        self.lines.strokeWidth = 1
+        self.lines[0].strokeColor = colors.red
+        self.lines[1].strokeColor = colors.green
+        self.lines[2].strokeColor = colors.blue
+
+        # control spacing. if useAbsolute = 1 then
+        # the next parameters are in points; otherwise
+        # they are 'proportions' and are normalized to
+        # fit the available space.
+        self.useAbsolute = 0   #- not done yet
+        self.groupSpacing = 1 #5
+
+        self.lineLabels = TypedPropertyCollection(Label)
+        self.lineLabelFormat = None
+        self.lineLabelArray = None
+
+        # This says whether the origin is above or below
+        # the data point. +10 means put the origin ten points
+        # above the data point if value > 0, or ten
+        # points below if data value < 0.  This is different
+        # to label dx/dy which are not dependent on the
+        # sign of the data.
+        self.lineLabelNudge = 10
+        # If you have multiple series, by default they butt
+        # together.
+
+        # New line chart attributes.
+        self.joinedLines = 1 # Connect items with straight lines.
+        self.inFill = 0
+        self.reversePlotOrder = 0
+
+    def demo(self):
+        """Shows basic use of a line chart."""
+
+        drawing = Drawing(200, 100)
+
+        data = [
+                (13, 5, 20, 22, 37, 45, 19, 4),
+                (14, 10, 21, 28, 38, 46, 25, 5)
+                ]
+
+        lc = HorizontalLineChart()
+
+        lc.x = 20
+        lc.y = 10
+        lc.height = 85
+        lc.width = 170
+        lc.data = data
+        lc.lines.symbol = makeMarker('Circle')
+
+        drawing.add(lc)
+
+        return drawing
+
+    def calcPositions(self):
+        """Works out where they go.
+
+        Sets an attribute _positions which is a list of
+        lists of (x, y) matching the data.
+        """
+
+        self._seriesCount = len(self.data)
+        self._rowLength = max(list(map(len,self.data)))
+
+        if self.useAbsolute:
+            # Dimensions are absolute.
+            normFactor = 1.0
+        else:
+            # Dimensions are normalized to fit.
+            normWidth = self.groupSpacing
+            availWidth = self.categoryAxis.scale(0)[1]
+            normFactor = availWidth / normWidth
+        self._normFactor = normFactor
+        self._vzero = vzero = self.valueAxis.scale(0)
+        self._hngs = hngs = 0.5 * self.groupSpacing * normFactor
+
+        pairs = set()
+        P = [].append
+        cscale = self.categoryAxis.scale
+        vscale = self.valueAxis.scale
+        data = self.data
+        flipXY = self._flipXY
+        n = len(data)
+        for rowNo,row in enumerate(data):
+            if isinstance(row, FillPairedData):
+                other = row.other
+                if 0<=other<n:
+                    if other==rowNo:
+                        raise ValueError('data row %r may not be paired with itself' % rowNo)
+                    t = (rowNo,other)
+                    pairs.add((min(t),max(t)))
+                else:
+                    raise ValueError('data row %r is paired with invalid data row %r' % (rowNo, other))
+            line = [].append
+            for colNo,datum in enumerate(row):
+                if datum is not None:
+                    c, g = cscale(colNo)
+                    v = vscale(datum)
+                    line((v, c+hngs) if flipXY else (c+hngs, v))
+            P(line.__self__)
+        P = P.__self__
+
+        #if there are some paired lines we ensure only one is created
+        for rowNo, other in pairs:
+            P[rowNo] = FillPairedData(P[rowNo],other)
+        self._pairInFills = len(pairs)
+        self._positions = P
+
+    def _innerDrawLabel(self, rowNo, colNo, x, y):
+        "Draw a label for a given item in the list."
+
+        labelFmt = self.lineLabelFormat
+        labelValue = self.data[rowNo][colNo]
+
+        if labelFmt is None:
+            labelText = None
+        elif type(labelFmt) is str:
+            if labelFmt == 'values':
+                try:
+                    labelText = self.lineLabelArray[rowNo][colNo]
+                except:
+                    labelText = None
+            else:
+                labelText = labelFmt % labelValue
+        elif hasattr(labelFmt,'__call__'):
+            labelText = labelFmt(labelValue)
+        else:
+            raise ValueError("Unknown formatter type %s, expected string or function"%labelFmt)
+
+        if labelText:
+            label = self.lineLabels[(rowNo, colNo)]
+            if not label.visible: return
+            # Make sure labels are some distance off the data point.
+            if y > 0:
+                label.setOrigin(x, y + self.lineLabelNudge)
+            else:
+                label.setOrigin(x, y - self.lineLabelNudge)
+            label.setText(labelText)
+        else:
+            label = None
+        return label
+
+    def drawLabel(self, G, rowNo, colNo, x, y):
+        '''Draw a label for a given item in the list.
+        G must have an add method'''
+        G.add(self._innerDrawLabel(rowNo,colNo,x,y))
+
+    def makeLines(self):
+        g = Group()
+
+        labelFmt = self.lineLabelFormat
+        P = self._positions
+        if self.reversePlotOrder: P.reverse()
+        lines = self.lines
+        styleCount = len(lines)
+        flipXY = self._flipXY
+        cA = self.categoryAxis
+        vA = self.valueAxis
+        _inFill = self.inFill
+        if (_inFill or self._pairInFills or
+                [rowNo for rowNo in range(len(P))
+                        if getattr(lines[rowNo%styleCount],'inFill',False)]
+                ):
+            if flipXY:
+                infillC = cA._x
+                infillV0 = vA._y
+                infillV1 = infillV0 + cA._length
+            else:
+                infillC = cA._y
+                infillV0 = vA._x
+                infillV1 = infillV0 + cA._length
+            inFillG = getattr(self,'_inFillG',g)
+        vzero = self._vzero
+        bypos = None
+
+        # Iterate over data rows.
+        for rowNo, row in enumerate(reversed(P) if self.reversePlotOrder else P):
+            styleIdx = rowNo % styleCount
+            rowStyle = lines[styleIdx]
+            strokeColor = rowStyle.strokeColor
+            fillColor = getattr(rowStyle,'fillColor',strokeColor)
+            inFill = getattr(rowStyle,'inFill',_inFill)
+            dash = getattr(rowStyle, 'strokeDashArray', None)
+            lineStyle = getattr(rowStyle,'lineStyle',None)
+
+            if hasattr(rowStyle, 'strokeWidth'):
+                strokeWidth = rowStyle.strokeWidth
+            elif hasattr(lines, 'strokeWidth'):
+                strokeWidth = lines.strokeWidth
+            else:
+                strokeWidth = None
+
+            # Iterate over data columns.
+            if lineStyle=='bar':
+                if bypos is None:
+                    if flipXY:
+                        bypos = max(vA._x,vzero)
+                        byneg = min(vA._x+vA._length,vzero)
+                    else:
+                        bypos = max(vA._y,vzero)
+                        byneg = min(vA._y+vA._length,vzero)
+                barWidth = getattr(rowStyle,'barWidth',Percentage(50))
+                if isinstance(barWidth,Percentage):
+                    hbw = self._hngs*barWidth*0.01
+                else:
+                    hbw = barWidth*0.5
+                for x, y in row:
+                    if flipXY:
+                        v0 = byneg if x<vzero else bypos
+                        t = v0, y-hbw, x-v0, 2*hbw
+                    else:
+                        v0 = byneg if y<vzero else bypos
+                        t = x-hbw,v0,2*hbw,y-v0
+                    g.add(Rect(*t,strokeWidth=strokeWidth,strokeColor=strokeColor,fillColor=fillColor))
+            elif self.joinedLines or lineStyle=='joinedLine':
+                points = flatten(row)
+                if inFill or isinstance(row,FillPairedData):
+                    filler = getattr(rowStyle, 'filler', None)
+                    if isinstance(row,FillPairedData):
+                        fpoints = points + flatten(reversed(P[row.other]))
+                    else:
+                        if flipXY:
+                            fpoints = [infillC,infillV0] + points + [infillC,infillV1]
+                        else:
+                            fpoints = [infillV0,infillC] + points + [infillV1,infillC]
+                    if filler:
+                        filler.fill(self,inFillG,rowNo,fillColor,fpoints)
+                    else:
+                        inFillG.add(Polygon(fpoints,fillColor=fillColor,strokeColor=strokeColor if strokeColor==fillColor else None,strokeWidth=strokeWidth or 0.1))
+                if not inFill or inFill==2 or strokeColor!=fillColor:
+                    line = PolyLine(points,strokeColor=strokeColor,strokeLineCap=0,strokeLineJoin=1)
+                    if strokeWidth:
+                        line.strokeWidth = strokeWidth
+                    if dash:
+                        line.strokeDashArray = dash
+                    g.add(line)
+
+            if hasattr(rowStyle, 'symbol'):
+                uSymbol = rowStyle.symbol
+            elif hasattr(lines, 'symbol'):
+                uSymbol = lines.symbol
+            else:
+                uSymbol = None
+
+            if uSymbol:
+                for colNo,(x,y) in enumerate(row):
+                    symbol = uSymbol2Symbol(tpcGetItem(uSymbol,colNo),x,y,rowStyle.strokeColor)
+                    if symbol: g.add(symbol)
+
+            # Draw item labels.
+            for colNo, (x, y) in enumerate(row):
+                self.drawLabel(g, rowNo, colNo, x, y)
+
+        return g
+
+    def draw(self):
+        "Draws itself."
+
+        vA, cA = self.valueAxis, self.categoryAxis
+        if self._flipXY:
+            vA.setPosition(self.x, self.y, self.width)
+        else:
+            vA.setPosition(self.x, self.y, self.height)
+        if vA: vA.joinAxis = cA
+        if cA: cA.joinAxis = vA
+        vA.configure(self.data)
+
+        y = self.y
+        x = self.x
+        if self._flipXY:
+            # If zero is in chart, put y axis there, otherwise
+            # use bottom.
+            crossesAt = vA.scale(0)
+            if not ((crossesAt > x + self.width) or (crossesAt < x)):
+                x = crossesAt
+            cA.setPosition(x, y, self.height)
+        else:
+            # If zero is in chart, put x axis there, otherwise
+            # use bottom.
+            crossesAt = vA.scale(0)
+            if not ((crossesAt > y + self.height) or (crossesAt < y)):
+                y = crossesAt
+            cA.setPosition(x, y, self.width)
+        cA.configure(self.data)
+
+        self.calcPositions()
+
+        g = Group()
+        g.add(self.makeBackground())
+        if self.inFill:
+            self._inFillG = Group()
+            g.add(self._inFillG)
+
+        g.add(cA)
+        g.add(vA)
+        cAdgl = getattr(cA,'drawGridLast',False)
+        vAdgl = getattr(vA,'drawGridLast',False)
+        if not cAdgl: cA.makeGrid(g,parent=self,dim=vA.getGridDims)
+        if not vAdgl: vA.makeGrid(g,parent=self,dim=cA.getGridDims)
+        g.add(self.makeLines())
+        if cAdgl: cA.makeGrid(g,parent=self,dim=vA.getGridDims)
+        if vAdgl: vA.makeGrid(g,parent=self,dim=cA.getGridDims)
+        for a in getattr(self,'annotations',()): g.add(a(self,cA.scale,vA.scale))
+        return g
+
+def _fakeItemKey(a):
+    '''t, z0, z1, x, y = a[:5]'''
+    return (-a[1],a[3],a[0],-a[4])
+
+class _FakeGroup:
+    def __init__(self):
+        self._data = []
+
+    def add(self,what):
+        if what: self._data.append(what)
+
+    def value(self):
+        return self._data
+
+    def sort(self):
+        self._data.sort(key=_fakeItemKey)
+        #for t in self._data: print t
+
+class HorizontalLineChart3D(HorizontalLineChart):
+    _attrMap = AttrMap(BASE=HorizontalLineChart,
+        theta_x = AttrMapValue(isNumber, desc='dx/dz'),
+        theta_y = AttrMapValue(isNumber, desc='dy/dz'),
+        zDepth = AttrMapValue(isNumber, desc='depth of an individual series'),
+        zSpace = AttrMapValue(isNumber, desc='z gap around series'),
+        )
+    theta_x = .5
+    theta_y = .5
+    zDepth = 10
+    zSpace = 3
+
+    def calcPositions(self):
+        HorizontalLineChart.calcPositions(self)
+        nSeries = self._seriesCount
+        zSpace = self.zSpace
+        zDepth = self.zDepth
+        if self.categoryAxis.style=='parallel_3d':
+            _3d_depth = nSeries*zDepth+(nSeries+1)*zSpace
+        else:
+            _3d_depth = zDepth + 2*zSpace
+        self._3d_dx = self.theta_x*_3d_depth
+        self._3d_dy = self.theta_y*_3d_depth
+
+    def _calc_z0(self,rowNo):
+        zSpace = self.zSpace
+        if self.categoryAxis.style=='parallel_3d':
+            z0 = rowNo*(self.zDepth+zSpace)+zSpace
+        else:
+            z0 = zSpace
+        return z0
+
+    def _zadjust(self,x,y,z):
+        return x+z*self.theta_x, y+z*self.theta_y
+
+    def makeLines(self):
+        labelFmt = self.lineLabelFormat
+        P = list(range(len(self._positions)))
+        if self.reversePlotOrder: P.reverse()
+        inFill = self.inFill
+        assert not inFill, "inFill not supported for 3d yet"
+        #if inFill:
+            #inFillY = self.categoryAxis._y
+            #inFillX0 = self.valueAxis._x
+            #inFillX1 = inFillX0 + self.categoryAxis._length
+            #inFillG = getattr(self,'_inFillG',g)
+        zDepth = self.zDepth
+        _zadjust = self._zadjust
+        theta_x = self.theta_x
+        theta_y = self.theta_y
+        F = _FakeGroup()
+        from reportlab.graphics.charts.utils3d import _make_3d_line_info
+        tileWidth = getattr(self,'_3d_tilewidth',None)
+        if not tileWidth and self.categoryAxis.style!='parallel_3d': tileWidth = 1
+
+        # Iterate over data rows.
+        for rowNo in P:
+            row = self._positions[rowNo]
+            n = len(row)
+            styleCount = len(self.lines)
+            styleIdx = rowNo % styleCount
+            rowStyle = self.lines[styleIdx]
+            rowColor = rowStyle.strokeColor
+            dash = getattr(rowStyle, 'strokeDashArray', None)
+            z0 = self._calc_z0(rowNo)
+            z1 = z0 + zDepth
+
+            if hasattr(self.lines[styleIdx], 'strokeWidth'):
+                strokeWidth = self.lines[styleIdx].strokeWidth
+            elif hasattr(self.lines, 'strokeWidth'):
+                strokeWidth = self.lines.strokeWidth
+            else:
+                strokeWidth = None
+
+            # Iterate over data columns.
+            if self.joinedLines:
+                if n:
+                    x0, y0 = row[0]
+                    for colNo in range(1,n):
+                        x1, y1 = row[colNo]
+                        _make_3d_line_info( F, x0, x1, y0, y1, z0, z1,
+                                theta_x, theta_y,
+                                rowColor, fillColorShaded=None, tileWidth=tileWidth,
+                                strokeColor=None, strokeWidth=None, strokeDashArray=None,
+                                shading=0.1)
+                        x0, y0 = x1, y1
+
+            if hasattr(self.lines[styleIdx], 'symbol'):
+                uSymbol = self.lines[styleIdx].symbol
+            elif hasattr(self.lines, 'symbol'):
+                uSymbol = self.lines.symbol
+            else:
+                uSymbol = None
+
+            if uSymbol:
+                for colNo in range(n):
+                    x1, y1 = row[colNo]
+                    x1, y1 = _zadjust(x1,y1,z0)
+                    symbol = uSymbol2Symbol(uSymbol,x1,y1,rowColor)
+                    if symbol: F.add((2,z0,z0,x1,y1,symbol))
+
+            # Draw item labels.
+            for colNo in range(n):
+                x1, y1 = row[colNo]
+                x1, y1 = _zadjust(x1,y1,z0)
+                L = self._innerDrawLabel(rowNo, colNo, x1, y1)
+                if L: F.add((2,z0,z0,x1,y1,L))
+
+        F.sort()
+        g = Group()
+        for v in F.value(): g.add(v[-1])
+        return g
+
+class VerticalLineChart(HorizontalLineChart):
+    _flipXY = 1
+
+def sample1():
+    drawing = Drawing(400, 200)
+
+    data = [
+            (13, 5, 20, 22, 37, 45, 19, 4),
+            (5, 20, 46, 38, 23, 21, 6, 14)
+            ]
+
+    lc = HorizontalLineChart()
+
+    lc.x = 50
+    lc.y = 50
+    lc.height = 125
+    lc.width = 300
+    lc.data = data
+    lc.joinedLines = 1
+    lc.lines.symbol = makeMarker('FilledDiamond')
+    lc.lineLabelFormat = '%2.0f'
+
+    catNames = 'Jan Feb Mar Apr May Jun Jul Aug'.split(' ')
+    lc.categoryAxis.categoryNames = catNames
+    lc.categoryAxis.labels.boxAnchor = 'n'
+
+    lc.valueAxis.valueMin = 0
+    lc.valueAxis.valueMax = 60
+    lc.valueAxis.valueStep = 15
+
+    drawing.add(lc)
+
+    return drawing
+
+class SampleHorizontalLineChart(HorizontalLineChart):
+    "Sample class overwriting one method to draw additional horizontal lines."
+
+    def demo(self):
+        """Shows basic use of a line chart."""
+
+        drawing = Drawing(200, 100)
+
+        data = [
+                (13, 5, 20, 22, 37, 45, 19, 4),
+                (14, 10, 21, 28, 38, 46, 25, 5)
+                ]
+
+        lc = SampleHorizontalLineChart()
+
+        lc.x = 20
+        lc.y = 10
+        lc.height = 85
+        lc.width = 170
+        lc.data = data
+        lc.strokeColor = colors.white
+        lc.fillColor = colors.HexColor(0xCCCCCC)
+
+        drawing.add(lc)
+
+        return drawing
+
+    def makeBackground(self):
+        g = Group()
+
+        g.add(HorizontalLineChart.makeBackground(self))
+
+        valAxis = self.valueAxis
+        valTickPositions = valAxis._tickValues
+
+        for y in valTickPositions:
+            y = valAxis.scale(y)
+            g.add(Line(self.x, y, self.x+self.width, y,
+                       strokeColor = self.strokeColor))
+
+        return g
+
+def sample1a():
+    drawing = Drawing(400, 200)
+
+    data = [
+            (13, 5, 20, 22, 37, 45, 19, 4),
+            (5, 20, 46, 38, 23, 21, 6, 14)
+            ]
+
+    lc = SampleHorizontalLineChart()
+
+    lc.x = 50
+    lc.y = 50
+    lc.height = 125
+    lc.width = 300
+    lc.data = data
+    lc.joinedLines = 1
+    lc.strokeColor = colors.white
+    lc.fillColor = colors.HexColor(0xCCCCCC)
+    lc.lines.symbol = makeMarker('FilledDiamond')
+    lc.lineLabelFormat = '%2.0f'
+
+    catNames = 'Jan Feb Mar Apr May Jun Jul Aug'.split(' ')
+    lc.categoryAxis.categoryNames = catNames
+    lc.categoryAxis.labels.boxAnchor = 'n'
+
+    lc.valueAxis.valueMin = 0
+    lc.valueAxis.valueMax = 60
+    lc.valueAxis.valueStep = 15
+
+    drawing.add(lc)
+
+    return drawing
+
+def sample2():
+    drawing = Drawing(400, 200)
+
+    data = [
+            (13, 5, 20, 22, 37, 45, 19, 4),
+            (5, 20, 46, 38, 23, 21, 6, 14)
+            ]
+
+    lc = HorizontalLineChart()
+
+    lc.x = 50
+    lc.y = 50
+    lc.height = 125
+    lc.width = 300
+    lc.data = data
+    lc.joinedLines = 1
+    lc.lines.symbol = makeMarker('Smiley')
+    lc.lineLabelFormat = '%2.0f'
+    lc.strokeColor = colors.black
+    lc.fillColor = colors.lightblue
+
+    catNames = 'Jan Feb Mar Apr May Jun Jul Aug'.split(' ')
+    lc.categoryAxis.categoryNames = catNames
+    lc.categoryAxis.labels.boxAnchor = 'n'
+
+    lc.valueAxis.valueMin = 0
+    lc.valueAxis.valueMax = 60
+    lc.valueAxis.valueStep = 15
+
+    drawing.add(lc)
+
+    return drawing
+
+def sample3():
+    drawing = Drawing(400, 200)
+
+    data = [
+            (13, 5, 20, 22, 37, 45, 19, 4),
+            (5, 20, 46, 38, 23, 21, 6, 14)
+            ]
+
+    lc = HorizontalLineChart()
+
+    lc.x = 50
+    lc.y = 50
+    lc.height = 125
+    lc.width = 300
+    lc.data = data
+    lc.joinedLines = 1
+    lc.lineLabelFormat = '%2.0f'
+    lc.strokeColor = colors.black
+
+    lc.lines[0].symbol = makeMarker('Smiley')
+    lc.lines[1].symbol = NoEntry
+    lc.lines[0].strokeWidth = 2
+    lc.lines[1].strokeWidth = 4
+
+    catNames = 'Jan Feb Mar Apr May Jun Jul Aug'.split(' ')
+    lc.categoryAxis.categoryNames = catNames
+    lc.categoryAxis.labels.boxAnchor = 'n'
+
+    lc.valueAxis.valueMin = 0
+    lc.valueAxis.valueMax = 60
+    lc.valueAxis.valueStep = 15
+
+    drawing.add(lc)
+
+    return drawing
+
+def sampleCandleStick():
+    from reportlab.graphics.widgetbase import CandleSticks
+    d = Drawing(400, 200)
+    chart = HorizontalLineChart()
+    d.add(chart)
+    chart.y = 20
+    boxMid = (100, 110, 120, 130)
+    hi = [m+10 for m in boxMid]
+    lo = [m-10 for m in boxMid]
+    boxHi = [m+6 for m in boxMid]
+    boxLo = [m-4 for m in boxMid]
+    boxFillColor = colors.pink
+    boxWidth = 20
+    crossWidth = 10
+    candleStrokeWidth = 0.5
+    candleStrokeColor = colors.black
+    chart.valueAxis.avoidBoundSpace = 5
+
+    chart.valueAxis.valueMin = min(min(boxMid),min(hi),min(lo),min(boxLo),min(boxHi))
+    chart.valueAxis.valueMax = max(max(boxMid),max(hi),max(lo),max(boxLo),max(boxHi))
+    lines = chart.lines
+    lines[0].strokeColor = None
+    I = range(len(boxMid))
+    chart.data = [boxMid]
+    lines[0].symbol = candles = CandleSticks(chart=chart, boxFillColor=boxFillColor, boxWidth=boxWidth, crossWidth=crossWidth, strokeWidth=candleStrokeWidth, strokeColor=candleStrokeColor)
+    for i in I: candles[i].setProperties(dict(position=i,boxMid=boxMid[i],crossLo=lo[i],crossHi=hi[i],boxLo=boxLo[i],boxHi=boxHi[i]))
+    return d

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/__init__.py

@@ -0,0 +1 @@
+__doc__="""Example drawings to review, used in autogenerated docs"""

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/bubble.py

@@ -0,0 +1,73 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.lineplots import ScatterPlot
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class Bubble(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,ScatterPlot(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.lines[0].strokeColor = color01
+        self.chart.lines[1].strokeColor = color02
+        self.chart.lines[2].strokeColor = color03
+        self.chart.lines[3].strokeColor = color04
+        self.chart.lines[4].strokeColor = color05
+        self.chart.lines[5].strokeColor = color06
+        self.chart.lines[6].strokeColor = color07
+        self.chart.lines[7].strokeColor = color08
+        self.chart.lines[8].strokeColor = color09
+        self.chart.lines[9].strokeColor = color10
+        self.chart.lines.symbol.kind        ='Circle'
+        self.chart.lines.symbol.size        = 15
+        self.chart.fillColor         = backgroundGrey
+        self.chart.lineLabels.fontName              = 'Helvetica'
+        self.chart.xValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.xValueAxis.labels.fontSize       = 7
+        self.chart.xValueAxis.forceZero             = 0
+        self.chart.data             = [((100,100), (200,200), (250,210), (300,300), (350,450))]
+        self.chart.xValueAxis.avoidBoundFrac           = 1
+        self.chart.xValueAxis.gridEnd                  = 115
+        self.chart.xValueAxis.tickDown                 = 3
+        self.chart.xValueAxis.visibleGrid              = 1
+        self.chart.yValueAxis.tickLeft              = 3
+        self.chart.yValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.yValueAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self.chart.lineLabelFormat  = None
+        self.chart.xLabel           = 'X Axis'
+        self.chart.y                = 30
+        self.chart.yLabel           = 'Y Axis'
+        self.chart.yValueAxis.labelTextFormat     = '%d'
+        self.chart.yValueAxis.forceZero           = 1
+        self.chart.xValueAxis.forceZero           = 1
+
+
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    Bubble().save(formats=['pdf'],outDir=None,fnRoot='bubble')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/clustered_bar.py

@@ -0,0 +1,84 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.samples.excelcolors import *
+from reportlab.graphics.charts.barcharts import HorizontalBarChart
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+
+class ClusteredBar(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,HorizontalBarChart(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.bars[0].fillColor = color01
+        self.chart.bars[1].fillColor = color02
+        self.chart.bars[2].fillColor = color03
+        self.chart.bars[3].fillColor = color04
+        self.chart.bars[4].fillColor = color05
+        self.chart.bars[5].fillColor = color06
+        self.chart.bars[6].fillColor = color07
+        self.chart.bars[7].fillColor = color08
+        self.chart.bars[8].fillColor = color09
+        self.chart.bars[9].fillColor = color10
+        self.chart.fillColor         = backgroundGrey
+        self.chart.barLabels.fontName              = 'Helvetica'
+        self.chart.valueAxis.labels.fontName       = 'Helvetica'
+        self.chart.valueAxis.labels.fontSize       = 6
+        self.chart.valueAxis.forceZero             = 1
+        self.chart.data             = [(100, 150, 180), (125, 180, 200)]
+        self.chart.groupSpacing     = 15
+        self.chart.valueAxis.avoidBoundFrac           = 1
+        self.chart.valueAxis.gridEnd                  = 80
+        self.chart.valueAxis.tickDown                 = 3
+        self.chart.valueAxis.visibleGrid              = 1
+        self.chart.categoryAxis.categoryNames         = ['North', 'South', 'Central']
+        self.chart.categoryAxis.tickLeft              = 3
+        self.chart.categoryAxis.labels.fontName       = 'Helvetica'
+        self.chart.categoryAxis.labels.fontSize       = 6
+        self.chart.categoryAxis.labels.dx             = -3
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self._add(self,Label(),name='XLabel',validate=None,desc="The label on the horizontal axis")
+        self.XLabel.fontName       = 'Helvetica'
+        self.XLabel.fontSize       = 7
+        self.XLabel.x              = 85
+        self.XLabel.y              = 10
+        self.XLabel.textAnchor     ='middle'
+        self.XLabel.maxWidth       = 100
+        self.XLabel.height         = 20
+        self.XLabel._text          = "X Axis"
+        self._add(self,Label(),name='YLabel',validate=None,desc="The label on the vertical axis")
+        self.YLabel.fontName       = 'Helvetica'
+        self.YLabel.fontSize       = 7
+        self.YLabel.x              = 12
+        self.YLabel.y              = 80
+        self.YLabel.angle          = 90
+        self.YLabel.textAnchor     ='middle'
+        self.YLabel.maxWidth       = 100
+        self.YLabel.height         = 20
+        self.YLabel._text          = "Y Axis"
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    ClusteredBar().save(formats=['pdf'],outDir=None,fnRoot='clustered_bar')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/clustered_column.py

@@ -0,0 +1,83 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.samples.excelcolors import *
+from reportlab.graphics.charts.barcharts import VerticalBarChart
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+
+class ClusteredColumn(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,VerticalBarChart(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.bars[0].fillColor = color01
+        self.chart.bars[1].fillColor = color02
+        self.chart.bars[2].fillColor = color03
+        self.chart.bars[3].fillColor = color04
+        self.chart.bars[4].fillColor = color05
+        self.chart.bars[5].fillColor = color06
+        self.chart.bars[6].fillColor = color07
+        self.chart.bars[7].fillColor = color08
+        self.chart.bars[8].fillColor = color09
+        self.chart.bars[9].fillColor = color10
+        self.chart.fillColor         = backgroundGrey
+        self.chart.barLabels.fontName              = 'Helvetica'
+        self.chart.valueAxis.labels.fontName       = 'Helvetica'
+        self.chart.valueAxis.labels.fontSize       = 7
+        self.chart.valueAxis.forceZero             = 1
+        self.chart.data             = [(100, 150, 180), (125, 180, 200)]
+        self.chart.groupSpacing     = 15
+        self.chart.valueAxis.avoidBoundFrac           = 1
+        self.chart.valueAxis.gridEnd                  = 115
+        self.chart.valueAxis.tickLeft                 = 3
+        self.chart.valueAxis.visibleGrid              = 1
+        self.chart.categoryAxis.categoryNames         = ['North', 'South', 'Central']
+        self.chart.categoryAxis.tickDown              = 3
+        self.chart.categoryAxis.labels.fontName       = 'Helvetica'
+        self.chart.categoryAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth  = 180
+        self.Title.height    = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self._add(self,Label(),name='XLabel',validate=None,desc="The label on the horizontal axis")
+        self.XLabel.fontName       = 'Helvetica'
+        self.XLabel.fontSize       = 7
+        self.XLabel.x              = 85
+        self.XLabel.y              = 10
+        self.XLabel.textAnchor     ='middle'
+        self.XLabel.maxWidth       = 100
+        self.XLabel.height         = 20
+        self.XLabel._text           = "X Axis"
+        self._add(self,Label(),name='YLabel',validate=None,desc="The label on the vertical axis")
+        self.YLabel.fontName       = 'Helvetica'
+        self.YLabel.fontSize       = 7
+        self.YLabel.x              = 12
+        self.YLabel.y              = 80
+        self.YLabel.angle          = 90
+        self.YLabel.textAnchor     ='middle'
+        self.YLabel.maxWidth       = 100
+        self.YLabel.height         = 20
+        self.YLabel._text           = "Y Axis"
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    ClusteredColumn().save(formats=['pdf'],outDir=None,fnRoot='clustered_column')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/excelcolors.py

@@ -0,0 +1,45 @@
+# define standard colors to mimic those used by Microsoft Excel
+from reportlab.lib.colors import PCMYKColor
+
+#colour names as comments at the end of each line are as a memory jogger ONLY
+#NOT HTML named colours!
+
+#Main colours as used for bars etc
+color01 = PCMYKColor(40,40,0,0)    # Lavender
+color02 = PCMYKColor(0,66,33,39)   # Maroon
+color03 = PCMYKColor(0,0,20,0)     # Yellow
+color04 = PCMYKColor(20,0,0,0)     # Cyan
+color05 = PCMYKColor(0,100,0,59)   # Purple
+color06 = PCMYKColor(0,49,49,0)    # Salmon
+color07 = PCMYKColor(100,49,0,19)  # Blue
+color08 = PCMYKColor(20,20,0,0)    # PaleLavender
+color09 = PCMYKColor(100,100,0,49) # NavyBlue
+color10 = PCMYKColor(0,100,0,0)    # Purple
+
+#Highlight colors - eg for the tops of bars
+color01Light = PCMYKColor(39,39,0,25)   # Light Lavender
+color02Light = PCMYKColor(0,66,33,54)   # Light Maroon
+color03Light = PCMYKColor(0,0,19,25)    # Light Yellow
+color04Light = PCMYKColor(19,0,0,25)    # Light Cyan
+color05Light = PCMYKColor(0,100,0,69)   # Light Purple
+color06Light = PCMYKColor(0,49,49,25)   # Light Salmon
+color07Light = PCMYKColor(100,49,0,39)  # Light Blue
+color08Light = PCMYKColor(19,19,0,25)   # Light PaleLavender
+color09Light = PCMYKColor(100,100,0,62) # Light NavyBlue
+color10Light = PCMYKColor(0,100,0,25)   # Light Purple
+
+#Lowlight colors - eg for the sides of bars
+color01Dark = PCMYKColor(39,39,0,49)   # Dark Lavender
+color02Dark = PCMYKColor(0,66,33,69)   # Dark Maroon
+color03Dark = PCMYKColor(0,0,20,49)    # Dark Yellow
+color04Dark = PCMYKColor(20,0,0,49)    # Dark Cyan
+color05Dark = PCMYKColor(0,100,0,80)   # Dark Purple
+color06Dark = PCMYKColor(0,50,50,49)   # Dark Salmon
+color07Dark = PCMYKColor(100,50,0,59)  # Dark Blue
+color08Dark = PCMYKColor(20,20,0,49)   # Dark PaleLavender
+color09Dark = PCMYKColor(100,100,0,79) # Dark NavyBlue
+color10Dark = PCMYKColor(0,100,0,49)   # Dark Purple
+
+#for standard grey backgrounds
+backgroundGrey = PCMYKColor(0,0,0,24)
+

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/exploded_pie.py

@@ -0,0 +1,65 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.piecharts import Pie
+from reportlab.graphics.samples.excelcolors import *
+from reportlab.graphics.widgets.grids import ShadedRect
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+
+class ExplodedPie(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,Pie(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 100
+        self.chart.height     = 100
+        self.chart.x          = 25
+        self.chart.y          = 25
+        self.chart.slices[0].fillColor = color01
+        self.chart.slices[1].fillColor = color02
+        self.chart.slices[2].fillColor = color03
+        self.chart.slices[3].fillColor = color04
+        self.chart.slices[4].fillColor = color05
+        self.chart.slices[5].fillColor = color06
+        self.chart.slices[6].fillColor = color07
+        self.chart.slices[7].fillColor = color08
+        self.chart.slices[8].fillColor = color09
+        self.chart.slices[9].fillColor = color10
+        self.chart.data                = (100, 150, 180)
+        self.chart.startAngle          = -90
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'North'), (color02, 'South'), (color03, 'Central')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 160
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self.Legend.columnMaximum  = 10
+        self.chart.slices.strokeWidth  = 1
+        self.chart.slices.fontName     = 'Helvetica'
+        self.background                = ShadedRect()
+        self.background.fillColorStart = backgroundGrey
+        self.background.fillColorEnd   = backgroundGrey
+        self.background.numShades      = 1
+        self.background.strokeWidth    = 0.5
+        self.background.x              = 20
+        self.background.y              = 20
+        self.chart.slices.popout       = 5
+        self.background.height         = 110
+        self.background.width          = 110
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    ExplodedPie().save(formats=['pdf'],outDir=None,fnRoot='exploded_pie')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/filled_radar.py

@@ -0,0 +1,54 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.spider import SpiderChart
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class FilledRadarChart(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,SpiderChart(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 90
+        self.chart.height     = 90
+        self.chart.x          = 45
+        self.chart.y          = 25
+        self.chart.strands[0].fillColor  = color01
+        self.chart.strands[1].fillColor  = color02
+        self.chart.strands[2].fillColor  = color03
+        self.chart.strands[3].fillColor  = color04
+        self.chart.strands[4].fillColor  = color05
+        self.chart.strands[5].fillColor  = color06
+        self.chart.strands[6].fillColor  = color07
+        self.chart.strands[7].fillColor  = color08
+        self.chart.strands[8].fillColor  = color09
+        self.chart.strands[9].fillColor  = color10
+        self.chart.strandLabels.fontName = 'Helvetica'
+        self.chart.strandLabels.fontSize = 6
+        self.chart.fillColor             = backgroundGrey
+        self.chart.data                  = [(125, 180, 200), (100, 150, 180)]
+        self.chart.labels                = ['North', 'South', 'Central']
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    FilledRadarChart().save(formats=['pdf'],outDir=None,fnRoot='filled_radar')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/line_chart.py

@@ -0,0 +1,83 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.lineplots import LinePlot
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class LineChart(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,LinePlot(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.lines[0].strokeColor = color01
+        self.chart.lines[1].strokeColor = color02
+        self.chart.lines[2].strokeColor = color03
+        self.chart.lines[3].strokeColor = color04
+        self.chart.lines[4].strokeColor = color05
+        self.chart.lines[5].strokeColor = color06
+        self.chart.lines[6].strokeColor = color07
+        self.chart.lines[7].strokeColor = color08
+        self.chart.lines[8].strokeColor = color09
+        self.chart.lines[9].strokeColor = color10
+        self.chart.fillColor         = backgroundGrey
+        self.chart.lineLabels.fontName              = 'Helvetica'
+        self.chart.xValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.xValueAxis.labels.fontSize       = 7
+        self.chart.xValueAxis.forceZero             = 0
+        self.chart.data             = [((0, 50), (100,100), (200,200), (250,210), (300,300), (400,500)), ((0, 150), (100,200), (200,300), (250,200), (300,400), (400, 600))]
+        self.chart.xValueAxis.avoidBoundFrac           = 1
+        self.chart.xValueAxis.gridEnd                  = 115
+        self.chart.xValueAxis.tickDown                 = 3
+        self.chart.xValueAxis.visibleGrid              = 1
+        self.chart.yValueAxis.tickLeft              = 3
+        self.chart.yValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.yValueAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self._add(self,Label(),name='XLabel',validate=None,desc="The label on the horizontal axis")
+        self.XLabel.fontName       = 'Helvetica'
+        self.XLabel.fontSize       = 7
+        self.XLabel.x              = 85
+        self.XLabel.y              = 10
+        self.XLabel.textAnchor     ='middle'
+        self.XLabel.maxWidth       = 100
+        self.XLabel.height         = 20
+        self.XLabel._text          = "X Axis"
+        self._add(self,Label(),name='YLabel',validate=None,desc="The label on the vertical axis")
+        self.YLabel.fontName       = 'Helvetica'
+        self.YLabel.fontSize       = 7
+        self.YLabel.x              = 12
+        self.YLabel.y              = 80
+        self.YLabel.angle          = 90
+        self.YLabel.textAnchor     ='middle'
+        self.YLabel.maxWidth       = 100
+        self.YLabel.height         = 20
+        self.YLabel._text          = "Y Axis"
+        self.chart.yValueAxis.forceZero           = 1
+        self.chart.xValueAxis.forceZero           = 1
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    LineChart().save(formats=['pdf'],outDir=None,fnRoot='line_chart')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/linechart_with_markers.py

@@ -0,0 +1,94 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.lineplots import LinePlot
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.widgets.markers import makeMarker
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class LineChartWithMarkers(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,LinePlot(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.lines[0].strokeColor = color01
+        self.chart.lines[1].strokeColor = color02
+        self.chart.lines[2].strokeColor = color03
+        self.chart.lines[3].strokeColor = color04
+        self.chart.lines[4].strokeColor = color05
+        self.chart.lines[5].strokeColor = color06
+        self.chart.lines[6].strokeColor = color07
+        self.chart.lines[7].strokeColor = color08
+        self.chart.lines[8].strokeColor = color09
+        self.chart.lines[9].strokeColor = color10
+        self.chart.lines[0].symbol = makeMarker('FilledSquare')
+        self.chart.lines[1].symbol = makeMarker('FilledDiamond')
+        self.chart.lines[2].symbol = makeMarker('FilledStarFive')
+        self.chart.lines[3].symbol = makeMarker('FilledTriangle')
+        self.chart.lines[4].symbol = makeMarker('FilledCircle')
+        self.chart.lines[5].symbol = makeMarker('FilledPentagon')
+        self.chart.lines[6].symbol = makeMarker('FilledStarSix')
+        self.chart.lines[7].symbol = makeMarker('FilledHeptagon')
+        self.chart.lines[8].symbol = makeMarker('FilledOctagon')
+        self.chart.lines[9].symbol = makeMarker('FilledCross')
+        self.chart.fillColor       = backgroundGrey
+        self.chart.lineLabels.fontName              = 'Helvetica'
+        self.chart.xValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.xValueAxis.labels.fontSize       = 7
+        self.chart.xValueAxis.forceZero             = 0
+        self.chart.data             = [((0, 50), (100,100), (200,200), (250,210), (300,300), (400,500)), ((0, 150), (100,200), (200,300), (250,200), (300,400), (400, 600))]
+        self.chart.xValueAxis.avoidBoundFrac           = 1
+        self.chart.xValueAxis.gridEnd                  = 115
+        self.chart.xValueAxis.tickDown                 = 3
+        self.chart.xValueAxis.visibleGrid              = 1
+        self.chart.yValueAxis.tickLeft              = 3
+        self.chart.yValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.yValueAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self._add(self,Label(),name='XLabel',validate=None,desc="The label on the horizontal axis")
+        self.XLabel.fontName       = 'Helvetica'
+        self.XLabel.fontSize       = 7
+        self.XLabel.x              = 85
+        self.XLabel.y              = 10
+        self.XLabel.textAnchor     ='middle'
+        self.XLabel.maxWidth       = 100
+        self.XLabel.height         = 20
+        self.XLabel._text          = "X Axis"
+        self._add(self,Label(),name='YLabel',validate=None,desc="The label on the vertical axis")
+        self.YLabel.fontName       = 'Helvetica'
+        self.YLabel.fontSize       = 7
+        self.YLabel.x              = 12
+        self.YLabel.y              = 80
+        self.YLabel.angle          = 90
+        self.YLabel.textAnchor     ='middle'
+        self.YLabel.maxWidth       = 100
+        self.YLabel.height         = 20
+        self.YLabel._text          = "Y Axis"
+        self.chart.yValueAxis.forceZero           = 1
+        self.chart.xValueAxis.forceZero           = 1
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    LineChartWithMarkers().save(formats=['pdf'],outDir=None,fnRoot='linechart_with_markers')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/radar.py

@@ -0,0 +1,66 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.samples.excelcolors import *
+from reportlab.graphics.charts.spider import SpiderChart
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+
+class RadarChart(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,SpiderChart(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 90
+        self.chart.height     = 90
+        self.chart.x          = 45
+        self.chart.y          = 25
+        self.chart.strands[0].strokeColor= color01
+        self.chart.strands[1].strokeColor= color02
+        self.chart.strands[2].strokeColor= color03
+        self.chart.strands[3].strokeColor= color04
+        self.chart.strands[4].strokeColor= color05
+        self.chart.strands[5].strokeColor= color06
+        self.chart.strands[6].strokeColor= color07
+        self.chart.strands[7].strokeColor= color08
+        self.chart.strands[8].strokeColor= color09
+        self.chart.strands[9].strokeColor= color10
+        self.chart.strands[0].fillColor  = None
+        self.chart.strands[1].fillColor  = None
+        self.chart.strands[2].fillColor  = None
+        self.chart.strands[3].fillColor  = None
+        self.chart.strands[4].fillColor  = None
+        self.chart.strands[5].fillColor  = None
+        self.chart.strands[6].fillColor  = None
+        self.chart.strands[7].fillColor  = None
+        self.chart.strands[8].fillColor  = None
+        self.chart.strands[9].fillColor  = None
+        self.chart.strands.strokeWidth   = 1
+        self.chart.strandLabels.fontName = 'Helvetica'
+        self.chart.strandLabels.fontSize = 6
+        self.chart.fillColor             = backgroundGrey
+        self.chart.data                  = [(125, 180, 200), (100, 150, 180)]
+        self.chart.labels                = ['North', 'South', 'Central']
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self.chart.strands.strokeWidth     = 1
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    RadarChart().save(formats=['pdf'],outDir=None,fnRoot='radar')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/runall.py

@@ -0,0 +1,57 @@
+# runs all the GUIedit charts in this directory -
+# makes a PDF sample for eaxh existing chart type
+import sys
+import glob
+import inspect
+
+def moduleClasses(mod):
+    def P(obj, m=mod.__name__, CT=type):
+        return (type(obj)==CT and obj.__module__==m)
+    try:
+        return inspect.getmembers(mod, P)[0][1]
+    except:
+        return None
+
+def getclass(f):
+    return moduleClasses(__import__(f))
+
+def run(format, VERBOSE=0):
+    formats = format.split( ',')
+    for i in range(0, len(formats)):
+        formats[i] == formats[i].strip().lower()
+    allfiles = glob.glob('*.py')
+    allfiles.sort()
+    for fn in allfiles:
+        f = fn.split('.')[0]
+        c = getclass(f)
+        if c != None:
+            print(c.__name__)
+            try:
+                for fmt in formats:
+                    if fmt:
+                        c().save(formats=[fmt],outDir='.',fnRoot=c.__name__)
+                        if VERBOSE:
+                            print("  %s.%s" % (c.__name__, fmt))
+            except:
+                print("  COULDN'T CREATE '%s.%s'!" % (c.__name__, format))
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        run('pdf,pict,png')
+    else:
+        try:
+            if sys.argv[1] == "-h":
+                print('usage: runall.py [FORMAT] [-h]')
+                print('   if format is supplied is should be one or more of pdf,gif,eps,png etc')
+                print('   if format is missing the following formats are assumed: pdf,pict,png')
+                print('   -h prints this message')
+            else:
+                t = sys.argv[1:]
+                for f in t:
+                    run(f)
+        except:
+            print('usage: runall.py [FORMAT][-h]')
+            print('   if format is supplied is should be one or more of pdf,gif,eps,png etc')
+            print('   if format is missing the following formats are assumed: pdf,pict,png')
+            print('   -h prints this message')
+            raise

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/scatter.py

@@ -0,0 +1,71 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.lineplots import ScatterPlot
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class Scatter(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,ScatterPlot(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.lines[0].strokeColor = color01
+        self.chart.lines[1].strokeColor = color02
+        self.chart.lines[2].strokeColor = color03
+        self.chart.lines[3].strokeColor = color04
+        self.chart.lines[4].strokeColor = color05
+        self.chart.lines[5].strokeColor = color06
+        self.chart.lines[6].strokeColor = color07
+        self.chart.lines[7].strokeColor = color08
+        self.chart.lines[8].strokeColor = color09
+        self.chart.lines[9].strokeColor = color10
+        self.chart.fillColor         = backgroundGrey
+        self.chart.lineLabels.fontName              = 'Helvetica'
+        self.chart.xValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.xValueAxis.labels.fontSize       = 7
+        self.chart.xValueAxis.forceZero             = 0
+        self.chart.data             = [((100,100), (200,200), (250,210), (300,300), (400,500)), ((100,200), (200,300), (250,200), (300,400), (400, 600))]
+        self.chart.xValueAxis.avoidBoundFrac           = 1
+        self.chart.xValueAxis.gridEnd                  = 115
+        self.chart.xValueAxis.tickDown                 = 3
+        self.chart.xValueAxis.visibleGrid              = 1
+        self.chart.yValueAxis.tickLeft              = 3
+        self.chart.yValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.yValueAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self.chart.lineLabelFormat  = None
+        self.chart.xLabel           = 'X Axis'
+        self.chart.y                = 30
+        self.chart.yLabel           = 'Y Axis'
+        self.chart.yValueAxis.labelTextFormat     = '%d'
+        self.chart.yValueAxis.forceZero           = 1
+        self.chart.xValueAxis.forceZero           = 1
+
+
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    Scatter().save(formats=['pdf'],outDir=None,fnRoot='scatter')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/scatter_lines.py

@@ -0,0 +1,82 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.lineplots import ScatterPlot
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class ScatterLines(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,ScatterPlot(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.lines[0].strokeColor = color01
+        self.chart.lines[1].strokeColor = color02
+        self.chart.lines[2].strokeColor = color03
+        self.chart.lines[3].strokeColor = color04
+        self.chart.lines[4].strokeColor = color05
+        self.chart.lines[5].strokeColor = color06
+        self.chart.lines[6].strokeColor = color07
+        self.chart.lines[7].strokeColor = color08
+        self.chart.lines[8].strokeColor = color09
+        self.chart.lines[9].strokeColor = color10
+        self.chart.lines[0].symbol = None
+        self.chart.lines[1].symbol = None
+        self.chart.lines[2].symbol = None
+        self.chart.lines[3].symbol = None
+        self.chart.lines[4].symbol = None
+        self.chart.lines[5].symbol = None
+        self.chart.lines[6].symbol = None
+        self.chart.lines[7].symbol = None
+        self.chart.lines[8].symbol = None
+        self.chart.lines[9].symbol = None
+        self.chart.fillColor         = backgroundGrey
+        self.chart.lineLabels.fontName              = 'Helvetica'
+        self.chart.xValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.xValueAxis.labels.fontSize       = 7
+        self.chart.xValueAxis.forceZero             = 0
+        self.chart.data             = [((100,100), (200,200), (250,210), (300,300), (400,500)), ((100,200), (200,300), (250,200), (300,400), (400, 600))]
+        self.chart.xValueAxis.avoidBoundFrac           = 1
+        self.chart.xValueAxis.gridEnd                  = 115
+        self.chart.xValueAxis.tickDown                 = 3
+        self.chart.xValueAxis.visibleGrid              = 1
+        self.chart.yValueAxis.tickLeft              = 3
+        self.chart.yValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.yValueAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self.chart.lineLabelFormat  = None
+        self.chart.xLabel           = 'X Axis'
+        self.chart.y                = 30
+        self.chart.yLabel           = 'Y Axis'
+        self.chart.yValueAxis.gridEnd             = 115
+        self.chart.yValueAxis.visibleGrid         = 1
+        self.chart.yValueAxis.labelTextFormat     = '%d'
+        self.chart.yValueAxis.forceZero           = 1
+        self.chart.xValueAxis.forceZero           = 1
+        self.chart.joinedLines                    = 1
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    ScatterLines().save(formats=['pdf'],outDir=None,fnRoot='scatter_lines')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/scatter_lines_markers.py

@@ -0,0 +1,72 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.lineplots import ScatterPlot
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class ScatterLinesMarkers(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,ScatterPlot(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.lines[0].strokeColor = color01
+        self.chart.lines[1].strokeColor = color02
+        self.chart.lines[2].strokeColor = color03
+        self.chart.lines[3].strokeColor = color04
+        self.chart.lines[4].strokeColor = color05
+        self.chart.lines[5].strokeColor = color06
+        self.chart.lines[6].strokeColor = color07
+        self.chart.lines[7].strokeColor = color08
+        self.chart.lines[8].strokeColor = color09
+        self.chart.lines[9].strokeColor = color10
+        self.chart.fillColor         = backgroundGrey
+        self.chart.lineLabels.fontName              = 'Helvetica'
+        self.chart.xValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.xValueAxis.labels.fontSize       = 7
+        self.chart.xValueAxis.forceZero             = 0
+        self.chart.data             = [((100,100), (200,200), (250,210), (300,300), (400,500)), ((100,200), (200,300), (250,200), (300,400), (400, 600))]
+        self.chart.xValueAxis.avoidBoundFrac           = 1
+        self.chart.xValueAxis.gridEnd                  = 115
+        self.chart.xValueAxis.tickDown                 = 3
+        self.chart.xValueAxis.visibleGrid              = 1
+        self.chart.yValueAxis.tickLeft              = 3
+        self.chart.yValueAxis.labels.fontName       = 'Helvetica'
+        self.chart.yValueAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self.chart.lineLabelFormat  = None
+        self.chart.xLabel           = 'X Axis'
+        self.chart.y                = 30
+        self.chart.yLabel           = 'Y Axis'
+        self.chart.yValueAxis.gridEnd             = 115
+        self.chart.yValueAxis.visibleGrid         = 1
+        self.chart.yValueAxis.labelTextFormat     = '%d'
+        self.chart.yValueAxis.forceZero           = 1
+        self.chart.xValueAxis.forceZero           = 1
+        self.chart.joinedLines                    = 1
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    ScatterLinesMarkers().save(formats=['pdf'],outDir=None,fnRoot='scatter_lines_markers')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/simple_pie.py

@@ -0,0 +1,61 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.piecharts import Pie
+from reportlab.graphics.widgets.grids import ShadedRect
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class SimplePie(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,Pie(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 100
+        self.chart.height     = 100
+        self.chart.x          = 25
+        self.chart.y          = 25
+        self.chart.slices[0].fillColor = color01
+        self.chart.slices[1].fillColor = color02
+        self.chart.slices[2].fillColor = color03
+        self.chart.slices[3].fillColor = color04
+        self.chart.slices[4].fillColor = color05
+        self.chart.slices[5].fillColor = color06
+        self.chart.slices[6].fillColor = color07
+        self.chart.slices[7].fillColor = color08
+        self.chart.slices[8].fillColor = color09
+        self.chart.slices[9].fillColor = color10
+        self.chart.data                = (100, 150, 180)
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'North'), (color02, 'South'),(color03, 'Central')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 160
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self.chart.slices.strokeWidth  = 1
+        self.chart.slices.fontName     = 'Helvetica'
+        self.background                = ShadedRect()
+        self.background.fillColorStart = backgroundGrey
+        self.background.fillColorEnd   = backgroundGrey
+        self.background.numShades      = 1
+        self.background.strokeWidth    = 0.5
+        self.background.x              = 25
+        self.background.y              = 25
+        self.Legend.columnMaximum  = 10
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    SimplePie().save(formats=['pdf'],outDir=None,fnRoot=None)

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/stacked_bar.py

@@ -0,0 +1,85 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.barcharts import HorizontalBarChart
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class StackedBar(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,HorizontalBarChart(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.bars[0].fillColor = color01
+        self.chart.bars[1].fillColor = color02
+        self.chart.bars[2].fillColor = color03
+        self.chart.bars[3].fillColor = color04
+        self.chart.bars[4].fillColor = color05
+        self.chart.bars[5].fillColor = color06
+        self.chart.bars[6].fillColor = color07
+        self.chart.bars[7].fillColor = color08
+        self.chart.bars[8].fillColor = color09
+        self.chart.bars[9].fillColor = color10
+        self.chart.fillColor         = backgroundGrey
+        self.chart.barLabels.fontName              = 'Helvetica'
+        self.chart.valueAxis.labels.fontName       = 'Helvetica'
+        self.chart.valueAxis.labels.fontSize       = 6
+        self.chart.valueAxis.forceZero             = 1
+        self.chart.data             = [(100, 150, 180), (125, 180, 200)]
+        self.chart.groupSpacing     = 15
+        self.chart.valueAxis.avoidBoundFrac           = 1
+        self.chart.valueAxis.gridEnd                  = 80
+        self.chart.valueAxis.tickDown                 = 3
+        self.chart.valueAxis.visibleGrid              = 1
+        self.chart.categoryAxis.categoryNames         = ['North', 'South', 'Central']
+        self.chart.categoryAxis.tickLeft              = 3
+        self.chart.categoryAxis.labels.fontName       = 'Helvetica'
+        self.chart.categoryAxis.labels.fontSize       = 6
+        self.chart.categoryAxis.labels.dx             = -3
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self._add(self,Label(),name='XLabel',validate=None,desc="The label on the horizontal axis")
+        self.XLabel.fontName       = 'Helvetica'
+        self.XLabel.fontSize       = 7
+        self.XLabel.x              = 85
+        self.XLabel.y              = 10
+        self.XLabel.textAnchor     ='middle'
+        self.XLabel.maxWidth       = 100
+        self.XLabel.height         = 20
+        self.XLabel._text           = "X Axis"
+        self._add(self,Label(),name='YLabel',validate=None,desc="The label on the vertical axis")
+        self.YLabel.fontName       = 'Helvetica'
+        self.YLabel.fontSize       = 7
+        self.YLabel.x              = 12
+        self.YLabel.y              = 80
+        self.YLabel.angle          = 90
+        self.YLabel.textAnchor     ='middle'
+        self.YLabel.maxWidth       = 100
+        self.YLabel.height         = 20
+        self.YLabel._text          = "Y Axis"
+        self.chart.categoryAxis.style='stacked'
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    StackedBar().save(formats=['pdf'],outDir=None,fnRoot='stacked_bar')

.venv/lib/python3.13/site-packages/reportlab/graphics/samples/stacked_column.py

@@ -0,0 +1,84 @@
+#Autogenerated by ReportLab guiedit do not edit
+from reportlab.graphics.charts.legends import Legend
+from reportlab.graphics.charts.barcharts import VerticalBarChart
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.samples.excelcolors import *
+
+class StackedColumn(_DrawingEditorMixin,Drawing):
+    def __init__(self,width=200,height=150,*args,**kw):
+        Drawing.__init__(self,width,height,*args,**kw)
+        self._add(self,VerticalBarChart(),name='chart',validate=None,desc="The main chart")
+        self.chart.width      = 115
+        self.chart.height     = 80
+        self.chart.x          = 30
+        self.chart.y          = 40
+        self.chart.bars[0].fillColor = color01
+        self.chart.bars[1].fillColor = color02
+        self.chart.bars[2].fillColor = color03
+        self.chart.bars[3].fillColor = color04
+        self.chart.bars[4].fillColor = color05
+        self.chart.bars[5].fillColor = color06
+        self.chart.bars[6].fillColor = color07
+        self.chart.bars[7].fillColor = color08
+        self.chart.bars[8].fillColor = color09
+        self.chart.bars[9].fillColor = color10
+        self.chart.fillColor         = backgroundGrey
+        self.chart.barLabels.fontName              = 'Helvetica'
+        self.chart.valueAxis.labels.fontName       = 'Helvetica'
+        self.chart.valueAxis.labels.fontSize       = 7
+        self.chart.valueAxis.forceZero             = 1
+        self.chart.data             = [(100, 150, 180), (125, 180, 200)]
+        self.chart.groupSpacing     = 15
+        self.chart.valueAxis.avoidBoundFrac           = 1
+        self.chart.valueAxis.gridEnd                  = 115
+        self.chart.valueAxis.tickLeft                 = 3
+        self.chart.valueAxis.visibleGrid              = 1
+        self.chart.categoryAxis.categoryNames         = ['North', 'South', 'Central']
+        self.chart.categoryAxis.tickDown              = 3
+        self.chart.categoryAxis.labels.fontName       = 'Helvetica'
+        self.chart.categoryAxis.labels.fontSize       = 7
+        self._add(self,Label(),name='Title',validate=None,desc="The title at the top of the chart")
+        self.Title.fontName   = 'Helvetica-Bold'
+        self.Title.fontSize   = 7
+        self.Title.x          = 100
+        self.Title.y          = 135
+        self.Title._text      = 'Chart Title'
+        self.Title.maxWidth   = 180
+        self.Title.height     = 20
+        self.Title.textAnchor ='middle'
+        self._add(self,Legend(),name='Legend',validate=None,desc="The legend or key for the chart")
+        self.Legend.colorNamePairs = [(color01, 'Widgets'), (color02, 'Sprockets')]
+        self.Legend.fontName       = 'Helvetica'
+        self.Legend.fontSize       = 7
+        self.Legend.x              = 153
+        self.Legend.y              = 85
+        self.Legend.dxTextSpace    = 5
+        self.Legend.dy             = 5
+        self.Legend.dx             = 5
+        self.Legend.deltay         = 5
+        self.Legend.alignment      ='right'
+        self._add(self,Label(),name='XLabel',validate=None,desc="The label on the horizontal axis")
+        self.XLabel.fontName       = 'Helvetica'
+        self.XLabel.fontSize       = 7
+        self.XLabel.x              = 85
+        self.XLabel.y              = 10
+        self.XLabel.textAnchor     ='middle'
+        self.XLabel.maxWidth       = 100
+        self.XLabel.height         = 20
+        self.XLabel._text          = "X Axis"
+        self._add(self,Label(),name='YLabel',validate=None,desc="The label on the vertical axis")
+        self.YLabel.fontName       = 'Helvetica'
+        self.YLabel.fontSize       = 7
+        self.YLabel.x              = 12
+        self.YLabel.y              = 80
+        self.YLabel.angle          = 90
+        self.YLabel.textAnchor     ='middle'
+        self.YLabel.maxWidth       = 100
+        self.YLabel.height         = 20
+        self.YLabel._text          = "Y Axis"
+        self.chart.categoryAxis.style='stacked'
+        self._add(self,0,name='preview',validate=None,desc=None)
+
+if __name__=="__main__": #NORUNTESTS
+    StackedColumn().save(formats=['pdf'],outDir=None,fnRoot='stacked_column')

.venv/lib/python3.13/site-packages/reportlab/graphics/widgets/__init__.py

@@ -0,0 +1,5 @@
+#Copyright ReportLab Europe Ltd. 2000-2017
+#see license.txt for license details
+#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/graphics/widgets/__init__.py
+__version__='3.3.0'
+__doc__='''Some non-chart widgets'''

.venv/lib/python3.13/site-packages/reportlab/graphics/widgets/adjustableArrow.py

@@ -0,0 +1,126 @@
+from reportlab.lib import colors
+from reportlab.lib.validators import *
+from reportlab.lib.attrmap import *
+from reportlab.graphics.shapes import Drawing, _DrawingEditorMixin, Group, Polygon
+from reportlab.graphics.widgetbase import Widget
+
+class AdjustableArrow(Widget):
+	"""This widget draws an arrow (style one).
+
+		possible attributes:
+		'x', 'y', 'size', 'fillColor'
+
+		"""
+	_attrMap = AttrMap(
+		x = AttrMapValue(isNumber,desc='symbol x coordinate'),
+		y = AttrMapValue(isNumber,desc='symbol y coordinate'),
+		dx = AttrMapValue(isNumber,desc='symbol x coordinate adjustment'),
+		dy = AttrMapValue(isNumber,desc='symbol x coordinate adjustment'),
+		stemThickness = AttrMapValue(isNumber, 'width of the stem'),
+		stemLength = AttrMapValue(isNumber, 'length of the stem'),
+		headProjection = AttrMapValue(isNumber, 'how much the head projects from the stem'),
+		headLength = AttrMapValue(isNumber, 'length of the head'),
+		headSweep = AttrMapValue(isNumber, 'howmuch the head sweeps back (-ve) or forwards (+ve)'),
+		scale = AttrMapValue(isNumber, 'scaling factor'),
+		fillColor = AttrMapValue(isColorOrNone),
+		strokeColor = AttrMapValue(isColorOrNone),
+		strokeWidth = AttrMapValue(isNumber),
+		boxAnchor = AttrMapValue(isBoxAnchor,desc='anchoring point of the label'),
+		right =AttrMapValue(isBoolean,desc='If True (default) the arrow is horizontal pointing right\nFalse means it points up'),
+		angle = AttrMapValue(isNumber, desc='angle of arrow default (0), right True 0 is horizontal to right else vertical up'),
+		)
+	def __init__(self,**kwds):
+		self._setKeywords(**kwds)
+		self._setKeywords(**dict(
+				x = 0,
+				y = 0,
+				fillColor = colors.red,
+				strokeWidth = 0,
+				strokeColor = None,
+				boxAnchor = 'c',
+				angle = 0,
+				stemThickness = 33,
+				stemLength = 50,
+				headProjection = 15,
+				headLength = 50,
+				headSweep = 0,
+				scale = 1.,
+				right=True,
+				))
+
+	def draw(self):
+		# general widget bits
+		g = Group()
+
+		x = self.x
+		y = self.y
+		scale = self.scale
+		stemThickness = self.stemThickness*scale
+		stemLength = self.stemLength*scale
+		headProjection = self.headProjection*scale
+		headLength = self.headLength*scale
+		headSweep = self.headSweep*scale
+		w = stemLength+headLength
+		h = 2*headProjection+stemThickness
+		# shift to the boxAnchor
+		boxAnchor = self.boxAnchor
+		if self.right:
+			if boxAnchor in ('sw','w','nw'):
+				dy = -h
+			elif boxAnchor in ('s','c','n'):
+				dy = -h*0.5
+			else:
+				dy = 0
+			if boxAnchor in ('w','c','e'):
+				dx = -w*0.5
+			elif boxAnchor in ('nw','n','ne'):
+				dx = -w
+			else:
+				dx = 0
+			points = [
+				dx, dy+headProjection+stemThickness,
+				dx+stemLength, dy+headProjection+stemThickness,
+				dx+stemLength+headSweep, dy+2*headProjection+stemThickness,
+				dx+stemLength+headLength, dy+0.5*stemThickness+headProjection,
+				dx+stemLength+headSweep, dy,
+				dx+stemLength, dy+headProjection,
+				dx, dy+headProjection,
+				]
+		else:
+			w,h = h,w
+			if boxAnchor in ('nw','n','ne'):
+				dy = -h
+			elif boxAnchor in ('w','c','e'):
+				dy = -h*0.5
+			else:
+				dy = 0
+			if boxAnchor in ('ne','e','se'):
+				dx = -w
+			elif boxAnchor in ('n','c','s'):
+				dx = -w*0.5
+			else:
+				dx = 0
+			points = [
+				dx+headProjection, dy,	#sw
+				dx+headProjection+stemThickness, dy,	#se
+				dx+headProjection+stemThickness, dy+stemLength,
+				dx+w, dy+stemLength+headSweep,
+				dx+headProjection+0.5*stemThickness, dy+h,
+				dx, dy+stemLength+headSweep,
+				dx+headProjection, dy+stemLength,
+				]
+
+		g.add(Polygon(
+				points = points,
+				fillColor = self.fillColor,
+				strokeColor = self.strokeColor,
+				strokeWidth = self.strokeWidth,
+				))
+		g.translate(x,y)
+		g.rotate(self.angle)
+		return g
+
+class AdjustableArrowDrawing(_DrawingEditorMixin,Drawing):
+	def __init__(self,width=100,height=63,*args,**kw):
+		Drawing.__init__(self,width,height,*args,**kw)
+		self._add(self,AdjustableArrow(),name='adjustableArrow',validate=None,desc=None)

.venv/lib/python3.13/site-packages/reportlab/graphics/widgets/eventcal.py

@@ -0,0 +1,299 @@
+#see license.txt for license details
+#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/graphics/widgets/eventcal.py
+# Event Calendar widget
+# author: Andy Robinson
+
+__version__='3.3.0'
+__doc__="""This file is a
+"""
+
+from reportlab.lib import colors
+from reportlab.graphics.shapes import Rect, Drawing, Group, String
+from reportlab.graphics.charts.textlabels import Label
+from reportlab.graphics.widgetbase import Widget
+
+
+class EventCalendar(Widget):
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.width = 300
+        self.height = 150
+        self.timeColWidth = None  # if declared, use it; otherwise auto-size.
+        self.trackRowHeight = 20
+        self.data = []  # list of Event objects
+        self.trackNames = None
+
+        self.startTime = None  #displays ALL data on day if not set
+        self.endTime = None    # displays ALL data on day if not set
+        self.day = 0
+
+
+        # we will keep any internal geometry variables
+        # here.  These are computed by computeSize(),
+        # which is the first thing done when drawing.
+        self._talksVisible = []  # subset of data which will get plotted, cache
+        self._startTime = None
+        self._endTime = None
+        self._trackCount = 0
+        self._colWidths = []
+        self._colLeftEdges = []  # left edge of each column
+
+    def computeSize(self):
+        "Called at start of draw.  Sets various column widths"
+        self._talksVisible = self.getRelevantTalks(self.data)
+        self._trackCount = len(self.getAllTracks())
+        self.computeStartAndEndTimes()
+        self._colLeftEdges = [self.x]
+        if self.timeColWidth is None:
+            w = self.width / (1 + self._trackCount)
+            self._colWidths = [w] * (1+ self._trackCount)
+            for i in range(self._trackCount):
+                self._colLeftEdges.append(self._colLeftEdges[-1] + w)
+        else:
+            self._colWidths = [self.timeColWidth]
+            w = (self.width - self.timeColWidth) / self._trackCount
+            for i in range(self._trackCount):
+                self._colWidths.append(w)
+                self._colLeftEdges.append(self._colLeftEdges[-1] + w)
+
+
+
+    def computeStartAndEndTimes(self):
+        "Work out first and last times to display"
+        if self.startTime:
+            self._startTime = self.startTime
+        else:
+            for (title, speaker, trackId, day, start, duration) in self._talksVisible:
+
+                if self._startTime is None: #first one
+                    self._startTime = start
+                else:
+                    if start < self._startTime:
+                        self._startTime = start
+
+        if self.endTime:
+            self._endTime = self.endTime
+        else:
+            for (title, speaker, trackId, day, start, duration) in self._talksVisible:
+                if self._endTime is None: #first one
+                    self._endTime = start + duration
+                else:
+                    if start + duration > self._endTime:
+                        self._endTime = start + duration
+
+
+
+
+    def getAllTracks(self):
+        tracks = []
+        for (title, speaker, trackId, day, hours, duration) in self.data:
+            if trackId is not None:
+                if trackId not in tracks:
+                    tracks.append(trackId)
+        tracks.sort()
+        return tracks
+
+    def getRelevantTalks(self, talkList):
+        "Scans for tracks actually used"
+        used = []
+        for talk in talkList:
+            (title, speaker, trackId, day, hours, duration) = talk
+            assert trackId != 0, "trackId must be None or 1,2,3... zero not allowed!"
+            if day == self.day:
+                if (((self.startTime is None) or ((hours + duration) >= self.startTime))
+                and ((self.endTime is None) or (hours <= self.endTime))):
+                    used.append(talk)
+        return used
+
+    def scaleTime(self, theTime):
+        "Return y-value corresponding to times given"
+        axisHeight = self.height - self.trackRowHeight
+        # compute fraction between 0 and 1, 0 is at start of period
+        proportionUp = ((theTime - self._startTime) / (self._endTime - self._startTime))
+        y = self.y + axisHeight - (axisHeight * proportionUp)
+        return y
+
+
+    def getTalkRect(self, startTime, duration, trackId, text):
+        "Return shapes for a specific talk"
+        g = Group()
+        y_bottom = self.scaleTime(startTime + duration)
+        y_top = self.scaleTime(startTime)
+        y_height = y_top - y_bottom
+
+        if trackId is None:
+            #spans all columns
+            x = self._colLeftEdges[1]
+            width = self.width - self._colWidths[0]
+        else:
+            #trackId is 1-based and these arrays have the margin info in column
+            #zero, so no need to add 1
+            x = self._colLeftEdges[trackId]
+            width = self._colWidths[trackId]
+
+        lab = Label()
+        lab.setText(text)
+        lab.setOrigin(x + 0.5*width, y_bottom+0.5*y_height)
+        lab.boxAnchor = 'c'
+        lab.width = width
+        lab.height = y_height
+        lab.fontSize = 6
+
+        r = Rect(x, y_bottom, width, y_height, fillColor=colors.cyan)
+        g.add(r)
+        g.add(lab)
+
+        #now for a label
+        # would expect to color-code and add text
+        return g
+
+    def draw(self):
+        self.computeSize()
+        g = Group()
+
+        # time column
+        g.add(Rect(self.x, self.y, self._colWidths[0], self.height - self.trackRowHeight, fillColor=colors.cornsilk))
+
+        # track headers
+        x = self.x + self._colWidths[0]
+        y = self.y + self.height - self.trackRowHeight
+        for trk in range(self._trackCount):
+            wid = self._colWidths[trk+1]
+            r = Rect(x, y, wid, self.trackRowHeight, fillColor=colors.yellow)
+            s = String(x + 0.5*wid, y, 'Track %d' % trk, align='middle')
+            g.add(r)
+            g.add(s)
+            x = x + wid
+
+        for talk in self._talksVisible:
+            (title, speaker, trackId, day, start, duration) = talk
+            r = self.getTalkRect(start, duration, trackId, title + '\n' + speaker)
+            g.add(r)
+
+
+        return g
+
+
+
+
+def test():
+    "Make a conference event for day 1 of UP Python 2003"
+
+
+    d = Drawing(400,200)
+
+    cal = EventCalendar()
+    cal.x = 50
+    cal.y = 25
+    cal.data = [
+        # these might be better as objects instead of tuples, since I
+        # predict a large number of "optionsl" variables to affect
+        # formatting in future.
+
+        #title, speaker, track id, day, start time (hrs), duration (hrs)
+        # track ID is 1-based not zero-based!
+        ('Keynote: Why design another programming language?',  'Guido van Rossum', None, 1, 9.0, 1.0),
+
+        ('Siena Web Service Architecture', 'Marc-Andre Lemburg', 1, 1, 10.5, 1.5),
+        ('Extreme Programming in Python', 'Chris Withers', 2, 1, 10.5, 1.5),
+        ('Pattern Experiences in C++', 'Mark Radford', 3, 1, 10.5, 1.5),
+        ('What is the Type of std::toupper()', 'Gabriel Dos Reis', 4, 1, 10.5, 1.5),
+        ('Linguistic Variables: Clear Thinking with Fuzzy Logic ', 'Walter Banks', 5, 1, 10.5, 1.5),
+
+        ('lunch, short presentations, vendor presentations', '', None, 1, 12.0, 2.0),
+
+        ("CORBA? Isn't that obsolete", 'Duncan Grisby', 1, 1, 14.0, 1.5),
+        ("Python Design Patterns", 'Duncan Booth', 2, 1, 14.0, 1.5),
+        ("Inside Security Checks and Safe Exceptions", 'Brandon Bray', 3, 1, 14.0, 1.5),
+        ("Studying at a Distance", 'Panel Discussion, Panel to include Alan Lenton & Francis Glassborow', 4, 1, 14.0, 1.5),
+        ("Coding Standards - Given the ANSI C Standard why do I still need a coding Standard", 'Randy Marques', 5, 1, 14.0, 1.5),
+
+        ("RESTful Python", 'Hamish Lawson', 1, 1, 16.0, 1.5),
+        ("Parsing made easier - a radical old idea", 'Andrew Koenig', 2, 1, 16.0, 1.5),
+        ("C++ & Multimethods", 'Julian Smith', 3, 1, 16.0, 1.5),
+        ("C++ Threading", 'Kevlin Henney', 4, 1, 16.0, 1.5),
+        ("The Organisation Strikes Back", 'Alan Griffiths & Sarah Lees', 5, 1, 16.0, 1.5),
+
+        ('Birds of a Feather meeting', '', None, 1, 17.5, 2.0),
+
+        ('Keynote: In the Spirit of C',  'Greg Colvin', None, 2, 9.0, 1.0),
+
+        ('The Infinite Filing Cabinet - object storage in Python', 'Jacob Hallen', 1, 2, 10.5, 1.5),
+        ('Introduction to Python and Jython for C++ and Java Programmers', 'Alex Martelli', 2, 2, 10.5, 1.5),
+        ('Template metaprogramming in Haskell', 'Simon Peyton Jones', 3, 2, 10.5, 1.5),
+        ('Plenty People Programming: C++ Programming in a Group, Workshop with a difference', 'Nico Josuttis', 4, 2, 10.5, 1.5),
+        ('Design and Implementation of the Boost Graph Library', 'Jeremy Siek', 5, 2, 10.5, 1.5),
+
+        ('lunch, short presentations, vendor presentations', '', None, 2, 12.0, 2.0),
+
+        ("Building GUI Applications with PythonCard and PyCrust", 'Andy Todd', 1, 2, 14.0, 1.5),
+        ("Integrating Python, C and C++", 'Duncan Booth', 2, 2, 14.0, 1.5),
+        ("Secrets and Pitfalls of Templates", 'Nicolai Josuttis & David Vandevoorde', 3, 2, 14.0, 1.5),
+        ("Being a Mentor", 'Panel Discussion, Panel to include Alan Lenton & Francis Glassborow', 4, 2, 14.0, 1.5),
+        ("The Embedded C Extensions to C", 'Willem Wakker', 5, 2, 14.0, 1.5),
+
+        ("Lightning Talks", 'Paul Brian', 1, 2, 16.0, 1.5),
+        ("Scripting Java Applications with Jython", 'Anthony Eden', 2, 2, 16.0, 1.5),
+        ("Metaprogramming and the Boost Metaprogramming Library", 'David Abrahams', 3, 2, 16.0, 1.5),
+        ("A Common Vendor ABI for C++ -- GCC's why, what and not", 'Nathan Sidwell & Gabriel Dos Reis', 4, 2, 16.0, 1.5),
+        ("The Timing and Cost of Choices", 'Hubert Matthews', 5, 2, 16.0, 1.5),
+
+        ('Birds of a Feather meeting', '', None, 2, 17.5, 2.0),
+
+        ('Keynote: The Cost of C &amp; C++ Compatibility', 'Andy Koenig', None, 3, 9.0, 1.0),
+
+        ('Prying Eyes: Generic Observer Implementations in C++', 'Andrei Alexandrescu', 1, 2, 10.5, 1.5),
+        ('The Roadmap to Generative Programming With C++', 'Ulrich Eisenecker', 2, 2, 10.5, 1.5),
+        ('Design Patterns in C++ and C# for the Common Language Runtime', 'Brandon Bray', 3, 2, 10.5, 1.5),
+        ('Extreme Hour (XH): (workshop) - Jutta Eckstein and Nico Josuttis', 'Jutta Ecstein', 4, 2, 10.5, 1.5),
+        ('The Lambda Library : Unnamed Functions for C++', 'Jaako Jarvi', 5, 2, 10.5, 1.5),
+
+        ('lunch, short presentations, vendor presentations', '', None, 3, 12.0, 2.0),
+
+        ('Reflective Metaprogramming', 'Daveed Vandevoorde', 1, 3, 14.0, 1.5),
+        ('Advanced Template Issues and Solutions (double session)', 'Herb Sutter',2, 3, 14.0, 3),
+        ('Concurrent Programming in Java (double session)', 'Angelika Langer', 3, 3, 14.0, 3),
+        ('What can MISRA-C (2nd Edition) do for us?', 'Chris Hills', 4, 3, 14.0, 1.5),
+        ('C++ Metaprogramming Concepts and Results', 'Walter E Brown', 5, 3, 14.0, 1.5),
+
+        ('Binding C++ to Python with the Boost Python Library', 'David Abrahams', 1, 3, 16.0, 1.5),
+        ('Using Aspect Oriented Programming for Enterprise Application Integration', 'Arno Schmidmeier', 4, 3, 16.0, 1.5),
+        ('Defective C++', 'Marc Paterno', 5, 3, 16.0, 1.5),
+
+        ("Speakers' Banquet & Birds of a Feather meeting", '', None, 3, 17.5, 2.0),
+
+        ('Keynote: The Internet, Software and Computers - A Report Card', 'Alan Lenton',  None, 4, 9.0, 1.0),
+
+        ('Multi-Platform Software Development; Lessons from the Boost libraries', 'Beman Dawes', 1, 5, 10.5, 1.5),
+        ('The Stability of the C++ ABI', 'Steve Clamage', 2, 5, 10.5, 1.5),
+        ('Generic Build Support - A Pragmatic Approach to the Software Build Process', 'Randy Marques', 3, 5, 10.5, 1.5),
+        ('How to Handle Project Managers: a survival guide', 'Barb Byro',  4, 5, 10.5, 1.5),
+
+        ('lunch, ACCU AGM', '', None, 5, 12.0, 2.0),
+
+        ('Sauce: An OO recursive descent parser; its design and implementation.', 'Jon Jagger', 1, 5, 14.0, 1.5),
+        ('GNIRTS ESAC REWOL -  Bringing the UNIX filters to the C++ iostream library.', 'JC van Winkel', 2, 5, 14.0, 1.5),
+        ('Pattern Writing: Live and Direct', 'Frank Buschmann & Kevlin Henney',  3, 5, 14.0, 3.0),
+        ('The Future of Programming Languages - A Goldfish Bowl', 'Francis Glassborow and friends',  3, 5, 14.0, 1.5),
+
+        ('Honey, I Shrunk the Threads: Compile-time checked multithreaded transactions in C++', 'Andrei Alexandrescu', 1, 5, 16.0, 1.5),
+        ('Fun and Functionality with Functors', 'Lois Goldthwaite', 2, 5, 16.0, 1.5),
+        ('Agile Enough?', 'Alan Griffiths', 4, 5, 16.0, 1.5),
+        ("Conference Closure: A brief plenary session", '', None, 5, 17.5, 0.5),
+
+        ]
+
+    #return cal
+    cal.day = 1
+
+    d.add(cal)
+
+
+    for format in ['pdf']:#,'gif','png']:
+        out = d.asString(format)
+        open('eventcal.%s' % format, 'wb').write(out)
+        print('saved eventcal.%s' % format)
+
+if __name__=='__main__':
+    test()

.venv/lib/python3.13/site-packages/reportlab/graphics/widgets/flags.py

@@ -0,0 +1,879 @@
+#see license.txt for license details
+#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/graphics/widgets/flags.py
+# Flag Widgets - a collection of flags as widgets
+# author: John Precedo (johnp@reportlab.com)
+
+__version__='3.3.0'
+__doc__="""This file is a collection of flag graphics as widgets.
+
+All flags are represented at the ratio of 1:2, even where the official ratio for the flag is something else
+(such as 3:5 for the German national flag). The only exceptions are for where this would look _very_ wrong,
+such as the Danish flag whose (ratio is 28:37), or the Swiss flag (which is square).
+
+Unless otherwise stated, these flags are all the 'national flags' of the countries, rather than their
+state flags, naval flags, ensigns or any other variants. (National flags are the flag flown by civilians
+of a country and the ones usually used to represent a country abroad. State flags are the variants used by
+the government and by diplomatic missions overseas).
+
+To check on how close these are to the 'official' representations of flags, check the World Flag Database at
+http://www.flags.ndirect.co.uk/
+
+The flags this file contains are:
+
+EU Members:
+United Kingdom, Austria, Belgium, Denmark, Finland, France, Germany, Greece, Ireland, Italy, Luxembourg,
+Holland (The Netherlands), Spain, Sweden
+
+Others:
+USA, Czech Republic, European Union, Switzerland, Turkey, Brazil
+
+(Brazilian flag contributed by Publio da Costa Melo [publio@planetarium.com.br]).
+"""
+
+from reportlab.lib import colors
+from reportlab.lib.validators import *
+from reportlab.lib.attrmap import *
+from reportlab.graphics.shapes import Line, Rect, Polygon, Drawing, Group, String, Circle, Wedge
+from reportlab.graphics import renderPDF
+from reportlab.graphics.widgets.signsandsymbols import _Symbol
+import copy
+from math import sin, cos, pi
+
+validFlag=OneOf(None,
+                'UK',
+                'USA',
+                'Afghanistan',
+                'Austria',
+                'Belgium',
+                'China',
+                'Cuba',
+                'Denmark',
+                'Finland',
+                'France',
+                'Germany',
+                'Greece',
+                'Ireland',
+                'Italy',
+                'Japan',
+                'Luxembourg',
+                'Holland',
+                'Palestine',
+                'Portugal',
+                'Russia',
+                'Spain',
+                'Sweden',
+                'Norway',
+                'CzechRepublic',
+                'Turkey',
+                'Switzerland',
+                'EU',
+                'Brazil'
+                )
+
+_size = 100.
+
+class Star(_Symbol):
+    """This draws a 5-pointed star.
+
+        possible attributes:
+        'x', 'y', 'size', 'fillColor', 'strokeColor'
+
+        """
+    _attrMap = AttrMap(BASE=_Symbol,
+            angle = AttrMapValue(isNumber, desc='angle in degrees'),
+            )
+    _size = 100.
+
+    def __init__(self):
+        _Symbol.__init__(self)
+        self.size = 100
+        self.fillColor = colors.yellow
+        self.strokeColor = None
+        self.angle = 0
+
+    def demo(self):
+        D = Drawing(200, 100)
+        et = Star()
+        et.x=50
+        et.y=0
+        D.add(et)
+        labelFontSize = 10
+        D.add(String(et.x+(et.size/2.0),(et.y-(1.2*labelFontSize)),
+                            et.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+        return D
+
+    def draw(self):
+        s = float(self.size)  #abbreviate as we will use this a lot
+        g = Group()
+
+        # new algorithm from markers.StarFive
+        R = float(self.size)/2
+        r = R*sin(18*(pi/180.0))/cos(36*(pi/180.0))
+        P = []
+        angle = 90
+        for i in range(5):
+            for radius in R, r:
+                theta = angle*(pi/180.0)
+                P.append(radius*cos(theta))
+                P.append(radius*sin(theta))
+                angle = angle + 36
+        # star specific bits
+        star = Polygon(P,
+                    fillColor = self.fillColor,
+                    strokeColor = self.strokeColor,
+                    strokeWidth=s/50)
+        g.rotate(self.angle)
+        g.shift(self.x+self.dx,self.y+self.dy)
+        g.add(star)
+
+        return g
+
+class Flag(_Symbol):
+    """This is a generic flag class that all the flags in this file use as a basis.
+
+        This class basically provides edges and a tidy-up routine to hide any bits of
+        line that overlap the 'outside' of the flag
+
+        possible attributes:
+        'x', 'y', 'size', 'fillColor'
+    """
+
+    _attrMap = AttrMap(BASE=_Symbol,
+            fillColor = AttrMapValue(isColor, desc='Background color'),
+            border = AttrMapValue(isBoolean, 'Whether a background is drawn'),
+            kind = AttrMapValue(validFlag, desc='Which flag'),
+            )
+
+    _cache = {}
+
+    def __init__(self,**kw):
+        _Symbol.__init__(self)
+        self.kind = None
+        self.size = 100
+        self.fillColor = colors.white
+        self.border=1
+        self.setProperties(kw)
+
+    def availableFlagNames(self):
+        '''return a list of the things we can display'''
+        return [x for x in self._attrMap['kind'].validate._enum if x is not None]
+
+    def _Flag_None(self):
+        s = _size  # abbreviate as we will use this a lot
+        g = Group()
+        g.add(Rect(0, 0, s*2, s, fillColor = colors.purple, strokeColor = colors.black, strokeWidth=0))
+        return g
+
+    def _borderDraw(self,f):
+        s = self.size  # abbreviate as we will use this a lot
+        g = Group()
+        g.add(f)
+        x, y, sW = self.x+self.dx, self.y+self.dy, self.strokeWidth/2.
+        g.insert(0,Rect(-sW, -sW, width=getattr(self,'_width',2*s)+3*sW, height=getattr(self,'_height',s)+2*sW,
+                fillColor = None, strokeColor = self.strokeColor, strokeWidth=sW*2))
+        g.shift(x,y)
+        g.scale(s/_size, s/_size)
+        return g
+
+    def draw(self):
+        kind = self.kind or 'None'
+        f = self._cache.get(kind)
+        if not f:
+            f = getattr(self,'_Flag_'+kind)()
+            self._cache[kind] = f._explode()
+        return self._borderDraw(f)
+
+    def clone(self):
+        return copy.copy(self)
+
+    def demo(self):
+        D = Drawing(200, 100)
+        name = self.availableFlagNames()
+        import time
+        name = name[int(time.time()) % len(name)]
+        fx = Flag()
+        fx.kind = name
+        fx.x = 0
+        fx.y = 0
+        D.add(fx)
+        labelFontSize = 10
+        D.add(String(fx.x+(fx.size/2.0),(fx.y-(1.2*labelFontSize)),
+                            name, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+        labelFontSize = int(fx.size/4.0)
+        D.add(String(fx.x+(fx.size),(fx.y+((fx.size/2.0))),
+                            "SAMPLE", fillColor=colors.gold, textAnchor='middle',
+                            fontSize=labelFontSize, fontName="Helvetica-Bold"))
+        return D
+
+    def _Flag_UK(self):
+        s = _size
+        g = Group()
+        w = s*2
+        g.add(Rect(0, 0, w, s, fillColor = colors.navy, strokeColor = colors.black, strokeWidth=0))
+        g.add(Polygon([0,0, s*.225,0, w,s*(1-.1125), w,s, w-s*.225,s, 0, s*.1125], fillColor = colors.mintcream, strokeColor=None, strokeWidth=0))
+        g.add(Polygon([0,s*(1-.1125), 0, s, s*.225,s, w, s*.1125, w,0, w-s*.225,0], fillColor = colors.mintcream, strokeColor=None, strokeWidth=0))
+        g.add(Polygon([0, s-(s/15.0), (s-((s/10.0)*4)), (s*0.65), (s-(s/10.0)*3), (s*0.65), 0, s], fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        g.add(Polygon([0, 0, (s-((s/10.0)*3)), (s*0.35), (s-((s/10.0)*2)), (s*0.35), (s/10.0), 0], fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        g.add(Polygon([w, s, (s+((s/10.0)*3)), (s*0.65), (s+((s/10.0)*2)), (s*0.65), w-(s/10.0), s], fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        g.add(Polygon([w, (s/15.0), (s+((s/10.0)*4)), (s*0.35), (s+((s/10.0)*3)), (s*0.35), w, 0], fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        g.add(Rect(((s*0.42)*2), 0, width=(0.16*s)*2, height=s, fillColor = colors.mintcream, strokeColor = None, strokeWidth=0))
+        g.add(Rect(0, (s*0.35), width=w, height=s*0.3, fillColor = colors.mintcream, strokeColor = None, strokeWidth=0))
+        g.add(Rect(((s*0.45)*2), 0, width=(0.1*s)*2, height=s, fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        g.add(Rect(0, (s*0.4), width=w, height=s*0.2, fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        return g
+
+    def _Flag_USA(self):
+        s = _size  # abbreviate as we will use this a lot
+        g = Group()
+
+        box = Rect(0, 0, s*2, s, fillColor = colors.mintcream, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        for stripecounter in range (13,0, -1):
+            stripeheight = s/13.0
+            if not (stripecounter%2 == 0):
+                stripecolor = colors.red
+            else:
+                stripecolor = colors.mintcream
+            redorwhiteline = Rect(0, (s-(stripeheight*stripecounter)), width=s*2, height=stripeheight,
+                fillColor = stripecolor, strokeColor = None, strokeWidth=20)
+            g.add(redorwhiteline)
+
+        bluebox = Rect(0, (s-(stripeheight*7)), width=0.8*s, height=stripeheight*7,
+            fillColor = colors.darkblue, strokeColor = None, strokeWidth=0)
+        g.add(bluebox)
+
+        lss = s*0.045
+        lss2 = lss/2.0
+        s9 = s/9.0
+        s7 = s/7.0
+        for starxcounter in range(5):
+            for starycounter in range(4):
+                ls = Star()
+                ls.size = lss
+                ls.x = 0-s/22.0+lss/2.0+s7+starxcounter*s7
+                ls.fillColor = colors.mintcream
+                ls.y = s-(starycounter+1)*s9+lss2
+                g.add(ls)
+
+        for starxcounter in range(6):
+            for starycounter in range(5):
+                ls = Star()
+                ls.size = lss
+                ls.x = 0-(s/22.0)+lss/2.0+s/14.0+starxcounter*s7
+                ls.fillColor = colors.mintcream
+                ls.y = s-(starycounter+1)*s9+(s/18.0)+lss2
+                g.add(ls)
+        return g
+
+    def _Flag_Afghanistan(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.mintcream, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        greenbox = Rect(0, ((s/3.0)*2.0), width=s*2.0, height=s/3.0,
+                fillColor = colors.limegreen, strokeColor = None, strokeWidth=0)
+        g.add(greenbox)
+
+        blackbox = Rect(0, 0, width=s*2.0, height=s/3.0,
+                fillColor = colors.black, strokeColor = None, strokeWidth=0)
+        g.add(blackbox)
+        return g
+
+    def _Flag_Austria(self):
+        s = _size  # abbreviate as we will use this a lot
+        g = Group()
+
+        box = Rect(0, 0, s*2, s, fillColor = colors.mintcream,
+            strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+
+        redbox1 = Rect(0, 0, width=s*2.0, height=s/3.0,
+            fillColor = colors.red, strokeColor = None, strokeWidth=0)
+        g.add(redbox1)
+
+        redbox2 = Rect(0, ((s/3.0)*2.0), width=s*2.0, height=s/3.0,
+            fillColor = colors.red, strokeColor = None, strokeWidth=0)
+        g.add(redbox2)
+        return g
+
+    def _Flag_Belgium(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.black, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+
+        box1 = Rect(0, 0, width=(s/3.0)*2.0, height=s,
+            fillColor = colors.black, strokeColor = None, strokeWidth=0)
+        g.add(box1)
+
+        box2 = Rect(((s/3.0)*2.0), 0, width=(s/3.0)*2.0, height=s,
+            fillColor = colors.gold, strokeColor = None, strokeWidth=0)
+        g.add(box2)
+
+        box3 = Rect(((s/3.0)*4.0), 0, width=(s/3.0)*2.0, height=s,
+            fillColor = colors.red, strokeColor = None, strokeWidth=0)
+        g.add(box3)
+        return g
+
+    def _Flag_China(self):
+        s = _size
+        g = Group()
+        self._width = w = s*1.5
+        g.add(Rect(0, 0, w, s, fillColor=colors.red, strokeColor=None, strokeWidth=0))
+
+        def addStar(x,y,size,angle,g=g,w=s/20.0,x0=0,y0=s/2.0):
+            s = Star()
+            s.fillColor=colors.yellow
+            s.angle = angle
+            s.size = size*w*2
+            s.x = x*w+x0
+            s.y = y*w+y0
+            g.add(s)
+
+        addStar(5,5,3, 0)
+        addStar(10,1,1,36.86989765)
+        addStar(12,3,1,8.213210702)
+        addStar(12,6,1,16.60154960)
+        addStar(10,8,1,53.13010235)
+        return g
+
+    def _Flag_Cuba(self):
+        s = _size
+        g = Group()
+
+        for i in range(5):
+            stripe = Rect(0, i*s/5.0, width=s*2, height=s/5.0,
+                fillColor = [colors.darkblue, colors.mintcream][i%2],
+                strokeColor = None,
+                strokeWidth=0)
+            g.add(stripe)
+
+        redwedge = Polygon(points = [ 0, 0, 4*s/5.0, (s/2.0), 0, s],
+                    fillColor = colors.red, strokeColor = None, strokeWidth=0)
+        g.add(redwedge)
+
+        star = Star()
+        star.x = 2.5*s/10.0
+        star.y = s/2.0
+        star.size = 3*s/10.0
+        star.fillColor = colors.white
+        g.add(star)
+
+        box = Rect(0, 0, s*2, s,
+            fillColor = None,
+            strokeColor = colors.black,
+            strokeWidth=0)
+        g.add(box)
+
+        return g
+
+    def _Flag_Denmark(self):
+        s = _size
+        g = Group()
+        self._width = w = s*1.4
+
+        box = Rect(0, 0, w, s,
+            fillColor = colors.red, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        whitebox1 = Rect(((s/5.0)*2), 0, width=s/6.0, height=s,
+            fillColor = colors.mintcream, strokeColor = None, strokeWidth=0)
+        g.add(whitebox1)
+
+        whitebox2 = Rect(0, ((s/2.0)-(s/12.0)), width=w, height=s/6.0,
+            fillColor = colors.mintcream, strokeColor = None, strokeWidth=0)
+        g.add(whitebox2)
+        return g
+
+    def _Flag_Finland(self):
+        s = _size
+        g = Group()
+
+        # crossbox specific bits
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.ghostwhite, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        blueline1 = Rect((s*0.6), 0, width=0.3*s, height=s,
+            fillColor = colors.darkblue, strokeColor = None, strokeWidth=0)
+        g.add(blueline1)
+
+        blueline2 = Rect(0, (s*0.4), width=s*2, height=s*0.3,
+            fillColor = colors.darkblue, strokeColor = None, strokeWidth=0)
+        g.add(blueline2)
+        return g
+
+    def _Flag_France(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s, fillColor = colors.navy, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        bluebox = Rect(0, 0, width=((s/3.0)*2.0), height=s,
+            fillColor = colors.blue, strokeColor = None, strokeWidth=0)
+        g.add(bluebox)
+
+        whitebox = Rect(((s/3.0)*2.0), 0, width=((s/3.0)*2.0), height=s,
+            fillColor = colors.mintcream, strokeColor = None, strokeWidth=0)
+        g.add(whitebox)
+
+        redbox = Rect(((s/3.0)*4.0), 0, width=((s/3.0)*2.0), height=s,
+            fillColor = colors.red,
+            strokeColor = None,
+            strokeWidth=0)
+        g.add(redbox)
+        return g
+
+    def _Flag_Germany(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s,
+                fillColor = colors.gold, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        blackbox1 = Rect(0, ((s/3.0)*2.0), width=s*2.0, height=s/3.0,
+            fillColor = colors.black, strokeColor = None, strokeWidth=0)
+        g.add(blackbox1)
+
+        redbox1 = Rect(0, (s/3.0), width=s*2.0, height=s/3.0,
+            fillColor = colors.orangered, strokeColor = None, strokeWidth=0)
+        g.add(redbox1)
+        return g
+
+    def _Flag_Greece(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s, fillColor = colors.gold,
+                        strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        for stripecounter in range (9,0, -1):
+            stripeheight = s/9.0
+            if not (stripecounter%2 == 0):
+                stripecolor = colors.deepskyblue
+            else:
+                stripecolor = colors.mintcream
+
+            blueorwhiteline = Rect(0, (s-(stripeheight*stripecounter)), width=s*2, height=stripeheight,
+                fillColor = stripecolor, strokeColor = None, strokeWidth=20)
+            g.add(blueorwhiteline)
+
+        bluebox1 = Rect(0, ((s)-stripeheight*5), width=(stripeheight*5), height=stripeheight*5,
+            fillColor = colors.deepskyblue, strokeColor = None, strokeWidth=0)
+        g.add(bluebox1)
+
+        whiteline1 = Rect(0, ((s)-stripeheight*3), width=stripeheight*5, height=stripeheight,
+            fillColor = colors.mintcream, strokeColor = None, strokeWidth=0)
+        g.add(whiteline1)
+
+        whiteline2 = Rect((stripeheight*2), ((s)-stripeheight*5), width=stripeheight, height=stripeheight*5,
+            fillColor = colors.mintcream, strokeColor = None, strokeWidth=0)
+        g.add(whiteline2)
+
+        return g
+
+    def _Flag_Ireland(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.forestgreen, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        whitebox = Rect(((s*2.0)/3.0), 0, width=(2.0*(s*2.0)/3.0), height=s,
+                fillColor = colors.mintcream, strokeColor = None, strokeWidth=0)
+        g.add(whitebox)
+
+        orangebox = Rect(((2.0*(s*2.0)/3.0)), 0, width=(s*2.0)/3.0, height=s,
+            fillColor = colors.darkorange, strokeColor = None, strokeWidth=0)
+        g.add(orangebox)
+        return g
+
+    def _Flag_Italy(self):
+        s = _size
+        g = Group()
+        g.add(Rect(0,0,s*2,s,fillColor=colors.forestgreen,strokeColor=None, strokeWidth=0))
+        g.add(Rect((2*s)/3.0, 0, width=(s*4)/3.0, height=s, fillColor = colors.mintcream, strokeColor = None, strokeWidth=0))
+        g.add(Rect((4*s)/3.0, 0, width=(s*2)/3.0, height=s, fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        return g
+
+    def _Flag_Japan(self):
+        s = _size
+        g = Group()
+        w = self._width = s*1.5
+        g.add(Rect(0,0,w,s,fillColor=colors.mintcream,strokeColor=None, strokeWidth=0))
+        g.add(Circle(cx=w/2.0,cy=s/2.0,r=0.3*w,fillColor=colors.red,strokeColor=None, strokeWidth=0))
+        return g
+
+    def _Flag_Luxembourg(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.mintcream, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        redbox = Rect(0, ((s/3.0)*2.0), width=s*2.0, height=s/3.0,
+                fillColor = colors.red, strokeColor = None, strokeWidth=0)
+        g.add(redbox)
+
+        bluebox = Rect(0, 0, width=s*2.0, height=s/3.0,
+                fillColor = colors.dodgerblue, strokeColor = None, strokeWidth=0)
+        g.add(bluebox)
+        return g
+
+    def _Flag_Holland(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.mintcream, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        redbox = Rect(0, ((s/3.0)*2.0), width=s*2.0, height=s/3.0,
+                fillColor = colors.red, strokeColor = None, strokeWidth=0)
+        g.add(redbox)
+
+        bluebox = Rect(0, 0, width=s*2.0, height=s/3.0,
+                fillColor = colors.darkblue, strokeColor = None, strokeWidth=0)
+        g.add(bluebox)
+        return g
+
+    def _Flag_Portugal(self):
+        return Group()
+
+    def _Flag_Russia(self):
+        s = _size
+        g = Group()
+        w = self._width = s*1.5
+        t = s/3.0
+        g.add(Rect(0, 0, width=w, height=t, fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        g.add(Rect(0, t, width=w, height=t, fillColor = colors.blue, strokeColor = None, strokeWidth=0))
+        g.add(Rect(0, 2*t, width=w, height=t, fillColor = colors.mintcream, strokeColor = None, strokeWidth=0))
+        return g
+
+    def _Flag_Spain(self):
+        s = _size
+        g = Group()
+        w = self._width = s*1.5
+        g.add(Rect(0, 0, width=w, height=s, fillColor = colors.red, strokeColor = None, strokeWidth=0))
+        g.add(Rect(0, (s/4.0), width=w, height=s/2.0, fillColor = colors.yellow, strokeColor = None, strokeWidth=0))
+        return g
+
+    def _Flag_Sweden(self):
+        s = _size
+        g = Group()
+        self._width = s*1.4
+        box = Rect(0, 0, self._width, s,
+            fillColor = colors.dodgerblue, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        box1 = Rect(((s/5.0)*2), 0, width=s/6.0, height=s,
+                fillColor = colors.gold, strokeColor = None, strokeWidth=0)
+        g.add(box1)
+
+        box2 = Rect(0, ((s/2.0)-(s/12.0)), width=self._width, height=s/6.0,
+            fillColor = colors.gold,
+            strokeColor = None,
+            strokeWidth=0)
+        g.add(box2)
+        return g
+
+    def _Flag_Norway(self):
+        s = _size
+        g = Group()
+        self._width = s*1.4
+
+        box = Rect(0, 0, self._width, s,
+                fillColor = colors.red, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        box = Rect(0, 0, self._width, s,
+                fillColor = colors.red, strokeColor = colors.black, strokeWidth=0)
+        g.add(box)
+
+        whiteline1 = Rect(((s*0.2)*2), 0, width=s*0.2, height=s,
+                fillColor = colors.ghostwhite, strokeColor = None, strokeWidth=0)
+        g.add(whiteline1)
+
+        whiteline2 = Rect(0, (s*0.4), width=self._width, height=s*0.2,
+                fillColor = colors.ghostwhite, strokeColor = None, strokeWidth=0)
+        g.add(whiteline2)
+
+        blueline1 = Rect(((s*0.225)*2), 0, width=0.1*s, height=s,
+                fillColor = colors.darkblue, strokeColor = None, strokeWidth=0)
+        g.add(blueline1)
+
+        blueline2 = Rect(0, (s*0.45), width=self._width, height=s*0.1,
+                fillColor = colors.darkblue, strokeColor = None, strokeWidth=0)
+        g.add(blueline2)
+        return g
+
+    def _Flag_CzechRepublic(self):
+        s = _size
+        g = Group()
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.mintcream,
+                        strokeColor = colors.black,
+            strokeWidth=0)
+        g.add(box)
+
+        redbox = Rect(0, 0, width=s*2, height=s/2.0,
+            fillColor = colors.red,
+            strokeColor = None,
+            strokeWidth=0)
+        g.add(redbox)
+
+        bluewedge = Polygon(points = [ 0, 0, s, (s/2.0), 0, s],
+                    fillColor = colors.darkblue, strokeColor = None, strokeWidth=0)
+        g.add(bluewedge)
+        return g
+
+    def _Flag_Palestine(self):
+        s = _size
+        g = Group()
+        box = Rect(0, s/3.0, s*2, s/3.0,
+            fillColor = colors.mintcream,
+                        strokeColor = None,
+            strokeWidth=0)
+        g.add(box)
+
+        greenbox = Rect(0, 0, width=s*2, height=s/3.0,
+            fillColor = colors.limegreen,
+            strokeColor = None,
+            strokeWidth=0)
+        g.add(greenbox)
+
+        blackbox = Rect(0, 2*s/3.0, width=s*2, height=s/3.0,
+            fillColor = colors.black,
+            strokeColor = None,
+            strokeWidth=0)
+        g.add(blackbox)
+
+        redwedge = Polygon(points = [ 0, 0, 2*s/3.0, (s/2.0), 0, s],
+                    fillColor = colors.red, strokeColor = None, strokeWidth=0)
+        g.add(redwedge)
+        return g
+
+    def _Flag_Turkey(self):
+        s = _size
+        g = Group()
+
+        box = Rect(0, 0, s*2, s,
+            fillColor = colors.red,
+                        strokeColor = colors.black,
+            strokeWidth=0)
+        g.add(box)
+
+        whitecircle = Circle(cx=((s*0.35)*2), cy=s/2.0, r=s*0.3,
+            fillColor = colors.mintcream,
+            strokeColor = None,
+            strokeWidth=0)
+        g.add(whitecircle)
+
+        redcircle = Circle(cx=((s*0.39)*2), cy=s/2.0, r=s*0.24,
+            fillColor = colors.red,
+            strokeColor = None,
+            strokeWidth=0)
+        g.add(redcircle)
+
+        ws = Star()
+        ws.angle = 15
+        ws.size = s/5.0
+        ws.x = (s*0.5)*2+ws.size/2.0
+        ws.y = (s*0.5)
+        ws.fillColor = colors.mintcream
+        ws.strokeColor = None
+        g.add(ws)
+        return g
+
+    def _Flag_Switzerland(self):
+        s = _size
+        g = Group()
+        self._width = s
+
+        g.add(Rect(0, 0, s, s, fillColor = colors.red, strokeColor = colors.black, strokeWidth=0))
+        g.add(Line((s/2.0), (s/5.5), (s/2), (s-(s/5.5)),
+            fillColor = colors.mintcream, strokeColor = colors.mintcream, strokeWidth=(s/5.0)))
+        g.add(Line((s/5.5), (s/2.0), (s-(s/5.5)), (s/2.0),
+            fillColor = colors.mintcream, strokeColor = colors.mintcream, strokeWidth=s/5.0))
+        return g
+
+    def _Flag_EU(self):
+        s = _size
+        g = Group()
+        w = self._width = 1.5*s
+
+        g.add(Rect(0, 0, w, s, fillColor = colors.darkblue, strokeColor = None, strokeWidth=0))
+        centerx=w/2.0
+        centery=s/2.0
+        radius=s/3.0
+        yradius = radius
+        xradius = radius
+        nStars = 12
+        delta = 2*pi/nStars
+        for i in range(nStars):
+            rad = i*delta
+            gs = Star()
+            gs.x=cos(rad)*radius+centerx
+            gs.y=sin(rad)*radius+centery
+            gs.size=s/10.0
+            gs.fillColor=colors.gold
+            g.add(gs)
+        return g
+
+    def _Flag_Brazil(self):
+        s = _size  # abbreviate as we will use this a lot
+        g = Group()
+
+        m = s/14.0
+        self._width = w = (m * 20)
+
+        def addStar(x,y,size, g=g, w=w, s=s, m=m):
+            st = Star()
+            st.fillColor=colors.mintcream
+            st.size = size*m
+            st.x = (w/2.0) + (x * (0.35 * m))
+            st.y = (s/2.0) + (y * (0.35 * m))
+            g.add(st)
+
+        g.add(Rect(0, 0, w, s, fillColor = colors.green, strokeColor = None, strokeWidth=0))
+        g.add(Polygon(points = [ 1.7*m, (s/2.0), (w/2.0), s-(1.7*m), w-(1.7*m),(s/2.0),(w/2.0), 1.7*m],
+                      fillColor = colors.yellow, strokeColor = None, strokeWidth=0))
+        g.add(Circle(cx=w/2.0, cy=s/2.0, r=3.5*m,
+                     fillColor=colors.blue,strokeColor=None, strokeWidth=0))
+        g.add(Wedge((w/2.0)-(2*m), 0, 8.5*m, 50, 98.1, 8.5*m,
+                    fillColor=colors.mintcream,strokeColor=None, strokeWidth=0))
+        g.add(Wedge((w/2.0), (s/2.0), 3.501*m, 156, 352, 3.501*m,
+                    fillColor=colors.mintcream,strokeColor=None, strokeWidth=0))
+        g.add(Wedge((w/2.0)-(2*m), 0, 8*m, 48.1, 100, 8*m,
+                    fillColor=colors.blue,strokeColor=None, strokeWidth=0))
+        g.add(Rect(0, 0, w, (s/4.0) + 1.7*m,
+                   fillColor = colors.green, strokeColor = None, strokeWidth=0))
+        g.add(Polygon(points = [ 1.7*m,(s/2.0), (w/2.0),s/2.0 - 2*m,    w-(1.7*m),(s/2.0) , (w/2.0),1.7*m],
+                      fillColor = colors.yellow, strokeColor = None, strokeWidth=0))
+        g.add(Wedge(w/2.0, s/2.0, 3.502*m, 166, 342.1, 3.502*m,
+                    fillColor=colors.blue,strokeColor=None, strokeWidth=0))
+
+        addStar(3.2,3.5,0.3)
+        addStar(-8.5,1.5,0.3)
+        addStar(-7.5,-3,0.3)
+        addStar(-4,-5.5,0.3)
+        addStar(0,-4.5,0.3)
+        addStar(7,-3.5,0.3)
+        addStar(-3.5,-0.5,0.25)
+        addStar(0,-1.5,0.25)
+        addStar(1,-2.5,0.25)
+        addStar(3,-7,0.25)
+        addStar(5,-6.5,0.25)
+        addStar(6.5,-5,0.25)
+        addStar(7,-4.5,0.25)
+        addStar(-5.5,-3.2,0.25)
+        addStar(-6,-4.2,0.25)
+        addStar(-1,-2.75,0.2)
+        addStar(2,-5.5,0.2)
+        addStar(4,-5.5,0.2)
+        addStar(5,-7.5,0.2)
+        addStar(5,-5.5,0.2)
+        addStar(6,-5.5,0.2)
+        addStar(-8.8,-3.2,0.2)
+        addStar(2.5,0.5,0.2)
+        addStar(-0.2,-3.2,0.14)
+        addStar(-7.2,-2,0.14)
+        addStar(0,-8,0.1)
+
+        sTmp = "ORDEM E PROGRESSO"
+        nTmp = len(sTmp)
+        delta = 0.850848010347/nTmp
+        radius = 7.9 *m
+        centerx = (w/2.0)-(2*m)
+        centery = 0
+        for i in range(nTmp):
+            rad = 2*pi - i*delta -4.60766922527
+            x=cos(rad)*radius+centerx
+            y=sin(rad)*radius+centery
+            if i == 6:
+                z = 0.35*m
+            else:
+                z= 0.45*m
+            g2 = Group(String(x, y, sTmp[i], fontName='Helvetica-Bold',
+                fontSize = z,strokeColor=None,fillColor=colors.green))
+            g2.rotate(rad)
+            g.add(g2)
+        return g
+
+def makeFlag(name):
+    flag = Flag()
+    flag.kind = name
+    return flag
+
+def test():
+    """This function produces three pdf files with examples of all the signs and symbols from this file.
+    """
+# page 1
+
+    labelFontSize = 10
+
+    X = (20,245)
+
+    flags = [
+            'UK',
+            'USA',
+            'Afghanistan',
+            'Austria',
+            'Belgium',
+            'Denmark',
+            'Cuba',
+            'Finland',
+            'France',
+            'Germany',
+            'Greece',
+            'Ireland',
+            'Italy',
+            'Luxembourg',
+            'Holland',
+            'Palestine',
+            'Portugal',
+            'Spain',
+            'Sweden',
+            'Norway',
+            'CzechRepublic',
+            'Turkey',
+            'Switzerland',
+            'EU',
+            'Brazil',
+            ]
+    y = Y0 = 530
+    f = 0
+    D = None
+    for name in flags:
+        if not D: D = Drawing(450,650)
+        flag = makeFlag(name)
+        i = flags.index(name)
+        flag.x = X[i%2]
+        flag.y = y
+        D.add(flag)
+        D.add(String(flag.x+(flag.size/2.0),(flag.y-(1.2*labelFontSize)),
+                name, fillColor=colors.black, textAnchor='middle', fontSize=labelFontSize))
+        if i%2: y = y - 125
+        if (i%2 and y<0) or name==flags[-1]:
+            renderPDF.drawToFile(D, 'flags%02d.pdf'%f, 'flags.py - Page #%d'%(f+1))
+            y = Y0
+            f = f+1
+            D = None
+
+if __name__=='__main__':
+    test()

.venv/lib/python3.13/site-packages/reportlab/graphics/widgets/grids.py

@@ -0,0 +1,542 @@
+#Copyright ReportLab Europe Ltd. 2000-2017
+#see license.txt for license details
+#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/graphics/widgets/grids.py
+__version__='3.3.0'
+
+from reportlab.lib import colors
+from reportlab.lib.validators import isNumber, isColorOrNone, isBoolean, isListOfNumbers, OneOf, isListOfColors, isNumberOrNone
+from reportlab.lib.attrmap import AttrMap, AttrMapValue
+from reportlab.graphics.shapes import Drawing, Group, Line, Rect, LineShape, definePath, EmptyClipPath
+from reportlab.graphics.widgetbase import Widget
+from math import radians
+from reportlab.graphics.transform import translate, rotate, mmult, transformPoints, inverse
+from reportlab.lib.utils import flatten
+
+def frange(start, end=None, inc=None):
+    "A range function, that does accept float increments..."
+
+    if end == None:
+        end = start + 0.0
+        start = 0.0
+
+    if inc == None:
+        inc = 1.0
+
+    L = []
+    end = end - inc*0.0001  #to avoid numrical problems
+    while 1:
+        next = start + len(L) * inc
+        if inc > 0 and next >= end:
+            break
+        elif inc < 0 and next <= end:
+            break
+        L.append(next)
+
+    return L
+
+
+def makeDistancesList(list):
+    """Returns a list of distances between adjacent numbers in some input list.
+
+    E.g. [1, 1, 2, 3, 5, 7] -> [0, 1, 1, 2, 2]
+    """
+
+    d = []
+    for i in range(len(list[:-1])):
+        d.append(list[i+1] - list[i])
+
+    return d
+
+
+class Grid(Widget):
+    """This makes a rectangular grid of equidistant stripes.
+
+    The grid contains an outer border rectangle, and stripes
+    inside which can be drawn with lines and/or as solid tiles.
+    The drawing order is: outer rectangle, then lines and tiles.
+
+    The stripes' width is indicated as 'delta'. The sequence of
+    stripes can have an offset named 'delta0'. Both values need
+    to be positive!
+    """
+
+    _attrMap = AttrMap(
+        x = AttrMapValue(isNumber, desc="The grid's lower-left x position."),
+        y = AttrMapValue(isNumber, desc="The grid's lower-left y position."),
+        width = AttrMapValue(isNumber, desc="The grid's width."),
+        height = AttrMapValue(isNumber, desc="The grid's height."),
+        orientation = AttrMapValue(OneOf(('vertical', 'horizontal')),
+            desc='Determines if stripes are vertical or horizontal.'),
+        useLines = AttrMapValue(OneOf((0, 1)),
+            desc='Determines if stripes are drawn with lines.'),
+        useRects = AttrMapValue(OneOf((0, 1)),
+            desc='Determines if stripes are drawn with solid rectangles.'),
+        delta = AttrMapValue(isNumber,
+            desc='Determines the width/height of the stripes.'),
+        delta0 = AttrMapValue(isNumber,
+            desc='Determines the stripes initial width/height offset.'),
+        deltaSteps = AttrMapValue(isListOfNumbers,
+            desc='List of deltas to be used cyclically.'),
+        stripeColors = AttrMapValue(isListOfColors,
+            desc='Colors applied cyclically in the right or upper direction.'),
+        fillColor = AttrMapValue(isColorOrNone,
+            desc='Background color for entire rectangle.'),
+        strokeColor = AttrMapValue(isColorOrNone,
+            desc='Color used for lines.'),
+        strokeWidth = AttrMapValue(isNumber,
+            desc='Width used for lines.'),
+        rectStrokeColor = AttrMapValue(isColorOrNone, desc='Color for outer rect stroke.'),
+        rectStrokeWidth = AttrMapValue(isNumberOrNone, desc='Width for outer rect stroke.'),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.width = 100
+        self.height = 100
+        self.orientation = 'vertical'
+        self.useLines = 0
+        self.useRects = 1
+        self.delta = 20
+        self.delta0 = 0
+        self.deltaSteps = []
+        self.fillColor = colors.white
+        self.stripeColors = [colors.red, colors.green, colors.blue]
+        self.strokeColor = colors.black
+        self.strokeWidth = 2
+
+
+    def demo(self):
+        D = Drawing(100, 100)
+
+        g = Grid()
+        D.add(g)
+
+        return D
+
+    def makeOuterRect(self):
+        strokeColor = getattr(self,'rectStrokeColor',self.strokeColor)
+        strokeWidth = getattr(self,'rectStrokeWidth',self.strokeWidth)
+        if self.fillColor or (strokeColor and strokeWidth):
+            rect = Rect(self.x, self.y, self.width, self.height)
+            rect.fillColor = self.fillColor
+            rect.strokeColor = strokeColor
+            rect.strokeWidth = strokeWidth
+            return rect
+        else:
+            return None
+
+    def makeLinePosList(self, start, isX=0):
+        "Returns a list of positions where to place lines."
+
+        w, h = self.width, self.height
+        if isX:
+            length = w
+        else:
+            length = h
+        if self.deltaSteps:
+            r = [start + self.delta0]
+            i = 0
+            while 1:
+                if r[-1] > start + length:
+                    del r[-1]
+                    break
+                r.append(r[-1] + self.deltaSteps[i % len(self.deltaSteps)])
+                i = i + 1
+        else:
+            r = frange(start + self.delta0, start + length, self.delta)
+
+        r.append(start + length)
+        if self.delta0 != 0:
+            r.insert(0, start)
+        #print 'Grid.makeLinePosList() -> %s' % r
+        return r
+
+
+    def makeInnerLines(self):
+        # inner grid lines
+        group = Group()
+
+        w, h = self.width, self.height
+
+        if self.useLines == 1:
+            if self.orientation == 'vertical':
+                r = self.makeLinePosList(self.x, isX=1)
+                for x in r:
+                    line = Line(x, self.y, x, self.y + h)
+                    line.strokeColor = self.strokeColor
+                    line.strokeWidth = self.strokeWidth
+                    group.add(line)
+            elif self.orientation == 'horizontal':
+                r = self.makeLinePosList(self.y, isX=0)
+                for y in r:
+                    line = Line(self.x, y, self.x + w, y)
+                    line.strokeColor = self.strokeColor
+                    line.strokeWidth = self.strokeWidth
+                    group.add(line)
+
+        return group
+
+
+    def makeInnerTiles(self):
+        # inner grid lines
+        group = Group()
+
+        w, h = self.width, self.height
+
+        # inner grid stripes (solid rectangles)
+        if self.useRects == 1:
+            cols = self.stripeColors
+
+            if self.orientation == 'vertical':
+                r = self.makeLinePosList(self.x, isX=1)
+            elif self.orientation == 'horizontal':
+                r = self.makeLinePosList(self.y, isX=0)
+
+            dist = makeDistancesList(r)
+
+            i = 0
+            for j in range(len(dist)):
+                if self.orientation == 'vertical':
+                    x = r[j]
+                    stripe = Rect(x, self.y, dist[j], h)
+                elif self.orientation == 'horizontal':
+                    y = r[j]
+                    stripe = Rect(self.x, y, w, dist[j])
+                stripe.fillColor = cols[i % len(cols)]
+                stripe.strokeColor = None
+                group.add(stripe)
+                i = i + 1
+
+        return group
+
+
+    def draw(self):
+        # general widget bits
+        group = Group()
+
+        group.add(self.makeOuterRect())
+        group.add(self.makeInnerTiles())
+        group.add(self.makeInnerLines(),name='_gridLines')
+
+        return group
+
+
+class DoubleGrid(Widget):
+    """This combines two ordinary Grid objects orthogonal to each other.
+    """
+
+    _attrMap = AttrMap(
+        x = AttrMapValue(isNumber, desc="The grid's lower-left x position."),
+        y = AttrMapValue(isNumber, desc="The grid's lower-left y position."),
+        width = AttrMapValue(isNumber, desc="The grid's width."),
+        height = AttrMapValue(isNumber, desc="The grid's height."),
+        grid0 = AttrMapValue(None, desc="The first grid component."),
+        grid1 = AttrMapValue(None, desc="The second grid component."),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.width = 100
+        self.height = 100
+
+        g0 = Grid()
+        g0.x = self.x
+        g0.y = self.y
+        g0.width = self.width
+        g0.height = self.height
+        g0.orientation = 'vertical'
+        g0.useLines = 1
+        g0.useRects = 0
+        g0.delta = 20
+        g0.delta0 = 0
+        g0.deltaSteps = []
+        g0.fillColor = colors.white
+        g0.stripeColors = [colors.red, colors.green, colors.blue]
+        g0.strokeColor = colors.black
+        g0.strokeWidth = 1
+
+        g1 = Grid()
+        g1.x = self.x
+        g1.y = self.y
+        g1.width = self.width
+        g1.height = self.height
+        g1.orientation = 'horizontal'
+        g1.useLines = 1
+        g1.useRects = 0
+        g1.delta = 20
+        g1.delta0 = 0
+        g1.deltaSteps = []
+        g1.fillColor = colors.white
+        g1.stripeColors = [colors.red, colors.green, colors.blue]
+        g1.strokeColor = colors.black
+        g1.strokeWidth = 1
+
+        self.grid0 = g0
+        self.grid1 = g1
+
+
+##    # This gives an AttributeError:
+##    #   DoubleGrid instance has no attribute 'grid0'
+##    def __setattr__(self, name, value):
+##        if name in ('x', 'y', 'width', 'height'):
+##            setattr(self.grid0, name, value)
+##            setattr(self.grid1, name, value)
+
+
+    def demo(self):
+        D = Drawing(100, 100)
+        g = DoubleGrid()
+        D.add(g)
+        return D
+
+
+    def draw(self):
+        group = Group()
+        g0, g1 = self.grid0, self.grid1
+        # Order groups to make sure both v and h lines
+        # are visible (works only when there is only
+        # one kind of stripes, v or h).
+        G = g0.useRects == 1 and g1.useRects == 0 and (g0,g1) or (g1,g0)
+        for g in G:
+            group.add(g.makeOuterRect())
+        for g in G:
+            group.add(g.makeInnerTiles())
+            group.add(g.makeInnerLines(),name='_gridLines')
+
+        return group
+
+
+class ShadedRect(Widget):
+    """This makes a rectangle with shaded colors between two colors.
+
+    Colors are interpolated linearly between 'fillColorStart'
+    and 'fillColorEnd', both of which appear at the margins.
+    If 'numShades' is set to one, though, only 'fillColorStart'
+    is used.
+    """
+
+    _attrMap = AttrMap(
+        x = AttrMapValue(isNumber, desc="The grid's lower-left x position."),
+        y = AttrMapValue(isNumber, desc="The grid's lower-left y position."),
+        width = AttrMapValue(isNumber, desc="The grid's width."),
+        height = AttrMapValue(isNumber, desc="The grid's height."),
+        orientation = AttrMapValue(OneOf(('vertical', 'horizontal')), desc='Determines if stripes are vertical or horizontal.'),
+        numShades = AttrMapValue(isNumber, desc='The number of interpolating colors.'),
+        fillColorStart = AttrMapValue(isColorOrNone, desc='Start value of the color shade.'),
+        fillColorEnd = AttrMapValue(isColorOrNone, desc='End value of the color shade.'),
+        strokeColor = AttrMapValue(isColorOrNone, desc='Color used for border line.'),
+        strokeWidth = AttrMapValue(isNumber, desc='Width used for lines.'),
+        cylinderMode = AttrMapValue(isBoolean, desc='True if shading reverses in middle.'),
+        )
+
+    def __init__(self,**kw):
+        self.x = 0
+        self.y = 0
+        self.width = 100
+        self.height = 100
+        self.orientation = 'vertical'
+        self.numShades = 20
+        self.fillColorStart = colors.pink
+        self.fillColorEnd = colors.black
+        self.strokeColor = colors.black
+        self.strokeWidth = 2
+        self.cylinderMode = 0
+        self.setProperties(kw)
+
+    def demo(self):
+        D = Drawing(100, 100)
+        g = ShadedRect()
+        D.add(g)
+
+        return D
+
+    def _flipRectCorners(self):
+        "Flip rectangle's corners if width or height is negative."
+        x, y, width, height, fillColorStart, fillColorEnd = self.x, self.y, self.width, self.height, self.fillColorStart, self.fillColorEnd
+        if width < 0 and height > 0:
+            x = x + width
+            width = -width
+            if self.orientation=='vertical': fillColorStart, fillColorEnd = fillColorEnd, fillColorStart
+        elif height<0 and width>0:
+            y = y + height
+            height = -height
+            if self.orientation=='horizontal': fillColorStart, fillColorEnd = fillColorEnd, fillColorStart
+        elif height < 0 and height < 0:
+            x = x + width
+            width = -width
+            y = y + height
+            height = -height
+        return x, y, width, height, fillColorStart, fillColorEnd
+
+    def draw(self):
+        # general widget bits
+        group = Group()
+        x, y, w, h, c0, c1 = self._flipRectCorners()
+        vertical = self.orientation == 'vertical'
+        cylinderMode = self.cylinderMode
+        linG = getattr(getattr(self,'_canvas',None),'linearGradient',None)
+        if linG:
+            canv = linG.__self__
+            canv.saveState()
+            p = canv.beginPath()
+            p.rect(x, y, w, h)
+            canv.clipPath(p, stroke=0)
+            if cylinderMode:
+                if vertical:
+                    linG(x, y, x+w/2, y, (c0,c1), extend=False)
+                    linG(x+w/2, y, x+w, y, (c1,c0), extend=False)
+                else:
+                    linG(x, y, x, y+h/2, (c0,c1), extend=False)
+                    linG(x, y+h/2, x, y+h, (c1,c0), extend=False)
+            else:
+                if vertical:
+                    linG(x, y, x+w, y, (c0,c1), extend=False)
+                else:
+                    linG(x, y, x, y+h, (c0,c1), extend=False)
+            canv.restoreState()
+        else:
+            numShades = self.numShades
+            if cylinderMode:
+                if not numShades%2: numShades = numShades+1
+                halfNumShades = int((numShades-1)/2) + 1
+            num = float(numShades) # must make it float!
+            if vertical:
+                if numShades == 1:
+                    V = [x]
+                else:
+                    V = frange(x, x + w, w/num)
+            else:
+                if numShades == 1:
+                    V = [y]
+                else:
+                    V = frange(y, y + h, h/num)
+
+            for v in V:
+                stripe = vertical and Rect(v, y, w/num, h) or Rect(x, v, w, h/num)
+                if cylinderMode:
+                    if V.index(v)>=halfNumShades:
+                        col = colors.linearlyInterpolatedColor(c1,c0,V[halfNumShades],V[-1], v)
+                    else:
+                        col = colors.linearlyInterpolatedColor(c0,c1,V[0],V[halfNumShades], v)
+                else:
+                    col = colors.linearlyInterpolatedColor(c0,c1,V[0],V[-1], v)
+                stripe.fillColor = col
+                stripe.strokeColor = col
+                stripe.strokeWidth = 1
+                group.add(stripe)
+        if self.strokeColor and self.strokeWidth>=0:
+            rect = Rect(x, y, w, h)
+            rect.strokeColor = self.strokeColor
+            rect.strokeWidth = self.strokeWidth
+            rect.fillColor = None
+            group.add(rect)
+        return group
+
+
+def colorRange(c0, c1, n):
+    "Return a range of intermediate colors between c0 and c1"
+    if n==1: return [c0]
+
+    C = []
+    if n>1:
+        lim = n-1
+        for i in range(n):
+            C.append(colors.linearlyInterpolatedColor(c0,c1,0,lim, i))
+    return C
+
+
+def centroid(P):
+    '''compute average point of a set of points'''
+    cx = 0
+    cy = 0
+    for x,y in P:
+        cx+=x
+        cy+=y
+    n = len(P)
+    return cx/n, cy/n
+
+def rotatedEnclosingRect(P, angle, rect):
+    '''
+    given P a sequence P of x,y coordinate pairs and an angle in degrees
+    find the centroid of P and the axis at angle theta through it
+    find the extreme points of P wrt axis parallel distance and axis
+    orthogonal distance. Then compute the least rectangle that will still
+    enclose P when rotated by angle. Positive angles correspond to clockwise
+    rotation of the enclosing rect.
+    '''
+    x0, y0 = centroid(P)
+    theta = radians(angle)
+    #translate to the centroid and rotate
+    mx = mmult(translate(x0,y0),rotate(angle))
+
+    #compute min and max of x and y of the rotated points
+    tp = flatten(transformPoints(mx,P))
+    xx = tp[::2]
+    yx = tp[1::2]
+    xn = min(xx)
+    xx = max(xx)
+    yn = min(yx)
+    yx = max(yx)
+
+    #make the enclosing rect and invert the original transform
+    rect.x = xn
+    rect.width = xx-xn
+    rect.y = yn
+    rect.height = yx-yn
+    g = Group(transform=inverse(mx))
+    g.add(rect)
+    return g
+
+class ShadedPolygon(Widget,LineShape):
+    '''given a list of points [(x0,y0),....] we construct an enclosing
+    shaded rectangle and mask using the polygon points.
+    At angle 0 the shading fillColorStart left --> fillColorEnd right.
+    positive angles rotate the shading clockwise.
+    '''
+    _attrMap = AttrMap(BASE=LineShape,
+        angle = AttrMapValue(isNumber,desc="Shading angle"),
+        fillColorStart = AttrMapValue(isColorOrNone),
+        fillColorEnd = AttrMapValue(isColorOrNone),
+        numShades = AttrMapValue(isNumber, desc='The number of interpolating colors.'),
+        cylinderMode = AttrMapValue(isBoolean, desc='True if shading reverses in middle.'),
+        points = AttrMapValue(isListOfNumbers),
+        )
+
+    def __init__(self,**kw):
+        self.angle = 90
+        self.fillColorStart = colors.red
+        self.fillColorEnd = colors.green
+        self.cylinderMode = 0
+        self.numShades = 50
+        self.points = [-1,-1,2,2,3,-1]
+        LineShape.__init__(self,kw)
+
+    def draw(self):
+        P = self.points
+        P = list(zip(P[::2],P[1::2]))
+        path = definePath([('moveTo',)+P[0]]+[('lineTo',)+x for x in P[1:]]+['closePath'],
+            fillColor=None, strokeColor=None)
+        path.isClipPath = 1
+        g = Group()
+        g.add(path)
+        angle = self.angle % 360
+        orientation = 'horizontal' if 0<=angle<=45 or 315<=angle<=360 or 135<=angle<=225 else 'vertical'
+        rect = ShadedRect(strokeWidth=0,strokeColor=None,orientation=orientation)
+        for k in 'fillColorStart', 'fillColorEnd', 'numShades', 'cylinderMode':
+            setattr(rect,k,getattr(self,k))
+        g.add(rotatedEnclosingRect(P, angle, rect))
+        g.add(EmptyClipPath)
+        path = path.copy()
+        path.isClipPath = 0
+        path.strokeColor = self.strokeColor
+        path.strokeWidth = self.strokeWidth
+        g.add(path)
+        return g
+
+if __name__=='__main__': #noruntests
+    angle=45
+    D = Drawing(120,120)
+    D.add(ShadedPolygon(points=(10,10,60,60,110,10),strokeColor=None,strokeWidth=1,angle=90,numShades=50,cylinderMode=0))
+    D.save(formats=['pdf','gif'],fnRoot='shobj',outDir='/tmp')

.venv/lib/python3.13/site-packages/reportlab/graphics/widgets/signsandsymbols.py

@@ -0,0 +1,977 @@
+#Copyright ReportLab Europe Ltd. 2000-2017
+#see license.txt for license details
+#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/graphics/widgets/signsandsymbols.py
+# signsandsymbols.py
+# A collection of new widgets
+# author: John Precedo (johnp@reportlab.com)
+
+__version__='3.3.0'
+__doc__="""This file is a collection of widgets to produce some common signs and symbols.
+
+Widgets include:
+
+- ETriangle (an equilateral triangle),
+- RTriangle (a right angled triangle),
+- Octagon,
+- Crossbox,
+- Tickbox,
+- SmileyFace,
+- StopSign,
+- NoEntry,
+- NotAllowed (the red roundel from 'no smoking' signs),
+- NoSmoking,
+- DangerSign (a black exclamation point in a yellow triangle),
+- YesNo (returns a tickbox or a crossbox depending on a testvalue),
+- FloppyDisk,
+- ArrowOne, and
+- ArrowTwo
+- CrossHair
+"""
+
+from reportlab.lib import colors
+from reportlab.lib.validators import *
+from reportlab.lib.attrmap import *
+from reportlab.lib.utils import isStr, asUnicode
+from reportlab.graphics import shapes
+from reportlab.graphics.widgetbase import Widget
+from reportlab.graphics import renderPDF
+
+
+class _Symbol(Widget):
+    """Abstract base widget
+    possible attributes:
+    'x', 'y', 'size', 'fillColor', 'strokeColor'
+    """
+    _nodoc = 1
+    _attrMap = AttrMap(
+        x = AttrMapValue(isNumber,desc='symbol x coordinate'),
+        y = AttrMapValue(isNumber,desc='symbol y coordinate'),
+        dx = AttrMapValue(isNumber,desc='symbol x coordinate adjustment'),
+        dy = AttrMapValue(isNumber,desc='symbol x coordinate adjustment'),
+        size = AttrMapValue(isNumber),
+        fillColor = AttrMapValue(isColorOrNone),
+        strokeColor = AttrMapValue(isColorOrNone),
+        strokeWidth = AttrMapValue(isNumber),
+        )
+    def __init__(self):
+        assert self.__class__.__name__!='_Symbol', 'Abstract class _Symbol instantiated'
+        self.x = self.y = self.dx = self.dy = 0
+        self.size = 100
+        self.fillColor = colors.red
+        self.strokeColor = None
+        self.strokeWidth = 0.1
+
+    def demo(self):
+        D = shapes.Drawing(200, 100)
+        s = float(self.size)
+        ob = self.__class__()
+        ob.x=50
+        ob.y=0
+        ob.draw()
+        D.add(ob)
+        D.add(shapes.String(ob.x+(s/2),(ob.y-12),
+                            ob.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=10))
+        return D
+
+class ETriangle(_Symbol):
+    """This draws an equilateral triangle."""
+
+    def __init__(self):
+        _Symbol.__init__(self)
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # Triangle specific bits
+        ae = s*0.125            #(ae = 'an eighth')
+        triangle = shapes.Polygon(points = [
+            self.x, self.y,
+            self.x+s, self.y,
+            self.x+(s/2),self.y+s],
+               fillColor = self.fillColor,
+               strokeColor = self.strokeColor,
+               strokeWidth=s/50.)
+        g.add(triangle)
+        return g
+
+class RTriangle(_Symbol):
+    """This draws a right-angled triangle.
+
+        possible attributes:
+        'x', 'y', 'size', 'fillColor', 'strokeColor'
+
+        """
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.fillColor = colors.green
+        self.strokeColor = None
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # Triangle specific bits
+        ae = s*0.125            #(ae = 'an eighth')
+        triangle = shapes.Polygon(points = [
+            self.x, self.y,
+            self.x+s, self.y,
+            self.x,self.y+s],
+               fillColor = self.fillColor,
+               strokeColor = self.strokeColor,
+               strokeWidth=s/50.)
+        g.add(triangle)
+        return g
+
+class Octagon(_Symbol):
+    """This widget draws an Octagon.
+
+        possible attributes:
+        'x', 'y', 'size', 'fillColor', 'strokeColor'
+
+    """
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.fillColor = colors.yellow
+        self.strokeColor = None
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # Octagon specific bits
+        athird=s/3
+
+        octagon = shapes.Polygon(points=[self.x+athird, self.y,
+                                              self.x, self.y+athird,
+                                              self.x, self.y+(athird*2),
+                                              self.x+athird, self.y+s,
+                                              self.x+(athird*2), self.y+s,
+                                              self.x+s, self.y+(athird*2),
+                                              self.x+s, self.y+athird,
+                                              self.x+(athird*2), self.y],
+                                      strokeColor = self.strokeColor,
+                                      fillColor = self.fillColor,
+                                      strokeWidth=10)
+        g.add(octagon)
+        return g
+
+class Crossbox(_Symbol):
+    """This draws a black box with a red cross in it - a 'checkbox'.
+
+        possible attributes:
+        'x', 'y', 'size', 'crossColor', 'strokeColor', 'crosswidth'
+
+    """
+
+    _attrMap = AttrMap(BASE=_Symbol,
+        crossColor = AttrMapValue(isColorOrNone),
+        crosswidth = AttrMapValue(isNumber),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.fillColor = colors.white
+        self.crossColor = colors.red
+        self.strokeColor = colors.black
+        self.crosswidth = 10
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # crossbox specific bits
+        box = shapes.Rect(self.x+1, self.y+1, s-2, s-2,
+               fillColor = self.fillColor,
+               strokeColor = self.strokeColor,
+               strokeWidth=2)
+        g.add(box)
+
+        crossLine1 = shapes.Line(self.x+(s*0.15), self.y+(s*0.15), self.x+(s*0.85), self.y+(s*0.85),
+               fillColor = self.crossColor,
+               strokeColor = self.crossColor,
+               strokeWidth = self.crosswidth)
+        g.add(crossLine1)
+
+        crossLine2 = shapes.Line(self.x+(s*0.15), self.y+(s*0.85), self.x+(s*0.85) ,self.y+(s*0.15),
+               fillColor = self.crossColor,
+               strokeColor = self.crossColor,
+               strokeWidth = self.crosswidth)
+        g.add(crossLine2)
+
+        return g
+
+
+class Tickbox(_Symbol):
+    """This draws a black box with a red tick in it - another 'checkbox'.
+
+        possible attributes:
+        'x', 'y', 'size', 'tickColor', 'strokeColor', 'tickwidth'
+
+"""
+
+    _attrMap = AttrMap(BASE=_Symbol,
+        tickColor = AttrMapValue(isColorOrNone),
+        tickwidth = AttrMapValue(isNumber),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.tickColor = colors.red
+        self.strokeColor = colors.black
+        self.fillColor = colors.white
+        self.tickwidth = 10
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # tickbox specific bits
+        box = shapes.Rect(self.x+1, self.y+1, s-2, s-2,
+               fillColor = self.fillColor,
+               strokeColor = self.strokeColor,
+               strokeWidth=2)
+        g.add(box)
+
+        tickLine = shapes.PolyLine(points = [self.x+(s*0.15), self.y+(s*0.35), self.x+(s*0.35), self.y+(s*0.15),
+                                             self.x+(s*0.35), self.y+(s*0.15), self.x+(s*0.85) ,self.y+(s*0.85)],
+               fillColor = self.tickColor,
+               strokeColor = self.tickColor,
+               strokeWidth = self.tickwidth)
+        g.add(tickLine)
+
+        return g
+
+class SmileyFace(_Symbol):
+    """This draws a classic smiley face.
+
+        possible attributes:
+        'x', 'y', 'size', 'fillColor'
+
+    """
+
+    def __init__(self):
+        _Symbol.__init__(self)
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.fillColor = colors.yellow
+        self.strokeColor = colors.black
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # SmileyFace specific bits
+        g.add(shapes.Circle(cx=self.x+(s/2), cy=self.y+(s/2), r=s/2,
+                fillColor=self.fillColor, strokeColor=self.strokeColor,
+                strokeWidth=max(s/38.,self.strokeWidth)))
+
+        for i in (1,2):
+            g.add(shapes.Ellipse(self.x+(s/3)*i,self.y+(s/3)*2, s/30, s/10,
+                    fillColor=self.strokeColor, strokeColor = self.strokeColor,
+                    strokeWidth=max(s/38.,self.strokeWidth)))
+
+        # calculate a pointslist for the mouth
+        # THIS IS A HACK! - don't use if there is a 'shapes.Arc'
+        centerx=self.x+(s/2)
+        centery=self.y+(s/2)
+        radius=s/3
+        yradius = radius
+        xradius = radius
+        startangledegrees=200
+        endangledegrees=340
+        degreedelta = 1
+        pointslist = []
+        a = pointslist.append
+        from math import sin, cos, pi
+        degreestoradians = pi/180.0
+        radiansdelta = degreedelta*degreestoradians
+        startangle = startangledegrees*degreestoradians
+        endangle = endangledegrees*degreestoradians
+        while endangle<startangle:
+              endangle = endangle+2*pi
+        angle = startangle
+        while angle<endangle:
+            x = centerx + cos(angle)*radius
+            y = centery + sin(angle)*yradius
+            a(x); a(y)
+            angle = angle+radiansdelta
+
+        # make the mouth
+        smile = shapes.PolyLine(pointslist,
+               fillColor = self.strokeColor,
+               strokeColor = self.strokeColor,
+               strokeWidth = max(s/38.,self.strokeWidth))
+        g.add(smile)
+
+        return g
+
+class StopSign(_Symbol):
+    """This draws a (British) stop sign.
+
+        possible attributes:
+        'x', 'y', 'size'
+
+        """
+    _attrMap = AttrMap(BASE=_Symbol,
+        stopColor = AttrMapValue(isColorOrNone,desc='color of the word stop'),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.strokeColor = colors.black
+        self.fillColor = colors.orangered
+        self.stopColor = colors.ghostwhite
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # stop-sign specific bits
+        athird=s/3
+
+        outerOctagon = shapes.Polygon(points=[self.x+athird, self.y,
+                                              self.x, self.y+athird,
+                                              self.x, self.y+(athird*2),
+                                              self.x+athird, self.y+s,
+                                              self.x+(athird*2), self.y+s,
+                                              self.x+s, self.y+(athird*2),
+                                              self.x+s, self.y+athird,
+                                              self.x+(athird*2), self.y],
+                                      strokeColor = self.strokeColor,
+                                      fillColor = None,
+                                      strokeWidth=1)
+        g.add(outerOctagon)
+
+        innerOctagon = shapes.Polygon(points=[self.x+athird+(s/75), self.y+(s/75),
+                                              self.x+(s/75), self.y+athird+(s/75),
+                                              self.x+(s/75), self.y+(athird*2)-(s/75),
+                                              self.x+athird+(s/75), self.y+s-(s/75),
+                                              self.x+(athird*2)-(s/75), (self.y+s)-(s/75),
+                                              (self.x+s)-(s/75), self.y+(athird*2)-(s/75),
+                                              (self.x+s)-(s/75), self.y+athird+(s/75),
+                                              self.x+(athird*2)-(s/75), self.y+(s/75)],
+                                      strokeColor = None,
+                                      fillColor = self.fillColor,
+                                      strokeWidth=0)
+        g.add(innerOctagon)
+
+        if self.stopColor:
+            g.add(shapes.String(self.x+(s*0.5),self.y+(s*0.4),
+                            'STOP', fillColor=self.stopColor, textAnchor='middle',
+                            fontSize=s/3, fontName="Helvetica-Bold"))
+
+        return g
+
+
+class NoEntry(_Symbol):
+    """This draws a (British) No Entry sign - a red circle with a white line on it.
+
+        possible attributes:
+        'x', 'y', 'size'
+
+        """
+
+    _attrMap = AttrMap(BASE=_Symbol,
+        innerBarColor = AttrMapValue(isColorOrNone,desc='color of the inner bar'),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.strokeColor = colors.black
+        self.fillColor = colors.orangered
+        self.innerBarColor = colors.ghostwhite
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # no-entry-sign specific bits
+        if self.strokeColor:
+            g.add(shapes.Circle(cx = (self.x+(s/2)), cy = (self.y+(s/2)), r = s/2, fillColor = None, strokeColor = self.strokeColor, strokeWidth=1))
+
+        if self.fillColor:
+            g.add(shapes.Circle(cx = (self.x+(s/2)), cy =(self.y+(s/2)), r = ((s/2)-(s/50)), fillColor = self.fillColor, strokeColor = None, strokeWidth=0))
+
+        innerBarColor = self.innerBarColor
+        if innerBarColor:
+            g.add(shapes.Rect(self.x+(s*0.1), self.y+(s*0.4), width=s*0.8, height=s*0.2, fillColor = innerBarColor, strokeColor = innerBarColor, strokeLineCap = 1, strokeWidth = 0))
+        return g
+
+class NotAllowed(_Symbol):
+    """This draws a 'forbidden' roundel (as used in the no-smoking sign).
+
+        possible attributes:
+        'x', 'y', 'size'
+
+        """
+
+    _attrMap = AttrMap(BASE=_Symbol,
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.strokeColor = colors.red
+        self.fillColor = colors.white
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+        strokeColor = self.strokeColor
+
+        # not=allowed specific bits
+        outerCircle = shapes.Circle(cx = (self.x+(s/2)), cy = (self.y+(s/2)), r = (s/2)-(s/10), fillColor = self.fillColor, strokeColor = strokeColor, strokeWidth=s/10.)
+        g.add(outerCircle)
+
+        centerx=self.x+s
+        centery=self.y+(s/2)-(s/6)
+        radius=s-(s/6)
+        yradius = radius/2
+        xradius = radius/2
+        startangledegrees=100
+        endangledegrees=-80
+        degreedelta = 90
+        pointslist = []
+        a = pointslist.append
+        from math import sin, cos, pi
+        degreestoradians = pi/180.0
+        radiansdelta = degreedelta*degreestoradians
+        startangle = startangledegrees*degreestoradians
+        endangle = endangledegrees*degreestoradians
+        while endangle<startangle:
+            endangle = endangle+2*pi
+        angle = startangle
+        while angle<endangle:
+            x = centerx + cos(angle)*radius
+            y = centery + sin(angle)*yradius
+            a(x); a(y)
+            angle = angle+radiansdelta
+        crossbar = shapes.PolyLine(pointslist, fillColor = strokeColor, strokeColor = strokeColor, strokeWidth = s/10.)
+        g.add(crossbar)
+        return g
+
+
+class NoSmoking(NotAllowed):
+    """This draws a no-smoking sign.
+
+        possible attributes:
+        'x', 'y', 'size'
+
+        """
+
+    def __init__(self):
+        NotAllowed.__init__(self)
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = NotAllowed.draw(self)
+
+        # no-smoking-sign specific bits
+        newx = self.x+(s/2)-(s/3.5)
+        newy = self.y+(s/2)-(s/32)
+        cigarrette1 = shapes.Rect(x = newx, y = newy, width = (s/2), height =(s/16),
+                fillColor = colors.ghostwhite, strokeColor = colors.gray, strokeWidth=0)
+        newx=newx+(s/2)+(s/64)
+        g.insert(-1,cigarrette1)
+
+        cigarrette2 = shapes.Rect(x = newx, y = newy, width = (s/80), height =(s/16),
+                fillColor = colors.orangered, strokeColor = None, strokeWidth=0)
+        newx= newx+(s/35)
+        g.insert(-1,cigarrette2)
+
+        cigarrette3 = shapes.Rect(x = newx, y = newy, width = (s/80), height =(s/16),
+                fillColor = colors.orangered, strokeColor = None, strokeWidth=0)
+        newx= newx+(s/35)
+        g.insert(-1,cigarrette3)
+
+        cigarrette4 = shapes.Rect(x = newx, y = newy, width = (s/80), height =(s/16),
+                fillColor = colors.orangered, strokeColor = None, strokeWidth=0)
+        newx= newx+(s/35)
+        g.insert(-1,cigarrette4)
+
+        return g
+
+
+class DangerSign(_Symbol):
+    """This draws a 'danger' sign: a yellow box with a black exclamation point.
+
+        possible attributes:
+        'x', 'y', 'size', 'strokeColor', 'fillColor', 'strokeWidth'
+
+        """
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.strokeColor = colors.black
+        self.fillColor = colors.gold
+        self.strokeWidth = self.size*0.125
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+        ew = self.strokeWidth
+        ae = s*0.125            #(ae = 'an eighth')
+
+
+        # danger sign specific bits
+
+        ew = self.strokeWidth
+        ae = s*0.125            #(ae = 'an eighth')
+
+        outerTriangle = shapes.Polygon(points = [
+            self.x, self.y,
+            self.x+s, self.y,
+            self.x+(s/2),self.y+s],
+               fillColor = None,
+               strokeColor = self.strokeColor,
+               strokeWidth=0)
+        g.add(outerTriangle)
+
+        innerTriangle = shapes.Polygon(points = [
+            self.x+(s/50), self.y+(s/75),
+            (self.x+s)-(s/50), self.y+(s/75),
+            self.x+(s/2),(self.y+s)-(s/50)],
+               fillColor = self.fillColor,
+               strokeColor = None,
+               strokeWidth=0)
+        g.add(innerTriangle)
+
+        exmark = shapes.Polygon(points=[
+            ((self.x+s/2)-ew/2), self.y+ae*2.5,
+            ((self.x+s/2)+ew/2), self.y+ae*2.5,
+            ((self.x+s/2)+((ew/2))+(ew/6)), self.y+ae*5.5,
+            ((self.x+s/2)-((ew/2))-(ew/6)), self.y+ae*5.5],
+               fillColor = self.strokeColor,
+               strokeColor = None)
+        g.add(exmark)
+
+        exdot = shapes.Polygon(points=[
+            ((self.x+s/2)-ew/2), self.y+ae,
+            ((self.x+s/2)+ew/2), self.y+ae,
+            ((self.x+s/2)+ew/2), self.y+ae*2,
+            ((self.x+s/2)-ew/2), self.y+ae*2],
+               fillColor = self.strokeColor,
+               strokeColor = None)
+        g.add(exdot)
+
+        return g
+
+
+class YesNo(_Symbol):
+    """This widget draw a tickbox or crossbox depending on 'testValue'.
+
+        If this widget is supplied with a 'True' or 1 as a value for
+        testValue, it will use the tickbox widget. Otherwise, it will
+        produce a crossbox.
+
+        possible attributes:
+        'x', 'y', 'size', 'tickcolor', 'crosscolor', 'testValue'
+
+"""
+
+    _attrMap = AttrMap(BASE=_Symbol,
+        tickcolor = AttrMapValue(isColor),
+        crosscolor = AttrMapValue(isColor),
+        testValue = AttrMapValue(isBoolean),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.tickcolor = colors.green
+        self.crosscolor = colors.red
+        self.testValue = 1
+
+    def draw(self):
+        if self.testValue:
+            yn=Tickbox()
+            yn.tickColor=self.tickcolor
+        else:
+            yn=Crossbox()
+            yn.crossColor=self.crosscolor
+        yn.x=self.x
+        yn.y=self.y
+        yn.size=self.size
+        yn.draw()
+        return yn
+
+
+    def demo(self):
+        D = shapes.Drawing(200, 100)
+        yn = YesNo()
+        yn.x = 15
+        yn.y = 25
+        yn.size = 70
+        yn.testValue = 0
+        yn.draw()
+        D.add(yn)
+        yn2 = YesNo()
+        yn2.x = 120
+        yn2.y = 25
+        yn2.size = 70
+        yn2.testValue = 1
+        yn2.draw()
+        D.add(yn2)
+        labelFontSize = 8
+        D.add(shapes.String(yn.x+(yn.size/2),(yn.y-(1.2*labelFontSize)),
+                            'testValue=0', fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+        D.add(shapes.String(yn2.x+(yn2.size/2),(yn2.y-(1.2*labelFontSize)),
+                            'testValue=1', fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+        labelFontSize = 10
+        D.add(shapes.String(yn.x+85,(yn.y-20),
+                            self.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+        return D
+
+class FloppyDisk(_Symbol):
+    """This widget draws an icon of a floppy disk.
+
+        possible attributes:
+        'x', 'y', 'size', 'diskcolor'
+
+        """
+
+    _attrMap = AttrMap(BASE=_Symbol,
+        diskColor = AttrMapValue(isColor),
+        )
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.diskColor = colors.black
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+
+        # floppy disk specific bits
+        diskBody = shapes.Rect(x=self.x, y=self.y+(s/100), width=s, height=s-(s/100),
+               fillColor = self.diskColor,
+               strokeColor = None,
+               strokeWidth=0)
+        g.add(diskBody)
+
+        label = shapes.Rect(x=self.x+(s*0.1), y=(self.y+s)-(s*0.5), width=s*0.8, height=s*0.48,
+               fillColor = colors.whitesmoke,
+               strokeColor = None,
+               strokeWidth=0)
+        g.add(label)
+
+        labelsplash = shapes.Rect(x=self.x+(s*0.1), y=(self.y+s)-(s*0.1), width=s*0.8, height=s*0.08,
+               fillColor = colors.royalblue,
+               strokeColor = None,
+               strokeWidth=0)
+        g.add(labelsplash)
+
+
+        line1 = shapes.Line(x1=self.x+(s*0.15), y1=self.y+(0.6*s), x2=self.x+(s*0.85), y2=self.y+(0.6*s),
+               fillColor = colors.black,
+               strokeColor = colors.black,
+               strokeWidth=0)
+        g.add(line1)
+
+        line2 = shapes.Line(x1=self.x+(s*0.15), y1=self.y+(0.7*s), x2=self.x+(s*0.85), y2=self.y+(0.7*s),
+               fillColor = colors.black,
+               strokeColor = colors.black,
+               strokeWidth=0)
+        g.add(line2)
+
+        line3 = shapes.Line(x1=self.x+(s*0.15), y1=self.y+(0.8*s), x2=self.x+(s*0.85), y2=self.y+(0.8*s),
+               fillColor = colors.black,
+               strokeColor = colors.black,
+               strokeWidth=0)
+        g.add(line3)
+
+        metalcover = shapes.Rect(x=self.x+(s*0.2), y=(self.y), width=s*0.5, height=s*0.35,
+               fillColor = colors.silver,
+               strokeColor = None,
+               strokeWidth=0)
+        g.add(metalcover)
+
+        coverslot = shapes.Rect(x=self.x+(s*0.28), y=(self.y)+(s*0.035), width=s*0.12, height=s*0.28,
+               fillColor = self.diskColor,
+               strokeColor = None,
+               strokeWidth=0)
+        g.add(coverslot)
+
+        return g
+
+class ArrowOne(_Symbol):
+    """This widget draws an arrow (style one).
+
+        possible attributes:
+        'x', 'y', 'size', 'fillColor'
+
+        """
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.fillColor = colors.red
+        self.strokeWidth = 0
+        self.strokeColor = None
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        x = self.x
+        y = self.y
+        s2 = s/2
+        s3 = s/3
+        s5 = s/5
+        g.add(shapes.Polygon(points = [
+                                        x,y+s3,
+                                        x,y+2*s3,
+                                        x+s2,y+2*s3,
+                                        x+s2,y+4*s5,
+                                        x+s,y+s2,
+                                        x+s2,y+s5,
+                                        x+s2,y+s3,
+                                       ],
+                fillColor = self.fillColor,
+                strokeColor = self.strokeColor,
+                strokeWidth = self.strokeWidth,
+                )
+            )
+        return g
+
+class ArrowTwo(ArrowOne):
+    """This widget draws an arrow (style two).
+
+        possible attributes:
+        'x', 'y', 'size', 'fillColor'
+
+        """
+
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.size = 100
+        self.fillColor = colors.blue
+        self.strokeWidth = 0
+        self.strokeColor = None
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+
+        # arrow specific bits
+        x = self.x
+        y = self.y
+        s2 = s/2
+        s3 = s/3
+        s5 = s/5
+        s24 = s/24
+
+        g.add(shapes.Polygon(
+            points = [
+                    x,y+11*s24,
+                    x,y+13*s24,
+                    x+18.75*s24, y+13*s24,
+                    x+2*s3, y+2*s3,
+                    x+s, y+s2,
+                    x+2*s3, y+s3,
+                    x+18.75*s24, y+11*s24,
+                    ],
+            fillColor = self.fillColor,
+            strokeColor = self.strokeColor,
+            strokeWidth = self.strokeWidth)
+            )
+
+        return g
+
+class CrossHair(_Symbol):
+    """This draws an equilateral triangle."""
+    _attrMap = AttrMap(BASE=_Symbol,
+            innerGap = AttrMapValue(EitherOr((isString,isNumberOrNone)),desc=' gap at centre as "x%" or points or None'),
+        )
+
+    def __init__(self):
+        self.x = self.y = self.dx = self.dy = 0
+        self.size = 10
+        self.fillColor = None
+        self.strokeColor = colors.black
+        self.strokeWidth = 0.5
+        self.innerGap = '20%'
+
+    def draw(self):
+        # general widget bits
+        s = float(self.size)  # abbreviate as we will use this a lot
+        g = shapes.Group()
+        ig = self.innerGap
+
+        x = self.x+self.dx
+        y = self.y+self.dy
+        hsize = 0.5*self.size
+        if not ig:
+            L = [(x-hsize,y,x+hsize,y), (x,y-hsize,x,y+hsize)]
+        else:
+            if isStr(ig):
+                ig = asUnicode(ig)
+                if ig.endswith(u'%'):
+                    gs = hsize*float(ig[:-1])/100.0
+                else:
+                    gs = float(ig)*0.5
+            else:
+                gs = ig*0.5
+            L = [(x-hsize,y,x-gs,y), (x+gs,y,x+hsize,y), (x,y-hsize,x,y-gs), (x,y+gs,x,y+hsize)]
+        P = shapes.Path(strokeWidth=self.strokeWidth,strokeColor=self.strokeColor)
+        for x0,y0,x1,y1 in L:
+            P.moveTo(x0,y0)
+            P.lineTo(x1,y1)
+        g.add(P)
+        return g
+
+
+def test():
+    """This function produces a pdf with examples of all the signs and symbols from this file.
+    """
+    labelFontSize = 10
+    D = shapes.Drawing(450,650)
+    cb = Crossbox()
+    cb.x = 20
+    cb.y = 530
+    D.add(cb)
+    D.add(shapes.String(cb.x+(cb.size/2),(cb.y-(1.2*labelFontSize)),
+                           cb.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                           fontSize=labelFontSize))
+
+    tb = Tickbox()
+    tb.x = 170
+    tb.y = 530
+    D.add(tb)
+    D.add(shapes.String(tb.x+(tb.size/2),(tb.y-(1.2*labelFontSize)),
+                            tb.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+
+    yn = YesNo()
+    yn.x = 320
+    yn.y = 530
+    D.add(yn)
+    tempstring = yn.__class__.__name__ + '*'
+    D.add(shapes.String(yn.x+(tb.size/2),(yn.y-(1.2*labelFontSize)),
+                            tempstring, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+    D.add(shapes.String(130,6,
+                            "(The 'YesNo' widget returns a tickbox if testvalue=1, and a crossbox if testvalue=0)", fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize*0.75))
+
+
+    ss = StopSign()
+    ss.x = 20
+    ss.y = 400
+    D.add(ss)
+    D.add(shapes.String(ss.x+(ss.size/2), ss.y-(1.2*labelFontSize),
+                            ss.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    ne = NoEntry()
+    ne.x = 170
+    ne.y = 400
+    D.add(ne)
+    D.add(shapes.String(ne.x+(ne.size/2),(ne.y-(1.2*labelFontSize)),
+                            ne.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    sf = SmileyFace()
+    sf.x = 320
+    sf.y = 400
+    D.add(sf)
+    D.add(shapes.String(sf.x+(sf.size/2),(sf.y-(1.2*labelFontSize)),
+                            sf.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    ds = DangerSign()
+    ds.x = 20
+    ds.y = 270
+    D.add(ds)
+    D.add(shapes.String(ds.x+(ds.size/2),(ds.y-(1.2*labelFontSize)),
+                            ds.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    na = NotAllowed()
+    na.x = 170
+    na.y = 270
+    D.add(na)
+    D.add(shapes.String(na.x+(na.size/2),(na.y-(1.2*labelFontSize)),
+                            na.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    ns = NoSmoking()
+    ns.x = 320
+    ns.y = 270
+    D.add(ns)
+    D.add(shapes.String(ns.x+(ns.size/2),(ns.y-(1.2*labelFontSize)),
+                            ns.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    a1 = ArrowOne()
+    a1.x = 20
+    a1.y = 140
+    D.add(a1)
+    D.add(shapes.String(a1.x+(a1.size/2),(a1.y-(1.2*labelFontSize)),
+                            a1.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    a2 = ArrowTwo()
+    a2.x = 170
+    a2.y = 140
+    D.add(a2)
+    D.add(shapes.String(a2.x+(a2.size/2),(a2.y-(1.2*labelFontSize)),
+                            a2.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    fd = FloppyDisk()
+    fd.x = 320
+    fd.y = 140
+    D.add(fd)
+    D.add(shapes.String(fd.x+(fd.size/2),(fd.y-(1.2*labelFontSize)),
+                            fd.__class__.__name__, fillColor=colors.black, textAnchor='middle',
+                            fontSize=labelFontSize))
+
+    renderPDF.drawToFile(D, 'signsandsymbols.pdf', 'signsandsymbols.py')
+    print('wrote file: signsandsymbols.pdf')
+
+if __name__=='__main__':
+    test()

.venv/lib/python3.13/site-packages/reportlab/graphics/widgets/table.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python
+#Copyright ReportLab Europe Ltd. 2000-2017
+#see license.txt for license details
+#history https://hg.reportlab.com/hg-public/reportlab/log/tip/src/reportlab/graphics/widgets/table.py
+__version__='3.3.0'
+
+from reportlab.graphics.widgetbase import Widget
+from reportlab.graphics import shapes
+from reportlab.lib import colors
+from reportlab.lib.validators import *
+from reportlab.lib.attrmap import *
+
+from reportlab.graphics.shapes import Drawing
+
+class TableWidget(Widget):
+    """A two dimensions table of labels
+    """
+
+    _attrMap = AttrMap(
+        x = AttrMapValue(isNumber, desc="x position of left edge of table"),
+        y = AttrMapValue(isNumber, desc="y position of bottom edge of table"),
+        width = AttrMapValue(isNumber, desc="table width"),
+        height = AttrMapValue(isNumber, desc="table height"),
+        borderStrokeColor = AttrMapValue(isColorOrNone, desc="table border color"),
+        fillColor = AttrMapValue(isColorOrNone, desc="table fill color"),
+        borderStrokeWidth = AttrMapValue(isNumber, desc="border line width"),
+        horizontalDividerStrokeColor = AttrMapValue(isColorOrNone, desc="table inner horizontal lines color"),
+        verticalDividerStrokeColor = AttrMapValue(isColorOrNone, desc="table inner vertical lines color"),
+        horizontalDividerStrokeWidth = AttrMapValue(isNumber, desc="table inner horizontal lines width"),
+        verticalDividerStrokeWidth = AttrMapValue(isNumber, desc="table inner vertical lines width"),
+        dividerDashArray = AttrMapValue(isListOfNumbersOrNone, desc='Dash array for dividerLines.'),
+        data = AttrMapValue(None, desc="a list of list of strings to be displayed in the cells"),
+        boxAnchor = AttrMapValue(isBoxAnchor, desc="location of the table anchoring point"),
+        fontName = AttrMapValue(isString, desc="text font in the table"),
+        fontSize = AttrMapValue(isNumber, desc="font size of the table"),
+        fontColor = AttrMapValue(isColorOrNone, desc="font color"),
+        alignment = AttrMapValue(OneOf("left", "right"), desc="Alignment of text within cells"),
+        textAnchor = AttrMapValue(OneOf('start','middle','end','numeric'), desc="Alignment of text within cells"),
+    )
+
+    def __init__(self, x=10, y=10, **kw):
+
+        self.x = x
+        self.y = y
+        self.width = 200
+        self.height = 100
+        self.borderStrokeColor = colors.black
+        self.fillColor = None
+        self.borderStrokeWidth = 0.5
+        self.horizontalDividerStrokeColor = colors.black
+        self.verticalDividerStrokeColor = colors.black
+        self.horizontalDividerStrokeWidth = 0.5
+        self.verticalDividerStrokeWidth = 0.25
+        self.dividerDashArray = None
+        self.data = [['North','South','East','West'],[100,110,120,130],['A','B','C','D']] # list of rows each row is a list of columns
+        self.boxAnchor = 'nw'
+        #self.fontName = None
+        self.fontSize = 8
+        self.fontColor = colors.black
+        self.alignment = 'right'
+        self.textAnchor = 'start'
+
+
+        for k, v in kw.items():
+            if k in list(self.__class__._attrMap.keys()):
+                setattr(self, k, v)
+            else:
+                raise ValueError('invalid argument supplied for class %s'%self.__class__)
+
+    def demo(self):
+        """ returns a sample of this widget with data
+        """
+        d = Drawing(400, 200)
+        t = TableWidget()
+        d.add(t, name='table')
+        d.table.dividerDashArray = (1, 3, 2)
+        d.table.verticalDividerStrokeColor = None
+        d.table.borderStrokeWidth = 0
+        d.table.borderStrokeColor = colors.red
+        return d
+
+    def draw(self):
+        """ returns a group of shapes
+        """
+        g = shapes.Group()
+
+        #overall border and fill
+        if self.borderStrokeColor or self.fillColor: # adds border and filling color
+            rect = shapes.Rect(self.x, self.y, self.width, self.height)
+            rect.fillColor = self.fillColor
+            rect.strokeColor = self.borderStrokeColor
+            rect.strokeWidth = self.borderStrokeWidth
+            g.add(rect)
+
+        #special case - for an empty table we want to avoid divide-by-zero
+        data = self.preProcessData(self.data)
+        rows = len(self.data)
+        cols = len(self.data[0])
+        #print "(rows,cols)=(%s, %s)"%(rows,cols)
+        row_step = self.height / float(rows)
+        col_step = self.width / float(cols)
+        #print "(row_step,col_step)=(%s, %s)"%(row_step,col_step)
+        # draw the grid
+        if self.horizontalDividerStrokeColor:
+            for i in range(rows): # make horizontal lines
+                x1 = self.x
+                x2 = self.x + self.width
+                y = self.y + row_step*i
+                #print 'line (%s, %s), (%s, %s)'%(x1, y, x2, y)
+                line = shapes.Line(x1, y, x2, y)
+                line.strokeDashArray = self.dividerDashArray
+                line.strokeWidth = self.horizontalDividerStrokeWidth
+                line.strokeColor = self.horizontalDividerStrokeColor
+                g.add(line)
+        if self.verticalDividerStrokeColor:
+            for i in range(cols): # make vertical lines
+                x = self.x+col_step*i
+                y1 = self.y
+                y2 = self.y + self.height
+                #print 'line (%s, %s), (%s, %s)'%(x, y1, x, y2)
+                line = shapes.Line(x, y1, x, y2)
+                line.strokeDashArray = self.dividerDashArray
+                line.strokeWidth = self.verticalDividerStrokeWidth
+                line.strokeColor = self.verticalDividerStrokeColor
+                g.add(line)
+
+        # since we plot data from down up, we reverse the list
+        self.data.reverse()
+        for (j, row) in enumerate(self.data):
+            y = self.y + j*row_step + 0.5*row_step - 0.5 * self.fontSize
+            for (i, datum) in enumerate(row):
+                if datum:
+                    x = self.x + i*col_step + 0.5*col_step
+                    s = shapes.String(x, y, str(datum), textAnchor=self.textAnchor)
+                    s.fontName = self.fontName
+                    s.fontSize = self.fontSize
+                    s.fillColor = self.fontColor
+                    g.add(s)
+        return g
+
+    def preProcessData(self, data):
+        """preprocess and return a new array with at least one row
+        and column (use a None) if needed, and all rows the same
+        length (adding Nones if needed)
+
+        """
+        if not data:
+            return [[None]]
+        #make all rows have similar number of cells, append None when needed
+        max_row = max( [len(x) for x in data] )
+        for rowNo, row in enumerate(data):
+            if len(row) < max_row:
+                row.extend([None]*(max_row-len(row)))
+        return data
+
+#test
+if __name__ == '__main__':
+    d = TableWidget().demo()
+    import os
+    d.save(formats=['pdf'],outDir=os.getcwd(),fnRoot=None)

.venv/lib/python3.13/site-packages/urllib3/contrib/emscripten/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import urllib3.connection
+
+from ...connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from .connection import EmscriptenHTTPConnection, EmscriptenHTTPSConnection
+
+
+def inject_into_urllib3() -> None:
+    # override connection classes to use emscripten specific classes
+    # n.b. mypy complains about the overriding of classes below
+    # if it isn't ignored
+    HTTPConnectionPool.ConnectionCls = EmscriptenHTTPConnection
+    HTTPSConnectionPool.ConnectionCls = EmscriptenHTTPSConnection
+    urllib3.connection.HTTPConnection = EmscriptenHTTPConnection  # type: ignore[misc,assignment]
+    urllib3.connection.HTTPSConnection = EmscriptenHTTPSConnection  # type: ignore[misc,assignment]
+    urllib3.connection.VerifiedHTTPSConnection = EmscriptenHTTPSConnection  # type: ignore[assignment]