path: root/src/util.py

#!/usr/bin/env python3
'''
xpybar – xmobar replacement written in python
Copyright © 2014, 2015  Mattias Andrée (maandree@member.fsf.org)

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
'''
import sys
import time
import threading
import subprocess


def async(target, name = None, group = None):
    '''
    Start a function asynchronously
    
    @param   target:()→void  The function
    @param   name:str?       The name of the thread
    @return  :Thread         A running deamon-thread running `target`, with the name `name`
    '''
    t = threading.Thread(target = target, name = name)
    t.setDaemon(True)
    t.start()
    return t


def watch(interval, target, delay = 0):
    '''
    Run a function periodically forever
    
    @param  interval:float  The number of seconds to sleep between invocatons
    @param  target:()→void  The function
    @param  delay:float     Number of extra seconds to wait the first time
    '''
    if not delay == 0:
        time.sleep(delay)
    while True:
        target()
        time.sleep(interval)


def forever(target, delay = 0):
    '''
    Run a function continuously forever
    
    @param  target:()→void  The function
    @param  delay:float     Number of extra seconds to wait the first time
    '''
    if not delay == 0:
        time.sleep(delay)
    while True:
        target()


def spawn(*command):
    '''
    Spawn an external process
    
    @param   command:*str  The command line
    @return  :istream      The process's stdout
    '''
    proc = subprocess.Popen(list(command), stderr = sys.stderr, stdout = subprocess.PIPE)
    return proc.stdout


def spawn_read(*command):
    '''
    Spawn an external process and returns its output
    
    @param   command:*str  The command line
    @return  :str          The process's output to stdout, without the final LF
    '''
    proc = subprocess.Popen(list(command), stderr = sys.stderr, stdout = subprocess.PIPE)
    out = proc.stdout.read().decode('utf-8', 'replace')
    if out.endswith('\n'):
        out = out[:-1]
    return out


def reduce(f, items):
    '''
    https://en.wikipedia.org/wiki/Fold_(higher-order_function)
    
    @param   f:(¿E?, ¿E?)→¿E?  The function
    @param   item:itr<¿E?>     The input
    @return  ¿E??              The output, `None` if `item` is empty
    '''
    if len(items) == 0:
        return None
    rc = items[0]
    for i in range(1, len(items)):
        rc = f(rc, items[i])
    return rc


def colour_aware_len(string, original_len = len):
    '''
    Colour-aware object length measurement function
    
    It is suggested to redefine `len` with this
    function in the following way.
    
        len_ = len
        len = lambda string : colour_aware_len(string, len_)
    
    @param   string:object              The object to measure
    @param   original_len:(object)→int  The original implementation of `len`
    @return  :int                       The length of `string`
    '''
    if not isinstance(string, str):
        return original_len(string)
    rc, esc = 0, False
    for c in string:
        if esc:
            if c == 'm':
                esc = False
        elif c == '\033':
            esc = True
        else:
            rc += 1
    return rc


def sprintf(format, *args):
    '''
    Alternative to the %-operator for strings, with support for '%n'
    
    @param   format:str                    The format string
    @param   args:*object                  The arguments to include in place of
                                           the placeholders in the format string
    @return  :(text:str, stops:list<int>)  The text after formatting, and locations of all '%n':s.
                                           Locations of '%n':s are measured using `len`, meaning that
                                           this function is aware of redefinitions of `len`.
    '''
    rc, measurements, curlen, esc, buf, args, argc = '', [], 0, False, '', tuple(args), 0
    for c in format:
        if esc:
            esc = False
            if c == 'n':
                buf %= args[:argc]
                curlen += len(buf)
                rc += buf
                buf = ''
                args = args[argc:]
                argc = 0
                measurements.append(curlen)
            else:
                buf += '%'
                buf += c
                argc += 1
        elif c == '%':
            esc = True
        else:
            buf += c
    rc += buf % args
    return (rc, measurements)


class Sometimes:
    '''
    Function wrapper for only actually invoking
    the function every n:th time, where n is a
    customisable parameter
    '''
    
    def __init__(self, function, interval, initial = 0):
        '''
        Constructor
        
        @param  function:(*?)→¿R?  The function
        @param  interval:int       Invoke the function every `interval`:th time
        @param  initial:int        The of times needed to invoke before actual invocation
        '''
        self.function = function
        self.interval = interval
        self.counter = initial
        self.last_return = None
    
    def __call__(self, *args, **kwargs):
        '''
        Invoke the function, every `interval`:th time
        
        @param   args:*?     The parameters of the function
        @param   kwargs:**?  The named parameters of the function
        @return  :¿R?        The return value of the function, the last return if not invoked
        '''
        rc = self.last_return
        if self.counter == 0:
            rc = self.function(*args, **kwargs)
            self.last_return = rc
            self.counter = self.interval
        self.counter -= 1
        return rc


class DelayedSometimes:
    '''
    Function wrapper for only actually invoking
    the function every n:th time, where n is a
    customisable parameter, with an added
    functionallity: the actual invocation will
    take place at the first invocation and then
    a number of invocations is required before
    the second actual invocation after which
    the normal interval will be used
    '''
    
    def __init__(self, function, delay, interval):
        '''
        Constructor
        
        @param  function:(*?)→¿R?  The functiony
        @param  delay:int          The of times needed to invoke between the first and second actual invocation
        @param  interval:int       Invoke the function every `interval`:th time
        '''
        def f(*args, **kwargs):
            self.function = Sometimes(function, interval, initial = delay)
            self.function.last_return = function(*args, **kwargs)
            return self.function.last_return
        self.function = f
    
    def __call__(self, *args, **kwargs):
        '''
        Invoke the function when scheduled
        
        @param   args:*?     The parameters of the function
        @param   kwargs:**?  The named parameters of the function
        @return  :¿R?        The return value of the function, the last return if not invoked
        '''
        return self.function(*args, **kwargs)


class Clocked:
    '''
    `Sometimes` wrapper that needs explicit re-evaluation before
    its `Sometimes` functionallity is invoked. That is, it needs
    a selected number of explicit re-evaluation before the value
    is actually re-evaluted.
    
    The rationale for this class is that you may want to update
    somethings more often than other things, periodically, but
    you may also want to update other things when certain events
    occur.
    '''
    
    def __init__(self, *args, **kwargs):
        '''
        Constructor
        
        @param  args:*     Positional arguments for the `Sometimes` constructor
        @param  kwargs:**  Keyworkd arguments for the `Sometimes` constructor
        '''
        self.sometimes = Sometimes(*args, **kwargs)
        self.text = self.sometimes()
    
    
    def __call__(self, update = False):
        '''
        Return the most recently evaluated value
        
        @param   update:bool  Whether to re-evalute the value and return the new value
        @return  :¿T?         The most recently evaluated value
        '''
        if update:
            self.text = self.sometimes()
        return self.text
    
    
    @staticmethod
    def update_all(functions):
        '''
        Update all elements in an iteratable that is of the type `Clocked`
        
        @param  functions:itr<¿T?>  The iteratable
        '''
        for f in functions:
            if isinstance(f, Clocked):
                f(True)