# -*- coding: utf-8 -*- #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # file sfc.py # purpose Skaperen's Function Collection (and other useful stuff) # # legal Copyright © 2018, 2020, 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 under Linux # # URLs http://ipal.net/python/sfc.py # http://ipal.net/python/sfcdebug.py (separate module to enable debug default mode) # # note developed primarily for BSD and Linux but may also work elsewhere # 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, 2020 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) """ _debugmode = True #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- import base64 import collections import copy as mod_copy import curses import curses.ascii import decimal import fcntl import inspect import itertools import ipaddress import math import numbers import os import pathlib import random import signal import socket import stat as mod_stat import struct import subprocess import struct import sys import re import termios import textwrap import time # check version before trying to do individual imports if sys.version_info.major<3:raise RuntimeError('Python versions 1.X-2.X are not supported') if sys.version_info.minor<6:raise RuntimeError('Python versions 3.0-3.5 are not supported') from base64 import b85decode,b85encode,b64decode,b64encode from base64 import b32decode,b32encode,b16decode,b16encode from collections import namedtuple from copy import copy,deepcopy from decimal import Decimal from fcntl import ioctl from inspect import currentframe from itertools import chain from numbers import Number from os import chdir,chmod,chown,dup,dup2,environ,environb,listdir,fchdir from os import link,mkdir,path,readlink,rmdir,stat,unlink,utime from os.path import expanduser from pathlib import Path,PurePath from random import randint,randrange from socket import inet_pton,AF_INET,AF_INET6 from stat import S_ISBLK,S_ISCHR,S_ISDIR,S_ISDOOR,S_ISFIFO,S_ISLNK,S_ISPORT from stat import S_ISREG,S_ISSOCK,S_ISWHT from struct import pack,unpack from subprocess import call,DEVNULL,PIPE,Popen,run,STDOUT from sys import argv,stderr,stdin,stdout,version_info from re import sub from termios import TIOCGWINSZ from textwrap import TextWrapper from time import gmtime,localtime,sleep,strftime,time as secs from collections.abc import Iterable # when sfc module was loaded sfc_load_time = secs() # set some lower case aliases number = Number path = Path popen = Popen purepath = PurePath textwrapper = TextWrapper # set some shorter aliases dec = Decimal num = Number txw = TextWrapper # set some missing 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 = {'.':',', ',':'.'}[decpnt] # get some constant system info cwd = os.getcwd() pid = os.getpid() egid = os.getegid() rgid = os.getgid() euid = os.geteuid() ruid = os.getuid() groups = os.getgroups() # Define short ways to express certain grouped types in uses of isinstance(). _bb = bytes,bytearray _fd = float,dec _if = int,float _ifd = int,float,dec _lt = list,tuple _ltsf = list,tuple,set,frozenset _ltsfd = list,tuple,set,frozenset,dict _sb = str,bytes _sbb = str,bytes,bytearray _sf = set,frozenset # Formats for date stamp and time stamp. ds_fmt = '%Y%m%d' ts_fmt = '%Y%m%d-%H%M%S' # Format for date and time expression. dt_fmt = '%Y-%m-%dT%H:%M:%S' #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # setting any one of these environment variables to a string that eval() returns a true value for will enable debug mode. # SFCdebug SFCdebugMODE SFCdebugging # SFCdebugmode # sfcdebug sfcdebugmode SFCdebugging # SFCDEBUG SFCDEBUGMODE SFCdebugging # any variable set true overrides any variable set false # importing module sfcdebug will enable debug mode unless any one of those environment variables is set to any string. #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- _debugvars = [y for x in ('SFCdebug','SFCdebugMODE','SFCdebugmode','SFCdebugging') for y in (x,x.upper(),x.lower())] _debugmode = any(eval(environ.get(x,'0'))for x in _debugvars) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- 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: # obj1['foo'] = obj2['bar'] # although the latter may also be used # # requires python 3.6 or later (uses f-strings) # # warning this class will fail in cases where keys # have values the same as existing methods # # warning adict_obj['__iter__'] = value # bad idea # # init usage adict_obj = adict() # empty # adict_obj = adict(dictionary) # adict_obj = adict(iterable) # adict_obj = adict(dictionary,key=value...) # adict_obj = adict(iterable,key=value...) # adict_obj = adict(key=value...) # # methods _cpwo, _del, _get, plus all dict methods # # attr usage adict_obj.name # name must be valid identifier # dict usage adict_obj[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,**kwargs): """Create a dictionary that works like attributes.""" n = 0 for arg in args: if isinstance(arg,(adict,dict)): self.update(arg) elif isinsrance(arg,Iterable): for a in arg: self.update(**dict(a)) else: raise TypeError(f'argument #{n} is not a dictionary or iterable') n += 1 self.update(**kwargs) def __delattr__(self,key): """Delete any attribute or iterable of keys.""" if isinstance(key,Iterable): 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 _cpwo(self,keys=[]): """Copy without a key or any key in iterable.""" new=adict(self) if not isinstance(keys,Iterable): keys = [keys] for key in keys: new.pop(key,None) return new def _del(self,key): """Delete any key or iterable of keys.""" if isinstance(key,Iterable): for k in key: del self[k] else: del self[key] return self def _get(self,keys,default=None): """Get a value based on a key or iterable of keys or return default.""" if not isinstance(keys,Iterable): keys = [keys] for key in iter(keys): if key in self: return self[key] return default def _pop(self,keys,default=None): """Pop a value based on a key or iterable of keys or return default.""" if not isinstance(keys,Iterable): keys = [keys] for key in iter(keys): if key in self: value = self[key] del self[key] return value return default #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def be(arg,begin=None,end=None): """Test if sequence {arg} begins with {begin} and ends with {end}.""" return (begin and arg[:len(begin)]==begin) and (end and arg[-len(end):]==end) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def box(text='empty box',name=None,padh=1,padv=0): """Return text with an ASCII box around it.""" if isinstance(padh,_fd): padh = int(padh) if not isinstance(padh,int): error_message = f'padding parameter padh is not int or float' raise TypeError(error_message) if isinstance(padv,_fd): padv = int(padv) if not isinstance(padv,int): error_message = f'padding parameter padv is not int or float' raise TypeError(error_message) if name is None: name = '' if isinstance(name,_bb): name = tostr(name) if not isinstance(name,str): error_message = f'name is {typestr(name)}, not str or bytes' raise TypeError(error_message) if isinstance(text,tuple): return tuple(box(list(text))) if isinstance(text,str): return '\n'.join(box(text.splitlines()))+'\n' if isinstance(text,bytes): return tobytes(box(tostr(text))) if isinstance(text,bytearray): return tobytearray(box(tostr(text))) if not isinstance(text,list): raise TypeError(f'argument #0 (text) type is {typename(text)}, not list') width = max([0,]+[len(x) for x in text]) if name: name = '<'+name+'>' text = ['|'+' '*padh+x.ljust(width,' ')+' '*padh+'|' for x in text] a = '+'+'-'*padh+'-'*width+'-'*padh+'+' b = '|'+' '*padh+' '*width+' '*padh+'|' r = [a] for n in range(padv): r += [b] r += text for n in range(padv): r += [b] r += [a] return r #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def camel_to_snake(c): """Convert a name from camelForm to snake_form.""" if isinstance(c,bytes): return tobytes(camel_to_snake(tostr(c))) if isinstance(c,bytearray): return tobytearray(camel_to_snake(tostr(c))) return sub('([a-z0-9])([A-Z])',r'\1_\2',sub('(.)([A-Z][a-z]+)',r'\1_\2',c)).lower() #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def chdir(path=None,user=None,abort=True): """Change the current directory to the specified directory or if none is specified, this user's home directory.""" if path is None: # if no specified path, then home directory if user is None: # if no specified user, then this user path = expanduser('~') else: path = expanduser('~'+tostr(user)) elif isinstance(path,int): if user is not None: raise TypeError(f'a file descriptor ((int) {path}) and user ((str) {user!r}) is an invalid combination') else: if user is None: # if no specified user, then this user path = expanduser(tostr(path)) else: path = expanduser('~'+tostr(user)+'/'+tostr(path)) try: result = os.chdir(path) if result is None: result = 0 # return an int result for success except Exception: if abort: if isinstance(path,str): exit(f'error changing to directory {path!r}') elif isinstance(path,int): exit(f'error changing to directory opened in file descriptor {path}') result = -1 return result cd = chdir #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def chjust(st,wl=9,wr=9,pl='',pr='',ch=''): """Justify a string around a character to be lined up.""" if not pl: pl = ' ' if not pr: pr = ' ' if not ch: ch = decpnt sl,sr = st.split(ch,1) return sl.rjust(wl,pl)+ch+sr.ljust(wr,pr) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def chmodref(rfn,fn,filenotfound1=None,filenotfound2=None): """Do chmod with mode from given file.""" try: rstat = stat(rfn,follow_symlinks=False) except FileNotFoundError: return filenotfound1 try: return chmod(fn,rstat.st_mode&4095,follow_symlinks=False) except FileNotFoundError: return filenotfound2 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def chownref(rfn,fn,filenotfound1=None,filenotfound2=None): """Do chown with owner and group from given file.""" try: rstat = stat(rfn,follow_symlinks=False) except FileNotFoundError: return filenotfound1 try: return chown(fn,rstat.st_uid,rstat.st_gid,follow_symlinks=False) except FileNotFoundError: return filenotfound2 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def cmdout(cmd): """Run a single command returning its output as a list of line, each in str/bytes/bytearray.""" if not isinstance(cmd,_lt): raise TypeError('argument 1 (command) must be a list or tuple (of str/bytes/bytearray).') for t in _sbb: if all(ininstance(x,t)for x in cmd): with Popen(cmd,stdout=PIPE,universal_newlines=(t==str)) as p: return p.stdout.read().splitlines() raise TypeError('argument 1 (command) must be a list or tuple of str/bytes/bytearray, all the same one type.') #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def commands(*args,**kwargs): """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 = kwargs.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,**kwargs)) kwargs['stdin']=p[-1].stdout kwargs['stdout'] = o p.append(Popen(args[-1],**kwargs)) r = [x.wait() for x in p] if c: c.close() return r command = commands cmd = commands cmds = commands #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def decode16(arg,**kwargs): """Convert a string from base16 to the string it encodes or convert all items in a list.""" if isinstance(arg,list): return [decode16(x,**kwargs)for x in arg] if isinstance(arg,tuple): return tuple(decode16(x,**kwargs)for x in arg) if isinstance(arg,str): return tostr(b16decode(arg,**kwargs)) if isinstance(arg,bytes): return b16decode(arg,**kwargs) if isinstance(arg,bytearray): return bytearray(b16decode(arg,**kwargs)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def decode32(arg,**kwargs): """Convert a string from base32 to the string it encodes or convert all items in a list.""" if isinstance(kwargs.get('map01',None),str): kwargs['map01'] = tobytes(kwargs['map01']) if isinstance(arg,list): return [decode32(x,**kwargs)for x in arg] if isinstance(arg,tuple): return tuple(decode32(x,**kwargs)for x in arg) if isinstance(arg,str): return tostr(b32decode(arg,**kwargs)) if isinstance(arg,bytes): return b32decode(arg,**kwargs) if isinstance(arg,bytearray): return bytearray(b32decode(arg,**kwargs)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def decode64(arg,**kwargs): """Convert a string from base64 to the string it encodes or convert all items in a list.""" if isinstance(kwargs.get('altchars',None),str): kwargs['altchars'] = tobytes(kwargs['altchars']) if isinstance(arg,list): return [decode64(x,**kwargs)for x in arg] if isinstance(arg,tuple): return tuple(decode64(x,**kwargs)for x in arg) if isinstance(arg,str): return tostr(b64decode(arg,**kwargs)) if isinstance(arg,bytes): return b64decode(arg,**kwargs) if isinstance(arg,bytearray): return bytearray(b64decode(arg,**kwargs)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def dslocal(time=None,fmt=None): """Return a date stamp (YYYYmmdd) str of given local time or of now.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ds_fmt return strftime(fmt,localtime(int(time))) dsloc = dslocal ds = dslocal #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def dsutc(time=None,fmt=None): """Return a date stamp (YYYYmmdd) str of given utc time or of now.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ds_fmt return strftime(fmt,utctime(int(time))) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ehr(*args,**kwargs): """Print a horizontal rule to stderr with optional string at end.""" if 'file' not in kwargs: kwargs['file'] = stderr return hr(*args,**kwargs) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def encode16(arg): """Convert a str or bytes to base16 as same type or convert all items in a list/tuple.""" if isinstance(arg,list): return [encode16(x)for x in arg] if isinstance(arg,tuple): return tuple(encode16(x)for x in arg) if isinstance(arg,str): return tostr(b16encode(tobytes(arg))) if isinstance(arg,bytes): return b16encode(arg) if isinstance(arg,bytearray): return tobytearray(b16encode(tobytes(arg))) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def encode32(arg): """Convert a str or bytes to base32 as same type or convert all items in a list/tuple.""" if isinstance(arg,list): return [encode32(x)for x in arg] if isinstance(arg,tuple): return tuple(encode32(x)for x in arg) if isinstance(arg,str): return tostr(b32encode(tobytes(arg))) if isinstance(arg,bytes): return b32encode(arg) if isinstance(arg,bytearray): return tobytearray(b32encode(tobytes(arg))) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def encode64(arg,**kwargs): """Convert a str or bytes to base64 as same type or convert all items in a list/tuple.""" if isinstance(kwargs.get('altchars',None),str): kwargs['altchars'] = tobytes(kwargs['altchars']) if isinstance(arg,list): return [encode64(x,**kwargs)for x in arg] if isinstance(arg,tuple): return tuple(encode64(x,**kwargs)for x in arg) if isinstance(arg,str): return tostr(b64encode(tobytes(arg),**kwargs)) if isinstance(arg,bytes): return b64encode(arg,**kwargs) if isinstance(arg,bytearray): return tobytearray(b64encode(tobytes(arg),**kwargs)) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def eprint(*args,**kwargs): """Print to stderr with flush.""" if 'file' not in kwargs: kwargs['file']=stderr if 'flush' not in kwargs: kwargs['flush']=True for x in (stderr,stdout): if x!=kwargs.get('file',None): x.flush() return print(*args,**kwargs) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- tty_format={0:'0',7:'a',8:'b',9:'t',10:'n',11:'v',12:'f',13:'r'} def esc_seq(s): """Convert character or bytes to escape sequences according to type.""" # a sequence of ints also works. if isinstance(s,str): return esc_seq_unicode(s) return esc_seq_ascii(s) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def esc_seq_ascii(a): """Convert ASCII characters or bytes to escape sequences.""" # a sequence of ints also works. if isinstance(a,str): a=[ord(x)for x in a] if isinstance(a,_bb): a=[x for x in a] if isinstance(a,_lt): o='' for x in a: if x in tty_format: o=o+'\\'+tty_format[x] elif x<127: o=o+repr(chr(x))[1:-1] elif x<256: o=o+'\\x'+hex(x)[-2:] else: o=o+'\\u????' return o return None #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def esc_seq_unicode(u): """Convert Unicode characters or bytes to escape sequences.""" # a sequence of ints also works. if isinstance(u,str): u=[ord(x)for x in u] if isinstance(u,_bb): u=[x for x in u] if isinstance(u,_lt): o='' for x in u: if x in tty_format: o=o+'\\'+tty_format[x] else: o=o+repr(chr(x))[1:-1] return o return None #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- _errors = [] def error(msg=None): """Manage errors with messages.""" if msg: eprint(msg) _errors.append(tostr(msg)) return #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def error_abort(): if _errors: n = len(_errors) exit(f'aborting due to {n} error{"s"[:n==1]}') return error_check = error_abort #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- 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,_sbb): 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 fstype(name): """Return a short string describing the file system type of the named object.""" if isinstance(name,bytes): return tobytes(fstype(tostr(name))) if isinstance(name,bytearray): return tobytearray(fstype(tostr(name))) try: stat = stat(name,follow_symlinks=False) mode = stat.st_mode t = 'unknown' except Exception: t = 'none' if mod_stat.S_ISREG(mode): t = 'file' if mod_stat.S_ISDIR(mode): t = 'dir' if mod_stat.S_ISLNK(mode): t = 'link' if mod_stat.S_ISCHR(mode): t = 'char' if mod_stat.S_ISBLK(mode): t = 'blk' if mod_stat.S_ISFIFO(mode): t = 'pipe' if mod_stat.S_ISSOCK(mode): t = 'socket' if mod_stat.S_ISDOOR(mode): t = 'door' if mod_stat.S_ISPORT(mode): t = 'port' if mod_stat.S_ISWHT(mode): t = 'whiteout' return t filetype = fstype #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def fstype_long(name): """Return a long string describing the file system type of the named object.""" if isinstance(name,bytes): return tobytes(fstype(tostr(name))) if isinstance(name,bytearray): return tobytearray(fstype(tostr(name))) try: stat = stat(name,follow_symlinks=False) mode = stat.st_mode t = 'unknown' except Exception: t = 'none' if mod_stat.S_ISREG(mode): t = 'Regular File' if mod_stat.S_ISDIR(mode): t = 'Directory' if mod_stat.S_ISLNK(mode): t = 'Symlink' if mod_stat.S_ISCHR(mode): t = 'Character Device' if mod_stat.S_ISBLK(mode): t = 'Block Device' if mod_stat.S_ISFIFO(mode): t = 'Pipe' if mod_stat.S_ISSOCK(mode): t = 'Socket' if mod_stat.S_ISDOOR(mode): t = 'Door' if mod_stat.S_ISPORT(mode): t = 'Port' if mod_stat.S_ISWHT(mode): t = 'Whiteout' return t filetype_long = fstype_long #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def flatten(l): """Flatten any depth of list/tuple of lists/tuples to a single level 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 (sbb) exists test for conditionals, without raising exceptions.""" try: stat(name,follow_symlinks=False) return True except FileNotFoundError: return False except Exception: return None exists = fn_exists #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def fn_status(name,exists=True,missing=False): """File name (sbb) missing test for conditionals, without raising exceptions.""" try: stat(name,follow_symlinks=False) return exists except FileNotFoundError: return missing except Exception: return None fn_stat = fn_status #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ftrgen1(apex,**kwargs): """File tree recursion (ftr) generator that yields all paths, optionally sorted by sortkey via key=.""" kfun = kwargs.pop('key',None) pre = 'TypeError: '+__name__+'() ' depth = kwargs.pop('depth',2**62) if kwargs: raise TypeError(pre+'got an unexpected keyword argument '+' '.join([repr(x) for x in kwargs.keys()])) if not isinstance(apex,str): raise TypeError(pre+'apex path is not a string') level = [[apex]] deep = 0 while level[0]: if level[-1]: yield '/'.join([x[0] for x in level]) # future: yield same type as the given path try: readlink(apex) names = [] except OSError: try: names = sorted(listdir(apex),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) ftrgen = ftrgen1 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ftrgen2(apex,**kwargs): """File tree recursion generator that yields all paths, """ \ """with lstat results for each path, """ \ """optionally sorted by sortkey in key=.""" for path in ftrgen1(apex,**kwargs): yield path,stat(path,follow_symlinks=False) ftrstatgen = ftrgen2 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ftrgen3(apex,**kwargs): """File tree recursion GENERATOR that yields all paths, """ \ """with lstat results and type code letter for each path, """ \ """optionally sorted by sortkey in key= applied to the path. """ types = kwargs.pop('types',None) if isinstance(apex,str): if not types: types = 'fdlbcpsPDW' types = frozenset(types) for p,s in ftrgen2(apex,**kwargs): if S_ISREG(s.st_mode):t='f' elif S_ISDIR(s.st_mode):t='d' elif S_ISLNK(s.st_mode):t='l' elif S_ISBLK(s.st_mode):t='b' elif S_ISCHR(s.st_mode):t='c' elif S_ISFIFO(s.st_mode):t='p' elif S_ISSOCK(s.st_mode):t='s' elif S_ISPORT(s.st_mode):t='P' elif S_ISDOOR(s.st_mode):t='D' elif S_ISWHT(s.st_mode):t='W' else:t='?' if t in types: yield p,s,t elif isinstance(apex,(bytes,bytearray)): if not types: types = b'fdlbcpsPDW' types = frozenset(bytes(types)) for p,s in ftrgen2(apex,**kwargs): if S_ISREG(s.st_mode):t=ord('f') elif S_ISDIR(s.st_mode):t=ord('d') elif S_ISLNK(s.st_mode):t=ord('l') elif S_ISBLK(s.st_mode):t=ord('b') elif S_ISCHR(s.st_mode):t=ord('c') elif S_ISFIFO(s.st_mode):t=ord('p') elif S_ISSOCK(s.st_mode):t=ord('s') elif S_ISPORT(s.st_mode):t=ord('P') elif S_ISDOOR(s.st_mode):t=ord('D') elif S_ISWHT(s.st_mode):t=ord('W') else:t=ord('?') if t in types: yield p,s,bytes([t]) return #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ftrget1(apex,**kwargs): """File tree recursion (ftr) getter that gets all paths, optionally sorted by sortkey via key=.""" kfun = kwargs.pop('key',None) pre = 'TypeError: '+__name__+'() ' depth = kwargs.pop('depth',2**62) if kwargs: raise TypeError(pre+'got an unexpected keyword argument '+' '.join([repr(x) for x in kwargs.keys()])) if not isinstance(apex,str): raise TypeError(pre+'apex path is not a string') paths = [] level = [[apex]] deep = 0 while level[0]: if level[-1]: paths.append('/'.join([x[0] for x in level])) try: readlink(apex) names = [] except OSError: try: names = sorted(listdir(apex),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) return paths ftrget = ftrget1 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def ftrget2(apex,**kwargs): """File tree recursion generator that yields all paths, """ \ """with lstat results for each path, """ \ """optionally sorted by sortkey in key=.""" return [(x,stat(x,follow_symlinks=False))for x in ftrget1(apex,**kwargs)] ftrstatget = ftrget2 #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def get_env(n): """Get environment variable value returned in same type as the given name.""" if isinstance(n,str): return environ[n] if isinstance(n,bytes): return tobytes(environ[tostr(n)]) if isinstance(n,bytearray): return bytearray(tobytes(environ[tostr(n)])) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- _get_terminal_size_whcr = namedtuple('get_terminal_size_whcr',('width','height','columns','rows','cols')) def get_terminal_size(fd=1,tty='/dev/tty'): """Return a tuple with terminal screen size width and height. function get_terminal_size aliases columns_rows,cols_rows,width_height options fd= which file descriptor of a terminal tty= which pathname of a terminal purpose return a named tuple with terminal screen width and height result.width result.height result.columns result.rows result.cols """ if fd==1 and tty=='/dev/tty': w,h = os.get_terminal_size() else: try: h,w = unpack('4H',ioctl(fd,TIOCGWINSZ,pack('4H',0,0,0,0)))[:2] except: try: fd = os.open(tty,os.O_WRONLY) h,w = unpack('4H',ioctl(fd,TIOCGWINSZ,pack('4H',0,0,0,0)))[:2] os.close(fd) except: h = w = None return _get_terminal_size_whcr(w,h,w,h,w) colums_rows = get_terminal_size cols_rows = get_terminal_size terminal_geometry = get_terminal_size terminal_size = get_terminal_size width_height = get_terminal_size #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # need to refer to this as layin or something like that but also have an insert as well def insert(base,insert='',position=-3): """Insert a string into a larger string at a given position (negative at end).""" if not isinstrance(insert,str) or len(insert)<1: # if nothing to insert return base if not isinstrance(base,str) or len(base)<1: # if nothing to receive insert return base b = [x for x in base] i = [x for x in insert] if position<0: last = len(base)+position first = last-len(insert) p = first for c in i: b[p] = c p += 1 if first < 0: return False first = position last = first+len(insert) if last >= len(base): return False p = first for c in i: b[p] = c p += 1 return ''.join(b) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def hr(*args,**kwargs): """Return a horizontal rule with optional string at end.""" s = kwargs('size',get_terminal_size()[0]) r = s.cols*'-' 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,default=0): """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 isinstance(bases,int): bases = frozenset({bases}) if not isinstance(bases,_ltsf): 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) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- _interfaceips_46 = namedtuple('_interfaceips_46',['ipv4','ipv6']) def interfaceips(name): """Get IP addresses of specified network interface.""" 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 _interfaceips_46((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 istextlistbytearray(arg): return isinstance(arg,list) and all(isinstance(x,bytearray)for x in arg) def istextlistbytes(arg): return isinstance(arg,list) and all(isinstance(x,bytes)for x in arg) def istextliststr(arg): return isinstance(arg,list) and all(isinstance(x,str)for x in arg) def istextlistbb(arg): return isinstance(arg,list) and all(isinstance(x,_bb)for x in arg) def istextlist(arg): return isinstance(arg,list) and all(isinstance(x,_sbb)for x in arg) def istexttuplebytearray(arg): return isinstance(arg,tuple) and all(isinstance(x,bytearray)for x in arg) def istexttuplebytes(arg): return isinstance(arg,tuple) and all(isinstance(x,bytes)for x in arg) def istexttuplestr(arg): return isinstance(arg,tuple) and all(isinstance(x,str)for x in arg) def istexttuplebb(arg): return isinstance(arg,tuple) and all(isinstance(x,_bb)for x in arg) def istexttuple(arg): return isinstance(arg,tuple) and all(isinstance(x,_sbb)for x in arg) def istextseqbytearray(arg): return isinstance(arg,_lt) and all(isinstance(x,bytearray)for x in arg) def istextseqbytes(arg): return isinstance(arg,_lt) and all(isinstance(x,bytes)for x in arg) def istextseqstr(arg): return isinstance(arg,_lt) and all(isinstance(x,str)for x in arg) def istextseqbb(arg): return isinstance(arg,_lt) and all(isinstance(x,_bb)for x in arg) def istextseq(arg): return isinstance(arg,_lt) and all(isinstance(x,_sbb)for x in arg) def istextbytearray(arg): return isinstance(arg,bytearray) and (not arg or arg[-1] is bytearray(b'\n')) def istextbytes(arg): return isinstance(arg,bytes) and (not arg or arg[-1] is b'\n') def istextstr(arg): return isinstance(arg,str) and (not arg or arg[-1] is '\n') #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def istype(v,t): """Like isinstance, but more flexible, though less efficient.""" # for istype arg2 can be a type or tuple, list, set or frozenset of types. # isinstance is limited to type or tuple of types, only 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 nzp(value=None,negative=None,zero=None,positive=None,other=None): """Return selected object based on sign of a number, or other object.""" if isinstance(value,_ifd): if value<0:return negative if value>0:return positive return zero return other #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def oprint(*args,**kwargs): """Print to stdout with flush.""" if 'file' not in kwargs: kwargs['file']=stdout if 'flush' not in kwargs: kwargs['flush']=True for x in (stderr,stdout): if x!=kwargs.get('file',None): x.flush() return print(*args,**kwargs) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- 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): ns = tostr(n) if isinstance(v,_bb): vs = tostr(v) p = environ[ns] if ns in environ: environ[ns] = vs if isinstance(n,str): return p if isinstance(n,bytes): return tobytes(p) if isinstance(n,bytearray): return tobytearray(p) return None environ[ns] = vs return None #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def pyconfig(*args,**kwargs): """Load a config file in Python format.""" if not args: raise ValueError('pyconfig: no positional arguments') if isinstance(args[0],_lt): args = args[0] if not args: raise ValueError('pyconfig: no items in arguments list/tuple') try: file = open(os.path.expanduser(os.path.join(*args))) code = file.read() file.close() exec(code,kwargs) del kwargs['__builtins__'] except Exception: kwargs = {} return kwargs #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def rangeforever(start=0,increment=1): """Return a range iterator that will last longer than this computer will exist.""" return range(start,2**8192,increment) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def readline(*args,**kwargs): """Read one line from a named file.""" with open(''.join(args),'r',**kwargs) as this: return this.readfile() #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def readlines(*args,**kwargs): """Read lines from a named file.""" lines = kwargs.pop('lines',-1) with open(''.join(args),'r',**kwargs) as this: return this.readfiles(lines=lines) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def s(i): return '' if i is 1 else 's' #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def set_env(n,v): """Set an envionment variable only if it has not been set.""" if isinstance(n,bb): n = tostr(n) if isinstance(v,bb): v = tostr(v) if n not in environ or not environ[n]: environ[n] = v return environ[n] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def set_envs(**kwargs): """Set multiple environment variables from keyword arguments (or a **dictionary).""" p = {k:v for k,v in environ.items()} for k,v in kwargs,items(): environ[k] = v return p #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def snake_to_camel(s): """Convert name from snake_form to camelForm.""" if isinstance(s,bytes): return tobytes(snake_to_camel(tostr(s))) if isinstance(s,bytearray): return tobytearray(snake_to_camel(tostr(s))) return s[:2]+''.join(x.capitalize() or '_' for x in s.split('_'))[2:] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def sleep_interval(interval=1): """Sleep to the next repeating interval.""" if interval<=0: interval=1 sleep(interval-secs()%interval) return #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def sleep_to(to_time): """Sleep to a given absolute time (float seconds), returning the duration.""" try: to_time = int(to_time) except Exception: try: to_time = float(to_time) except Exception: raise TypeError('to time not valid float or int') d = to_time-secs() sleep(d) return d #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def str_to_list(s): """Convert str to a list of ints.""" return [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) tn = ti #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tobytearray(arg): """Convert to bytearray, transparently (no encoding).""" if isinstance(arg,str): return bytearray(ord(x)for x in arg) if isinstance(arg,bytes): return bytearray(arg) if isinstance(arg,_lt): if all(isinstance(x,int)for x in arg): return bytearray(arg) if all(isinstance(x,_if)for x in arg): return bytearray(int(x)for x in arg) if all(isinstance(x,_sbb)for x in arg): _list = [tobytearray(x)for x in arg] if isinstance(arg,list): return _list return tuple(_list) if isinstance(arg,bytearray): return arg raise TypeError(f'cannot convert {arg!r} to bytearray') s2ba = tobytearray toba = tobytearray #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tobytes(arg): """Convert to bytes, transparently (no encoding).""" if isinstance(arg,str): return bytes(ord(x)for x in arg) if isinstance(arg,bytes): return arg if isinstance(arg,_lt): if all(isinstance(x,int)for x in arg): return bytes(arg) if all(isinstance(x,_if)for x in arg): return bytes(int(x)for x in arg) if all(isinstance(x,_sbb)for x in arg): _list = [tobytes(x)for x in arg] if isinstance(arg,list): return _list return tuple(_list) if isinstance(arg,bytearray): return bytes(arg) raise TypeError(f'cannot convert {arg!r} to bytes') s2b = tobytes tob = tobytes #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- 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,_bb): 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 tostr(b): """Convert to str, transparently (no decoding).""" if isinstance(b,_bb): return ''.join(chr(x)for x in b) if isinstance(b,_lt): if all(isinstance(x,int)for x in arg): return tostr(bytes(x for x in arg)) if all(isinstance(x,_if)for x in arg): return tostr(bytes(int(x)for x in arg)) if all(isinstance(x,_sbb)for x in arg): _list = [tostr(x)for x in arg] if isinstance(arg,list): return _list return tuple(_list) if isinstance(b,str): return b error_message = f'cannot convert {b!r} to str' raise TypeError(error_message) b2s = tostr #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tslocal(time=None,fmt=None): """Return a time stamp string from a given time or for now.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ts_fmt return strftime(fmt,localtime(int(time))) ts = tslocal #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsmlocal(time=None,sep='-',pnt=None,fmt=None): """Return a time stamp string with milliseconds.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ts_fmt if pnt is None: pnt = decpnt return strftime(fmt,localtime(int(time))).replace('-',sep)+pnt+str(int((1+time-int(time))*1000))[1:] tsmloc = tsmlocal tsm = tsmlocal #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsmutc(time=None,sep='-',pnt=None,fmt=None): """Return a time stamp string with milliseconds.""" try: time = float(time) except Exception: time = secs() if pnt is None: pnt = decpnt return strftime(fmt,utctime(int(time))).replace('-',sep)+pnt+str(int((1+time-int(time))*1000))[1:] tsmloc = tsmlocal tsm = tsmlocal #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsnlocal(time=None,sep='-',pnt=None,fmt=None): """Return a time stamp string with nanoseconds.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ts_fmt if pnt is None: pnt = decpnt return strftime(fmt,localtime(int(time))).replace('-',sep)+pnt+str(int((1+time-int(time))*1000000000))[1:] tsnloc = tsnlocal tsn = tsnlocal #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsnutc(time=None,sep='-',pnt=None,fmt=None): """Return a time stamp string with nanoseconds.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ts_fmt if pnt is None: pnt = decpnt return strftime(fmt,utctime(int(time))).replace('-',sep)+pnt+str(int((1+time-int(time))*1000000000))[1:] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsulocal(time=None,sep='-',pnt=None,fmt=None): """Return a time stamp string with microseconds.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ts_fmt if pnt is None: pnt = decpnt return strftime(fmt,localtime(int(time))).replace('-',sep)+pnt+str(int((1+time-int(time))*1000000))[1:] tsuloc = tsulocal tsu = tsulocal #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsuutc(time=None,sep='-',pnt=None,fmt=None): """Return a time stamp string with microseconds.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ts_fmt if pnt is None: pnt = decpnt return strftime(fmt,utctime(int(time))).replace('-',sep)+pnt+str(int((1+time-int(time))*1000000))[1:] #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def tsutc(time=None,fmt=None): """Return a time stamp string from a given UTC time or for now.""" try: time = float(time) except Exception: time = secs() if fmt is None: fmt = ts_fmt return strftime(fmt,utctime(int(time))) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def typename(obj): """Return the type as a simple string.""" return str(type(obj)).split("'")[1] typestr = typename #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def uniqnum(): """Return a unique number for this process run.""" return int(time.time()*3906250)*65536+os.getpid() #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def uniqstr(): """Return a unique number for this process run as a string.""" return str(uniqnum()) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def validip(addr): """Return values indicating if the given IP address is valid for IPv4 and/or IPv6. 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. return 10 if the given IP address is ambiguous. 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 (ambiguous) """ 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 """ addr = tostr(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 """ addr = tostr(addr) if ':' not in addr: r = 0 else: try: inet_pton(AF_INET6,addr) r = 6 except (OSError,IOError): r = 0 return r #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def yes_or_no(x,no=False,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,_sbb): x = tostr(x) if x.lower() in n: return no elif 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 ymdhms(): """From time in int or float return just tuple of year,month,date,hour,minute,second""" """ in the same timezone with second as int or float and the others as int.""" return tuple([x for x in gmtime(time_in_seconds)[:5]]+[time_in_seconds%60]) #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # to enable debug tools, set one of these 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. #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- # To enable debugging by default, before importing "sfc", import "sfcdebug", or do this: # if 'SFCdebug' not in environ: # environ['SFCdebug'] = '1' #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- if not _debugmode: def _do_nothing_(*a,**o): return pr = _do_nothing_ pv = _do_nothing_ sl = _do_nothing_ else: print('SFC debugging enabled',file=stderr,flush=True) # 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,**kwargs): kwargs['file'] = kwargs.get('file',stderr) if kwargs.get('file',None)!=stdout: _flush() try: print(*args,**kwargs) kwargs['file'].flush() except BrokenPipeError: pass return # print variables, given their names, or report if undefined def pv(*args,**kwargs): kwargs['file'],c = kwargs.get('file',stderr),kwargs.pop('prefix','') try: if not args: # if nothing to do print(**kwargs) _flush(kwargs['file']) return 0 f = currentframe() if 'f_back' not in dir(f): print(**kwargs) _flush(kwargs['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(kwargs['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:], **kwargs) continue elif not n: # null variable name print(p+c+'............. ', s[0], **kwargs) _flush(kwargs['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', **kwargs) _flush(kwargs['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),**kwargs) else: print(o,repr(n),'=',repr(v),**kwargs) _flush(kwargs['file']) continue except BrokenPipeError: pass return # sleep a specified time after flushing standard files def sl(sec,**kwargs): kwargs.get('file',stdout).flush() _flush() sleep(float(sec)) return #-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.-------.------- def _main(args): eprint() text = """ This is a module to be imported, not a command. Nothing to see here, except code. MOVE ALONG! """ text = text.splitlines()[1:] text = box(text,padh=4) eprint() for line in text: eprint(line) 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