diff options
Diffstat (limited to 'venv/lib/python3.8/site-packages/plotly/shapeannotation.py')
| -rw-r--r-- | venv/lib/python3.8/site-packages/plotly/shapeannotation.py | 246 |
1 files changed, 246 insertions, 0 deletions
diff --git a/venv/lib/python3.8/site-packages/plotly/shapeannotation.py b/venv/lib/python3.8/site-packages/plotly/shapeannotation.py new file mode 100644 index 0000000..a2323ed --- /dev/null +++ b/venv/lib/python3.8/site-packages/plotly/shapeannotation.py @@ -0,0 +1,246 @@ +# some functions defined here to avoid numpy import + + +def _mean(x): + if len(x) == 0: + raise ValueError("x must have positive length") + return float(sum(x)) / len(x) + + +def _argmin(x): + return sorted(enumerate(x), key=lambda t: t[1])[0][0] + + +def _argmax(x): + return sorted(enumerate(x), key=lambda t: t[1], reverse=True)[0][0] + + +def _df_anno(xanchor, yanchor, x, y): + """Default annotation parameters""" + return dict(xanchor=xanchor, yanchor=yanchor, x=x, y=y, showarrow=False) + + +def _add_inside_to_position(pos): + if not ("inside" in pos or "outside" in pos): + pos.add("inside") + return pos + + +def _prepare_position(position, prepend_inside=False): + if position is None: + position = "top right" + pos_str = position + position = set(position.split(" ")) + if prepend_inside: + position = _add_inside_to_position(position) + return position, pos_str + + +def annotation_params_for_line(shape_type, shape_args, position): + # all x0, x1, y0, y1 are used to place the annotation, that way it could + # work with a slanted line + # even with a slanted line, there are the horizontal and vertical + # conventions of placing a shape + x0 = shape_args["x0"] + x1 = shape_args["x1"] + y0 = shape_args["y0"] + y1 = shape_args["y1"] + X = [x0, x1] + Y = [y0, y1] + R = "right" + T = "top" + L = "left" + C = "center" + B = "bottom" + M = "middle" + aY = max(Y) + iY = min(Y) + eY = _mean(Y) + aaY = _argmax(Y) + aiY = _argmin(Y) + aX = max(X) + iX = min(X) + eX = _mean(X) + aaX = _argmax(X) + aiX = _argmin(X) + position, pos_str = _prepare_position(position) + if shape_type == "vline": + if position == set(["top", "left"]): + return _df_anno(R, T, X[aaY], aY) + if position == set(["top", "right"]): + return _df_anno(L, T, X[aaY], aY) + if position == set(["top"]): + return _df_anno(C, B, X[aaY], aY) + if position == set(["bottom", "left"]): + return _df_anno(R, B, X[aiY], iY) + if position == set(["bottom", "right"]): + return _df_anno(L, B, X[aiY], iY) + if position == set(["bottom"]): + return _df_anno(C, T, X[aiY], iY) + if position == set(["left"]): + return _df_anno(R, M, eX, eY) + if position == set(["right"]): + return _df_anno(L, M, eX, eY) + elif shape_type == "hline": + if position == set(["top", "left"]): + return _df_anno(L, B, iX, Y[aiX]) + if position == set(["top", "right"]): + return _df_anno(R, B, aX, Y[aaX]) + if position == set(["top"]): + return _df_anno(C, B, eX, eY) + if position == set(["bottom", "left"]): + return _df_anno(L, T, iX, Y[aiX]) + if position == set(["bottom", "right"]): + return _df_anno(R, T, aX, Y[aaX]) + if position == set(["bottom"]): + return _df_anno(C, T, eX, eY) + if position == set(["left"]): + return _df_anno(R, M, iX, Y[aiX]) + if position == set(["right"]): + return _df_anno(L, M, aX, Y[aaX]) + raise ValueError('Invalid annotation position "%s"' % (pos_str,)) + + +def annotation_params_for_rect(shape_type, shape_args, position): + x0 = shape_args["x0"] + x1 = shape_args["x1"] + y0 = shape_args["y0"] + y1 = shape_args["y1"] + + position, pos_str = _prepare_position(position, prepend_inside=True) + if position == set(["inside", "top", "left"]): + return _df_anno("left", "top", min([x0, x1]), max([y0, y1])) + if position == set(["inside", "top", "right"]): + return _df_anno("right", "top", max([x0, x1]), max([y0, y1])) + if position == set(["inside", "top"]): + return _df_anno("center", "top", _mean([x0, x1]), max([y0, y1])) + if position == set(["inside", "bottom", "left"]): + return _df_anno("left", "bottom", min([x0, x1]), min([y0, y1])) + if position == set(["inside", "bottom", "right"]): + return _df_anno("right", "bottom", max([x0, x1]), min([y0, y1])) + if position == set(["inside", "bottom"]): + return _df_anno("center", "bottom", _mean([x0, x1]), min([y0, y1])) + if position == set(["inside", "left"]): + return _df_anno("left", "middle", min([x0, x1]), _mean([y0, y1])) + if position == set(["inside", "right"]): + return _df_anno("right", "middle", max([x0, x1]), _mean([y0, y1])) + if position == set(["inside"]): + # TODO: Do we want this? + return _df_anno("center", "middle", _mean([x0, x1]), _mean([y0, y1])) + if position == set(["outside", "top", "left"]): + return _df_anno( + "right" if shape_type == "vrect" else "left", + "bottom" if shape_type == "hrect" else "top", + min([x0, x1]), + max([y0, y1]), + ) + if position == set(["outside", "top", "right"]): + return _df_anno( + "left" if shape_type == "vrect" else "right", + "bottom" if shape_type == "hrect" else "top", + max([x0, x1]), + max([y0, y1]), + ) + if position == set(["outside", "top"]): + return _df_anno("center", "bottom", _mean([x0, x1]), max([y0, y1])) + if position == set(["outside", "bottom", "left"]): + return _df_anno( + "right" if shape_type == "vrect" else "left", + "top" if shape_type == "hrect" else "bottom", + min([x0, x1]), + min([y0, y1]), + ) + if position == set(["outside", "bottom", "right"]): + return _df_anno( + "left" if shape_type == "vrect" else "right", + "top" if shape_type == "hrect" else "bottom", + max([x0, x1]), + min([y0, y1]), + ) + if position == set(["outside", "bottom"]): + return _df_anno("center", "top", _mean([x0, x1]), min([y0, y1])) + if position == set(["outside", "left"]): + return _df_anno("right", "middle", min([x0, x1]), _mean([y0, y1])) + if position == set(["outside", "right"]): + return _df_anno("left", "middle", max([x0, x1]), _mean([y0, y1])) + raise ValueError("Invalid annotation position %s" % (pos_str,)) + + +def axis_spanning_shape_annotation(annotation, shape_type, shape_args, kwargs): + """ + annotation: a go.layout.Annotation object, a dict describing an annotation, or None + shape_type: one of 'vline', 'hline', 'vrect', 'hrect' and determines how the + x, y, xanchor, and yanchor values are set. + shape_args: the parameters used to draw the shape, which are used to place the annotation + kwargs: a dictionary that was the kwargs of a + _process_multiple_axis_spanning_shapes spanning shapes call. Items in this + dict whose keys start with 'annotation_' will be extracted and the keys with + the 'annotation_' part stripped off will be used to assign properties of the + new annotation. + + Property precedence: + The annotation's x, y, xanchor, and yanchor properties are set based on the + shape_type argument. Each property already specified in the annotation or + through kwargs will be left as is (not replaced by the value computed using + shape_type). Note that the xref and yref properties will in general get + overwritten if the result of this function is passed to an add_annotation + called with the row and col parameters specified. + + Returns an annotation populated with fields based on the + annotation_position, annotation_ prefixed kwargs or the original annotation + passed in to this function. + """ + # set properties based on annotation_ prefixed kwargs + prefix = "annotation_" + len_prefix = len(prefix) + annotation_keys = list(filter(lambda k: k.startswith(prefix), kwargs.keys())) + # If no annotation or annotation-key is specified, return None as we don't + # want an annotation in this case + if annotation is None and len(annotation_keys) == 0: + return None + # TODO: Would it be better if annotation were initialized to an instance of + # go.layout.Annotation ? + if annotation is None: + annotation = dict() + for k in annotation_keys: + if k == "annotation_position": + # don't set so that Annotation constructor doesn't complain + continue + subk = k[len_prefix:] + annotation[subk] = kwargs[k] + # set x, y, xanchor, yanchor based on shape_type and position + annotation_position = None + if "annotation_position" in kwargs.keys(): + annotation_position = kwargs["annotation_position"] + if shape_type.endswith("line"): + shape_dict = annotation_params_for_line( + shape_type, shape_args, annotation_position + ) + elif shape_type.endswith("rect"): + shape_dict = annotation_params_for_rect( + shape_type, shape_args, annotation_position + ) + for k in shape_dict.keys(): + # only set property derived from annotation_position if it hasn't already been set + # see above: this would be better as a go.layout.Annotation then the key + # would be checked for validity here (otherwise it is checked later, + # which I guess is ok too) + if (k not in annotation) or (annotation[k] is None): + annotation[k] = shape_dict[k] + return annotation + + +def split_dict_by_key_prefix(d, prefix): + """ + Returns two dictionaries, one containing all the items whose keys do not + start with a prefix and another containing all the items whose keys do start + with the prefix. Note that the prefix is not removed from the keys. + """ + no_prefix = dict() + with_prefix = dict() + for k in d.keys(): + if k.startswith(prefix): + with_prefix[k] = d[k] + else: + no_prefix[k] = d[k] + return (no_prefix, with_prefix) |