python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/recipes/traits.py

@@ -0,0 +1,157 @@
+""" Shim to give us a uniform way of importing traits (and replacing them if needed in the future)"""
+from __future__ import absolute_import
+import numpy as np
+
+import logging
+logger = logging.getLogger(__name__)
+
+try:
+    from enthought.traits.api import *
+except ImportError:
+    from traits.api import *
+
+# definitions below have been adapted based on https://docs.enthought.com/traits-futures/0.2/_modules/traits/trait_types.html
+# these Dict have been deprecated for a while and need to be defined here for newer traits.api modules
+# FIXME - change usage within code and remove aliases
+DictStrAny = Dict(str, Any)
+DictStrStr = Dict(str, str)
+DictStrList = Dict(str, list)
+DictStrFloat = Dict(str, float)
+DictStrBool = Dict(str, bool)
+
+# -- List Traits ------- same as dict traits; we define only a subset of all possible List traits here
+# FIXME - change usage within code and remove aliases
+ListInt = List(int)
+ListFloat = List(float)
+ListStr = List(str)
+ListUnicode = List(str)
+ListComplex = List(complex)
+ListBool = List(bool)
+
+#Monkey-patch traits so that editors need enter / focus change to update by default
+from traits import trait_types
+trait_types.TraitType.auto_set = False
+trait_types.TraitType.enter_set = True
+
+class Input(CStr):
+    fast_validate = None
+    
+    def validate(self, object, name, value):
+        value = CStr.validate(self, object, name, value)
+
+        if getattr(object, '_initial_set', False):
+            # defer validation when performed in constructor to avoid detection of spurious circular references with default values (see issue #695)
+            
+            # make sure we're not assigning to an output of this module
+            mod_outputs = getattr(object, 'outputs', [])
+            if value in mod_outputs:
+                # trying to assign input to output
+                raise TraitError('Assigning "%s" to input "%s" would result in a circular reference (value is in module outputs).' % (value, name))
+                
+            # make sure we are not assigning to any downstream outputs
+            recipe = getattr(object, '_parent', None)
+            if recipe is not None:
+                if value in recipe.downstream_outputs(list(object.outputs)):
+                    # trying to assign input to output
+                    raise TraitError('Assigning "%s" to input "%s" would result in a circular reference (value is in downstream outputs).' % (value, name))
+                
+        return value
+    
+# class InputList(ListStr):
+#     fast_validate=None
+#
+#     def validate(self, object, name, value):
+#         value = ListStr.validate(self, object, name, value)
+#
+#         if getattr(object, '_initial_set', False):
+#             # defer validation when performed in constructor to avoid detection of spurious circular references with default values (see issue #695)
+#
+#             for v in value:
+#                 # make sure we're not assigning to an output of this module
+#                 mod_outputs = getattr(object, 'outputs', [])
+#                 if v in mod_outputs:
+#                     # trying to assign input to output
+#                     raise TraitError(
+#                         'Assigning "%s" to input "%s" would result in a circular reference (value is in module outputs).' % (
+#                         v, name))
+#
+#                 # make sure we are not assigning to any downstream outputs
+#                 recipe = getattr(object, '_parent', None)
+#                 if recipe is not None:
+#                     if v in recipe.downstream_outputs(list(object.outputs)):
+#                         # trying to assign input to output
+#                         raise TraitError(
+#                             'Assigning "%s" to input "%s" would result in a circular reference (value is in downstream outputs).' % (
+#                             v, name))
+#
+#         return value
+#
+    
+        
+
+class Output(CStr):
+    fast_validate = None
+    
+    def validate(self, object, name, value):
+        value = CStr.validate(self, object, name, value)
+        
+        if getattr(object, '_initial_set', False):
+            # defer validation when performed in constructor to avoid detection of spurious circular references with default values (see issue #695)
+        
+            # make sure we're not assigning to an input of this module
+            mod_inputs = getattr(object, 'inputs', [])
+            if value in mod_inputs:
+                # trying to assign input to output
+                raise TraitError(
+                    'Assigning "%s" to output "%s" would result in a circular reference (value is in module inputs).' % (value, name))
+                
+            
+            # make sure we are not assigning to any downstream outputs
+            recipe = getattr(object, '_parent', None)
+            if recipe is not None:
+                if value in recipe.upstream_inputs(list(object.inputs)):
+                    # trying to assign input to output
+                    raise TraitError(
+                        'Assigning "%s" to output "%s" would result in a circular reference (value is in upstream inputs).' % (
+                        value, name))
+                
+        
+        return value
+
+class FileOrURI(File):
+    '''Custom trait for files that can either be on disk or on the cluster
+    
+    Used for calibration data such as PSFs and shiftmaps which are static across multiple invocations of a recipe.
+    
+    Disables validation to work around traitsUI issues
+    '''
+    
+    info_text = 'a local file name or pyme-cluster:// URI'
+    
+    def __init__(self, *args, **kwargs):
+        kwargs['exists'] = True # file must exist
+        File.__init__(self, *args, **kwargs)
+    
+    def validate(self, object, name, value):
+        # Traitsui hangs up if a file doesn't validate correctly and doesn't allow selecting a replacement - disable validation for now :(
+        # FIXME
+        return value
+
+class _IntFloat(BaseFloat):
+    # WARNING: This is a fudge used in skimage wrapping. It should not be used unless absolutely necessary and might dissappear if and when we 
+    # find a better replacement. Has a 'private' (leading underscore) name to discourage use.
+    # TODO - Can we inherit from Float instead to eliminate the `set()` method?
+    default_value = 0.0
+    info_text = 'Frankenstein to deal with automatic introspection'
+
+    def set(self, obj, name, value):
+        setattr(self, name, value)
+        self.set_value(obj, name, value)
+
+    def get(self, obj, name):
+        val = self.get_value(obj, name)
+        if val is None:
+            val = self.default_value
+        if val == np.round(val):
+            val = int(val)
+        return val

