Saravanan666/pypi-org huggingface dataset:
Package: commandLineMusicVideo
commandLineMusicVideoThis is a Python3pip packagethat uses ffmpeg to render videos using an image and audio file as inputs.Tutorial Video:https://www.youtube.com/watch?v=tR6U8RrHubEExample video rendered using this package:https://www.youtube.com/watch?v=5SqLD4GEVHc&t=911sQuickstartMake sure you have ffmpeg installed on your command line, ensure ffmpeg is downloaded by running the command:ffmpegWhich should give you an output with info on the version of ffmpeg installed.Download the commandLineMusicVideo package with this command:pip install commandLineMusicVideoRun the installed package withpython3 -m commandLineMusicVideo -h -tto view the help page and test your ffmpeg.ExamplesRendering individual videos and a full album video for a folder.python3 -m commandLineMusicVideo -songs "../../../Infernal Love/Violet Eves - Promenade [1988, IRA]/" mp3 "front.jpg" -fullAlbum -removeFirst 19This command will get 'front.jpg' and all the mp3 files located in the specified folder:The-removeFirst 19tag will format the individual song output filenames based on their input filename, for example, the filenameViolet Eves - 04 - Fiaba di Saleafter having its first 19 chars removed, would be:Fiaba di SaleAfter running the full commandLineMusicVideo command, the folder output (with all the individual songs AND the fullAlbum) will look like this:The output videos will keep the image's aspect ratio.Flags-hDisplay help.-testTest your ffmpeg.-songs "folderFilepath/" "audioFormat" "imageName.jpeg"Render each audioFormat file in the folderFilepath, using the imageName also found in the folderFilepath.-fullAlbumRender full album with these songs as well.-fullAlbumOnlyOnly render the full album.-outputResolution 1920:1080Set output resolution for video.Output Filename Formatting Flags:-removeFirst #Remove first # chars from song filename for output filename.-removeUpTo "-"Remove everything up to and including the first instance of this char.-removeAfter "-"Remove everything after and including this char.-titleizeCapitalize first letter of each word of output filename')
Package: commandlineplot
clplot - command line plotting utilityThis utility is a command line front end to the matplotlib plottingmodule. This utility handles reading the data from file and determining
the structure of the data. The utility attempts to make reasonable
plot output using a collection of assumptions and inferences from the
data. In many cases, reasonable output can be produced by the utility
with the user providing nothing more than file names.when install with setuptools (or variant), an executable ‘plot’ is addedto the user’s path.
Package: command-line-timer
command line timerinstalls a command line tool calledtimerwhich counts down from given HH:MM:SS, and then sounds an alarm.usage$ timer 5# set timer for 5 seconds. counts down from 00:00:05$ timer 5:00# set timer for 5 minutes.expected output$ timer 5  
Thu Aug  1 09:50:58 MST 2019  
timer ended at 9:51:03 AM
Package: command_manager
command_manager===================Entry point for Python scripts.Helps you structure additional scripts of your application within one or more Python packages and call them from one place.Installation-------------Install using `pip`...pip install command_managerUsing-------------------Create a Python package anywhere in your application.For example, the package `commands` and the entry point `manager.py`.├── commands│   ├── __init__.py│   └── my_first_command.py├── src└── manager.pyIn `manage.py` add the following:if __name__ == '__main__':import logging.config # Optional for loggingfrom command_manager import ManagerLOGGING = { # Optional for logging'version': 1,'disable_existing_loggers': False,'formatters': {'verbose': {'format': '%(levelname)s | %(asctime)s | %(module)s | %(message)s'}},'handlers': {'commands_handler': {'level': 'INFO','class': 'logging.handlers.RotatingFileHandler','formatter': 'verbose','filename': os.path.join("logs", 'commands.log'),'maxBytes': 100000,'backupCount': 10,}},'loggers': {'commands.my_first_command': {'handlers': ['commands_handler'],'level': 'INFO','propagate': False}},}logging.config.dictConfig(LOGGING) # Optional for loggingmanager = Manager(["commands"])manager.run()In `my_first_command.py` add the following:from command_manager.commands import BaseCommandclass Command(BaseCommand):description = "Simple command"def add_arguments(self, parser):parser.add_argument("--arg1", help="argument arg1")parser.add_argument("--arg2", help="argument arg2")def handle(self, *args, **kwargs):self.logger.info("START")print "Hello Word: arg1={arg1} arg2={arg2}".format(**kwargs)self.logger.info("END")> **Warning:**> The class must be called the `Command` and inherited from `BaseCommand`Now call `manage.py` from the console.![python manage.py](/asserts/manage.png)Call our command `my_first_command.py`![python manage.py my_first_command](/asserts/command_call.png)
Package: command-mk2
Filter CommandMk2 Aiogram 3Improved command filterclassRestrictModel(BaseModel):period:datereason:Optional[str]@router.message(CommandMk2('ban{period}{reason}',response_model=RestrictModel,response_model_name='vars'))asyncdefban_user(message:Message,period:date,reason:Optional[str]):...Diff:Command arguments parsing, not just leaving single string like built-in aiogram filterCommand arguments separation and validation using Pydantic model.
Package: commandnotfound
commandnotfoundThis package provides a wrapper of command-not-found commands:Apt-based distribution's/usr/lib/command-not-foundYum-based distribution's/usr/libexec/pk-command-not-foundYou know that when you type a command and then try to run it, if the command is not found, you will be informed that there is a command with a similar name, or you will be prompted to install the package required by it.I want my Python scripts that call such commands internally to also display this kind of friendly messages. However, the trick does not work when you try to run a command insubprocess.run. It simply displays a "command not found" message.Thecommandnotfoundwrapssubprocess.run, and when the command passed as its argument is not found, it invoke the command-not-found commands.Note: Tested only on Ubuntu.How it worksIn some apt-based distributions such as Ubuntu, shows a hint as an error message, when a user types wrong command name, e.g.:$converT

