Ignore:
Timestamp:
03/20/12 08:18:01 (2 years 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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 
Note: See TracChangeset for help on using the changeset viewer.