Saravanan666/pypi-org huggingface dataset:
Package: terminalpyth
TerminalPythLibrary that allows you to call terminal commands in python whithout discarding director changes (unlike os.system() method does).Installation:$ pip install terminalpythUsage:import terminalpyCreate a terminalpy object. Pass True or False as argument if you want (or not) to have back the output.trm = terminalpy.Terminal(output=True)Only one straight-forward method: type. Pass inside it the command you want to be executed.output = trm.type('pwd')

# in this case, returns path to the current directory,
# which in this case is stored in "output"It works with pretty much every terminal command.To use "sudo", if you are not in a terminal session itself, you must add the "-S" option,
to read the password from IDE (e.g. Pycharm).trm.clear()This command clears the memory of the directory changes, returning back to the project foler.trm.setOutput(output=False)Changes the state of the return action. If "False", there will be no return value, otherwise there will.The method allows to change the state during the session.Example:Imagine a basic directory tree:- home
    - python
        - project1
            - main.py
        - prokect2
            - main2.py
    - cpp
        - project3This is the difference between TerminalPyth and os, receiving the same exact instructions:# /home/python/project1/main.py
import terminalpy as tp

term = tp.Terminal(output=True)

path = term.type('pwd')
print(path)
# output: /home/python/project1

term.type('cd ..')
print(term.type('ls')
# output:   project1
#           project2

term.type('cd ..')
term.type('cd cpp')
print(term.type('pwd'))
# output: /home/cpp

term.clear()
print(term.type('pwd'))
# output: /home/python/project1

--------------------------------

# /home/python/project2/main2.py
import os

os.system('pwd')
# output: /home/python/project2

os.system('cd ..')
os.system('ls')
# output: main2.py

os.system('cd ..')
os.system('cd c++') # Error: The directory 'cpp' does not exist
os.system('pwd')
# output: /home/python/project2The main differences between TerminalPyth and os.system():- TerminalPyth allows multiple direcotry changes- TerminalPyth allows to store the output in a variable- TerminalPyth lets you chose if return the output or not- os.system() prints its output always, in any case- os.system() doesn't allow to store the output- os.system() doesn't allow multiple directory change
Package: terminal-quest
# Introductionterminal-questis a [gamified](https://en.wikipedia.org/wiki/Gamification)
introduction to basic command line navigation and file manipulation skills. It
is implemented in the python programming language but requires no programming
other than entering commands on a command line.terminal-questis a series of puzzles that can be solved with only the
commandscd,ls,man,cat,head,tail,grep, file
globbing (*character), and output redirection (>character).![terminal_quest.png](terminal_quest.png)## Installation and Use ##### pypi ###You can installterminal-questusingpip:` pip installterminal-quest`### Manual Installation ###If you do not have access to anaconda, you may also install this package
manually. You can either clone this repo to your local machine with:` git clonehttps://github.com/BU-Neuromics/terminal_quest`or simply download the most recent stable version from [the downloads
page](https://github.com/BU-Neuromics/terminal_quest/tags).Once downloaded (and expanded, if downloaded as an archive), open a terminal
and run from within the source directory:` python setup.py install terminal_quest `### Dependencies ###This package uses the following non-standard python packages:[future](https://pypi.python.org/pypi/future)[fabulous](https://pypi.python.org/pypi/fabulous)[pillow](https://python-pillow.org/)
Package: terminal-space
Terminal SpaceTerminal Space is a text-based space trading and exploration game that was inspired byTradeWars 2002and several other space trading, elite-type games such asSpace TraderandSpace Rangers.FeaturesFull screen text-based interfaceSingle and multi-player modes (with standalone server)TradeWars 2002 concepts like sectors, planets, ports, and shipsIt currently implements the TradeWars basics of a universe, sectors, and ports, but will soon be taken in new directions.Roadmap0.1 (released) - Basic client/server model with structured text ui and simple TW2002 gameplay0.2 - Explore turn-based combat ala JRPGs like Octopath.  Focus on game mechanics.0.3 - Server and client saving, maybe host a game0.4 - Who knows...InstallationTo run it, install Python 3.7 and run:pip3 install terminal-spaceRunning the gameWith the game installed, simply runtspace-clientTo run the server standalone (needed for the "Join Game" option), run:tspace-serverDevelopmentTo install it locally, run:make virtualenv
source venv/bin/activateTo run the client, type:make runYou can see all the possible commands by running:makeDevelopment is often streamed on myTwitch streamand I'm on twitter as @mrdonbrown.
Package: terminal-styler
Terminal StylerCLI tool for adding foreground and background colours, as well as styles such as bold, underline, and more to your terminal output.PrerequisitesPythonSupport for ANSI codes in your terminalInstallationTo install the program, you may use pip or any package manager of your choice as the program is available on PyPI. To install using pip, execute the following command:pip install terminal-stylerExecutionTo run the program, execute the following command from the root directory of the project:stylet <input-file> [<output-file>]If no output file is specified, the output file will bestyled-<input-file>.Input FileThe input file should be a file containing the text you wish to style. The text can be styled using the following syntax:<console[.<styles>]>text</console>Each style is separated by a period.Eg:<console.bold.underline.color-green>text</console>The following styles are supported:boldunderlinereverse-textcolor-<color>bg-<color>The following colours are supported:blackredgreenyellowbluemagentacyanwhitegreyRBG colors can be specified in place of the default colors, using the syntax [#hexcode].Eg:<console.bg-[#ff0000]>text</console>Each color has a dark alternative, except black and grey, represented as dark-<color>.Eg:<console.color-dark-red>text</console>You may also nest console tags within each other.Eg:<console.bold>Hello<console.underline>World!</console> How are you?</console>Note:If you wish to use<consoleor</console>in your text without it being transpiled, you must prefix 'console' with a bang!Eg:<!console>text</!console>will be transpiled to<console>text</console>One exclaimation mark will be removed from after each<, if present.Output FileThe output file will be a copy of the input file, with the text styled according to the input file. If no output file is specified, the output file will be named styled-input-file.The output file will be of the same type as the input file.Note:If the output file already exists, it will be overwritten.Note:The application will not check if the input file is a valid file, or if the output file is a valid file name.ExamplesInputtest.pyprint("<console.color-dark-red.bg-green.bold>Hello <console.underline>World!</console></console>")
print("<console.color-[#B8B8B8]>How are you?</console>!")
print("I <console.color-green>am</console> <console.reverse-text.bold>good</console>")Outputstyled-test.pyprint("[0m[31m[102m[1mHello [0m[31m[102m[1m[4mWorld![0m[31m[102m[1m[0m")
print("[0m[38;2;184;184;184mHow are you?[0m!")
print("I [0m[92mam[0m [0m[7m[1mgood[0m")InputTest.javapackage test;

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello <console.bold>World!</console>");
    }
}OutputTest.javapackage test;

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello [0m[1mWorld![0m");
    }
}
Package: terminaltables
terminaltablesWhat is itEasily draw tables in terminal/console applications from a list of lists of strings. Supports multi-line rows.Python 2.6, 2.7, PyPy, PyPy3, 3.3, 3.4, and 3.5+ supported on Linux and OS X.Python 2.7, 3.3, 3.4, and 3.5+ supported on Windows (both 32 and 64 bit versions of Python).📖 Full documentation:https://robpol86.github.io/terminaltablesQuickstartInstall:pipinstallterminaltablesUsage:fromterminaltablesimportAsciiTabletable_data=[['Heading1','Heading2'],['row1 column1','row1 column2'],['row2 column1','row2 column2'],['row3 column1','row3 column2']]table=AsciiTable(table_data)printtable.table+--------------+--------------+|Heading1|Heading2|+--------------+--------------+|row1column1|row1column2||row2column1|row2column2||row3column1|row3column2|+--------------+--------------+Example ImplementationsSource code for examples:example1.pyexample2.pyexample3.pyChange Log
Package: terminaltables-whl
terminaltablesForked because original project's repo is ARCHIVED and there are no wheels for the old project in pypi.What is itEasily draw tables in terminal/console applications from a list of lists of strings. Supports multi-line rows.Python 2.6, 2.7, PyPy, PyPy3, 3.3, 3.4, and 3.5 supported on Linux and OS X.Python 2.7, 3.3, 3.4, and 3.5 supported on Windows (both 32 and 64 bit versions of Python).📖 Full documentation:https://robpol86.github.io/terminaltablesQuickstartInstall:pipinstallterminaltablesUsage:fromterminaltablesimportAsciiTabletable_data=[['Heading1','Heading2'],['row1 column1','row1 column2'],['row2 column1','row2 column2'],['row3 column1','row3 column2']]table=AsciiTable(table_data)printtable.table+--------------+--------------+|Heading1|Heading2|+--------------+--------------+|row1column1|row1column2||row2column1|row2column2||row3column1|row3column2|+--------------+--------------+Example ImplementationsExample Scripts ScreenshotSource code for examples:example1.pyexample2.py <https://github.com/Robpol86/terminaltables/blob/master/example2.py>, andexample3.py <https://github.com/Robpol86/terminaltables/blob/master/example3.py>.. changelog-section-start
Package: terminal-temple
# terminal templeThe long-awaited sequel to [terminal_quest](https://bitbucket.org/bubioinformaticshub/terminal_quest).
This is a slightly less cute little set of puzzles that develops slightly more
advanced command line skills than terminal_quest. It requires python 3.6 or
greater.Note:to complete these puzzles, you should have a firm grasp of these
shell commands:cdmvcatfindechoexportand environment variablesA command line text editor might be helpful as well.You can install it with` pip installterminal-temple`Once installed, the command line commanedterminal_templewill be available
on your command line. Run it to start the puzzles!
Package: terminal-text
Terminal TextA simple python module that allows you send text messages to your phone.Installationpip install terminal-textinstall the moduleexportEMAIL = Your EmailexportPASS = Your login passwordexportSMTP, smpt setting from your email for examplesmtp.gmail.comexportPORT, SMPT portexportSMS_GATEWAYthe sms gateway of your carrier.SMS GATEWAYSAT&T: [number]@txt.att.netSprint: [number]@messaging.sprintpcs.com or [number]@pm.sprint.comT-Mobile: [number]@tmomail.netVerizon: [number]@vtext.comBoost Mobile: [number]@myboostmobile.comCricket: [number]@sms.mycricket.comMetro PCS: [number]@mymetropcs.comTracfone: [number]@mmst5.tracfone.comU.S. Cellular: [number]@email.uscc.netVirgin Mobile: [number]@vmobl.comNOTE: Make sure to add 1 before the number.Usagetermtext -m "Enter Message\n"ContributionThis module is available under MIT license.if you would like to contribute to this module feel free to fork and create a PR.
Package: terminaltools
terminaltools⌨ Some personal tools for working with the terminal in Python.This package contains some useful functions I created for my personal use in Python terminal projects, including styling and querying the user.⚠ Please note that this package is almost certainly laced with bugs, so use it at your own risk! If you encounter any issues, please create an issue on GitHub (https://github.com/ericli3690/terminaltools) or email me atericli3690@gmail.com.🛠 Installation and Use>> pip install terminaltoolsfromterminaltoolsimportfunction_name_herefunction_name_here(arguments_here)🎨 Color FunctionsAvailable ColorsBLACK, RED, GREEN, YELLOW, BLUE, PURPLE, CYAN, WHITEmarker(color)Returns the escape sequence for a given color.colored(text, color)Returns the text parameter as a given color.color_print(text, color, is_input, insert_end)Prints the text parameter as a given color.insert_end is used for the 'end' parameter in print statements; is_input will allow an input to be created instead.🖨 Other Printing Functionsdelay(interval)Repeatedly refreshes the line, inputting a new dot every second until the amount of dots equals parameter INTERVAL (in seconds).nest(text, top_icon, side_icon, corner_icon, left_right_padding, up_down_padding)DEFAULTS TO:None, '=', '', '', 0, 0Nests 'text' in a box with 'top_icon' on the top and bottom, 'side_icon' on the left and right, and 'corner_icon' on the corners; can also add interior padding via left_right_padding and up_down_padding.Returns a string.Try nesting nests in nests!❓ Querying the Userask(prompt, filter, disallow_null, clear_console, colors)define a filter, then call ask:defmyFilter(reply):if(reply=="0"):returnFalse,'This value is not allowed.'else:returnTrue,'Value accepted.'ask("Enter a non-zero character.",myFilter)Warning: this uses eval().Your filter may be named anything, but its argument MUST be called "reply"disallow_null is true by default; clear_console on user success and failure are both false by default; success color and failure color are green and red respectively by default.
Package: terminal-tracker
terminal-trackerMaintaining and organizing a history of terminal commands executed for a folder/project from any terminal.OverviewThis tools helps with analysing, filtering and segregrating your command history. It also provides functions to support storing of this history in a better format, that can be used share with people or used in future. It recommends commands (based of length of command and frequency of use) that should have an alias.Main featuresRecommends commands that should have an alias.It provides support for both zsh and bash shells.Nice format to store and share historyInstallingpip install terminal-trackerDependenciespandaspytzUsagefrom terminal_tracker import FrequencyFile
ff = FrequencyFile("zsh_history_file.txt", timeframe=False, shell="zsh")
most_frequent_command = ff.find_most_frequent()ConfigurationsThese congifurations will help you to better store your history:zshThese should be added to /.zshrcexport HISTFILE=~/.zsh_history
export HISTFILESIZE=1000000000      # big big history
export HISTSIZE=1000000000          # big big history
setopt INC_APPEND_HISTORY           # append to history, don't overwrite it
setopt EXTENDED_HISTORY
setopt HIST_FIND_NO_DUPS            # no duplicate entries
setopt HIST_IGNORE_ALL_DUPS         # no duplicate entries
setopt interactivecommentsbashThese should be added to /.bashrcexport HISTCONTROL=ignoredups:erasedups  # no duplicate entries
export HISTSIZE=100000                   # big big history
export HISTFILESIZE=100000               # big big history
shopt -s histappend                      # append to history, don't overwrite it

# Save and reload the history after each command finishes
export PROMPT_COMMAND="history -a; history -c; history -r; $PROMPT_COMMAND"Coverage and TestsTests and coverage can be run using these simple make commandsmake coverage
make testContributing to terminal_trackerAll contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome.
Package: terminal-typing-tutor
Terminal Typing TutorA port of GNU Typist (GTypist)https://github.com/justinsgithub/terminal-typing-tutor/assets/74565194/c299740b-a2f2-47f5-b244-1ca41fa48295Project GoalsGTypist is by far the best program I have used to learn how to type faster.
However it is pretty outdated and has many potential features that can be added.
I was initially going to just add to the C code, but decided to switch to Python for faster implementation.
It is a tradeoff for speed, but so far the difference has not taken away from the program.I tried to stick with the original program layout and how it did things as much as possible, both out of simplicity and respect to the original.I also think this could be a good starting open-source project for new developers to contribute to.Installin your terminal:$ pip install --user terminal-typing-tutor
---> 100%
Successfully installed terminal-typing-tutor

$ tttupgrade:$ pip install --user --upgrade terminal-typing-tutorFeaturesNewTracking all time WPM, and saving scores to ~/.config/terminal-typing-tutor directoryThis allows for saving typing scores long-term and between machines.I add terminal-typing-tutor to my dotfiles managed by stow so that they are saved to githubSmall UI improvements, such as centering the text on the screen, having it up in top left was especially annoying on a large monitorLackingThere are features and also lessons missing from the original GTypist that I don't use.If there is anything you want added, feel free to create and issue or make a pull request, contributions are welcome and encouragedRequirementsThis project is built with:Python 3.6+Typerfor command line functionality (not really doing much at the moment, but future features will incorporate it more)Blessedfor the terminal interface, a wrapper around the curses moduleContributingI think this project would be an awesome first open source project for new developers looking to contribute.There are plenty of things to be improved or added to this package, such as:refactoring the code, since it has just been me, I did not worry too much about making it super pretty.there are places where code is repeated and can be extracted into a reusable functionadding theme optionstracking the date of users personal bests to display progress over timeadding new lessons for programming, such as an html, python, and javascript lessonSome of the new features will need to implementTyper, the docs are awesome, so are theBlesseddocsLicenseI stuck with the original license of the project, this is my first real open source project, so please let me know if there are any standards or anything I should do better.
Package: terminalui
TerminalUIA Python Package that allows for the easily development of Terminal User Interfaces that require asynchronous read/write. Features include:TerminalUI class which handles user keypresses, simply pass it your command entered functionAsynchronous read/write capabilitiesConfigurable options panel for configuring your application at runtimeOptions can either be a list of selectable values or an editable valueSeveral other featuresThe package is built uponurwid. This means, unfortunately, based on how the TerminalUI class is currently implemented it will not work with on Windows. It will however, work with the Windows Linux Subsystem (WSL). Here is aguideon how to enable WSL on Windows 10.InstallationTo install via pippip3 install terminaluiTo install from source (with symlink so updates to source are immediately reflected in packages that utilise TerminalUI)git clone https://github.com/jmount1992/TerminalUI.git
python3 -m pip install --user --upgrade setuptools wheel
python3 setup.py sdist bdist_wheel 
pip3 install -e .DocumentationAdditional documentation will be coming in the future. For now check out the examples and the docstrings in the TerminalUI class.
Package: terminalutilities
terminalutilitiesA set of utilities for use in a terminal.Progress BarA progress bar used to track the progress of a value from 0 to some maximum value, printing in-place (overwriting) this progress.UsageInitialise the bar by creating aProgressBarobject, passing at least a title and a maximum value, then callUpdatewith the new value. Once the value has reached its maximum, callCompleteto finalise the bar and continue with the program.Examplen=999999pb=terminalutilities.ProgressBar("Doing",n)x=0whilex<n:x+=1pb.Update(x)pb.Complete()Selection MenuA selection menu used to allow the user to execute one of a set of prebuilt commands.UsageSet up a list of 'options', which are dictionaries with keysname: The name of the optionaliases: A list of all the words that will trigger this optiondesc: A description of the optionfunc: The function to be executed upon selecting this option; such a function must take in a single argumentargswhich is a list of all words given after the trigger word (e.g. inputting 'test arg1 arg2' makesargs == ['arg1', 'arg2']; inputting 'test' makesargs == []).Two options are included by default:
"Help", which displays a list of all the options available to this menu; and
"Quit", which quits the menu.The menu will continue prompting the user until one of the functions it calls returns something notNone(the function for "Quit" returns-1)ExampledefTestOption(args):print("test option's function is working")options=[{"name":"testoption","desc":"this is a test option","aliases":["testoption","test","t","testop"],"func":TestOption}]SelectionMenu(options)
Package: terminal_velocity
Terminal Velocityis a fast note-taking app for the UNIX terminal, that
focuses on letting you create or find a note as quickly and easily as possible,
then uses your$EDITORto open and edit the note. It is heavily inspired
by the OS X appNotational Velocity.
For screenshots and features, see theTerminal Velocity website.To install Terminal Velocity, run:pip install terminal_velocityThen to launch it just run:terminal_velocityTo use a different notes directory, run:terminal_velocity path/to/your/notes/dirTo see all the command-line options, run:terminal_velocity -hTo quit the app, pressctrl-corctrl-x.To upgrade Terminal Velocity to the latest version, run:pip install --upgrade terminal_velocityTo uninstall it, run:pip uninstall terminal_velocityTo make a bug report or feature request, useGitHub Issues.To contribute documentation, usethe wiki.To contribute code to Terminal Velocity, seeCONTRIBUTING.HackingTo release a new version of Terminal Velocity:Increment the version number in thesetup.py file,
add an entry te thechangelog,
commit both changes to git and push them to github.
For example, seeaae87b.Upload the new release tothe terminal_velocity package on pypi: runpython setup.py sdist upload-rpypi.For more information seehttps://packaging.python.org/.