Command'converT'notfound,didyoumean:command'convert'fromdebimagemagick-6.q16(8:6.9.10.23+dfsg-2.1ubuntu11.4)....This help system is implemented as/usr/lib/command-not-found, and the bash call it when a command is not found on PATH directories.The help system does not work when you run command in a Python code withsubprocess.run, e.g.:$python3
Python3.8.10(default,Mar152022,12:22:08)[GCC9.4.0]onlinux
Type"help","copyright","credits"or"license"formoreinformation.
>>>importsubprocess>>>subprocess.run(["converT"])Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>
....
FileNotFoundError:[Errno2]Nosuchfileordirectory:'converT'>>>In short, the error message says that the command could not be found.So the commandnotfound wrapper wrapssubprocess.runand detectsFileNotFoundErroris thrown or not, and in case it thrown, call the help command/usr/lib/command-not-found.$python3Python3.8.10(default,Mar152022,12:22:08)[GCC9.4.0]onlinux
Type"help","copyright","credits"or"license"formoreinformation.
>>>importsubprocess
>>>importcommandnotfound
>>>wrapped_run=commandnotfound.wrap(subprocess.run)>>>wrapped_run(["converT"])Command'converT'notfound,didyoumean:command'convert'fromdebimagemagick-6.q16(8:6.9.10.23+dfsg-2.1ubuntu11.4)....
FileNotFoundError:[Errno2]Nosuchfileordirectory:'converT'>>>This time, the error message pointed out that the command name may be wrong!
Package: command-notifier
A very simple command-notification package based on SQS for distributed systems> Warning: This can be abused to take down your entire infrastructure, gain root access, etc.InstallationUsing PIP via PyPI:pip install command-notifierUsing PIP via Github:pip install git+git://github.com/josegonzalez/python-command-notifier.git#egg=command-notifierUsageCLI Usage of cn-publish is as follows:usage: cn-publish [-h] [-a AWS_ACCESS_KEY_ID] [-s AWS_SECRET_ACCESS_KEY]
                  [-c COMMAND] [-r EC2_REGION] [-t SNS_TOPIC]

cn-publish, a tool to publish a command via sns

optional arguments:
  -h, --help            show this help message and exit
  -a AWS_ACCESS_KEY_ID, --aws-access-key-id AWS_ACCESS_KEY_ID
                        AWS Access Key ID
  -s AWS_SECRET_ACCESS_KEY, --aws-secret-access-key AWS_SECRET_ACCESS_KEY
                        AWS Secret Access Key
  -c COMMAND, --command COMMAND
                        Command to publish
  -r EC2_REGION, --ec2-region EC2_REGION
                        EC2 Region
  -t SNS_TOPIC, --sns-topic SNS_TOPIC
                        SNS Topic to publish to

cn-publish is pwnageCLI Usage of cn-subscribe is as follows:usage: cn-subscribe [-h] [-a AWS_ACCESS_KEY_ID] [-s AWS_SECRET_ACCESS_KEY]
                    [-c COMMAND_FILE] [-r EC2_REGION] [-t SNS_TOPIC]
                    [-w SNS_WAIT_TIME_SECONDS] [-q SQS_QUEUE]

