Ignore:
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/orngRegistry.py

    r10865 r10879  
    102102        except ImportError, err: 
    103103            print "While loading, importing widgets '%s' failed: %s" % (entry_point.name, err) 
     104        except pkg_resources.DistributionNotFound, err: 
     105            print "Loading add-on '%s' failed because of a missing dependency: '%s'" % (entry_point.name, err) 
     106        except Exception, err: 
     107            print "An exception occurred during the loading of '%s':\n%r" %(entry_point.name, err) 
    104108 
    105109    categories = {}      
  • Orange/OrangeWidgets/OWHist.py

    r9671 r10874  
    1515        self.parent = parent 
    1616        self.type = type 
    17          
     17 
    1818        self.enableXaxis(1) 
    1919        self.enableYLaxis(1) 
    20          
     20 
    2121        self.xData = [] 
    2222        self.yData = [] 
    23          
     23 
    2424        self.minValue = 0 
    2525        self.maxValue = 0 
     
    2828        self.lowerBoundaryKey = None 
    2929        self.upperBoundaryKey = None 
    30          
     30 
    3131        self.enableGridXB(False) 
    3232        self.enableGridYL(False) 
     
    3636 
    3737    def setValues(self, values): 
     38        if len(values) <= 0: 
     39            self.yData, self.xData = [], [] 
     40            self.minx = -1 
     41            self.maxx = -1 
     42            self.miny = -1 
     43            self.maxy = -1 
     44            self.minValue = -1 
     45            self.maxValue = -1 
     46            self.updateData() 
     47            self.replot() 
     48            return 
     49 
    3850        nBins = 100 
    3951        if len(values) < 100: 
     
    4355        #if numpy version greater than 1.3 
    4456        if len(self.xData) == len(self.yData) + 1: 
    45             self.xData = [(self.xData[i] + self.xData[i+1]) / 2. for i in range(len(self.xData) - 1)] 
    46          
    47         self.minx = min(self.xData)  
     57            self.xData = [(self.xData[i] + self.xData[i + 1]) / 2. for i in range(len(self.xData) - 1)] 
     58 
     59        self.minx = min(self.xData) 
    4860        self.maxx = max(self.xData) 
    4961        self.miny = min(self.yData) 
    5062        self.maxy = max(self.yData) 
    51          
     63 
    5264        self.minValue = min(values) 
    5365        self.maxValue = max(values) 
    54          
     66 
    5567        self.updateData() 
    5668        self.replot() 
    57          
     69 
    5870    def setBoundary(self, lower, upper): 
    5971        if len(self.xData) == 0 and len(self.yData) == 0: 
    6072            return 
    61          
     73 
    6274        self.lowerBoundary = lower 
    6375        self.upperBoundary = upper 
    6476        maxy = max(self.yData) 
    65          
     77 
    6678        self.lowerBoundaryKey.setData([float(self.lowerBoundary), float(self.lowerBoundary)], [0., float(maxy)]) 
    6779        self.upperBoundaryKey.setData([float(self.upperBoundary), float(self.upperBoundary)], [0., float(maxy)]) 
    6880#        self.updateData() 
    6981        self.replot() 
    70              
     82 
    7183    def updateData(self): 
    72         self.removeDrawingCurves(removeLegendItems = 0, removeMarkers=1) 
    73                      
    74         self.key = self.addCurve("histogramCurve", Qt.blue, Qt.blue, 6, symbol = QwtSymbol.NoSymbol, style = QwtPlotCurve.Steps, xData = self.xData, yData = self.yData) 
    75          
     84        self.removeDrawingCurves(removeLegendItems=0, removeMarkers=1) 
     85 
     86        self.key = self.addCurve("histogramCurve", Qt.blue, Qt.blue, 6, symbol=QwtSymbol.NoSymbol, style=QwtPlotCurve.Steps, xData=self.xData, yData=self.yData) 
     87 
    7688        maxy = self.maxy 
    77         self.lowerBoundaryKey = self.addCurve("lowerBoundaryCurve", Qt.red, Qt.red, 6, symbol = QwtSymbol.NoSymbol, style = QwtPlotCurve.Lines, xData = [float(self.lowerBoundary), float(self.lowerBoundary)], yData = [0., float(maxy)]) 
    78         self.upperBoundaryKey = self.addCurve("upperBoundaryCurve", Qt.red, Qt.red, 6, symbol = QwtSymbol.NoSymbol, style = QwtPlotCurve.Lines, xData = [float(self.upperBoundary), float(self.upperBoundary)], yData = [0., float(maxy)]) 
     89        self.lowerBoundaryKey = self.addCurve("lowerBoundaryCurve", Qt.red, Qt.red, 6, symbol=QwtSymbol.NoSymbol, style=QwtPlotCurve.Lines, xData=[float(self.lowerBoundary), float(self.lowerBoundary)], yData=[0., float(maxy)]) 
     90        self.upperBoundaryKey = self.addCurve("upperBoundaryCurve", Qt.red, Qt.red, 6, symbol=QwtSymbol.NoSymbol, style=QwtPlotCurve.Lines, xData=[float(self.upperBoundary), float(self.upperBoundary)], yData=[0., float(maxy)]) 
    7991 
    8092        minx = self.minx 
     
    89101    def updateData(self): 
    90102        OWHist.updateData(self) 
    91         self.upperTailShadeKey = self.addCurve("upperTailShade", Qt.blue, Qt.blue, 6, symbol = QwtSymbol.NoSymbol, style = QwtPlotCurve.Steps) 
    92         self.lowerTailShadeKey = self.addCurve("lowerTailShade", Qt.blue, Qt.blue, 6, symbol = QwtSymbol.NoSymbol, style = QwtPlotCurve.Steps) 
    93         self.middleShadeKey = self.addCurve("middleShade", Qt.blue, Qt.blue, 6, symbol = QwtSymbol.NoSymbol, style = QwtPlotCurve.Steps) 
     103        self.upperTailShadeKey = self.addCurve("upperTailShade", Qt.blue, Qt.blue, 6, symbol=QwtSymbol.NoSymbol, style=QwtPlotCurve.Steps) 
     104        self.lowerTailShadeKey = self.addCurve("lowerTailShade", Qt.blue, Qt.blue, 6, symbol=QwtSymbol.NoSymbol, style=QwtPlotCurve.Steps) 
     105        self.middleShadeKey = self.addCurve("middleShade", Qt.blue, Qt.blue, 6, symbol=QwtSymbol.NoSymbol, style=QwtPlotCurve.Steps) 
    94106 
    95107        self.upperTailShadeKey.setBrush(QBrush(Qt.blue)) 
     
    103115        if len(self.xData) == 0 and len(self.yData) == 0: 
    104116            return 
    105          
     117 
    106118        if self.type in ["hiTail", "twoTail"]: 
    107             index = max(min(int(math.ceil(100*(self.upperBoundary-self.minx)/(self.maxx-self.minx))), 100), 0) 
     119            index = max(min(int(math.ceil(100 * (self.upperBoundary - self.minx) / (self.maxx - self.minx))), 100), 0) 
    108120            x = [self.upperBoundary] + list(self.xData[index:]) 
    109121            y = [self.yData[min(index, 99)]] + list(self.yData[index:]) 
     
    112124            self.upperTailShadeKey.setData(x, y) 
    113125        if self.type in ["lowTail", "twoTail"]: 
    114             index = max(min(int(math.ceil(100*(self.lowerBoundary-self.minx)/(self.maxx-self.minx))),100), 0) 
     126            index = max(min(int(math.ceil(100 * (self.lowerBoundary - self.minx) / (self.maxx - self.minx))), 100), 0) 
    115127            x = list(self.xData[:index]) + [self.lowerBoundary] 
    116             y = list(self.yData[:index]) + [self.yData[min(index,99)]] 
     128            y = list(self.yData[:index]) + [self.yData[min(index, 99)]] 
    117129            x = [float(a) for a  in x] 
    118130            y = [float(a) for a  in y] 
    119131            self.lowerTailShadeKey.setData(x, y) 
    120132        if self.type in ["middle"]: 
    121             indexLow = max(min(int(100*(self.lowerBoundary-self.minx)/(self.maxx-self.minx)),99), 0) 
    122             indexHi = max(min(int(100*(self.upperBoundary-self.minx)/(self.maxx-self.minx)), 100)-1, 0) 
    123             x = [self.lowerBoundary] + list(self.xData[indexLow: indexHi]) +[self.upperBoundary] 
    124             y = [self.yData[max(index,0)]] + list(self.yData[indexLow: indexHi]) +[self.yData[max(indexHi, 99)]] 
     133            indexLow = max(min(int(100 * (self.lowerBoundary - self.minx) / (self.maxx - self.minx)), 99), 0) 
     134            indexHi = max(min(int(100 * (self.upperBoundary - self.minx) / (self.maxx - self.minx)), 100) - 1, 0) 
     135            x = [self.lowerBoundary] + list(self.xData[indexLow: indexHi]) + [self.upperBoundary] 
     136            y = [self.yData[max(index, 0)]] + list(self.yData[indexLow: indexHi]) + [self.yData[max(indexHi, 99)]] 
    125137            x = [float(a) for a  in x] 
    126138            y = [float(a) for a  in y] 
     
    132144        if self.type in ["lowTail", "hiTail", "twoTail"]: 
    133145            self.middleShadeKey.setData([], []) 
    134          
     146 
    135147    def setBoundary(self, low, hi): 
    136148        OWHist.setBoundary(self, low, hi) 
     
    138150#        self.updateData() 
    139151        self.replot() 
    140      
     152 
    141153    def _setBoundary(self, boundary, cut): 
    142154        if self.type in ["twoTail", "middle"]: 
     
    150162        else: 
    151163            self.setBoundary(cut, cut) 
    152          
     164 
    153165    def mousePressEvent(self, e): 
    154166        if self.state == SELECT and self.getBoundaryAt(e.pos()) and e.button() == Qt.LeftButton: 
     
    161173        else: 
    162174            return OWHist.mousePressEvent(self, e) 
    163          
     175 
    164176    def mouseMoveEvent(self, e): 
    165177        if self.state == SELECT: 
     
    174186                    self.canvas().setCursor(self._cursor) 
    175187        else: 
    176             return OWHist.mouseMoveEvent(self ,e)         
     188            return OWHist.mouseMoveEvent(self , e) 
    177189 
    178190    def mouseReleaseEvent(self, e): 
     
    195207        else: 
    196208            return None 
    197              
     209 
  • Orange/OrangeWidgets/OWNxHist.py

    r10860 r10875  
    1919        self.parent = parent 
    2020 
    21     def addHistogramControls(self, parent=None): 
    2221        # set default settings 
    2322        self.spinLowerThreshold = 0 
     
    3635        self.graph_matrix = None 
    3736 
     37    def addHistogramControls(self, parent=None): 
    3838        if parent is None: 
    3939            parent = self.controlArea 
     
    9999 
    100100    def setMatrix(self, data): 
    101         if data == None: return 
     101        if data == None: 
     102            self.matrix = None 
     103            self.histogram.setValues([]) 
     104            self.attributeCombo.clear() 
     105            self.generateGraph() 
     106            return 
    102107 
    103108        if not hasattr(data, "items") or data.items is None: 
     
    117122        self.attributeCombo.clear() 
    118123        vars = [] 
    119         if (self.matrix != None): 
    120             if hasattr(self.matrix, "items"): 
    121  
    122                 if isinstance(self.matrix.items, orange.ExampleTable): 
    123                     vars = list(self.matrix.items.domain.variables) 
    124  
    125                     metas = self.matrix.items.domain.getmetas(0) 
    126                     for i, var in metas.iteritems(): 
    127                         vars.append(var) 
     124 
     125        if hasattr(self.matrix, "items"): 
     126 
     127            if isinstance(self.matrix.items, orange.ExampleTable): 
     128                vars = list(self.matrix.items.domain.variables) 
     129 
     130                metas = self.matrix.items.domain.getmetas(0) 
     131                for i, var in metas.iteritems(): 
     132                    vars.append(var) 
    128133 
    129134        self.icons = self.createAttributeIconDict() 
     
    176181 
    177182        if self.matrix == None: 
    178             self.infoa.setText("No data loaded.") 
    179             self.infob.setText("") 
     183            if hasattr(self, "infoa"): 
     184                self.infoa.setText("No data loaded.") 
     185            if hasattr(self, "infob"): 
     186                self.infob.setText("") 
     187            if hasattr(self, "infoc"): 
     188                self.infoc.setText("") 
     189            self.pconnected = 0 
     190            self.nedges = 0 
     191            self.graph = None 
     192            if hasattr(self, "sendSignals"): 
     193                self.sendSignals() 
    180194            return 
    181195 
     
    266280 
    267281        if matrix != None: 
    268             matrix.items = self.graph.items() 
     282            matrix.setattr("items", self.graph.items()) 
    269283        self.graph_matrix = matrix 
    270284 
  • Orange/OrangeWidgets/Unsupervised/OWNxCanvasQt.py

    r10854 r10878  
    99MOVE_SELECTION = 100 
    1010 
    11 import Orange 
    12 import random 
    1311import numpy 
    1412 
     
    1715from plot.owtools import * 
    1816 
     17from Orange import core, data, misc, network, orangeqt, projection 
    1918from orngScaleScatterPlotData import * 
    20 from Orange import orangeqt 
    2119 
    2220class NodeItem(orangeqt.NodeItem): 
     
    4745        orangeqt.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
    4846 
    49     def fragviz_callback(self, a, b, mds, mdsRefresh, components, progress_callback): 
     47    def fragviz_callback(self, a, b, mds, mdsRefresh, graph_components, matrix_components, progress_callback): 
    5048        """Refresh the UI when running  MDS on network components.""" 
    5149 
     
    5553            x_mds = [] 
    5654            y_mds = [] 
    57             phi = [None] * len(components) 
     55            phi = [None] * len(graph_components) 
    5856            nodes = self.nodes() 
    59  
    60             for i, component in enumerate(components): 
    61  
    62                 if len(mds.points) == len(components):  # if average linkage before 
     57            ncomponents = len(graph_components) 
     58 
     59            for i in range(ncomponents): 
     60 
     61                if len(mds.points) == ncomponents:  # if average linkage before 
    6362                    x_avg_mds = mds.points[i][0] 
    6463                    y_avg_mds = mds.points[i][1] 
    6564                else:                                   # if not average linkage before 
    66                     x = [mds.points[u][0] for u in component] 
    67                     y = [mds.points[u][1] for u in component] 
     65                    x = [mds.points[u][0] for u in matrix_components[i]] 
     66                    y = [mds.points[u][1] for u in matrix_components[i]] 
    6867 
    6968                    x_avg_mds = sum(x) / len(x) 
     
    7877 
    7978 
    80                 x = [nodes[i].x() for i in component] 
    81                 y = [nodes[i].y() for i in component] 
     79                x = [nodes[j].x() for j in graph_components[i]] 
     80                y = [nodes[j].y() for j in graph_components[i]] 
    8281 
    8382                x_avg_graph = sum(x) / len(x) 
     
    9089                                        x_avg_mds, y_avg_mds, phi)) 
    9190 
    92             for i, component in enumerate(components): 
     91            for i, component in enumerate(graph_components): 
    9392                x_avg_graph, y_avg_graph, x_avg_mds, \ 
    9493                y_avg_mds, phi = component_props[i] 
     
    105104                if not rotationOnly: 
    106105                    self.set_node_coordinates(dict( 
    107                        (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds, 
    108                             (nodes[i].y() - y_avg_graph) + y_avg_mds)) \ 
    109                                   for i in component)) 
     106                       (j, ((nodes[j].x() - x_avg_graph) + x_avg_mds, 
     107                            (nodes[j].y() - y_avg_graph) + y_avg_mds)) \ 
     108                                  for j in component)) 
    110109 
    111110            #if self.mdsType == MdsType.exactSimulation: 
     
    147146        self.stopMDS = False 
    148147 
    149         components = Orange.network.nx.algorithms.components.connected.connected_components(graph) 
    150         distances.matrixType = Orange.core.SymMatrix.Symmetric 
     148        nodes_inds = {n: i for i, n in enumerate(sorted(graph.nodes_iter()))} 
     149        inds_nodes = {i: n for i, n in enumerate(sorted(graph.nodes_iter()))} 
     150 
     151        graph_components = network.nx.algorithms.connected_components(graph) 
     152        matrix_components = [[nodes_inds[n] for n in c] for c in graph_components] 
     153 
     154        distances.matrixType = misc.SymMatrix.Symmetric 
    151155 
    152156        # scale net coordinates 
    153157        if avgLinkage: 
    154             distances = distances.avgLinkage(components) 
     158            distances = distances.avgLinkage(matrix_components) 
    155159 
    156160        # if only one component 
     
    158162            return 0 
    159163 
    160         mds = Orange.projection.mds.MDS(distances) 
    161         mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     164        mds = projection.mds.MDS(distances) 
     165        mds.optimize(10, projection.mds.SgnRelStress, 0) 
    162166        rect = self.data_rect() 
    163167        w_fr = rect.width() 
     
    165169        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
    166170 
    167         x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    168         y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
     171        x_mds, y_mds = zip(*mds.points) 
    169172        w_mds = max(x_mds) - min(x_mds) 
    170173        h_mds = max(y_mds) - min(y_mds) 
     
    179182            d_fr = 1 
    180183 
    181         self.set_node_coordinates(dict( 
    182            (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes)) 
     184        self.set_node_coordinates({key: (node.x() * d_mds / d_fr, node.y() * d_mds / d_fr) \ 
     185                                   for key, node in nodes.iteritems()}) 
    183186 
    184187        #self.update_properties() 
     
    188191        if opt_from_curr: 
    189192            if avgLinkage: 
    190                 for u, c in enumerate(components): 
     193                for u, c in enumerate(graph_components): 
    191194                    x = sum([nodes[n].x() for n in c]) / len(c) 
    192195                    y = sum([nodes[n].y() for n in c]) / len(c) 
     
    200203            mds.Torgerson() 
    201204 
    202         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
     205        mds.optimize(steps, projection.mds.SgnRelStress, minStressDelta, 
    203206                     progressCallback= 
    204                          lambda a, 
    205                                 b=None, 
    206                                 mds=mds, 
    207                                 mdsRefresh=mdsRefresh, 
    208                                 components=components, 
    209                                 progress_callback=progress_callback: 
    210                                     self.fragviz_callback(a, b, mds, mdsRefresh, components, progress_callback)) 
    211  
    212         self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback) 
    213  
    214         if progress_callback != None: 
     207                         lambda a, b=None, mds=mds, mdsRefresh=mdsRefresh, graph_comp=graph_components, 
     208                                matrix_comp=matrix_components, progress_callback=progress_callback: 
     209                         self.fragviz_callback(a, b, mds, mdsRefresh, graph_comp, matrix_comp, progress_callback)) 
     210 
     211        self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, graph_components, matrix_components, progress_callback) 
     212 
     213        if progress_callback is not None: 
    215214            progress_callback(mds.avgStress, self.mdsStep) 
    216215 
     
    223222        if not self.mdsStep % mdsRefresh: 
    224223 
    225             self.set_node_coordinates(dict((u, (mds.points[u][0], \ 
    226                                                 mds.points[u][1])) for u in \ 
    227                                            range(len(mds.points)))) 
     224            self.set_node_coordinates({n: (mds.points[i][0], \ 
     225                                           mds.points[i][1]) for i, n in enumerate(sorted(self.nodes()))}) 
    228226            self.plot().replot() 
    229227            qApp.processEvents() 
     
    254252        self.stopMDS = False 
    255253 
    256         distances.matrixType = Orange.core.SymMatrix.Symmetric 
    257         mds = Orange.projection.mds.MDS(distances) 
    258         mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     254        distances.matrixType = core.SymMatrix.Symmetric 
     255        mds = projection.mds.MDS(distances) 
     256        mds.optimize(10, projection.mds.SgnRelStress, 0) 
    259257        rect = self.data_rect() 
    260258        w_fr = rect.width() 
     
    262260        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
    263261 
    264         x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    265         y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
     262        x_mds, y_mds = zip(*mds.points) 
    266263        w_mds = max(x_mds) - min(x_mds) 
    267264        h_mds = max(y_mds) - min(y_mds) 
     
    284281            mds.Torgerson() 
    285282 
    286         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
     283        mds.optimize(steps, projection.mds.SgnRelStress, minStressDelta, 
    287284                     progressCallback= 
    288285                         lambda a, 
     
    295292        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, progress_callback) 
    296293 
    297         if progress_callback != None: 
     294        if progress_callback is not None: 
    298295            progress_callback(mds.avgStress, self.mdsStep) 
    299296 
     
    442439            return 
    443440 
    444         components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
     441        components = network.nx.algorithms.components.connected_components(self.graph) 
    445442        nodes = self.networkCurve.nodes() 
    446443 
     
    466463                if var.name == attribute: 
    467464                    colorIndex = i 
    468                     if var.varType == orange.VarTypes.Discrete: 
     465                    if var.varType == core.VarTypes.Discrete: 
    469466                        colorIndices = getVariableValueIndices(var, colorIndex) 
    470467 
     
    474471                if var.name == attribute: 
    475472                    colorIndex = i 
    476                     if var.varType == orange.VarTypes.Discrete: 
     473                    if var.varType == core.VarTypes.Discrete: 
    477474                        colorIndices = getVariableValueIndices(var, colorIndex) 
    478475 
     
    480477        palette.setNumberOfColors(len(colorIndices)) 
    481478 
    482         if colorIndex != None and table.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     479        if colorIndex != None and table.domain[colorIndex].varType == core.VarTypes.Continuous: 
    483480            minValue = float(min([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
    484481            maxValue = float(max([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
     
    496493            nodes = self.graph.nodes() 
    497494 
    498         if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
     495        if colorIndex is not None and self.items.domain[colorIndex].varType == core.VarTypes.Continuous and minValue == maxValue: 
    499496            colors.update((node, self.discPalette[0]) for node in nodes) 
    500497 
    501         elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     498        elif colorIndex is not None and self.items.domain[colorIndex].varType == core.VarTypes.Continuous: 
    502499            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)]) 
    503500                          if str(self.items[v][colorIndex].value) != '?' else 
    504501                          (v, self.discPalette[0]) for v in nodes) 
    505502 
    506         elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     503        elif colorIndex is not None and self.items.domain[colorIndex].varType == core.VarTypes.Discrete: 
    507504            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes) 
    508505 
     
    523520 
    524521        label_attributes = [] 
    525         if self.items is not None and isinstance(self.items, orange.ExampleTable): 
     522        if self.items is not None and isinstance(self.items, data.Table): 
    526523            label_attributes = [self.items.domain[att] for att in \ 
    527524                self.node_label_attributes if att in self.items.domain] 
     
    563560        colors = [] 
    564561 
    565         if colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
     562        if colorIndex is not None and self.links.domain[colorIndex].varType == core.VarTypes.Continuous and minValue == maxValue: 
    566563            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
    567564 
    568         elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     565        elif colorIndex is not None and self.links.domain[colorIndex].varType == core.VarTypes.Continuous: 
    569566            colors = [self.contPalette[(float(self.links[edge.links_index()][colorIndex].value) - minValue) / (maxValue - minValue)] 
    570567                          if str(self.links[edge.links_index()][colorIndex].value) != '?' else 
    571568                          self.discPalette[0] for edge in self.networkCurve.edges()] 
    572569 
    573         elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     570        elif colorIndex is not None and self.links.domain[colorIndex].varType == core.VarTypes.Discrete: 
    574571            colors = [self.discEdgePalette[colorIndices[self.links[edge.links_index()][colorIndex].value]] for edge in self.networkCurve.edges()] 
    575572 
     
    590587 
    591588        label_attributes = [] 
    592         if self.links is not None and isinstance(self.links, orange.ExampleTable): 
     589        if self.links is not None and isinstance(self.links, data.Table): 
    593590            label_attributes = [self.links.domain[att] for att in \ 
    594591                self.edge_label_attributes if att in self.links.domain] 
     
    606603    def set_tooltip_attributes(self, attributes): 
    607604        if self.graph is None or self.items is None or \ 
    608            not isinstance(self.items, orange.ExampleTable): 
     605           not isinstance(self.items, data.Table): 
    609606            return 
    610607 
    611608        tooltip_attributes = [self.items.domain[att] for att in \ 
    612609                                 attributes if att in self.items.domain] 
    613         self.networkCurve.set_node_tooltips(dict((node, ', '.join(str(\ 
     610        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str( \ 
    614611                   self.items[node][att]) for att in tooltip_attributes)) \ 
    615612                                                        for node in self.graph)) 
     
    618615        old_nodes = set(self.graph.nodes_iter()) 
    619616        new_nodes = set(newgraph.nodes_iter()) 
    620         inter_nodes = old_nodes.intersection(new_nodes) 
    621         remove_nodes = list(old_nodes.difference(inter_nodes)) 
    622         add_nodes = list(new_nodes.difference(inter_nodes)) 
     617        inter_nodes = old_nodes & new_nodes 
     618        remove_nodes = list(old_nodes - inter_nodes) 
     619        add_nodes = list(new_nodes - inter_nodes) 
    623620 
    624621        self.graph = newgraph 
     
    629626        current_nodes = self.networkCurve.nodes() 
    630627 
    631         center_x = numpy.average([node.x() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0 
    632         center_y = numpy.average([node.y() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0 
     628        center_x = numpy.average([node.x() for node in current_nodes.itervalues()]) if len(current_nodes) > 0 else 0 
     629        center_y = numpy.average([node.y() for node in current_nodes.itervalues()]) if len(current_nodes) > 0 else 0 
    633630 
    634631        def closest_nodes_with_pos(nodes): 
     
    650647        pos = dict((n, [numpy.average(c) for c in zip(*[(current_nodes[u].x(), current_nodes[u].y()) for u in closest_nodes_with_pos(set([n]))])]) for n in add_nodes) 
    651648 
    652         self.networkCurve.remove_nodes(list(remove_nodes)) 
     649        self.networkCurve.remove_nodes(remove_nodes) 
    653650 
    654651        nodes = dict((v, self.NodeItem(v, x=pos[v][0] if len(pos[v]) == 2 else center_x, y=pos[v][1] if len(pos[v]) == 2 else center_y, parent=self.networkCurve)) for v in add_nodes) 
     
    712709        #add nodes 
    713710        #self.vertices_old = [(None, []) for v in self.graph] 
    714         vertices = dict((v, self.NodeItem(v, parent=self.networkCurve)) for v in self.graph) 
    715         self.networkCurve.set_nodes(vertices) 
     711        nodes = dict((v, self.NodeItem(v, parent=self.networkCurve)) for v in self.graph.nodes_iter()) 
     712        self.networkCurve.set_nodes(nodes) 
    716713 
    717714        #build edge to row index 
     
    734731        if self.links is not None and len(self.links) > 0: 
    735732            links = self.links 
    736             links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in self.graph.edges()) 
    737  
    738             if self.graph.is_directed(): 
    739                 edges = [EdgeItem(vertices[i], vertices[j], 
    740                     graph[i][j].get('weight', 1), links_index, arrows=EdgeItem.ArrowV, \ 
     733            links_indices = (self.edge_to_row[i + 1][j + 1] \ 
     734                             for (i, j) in self.graph.edges_iter()) 
     735 
     736            arrow = EdgeItem.ArrowV if self.graph.is_directed() else None 
     737 
     738            edges = [EdgeItem(nodes[i], nodes[j], 
     739                    graph[i][j].get('weight', 1), links_index, arrows=arrow, \ 
    741740                    parent=self.networkCurve) for ((i, j), links_index) in \ 
    742                          zip(self.graph.edges(), links_indices)] 
    743             else: 
    744                 edges = [EdgeItem(vertices[i], vertices[j], 
    745                     graph[i][j].get('weight', 1), links_index, \ 
    746                     parent=self.networkCurve) for ((i, j), links_index) in \ 
    747                          zip(self.graph.edges(), links_indices)] 
    748  
    749         elif self.graph.is_directed(): 
    750             edges = [EdgeItem(vertices[i], vertices[j], 
    751                                       graph[i][j].get('weight', 1), arrows=EdgeItem.ArrowV, parent=self.networkCurve) for (i, j) in self.graph.edges()] 
     741                         zip(self.graph.edges_iter(), links_indices)] 
    752742        else: 
    753             edges = [EdgeItem(vertices[i], vertices[j], 
    754                                       graph[i][j].get('weight', 1), parent=self.networkCurve) for (i, j) in self.graph.edges()] 
     743            arrow = EdgeItem.ArrowV if self.graph.is_directed() else None 
     744 
     745            edges = [EdgeItem(nodes[i], nodes[j], graph[i][j].get('weight', 1), \ 
     746                              arrows=arrow, parent=self.networkCurve) \ 
     747                                  for (i, j) in self.graph.edges_iter()] 
    755748 
    756749        self.networkCurve.set_edges(edges) 
  • Orange/OrangeWidgets/Unsupervised/OWNxClustering.py

    r9671 r10873  
    1313from OWWidget import * 
    1414 
    15  
    1615class OWNxClustering(OWWidget): 
    1716 
     
    2423        self.inputs = [("Network", Orange.network.Graph, 
    2524                        self.setNetwork, Default)] 
    26         self.outputs = [("Network", Orange.network.Graph)] 
     25        self.outputs = [("Network", Orange.network.Graph), 
     26                        ("Community Detection", cd.CommunityDetection)] 
    2727 
    2828        self.net = None 
     
    5757                     callback=lambda b=True: self.cluster(b)) 
    5858 
     59        self.cluster() 
     60 
    5961    def setNetwork(self, net): 
    6062        self.net = net 
     
    6870        self.info.setText(' ') 
    6971 
     72        if self.method == 0: 
     73            alg = cd.label_propagation 
     74            kwargs = {'results2items': 1, 
     75                      'resultHistory2items': self.iterationHistory, 
     76                      'iterations': self.iterations} 
     77 
     78        elif self.method == 1: 
     79            alg = cd.label_propagation_hop_attenuation 
     80            kwargs = {'results2items': 1, 
     81                      'resultHistory2items': self.iterationHistory, 
     82                      'iterations': self.iterations, 
     83                      'delta': self.hop_attenuation} 
     84 
     85        self.send("Community Detection", cd.CommunityDetection(alg, **kwargs)) 
     86 
    7087        if self.net is None: 
    7188            self.send("Network", None) 
    7289            return 
    7390 
    74         if self.method == 0: 
    75             labels = cd.label_propagation(self.net, results2items=1, 
    76                                     resultHistory2items=self.iterationHistory, 
    77                                     iterations=self.iterations) 
    78         if self.method == 1: 
    79             labels = cd.label_propagation_hop_attenuation( 
    80                                     self.net, 
    81                                     results2items=1, 
    82                                     resultHistory2items=self.iterationHistory, 
    83                                     iterations=self.iterations, 
    84                                     delta=self.hop_attenuation) 
     91        labels = alg(self.net, **kwargs) 
    8592 
    8693        self.info.setText('%d clusters found' % len(set(labels.values()))) 
  • Orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r10862 r10878  
    1111import time 
    1212 
    13 import Orange 
    1413import OWGUI 
    1514import OWColorPalette 
    1615import orngMDS 
    1716 
     17from Orange import core, data, feature, network 
    1818from OWWidget import * 
    1919from operator import itemgetter 
     
    4646            OWWidget.__init__(self, parent, signalManager, name, noReport=True) 
    4747            #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
    48             self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
    49                            ("Items", Orange.data.Table, self.set_items), 
    50                            ("Item Subset", Orange.data.Table, self.mark_items), 
    51                            ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix), 
    52                            ("Net View", Orange.network.NxView, self.set_network_view)] 
    53  
    54             self.outputs = [("Selected Network", Orange.network.Graph), 
    55                             ("Distance Matrix", Orange.core.SymMatrix), 
    56                             ("Marked Items", Orange.data.Table), 
    57                             ("Selected Items", Orange.data.Table), 
    58                             ("Other Items", Orange.data.Table)] 
     48            self.inputs = [("Network", network.Graph, self.set_graph, Default), 
     49                           ("Items", data.Table, self.set_items), 
     50                           ("Item Subset", data.Table, self.mark_items), 
     51                           ("Distances", core.SymMatrix, self.set_items_distance_matrix), 
     52                           ("Net View", network.NxView, self.set_network_view)] 
     53 
     54            self.outputs = [("Selected Network", network.Graph), 
     55                            ("Distance Matrix", core.SymMatrix), 
     56                            ("Marked Items", data.Table), 
     57                            ("Selected Items", data.Table), 
     58                            ("Other Items", data.Table)] 
    5959                            #("Attribute Selection List", AttributeList)] 
    6060 
     
    353353        def hide_selection(self): 
    354354            nodes = set(self.graph.nodes()).difference(self.networkCanvas.selected_nodes()) 
    355             self.change_graph(Orange.network.nx.Graph.subgraph(self.graph, nodes)) 
     355            self.change_graph(network.nx.Graph.subgraph(self.graph, nodes)) 
    356356 
    357357        def show_selection(self): 
     
    372372 
    373373            items = self.graph_base.items() 
    374             if items.domain[att].var_type == Orange.feature.Type.Continuous: 
     374            if items.domain[att].var_type == feature.Type.Continuous: 
    375375                for v in vertices: 
    376376                    items[v][att] = float(self.editValue) 
     
    387387            self.cb_show_component_distances.setEnabled(0) 
    388388 
    389             if matrix is None or self.graph_base is None: 
     389            if matrix is None: 
    390390                self.items_matrix = None 
     391                return 
     392 
     393            if self.graph_base is None: 
    391394                self.networkCanvas.items_matrix = None 
    392395                self.information('No graph found!') 
     
    404407            self.cb_show_component_distances.setEnabled(1) 
    405408 
    406             if str(self.optMethod) in ['8', '9', '10']: 
    407                 if self.items_matrix is not None and self.graph is not None and \ 
    408                 self.items_matrix.dim == self.graph.number_of_nodes(): 
     409            if self.optMethod in [8, 9, 10]: 
     410                if self.items_matrix is not None and self.graph_base is not None and \ 
     411                                    self.items_matrix.dim == self.graph_base.number_of_nodes(): 
    409412                    self.optButton.setEnabled(True) 
    410                     self.optButton.setChecked(True) 
    411                     self.graph_layout() 
     413 
     414                    if self.optMethod in [8, 9]: 
     415                        self.cb_opt_from_curr.setEnabled(True) 
     416 
     417                    if self.optMethod == 8: # if FragViz, run FR first 
     418                        self.optMethod = 2 
     419                        self.optButton.setChecked(True) 
     420                        self.graph_layout() 
     421                        self.optMethod = 8 
     422 
     423                self.optButton.setChecked(True) 
     424                self.graph_layout() 
    412425 
    413426        def _set_canvas_attr(self, attr, value): 
     
    553566                    graph_node['y'] = plot_node.y() 
    554567 
    555                 Orange.network.readwrite.write(self.graph, fn) 
     568                network.readwrite.write(self.graph, fn) 
    556569 
    557570        def send_data(self): 
     
    619632 
    620633            for var in vars: 
    621                 if var.varType in [Orange.feature.Type.Discrete, \ 
    622                                    Orange.feature.Type.Continuous]: 
     634                if var.varType in [feature.Type.Discrete, \ 
     635                                   feature.Type.Continuous]: 
    623636                    self.colorCombo.addItem(self.icons.get(var.varType, \ 
    624637                                            self.icons[-1]), unicode(var.name)) 
    625638 
    626                 if var.varType in [Orange.feature.Type.String] and hasattr(self.graph, 'items') and self.graph_base.items() is not None and len(self.graph_base.items()) > 0: 
     639                if var.varType in [feature.Type.String] and hasattr(self.graph, 'items') and self.graph_base.items() is not None and len(self.graph_base.items()) > 0: 
    627640 
    628641                    value = self.graph_base.items()[0][var].value 
     
    639652                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
    640653 
    641                 elif var.varType in [Orange.feature.Type.Continuous]: 
     654                elif var.varType in [feature.Type.Continuous]: 
    642655                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    643656 
     
    648661 
    649662            for var in edgeVars: 
    650                 if var.varType in [Orange.feature.Type.Discrete, Orange.feature.Type.Continuous]: 
     663                if var.varType in [feature.Type.Discrete, feature.Type.Continuous]: 
    651664                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    652665 
     
    766779        def set_graph_none(self): 
    767780            self.graph = None 
     781            self.graph_base = None 
    768782            #self.graph_base = None 
    769783            self._clear_combos() 
     
    952966                commonVars = set(lstNewDomain) & set(lstOrgDomain) 
    953967 
    954                 self.markInputCombo.addItem(self.icons[Orange.feature.Type.Discrete], unicode("ID")) 
     968                self.markInputCombo.addItem(self.icons[feature.Type.Discrete], unicode("ID")) 
    955969 
    956970                if len(commonVars) > 0: 
     
    959973                        mrkVar = items.domain[var] 
    960974 
    961                         if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.feature.Type.String: 
     975                        if orgVar.varType == mrkVar.varType and orgVar.varType == feature.Type.String: 
    962976                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
    963977 
     
    10451059                self.optMethod = method 
    10461060 
    1047             if str(self.optMethod) == '0': 
     1061            if self.optMethod == 0: 
    10481062                self.optButton.setEnabled(False) 
    10491063            else: 
    10501064                self.optButton.setEnabled(True) 
    10511065 
    1052             if str(self.optMethod) in ['2', '3', '4']: 
     1066            if self.optMethod in [2, 3, 4]: 
    10531067                self.stepsSpin.setEnabled(True) 
    10541068 
    1055             elif str(self.optMethod) in ['8', '9', '10']: 
    1056                 if str(self.optMethod) == '8': 
     1069            elif self.optMethod in [8, 9, 10]: 
     1070                if self.optMethod == 10: 
    10571071                    self.stepsSpin.label.setText('Pivots: ') 
    10581072 
    1059                 if str(self.optMethod) in ['9', '10']: 
     1073                if self.optMethod in [8, 9]: 
    10601074                    self.cb_opt_from_curr.setEnabled(True) 
    10611075 
     
    10701084                    self.optButton.setEnabled(False) 
    10711085                    return 
    1072                 if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1086                if self.items_matrix.dim != self.graph_base.number_of_nodes(): 
    10731087                    self.error('Distance matrix dimensionality must equal number of vertices') 
    10741088                    self.optButton.setEnabled(False) 
     
    10981112                return 
    10991113 
    1100             if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1114            if self.items_matrix.dim != self.graph_base.number_of_nodes(): 
    11011115                self.error('Distance matrix dimensionality must equal number of vertices') 
    11021116                self.optButton.setChecked(False) 
     
    11161130                matrix = self.items_matrix 
    11171131            else: 
    1118                 matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
     1132                matrix = self.items_matrix.get_items(sorted(self.graph.nodes_iter())) 
    11191133 
    11201134            self.networkCanvas.networkCurve.layout_fragviz(self.frSteps, matrix, self.graph, self.mds_progress, self.opt_from_curr) 
     
    11351149                return 
    11361150 
    1137             if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1151            if self.items_matrix.dim != self.graph_base.number_of_nodes(): 
    11381152                self.error('Distance matrix dimensionality must equal number of vertices') 
    11391153                self.optButton.setChecked(False) 
     
    14261440 
    14271441            self.progressBarInit() 
    1428             components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
     1442            components = [c for c in network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
    14291443            if 'component name' in self.graph_base.items().domain: 
    14301444                keyword_table = self.graph_base.items() 
    14311445            else: 
    1432                 keyword_table = Orange.data.Table(Orange.data.Domain(Orange.feature.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
     1446                keyword_table = data.Table(data.Domain(feature.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
    14331447 
    14341448            import obiGO 
     
    15461560 
    15471561            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    1548             self.set_items(Orange.data.Table([self.graph_base.items(), keyword_table])) 
     1562            self.set_items(data.Table([self.graph_base.items(), keyword_table])) 
    15491563            self.progressBarFinished() 
    15501564 
  • Orange/__init__.py

    r10827 r10882  
    11from __future__ import absolute_import 
    22 
    3 __version__ = "2.6a1" 
     3# This is overwritten with version from version.py, which is generated by 
     4# setup.py automatically 
     5__version__ = "unknown" 
    46 
    57ADDONS_ENTRY_POINT = 'orange.addons' 
     
    4345        except ImportError, err: 
    4446            warnings.warn("Importing add-on '%s' failed: %s" % (entry_point.name, err), UserWarning, 2) 
     47        except pkg_resources.DistributionNotFound, err: 
     48            warnings.warn("Loading add-on '%s' failed because of a missing dependency: '%s'" % (entry_point.name, err), UserWarning, 2) 
     49        except Exception, err: 
     50            warning.warn("An exception occurred during the loading of '%s':\n%r" %(entry_point.name, err), UserWarning, 2) 
     51 
    4552 
    4653_import("utils") 
  • Orange/network/community.py

    r9922 r10872  
    5757        G.set_items(Orange.data.Table([items, data])) 
    5858 
     59 
     60class CommunityDetection(object): 
     61 
     62    def __init__(self, algorithm, **kwargs): 
     63        self.algorithm = algorithm 
     64        self.kwargs = kwargs 
     65 
     66    def __call__(self, G): 
     67        return self.algorithm(G, **self.kwargs) 
    5968 
    6069def label_propagation_hop_attenuation(G, results2items=0, \ 
  • docs/development/rst/conf.py

    r10437 r10881  
    1313 
    1414import sys, os 
     15 
     16import imp 
     17module_setup = imp.load_source('module_setup', os.path.join(os.path.dirname(__file__), '..', '..', '..', 'setup.py')) 
     18VERSION = module_setup.VERSION 
    1519 
    1620# If extensions (or modules to document with autodoc) are in another directory, 
    1721# add these directories to sys.path here. If the directory is relative to the 
    1822# documentation root, use os.path.abspath to make it absolute, like shown here. 
    19 sys.path.append(os.path.abspath('../../../')) 
     23sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../'))) 
    2024import Orange 
    2125 
     
    4751# 
    4852# The short X.Y version. 
    49 version = '2.5' 
     53version = VERSION 
    5054# The full version, including alpha/beta/rc tags. 
    51 release = '2.5 beta' 
     55release = VERSION 
    5256 
    5357# The language for content autogenerated by Sphinx. Refer to documentation 
  • docs/extend-widgets/rst/conf.py

    r10437 r10881  
    1313 
    1414import sys, os 
     15 
     16import imp 
     17module_setup = imp.load_source('module_setup', os.path.join(os.path.dirname(__file__), '..', '..', '..', 'setup.py')) 
     18VERSION = module_setup.VERSION 
    1519 
    1620# If extensions (or modules to document with autodoc) are in another directory, 
    1721# add these directories to sys.path here. If the directory is relative to the 
    1822# documentation root, use os.path.abspath to make it absolute, like shown here. 
    19 sys.path.append(os.path.abspath('../../../')) 
     23sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../'))) 
    2024import Orange 
    2125 
     
    4751# 
    4852# The short X.Y version. 
    49 version = '2.5' 
     53version = VERSION 
    5054# The full version, including alpha/beta/rc tags. 
    51 release = '2.5 beta' 
     55release = VERSION 
    5256 
    5357# The language for content autogenerated by Sphinx. Refer to documentation 
  • docs/first-steps/rst/conf.py

    r9402 r10881  
    1313 
    1414import sys, os 
     15 
     16import imp 
     17module_setup = imp.load_source('module_setup', os.path.join(os.path.dirname(__file__), '..', '..', '..', 'setup.py')) 
     18VERSION = module_setup.VERSION 
    1519 
    1620# If extensions (or modules to document with autodoc) are in another directory, 
    1721# add these directories to sys.path here. If the directory is relative to the 
    1822# documentation root, use os.path.abspath to make it absolute, like shown here. 
    19 #sys.path.append(os.path.abspath('.')) 
     23sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../'))) 
     24import Orange 
    2025 
    2126# -- General configuration ----------------------------------------------------- 
     
    4651# 
    4752# The short X.Y version. 
    48 version = '2.5' 
     53version = VERSION 
    4954# The full version, including alpha/beta/rc tags. 
    50 release = '2.5 beta' 
     55release = VERSION 
    5156 
    5257# The language for content autogenerated by Sphinx. Refer to documentation 
  • docs/reference/rst/conf.py

    r10037 r10881  
    1212# serve to show the default. 
    1313 
    14 import sys, os, os.path 
     14import sys, os 
    1515 
    1616#rewrite formatargs function with different defaults 
     
    2222numpydoc.docscrape.inspect = myinspect 
    2323 
     24import imp 
     25module_setup = imp.load_source('module_setup', os.path.join(os.path.dirname(__file__), '..', '..', '..', 'setup.py')) 
     26VERSION = module_setup.VERSION 
     27 
    2428#disable deprecation decorators for the documentation 
    2529os.environ["orange_no_deprecated_members"] = "1" 
     
    2832# add these directories to sys.path here. If the directory is relative to the 
    2933# documentation root, use os.path.abspath to make it absolute, like shown here. 
    30 sys.path.append(os.path.abspath('../../../orange')) 
     34sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../'))) 
     35import Orange 
    3136 
    3237# -- General configuration ----------------------------------------------------- 
     
    6469# 
    6570# The short X.Y version. 
    66 version = '2.5' 
     71version = VERSION 
    6772# The full version, including alpha/beta/rc tags. 
    68 release = '2.5 beta' 
     73release = VERSION 
    6974 
    7075# The language for content autogenerated by Sphinx. Refer to documentation 
  • docs/tutorial/rst/conf.py

    r9387 r10881  
    1313 
    1414import sys, os 
     15 
     16import imp 
     17module_setup = imp.load_source('module_setup', os.path.join(os.path.dirname(__file__), '..', '..', '..', 'setup.py')) 
     18VERSION = module_setup.VERSION 
    1519 
    1620# If extensions (or modules to document with autodoc) are in another directory, 
    1721# add these directories to sys.path here. If the directory is relative to the 
    1822# documentation root, use os.path.abspath to make it absolute, like shown here. 
    19 #sys.path.append(os.path.abspath('.')) 
     23sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../'))) 
     24import Orange 
    2025 
    2126# -- General configuration ----------------------------------------------------- 
     
    4651# 
    4752# The short X.Y version. 
    48 version = '2.5' 
     53version = VERSION 
    4954# The full version, including alpha/beta/rc tags. 
    50 release = '2.5 beta' 
     55release = VERSION 
    5156 
    5257# The language for content autogenerated by Sphinx. Refer to documentation 
  • docs/widgets/rst/conf.py

    r10405 r10881  
    1313 
    1414import sys, os 
     15 
     16import imp 
     17module_setup = imp.load_source('module_setup', os.path.join(os.path.dirname(__file__), '..', '..', '..', 'setup.py')) 
     18VERSION = module_setup.VERSION 
    1519 
    1620# If extensions (or modules to document with autodoc) are in another directory, 
    1721# add these directories to sys.path here. If the directory is relative to the 
    1822# documentation root, use os.path.abspath to make it absolute, like shown here. 
    19 #sys.path.append(os.path.abspath('.')) 
     23sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../'))) 
     24import Orange 
    2025 
    2126# -- General configuration ----------------------------------------------------- 
     
    9095# 
    9196# The short X.Y version. 
    92 version = '2.5' 
     97version = VERSION 
    9398# The full version, including alpha/beta/rc tags. 
    94 release = '2.5 beta' 
     99release = VERSION 
    95100 
    96101# The language for content autogenerated by Sphinx. Refer to documentation 
  • install-scripts/mac/dailyrun.sh

    r10702 r10870  
    3131fi 
    3232 
     33SOURCES_DIR=$PUBLISH_DIR/sources 
    3334 
    3435defaults write com.apple.desktopservices DSDontWriteNetworkStores true 
     
    3738    /Users/ailabc/mount-dirs.sh || { echo "Mounting failed." ; exit 1 ; } 
    3839fi 
     40 
     41# Get old source addon versions from PKG-INFO files (these are updated by dailyrun-sources) 
     42OLD_ORANGE_VERSION=`grep "^Version:" $SOURCES_DIR/Orange.egg-info/PKG-INFO | cut -d " " -f 2` 
     43OLD_BIOINFORMATICS_VERSION=`grep "^Version:" $SOURCES_DIR/Orange_Bioinformatics.egg-info/PKG-INFO | cut -d " " -f 2` 
     44OLD_TEXT_VERSION=`grep "^Version:" $SOURCES_DIR/Orange_Text_Mining.egg-info/PKG-INFO | cut -d " " -f 2` 
     45 
    3946 
    4047SOURCE_LOG=$WORK_DIR/sources-daily-build.log 
     
    4956 
    5057 
    51 SOURCES_DIR=$PUBLISH_DIR/sources 
    52  
    53 # Get versions from PKG-INFO files (these are updated by dailyrun-sources) 
     58# Get new versions from PKG-INFO files (these are updated by dailyrun-sources) 
    5459ORANGE_VERSION=`grep "^Version:" $SOURCES_DIR/Orange.egg-info/PKG-INFO | cut -d " " -f 2` 
    5560BIOINFORMATICS_VERSION=`grep "^Version:" $SOURCES_DIR/Orange_Bioinformatics.egg-info/PKG-INFO | cut -d " " -f 2` 
     
    6873TEXT_SOURCE_MD5=`md5 -q $SOURCES_DIR/$TEXT_SOURCE` 
    6974 
     75# Are there new versions of orange and addons available. 
     76if [[ $OLD_ORANGE_VERSION < $ORANGE_VERSION ]]; then 
     77    NEW_ORANGE=1 
     78fi 
     79 
     80if [[ $OLD_BIOINFORMATICS_VERSION < $BIOINFORMATICS_VERSION ]]; then 
     81    NEW_BIOINFORMATICS=1 
     82    NEW_BUNDLE_ADDONS=1 
     83fi 
     84 
     85if [[ $OLD_TEXT_VERSION < $TEXT_VERSION ]]; then 
     86    NEW_TEXT=1 
     87    NEW_BUNDLE_ADDONS=1 
     88fi 
    7089 
    7190## Daily bundle build from hg (for now always until versioning is established). 
    7291if [[ true || $NEW_ORANGE || $NEW_BIOINFORMATICS || $NEW_TEXT || $FORCE ]]; then 
    73     ./bundle-daily-build-hg.sh &> $WORK_DIR/bundle-daily-build.log 
     92    ./bundle-daily-build-hg.sh $NEW_BUNDLE_ADDONS &> $WORK_DIR/bundle-daily-build.log 
    7493    EXIT_VALUE=$? 
    7594fi 
     
    103122OLD_TEXT_VERSION=`curl --silent $BASE/orange-text-gui-dev-py.info | grep "Version: " | cut -d" " -f 2` 
    104123 
    105 if [[ $OLD_ORANGE_VERSION < ORANGE_VERSION ]]; then 
     124if [[ $OLD_ORANGE_VERSION < $ORANGE_VERSION ]]; then 
    106125    NEW_ORANGE=1 
    107126fi 
    108127 
    109 if [[ $OLD_BIOINFORMATICS_VERSION < BIOINFORMATICS_VERSION ]]; then 
     128if [[ $OLD_BIOINFORMATICS_VERSION < $BIOINFORMATICS_VERSION ]]; then 
    110129    NEW_BIOINFORMATICS=1 
    111130fi 
    112131 
    113 if [[ $OLD_TEXT_VERSION < TEXT_VERSION ]]; then 
     132if [[ $OLD_TEXT_VERSION < $TEXT_VERSION ]]; then 
    114133    NEW_TEXT=1 
    115134fi 
  • setup.py

    r10845 r10881  
    11#!usr/bin/env python 
    22 
    3 import distribute_setup 
    4 distribute_setup.use_setuptools() 
     3try: 
     4    import distribute_setup 
     5    distribute_setup.use_setuptools() 
     6except ImportError: 
     7    # For documentation we load setup.py to get version 
     8    # so it does not matter if importing fails 
     9    pass 
    510 
    611import glob, os, sys, types 
     
    9297import imp 
    9398try: 
    94     orangeqt_setup = imp.load_source('orangeqt_setup', 'source/orangeqt/setup.py') 
     99    orangeqt_setup = imp.load_source('orangeqt_setup', os.path.join(os.path.dirname(__file__), 'source/orangeqt/setup.py')) 
    95100    build_pyqt_ext = orangeqt_setup.build_pyqt_ext 
    96101except ImportError: 
     
    703708 
    704709SETUP_REQUIRES = ( 
    705     'distribute', 
     710    'setuptools', 
    706711) 
    707712 
    708713INSTALL_REQUIRES = ( 
    709     'distribute', 
     714    'setuptools', 
    710715    'numpy', 
    711716) 
  • source/orangeqt/networkcurve.cpp

    r10736 r10873  
    4242ModelItem::ModelItem(int index, int symbol, QColor color, int size, QGraphicsItem* parent): NodeItem(index, symbol, color, size, parent) 
    4343{ 
    44  
     44    representative = 0; 
    4545} 
    4646 
     
    5656        int _size = size() + 5; 
    5757 
    58         painter->setPen(QPen(QBrush(color()), 1, Qt::SolidLine, Qt::RoundCap)); 
     58        int pen_size = (representative) ? 3 : 1; 
     59        painter->setPen(QPen(QBrush(color()), pen_size, Qt::SolidLine, Qt::RoundCap)); 
    5960 
    6061        QRadialGradient gradient(QPointF(0, 0), _size); 
     
    110111    } 
    111112    */ 
     113} 
     114 
     115void ModelItem::set_representative(bool value) 
     116{ 
     117    representative = value; 
     118} 
     119 
     120bool ModelItem::is_representative() const 
     121{ 
     122    return representative; 
    112123} 
    113124 
  • source/orangeqt/networkcurve.h

    r9378 r10872  
    145145 
    146146    virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0); 
     147 
     148    void set_representative(bool value); 
     149    bool is_representative() const; 
     150 
     151private: 
     152    bool representative; 
    147153}; 
    148154 
  • source/orangeqt/networkcurve.sip

    r9361 r10873  
    3535    void set_image(QPixmap* im); 
    3636}; 
    37  
     37     
    3838class ModelItem : NodeItem 
    3939{ 
     
    4141    ModelItem(int index, int symbol, QColor color, int size, QGraphicsItem* parent /TransferThis/ = 0); 
    4242    virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0); 
     43     
     44    void set_representative(double y = true); 
     45    bool is_representative() const; 
    4346}; 
    4447 
Note: See TracChangeset for help on using the changeset viewer.