Changeset 10581:94a831b04ec3 in orange


Ignore:
Timestamp:
03/20/12 08:18:01 (14 months ago)
Author:
markotoplak
Branch:
default
rebase_source:
5f093927cfe99adbb8b562a712db8e15d1b77c82
Message:

Moved some other scripts from misc to utils and Orange imports and canvas not works, although not systematically tested.

Files:
17 edited
1 copied
5 moved

Legend:

Unmodified
Added
Removed

  • Orange/OrangeCanvas/orngCanvas.pyw

    r10489 r10581  
    55# This module has to be imported first because it takes care of the system PATH variable 
    66# Namely, it throws out the MikTeX directories which contain an incompatible Qt .dll's 
    7 import orngEnviron, Orange.misc.addons 
     7import orngEnviron, Orange.utils.addons 
    88 
    99from PyQt4.QtCore import * 
    … …  
    225225            orngTabs.constructCategoriesPopup(self) 
    226226            self.createWidgetsToolbar() 
    227         Orange.misc.addons.addon_refresh_callback.append(addOnRefreshCallback) 
     227        Orange.utils.addons.addon_refresh_callback.append(addOnRefreshCallback) 
    228228 
    229229        # create menu 
    … …  
    851851                anyFailed = False 
    852852                anyDone = False 
    853                 for r in Orange.misc.addons.available_repositories: 
     853                for r in Orange.utils.addons.available_repositories: 
    854854                    #TODO: # Should show some progress (and enable cancellation) 
    855855                    try: 
    … …  
    873873                    addOn.uninstall(refresh=False) 
    874874                    if id in dlg.addOnsToAdd.items(): 
    875                         Orange.misc.addons.install_addon_from_repo(dlg.addOnsToAdd[id], global_install=False, refresh=False) 
     875                        Orange.utils.addons.install_addon_from_repo(dlg.addOnsToAdd[id], global_install=False, refresh=False) 
    876876                        del dlg.addOnsToAdd[id] 
    877877                except Exception, e: 
    … …  
    880880                if id.startswith("registered:"): 
    881881                    try: 
    882                         Orange.misc.addons.register_addon(addOn.name, addOn.directory, refresh=False, systemwide=False) 
     882                        Orange.utils.addons.register_addon(addOn.name, addOn.directory, refresh=False, systemwide=False) 
    883883                    except Exception, e: 
    884884                        print "Problem registering add-on %s: %s" % (addOn.name, e) 
    885885                else: 
    886886                    try: 
    887                         Orange.misc.addons.install_addon_from_repo(dlg.addOnsToAdd[id], global_install=False, refresh=False) 
     887                        Orange.utils.addons.install_addon_from_repo(dlg.addOnsToAdd[id], global_install=False, refresh=False) 
    888888                    except Exception, e: 
    889889                        print "Problem installing add-on %s: %s" % (addOn.name, e) 
    890890            if len(dlg.addOnsToAdd)+len(dlg.addOnsToRemove)>0: 
    891                 Orange.misc.addons.refresh_addons(reload_path=True) 
     891                Orange.utils.addons.refresh_addons(reload_path=True) 
    892892                 
    893893    def menuItemShowStatusBar(self): 

  • Orange/OrangeCanvas/orngDlgs.py

    r10560 r10581  
    800800        self.addOnsToAdd = {} 
    801801        self.addOnsToRemove = {} 
    802         import Orange.misc.addons 
    803         self.repositories = [repo.clone() for repo in Orange.misc.addons.available_repositories] 
     802        import Orange.utils.addons 
     803        self.repositories = [repo.clone() for repo in Orange.utils.addons.available_repositories] 
    804804         
    805805        # Bottom info pane 
    … …  
    887887     
    888888    def accept(self): 
    889         import Orange.misc.addons 
     889        import Orange.utils.addons 
    890890        if len(self.addOnsToAdd) + len(self.addOnsToRemove) > 0: 
    891891            summary = AddOnManagerSummary(self.addOnsToAdd, self.addOnsToRemove, self) 
    892892            if summary.exec_() == QDialog.Rejected: 
    893893                return 
    894         Orange.misc.addons.available_repositories = self.repositories 
    895         Orange.misc.addons.save_repositories() 
     894        Orange.utils.addons.available_repositories = self.repositories 
     895        Orange.utils.addons.save_repositories() 
    896896        QDialog.accept(self) 
    897897         
    … …  
    899899        dlg = AddOnRepositoryData() 
    900900        while dlg.exec_() == QDialog.Accepted: 
    901             import Orange.misc.addons 
     901            import Orange.utils.addons 
    902902            try: 
    903                 repo = Orange.misc.addons.OrangeAddOnRepository(dlg.name, dlg.url)   #TODO: This can take some time - inform the user! 
     903                repo = Orange.utils.addons.OrangeAddOnRepository(dlg.name, dlg.url)   #TODO: This can take some time - inform the user! 
    904904                self.repositories.append(repo) 
    905905            except Exception, e: 
    … …  
    916916        dlg = AddOnRepositoryData(name=repo.name, url=repo.url) 
    917917        while dlg.exec_() == QDialog.Accepted: 
    918             import Orange.misc.addons 
     918            import Orange.utils.addons 
    919919            try: 
    920920                oldname, oldurl = repo.name, repo.url 
    … …  
    934934            return 
    935935        # Is it a default repository? We cannot delete it! 
    936         import Orange.misc.addons 
    937         if repo.__class__ is Orange.misc.addons.OrangeDefaultAddOnRepository: 
     936        import Orange.utils.addons 
     937        if repo.__class__ is Orange.utils.addons.OrangeDefaultAddOnRepository: 
    938938            return 
    939939         
    … …  
    970970    def upgradeCandidates(self): 
    971971        result = [] 
    972         import orngEnviron, Orange.misc.addons 
     972        import orngEnviron, Orange.utils.addons 
    973973        for item in self.tree.addOnItems: 
    974974            id = item.newest.id 
    975975            if id.startswith("registered:"): continue 
    976             installedAo = Orange.misc.addons.installed_addons[id] if id in Orange.misc.addons.installed_addons else None 
     976            installedAo = Orange.utils.addons.installed_addons[id] if id in Orange.utils.addons.installed_addons else None 
    977977            installed = installedAo.version if installedAo else None  
    978978            selected = self.addOnsToAdd[id].version if id in self.addOnsToAdd else None 
    … …  
    997997        if not newAddOn: 
    998998            return 
    999         import Orange.misc.addons 
    1000         self.addOnsToRemove[newAddOn.id] = Orange.misc.addons.installed_addons[newAddOn.id] 
     999        import Orange.utils.addons 
     1000        self.addOnsToRemove[newAddOn.id] = Orange.utils.addons.installed_addons[newAddOn.id] 
    10011001        self.addOnsToAdd[newAddOn.id] = newAddOn 
    10021002        if refresh: 
    … …  
    10111011            if os.path.exists(os.path.join(dir, "widgets")): 
    10121012                name = os.path.split(dir)[1] 
    1013                 import Orange.misc.addons 
     1013                import Orange.utils.addons 
    10141014                id = "registered:"+dir 
    1015                 self.addOnsToAdd[id] = Orange.misc.addons.OrangeRegisteredAddOn(name, dir, systemwide=False) 
     1015                self.addOnsToAdd[id] = Orange.utils.addons.OrangeRegisteredAddOn(name, dir, systemwide=False) 
    10161016                self.refreshView(id) 
    10171017            else: 
    … …  
    10281028        addOn = self.getAddOnFromItem(self.tree.currentItem()) 
    10291029        if not addOn: return 
    1030         import Orange.misc.addons 
    1031         if addOn.__class__ is not Orange.misc.addons.OrangeAddOnInRepo: return 
     1030        import Orange.utils.addons 
     1031        if addOn.__class__ is not Orange.utils.addons.OrangeAddOnInRepo: return 
    10321032        if not addOn.repository.has_web_script: return 
    10331033        self.canvasDlg.helpWindow.open("%s/addOnServer.py/%s/doc/widgets/" % (addOn.repository.url, addOn.filename), modal=True) 
    … …  
    10631063                    self.addOnsToAdd[id] = addOn 
    10641064        else:                                 # Mark for removal (or delete installation request) 
    1065             import Orange.misc.addons, orngEnviron 
    1066             installedAo = Orange.misc.addons.installed_addons[id] if id in Orange.misc.addons.installed_addons else None  
     1065            import Orange.utils.addons, orngEnviron 
     1066            installedAo = Orange.utils.addons.installed_addons[id] if id in Orange.utils.addons.installed_addons else None  
    10671067            if installedAo: 
    10681068                if not installedAo.directory.startswith(orngEnviron.addOnsDirUser): 
    … …  
    10741074                del self.addOnsToAdd[id] 
    10751075            elif id not in self.addOnsToRemove: 
    1076                 import Orange.misc.addons 
    1077                 if id in Orange.misc.addons.installed_addons: 
    1078                     self.addOnsToRemove[id] = Orange.misc.addons.installed_addons[id] 
     1076                import Orange.utils.addons 
     1077                if id in Orange.utils.addons.installed_addons: 
     1078                    self.addOnsToRemove[id] = Orange.utils.addons.installed_addons[id] 
    10791079                elif id.startswith("registered:"): 
    10801080                    self.addOnsToRemove[id] = item.newest 
    … …  
    10851085        if not item: 
    10861086            return None 
    1087         import Orange.misc.addons 
     1087        import Orange.utils.addons 
    10881088        if hasattr(item, "repository"): 
    10891089            return item.repository 
    10901090        else: 
    1091             if item.newest.__class__ is not Orange.misc.addons.OrangeAddOnInRepo: 
     1091            if item.newest.__class__ is not Orange.utils.addons.OrangeAddOnInRepo: 
    10921092                return None 
    10931093            return  item.newest.repository 
    … …  
    11051105        if not item: 
    11061106            item = self.tree.currentItem() 
    1107         import Orange.misc.addons 
     1107        import Orange.utils.addons 
    11081108        if hasattr(item, "newest"): 
    1109             if item.newest.__class__ is not Orange.misc.addons.OrangeRegisteredAddOn: 
     1109            if item.newest.__class__ is not Orange.utils.addons.OrangeRegisteredAddOn: 
    11101110                import orngEnviron 
    11111111                addOn = item.newest 
    … …  
    11131113                self.lblVerAvailValue.setText(addOn.version_str) 
    11141114     
    1115                 addOnInstalled = Orange.misc.addons.installed_addons[addOn.id] if addOn.id in Orange.misc.addons.installed_addons else None 
     1115                addOnInstalled = Orange.utils.addons.installed_addons[addOn.id] if addOn.id in Orange.utils.addons.installed_addons else None 
    11161116                addOnToInstall = self.addOnsToAdd[addOn.id] if addOn.id in self.addOnsToAdd else None 
    11171117                addOnToRemove = self.addOnsToRemove[addOn.id] if addOn.id in self.addOnsToRemove else None 
    … …  
    11211121                self.donotUpgradeButton.setVisible(addOn.id in self.addOnsToRemove and addOnToInstall==addOn) 
    11221122                self.webButton.setVisible(addOn.homepage != None) 
    1123                 self.listWidgetsButton.setVisible(len(addOn.widgets) > 0 and addOn.__class__ is Orange.misc.addons.OrangeAddOnInRepo and addOn.repository.has_web_script) 
     1123                self.listWidgetsButton.setVisible(len(addOn.widgets) > 0 and addOn.__class__ is Orange.utils.addons.OrangeAddOnInRepo and addOn.repository.has_web_script) 
    11241124                 
    11251125                if addOnToInstall: 
    … …  
    11411141    def enableDisableButtons(self): 
    11421142        repo = self.getRepoFromItem(self.tree.currentItem()) 
    1143         import Orange.misc.addons 
    1144         self.delRepoButton.setEnabled(repo.__class__ is not Orange.misc.addons.OrangeDefaultAddOnRepository if repo!=None else False) 
    1145         self.editRepoButton.setEnabled(repo.__class__ is not Orange.misc.addons.OrangeDefaultAddOnRepository if repo!=None else False) 
     1143        import Orange.utils.addons 
     1144        self.delRepoButton.setEnabled(repo.__class__ is not Orange.utils.addons.OrangeDefaultAddOnRepository if repo!=None else False) 
     1145        self.editRepoButton.setEnabled(repo.__class__ is not Orange.utils.addons.OrangeDefaultAddOnRepository if repo!=None else False) 
    11461146        self.upgradeAllButton.setEnabled(self.upgradeCandidates() != []) 
    11471147         
    … …  
    11541154     
    11551155    def resetChecked(self, id): 
    1156         import Orange.misc.addons 
    1157         value = id in Orange.misc.addons.installed_addons or id.startswith("registered:") 
     1156        import Orange.utils.addons 
     1157        value = id in Orange.utils.addons.installed_addons or id.startswith("registered:") 
    11581158        value = value and id not in self.addOnsToRemove 
    11591159        value = value or id in self.addOnsToAdd 
    … …  
    11861186        # Installed first 
    11871187        if self.sortInstalledFirst and len(addOnList)>0 and "id" in addOnList[0][0].__dict__: 
    1188             import Orange.misc.addons 
    1189             addOnList = [(n, v) for (n, v) in addOnList if     n.id in Orange.misc.addons.installed_addons] \ 
    1190                       + [(n, v) for (n, v) in addOnList if not n.id in Orange.misc.addons.installed_addons] 
     1188            import Orange.utils.addons 
     1189            addOnList = [(n, v) for (n, v) in addOnList if     n.id in Orange.utils.addons.installed_addons] \ 
     1190                      + [(n, v) for (n, v) in addOnList if not n.id in Orange.utils.addons.installed_addons] 
    11911191         
    11921192        for (i, (newest, versions)) in enumerate(addOnList): 
    … …  
    12751275        # Add add-ons that are not present in any repository 
    12761276        if self.searchStr.strip() == "":   # but we do not need to search among installed add-ons 
    1277             import Orange.misc.addons 
     1277            import Orange.utils.addons 
    12781278            onlyInstalledAddOns = {} 
    1279             for addOn in Orange.misc.addons.installed_addons.values(): 
     1279            for addOn in Orange.utils.addons.installed_addons.values(): 
    12801280                if addOn.id not in shownAddOns: 
    12811281                    onlyInstalledAddOns[addOn.id] = [addOn] 
    … …  
    12831283             
    12841284        # Registered Add-ons 
    1285         if Orange.misc.addons.registered_addons != [] or any([id.startswith("registered:") for id in self.addOnsToAdd]): 
     1285        if Orange.utils.addons.registered_addons != [] or any([id.startswith("registered:") for id in self.addOnsToAdd]): 
    12861286            regiItem = QTreeWidgetItem(self.tree) 
    12871287            regiItem.repository = None 
    … …  
    12951295            addOnsToAdd = [] 
    12961296            import re 
    1297             words = [word for word in re.split(Orange.misc.addons.index_re, self.searchStr.lower()) if word!=""] 
    1298             visibleAddOns = [ao for ao in Orange.misc.addons.registered_addons+[ao for ao in self.addOnsToAdd.values() if ao.id.startswith("registered:")] if all([word in ao.name for word in words])] 
     1297            words = [word for word in re.split(Orange.utils.addons.index_re, self.searchStr.lower()) if word!=""] 
     1298            visibleAddOns = [ao for ao in Orange.utils.addons.registered_addons+[ao for ao in self.addOnsToAdd.values() if ao.id.startswith("registered:")] if all([word in ao.name for word in words])] 
    12991299            self.addAddOnsToTree(regiItem, visibleAddOns) 
    13001300            if selectedRegisteredAddOnId: 
    … …  
    14321432class saveApplicationDlg(QDialog): 
    14331433    def __init__(self, *args): 
    1434         import Orange.misc.addons 
     1434        import Orange.utils.addons 
    14351435         
    14361436        apply(QDialog.__init__,(self,) + args) 

  • Orange/OrangeCanvas/orngRegistry.py

    r10453 r10581  
    1212    sys.path.append(orangeDir) 
    1313 
    14 import orngEnviron, Orange.misc.addons 
     14import orngEnviron, Orange.utils.addons 
    1515 
    1616class WidgetDescription: 
    … …  
    7373             
    7474    # read list of add-ons 
    75     for addOn in Orange.misc.addons.installed_addons.values() + Orange.misc.addons.registered_addons: 
     75    for addOn in Orange.utils.addons.installed_addons.values() + Orange.utils.addons.registered_addons: 
    7676        addOnWidgetsDir = os.path.join(addOn.directory, "widgets") 
    7777        if os.path.isdir(addOnWidgetsDir): 

  • Orange/__init__.py

    r10580 r10581  
    125125 
    126126_import("misc") 
    127 _import("misc.counters") 
    128 _import("misc.addons") 
    129 _import("misc.render") 
    130127_import("misc.selection") 
    131 _import("misc.serverfiles") 
    132128#_import("misc.r") 
    133129 
    134130_import("utils") #TODO hide utils from the user 
    135131_import("utils.environ") 
    136  
     132_import("utils.counters") 
     133_import("utils.addons") 
     134_import("utils.render") 
     135_import("utils.serverfiles") 
     136# 
    137137try: 
    138138    from . import version 

  • Orange/classification/lookup.py

    r10580 r10581  
    3030    lookup = lookup_from_bound(class_var, bound) 
    3131    if lookup: 
    32         for i, attrs in enumerate(Orange.misc.counters.LimitedCounter( 
     32        for i, attrs in enumerate(Orange.utils.counters.LimitedCounter( 
    3333                    [len(var.values) for var in bound])): 
    3434            lookup.lookup_table[i] = Orange.data.Value(class_var, function(attrs)) 
    … …  
    3737        dom = Orange.data.Domain(bound, class_var) 
    3838        data = Orange.data.Table(dom) 
    39         for attrs in Orange.misc.counters.LimitedCounter( 
     39        for attrs in Orange.utils.counters.LimitedCounter( 
    4040                    [len(var.values) for var in dom.features]): 
    4141            data.append(Orange.data.Example(dom, attrs + [function(attrs)])) 
    … …  
    8989        lc = 0 
    9090        if len(boundset)==1: 
    91             cnt = Orange.misc.counters.LimitedCounter([len(x.values)+1 for x in boundset]) 
     91            cnt = Orange.utils.counters.LimitedCounter([len(x.values)+1 for x in boundset]) 
    9292        else: 
    93             cnt = Orange.misc.counters.LimitedCounter([len(x.values) for x in boundset]) 
     93            cnt = Orange.utils.counters.LimitedCounter([len(x.values) for x in boundset]) 
    9494        for ex in cnt: 
    9595            for i in range(len(ex)): 

  • Orange/classification/svm/__init__.py

    r10580 r10581  
    2222from Orange import feature as variable 
    2323 
    24 from Orange.misc import _orange__new__ 
     24from Orange.utils import _orange__new__ 
    2525 
    2626def max_nu(data): 

  • Orange/clustering/hierarchical.py

    r10580 r10581  
    977977         
    978978""" 
    979 Dendrogram ploting using Orange.misc.render 
     979Dendrogram ploting using Orange.utils.render 
    980980""" 
    981981 
    982 from Orange.misc.render import EPSRenderer, ColorPalette 
     982from Orange.utils.render import EPSRenderer, ColorPalette 
    983983 
    984984class DendrogramPlot(object): 
    … …  
    11891189    """ 
    11901190    import os 
    1191     from Orange.misc.render import PILRenderer, EPSRenderer, SVGRenderer 
     1191    from Orange.utils.render import PILRenderer, EPSRenderer, SVGRenderer 
    11921192    if isinstance(file, basestring): 
    11931193        name, ext = os.path.splitext(file) 

  • Orange/data/io.py

    r10580 r10581  
    893893from ConfigParser import SafeConfigParser 
    894894 
    895 @Orange.misc.lru_cache(maxsize=1) 
     895@Orange.utils.lru_cache(maxsize=1) 
    896896def persistent_search_paths(): 
    897897    """ Return a list of persistent registered (prefix, path) pairs 

  • Orange/data/preprocess/__init__.py

    r10542 r10581  
    9797import Orange.feature.discretization 
    9898import Orange.feature.scoring 
    99 from Orange.misc import _orange__new__, _orange__reduce__ 
     99from Orange.utils import _orange__new__, _orange__reduce__ 
    100100 
    101101class DiscretizeEntropy(Discretize): 

  • Orange/ensemble/forest.py

    r10580 r10581  
    3434    split is  (on average) as specified.""" 
    3535 
    36     __new__ = Orange.misc._orange__new__(Orange.core.Learner) 
     36    __new__ = Orange.utils._orange__new__(Orange.core.Learner) 
    3737 
    3838    def __init__(self, base=None, rand=None): #pickle needs an empty init 
    … …  
    102102    """ 
    103103 
    104     __new__ = Orange.misc._orange__new__(Orange.core.Learner) 
     104    __new__ = Orange.utils._orange__new__(Orange.core.Learner) 
    105105 
    106106    def __init__(self, trees=100, attributes=None,\ 
    … …  
    119119        if not self.rand: 
    120120            self.rand = random.Random(0) 
    121         self.randorange = Orange.misc.Random(self.rand.randint(0,2**31-1)) 
     121        self.randorange = Orange.utils.Random(self.rand.randint(0,2**31-1)) 
    122122 
    123123        if learner == None: 
    … …  
    313313        if not self.rand: 
    314314            self.rand = random.Random(0) 
    315         self.randorange = Orange.misc.Random(self.rand.randint(0,2**31-1)) 
     315        self.randorange = Orange.utils.Random(self.rand.randint(0,2**31-1)) 
    316316 
    317317        if learner == None: 
    … …  
    477477    """ 
    478478 
    479     __new__ = Orange.misc._orange__new__(Orange.core.Learner) 
     479    __new__ = Orange.utils._orange__new__(Orange.core.Learner) 
    480480      
    481481    def __init__(self, base, rand): 

  • Orange/evaluation/testing.py

    r10580 r10581  
    22 
    33import Orange 
    4 from Orange.misc import demangle_examples, getobjectname 
     4from Orange.utils import demangle_examples, getobjectname 
    55from Orange.utils import deprecated_keywords, deprecated_members 
    66 

  • Orange/fixes/fix_changed_names.py

    r10580 r10581  
    418418           "orngMisc.compare2_smaller":"Orange.misc.selection.compare_smaller", 
    419419 
    420            "orngMisc.Renderer": "Orange.misc.render.Renderer", 
    421            "orngMisc.EPSRenderer": "Orange.misc.render.EPSRenderer", 
    422            "orngMisc.SVGRenderer": "Orange.misc.render.SVGRenderer", 
    423            "orngMisc.PILRenderer": "Orange.misc.render.PILRenderer", 
     420           "orngMisc.Renderer": "Orange.utils.render.Renderer", 
     421           "orngMisc.EPSRenderer": "Orange.utils.render.EPSRenderer", 
     422           "orngMisc.SVGRenderer": "Orange.utils.render.SVGRenderer", 
     423           "orngMisc.PILRenderer": "Orange.utils.render.PILRenderer", 
    424424           # The rest of orngMisc is handled by fix_orange_imports (maps to Orange.misc)  
    425425 

  • Orange/misc/__init__.py

    r10580 r10581  
    334334---------------- 
    335335 
    336 .. automodule:: Orange.misc.counters 
    337   :members: 
    338  
    339 .. automodule:: Orange.misc.render 
    340   :members: 
    341  
    342336.. automodule:: Orange.misc.selection 
    343337 
    344 .. automodule:: Orange.misc.addons 
    345  
    346 .. automodule:: Orange.misc.serverfiles 
    347  
    348338""" 
    349 import counters 
    350 import render 
    351339from functools import wraps 
    352340from Orange.core import RandomGenerator as Random 
    … …  
    354342from Orange.core import CostMatrix 
    355343 
    356 # addons is intentionally not imported; if it were, add-ons' directories would 
    357 # be added to the python path. If that sounds OK, this can be changed ... 
    358  
    359 __all__ = ["counters", "selection", "render", "serverfiles" ] 
    360  
    361 import random, types, sys 
    362 import time 
    363  
    364 def getobjectname(x, default=""): 
    365     if type(x)==types.StringType: 
    366         return x 
    367        
    368     for i in ["name", "shortDescription", "description", "func_doc", "func_name"]: 
    369         if getattr(x, i, ""): 
    370             return getattr(x, i) 
    371  
    372     if hasattr(x, "__class__"): 
    373         r = repr(x.__class__) 
    374         if r[1:5]=="type": 
    375             return str(x.__class__)[7:-2] 
    376         elif r[1:6]=="class": 
    377             return str(x.__class__)[8:-2] 
    378     return default 
    379  
    380  
    381 def demangle_examples(x): 
    382     if type(x)==types.TupleType: 
    383         return x 
    384     else: 
    385         return x, 0 
    386  
    387 def frange(*argw): 
    388     """ Like builtin `range` but works with floats 
    389     """ 
    390     start, stop, step = 0.0, 1.0, 0.1 
    391     if len(argw)==1: 
    392         start=step=argw[0] 
    393     elif len(argw)==2: 
    394         stop, step = argw 
    395     elif len(argw)==3: 
    396         start, stop, step = argw 
    397     elif len(argw)>3: 
    398         raise AttributeError, "1-3 arguments expected" 
    399  
    400     stop+=1e-10 
    401     i=0 
    402     res=[] 
    403     while 1: 
    404         f=start+i*step 
    405         if f>stop: 
    406             break 
    407         res.append(f) 
    408         i+=1 
    409     return res 
    410  
    411 verbose = 0 
    412  
    413 def print_verbose(text, *verb): 
    414     if len(verb) and verb[0] or verbose: 
    415         print text 
    416  
    417 def lru_cache(maxsize=100): 
    418     """ A least recently used cache function decorator. 
    419     (Similar to the functools.lru_cache in python 3.2) 
    420     """ 
    421      
    422     def decorating_function(func): 
    423         import functools 
    424         cache = {} 
    425          
    426         @functools.wraps(func) 
    427         def wrapped(*args, **kwargs): 
    428             key = args + tuple(sorted(kwargs.items())) 
    429             if key not in cache: 
    430                 res = func(*args, **kwargs) 
    431                 cache[key] = (time.time(), res) 
    432                 if len(cache) > maxsize: 
    433                     key, (_, _) = min(cache.iteritems(), key=lambda item: item[1][0]) 
    434                     del cache[key] 
    435             else: 
    436                 _, res = cache[key] 
    437                 cache[key] = (time.time(), res) # update the time 
    438                  
    439             return res 
    440          
    441         def clear(): 
    442             cache.clear() 
    443          
    444         wrapped.clear = clear 
    445         wrapped._cache = cache 
    446          
    447         return wrapped 
    448     return decorating_function 
    449  
    450 #from Orange.misc.render import contextmanager 
    451 from contextlib import contextmanager 
    452  
    453 @contextmanager 
    454 def member_set(obj, name, val): 
    455     """ A context manager that sets member ``name`` on ``obj`` to ``val`` 
    456     and restores the previous value on exit.  
    457     """ 
    458     old_val = getattr(obj, name, val) 
    459     setattr(obj, name, val) 
    460     yield 
    461     setattr(obj, name, old_val) 
    462      
    463      
    464 class recursion_limit(object): 
    465     """ A context manager that sets a new recursion limit.  
    466      
    467     """ 
    468     def __init__(self, limit=1000): 
    469         self.limit = limit 
    470          
    471     def __enter__(self): 
    472         self.old_limit = sys.getrecursionlimit() 
    473         sys.setrecursionlimit(self.limit) 
    474      
    475     def __exit__(self, exc_type, exc_val, exc_tb): 
    476         sys.setrecursionlimit(self.old_limit) 
    477          
    478 """ 
    479 Some utility functions common to Orange classes. 
    480   
    481 """ 
    482  
    483 def _orange__new__(base=None): 
    484     """ Return an orange 'schizofrenic' __new__ class method. 
    485      
    486     :param base: base orange class (default orange.Learner) 
    487     :type base: type 
    488           
    489     Example:: 
    490         class NewOrangeLearner(orange.Learner): 
    491             __new__ = _orange__new(orange.Learner) 
    492          
    493     """ 
    494     if base is None: 
    495         import Orange 
    496         base = Orange.core.Learner 
    497          
    498     @wraps(base.__new__) 
    499     def _orange__new_wrapped(cls, data=None, **kwargs): 
    500         if base == object: 
    501             self = base.__new__(cls) 
    502         else: 
    503             self = base.__new__(cls, **kwargs) 
    504  
    505         if data: 
    506             self.__init__(**kwargs) 
    507             return self.__call__(data) 
    508         else: 
    509             return self 
    510     return _orange__new_wrapped 
    511  
    512  
    513 def _orange__reduce__(self): 
    514     """ A default __reduce__ method for orange types. Assumes the object 
    515     can be reconstructed with the call `constructor(__dict__)` where __dict__ 
    516     if the stored (pickled) __dict__ attribute. 
    517      
    518     Example:: 
    519         class NewOrangeType(orange.Learner): 
    520             __reduce__ = _orange__reduce() 
    521     """  
    522     return type(self), (), dict(self.__dict__) 
    523  
    524 from Orange.utils import deprecated_function_name 
    525  
    526 demangleExamples = deprecated_function_name(demangle_examples) 
    527 printVerbose = deprecated_function_name(print_verbose) 
    528  
     344__all__ = ["selection" ] 
    529345# Must be imported after deprecation function definitions 
    530346import selection 

  • Orange/orng/addOnPack.py

    r9671 r10581  
    66import OWGUI 
    77 
    8 import Orange.misc.addons 
     8import Orange.utils.addons 
    99 
    1010 
    … …  
    3939        p = OWGUI.widgetBox(page, "Select a registered add-on to pack", orientation="horizontal") 
    4040        self.aolist = OWGUI.listBox(p, self, callback=self.list_selection_callback) 
    41         self.registered_addons = Orange.misc.addons.registered_addons 
     41        self.registered_addons = Orange.utils.addons.registered_addons 
    4242        for ao in self.registered_addons: 
    4343            self.aolist.addItem(ao.name) 
    … …  
    163163        xml = os.path.join(self.directory, "addon.xml") 
    164164        if os.path.isfile(xml): 
    165             self.ao = Orange.misc.addons.OrangeAddOn(xmlfile=open(xml, 'r')) 
     165            self.ao = Orange.utils.addons.OrangeAddOn(xmlfile=open(xml, 'r')) 
    166166        else: 
    167             self.ao = Orange.misc.addons.OrangeAddOn() 
     167            self.ao = Orange.utils.addons.OrangeAddOn() 
    168168        denone = lambda x: x if x else ""  
    169169        self.e_id.setText(self.ao.id if self.ao.id else str(uuid.uuid1())) 
    170170        self.e_name.setText(self.ao.name or os.path.split(self.directory)[1]) 
    171         self.e_version.setText(Orange.misc.addons.suggest_version(self.ao.version_str)) 
     171        self.e_version.setText(Orange.utils.addons.suggest_version(self.ao.version_str)) 
    172172        self.e_description.setPlainText(denone(self.ao.description)) 
    173173        self.e_preferreddir.setText(denone(self.ao.preferred_directory)) 
    … …  
    213213         
    214214    def accept(self): 
    215         rao = Orange.misc.addons.OrangeRegisteredAddOn(self.ao.name, self.directory) 
     215        rao = Orange.utils.addons.OrangeRegisteredAddOn(self.ao.name, self.directory) 
    216216        rao.prepare(self.ao.id, self.ao.name, str(self.e_version.text()), unicode(self.e_description.toPlainText()), self.e_tags.parseEntries(), 
    217217                    self.e_aorganizations.parseEntries(), self.e_aauthors.parseEntries(), self.e_acontributors.parseEntries(), self.preferredDir, 

  • Orange/utils/__init__.py

    r10580 r10581  
    2929---------------- 
    3030 
    31 ..automodule:: Orange.utils.environ 
     31.. automodule:: Orange.utils.environ 
     32 
     33.. automodule:: Orange.utils.counters 
     34  :members: 
     35 
     36.. automodule:: Orange.utils.render 
     37  :members: 
     38 
     39.. automodule:: Orange.utils.addons 
    3240 
    3341""" 
    3442 
    35 """ 
    3643__all__ = ["deprecated_members", "deprecated_keywords", 
    3744           "deprecated_attribute", "deprecation_warning", 
    38            "deprecated_function_name"] 
    39 """ 
     45           "deprecated_function_name", 
     46           "counters", "render", "serverfiles"] 
    4047 
    4148import environ 
    … …  
    422429 
    423430progressBarMilestones = deprecated_function_name(progress_bar_milestones) 
     431 
     432import random, types, sys 
     433import time 
     434 
     435def getobjectname(x, default=""): 
     436    if type(x)==types.StringType: 
     437        return x 
     438       
     439    for i in ["name", "shortDescription", "description", "func_doc", "func_name"]: 
     440        if getattr(x, i, ""): 
     441            return getattr(x, i) 
     442 
     443    if hasattr(x, "__class__"): 
     444        r = repr(x.__class__) 
     445        if r[1:5]=="type": 
     446            return str(x.__class__)[7:-2] 
     447        elif r[1:6]=="class": 
     448            return str(x.__class__)[8:-2] 
     449    return default 
     450 
     451 
     452def demangle_examples(x): 
     453    if type(x)==types.TupleType: 
     454        return x 
     455    else: 
     456        return x, 0 
     457 
     458def frange(*argw): 
     459    """ Like builtin `range` but works with floats 
     460    """ 
     461    start, stop, step = 0.0, 1.0, 0.1 
     462    if len(argw)==1: 
     463        start=step=argw[0] 
     464    elif len(argw)==2: 
     465        stop, step = argw 
     466    elif len(argw)==3: 
     467        start, stop, step = argw 
     468    elif len(argw)>3: 
     469        raise AttributeError, "1-3 arguments expected" 
     470 
     471    stop+=1e-10 
     472    i=0 
     473    res=[] 
     474    while 1: 
     475        f=start+i*step 
     476        if f>stop: 
     477            break 
     478        res.append(f) 
     479        i+=1 
     480    return res 
     481 
     482verbose = 0 
     483 
     484def print_verbose(text, *verb): 
     485    if len(verb) and verb[0] or verbose: 
     486        print text 
     487 
     488def lru_cache(maxsize=100): 
     489    """ A least recently used cache function decorator. 
     490    (Similar to the functools.lru_cache in python 3.2) 
     491    """ 
     492     
     493    def decorating_function(func): 
     494        import functools 
     495        cache = {} 
     496         
     497        @functools.wraps(func) 
     498        def wrapped(*args, **kwargs): 
     499            key = args + tuple(sorted(kwargs.items())) 
     500            if key not in cache: 
     501                res = func(*args, **kwargs) 
     502                cache[key] = (time.time(), res) 
     503                if len(cache) > maxsize: 
     504                    key, (_, _) = min(cache.iteritems(), key=lambda item: item[1][0]) 
     505                    del cache[key] 
     506            else: 
     507                _, res = cache[key] 
     508                cache[key] = (time.time(), res) # update the time 
     509                 
     510            return res 
     511         
     512        def clear(): 
     513            cache.clear() 
     514         
     515        wrapped.clear = clear 
     516        wrapped._cache = cache 
     517         
     518        return wrapped 
     519    return decorating_function 
     520 
     521#from Orange.misc.render import contextmanager 
     522from contextlib import contextmanager 
     523 
     524@contextmanager 
     525def member_set(obj, name, val): 
     526    """ A context manager that sets member ``name`` on ``obj`` to ``val`` 
     527    and restores the previous value on exit.  
     528    """ 
     529    old_val = getattr(obj, name, val) 
     530    setattr(obj, name, val) 
     531    yield 
     532    setattr(obj, name, old_val) 
     533     
     534     
     535class recursion_limit(object): 
     536    """ A context manager that sets a new recursion limit.  
     537     
     538    """ 
     539    def __init__(self, limit=1000): 
     540        self.limit = limit 
     541         
     542    def __enter__(self): 
     543        self.old_limit = sys.getrecursionlimit() 
     544        sys.setrecursionlimit(self.limit) 
     545     
     546    def __exit__(self, exc_type, exc_val, exc_tb): 
     547        sys.setrecursionlimit(self.old_limit) 
     548         
     549""" 
     550Some utility functions common to Orange classes. 
     551  
     552""" 
     553 
     554def _orange__new__(base=None): 
     555    """ Return an orange 'schizofrenic' __new__ class method. 
     556     
     557    :param base: base orange class (default orange.Learner) 
     558    :type base: type 
     559          
     560    Example:: 
     561        class NewOrangeLearner(orange.Learner): 
     562            __new__ = _orange__new(orange.Learner) 
     563         
     564    """ 
     565    if base is None: 
     566        import Orange 
     567        base = Orange.core.Learner 
     568         
     569    @wraps(base.__new__) 
     570    def _orange__new_wrapped(cls, data=None, **kwargs): 
     571        if base == object: 
     572            self = base.__new__(cls) 
     573        else: 
     574            self = base.__new__(cls, **kwargs) 
     575 
     576        if data: 
     577            self.__init__(**kwargs) 
     578            return self.__call__(data) 
     579        else: 
     580            return self 
     581    return _orange__new_wrapped 
     582 
     583 
     584def _orange__reduce__(self): 
     585    """ A default __reduce__ method for orange types. Assumes the object 
     586    can be reconstructed with the call `constructor(__dict__)` where __dict__ 
     587    if the stored (pickled) __dict__ attribute. 
     588     
     589    Example:: 
     590        class NewOrangeType(orange.Learner): 
     591            __reduce__ = _orange__reduce() 
     592    """  
     593    return type(self), (), dict(self.__dict__) 
     594 
     595demangleExamples = deprecated_function_name(demangle_examples) 
     596printVerbose = deprecated_function_name(print_verbose) 
     597 

  • Orange/utils/addons.py

    r10580 r10581  
    66.. index:: add-ons 
    77 
    8 Orange.misc.addons module provides a framework for Orange add-on management. As 
     8Orange.utils.addons module provides a framework for Orange add-on management. As 
    99soon as it is imported, the following initialization takes place: the list of 
    1010installed add-ons is loaded, their directories are added to python path 
    … …  
    270270            it exists and does the same as "auto" otherwise; "auto" generates a 
    271271            new version number from the current date in format 'yyyy.mm.dd' 
    272             (see :obj:`Orange.misc.addons.suggest_version`); if that is equal 
     272            (see :obj:`Orange.utils.addons.suggest_version`); if that is equal 
    273273            to the current version, another integer component is appended. 
    274274        :type version: str 

  • docs/reference/rst/Orange.utils.rst

    r9372 r10581  
    1 ######################## 
    2 Miscellaneous (``misc``) 
    3 ######################## 
     1############################### 
     2Developer utilities (``utils``) 
     3############################### 
    44 
    5 .. automodule:: Orange.misc 
     5.. automodule:: Orange.utils 

  • docs/reference/rst/index.rst

    r10554 r10581  
    3838   Orange.misc 
    3939 
     40   Orange.utils 
     41 
    4042**************** 
    4143Index and search 

  • install-scripts/addon-pack/prepare-and-pack.py

    r9093 r10581  
    44sys.path += ["/root/orange"] 
    55 
    6 import Orange.misc.addons 
    7 rao = Orange.misc.addons.OrangeRegisteredAddOn(None, sys.argv[1]) 
     6import Orange.utils.addons 
     7rao = Orange.utils.addons.OrangeRegisteredAddOn(None, sys.argv[1]) 
    88rao.prepare(None, None, None, None, None, None, None, None, None, None) 
    99 
Note: See TracChangeset for help on using the changeset viewer.