cn-subscribe, a tool to run commands published from sqs

optional arguments:
  -h, --help            show this help message and exit
  -a AWS_ACCESS_KEY_ID, --aws-access-key-id AWS_ACCESS_KEY_ID
                        AWS Access Key ID
  -s AWS_SECRET_ACCESS_KEY, --aws-secret-access-key AWS_SECRET_ACCESS_KEY
                        AWS Secret Access Key
  -c COMMAND_FILE, --command-file COMMAND_FILE
                        Path to json file with whitelisted commands
  -r EC2_REGION, --ec2-region EC2_REGION
                        EC2 Region
  -t SNS_TOPIC, --sns-topic SNS_TOPIC
                        SNS Topic to subscribe to
  -w SNS_WAIT_TIME_SECONDS, --sns-wait-time-seconds SNS_WAIT_TIME_SECONDS
                        SNS Wait Time in Seconds
  -q SQS_QUEUE, --sqs-queue SQS_QUEUE
                        SQS Queue to utilize to

cn-subscribe is pwnageYou can also use the equivalent environment variables in place of command arguments.
Package: commando
Version 1.0.0A simple wrapper forargparsethat allows commands and arguments
to be defined declaratively using decorators. Note that this does
not support all the features ofargparseyet.Commando also bundles a few utilities that are useful when building
command line applications.ExampleWithout commando:def main():
    parser = argparse.ArgumentParser(description='hyde - a python static website generator',
                                  epilog='Use %(prog)s {command} -h to get help on individual commands')
    parser.add_argument('-v', '--version', action='version', version='%(prog)s ' + __version__)
    parser.add_argument('-s', '--sitepath', action='store', default='.', help="Location of the hyde site")
    subcommands = parser.add_subparsers(title="Hyde commands",
                                     description="Entry points for hyde")
    init_command = subcommands.add_parser('init', help='Create a new hyde site')
    init_command.set_defaults(run=init)
    init_command.add_argument('-t', '--template', action='store', default='basic', dest='template',
                     help='Overwrite the current site if it exists')
    init_command.add_argument('-f', '--force', action='store_true', default=False, dest='force',
                     help='Overwrite the current site if it exists')
    args = parser.parse_args()
    args.run(args)

def init(self, params):
    print params.sitepath
    print params.template
    print params.overwriteWith commando:class Engine(Application):

    @command(description='hyde - a python static website generator',
            epilog='Use %(prog)s {command} -h to get help on individual commands')
    @param('-v', '--version', action='version', version='%(prog)s ' + __version__)
    @param('-s', '--sitepath', action='store', default='.', help="Location of the hyde site")
    def main(self, params): pass

    @subcommand('init', help='Create a new hyde site')
    @param('-t', '--template', action='store', default='basic', dest='template',
            help='Overwrite the current site if it exists')
    @param('-f', '--force', action='store_true', default=False, dest='overwrite',
            help='Overwrite the current site if it exists')
    def init(self, params):
        print params.sitepath
        print params.template
        print params.overwriteResourcesChangelogLicenseContributingAuthors
Package: commandor
Helpers for command line arguments parserOverviewServers configurationINSTALLATIONYou can install the most recent commandor version usingeasy_install:easy_install commandororpip:pip install commandorContributeCheck for open issues or open a fresh issue to start a discussion around a feature idea or a bug.
There is a Contributor Friendly tag for issues that should be ideal for people who are not very familiar with the codebase yet.Forkthe repositoryon Github to start making your changes to thedevelopbranch (or branch off of it).Write a test which shows that the bug was fixed or that the feature works as expected.Send a pull request and bug the maintainer until it gets merged and published.SEE ALSOReceptor
Package: commandparse
commandparseModule to parse command based CLI application.Usage:Subclass the Command classAdd a method with a name such asprefix_commandnamewith kwargs as required argumentCreate an ArgumentParser instanceCall theSubclass.add_suparserswith the ArgumentParser instance and other settingsUse thedispatch_commandfunction with the args returned byparser.parse_args()parser = ArgumentParser(...)
[...]
Subclass.add_subparsers(parser, prefixes=["get_", "do_", ...], title="commands", description="available commands")