PYME/recipes/vertical_recipe_display.py

@@ -0,0 +1,373 @@
+from . import recipeLayout
+import wx
+import numpy as np
+from PYME.IO import tabular
+
+import logging
+logger = logging.getLogger(__name__)
+
+# class RecipeDisplayPanel(wx.ScrolledWindow):
+#     def __init__(self, *args, **kwargs):
+#         wx.ScrolledWindow.__init__(self, *args, **kwargs)
+
+class RecipeDisplayPanel(wx.Panel):
+    def __init__(self, *args, **kwargs):
+        wx.Panel.__init__(self, *args,**kwargs)
+        self.recipe = None
+
+        self.output_positions = {}
+        self.input_positions = {}
+        self.data_positions = {}
+        self.data_positions_in = {}
+
+        self.input_target_panes = {}
+        self.output_source_panes = {}
+        self.data_panes = {}
+        
+        self.orderd = []
+        self.x0s = {}
+        
+        self.cols = {}
+        self._pens = {}
+        
+        self.fp = None
+
+        self._traits_views = []
+
+        self._layout_valid = False
+        
+        #self.SetMinSize((200, 500))
+        
+        #self.SetScrollRate(0, 20)
+        #self.ShowScrollbars(wx.SHOW_SB_DEFAULT, wx.SHOW_SB_ALWAYS)
+        
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+        self.Bind(wx.EVT_IDLE, self.OnIdle)
+
+    def _col(self,node):
+        dark_mode = False
+        
+        try:
+            dark_mode = wx.SystemSettings.GetAppearance().IsDark()
+        except AttributeError:
+            # wx < 4.1 doesn't have GetAppearance
+            pass
+        
+        if dark_mode:
+            factor = 1.0
+        else:
+            factor = 0.7
+
+        import matplotlib.pyplot as plt
+        if not node in self.cols.keys():
+            self.cols[node] = factor*np.array(plt.cm.hsv(np.random.rand()))
+            #cols[node] = 0.7 * np.array(plt.cm.hsv((_col.n_col % len(data_nodes)) / float(len(data_nodes))))
+        #return self.cols[node]
+
+        c = self.cols[node]
+        if self.recipe.failed and not node in self.recipe.namespace.keys():
+            c = 0.2 * c + 0.8 * 0.5
+            return np.array([.9,.6,.6,1.])
+            
+        return c
+        
+    def SetRecipe(self, recipe):
+        self.recipe = recipe
+        self.recipe.recipe_changed.connect(self.invalidate_layout)
+        self.recipe.recipe_failed.connect(self.invalidate_layout)
+        self.invalidate_layout()
+        self.recipe.recipe_executed.connect(self._update_n_events)
+
+    def _refr(self, **kwargs):
+        #print 'p_'
+        #wx.CallLater(10, self.Refresh)
+        self.Layout()
+        #print self.GetSizer().GetSize()
+        #self.SetMinSize(self.GetSizer().GetSize())
+        self.GetParent().Layout()
+        self.GetParent().GetParent().Layout()
+        self.Refresh()
+
+    def _set_n_events(self, node, st):
+        node_col = tuple([int(v) for v in (255 * self._col(node)[:3])])
+
+        evts = ''
+        data = self.recipe.namespace.get(node, None)
+        if isinstance(data, tabular.TabularBase):
+            evts = ' [%d evts]' % len(data)
+                
+        st.SetLabelMarkup("<span foreground='#%02x%02x%02x'>%s%s</span>" % (node_col + (node,evts)))
+
+    def _update_n_events(self, *args, **kwargs):
+        for node, t in self.data_panes.items():
+            self._set_n_events(node, t[1])
+
+    def OnIdle(self, evt=None):
+        if not self._layout_valid:
+            self._layout_valid = True
+            self._layout()
+
+    def invalidate_layout(self, *args, **kwargs):
+        # avoid re-doing the layout multiple times
+        # flag as invalid and let OnIdle do the layout
+        self._layout_valid = False
+
+    def _layout(self, *args, **kwargs):
+        #print('RecipeView._layout')
+        #import traceback
+        #traceback.print_stack()
+
+        # dispose of any current traits views
+        for tv in self._traits_views:
+            tv.dispose()
+
+        self._traits_views.clear()
+
+        wx.CallAfter(self._layout2)
+        #self._layout2()
+        
+    def _layout2(self):
+        #print('RecipeView._layout2')
+        
+        if self.fp:
+            _popEventHandlers(self.fp, handler_type=wx.EvtHandler)
+            self.fp.elements = []
+            # Wrap this in a try block to prevent an error when using OutputModules
+            # TODO: Figure out why this is necessary.
+                       
+            try:
+                self.fp.DestroyChildren()
+            except:
+                logger.exception('error destroying fold panel children')
+                pass
+        self.fp = None
+        #print('destroyed fold panel children')
+        
+        self.DestroyChildren()
+        #print('destroyed children')
+        
+
+        from matplotlib import pyplot as plt
+        from .base import ModuleBase, OutputModule
+        import textwrap
+        
+        #from PYME.ui import autoFoldPanel as afp
+        import PYME.ui.manualFoldPanel as afp
+
+        dg = self.recipe.dependancyGraph()
+        rdg = self.recipe.reverseDependancyGraph()
+
+        self.ordered, self.x0s = recipeLayout.layout_vertical(dg, rdg)
+
+        x_vals = -.1 * (1 + np.arange(len(self.ordered)))
+
+
+        self.input_target_panes = {}
+        self.output_source_panes = {}
+        self.data_panes = {}
+        
+        #what data do we already have in the namespace?
+        self.input_datasources = list(self.recipe.namespace.keys())
+        
+        for node in self.ordered:
+            if isinstance(node, ModuleBase):
+                for op in node.outputs:
+                    try:
+                        #this is obviously not an input - remove from list of input data
+                        self.input_datasources.remove(op)
+                    except ValueError:
+                        pass
+
+        hsizer = wx.BoxSizer(wx.HORIZONTAL)
+        hsizer.AddSpacer(20)
+        
+        self.fp = afp.foldPanel(self)
+        hsizer.Add(self.fp, 1, wx.EXPAND, 0)
+
+        hsizer.AddSpacer(10)
+        
+        for N, node in enumerate(self.ordered):
+            if isinstance(node, ModuleBase):
+                #This is a module - plot a box
+                s = node.__class__.__name__
+                
+                item = afp.foldingPane(self.fp, -1, caption=s, pinned = False)
+                if getattr(node, '_has_buttons', False) or (getattr(node,'_get_actions', None) is not None):
+                    kind = 'panel'
+                else:
+                    kind = 'subpanel'
+                pan = node.edit_traits(parent=item, kind=kind, view='pipeline_view_min')
+                self._traits_views.append(pan)
+                pan.control.SetMinSize((150, -1))
+                item.AddNewElement(pan.control)
+                if getattr(node, '_last_error', None):
+                    # error on this node, turn background red
+                    # TODO - this is a rather hacky
+                    item.stCaption.style.update({'BACKGROUND_COLOUR_1': (220, 198, 198), #default AUI caption colours
+                                               'BACKGROUND_COLOUR_2': (255, 226, 226)})
+                self.fp.AddPane(item)
+                
+                #p = pan.control
+                #j += 1
+        
+                #draw input lines
+                inputs = list(node.inputs)
+                ip_xs = [self._data_output_pos(ip)[0] for ip in inputs]
+                ip_ys = np.linspace(0, 1, 2 * len(inputs) + 1)[1::2]
+                ip_ys = ip_ys[np.argsort(ip_xs)[::-1]]
+
+                for ip_y, ip in zip(ip_ys, inputs):
+                    self.input_target_panes[ip] = (item, ip_y)
+                    #self.input_positions[ip] = lambda : (self.fp.panes[j].Position[0], self.fp.panes[j].Position[1] + ip_y*self.fp.panes[j].GetSize()[1])
+                    #self.input_positions[ip] = lambda : _get_op(j)
+                #
+                # #draw the nodes outputs
+                outputs = list(node.outputs)[::-1]
+                if len(outputs) > 0:
+                    op_y = np.linspace(0, 1, 2 * len(outputs) + 1)[1::2]
+                    op_x = 5*np.arange(len(outputs))[::-1]
+
+                    for yp, xp, op in zip(op_y, op_x, outputs):
+                        self.output_source_panes[op] = (item, xp, yp)
+                        
+                        #self.output_positions[op] = lambda : (item.GetPosition()[0] + item.GetSize()[0] + 5 + xp, item.GetPosition()[1] + yp*item.GetSize()[1])
+        
+            else:
+                # we must be an input - route back to LHS
+                try:
+                    #only map back if we are going to be used.
+                    if True:#rdg.get(node, False):
+                        xi, yi = self._output_position(node)
+                        x_0 = x_vals[self.x0s[node]]
+                        #ax.plot([2, xi, xi, x_0], [yi, yi, y, y], '-', color=_col(node), lw=2)
+
+                        #print('Adding static text')
+                        item = afp.foldingPane(self.fp, -1, caption=None, pinned=True, folded=False, padding=0, style=0)
+                        st = wx.StaticText(item, -1, node)
+                        
+                        self._set_n_events(node, st)
+                            
+                        item.AddNewElement(st, foldable=False)
+                        self.fp.AddPane(item)
+                        
+                        self.data_panes[node] = (item, st)
+
+                        #self.data_positions[node] = lambda : (item.GetPosition()[0] + x_0, item.GetPosition()[1] + 0.5 * item.GetSize()[1])
+                        #self.data_positions_in[node] = lambda : (item.GetPosition()[0] + st.GetSize()[0], item.GetPosition()[1] + 0.5 * item.GetSize()[1])
+            
+        
+                except KeyError:
+                    #dangling input
+                    #print('dangling input')
+                    
+                    x_0 = x_vals[self.x0s[node]]
+
+                    item = afp.foldingPane(self.fp, -1, caption=None, pinned=True, folded=False, padding=0, style=0)
+                    st = wx.StaticText(item, -1, node)
+
+                    node_col = tuple([int(v) for v in (255 * self._col(node)[:3])])
+                    
+                    
+                    bg = ''
+                    evts = ''
+                    
+                    if node in self.input_datasources:
+                        bg = " background='#D0D0D0'"
+
+                    data = self.recipe.namespace.get(node, None)
+                    if isinstance(data, tabular.TabularBase):
+                        evts = ' [%d evts]' % len(data)
+                       
+                    st.SetLabelMarkup("<u><span foreground='#%02x%02x%02x' weight='bold'%s>%s%s</span></u>" % (node_col + (bg, node,evts)))
+                    item.AddNewElement(st, foldable=False)
+                    self.fp.AddPane(item)
+
+                    self.data_panes[node] = (item, st)
+                    #self.data_positions[node] = lambda : (item.GetPosition()[0] + x_0, item.GetPosition()[1] + 0.5 * item.GetSize()[1])
+                
+        
+        print('Input datasources: ',  self.input_datasources)
+        
+        self.fp.fold_signal.connect(self._refr)
+        self.SetSizerAndFit(hsizer)
+        self.Layout()
+        
+    def _input_position(self, key):
+        item, ip_y = self.input_target_panes[key]
+        xp, yp = item.Position
+        sx, sy = item.Size
+        
+        return xp, yp + ip_y*sy
+
+    def _output_position(self, key):
+        item, ip_x, ip_y = self.output_source_panes[key]
+        xp, yp = item.Position
+        sx, sy = item.Size
+    
+        return xp + sx + 5 + ip_x, yp + ip_y * sy
+    
+    def _data_input_pos(self, key):
+        item, st = self.data_panes[key]
+        xp, yp = item.Position
+        sx, sy = item.Size
+        
+        return xp + st.GetTextExtent(st.GetLabel())[0] + 3, yp + 0.5*sy
+
+    def _data_output_pos(self, key):
+        item, st = self.data_panes[key]
+        xp, yp = item.Position
+        sx, sy = item.Size
+    
+        return xp - 5*(1+self.x0s[key]), yp + 0.5 * sy
+        
+        
+    def OnPaint(self, dc):
+        #print 'p'
+        #if not self.IsShownOnScreen():
+        #    return
+        if self.fp is None:
+            return
+        
+
+        dc = wx.PaintDC(self)
+        #self.PrepareDC(dc)
+        #dc.BeginDrawing()
+
+        x_0 = self.fp.Position[0]
+        x_1 = x_0 + self.fp.Size[0]
+
+        dc.SetPen(wx.BLACK_PEN)
+        for nd in self.x0s.keys():
+            dc.SetPen(wx.Pen(wx.Colour(*((255*self._col(nd))[:3]).astype('i').tolist()), 2))
+            try:
+                x0, y0 = self._output_position(nd)
+                x1, y1 = self._data_input_pos(nd)
+
+                dc.DrawLines([(x_1, y0), (x0+x_0, y0), (x0+x_0, y1), (x1+x_0, y1)])
+            except KeyError:
+                pass
+
+            try:
+                x0, y0 = self._input_position(nd)
+                x1, y1 = self._data_output_pos(nd)
+
+                dc.DrawLines([(x_0, y0), (x1+x_0, y0), (x1+x_0, y1), (x_0, y1)])
+            except KeyError:
+                pass
+        
+        #dc.EndDrawing()
+
+def _popEventHandlers(ctrl, handler_type=wx.EvtHandler):
+    """Pop any event handlers that have been pushed on to a window and its
+    children.
+    """
+    # borrowed from traitsui.wx.toolkit
+
+    handler = ctrl.GetEventHandler()
+    while ctrl is not handler:
+        next_handler = handler.GetNextHandler()
+        if isinstance(handler, handler_type):
+            ctrl.PopEventHandler(True)
+        handler = next_handler
+    for child in ctrl.GetChildren():
+        _popEventHandlers(child, handler_type)

