cmdpackage 0.1.3__py3-none-any.whl

cmdpackage-0.1.3.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: cmdpackage
+Version: 0.1.3
+Summary: Automated python package generator for CLI function calls
+Author-email: mpytel <mpytel@domain.com>
+Maintainer-email: mpytel <mpytel@domain.com>
+Project-URL: Homepage, https://github.com/mpytel/cmdpackage
+Project-URL: Bug Tracker, https://github.com/mpytel/cmdpackage/issues
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Command Package (cmdpackage)
+
+## Table of Contents
+
+- [Command Package (cmdpackage)](#command-package-cmdpackage)
+  - [Table of Contents](#table-of-contents)
+  - [Introduction](#introduction)
+  - [Standard Installation from PyPI](#standard-installation-from-pypi)
+    - [Using cmdpackage to Create New Python Packages](#using-cmdpackage-to-create-new-python-packages)
+    - [Modifying New Python Packages](#modifying-new-python-packages)
+      - [Install New Editable Python Package](#install-new-editable-python-package)
+  - [Editable cmdpackage Installation](#editable-cmdpackage-installation)
+    - [Automated Default New Package Setup with `cmdpackage.sh`](#automated-default-new-package-setup-with-cmdpackagesh)
+
+-----
+
+## Introduction
+
+**cmdpackage** is a pip package that generates opinionated Python command-line program packages. These derived program packages automate the creation of new CLI program commands that you can modify in a development environment. `cmdpackage` can be installed as a standard (or "production") installation or as an editable (or "development") installation directly from GitHub.
+
+-----
+
+## Standard Installation from PyPI
+
+A standard installation allows a user to quickly create derived program packages.
+
+```bash
+pip install cmdpackage
+```
+
+The derived program packages will be modified in a virtual Python development environment using `virtualenv`. This virtual environment is isolated as a self-contained Python installation with its own `site-packages` directory. This isolation prevents dependency conflicts between different projects.
+
+```bash
+pip install virtualenv
+```
+
+### Using cmdpackage to Create New Python Packages
+
+Once installed, you can create a package directory for your new Python package (e.g., `myTypes`) and run `cmdpackage` to generate the necessary files within this directory.
+
+```
+mkdir $HOME/myTypes
+cd $HOME/myTypes
+cmdpackage
+```
+
+You will be asked standard package generation questions:
+
+```
+name (myTypes):
+version (0.1.0):
+description (myTypes pip package):
+readme ():
+license (MIT License):
+authors (username):
+authorsEmail (username@domain.com):
+maintainers (username):
+maintainersEmail (username@domain.com):
+classifiers ():
+commit a git repo [Y/n]?:
+```
+
+The **default input** for each question is the bracketed value. The username will be set to your global Git config name if Git is present; otherwise, your system login username will be used.
+
+### Modifying New Python Packages
+
+You're now ready to work on your new Python package, `myTypes`, by first activating a Python virtual development environment.
+
+  * **Activation Process:** To use a virtual environment, you must **activate** it. This is typically done by running a script within the environment's directory:
+
+      * On Linux/macOS: `source /path/to/myTypes/env/bin/activate`
+      * On Windows: `/path/to/myTypes/env/Scripts/activate` **(Not tested on Windows)**
+
+    Activating the environment modifies your terminal's shell session, primarily by adjusting your `PATH` environment variable. This ensures that when you type `python` or `pip`, you are using the Python interpreter and package manager from within that specific virtual environment, rather than your system's global Python.
+
+    **Deactivation Process:** When you **deactivate** a virtual environment, you return to the System/Global Python Environment.
+
+      * Execute: `deactivate`
+
+#### Install New Editable Python Package
+
+```
+pip install -e .
+```
+
+Executing `pip list` results in the following output, showing the localized package installation in the Python virtual environment:
+
+```
+Package    Version Editable project location
+---------- ------- -----------------------------------
+myTypes    0.1.0   /Users/<username>/proj/python/myTypes
+pip        25.1.1
+setuptools 80.9.0
+wheel      0.45.1
+```
+
+Your new `myTypes` program is now ready to use as a launching point for your Python CLI development. A list of installed commands can be found using:
+
+```
+myTypes -h
+```
+
+To add a new command named `type` – which will record a token, a title representing the type of information this token represents, and a short description of what it is and where it can be used – use the following command:
+
+```
+myTypes newCmd type token title sd
+```
+
+You will then be prompted to enter help text for the command and each of the arguments you defined (`type`, `title`, `sd`):
+
+1.  Enter a description of the 'type' command:
+    *Records a token that represents a type of data or information.*
+2.  Enter a description of the 'token' argument:
+    *The token that represents a type of data or information.*
+3.  Enter a description of the 'title' argument:
+    *The title of the token that represents a type of data or information.*
+4.  Enter a description of the 'sd' argument:
+    *A short description of the type of data or information is entered for sd.*
+
+Run the new `myTypes type` command:
+
+```
+myTypes type int integer 'An integer is a whole number that can be positive, negative, or zero.'
+```
+
+The path to the Python file that needs your modification (`type.py`) is displayed as output, along with the values of the three arguments (type, title, sd):
+
+```
+DEBUG: Modify default behavior in myTypes/commands/type.py
+INFO: token: int
+INFO: title: integer
+INFO: sd: An integer is a whole number that can be positive, negative, or zero.
+```
+
+The `rmCmd` is used to remove a command from your `myTypes` program.
+
+```
+myTypes rmCmd run
+```
+
+-----
+
+## Editable cmdpackage Installation
+
+Modifying a clone of the `cmdpackage` GitHub repository allows a developer to change the initial files of new commands added to `cmdpackage` derived Python packages. The following commands are used to clone and install `cmdpackage` in a virtual environment for this purpose:
+
+```bash
+mkdir $HOME/proj
+cd  $HOME/proj
+git clone https://github.com/mpytel/cmdpackage.git
+cd cmdpackage
+pip install -e .
+```
+
+We purposely installed `cmdpackage` in the System/Global Python Environment. `cmdpackage` is then used to generate program packages that run in Virtual Python Environments set up by `cmdpackage` when run in a new Python package directory for modification in a development environment. This is performed using the commands described in the two above sections:
+
+1.  [Creating a new package](#using-cmdpackage-to-create-new-python-packages)
+2.  [Modifying new python packages](#modifying-new-python-packages)
+
+### Automated Default New Package Setup with `cmdpackage.sh`
+
+A shell script (`cmdpackage.sh`) is provided in the `cmdpackage` directory to automate the creation of a new package using default setup values. This script creates and changes the working directory to one named after your program package. It then creates and activates a virtual environment within this directory, and installs the `cmdpackage` pip package from the local repository. It then creates the new package and uninstalls `cmdpackage` from the new package's virtual environment. The new package is installed and run to create a 'helloWorld' command to test and illustrate the `newCmd` command that is provided with the new derived package.
+
+From any directory, execute the following command to run this shell script:
+
+```bash
+source $HOME/proj/python/cmdpackage/cmdpackage.sh myPack
+```
+
+If you prefer not to use the `cmdpackage.sh` shell script, the manual command steps used to create/install/use a new package (`myPack`) with a new 'helloWorld' command are:
+
+```bash
+mkdir myPack
+cd myPack
+virtualenv env/myPack
+source env/myPack/bin/activate
+pip install $HOME/proj/python/cmdpackage
+cmdpackage
+   # Press the return key 11 times to accept the default values.
+pip uninstall cmdpackage
+   # Press the return key to accept the default value Y.
+pip install -e .
+myPack newCmd helloWorld greeting
+   # When prompted by 'Enter help description for helloWorld:'
+   # enter: 'Echo the greeting text.'
+   # When prompted by 'Enter help description for greeting:'
+   # enter: 'The text to echo.'
+myPack helloWorld "You're ready to add and remove commands, and modify code in your myPack project!"
+```
+
+The following output results from executing `myPack helloWorld`:
+
+```
+DEBUG: Modify default behavior in myPack/commands/helloWorld.py
+INFO: greeting: You're ready to add and remove commands, and modify code in your myPack project!
+```

cmdpackage-0.1.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+cmdpackage-0.1.3.dist-info/licenses/LICENSE,sha256=I-KXocS3ZqDVWR09w3y-b41lJG1RLsYM3SYN5Haudo0,1069
+src/__init__.py,sha256=jVjBxmyRJ5OTQ9ty5aZr_FR2LOa8vnLo1Z06edN-u6s,2651
+src/defs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/defs/createzVirtualEnv.py,sha256=ZKsf_y82pRK_ExpEcAg7LfwNl6arwBFZYwtF5ZCBCiU,1008
+src/defs/runSubProc.py,sha256=J-TVMYkrsmf8UnmA5KYco6Wso2XfyNp-0QEN5P6-cZY,356
+src/defs/writeCLIPackage.py,sha256=rfvQmX9CkpwUqQnMoCYCoPxEE_le78A128GQXBdzfjk,3610
+src/defs/writePyProject.py,sha256=KA5p07WyXZvJ-SG70831EcE-KoK4suZanDsxrGIzp20,4582
+src/defs/writeSetup.py,sha256=t3S1vR8en9rDPoMGZfBgoZpHDzCGmDsvY_6M1MnjKhk,3868
+src/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/templates/cmdTemplate.py,sha256=6sffPLlGAYNO-KxXX9VL8AsD0FX-K3R4QSB49I2tc_0,27384
+src/templates/pyprojectTemplate.py,sha256=9f-AKvbAWzHhDHvsh4Yk1TeATJi1RIecic4vrmAK5ns,1778
+src/templates/setupTemplates.py,sha256=SVmUVP0anIaSGWBVby-eqDoksHMTR4C8wl31qAKCdp0,1720
+cmdpackage-0.1.3.dist-info/METADATA,sha256=TP60x6NoWlNBKdruZAEMP_2f14yts_56JtGHTfRm7sQ,8865
+cmdpackage-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cmdpackage-0.1.3.dist-info/entry_points.txt,sha256=AMwJtkreLnhYlrSO2lms8N_aeFxXiIvryvUnIPNoADQ,40
+cmdpackage-0.1.3.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+cmdpackage-0.1.3.dist-info/RECORD,,

cmdpackage-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cmdpackage-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cmdpackage = src:main

cmdpackage-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Martin Pytel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cmdpackage-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/__init__.py

@@ -0,0 +1,73 @@
+import os
+from .defs.writePyProject import writePyProject
+from .defs.writeCLIPackage import writeCLIPackage
+from .defs.createzVirtualEnv import createzVirtualEnv
+import sys
+from pathlib import Path
+
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+def main():
+    projName = ''
+    askForDirChange = False
+    if len(sys.argv) > 1:
+        projName: str = sys.argv[1]
+        # set the working directory to cwd+projName
+        askForDirChange = ensure_and_cd_to_directory(projName)
+    else:
+        projName = Path(os.getcwd()).stem
+    fields: dict[str,str] = writePyProject()
+    writeCLIPackage(fields)
+    createzVirtualEnv(fields)
+    print(f'*** Activate and install {projName} virtual enviroment ***')
+    if askForDirChange:
+        print(f'{GREEN}execute{RESET}: cd {projName}')
+    print(f'{GREEN}execute{RESET}: . env/{projName}/bin/activate')
+    print(f'{GREEN}execute{RESET}: pip install -e .')
+
+if __name__ == '__main__':
+    main()
+
+def ensure_and_cd_to_directory(target_dir_name: str) -> bool:
+    """
+    Checks if a target directory exists in the current working directory.
+    If it exists, changes the current working directory to it.
+    If it does not exist, creates the directory and then changes the working directory to it.
+
+    Args:
+        target_dir_name: The name of the target directory (e.g., "my_project").
+
+    Returns:
+        True if the operation was successful, False otherwise.
+    """
+    # Get the current working directory
+    chkForExistingProject = False
+    current_cwd = os.getcwd()
+    current_cwd_path = Path(current_cwd)
+    target_path = current_cwd_path.joinpath(target_dir_name)
+    # Construct the full path to the target directory
+    try:
+        # Check if the directory already exists
+        if target_path.is_dir():
+            files = [i for i in target_path.iterdir()]
+            if len(files) == 0:
+                if current_cwd_path.stem != target_dir_name:
+                    os.chdir(target_path)
+                    theCWD = os.getcwd()
+                    print(f"Changing working directory to: {theCWD}")
+            else:
+                print(f"Program directory exits and contains files.")
+                return False
+        else:
+            # Directory does not exist, create it
+            # os.makedirs can create intermediate directories if needed
+            os.makedirs(target_path)
+            os.chdir(target_path)
+            theCWD = os.getcwd()
+            print(f"Changing working directory to: {theCWD}")
+        return True
+    except OSError as e:
+        print(
+            f"Error: Could not process directory '{target_dir_name}'. Reason: {e}")
+        return False

src/defs/createzVirtualEnv.py

@@ -0,0 +1,27 @@
+from .runSubProc import runSubProc
+
+def createzVirtualEnv(fields: dict):
+    try:
+        yellow = "\033[33m"
+        reset = "\033[0m"
+        name = "name"
+        rtnCompProc = runSubProc(f'virtualenv env/{fields[name]}')
+        print(
+            f'* Source the virtual environment with:  {yellow}. env/{fields[name]}/bin/activate{reset}')
+        print(
+            f'* Install "{fields[name]}" with:  {yellow}pip install -e .{reset}')
+        print(f'* Verify install with:  {yellow}pip list{reset}')
+        print(
+            f'* Restore original shell environment with: {yellow}deactivate{reset}\n')
+        print(
+            f'* Create and test first new command:\n' + \
+            f'  {yellow}{fields[name]} newCmd firstCMD firstARG{reset}\n' + \
+            f'  {yellow}{fields[name]} -h{reset}\n' + \
+            f'  {yellow}{fields[name]} firstCMD firstARG{reset}\n' + \
+            f'  {yellow}{fields[name]} rmCmd firstCMD{reset}\n')
+    except:
+        print(rtnCompProc)
+        pass
+
+
+

src/defs/runSubProc.py

@@ -0,0 +1,10 @@
+from subprocess import run, DEVNULL, CompletedProcess
+
+def runSubProc(theCmd: str, noOutput=True) -> CompletedProcess:
+    if noOutput:
+        rtnCompProc = run(theCmd, shell=True,
+                                stdout=DEVNULL,
+                                stderr=DEVNULL)
+    else:
+        rtnCompProc = run(theCmd, shell=True)
+    return rtnCompProc

src/defs/writeCLIPackage.py

@@ -0,0 +1,98 @@
+import os, json
+from ..templates.cmdTemplate import \
+    initFile, logPrintTemplate, \
+    commandsFileStr, commandsJsonDict, \
+    cmdSwitchbordFileStr, cmdOptSwitchbordFileStr, \
+    argParseTemplate, optSwitchesTemplate, \
+    newCmdStr, modCmdStr, rmCmdStr, \
+    newCmdTemplateStr, argDefTemplateStr
+
+def writeCLIPackage(fields: dict):
+    print()
+    field_name = "name"
+    programName = fields[field_name]
+    # -- package dir files
+    ## write __init__.py to package dir from str
+    packDir = os.path.join(os.path.abspath("."),'src')
+    print('packDir:', str(packDir))
+    chkDir(packDir)
+    fileName = os.path.join(packDir,"__init__.py")
+    with open(fileName,"w") as wf:
+        wf.write(initFile)
+
+    # -- defs dir files
+    ## write logPrint.py def for def dir from template
+    dirName = os.path.join(packDir,"defs")
+    fileName = os.path.join(dirName,"logIt.py")
+    fileStr = logPrintTemplate.substitute(name=programName)
+    chkDir(dirName)
+    with open(fileName,"w") as wf:
+        wf.write(fileStr)
+
+    # -- classes dir files
+    #write argPars.py to class directory from template
+    field_name = "description"
+    description = fields[field_name]
+    dirName = os.path.join(packDir,"classes")
+    fileName = os.path.join(dirName,"argParse.py")
+    fileStr = argParseTemplate.substitute(description=description)
+    chkDir(dirName)
+    with open(fileName,"w") as wf:
+        wf.write(fileStr)
+    ## write optSwitches.py to clsass dir from template
+    fileName = os.path.join(dirName,"optSwitches.py")
+    fileStr = optSwitchesTemplate.substitute(name=programName)
+    with open(fileName,"w") as wf:
+        wf.write(fileStr)
+
+    # -- commands dir files
+    ## write commands.py Commands class file
+    dirName = os.path.join(packDir,"commands")
+    fileName = os.path.join(dirName,"commands.py")
+    chkDir(dirName)
+    with open(fileName,"w") as wf:
+        wf.write(commandsFileStr)
+    # write commands.json to commands dir from dict
+    fileName = os.path.join(dirName,"commands.json")
+    with open(fileName,"w") as wf:
+        cmdJson = json.dumps(commandsJsonDict,indent=2)
+        wf.write(cmdJson)
+    ## write cmdSwitchbord.py to def dir from str
+    fileName = os.path.join(dirName,"cmdSwitchbord.py")
+    with open(fileName,"w") as wf:
+        wf.write(cmdSwitchbordFileStr)
+    ## write cmdOptSwitchbord.py to def dir from str
+    fileName = os.path.join(dirName,"cmdOptSwitchbord.py")
+    with open(fileName,"w") as wf:
+        wf.write(cmdOptSwitchbordFileStr)
+    ## write newCmd.py to commands dir from str
+    fileName = os.path.join(dirName,"newCmd.py")
+    with open(fileName,"w") as wf:
+        wf.write(newCmdStr)
+    ## write rmCmd.py to commands dir from str
+    fileName = os.path.join(dirName,"modCmd.py")
+    with open(fileName,"w") as wf:
+        wf.write(modCmdStr)
+    ## write rmCmd.py to commands dir from str
+    fileName = os.path.join(dirName,"rmCmd.py")
+    with open(fileName,"w") as wf:
+        wf.write(rmCmdStr)
+
+    # -- commands\templates dir files
+    ## write newCmd.py template file
+    dirName = os.path.join(dirName, "templates")
+    fileName = os.path.join(dirName,"newCmd.py")
+    chkDir(dirName)
+
+    fileStr = "from string import Template\n"
+    fileStr += "from textwrap import dedent\n\n"
+    fileStr += f'cmdDefTemplate = Template(dedent("""{newCmdTemplateStr}\n"""))\n\n'
+    fileStr += f'argDefTemplate = Template(dedent("""{argDefTemplateStr}\n"""))'
+    with open(fileName,"w") as wf:
+        wf.write(fileStr)
+
+def chkDir(dirName: str):
+    if not os.path.isdir(dirName):
+        os.makedirs(dirName, exist_ok=True)
+
+

src/defs/writePyProject.py

@@ -0,0 +1,140 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+from ..templates.pyprojectTemplate import (
+    pyproject_base_template, gitignore_content, classifiers_line,
+    classifiers_template)
+from sys import version_info
+from .runSubProc import runSubProc
+from subprocess import Popen, PIPE
+from getpass import getuser
+import os
+
+
+def writePyProject() -> dict[str,str]:
+    rtnDict = {}
+    fields = ['name', 'version', 'description', 'readme',
+              'license', 'authors', 'authorsEmail', 'maintainers', 'maintainersEmail', 'classifiers']
+
+    for field_name in fields:
+        default_value = default_values(field_name)
+        if field_name == 'description':
+            default_value = default_value.replace('name', rtnDict['name'])
+        input_msg = input_message(field_name, default_value)
+        input_value = get_input(input_msg, default=default_value)
+        rtnDict[field_name] = input_value
+
+    pyproject_content = pyproject_base_template.substitute(
+        name=rtnDict['name'],
+        version=rtnDict['version'],
+        description=rtnDict['description'],
+        readme=rtnDict['readme'],
+        license=rtnDict['license'],
+        authors=rtnDict['authors'],
+        authorsEmail=rtnDict['authorsEmail'],
+        maintainers=rtnDict['maintainers'],
+        maintainersEmail=rtnDict['maintainersEmail'],
+        classifiers=gen_classifiers()
+    )
+
+    with open('pyproject.toml', 'w') as pyproject_file:
+        write_content(pyproject_file, pyproject_content)
+
+    with_gitignore = get_input('commit a git repo [Y/n]?: ',
+                               default='y')
+    if with_gitignore.lower() == 'y':
+        with open('.gitignore', 'w') as gitignore_file:
+            write_content(gitignore_file, gitignore_content)
+        initGitRepo()
+    return rtnDict
+
+
+def input_message(field_name, default_value):
+    return u'{} ({}): '.format(field_name, default_value)
+
+
+def gen_classifiers():
+    mayor, minor = version_info[:2]
+    python = "Programming Language :: Python"
+    local = "Programming Language :: Python :: {}.{}".format(mayor, minor)
+    classifiers = [python, local]
+
+    classifiers_lines = ''
+    for cls in classifiers:
+        classifiers_lines += classifiers_line.substitute(classifier=cls)
+
+    return classifiers_template.substitute(classifiers=classifiers_lines)
+
+
+def initGitRepo():
+    rtnStr = runSubProc('ls .git')
+    if rtnStr.returncode != 0:
+        rtnStr = runSubProc(f'git init')
+    if rtnStr.returncode == 0:
+        rtnStr = runSubProc(f'git add .')
+    if rtnStr.returncode == 0:
+        rtnStr = runSubProc(f'git commit -m "inital commit"', noOutput=False)
+
+
+def get_username():
+    '''Get git config values.'''
+    username = ''
+
+    # use try-catch to prevent crashes if user doesn't install git
+    try:
+        # run git config --global <key> to get username
+        git_command = ['git', 'config', '--global', 'user.name']
+        p = Popen(git_command, stdout=PIPE, stderr=PIPE)
+        output, err = p.communicate()
+
+        # turn stdout into unicode and strip it
+        username = output.decode('utf-8').strip()
+
+        # if user doesn't set global git config name, then use getuser()
+        if not username:
+            username = getuser()
+    except OSError:
+        # if git command is not found, then use getuser()
+        username = getuser()
+
+    return username
+
+
+#fields = ['name', 'version', 'description', 'readme',
+#          'license', 'author', author email, 'maintainer', 'maintainer email', 'classifiers']
+def default_values(field_name):
+    if field_name == 'name':
+        rtnStr = os.path.relpath('.', '..')
+        rtnStr = rtnStr.replace("-", "_")
+        return rtnStr
+    if field_name == 'version':
+        return '0.1.0'
+    elif field_name == 'description':
+        return 'name pip package'
+    elif field_name == 'license':
+        return 'MIT License'
+    elif field_name == 'authors':
+        return get_username()
+    elif field_name == 'authorsEmail':
+        return f'{get_username()}@domain.com'
+    elif field_name == 'maintainers':
+        return get_username()
+    elif field_name == 'maintainersEmail':
+        return f'{get_username()}@domain.com'
+    else: return ''
+
+def get_input(input_msg, default=None):
+    if version_info >= (3, 0):
+        input_value = input(input_msg)
+    else:
+        input_value = input_msg.encode('utf8').decode('utf8')
+
+    if input_value == '':
+        return default
+    return input_value
+
+
+def write_content(file, content):
+    if version_info >= (3, 0):
+        file.write(content)
+    else:
+        file.write(content.encode('utf8'))