#!/usr/bin/env python # encoding: utf-8 import sys import os from Naked.settings import debug as DEBUG_FLAG #------------------------------------------------------------------------------ # # FILE & DIRECTORY PATHS # #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # [ filename function ] (string) # returns file name from a file path (including the file extension) # Tests: test_SYSTEM.py :: test_sys_filename #------------------------------------------------------------------------------ def filename(filepath): try: return os.path.basename(filepath) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return base filename from filename() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ file_extension function ] (string) # returns file extension from a filepath # Tests: test_SYSTEM.py :: test_sys_file_extension #------------------------------------------------------------------------------ def file_extension(filepath): try: return os.path.splitext(filepath)[1] except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return file extension with file_extension() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ directory function ] (string) # returns directory path to the filepath # Tests: test_SYSTEM.py :: test_sys_dir_path #------------------------------------------------------------------------------ def directory(filepath): try: return os.path.dirname(filepath) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return directory path to file with directory() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ make_path function ] (string) # returns OS independent file path from tuple of path components # Tests: test_SYSTEM.py :: test_sys_make_filepath #------------------------------------------------------------------------------ def make_path(*path_list): try: return os.path.join(*path_list) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to make OS independent path with the make_path() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ currentdir_to_basefile decorator function ] (returns decorated original function) # concatenates the absolute working directory path to the basename of file in the first parameter of the undecorated function # Tests: test_SYSTEM.py :: test_sys_add_currentdir_path_to_basefile #------------------------------------------------------------------------------ def currentdir_to_basefile(func): try: from functools import wraps @wraps(func) def wrapper(file_name, *args, **kwargs): current_directory = os.getcwd() #get current working directory path full_path = os.path.join(current_directory, file_name) # join cwd path to the filename for full path return func(full_path, *args, **kwargs) #return the original function with the full path to file as first argument return wrapper except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: error with the currentdir_to_basefile() decorator function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ currentdir_firstparam decorator function ] (returns decorated original function) # adds the current working directory as the first function parameter of the decorated function # Tests: test_SYSTEM.py :: test_sys_add_currentdir_path_first_arg #------------------------------------------------------------------------------ def currentdir_firstparam(func): try: from functools import wraps @wraps(func) def wrapper(dir="", *args, **kwargs): current_directory = os.getcwd() return func(current_directory, *args, **kwargs) return wrapper except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: error with the currentdir_firstargument() decorator function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ currentdir_lastargument decorator function ] (returns decorated original function) # adds the current working directory as the last function parameter of the decorated function # Note: you cannot use other named arguments in the original function with this decorator # Note: the current directory argument in the last position must be named current_dir # Tests: test_SYSTEM.py :: test_sys_add_currentdir_last_arg #------------------------------------------------------------------------------ def currentdir_lastparam(func): try: from functools import wraps @wraps(func) def wrapper(*args, **kwargs): the_cwd = os.getcwd() return func(*args, current_dir=the_cwd) return wrapper except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: error with the currentdir_lastargument() decorator function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ fullpath function ] (string) # returns the absolute path to a file that is in the current working directory # file_name = the basename of the file in the current working directory # Example usage where test.txt is in working directory: # filepath = fullpath("test.txt") # Tests: test_SYSTEM.py :: test_sys_full_path_to_file #------------------------------------------------------------------------------ @currentdir_to_basefile # current directory decorator - adds the directory path up to the filename to the basefile name argument to original function def fullpath(file_name): try: return file_name except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return absolute path to the file with the fullpath() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ cwd function ] (string) # returns the current working directory path # does not need to be called with an argument, the decorator assigns it # Example usage: # current_dir = cwd() # Tests: test_SYSTEM.py :: test_sys_cwd_path #------------------------------------------------------------------------------ @currentdir_firstparam def cwd(dir=""): try: return dir except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return the current working directory with the cwd() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # # DIRECTORY WRITES # #------------------------------------------------------------------------------ ## TODO: add tests #------------------------------------------------------------------------------ # [ make_dirs function ] (--none--) # make a new directory path (recursive if multiple levels of depth) if it # DOES NOT already exist #------------------------------------------------------------------------------ def make_dirs(dirpath): try: import os import errno os.makedirs(dirpath) return True except OSError as ose: if ose.errno != errno.EEXIST: # directory already exists if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: Could not write the directory path passed as an argument to the make_dirs() function (Naked.toolshed.system).") raise ose else: return False except Exception as e: raise e #------------------------------------------------------------------------------ # # FILE & DIRECTORY TESTING # #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # [ file_exists function ] (boolean) # return boolean for existence of file in specified path # Tests: test_SYSTEM.py :: test_file_exists #------------------------------------------------------------------------------ def file_exists(filepath): try: if os.path.exists(filepath) and os.path.isfile(filepath): # test that exists and is a file return True else: return False except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: error with test for the presence of the file with the file_exists() method (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ is_file function ] (boolean) # returns boolean for determination of whether filepath is a file # Tests: test_SYSTEM.py :: test_sys_is_file, test_sys_is_file_missing_file, # test_sys_is_file_when_dir #------------------------------------------------------------------------------ def is_file(filepath): try: return os.path.isfile(filepath) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: error with test for file with the is_file() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ dir_exists function ] (boolean) # return boolean for existence of directory in specified path # Tests: test_SYSTEM.py :: test_dir_exists, test_dir_exists_missing_dir #------------------------------------------------------------------------------ def dir_exists(dirpath): try: if os.path.exists(dirpath) and os.path.isdir(dirpath): # test that exists and is a directory return True else: return False except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: error with test for directory with the dir_exists() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ is_dir function ] (boolean) # returns boolean for determination of whether dirpath is a directory # Tests: test_SYSTEM.py :: test_sys_dir_is_dir, test_sys_dir_is_dir_when_file, # test_sys_dir_is_dir_when_missing #------------------------------------------------------------------------------ def is_dir(dirpath): try: return os.path.isdir(dirpath) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: error with test for directory with the is_dir() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # # FILE METADATA # #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # [ filesize function ] (int) # return file size in bytes # Tests: test_SYSTEM.py :: test_sys_meta_file_size #------------------------------------------------------------------------------ def file_size(filepath): try: return os.path.getsize(filepath) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return file size with the file_size() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ file_mod_time function ] (string) # return the last file modification date/time # Tests: test_SYSTEM.py :: test_sys_meta_file_mod #------------------------------------------------------------------------------ def file_mod_time(filepath): try: import time return time.ctime(os.path.getmtime(filepath)) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return file modification data with the file_mod_time() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # # FILE LISTINGS # #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # [ list_all_files function ] (list) # returns a list of all files in developer specified directory # Tests: test_SYSTEM.py :: test_sys_list_all_files, test_sys_list_all_files_emptydir #------------------------------------------------------------------------------ def list_all_files(dir): try: filenames = [name for name in os.listdir(dir) if os.path.isfile(os.path.join(dir, name))] return filenames except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to generate directory file list with the list_all_files() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ list_filter_files function ] (list) # returns a list of files filtered by developer defined file extension in developer defined directory # Usage example: # filenames = list_filter_files("py", "tests") # Tests: test_SYSTEM.py :: test_sys_list_filter_files, test_sys_list_filter_files_nomatch #------------------------------------------------------------------------------ def list_filter_files(extension_filter, dir): try: if not extension_filter.startswith("."): extension_filter = "." + extension_filter filenames = [name for name in os.listdir(dir) if name.endswith(extension_filter)] return filenames except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return list of filtered files with the list_filter_files() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ list_all_files_cwd function ] (list) # returns a list of all files in the current working directory # Note: does not require argument, the decorator assigns the cwd # Usage example: # file_list = list_all_files_cwd() # Tests: test_SYSTEM.py :: test_sys_list_all_files_cwd #------------------------------------------------------------------------------ @currentdir_firstparam def list_all_files_cwd(dir=""): try: return list_all_files(dir) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return list of all files in current working directory with the list_all_files_cwd() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ list_filter_files_cwd function ] (list) # returns a list of all files in the current working directory filtered by developer specified file extension # Note: do not specify the second argument, decorator assigns it # Usage example: # file_list = list_filter_files_cwd(".py") # Tests: test_SYSTEM.py :: test_sys_filter_files_cwd, test_sys_filter_files_cwd_nomatch #------------------------------------------------------------------------------ @currentdir_lastparam def list_filter_files_cwd(extension_filter, current_dir=""): try: return list_filter_files(extension_filter, current_dir) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return list of filtered files in current working directory with the list_filter_files_cwd() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ list_match_files function ] (list) # returns a list of all files that match the developer specified wildcard match pattern # can optionally specify return of full path to the files (rather than relative path from cwd) by setting full_path to True # Usage examples: # file_list = list_match_files("*.py") # file_list_fullpath = list_match_files("*.py", True) # Tests: test_SYSTEM.py :: test_sys_match_files, test_sys_match_files_fullpath #------------------------------------------------------------------------------ def list_match_files(match_pattern, full_path = False): try: from glob import glob filenames = glob(match_pattern) if full_path: filenames_fullpath = [] cwd = os.getcwd() for name in filenames: name = os.path.join(cwd, name) #make the full path to the file filenames_fullpath.append(name) #add to the new list return filenames_fullpath #then return that list else: return filenames except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return list of matched files with the list_match_files() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # # SYMBOLIC LINK TESTING # #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # [ is_link function ] (boolean) # return boolean indicating whether the path is a symbolic link #------------------------------------------------------------------------------ def is_link(filepath): try: return os.path.islink(filepath) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to determine whether path is a symbolic link with the is_link() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ real_path function ] (string) # return the real file path pointed to by a symbolic link #------------------------------------------------------------------------------ def real_path(filepath): try: return os.path.realpath(filepath) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to return real path for symbolic link with the real_path() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # # DATA STREAMS # #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # [ stdout function ] # print to std output stream #------------------------------------------------------------------------------ def stdout(text): try: print(text) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to print to the standard output stream with the stdout() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ stdout_xnl function ] # print to std output stream without a newline #------------------------------------------------------------------------------ def stdout_xnl(text): try: sys.stdout.write(text) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to print to the standard output stream with the stdout_xnl() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ stdout_iter function ] # print items in an iterable to the standard output stream with newlines after each string #------------------------------------------------------------------------------ def stdout_iter(iter): try: for x in iter: stdout(x) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to print to the standard output stream with the stdout_iter() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ stdout_iter_xnl function ] # print items in an iterable to the standard output stream without newlines after each string #------------------------------------------------------------------------------ def stdout_iter_xnl(iter): try: for x in iter: stdout_xnl(x) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to print to the standard output stream with the stdout_iter() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ stderr function ] # print to std error stream # optionally (i.e. if exit = nonzero integer) permits exit from application with developer defined exit code #------------------------------------------------------------------------------ def stderr(text, exit=0): try: sys.stderr.write(text + "\n") if exit: raise SystemExit(exit) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to print to the standard error stream with the stderr() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # [ stderr_xnl function ] # print to the standard error stream without a newline character after the `text` string #------------------------------------------------------------------------------ def stderr_xnl(text, exit=0): try: sys.stderr.write(text) if exit: raise SystemExit(exit) except Exception as e: if DEBUG_FLAG: sys.stderr.write("Naked Framework Error: unable to print to the standard error stream with the stderr() function (Naked.toolshed.system).") raise e #------------------------------------------------------------------------------ # # APPLICATION CONTROL # #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # [ exit_with_status function ] # application exit with developer specified exit status code (default = 0) # use an exit status integer argument # Tests: test_SYSTEM.py :: test_sys_exit_with_code #------------------------------------------------------------------------------ def exit_with_status(exit=0): raise SystemExit(exit) #------------------------------------------------------------------------------ # [ exit_fail function ] # application exit with status code 1 # Tests: test_SYSTEM.py :: test_sys_exit_failure #------------------------------------------------------------------------------ def exit_fail(): raise SystemExit(1) #------------------------------------------------------------------------------ # [ exit_success function] # application exit with status code 0 # Tests: test_SYSTEM.py :: test_sys_exit_success #------------------------------------------------------------------------------ def exit_success(): raise SystemExit(0) if __name__ == '__main__': pass # #------------------------------------------------------------------------------ # # Standard Output Tests # #------------------------------------------------------------------------------ # stdout("This is a test") # for x in range(10): # stdout_xnl(str(x) + " ") # list_ten = ['10% ', '20% ', '30% ', '40% ', '50% ', '60% ', '70% ', '80% ', '90% ', '100%'] # stdout_iter(list_ten) # #------------------------------------------------------------------------------ # # Standard Error Tests # #------------------------------------------------------------------------------ # stderr("This is a test") # stderr("This is a test", 1) #exit with status code 1