PYME/resources/__init__.py

@@ -0,0 +1,23 @@
+"""
+PYME.resources
+==============
+
+A storage area for non-code based resources.
+
+"""
+import os
+dirname = os.path.dirname(__file__)
+
+def getIconPath(name):
+	"""Returns the full path to the icon with the given name"""
+
+	return os.path.join(dirname, 'icons', name)
+
+def get_web_static_dir():
+	return os.path.join(dirname, 'web', 'static')
+
+def get_web_dir():
+	return os.path.join(dirname, 'web')
+
+def get_test_data_dir():
+	return os.path.join(dirname, 'test_datasets')

PYME/resources/config_template/distributor.yaml

@@ -0,0 +1,14 @@
+distributor:
+  http_endpoint: 0.0.0.0:1234
+  http_print_debug_logs: false
+  logic:
+    max_allowed_fails: 5
+    node_timeout: 10s
+    max_parallel_rate_requests: 10
+    rating_buffer_size: 50
+    rating_buffer_flush_interval: 1s
+    queue_stats_ttl: 24h0m0s
+    queue_stats_gc_interval: 2m0s
+    rate_request_timeout: 3s
+    http_client_timeout: 10s
+    default_num_want: 50

PYME/resources/config_template/nodeserver.yaml

@@ -0,0 +1,15 @@
+nodeserver:
+  http_endpoint: 0.0.0.0:1337
+  http_print_debug_logs: false
+  distributors:
+  - 10.150.7.1:1234
+  pyme_cluster_rater:
+    data_server_root_dir: /mnt/storage/pyme
+  logic:
+    gc_interval: 1m0s
+    gc_cutoff: 5m0s
+    announce_interval: 3s
+    hand_in_buffer_size: 50
+    hand_in_buffer_flush_interval: 3s
+    num_want_tasks: -1
+    get_tasks_long_polling_timeout: 10s