cmd = Subclass(...)
cmd.dispatch_command(commands, args)See example.py for a more complete example. For a real world application using this lib, see:https://github.com/franc-pentest/ldeep
Package: commandpool
Utility classes and functions for running subprocess commands in parallel:>>>fromrandomimportrandrange>>>fromcommandpoolimportrun>>>commands=['sleep%s'%randrange(5)for_inrange(100)]>>>forproc,cmdinrun(commands):...print(proc.returncode,proc,cmd,sep=', ')0,<subprocess.Popenobjectat0x7fa470b5e278>,sleep10,<subprocess.Popenobjectat0x7fa470b449b0>,sleep20,<subprocess.Popenobjectat0x7fa470b53d30>,sleep20,<subprocess.Popenobjectat0x7fa470b44b70>,sleep30,<subprocess.Popenobjectat0x7fa470b53cf8>,sleep30,<subprocess.Popenobjectat0x7fa470b53d68>,sleep4One way to look at the functionality provided by this library is like asubprocessequivalent of:echo$commands|xargs-P$concurrencysh-cThis library works by periodically checking if started processes have finished
and then starting new ones in their place.InstallationThe latest stable version of commandpool can be installed from pypi:$pipinstallcommandpoolUsageFunctionalfromcommandpoolimportrun# Run at most 5 commands at a time.run(commands,concurrency=5)# Start all commands at the same time (this is the default).run(commands,concurrency=None)# The duration between 'ticks' is configurable.run(commands,sleep_seconds=0.1)# Processing commands as they are finished.forproc,cmdinrun(commands):assertisinstance(proc,subprocess.Popen)# The way commands are started is configurable through `start_command`.fromsubprocessimportPopen,PIPEcommands={i:('echo',i*i)foriinrange(5,10)}start_command=lambdanum:Popen(commands[num],stdout=PIPE)forproc,cmdinrun(commands,start_command=start_command):print(proc.stdout,cmd,commands[cmd])# b'25', 5, ('echo', 25)# b'36', 6, ('echo', 36)# ...SubclassingfromcommandpoolimportConcurrentCommandRunnerclassMyCommandRunner(ConcurrentCommandRunner):defstart_command(self,cmd):...defcommand_finished(self,proc,cmd):...runner=MyCommandRunner(commands,sleep_interval=1.0)runner.run()TodoAdd tests.Complete documentation.AlternativesConcurrentCommandRunnercan be implemented in a few lines with the help ofconcurrent.futures, assuming that spawning a thread per command is
acceptable. This also has the added benefit of yielding as soon as a command
(wrapped in a future) is complete, instead of atsleep_secondsintervals, as
is the case withConcurrentCommandRunner.fromconcurrent.futuresimportThreadPoolExecutor,as_completedfromsubprocessimportrunwithThreadPoolExecutor(max_workers=10)aspool:futures={pool.submit(run,cmd):cmdforcmdincommands}forresinas_completed(futures):print(futures[res],res.returncode)LicenseReleased under the terms of theRevised BSD License.
Package: command-saver-terminal-program
CommandSaverCommandSaver is a console-interface application that saves and executes terminal commands added by the user.SummaryThe purpose of the program is to help the user keep track of commonly used complicated commands. It is a lot like aliases.InstallationInstall the package in the user directory using:pip install --user command-saver-terminal-programClose the shell, start a new shell and usecsto run.If command not found error happensThis error happens when the script path hasn't been added to the user's directory. Check whether the installation directory is included in the user's PATH. If not, modify your shell configuration file (e.g., ~/.bashrc or ~/.zshrc) to include it. For example, you can add the following line to your ~/.zshrc file:export PATH=/local/home/username/.local/bin:$PATHRunning in the terminalUsecsto launch the program from bash or zsh.
Or run a single command usingcs OPTION COMMAND_IDDevelopmentProject has been developed using PyCharm integrated development environment (IDE) and in accordance with the design of Software Engineering Fundamentals final assignment (University assignment).DocumentationRead more about rich package here:https://rich.readthedocs.io/en/stable/tables.htmlRead more about logger here:https://docs.python.org/3/library/logging.htmlRead more about mock objects used for unit tests here:https://docs.python.org/3/library/unittest.mock.html?highlight=patch#module-unittest.mockAdditional details on the design and the project have been described in the Software Engineering Fundamentals final assignment.DevelopmentThe code has a comment in almost every line, this was the coursework requirement.TestingUnit tests have been called them in the terminal using python. Tests have not been updated for CommandSaver versions >2.0 (outdated from 1.0 - didn't have time to do them).Packaging & DeploymentPackaged using:pip install setuptools wheelpython setup.py sdist bdist_wheelDistributed via PyPI using twine:pip install twinetwine upload dist/*Locally tested using:pip install --user dist/command-saver-terminal-program-2.2.2.tar.gz
Package: commands-generator
Installation$[sudo]pipinstallcommands-generator$[sudo]npmi-gcommands-generatorHow it worksscripts (shebang#!required):namespace/script.py
namespace/subnamespace/script.shgenerated commands:namespace:script
namespace:subnamespace:scriptFeaturesgenerateshell commands from scriptsshell namespaces-namespace:command. folder names as namespacesConfig~/.bashrc:export PATH=path/to/commands:$PATHExamplesgenerate~/.local/share/binfromdotfiles/scripts:dotfiles/scripts/git/commit.sh
dotfiles/scripts/files/python/setup.cfg/create.sh
dotfiles/scripts/web/github.com/push.sh$cdpath/to/dotfiles
$commands-generatorscripts~/.local/share/bingenerated commands:~/.local/share/bin/git:commit
~/.local/share/bin/files:python:setup.cfg:create
~/.local/share/bin/web:github.com:pushusage:$ files:python:requirements.txt:create
$ git:commit
$ web:github.com:pushRelatedclassifiers-generator- python classifiers generatorcommands-generator- shell commands generatorlaunchd-generator- launchd.plist generatorreadme-generator-README.mdgeneratorsetupcfg-generator-setup.cfggeneratortravis-generator-.travis.ymlgeneratorreadme42.com
Package: commandsheet
Commandsheet: display catalog of commands user uses oftenWhat does it do? Exactly what the title says! (Or maybe more like: display
catalog of commands you never remember how to use).I came up with this project for one reason: there's always some of those
commands I never remember how to use.Commandsheet to the rescue! With it, you can document the commands of your
liking (i.e. the commands you never know how to use) and what they do to a
config file, which Commandsheet then reads and prints nicely to the screen for
you. Nice and simple!InstallationCommandsheet is available in PyPi!python-mpipinstallcommandsheetUsageYou should have a basic config file set up before you can use Commandsheet.
Check the next section to set up the config.After setting up the config file, using Commandsheet is as easy as running:commandsheetConfigurationBelow is an example config file for Commandsheet. Copy the contents, create the
file~./config/commandsheet/commandsheet.iniand paste the contents there.The name between the brackets denotes the start of a section. The name can be
anything useful for you, for example '[my commands]'. To add entries under a
section, separate the key and value with a '=', where the key on the left of
the '=' is supposed to be a command or a command-sequence, and the value on
the right a description for that command / command-sequence.# commandsheet.ini[ffmpeg]ffmpeg -i input.mp4 output.avi=convert input.mp4 to output.avi[zipfiles]unzip filename.zip -d <dir>=unzip filename.zip to <dir>zip archive.zip file1 file2=zip files to archive.zipzip -r archive.zip dir1 dir2=zip dirs into archive.zipzip -r archive.zip dir1 dir2 file1 file2=zip dirs & files into archive.zip[filesystem]ls -l=list in long formatcp -v=copy and show what is happening[networking]ip a=show interface configurationping <address>=ping address <address>
Package: command-spawner
Command SpawnerCommand Spawner is a non-blocking command runner library for Python.Command Spawner runs commands at background and provides live output, error and finish data through the provided callback functions.InstallingInstall and update using pip:$pipinstallcommand-spawnerExample usage# Triggered when received new stdoutdefon_output(data):print(f"Received data:{data}")# Triggered when received new stderrdefon_error(data):print(f"Received error:{data}")# Triggered when the command execution has finisheddefon_finished(data):print(f"Finished with return code:{data}")# Triggered when an exception has been thrown from the process moduledefon_exception(exception):print(f"Received exception:{exception}")# orraiseexceptioncommand_spawner=CommandSpawner(command="ping google.com",on_output_callback=on_output,# Suppress output when it is not providedon_error_callback=on_error,# Suppress error when it is not providedon_finished_callback=on_finished,# Suppress return code when it is not providedon_exception_callback=on_exception,# Raise exception on runtime when it is not providedshell=False,# If True, the command will be executed through the shell (not recommended)daemon=False# If True, current runtime will not wait for commands to be executed)# The method to run the processcommand_spawner.run()# The method to kill the current processcommand_spawner.kill()# The method to wait for the process to be finishedcommand_spawner.wait()Enjoy!