# -*- coding: utf-8 -*- #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # file sfc.py # purpose Skaperen's Function Collection (and other useful stuff) # # legal Copyright © 2018, 2019, by Phil D. Howard - all other rights reserved # license MIT-like, see __license__ below # # usage import sfc -or- from sfc import * # supported Python 3.6 or higher # # note code in this file assumes a text screen width of at least 128 to 135 character columns #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- """Skaperen's Function Collection (and other useful stuff)""" __license__ = """ Copyright © 2018, 2019, by Phil D. Howard - all other rights reserved Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. The author may be contacted by decoding the number 11054987560151472272755686915985840251291393453694611309 (provu igi la numeron al duuma) """ #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- import base64 import decimal import fcntl import inspect import itertools import ipaddress import math import numbers import os import pathlib import socket import struct import subprocess import stat import struct import sys import re import termios import time if sys.version_info.major<3:raise RuntimeError('Python version 2 is not supported') if sys.version_info.minor<5:raise RuntimeError('Python version 3.4 is not supported') from base64 import b64decode,b64encode,b32decode,b32encode,b16decode,b16encode from decimal import Decimal from fcntl import ioctl from inspect import currentframe from itertools import chain from numbers import Number from os import chdir,environ,get_terminal_size,listdir,lstat,path,readlink from pathlib import Path,PurePath from socket import inet_pton,AF_INET,AF_INET6 from stat import S_ISREG,S_ISDIR,S_ISLNK,S_ISCHR,S_ISBLK,S_ISFIFO,S_ISSOCK,S_ISDOOR,S_ISPORT,S_ISWHT from struct import pack,unpack from subprocess import call,DEVNULL,PIPE,Popen,run from sys import argv,stderr,stdin,stdout,version_info from re import sub from termios import TIOCGWINSZ from time import gmtime,localtime,sleep,strftime,time as secs dec = Decimal num = Number #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # Doing this (2 lines): # if 'SFCdebug' not in os.environ: # os.environ['SFCdebug'] = '1' # before importing sfc will enable debugging mode and leave the option to disable it at run time. #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # Determine if debug mode is requested. _debugmode_ = any(eval(environ.get(y,'0'))for x in ('SFCdebug','SFCdebugON','SFCdebugMODE') for y in (x,x.upper(),x.lower())) # Define short ways to express certain grouped types in uses of isinstance(). _bb = bytes,bytearray _lt = list,tuple _ltsf = list,tuple,set,frozenset _ltsfd = list,tuple,set,frozenset,dict _sbb = str,bytes,bytearray _sf = set,frozenset # Set some types. NoneType = type(None) NotImplementedType = type(NotImplemented) EllipsisType = type(Ellipsis) # Define which character is used for decimal point and separator. decpnt = str(Decimal(3)/Decimal(2))[1] decsep = '.' if decpnt is ',' else ',' if decpnt is '.' else ' ' #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- class adict(dict): """Class that is like a dictionary with items usable like attributes. purpose class that is a dictionary with items usable like attributes so code can look like: obj1.foo = obj2.bar instead of like: obj1['foo'] = obj2['bar'] although the latter may also be used on the same objects warning this class can fail in cases where keys have values the same as dictionary methods or standard attributes init usage object = adict(dictionary) object = adict(dictionary,key=value...) object = adict(key=value...) attr usage object.name dict usage object[key] note attribute usage is like string keys that are limited to what can be a valid identifier while dictionary usage can use any hashable value as a key """ def __init__(self,*args,**opts): arn = 0 for arg in args: arn += 1 if isinstance(arg,(adict,dict)): self.update(arg) elif arg and isinstance(arg,_ltsfd): an = -1 for ar in arg: an += 1 if isinstance(ar,_lt) and len(ar)==2: self[ar[0]] = ar[1] else: raise TypeError('not a 2-sequence at ['+str(an)+'] of argument '+str(arn)) else: raise TypeError('argument '+str(arn)+' is not a sequence') if opts: if isinstance(opts,(adict,dict)): self.update(opts) else: raise TypeError('options ('+repr(opts)+') is not a dictionary') def __delattr__(self,key): """Delete any attribute or list of keys.""" if isinstance(key,_ltsfd): for k in key: del self[k] else: del self[key] return self def __getattr__(self,key): """Get any attribute.""" return self[key] def __setattr__(self,key,value): """Set any attribute.""" self[key] = value return self def _copy(self): """Shallow copy.""" return adict(self) def _find(self,*args): """Find a value from a specified key or list (not a tuple) of keys or return default.""" if not isinstance(args[0],list): args[0] = [args[0]] for key in args[0]: if key in self: return self[key] return None if len(args)<2 else args[1] def _sans(self,key): """Copy adict without a specified key or list (not a tuple) of keys.""" d=adict(self) if isinstance(key,list): for k in key: del d[k] else: d=adict(self) del d[key] return d #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def box(text,name=None): """Return text with an ASCII box around it.""" t = [x for x in '\n'.join(text).splitlines()] w = max(len(x) for x in t) if not isinstance(name,str): name = '['+repr(name)+']' if name: name = '<'+name+'>' return ['+-'+name.ljust(w,'-')+'-+']+['| '+x.ljust(w,' ')+' |' for x in t]+['+-'+(w*'-')+'-+'] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def bytes_to_str(b): """Convert bytes to str, transparently.""" # or a list/tuple/set/frozenset/dict of ints if ininstance(b,_ltsfd) and all(isinstance(x,int)for x in b): b = bytes(b) if not isinstance(b,_bb): raise TypeError('Argument 1 is not bytes or bytearray') return ''.join(chr(x) for x in b) b2s = bytes_to_str #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def cd(*args,**opts): """Change the current directory to the specified directory or if none is specified, the user home directory.""" if 'dir' in opts: if 'user' in opts: dir = os.path.expanduser('~'+opts['user']+'/'+opts['dir']) else: dir = os.path.expanduser(opts['dir']) else: if args: if 'user' in opts: dir = os.path.expanduser('~'+opts['user']+'/'+args[0]) else: dir = os.path.expanduser(args[0]) else: if 'user' in opts: dir = os.path.expanduser('~'+opts['user']) else: dir = os.path.expanduser('~') try: result = os.chdir(str(dir)) except Exception: result = -1 if not result: result = 0 return result #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def camel_to_snake(c): """Convert a name from camelForm to snake_form.""" return sub('([a-z0-9])([A-Z])',r'\1_\2',sub('(.)([A-Z][a-z]+)',r'\1_\2',c)).lower() #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def commands(*args,**opts): """Run one command or many commands piped in sequence.""" if not isinstance(args,_lt) or not isinstance(args[0],_lt): return while isinstance(args[0][0],_lt): args=args[0] o = opts.pop('stdout',stdout) c = None if isinstance(o,_sbb): o = open(o,'w') c = o p = [] for arg in args[:-1]: p.append(Popen(arg,stdout=PIPE,**opts)) opts['stdin']=p[-1].stdout opts['stdout'] = o p.append(Popen(args[-1],**opts)) r = [x.wait() for x in p] if c: c.close() return r cmds = commands #alias #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def decode64s(s,**opts): """Convert a string from base64 to a string.""" return ''.join(chr(c) for c in b64decode(bytes(ord(c) for c in s),**opts)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ds(time=None): """Return a date stamp string from given time or for now.""" try: time = float(time) except Exception: time = secs() return strftime('%Y%m%d',localtime(time)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def encode64s(s,**opts): """Convert a string to base64 as a string.""" return ''.join(chr(c) for c in b64encode(bytes(ord(c) for c in s),**opts)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def eprint(*args,**opts): """Print to stderr with flush.""" if 'file' not in opts: opts['file']=stderr if 'flush' not in opts: opts['flush']=True for x in (stderr,stdout): if x!=opts.get('file',None): x.flush() return print(*args,**opts) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def eprintf(*args,**opts): """Print to stderr with flush using format().""" if not args: return None if 'file' not in opts: opts['file'] = stderr if 'flush' not in opts: opts['flush']=True for x in (stderr,stdout): if x!=opts.get('file',None): x.flush() return print(args[0],**opts) if len(args)<2 else print(args[0].format(*args[1:]),**opts) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def error(msg=None): """Manage errors with messages.""" if msg: eprint(msg) _errors.append(msg) return _errors = [] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def error_abort(): if _errors: n = len(_errors) exit(f'aborting due to {n} error{"s"[:n==1]}') return error_check = error_abort #alias #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def exec_file(file,**d): """Load settings from a file in Python syntax with initial values in named arguments that are included in the return.""" if isinstance(file,(str,bytes,bytearray)): with open(f) as f: s = f.read() else: s = file.read() try: exec(s,d) del d['__builtins__'] return d except Exception: pass return False #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def filetype(name): mode = lstat(name) t = '?' if stat.S_ISREG(mode): t = 'file' if stat.S_ISDIR(mode): t = 'dir' if stat.S_ISLNK(mode): t = 'link' if stat.S_ISCHR(mode): t = 'char' if stat.S_ISBLK(mode): t = 'blk' if stat.S_ISFIFO(mode): t = 'pipe' if stat.S_ISSOCK(mode): t = 'socket' if stat.S_ISDOOR(mode): t = 'door' if stat.S_ISPORT(mode): t = 'port' if stat.S_ISWHT(mode): t = 'whiteout' return t #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def flatten(l): """Flatten a list/tuple of lists/tuples to a single list/tuple.""" r = [] for i in l: if isinstance(i,_lt): r.extend(flatten(i)) else: r.append(i) return type(l)(r) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def fn_exists(name): """File name exists test for conditionals, no exceptions.""" try: os.lstat(name) # strings or bytes return True except FileNotFoundError: return False except Exception: return None #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ftrgen(path,**opts): """File tree recursion (ftr) generator that yields all paths, sorted by sortkey via key=.""" kfun = opts.pop('key',None) pre = 'TypeError: '+__name__+'() ' depth = opts.pop('depth',2**62) if opts: raise TypeError(pre+'got an unexpected keyword argument '+' '.join([repr(x) for x in opts.keys()])) if not isinstance(path,str): raise TypeError(pre+'apex path is not a string') level = [[path]] deep = 0 while level[0]: if level[-1]: path = '/'.join([x[0] for x in level]) yield path try: readlink(path) names = [] except OSError: try: names = sorted(listdir(path),key=kfun) except OSError: names = [] deep += 1 if deep > depth: names = [] if names: level.append(names) else: level[-1].pop(0) continue else: level[-1:] = [] level[-1].pop(0) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def get_env(n): if isinstance(n,str): return environ[n] if isinstance(n,_bb): return str_to_bytes(environ[bytes_to_str(n)]) if isinstance(n,bytearray): return bytearray(str_to_bytes(environ[bytes_to_str(n)])) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def get_terminal_size(): """Get terminal width,height or columns,rows.""" try: w,h = os.get_terminal_size() except: h,w = None,None if not h or not w: try: h,w = struct.unpack('4H',fcntl.ioctl(1,termios.TIOCGWINSZ,struct.pack('4H',0,0,0,0)))[:2] except: h,w = None,None if not h or not w: try: d = os.open('/dev/tty',os.O_WRONLY) h,w = struct.unpack('4H',fcntl.ioctl(d,termios.TIOCGWINSZ,struct.pack('4H',0,0,0,0)))[:2] os.close(fd) except: h,w = None,None return w,h #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def hr(*args): """Print a horizontal rule with optional string at end.""" w,h = wh() r = w*'-' if args and isinstance(args[0],str) and len(args[0]) 234 8 0 6 2 6 _intx_prefs = '__btq___o_d_____x_______________y___z' _intx_bases = {-8,-1,0,2,3,4,8,10,16,32,36} _intx_octal = {'0','1','2','3','4','5','6','7'} # valid as octal _intx_zeros = {'0','','zer','nil','nol','nul'} # words[:3] equivalent to 0 _intx_trans = {'A':'4', 'B':'8', 'E':'3', 'I':'1', 'L':'1', 'O':'0', 'Q':'0', 'S':'5', 'a':'4', 'b':'8', 'e':'3', 'i':'1', 'l':'1', 'o':'0', 'q':'0', 's':'5', } _intx_default_bases = {-8,-1,0,2,3,4,8,10,16,32,36} def intx(digits='0',bases=_intx_default_bases): """Convert digits to int, in an extended way, better than int(). function convert digits to int, in an extended way, better than plain ole int() purpose implement a function to perform extended int conversion. syntax intx(digits) intx(digits,bases) intx(digits,bases=list or set) digits all decimal, basic conversion like int(), or ... letters in the following forms may be given in lower or upper case or a mix of them: no prefix: {10} decimal prefix '0b' or 'b': {2} binary prefix '0t' or 't': {3} ternary (trinary) prefix '0q' or 'q': {4} quaternary prefix '0o' or 'o': {8} octal prefix '0d' or 'd': {10} decimal prefix '0x' or 'x': {16} cetal (hexadecimal) prefix '0y' or 'y': {32} duotridecimal prefix '0z' or 'z': {36} hexatrigesimal (hexatridecimal) note not all base values below 36 are recognized, for bases not handled by intx(), use the built-in int() function. bases a set of bases allowed for conversion and/or various option flags or any container type supported by set() 2, 3, 4, 8, 10, 16, 32, 36: enable these bases feature more values may be included in the set of bases to enable additional features designated by values less than 2 0: suppress exceptions (return None if so) exceptions are still raised for bad arguments -1: enable a prefix of '-' to negate the number -2: forces the number to be negated -3: translate look-alike letters to digits -8: interpret a leading '0' as octal (as in source) -44 remove ',' characters from the numbers to convert -46 remove '.' characters from the numbers to convert defaults if no digits are given, return None if bases is not given, the following set is used: { -8, -1, 0, 2, 3, 4, 8, 10, 16, 32, 36 } returns the converted int value unless a suppressed exception or error happens author Phil D. Howard email 11054987560151472272755686915985840251291393453694611309 (provu igi la numeron al duuma) note Please report failures or code improvement to the author. """ if not bases: bases = _intx_bases if not isinstance(bases,(list,tuple,set,frozenset)): raise TypeError('intx: bases must be a sequence or a set of ints') if not all([isinstance(x,(int,float)) for x in bases]): raise TypeError('intx: bases must be a sequence or a set of ints') bases = frozenset(bases) if 0 in bases: try: return intx(digits,bases-{0}) except: return None try: digits = digits.lower() except: raise TypeError('intx: digits must be a string or bytes type') if -44 in bases: digits = digits.replace(',','') if -46 in bases: digits = digits.replace('.','') if -3 in bases: digits = digits.translate(_intx_trans) if digits[:3] in _intx_zeros: # zer nil nul return 0 if -1 in bases and digits[:0]=='-': return -intx(digits[:1],bases-{-1}) if -2 in bases: return -intx(digits,bases-{-2}) for b in (16,8,10,2,3,4,32,36): # various bases if b in bases: p = _intx_prefs[b] if digits[:2]=='0'+p: return int(digits[2:],b) elif digits[:1]==p: return int(digits[1:],b) if -8 in bases: # leading '0' but no base letter means octal if digits[:1]=='0': if digits[1:2] in _intx_octal: return int(digits[1:],8) if 10 in bases: return int(digits,10) return int(digits,0) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def interfaceips(name): if isinstance(name,_bb): name = ''.join(chr(x) for x in name) proc = Popen(['ifconfig',name],stdout=PIPE,bufsize=4096) try: out,err = proc.communicate(timeout=127) except TimeoutExpired: proc.kill() out,err = proc.communicate(timeout=127) lines = out.splitlines() for line in lines: if len(line) < 8: continue tokens = line.strip().split() if len(tokens) < 3: continue if tokens[0]=='inet': ip4 = tokens[1] if tokens[0]=='inet6': ip6 = tokens[1] if ip4 and '/' in ip4: ip4 = ip4.split('/')[0] if ip6 and '/' in ip6: ip6 = ip6.split('/')[0] return (ip4,ip6) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def isare(n,_is='is',_are='are'): # is is a reserved word so these keyword options begin with an underscore. """Return 'is' for 1 else 'are' (or whatever is specified in keyword options).""" return _is if n==1 else _are #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def istype(v,t): """Like isinstance, but more flexible, though less efficient.""" x = type(v) return x is t or x in t #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def lineno(level=0): """Return line number of caller N levels back.""" frame = currentframe().f_back while frame and level>0: level -= 1 frame = frame.f_back return frame.f_lineno if frame else None #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def linenos(): """Return a list of line numbers of callers all the way back.""" nums = [] frame = currentframe().f_back while frame: nums.append(frame.f_lineno) frame = frame.f_back return nums #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def linenostr(level=0): """Return line number of caller N levels back as a string.""" n = lineno(level=level+1) return str(n) if isinstance(n,int) else '?' #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def microsecs(): """Return current time value scaled to microseconds.""" return secs()*1000000 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def millisecs(): """Return current time value scaled to milliseconds.""" return secs()*1000 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def nanosecs(): """Return current time value scaled to nanoseconds.""" return secs()*1000000000 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def oprint(*args,**opts): """Print to stdout with flush.""" if 'file' not in opts: opts['file']=stdout if 'flush' not in opts: opts['flush']=True for x in (stderr,stdout): if x!=opts.get('file',None): x.flush() return print(*args,**opts) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def oprintf(*args,**opts): """Print to stdout with flush using format().""" if not args: return None if 'file' not in opts: opts['file'] = stdout if 'flush' not in opts: opts['flush']=Truea for x in (stderr,stdout): if x!=opts.get('file',None): x.flush() return print(args[0],**opts) if len(args)<2 else print(args[0].format(*args[1:]),**opts) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def parpid(p): """Return parent PID in Linux as same type: int,float,str.""" i = int(p) if i<2: return 1 with open('/proc/'+str(i)+'/status') as o: for x in o: a,b = x.strip().split(None,1) if a=='PPid:': return type(p)(b) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def plural(value=1,one='',not_one='s'): """Syntactic sugar to return 's' for plural cases else '' or allow substituting other strings. function plural purpose syntactic sugar to return 's' for plural cases else '' or allow substituting other strings examples print('I see %d thing%s here'%(n,plural(n))) print('il y a %d chose%s ici'%(n,plural(n))) print('Det er %d element%s her'%(n,plural(n,'','er'))) print('There %s %d thing%s here'%(plural(n,'is','are'),n,plural(n))) """ valu = float(value) return one if value==1 else not_one #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def put_env(n,v): """Put an envionment variable even if it is already set and return the previous value.""" if isinstance(n,_bb): n = bytes_to_str(n) p = environ[n] if isinstance(v,_bb): v = bytes_to_str(v) p = str_to_bytes(environ[n]) if isinstance(n,_bb): n = bytes_to_str(n) p = str_to_bytes(p) environ[n] = v return p #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def rangeforever(start=0,increment=1): """Return a range iterator that will last longer than this computer will exist.""" return range(start,2**1024,increment) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def set_env(n,v): """Set an envionment variable only if it has not been set.""" if isinstance(n,bb): n = bytes_to_str(n) if isinstance(v,bb): v = bytes_to_str(v) if n not in environ or not environ[n]: environ[n] = v return environ[n] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def set_envs(**kwargs): """Set multiple environmeny variables from keyword arguments (or a **dictionar)..""" p = {k:v for k,v in os.environ} for k,v in kwargs: os.environ[k] = v return p #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def snake_to_camel(s): """Convert name from snake_form to camelForm.""" return s[:2]+''.join(x.capitalize() or '_' for x in s.split('_'))[2:] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def sleep_interval(interval): """Sleep to the next repeating interval (int version).""" i = int(interval) t = secs() u = int(t) s = float(u+i-u%i)-t return sleep(s) def sleep_interval(interval): """Sleep to the next repeating interval (float version).""" i = float(interval) t = secs() s = (t+i-t%i)-t return sleep(s) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def sleep_to(to_time): if not isinstance(to_time,(float,int)): return 0 d = to_time-secs() sleep(d) return d #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def str_to_bytearray(s): """Convert str to bytearray, transparently.""" return bytearray(ord(x)%256 for x in s) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def str_to_bytes(s): """Convert str to bytes, transparently.""" return bytes(ord(x)%256 for x in s) s2b = str_to_bytes #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def str_to_list(s): """Convert str to a list of ints.""" return list(ord(x) for x in s) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def str_to_tuple(s): """Convert str to a tuple of ints.""" return tuple(ord(x) for x in s) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tfn(name=None,time=None): """Return a time related temporary file name.""" s = hex(ti(time=time))[2:].rjust(14,'0') if name: s = name+'.'+s return s #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ti(time=None): """Return a time related int.""" try: time = float(time) except Exception: time = secs() return int(time*3906250) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def todec(number): """Try converting a number string to a decimal, returning None if it fails. function todec purpose try converting a string or other number to decimal.Decimal, just returning None if it fails note bytes is not supported by decimal.Decimal so this function converts bytes to str argument 1 (str) digits to be converted with maybe one decimal point 1 (number) number to be converted. returns converted decimal number or None note test should be like this: if return_value is None: """ if isinstance(number,(bytearray if bytes==str else bytes,bytearray)): number = ''.join(chr(x) for x in number) if isinstance(number,str): number = number.replace(decsep,'') # 1,234,567.8 -> 1234567.8 if number[0] == '$': number = number[1:] if len(number.split(decpnt)) not in (1,2): return None try: return decimal.Decimal(number)+decimal.Decimal(0) except decimal.InvalidOperation: return None else: try: return decimal.Decimal(number)+decimal.Decimal(0) except decimal.InvalidOperation: return None #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ts(time=None): """Return a time stamp string from a given time or for now.""" try: time = float(time) except Exception: time = secs() return strftime('%Y%m%d-%H%M%S',localtime(time)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsm(time=None): """Return a time stamp string with milliseconds.""" try: time = float(time) except Exception: time = secs() return strftime('%Y%m%d-%H%M%S',localtime(time))+'.'+str(int((1+time-int(time))*1000))[1:] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsn(time=None): """Return a time stamp string with nanoseconds.""" if not isinstance(time,(int,float)): time = secs() return strftime('%Y%m%d-%H%M%S',localtime(time))+'.'+str(int((1+time-int(time))*1000000000))[1:] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsu(time=None): """Return a time stamp string with microseconds.""" if not isinstance(time,(int,float)): time = secs() return strftime('%Y%m%d-%H%M%S',localtime(time))+'.'+str(int((1+time-int(time))*1000000))[1:] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def validip(addr): """Return True if the given IP address is valid for IPv4 or IPv6 or None if not either. function validip purpose return 4 if the given IP address is valid for IPv4 or return 6 if the given IP address is valid for IPv6 or return 0 if the given IP address is not valid for either IPv4 or IPv6. argument 1 (str,bytes) that may be an IP address returns 4 or 6 for the address family if it is valid 0 if the address is not valid IPv4 nor valid IPv6 10 if the address is somehow valid for both IPv4 and IPv6 """ return validipv4(addr)+validipv6(addr) ipversion = validip #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def validipv4(addr): """Return 4 if the given IP address is valid for IPv4 or 0 if not. function validipv4 argument 1 (str,bytes) that may be an IPv4 address purpose return 4 if the given IP address is valid for IPv4 or 0 if not returns 4 if the given IP address is valid for IPv4 or 0 if not """ if isinstance(addr,_bb): addr = bytes_to_str(addr) if '.' not in addr: r = 0 else: try: inet_pton(AF_INET,addr) r = 4 except (OSError,IOError): r = 0 return r #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def validipv6(addr): """Return 6 if the given IP address is valid for IPv6 or 0 if not. function validipv6 argument 1 (str,bytes) that may be an IPv6 address purpose return 6 if the given IP address is valid for IPv6 or 0 if not returns 6 if the given IP address is valid for IPv6 or 0 if not """ if isinstance(addr,_bb): addr = bytes_to_str(addr) if ':' not in addr: r = 0 else: try: inet_pton(AF_INET6,addr) r = 6 except (OSError,IOError): r = 0 return r #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def width_height(): """Return s 2-tuple with terminal screen width and height. function width_height aliases columns_rows,cr,wh no arguments purpose return s 2-tuple with terminal screen width and height """ try: w,h = get_terminal_size() except: try: h,w = unpack('4H',ioctl(1,TIOCGWINSZ,pack('4H',0,0,0,0)))[:2] except: try: d = os.open('/dev/tty',os.O_WRONLY) h,w = unpack('4H',ioctl(d,TIOCGWINSZ,pack('4H',0,0,0,0)))[:2] os.close(fd) except: h,w = None,None return w,h colums_rows = width_height #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def wh(): """Return s 2-tuple with terminal screen width and height. function width_height aliases columns_rows,cr,wh no arguments purpose return s 2-tuple with terminal screen width and height """ try: w,h = os.get_terminal_size() except: w,h = None,None if not h or not w: try: h,w = struct.unpack('4H',fcntl.ioctl(1,termios.TIOCGWINSZ,struct.pack('4H',0,0,0,0)))[:2] except: h,w = None,None if not h or not w: try: d = os.open('/dev/tty',os.O_WRONLY) h,w = struct.unpack('4H',fcntl.ioctl(d,termios.TIOCGWINSZ,struct.pack('4H',0,0,0,0)))[:2] os.close(fd) except: h,w = None,None return w,h cr = wh #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def yes_or_no(x,no=None,yes=True,unknown=None): """Determine if a given string means yes/true or no/false function yes_or_no aliases oui_ou_non,ja_oder_nein,ja_of_nee,ja_eller_nej,ja_eller_nei purpose determine if a given string in various languages means yes or no arguments 1: the string or value to check no= alternate value to return for no yes= alternate value to return for yes unknown= alternate value to return for unknown returns None or the value of no= if string/value indicates no True or the value of yes= if string/value indicates yes None or the value of unknwon= if string/value cannot be determined note Only a few European languages are represented here. """ y={'ano','bai','da','ie','iè','ja','jah','jes','jo','kylla','oui','si','sí','sì','sim','yes',} n={'dim','ei','ez','ikke','ingen','inno','innò','nao','não','ne','nee','nei','nein','no','non',} if isinstance(x,strs): if str(x).lower() in n: return no elif str(x).lower() in y: return yes elif isinstance(x,Number): if x: return yes else: return no return unknown # Alias this function in a few languages. oui_ou_non = yes_or_no ja_oder_nein = yes_or_no ja_of_nee = yes_or_no ja_eller_nej = yes_or_no ja_eller_nei = yes_or_no jes_au_ne = yes_or_no jo_oder_nee = yes_or_no si_o_no = yes_or_no sim_ou_nau = yes_or_no #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymd(time=None): """Return the date as a string.""" try: t = float(time) except Exception: t = secs() return strftime('%Y-%m-%d',localtime(t)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymd3ints(time=None): """Return the date as a 3-tuple of ints.""" try: t = float(time) except Exception: t = secs() ints = [int(x) for x in strftime('%Y_%m_%d',localtime(t)).split('_')] return ints #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhms(time=None,sep='T'): """Return the date and time as a string.""" try: t = float(time) except Exception: t = secs() return strftime('%Y-%m-%d_%H-%M-%S',localtime(t)).replace('_',sep) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhms6ints(time=None): """Return the date and time as a 6-tuple of ints.""" try: t = float(time) except Exception: t = secs() ints = [int(x) for x in strftime('%Y_%m_%d_%H_%M_%S_0',localtime(t)).split('_')] return ints #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhmsm(time=None,sep='T'): """Return the date and time as a string with milliseconds.""" try: t = float(time) except Exception: t = secs() return strftime('%Y-%m-%d_%H-%M-%S',localtime(t))+'.'+str(int((1+t-int(t))*1000))[1:].replace('_',sep) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhmsm7ints(time=None): """Return the date and time as a 7-tuple of ints with milliseconds.""" try: t = float(time) except Exception: t = secs() ints = [int(x) for x in strftime('%Y_%m_%d_%H_%M_%S_0',localtime(t)).split('_')] return ints+[int((t-int(t))*1000)] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhmsn(time=None,sep='T'): """Return the date and time as a string with nanoseconds.""" try: t = float(time) except Exception: t = secs() return strftime('%Y-%m-%d_%H-%M-%S',localtime(t))+'.'+str(int((1+t-int(t))*1000000000))[1:].replace('_',sep) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhmsn7ints(time=None): """Return the date and time as a 7-tuple of ints with nanoseconds.""" try: t = float(time) except Exception: t = secs() ints = [int(x) for x in strftime('%Y_%m_%d_%H_%M_%S',localtime(t)).split('_')] return ints+[int((t-int(t))*1000000000)] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhmsu(time=None,sep='T'): """Return the date and time as a string with microsecnds.""" try: t = float(time) except Exception: t = secs() return strftime('%Y-%m-%d_%H-%M-%S',localtime(t))+'.'+str(int((1+t-int(t))*1000000))[1:].replace('_',sep) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ymdhmsu7ints(time=None): """Return the date and time as a 7-tuple of ints with microsecnds.""" try: t = float(time) except Exception: t = secs() ints = [int(x) for x in strftime('%Y_%m_%d_%H_%M_%S',localtime(t)).split('_')] return ints+[int((t-int(t))*1000000)] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # to enable debug tools, set one of the environment variables to a # string that evaluates as true by the eval() function: # SFCdebug SFCdebugON SFCdebugMODE # SFCDEBUG SFCDEBUGON SFCDEBUGMODE # sfcdebug sfcdebugon sfcdebugmode #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # pr() Do printing just like print(), default to stderr, and flush. # pv() Print variables, given their names, or report if undefined. # sl() Sleep a specified time after flushing stdout or file= file. #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # The pv() function is particularly helpful. Call pv() with one or # more arguments naming variables to be printed. its name and value # will be printed if the variable is defined in the caller's local or # global namespace. If the variable is not defined, then a one line # message is produced explaining that the variable is not defined. # To help with debugging, pv() includes the line number of the source # code it came from on each line of output. If the arument string begins with # a '#' character, then the remainder of the string is a comment, not a # variable. A prefix for each line may be given as a named option on # the call to pv() or given in an argument as a string that begins # with the '=' character. #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # Doing this: # if 'SFCdebug' not in os.environ: # os.environ['SFCdebug'] = '1' # before importing sfc will enable debugging mode and leave the option to disable it at run time. #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- if not _debugmode_: def _do_nothing_(*a,**o): return pr = _do_nothing_ pv = _do_nothing_ sl = _do_nothing_ else: eprint('SFC debugging enabled') # flush multiple files def _flush(*a): stderr.flush() stdout.flush() for f in a: f.flush() return # do printing just like print() then flush the file it used def pr(*args,**opts): opts['file'] = opts.get('file',stderr) if opts.get('file',None)!=stdout: _flush() try: print(*args,**opts) opts['file'].flush() except BrokenPipeError: pass return # print variables, given their names, or report if undefined def pv(*args,**opts): opts['file'],c = opts.get('file',stderr),opts.pop('prefix','') try: if not args: # if nothing to do print(**opts) _flush(opts['file']) return 0 f = currentframe() if 'f_back' not in dir(f): print(**opts) _flush(opts['file']) return 0 f = f.f_back l,g = f.f_locals,f.f_globals if 'f_lineno' in dir(f): p='line '+repr(f.f_lineno)+': ' else: p='unknown line: ' _flush() # synchronize outputs for name in args: _flush(opts['file']) s = name.split('.') n = s.pop(0) if n[:1] in '!': # use what follows as a var name n = n[1:] elif n[:1] in '+=:': # use what follows as a prefix c = n[1:] continue elif n[:1] is '#': # use what follows as a comment print(p+c+'............. ', n[1:], **opts) continue elif not n: # null variable name print(p+c+'............. ', s[0], **opts) _flush(opts['file']) continue elif n in l: # var is local o,v = p+c+'... local var:',l[n] elif n in g: # var is global o,v = p+c+'.. global var:',g[n] else: # not local or global print(p+c+'............. ', repr(name), 'not assigned in local or global namespace', **opts) _flush(opts['file']) continue while s: m = s.pop(0) if m in dir(v): v,n = getattr(v,m),n+'.'+m else: break if isinstance(v,str) and len(v)<11: x=['['+hex(ord(x)+256)[-2:]+']' for x in v] print(o,repr(n),'=',repr(v),' '.join(x),**opts) else: print(o,repr(n),'=',repr(v),**opts) _flush(opts['file']) continue except BrokenPipeError: pass return # sleep a specified time after flushing standard files def sl(sec,**opts): opts.get('file',stdout).flush() _flush() sleep(float(sec)) return #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def _main(args): eprint() eprint('+-------------------------------------------------+') eprint('| This is a module to be imported, not a command. |') eprint('| Nothing to see here, except code. MOVE ALONG! |') eprint('+-------------------------------------------------+') eprint() return #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- if __name__ == '__main__': try: result=_main(argv) except BrokenPipeError: result = 141 except KeyboardInterrupt: print(flush=True) result = 98 if result is None or result is True: result = 0 elif result is False: result = 1 exit(result) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # EOF