PYME/resources/icons/mesh.svg

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 20.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 300 300" style="enable-background:new 0 0 300 300;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:url(#SVGID_1_);stroke:#000000;stroke-width:7;stroke-miterlimit:10;}
+	.st1{fill:url(#SVGID_2_);stroke:#000000;stroke-width:7;stroke-miterlimit:10;}
+	.st2{fill:none;stroke:#000000;stroke-width:7;stroke-miterlimit:10;}
+</style>
+<g>
+	<radialGradient id="SVGID_1_" cx="150.6468" cy="146.0155" r="142.9088" gradientUnits="userSpaceOnUse">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="0.8099" style="stop-color:#ED1C24"/>
+		<stop  offset="1" style="stop-color:#780000"/>
+	</radialGradient>
+	<polygon class="st0" points="4.1,185.5 47.4,100.3 149.4,6.8 271.1,50.9 297.1,209.3 208,285.2 149.4,192.6 	"/>
+	<radialGradient id="SVGID_2_" cx="101.6654" cy="234.4909" r="0" gradientUnits="userSpaceOnUse">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="0.8099" style="stop-color:#ED1C24"/>
+		<stop  offset="1" style="stop-color:#780000"/>
+	</radialGradient>
+	<path class="st1" d="M101.7,234.5"/>
+	<line class="st2" x1="47.4" y1="100.3" x2="149.4" y2="192.6"/>
+	<line class="st2" x1="149.4" y1="6.8" x2="149.4" y2="192.6"/>
+	<line class="st2" x1="271.1" y1="50.9" x2="149.4" y2="192.6"/>
+	<line class="st2" x1="297.1" y1="209.3" x2="149.4" y2="192.6"/>
+</g>
+</svg>

PYME/resources/icons/points.svg

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 20.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 300 300" style="enable-background:new 0 0 300 300;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FF0000;stroke:#000000;stroke-width:2;}
+	.st1{fill:#00FFFF;stroke:#000000;stroke-width:2;}
+	.st2{fill:#FF00FF;stroke:#000000;stroke-width:2;}
+</style>
+<g>
+	<title>Layer 1</title>
+	<ellipse id="svg_6" class="st0" cx="84.5" cy="199.5" rx="49.5" ry="49.5"/>
+	<ellipse id="svg_7" class="st1" cx="168.5" cy="77.5" rx="49.5" ry="49.5"/>
+	<ellipse id="svg_8" class="st2" cx="197.8" cy="213.2" rx="47.8" ry="47.8"/>
+</g>
+</svg>