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