<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _arc_slice_context( cls, slice_value, total_values, label, color, stroke_color, radius=128, label_position=(256, 0), start_angle=- math.pi / 2, center_point=(128, 128), hole=0):
 """Create arc slice context to be rendered in svg. :param slice_value: The value the slice represent. :type slice_value: float :param total_values: The total value of one full circle arc. In other words, the value when of 100% representation. :type total_values: float :param label: The label for the slice. :type label: str :param color: The hexa-color of the slice. :type color: str :param stroke_color: The hexa-color of the stroke of the slice. :type stroke_color: str :param radius: The radius of the circle in this svg unit. :type radius: float :param label_position: The position of the legend label. :type label_position: (float, float) :param start_angle: The start angle of the slice in radian unit. :type start_angle: float :param center_point: The center point of the circle. :type center_point: (float, float) :param hole: The radius of inner hole circle :type hole: float :return: The dictionary of slice context for svg renderer or None if there is any issue :rtype: dict, None """

        try:
            step_angle = 1.0 * slice_value / total_values * 2 * math.pi
        except ZeroDivisionError:
            return None
        # move marker
        d = ''
        d += 'M{position_x:f},{position_y:f}'.format(
            position_x=radius * math.cos(start_angle) + center_point[0],
            position_y=radius * math.sin(start_angle) + center_point[1]
        )
        # outer arc, counterclockwise
        next_angle = start_angle + step_angle
        # arc flag depends on step angle size
        large_arc_flag = 1 if step_angle > math.pi else 0
        outer_arc_syntax = (
            'a{center_x:f},{center_y:f} '
            '{x_axis_rotation:d} '
            '{large_arc_flag:d} {sweep_direction_flag:d} '
            '{end_position_x:f},{end_position_y:f}')
        d += outer_arc_syntax.format(
            # center of donut
            center_x=radius,
            center_y=radius,
            # arc not skewed
            x_axis_rotation=0,
            # arc flag depends on step angle size
            large_arc_flag=large_arc_flag,
            # sweep counter clockwise, always
            sweep_direction_flag=1,
            end_position_x=(
                radius * (math.cos(next_angle) - math.cos(start_angle))),
            end_position_y=(
                radius * (math.sin(next_angle) - math.sin(start_angle)))
        )
        # if hole == 0 then only pie chart
        if not hole == 0:
            # line in
            inner_radius = radius - hole
            d += 'l{end_position_x:f},{end_position_y:f}'.format(
                end_position_x=(- inner_radius * math.cos(next_angle)),
                end_position_y=(- inner_radius * math.sin(next_angle))
            )

            # inner arc
            inner_arc_syntax = (
                'a{center_x:f},{center_y:f} '
                '{x_axis_rotation:d} '
                '{large_arc_flag:d} {sweep_direction_flag:d} '
                '{end_position_x:f},{end_position_y:f}')
            d += inner_arc_syntax.format(
                # center of donut
                center_x=hole,
                center_y=hole,
                # arc not skewed
                x_axis_rotation=0,
                # arc flag depends on step angle size
                large_arc_flag=large_arc_flag,
                # sweep clockwise, always
                sweep_direction_flag=0,
                end_position_x=(
                    hole * (math.cos(start_angle) - math.cos(next_angle))),
                end_position_y=(
                    hole * (math.sin(start_angle) - math.sin(next_angle)))
            )

        # close path
        d += 'Z'
        # calculate center of slice to put value text
        mean_angle = start_angle + step_angle / 2
        center_slice_radius = radius / 2
        if not hole == 0:
            # skew radius outwards, because inner circle is hollow
            center_slice_radius += inner_radius / 2
        # calculate center of slice, angle increments clockwise
        # from 90 degree position
        center_slice_x = (
            center_point[0]
            + center_slice_radius
            * math.cos(mean_angle))
        center_slice_y = (
            center_point[1]
            + center_slice_radius
            * math.sin(mean_angle))
        show_label = True
        # if percentage is less than 10%, do not show label
        if 1.0 * slice_value / total_values < 0.1:
            show_label = False

        # label should be a string, since it will be used to define a
        # css-class
        if not label:
            label = ''

        one_slice = {
            'center': (center_slice_x, center_slice_y),
            'path': d,
            'fill': color,
            'show_label': show_label,
            'label_position': label_position,
            'value': slice_value,
            'percentage': slice_value * 100.0 / total_values,
            'label': label,
            'stroke': stroke_color,
            'stroke_opacity': 1
        }
        return one_slice