Saravanan666/pypi-org huggingface dataset:
Package: clia
A Command Line Intelligent Assistant (CLIA, pronounced asclea) build using Python.InstallationpipinstallciaHow to runpython-mcliatell-me"YOUR QUERY HERE"NoteThe query is matched using regular expressions, so there is no limitation on the order of the words in your query.Even though in the examples below, the output is just single-colored, the actual response in your terminal will be colored and highlighted based on the queryExample commandsSome Basic greetings and closings likepython-mcliatell-me"Hi."python-mcliatell-me"How are you?"python-mcliatell-me"Good morning!"python-mcliatell-me"Bye, goodnight!"python-mcliatell-me"What is your name?"Ask date and timepython-mcliatell-me"What time is it?"python-mcliatell-me"Tell me the date"Ask to search on webpython-mcliatell-me"Search funny dog videos on Youtube"python-mcliatell-me"Search about What is Python?"python-mcliatell-me"Search ramanujan on wikipedia"Lighten up your moodpython-mcliatell-me"Tell me a joke"
Package: cliai
CliAICliAI is a user-friendly Python package that lets you interact with OpenAI's ChatGPT via a command-line interface (CLI). Easily test and prototype chatbots, language models, and innovative ideas without writing any code.InstallationInstall CliAI using pip:pip install cliaiCliAI requires Python 3.8 or higher.Usage and TipsStart an interactive conversation by running:cliai chatThe CLI will guide you through the process to create a configuration.You can also specify an API key by setting the environment variableexport OPENAI_API_KEY="your-key"or by using the--api-key <OPENAI_API_KEY>flag.Bypass OpenAI RestrictionsIn certain regions (e.g., China), connecting to OpenAI may be problematic.
Bypass these restrictions by changing the official API base URL to a custom one using the--api-baseflag.cliai chat --api-base <OPENAI_API_BASE>Make it portableYou can use Linux on your mobile device to install CliAI.For iOS & iPadOS, use iSH.Prompt InjectionDuring chat mode, you can easily modify messages. In addition to changing your own input (user), you can tweak the model's response (assistant) and system prompt (system) to guide the conversation as desired.
Also you can usefine-tuning parametersto adjust the model's behaviour.Experiment and enjoy hacking the model!Debugging--verbose: Enable verbose output for easier debugging.--stream: Enable stream output in the response (experimental).LicenseCliAI is distributed under the MIT license. SeeLICENSEfor more information.To contribute to this project, feel free to raise issues or submit code.
Package: cliannelibrary
clianne library - useful python methodsClianne Library- this project is a Python client library which includes useful methods on different topics:processing XML resourcescustom functions for working with filesInstallationInstall the current version withPyPI:pipinstallcliannelibraryOr from Github:pipinstallhttps://github.com/DmitryOstroushko/cliannelibrary/archive/main.zipUsageXML processingYou can create XMLLibrary instance based on XML file, and then use it to modify XML structure with operarions:ADDMODIFYDELETExml_structure=XMLLibrary('file.xml')xml_structure.set_xml_node_to_modify(tag='xml_tag',attrib_dict={'attr_1':'test_1','attr_2':'test_2'}node_value='text')xml_structure.do_modify_xml(3)You can rename files to digital-names with mask-smaplemask:str='*'start_number:int=20210300FileLibrary().rename_file_by_mask(False,mask,start_number)ExampleCreate a new Story in the first Project that is returned from the API in the all projects list.If you installed a module from PyPi, you should to import it like this:from cliannelibrary.xml_library import XMLLibraryIf from GitHub or source:to be donefromfromcliannelibrary.xml_libraryimportXMLLibraryfromfromcliannelibrary.file_libraryimportFileLibraryExampletobedoneContributingBug reports and/or pull requests are welcomeLicenseThe module is available as open source under the terms of theApache License, Version 2.0
Package: cli-app
Python CLI AppFramework for creating CLI apps using PythonThe purpose of this library is to speed up bulding CLI applications by providing abstract classes representing an app and its commands. It usesargparseto define and parse command line arguments.ConceptsAppAn "App" is the main entry point of an application. It groups together one or more commandsCommandA "Command" is a single operation that the application can perform. It is identified by a positional argument on the command line. Let's takegitas an example.gitwould be theappthat provides differentcommands, such asadd,commit,merge,checkout, etc.Examplegit.py#!/usr/bin/env python3fromcli_appimportAppfromcommands.checkoutimportCheckoutfromcommands.mergeimportMergeclassGit(App):"""Git - fast, scalable, distributed revision control system"""defregister_commands(self):self.add_command('checkout',Checkout)# make the Checkout command available through `git.py checkout …`self.add_command('merge',Merge)# make the Merge command available through `git.py merge …`if__name__=='__main__':app=Git()app.run()commands/checkout.pyfromcli_appimportCommandclassCheckout(Command):"""Switch branches or restore working tree files"""@staticmethoddefregister_arguments(parser):parser.add_argument('ref',type=str,help='The ref (branch name, tag, commit sha) to checkout')defrun(self):# Do whatever needs to be done to checkout given refprint('Checking out%s'%self.app.args.ref)commands/merge.pyfromcli_appimportCommandclassMerge(Command):"""Join two or more development histories together"""@staticmethoddefregister_arguments(parser):parser.add_argument('branch',type=str,help='The branch to merge into the currently checked-out branch')defrun(self):# Do whatever needs to be done to merge given branchprint('Merging%sinto current branch'%self.app.args.branch)
Package: cliar
CliarCliaris a Python package to help you create commandline interfaces. It focuses on simplicity and extensibility:Creating a CLI is as simple as subclassing fromcliar.Cliar.Extending a CLI is as simple as subclassing from acliar.Cliarsubclass.Cliar's mission is to let you focus on the business logic instead of building an interface for it. At the same time, Cliar doesn't want to stand in your way, so it provides the means to customize the generated CLI.Installation$pipinstallcliarCliar requires Python 3.6+ and is tested on Windows, Linux, and macOS. There are no dependencies outside Python's standard library.Basic UsageLet's create a commandline calculator that adds two floats:fromcliarimportCliarclassCalculator(Cliar):'''Calculator app.'''defadd(self,x:float,y:float):'''Add two numbers.'''print(f'The sum of{x}and{y}is{x+y}.')if__name__=='__main__':Calculator().parse()Save this code tocalc.pyand run it. Try different inputs:Valid input:$ python calc.py add 12 34
The sum of 12.0 and 34.0 is 46.0.Invalid input:$ python calc.py add foo bar
usage: calc.py add [-h] x y
calc.py add: error: argument x: invalid float value: 'foo'Help:$ python calc.py -h
usage: calc.py [-h] {add} ...

Calculator app.

optional arguments:
-h, --help  show this help message and exit

commands:
{add}       Available commands:
    add       Add two numbers.Help foraddcommand:$ python calc.py add -h
usage: calc.py add [-h] x y

Add two numbers.

positional arguments:
x
y

optional arguments:
-h, --help  show this help message and exitA few things to note:It's a regular Python class with a regular Python method. You don't need to learn any new syntax to use Cliar.addmethod is converted toaddcommand, its positional params are converted to positional commandline args.There is no explicit conversion to float forxoryor error handling in theaddmethod body. Instead,xandyare just treated as floats. Cliar converts the types usingadd's type hints. Invalid input doesn't even reach your code.--helpand-hflags are added automatically and the help messages are generated from the docstrings.Setuptools and PoetryTo invoke your CLI via an entrypoint, wrapparsecall in a function and point to it in yoursetup.pyorpyproject.toml.calc.py:...
def entry_point():
    Calculator().parse()setup.py:setup(
    ...
    entry_points = {
        'console_scripts': ['calc=calc:entry_point'],
    }
    ...
)pyproject.toml:...
[tool.poetry.scripts]
calc = 'calc:entry_point'Read NextTutorial →Cliar vs. Click vs. docopt →
Package: cli-args
cli-argsDo you belong to those who have to look up the calls you have to make toargparse? And are you longing for
a way to just import the parsed arguments as you would importsys.argv? Thencli-argsis the way to go!cli-argsis a Python library for an easier parsing of command line arguments.
It wraps the popularargparseto
allow importing parsed arguments from anywhere in the code. One of the key
features is the way you define what arguments you accept. By providing a
dictionary - that also can be read from a JSON file! - you can easily set all
available command line arguments at one specific, easy-to-find place.Get it!pipinstallcli-argsUse it!demo.pyimportcli_args# or: cli_args.from_file('path/to/schema.json')cli_args.from_schema({"description":"Process some integers.","arguments":[{"short":"a","long":"integer_a","var":"NUMBER","help":"The first integer","default":0,"type":"int"},{"short":"b","long":"integer_b","var":"NUMBER","help":"The second integer","default":"0","type":"int"}]})print(cli_args.argv['integer_a'])# 3print(cli_args.argv['integer_b'])# 5python demo.py --integer_a=3 --integer_b=5LicenseLicensed under theMITLicense. Happy forking :)
Package: cli-args-system
Install from piplinux: pip3 install cli-args-system
windows: pip install cli-args-systemInstall from scratchlinux: sudo python3 setup.py install
windows: python setup.py installWhat is cli_args_system ?In an general way its a library to manipulate argv args its content and its flagsBasic Usagethe most basic application:fromcli_args_systemimportArgsargs=Args()print(args)running:$ python3  test.py  -a "value of a" -b "value of b"results:{"default":[],"a":["value of a "],"b":["value of b"]}Args:retrieving the args:fromcli_args_systemimportArgsargs=Args()list_of_args=args.args()print(list_of_args)accessing args index:fromcli_args_systemimportArgsargs=Args()try:print(f'second arg is{args[1]}')exceptIndexError:print('there less than 2 args')making iterations:fromcli_args_systemimportArgsargs=Args()forainargs:print(a)Flags:retrieving all flags dict:fromcli_args_systemimportArgsargs=Args()flags=args.flags_dict()print(flags)running:python3test.py00x-a101a-b201b->{'default':[0,'0x'],'a':['10','1a'],'b':[20,'1b']}getting FlagsContent Object:fromcli_args_systemimportArgsargs=Args()out=args.flags_content('o','out')print(out)running:python3test.py-oa.txt->exist:True
filled:True
args:['a.txt']retrieving  flags and making iterations:fromcli_args_systemimportArgsargs=Args()out=args.flags_content('o','out')full_list=out.flags()try:first_element=out[0]print(f'first element is:{first_element}')exceptIndexError:pass#making iterationsforfinout:print(f)print(f'full list is:{full_list}')running:python3test.py-oa.txtb.txt->firstelementis:a.txt
a.txt
b.txt
fulllistis:['a.txt','b.txt']checking Flags Status:fromcli_args_systemimportArgsargs=Args()out=args.flags_content('o','out')ifout.exist():print('out flag exist')ifout.exist_and_empty():print('out flag exist but its empty')ifout.filled():print('out flag its filled')if'a.txt'inout:print('a.txt in out flag')running:python3test.py-oa.txt
->
outflagexist
outflagitsfilled
a.txtinoutflag
Package: cliask
* [[https://github.com/Sleft/cliask][cliask]]A Python module for getting validated user input via the console which is meant to ease the process of building command line interfaces. Provides the function =ask= which will ask for input until a valid response is given. Also provides the function =agree= which will ask for input until the answer is yes or no. Both functions are similar to and inspired by the functions with the same name in the Ruby library [[http://highline.rubyforge.org/][HighLine]]. The following code gives a peek of how the functions can be used:#+BEGIN_EXAMPLEimport cliaskanimal = cliask.ask('Cow or cat? ',validator=('cow', 'cat'),invalid_response='You must say cow or cat')yn = cliask.agree('Yes or no? ')print(animal)print(yn)#+END_EXAMPLE** InstallationTo use cliask you need Python 3. The following describes two ways of installing. The first method requires that =git= is installed and the second does not. Either way the module has to be [[http://docs.python.org/3/tutorial/modules.html][imported]] for it to be used.*** pipMake sure you have =pip= installed then do the following:#+BEGIN_EXAMPLEsudo pip install cliask#+END_EXAMPLE*** Git=cd= to the directory you want to install in and do#+BEGIN_EXAMPLEgit clone https://github.com/Sleft/cliask.git .#+END_EXAMPLEto clone the git repository into that directory. You can use the same command if you want to update your installation.*** Archive[[https://github.com/Sleft/cliask/archive/master.zip][Download]] an archive and extract to the directory you want to install in.** UsageSee the documentation in [[https://github.com/Sleft/cliask/blob/master/cliask.py][cliask.py]], especially the documention for =cliask.ask= and the example of usage in =cliask._test=. Run cliask.py, =python cliask.py=, to try the example of usage.** CreditsThe code in the module was first posted as [[http://stackoverflow.com/a/14977144][an answer]] to [[http://stackoverflow.com/q/14962930][a question]].** LicenseSee [[https://github.com/Sleft/yasnippet-latex-mode/blob/master/LICENSE.org][LICENSE.org]].
Package: cli-assistant
HelperThis is a simple cli tool to help you with your linux and git commandsAbout Helper
Helper was built with openai api using the model ‘davinci’UsageTo use Helper , you will need openai api key. Follow these steps to
generate the api key or visit thisarticlefor more details. * step1: signuphereand create an openai account
* step2: go to openai api key pagelink* step3 : click
“Create new secret key”Now that you have your api key, run the following command in your
terminalexport OPENAI_API_KEY="your_OPENAI_API_KEY"You’re ready to use helper in your terminal. Here is an example of how
helper can be used.helper "Linux command for  ip address"the output to the command above is :output:ip addr
Package: clib
clibclib is intended a base on top of which to build CLIs.It usesclickand aims to provide some utilities on
top of it to make build CLIs faster and easier.One core goal of clib is to provide a reasonably standard interface for many
common tasks, to allow switching the (usually third party) libraries it uses
easily.Although primarily intended as a library, it provides some simple commands of
its own.Installingpip install clibContributorshttps://gitlab.com/iwaseatenbyagrueLicenseCopyright (C) 2018 iwaseatenbyagrueThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.You should have received a copy of the GNU Affero General Public License
along with this program.  If not, seehttp://www.gnu.org/licenses/.
Package: clibato
Clibato: CLI Backup ToolClibato is a simple backup/restore tool. I created it to backup and restore
my.dotfiles, and to have fun with Python 🐍.The name Clibato stands for (CLI) (ba)ckup (to)ol.Quick startpip install clibato # Installation
clibato init --config=~/.clibato.yml
vim ~/.clibato.yml # Configuration (required)
clibato backup # Perform backup
clibato restore # Restore last backupInstallationClibato can easily be installed usingpip.pip install clibatoOnce installed, you can run it asclibatoorpython -m clibato.ConfigurationTo use the tool, start by creating a configuration file. The~/.clibato.ymlwill automatically be detected so, it is the recommended location. However,
you can place your configuration anywhere.clibato init --config=~/.clibato.ymlThe generated file contains comments to help you with the configuration.Auto-detectionIf--configis not specified, the following locations will be searched:The directory from which the command was issued, i.e../.clibato.yml.The user's home directory, i.e.~/.clibato.yml.If your configuration is not in one of those locations, you can use the--configflag with otherclibatocommands.SuggestionsPlace your config in~/.clibato.yml.This way, you don't have to specify--configall the time.Include your.clibato.ymlin your backup.UsageAfter you've installed and configured the tool, here's how you use it.BackupTo perform a backup, run the following command:clibato backupRestoreTo restore the last backup, run the following command:clibato restoreExamplesFor detailed documentation, and more examples, see.clibato.example.yml.Backup to a directorycontents:.bashrc:.clibato.yml:destination:type:'directory'path:'~/backup/clibato'Backup to a Git repositorycontents:.bashrc:.clibato.yml:destination:type:'repository'path:'~/backup/clibato'remote:'git@gitlab.com:jigarius/dotfiles.git'branch:'main'
Package: clibf
clibfInstallFrom PyPipipinstallclibfFrom GitHubpipinstallgit+https://github.com/donno2048/bf-interpreterRunBrainfuck fileclibf-fmy_bf_script.b# or with a promptclibf-FStringclibf-s"+[+[<<<+>>>>]+<-<-<<<+<++]<<.<++.<++..+++.<<++.<---.>>.>.+++.------.>-.>>--."Choose file with GUIclibf-g
Package: cliboa
Table of ContentsIntroctionWhat is cliboaFeaturesManualHow to ContributeQuick StartInstall cliboaConfiguration of a Simple ETL ProcessingDirectory TreeInstall PyPI packagesWrite a Scenario of ETL ProcessingSet an environmentExecute a scenario of ETL ProcessingYAML ConfigurationDefault ETL ModulesHow to Implement Additional ETL ModulesIntroductionWhat is cliboacliboa is an application framework which can implement ETL(ELT) pipeline. It eases the implementation of ETL(ELT) pipeline. In this case, ETL(ELT) pipeline means the processings like fetch, transform and transfer of data between various databases, storages, and other services.FeaturesPython based framework.ETL(ELT) processing is executable by YAML based configuration.Additional modules for ETL(ELT) pipeline can be implemented by only a few steps if default modules not enough.ManualSeeMANUAL.mdHow to ContributeSeeCONTRIBUTING.mdQuick StartRequirementsAvailable on macOS and any Linux distributions, like Debian, Ubuntu, CentOS, REL, or etc.Install cliboapython version 3.7 or later and poetry are required. In the environemnt which pip can be used, execute as below.sudo pip3 install poetry
sudo pip3 install cliboaConfiguration of a Simple ETL ProcessingAfter installed cliboa, 'cliboadmin' can be used as an administrator command.Create an executable environment of cliboa by using cliboadmin.$ cd /usr/local
$ sudo cliboadmin init sample
$ cd sample
$ sudo cliboadmin create simple-etlDirectory TreeDirectory tree which was created aforementioned commands is as below.sample
├── pyproject.toml
├── bin
│   └── clibomanager.py
├── cliboa
│   └── conf
├── common
│   ├── __init__.py
│   ├── environment.py
│   └── scenario
├── conf
│   ├── cliboa.ini
│   └── logging.conf
├── logs
├── project
│   └── simple-etl
│       ├── scenario
│       └── scenario.ymlInstall PyPI packages$ cd sample
$ poetry installWrite a Scenario of ETL ProcessingAs a simple etl processing, write scenario.yml in simple-etl as below.The following example is just download a gzip file from the local sftp server, decompress it, and upload it to the local sftp server.SeeExamplesSet an EnvironmentTo make the above scenario available, set a local machine as a sftp server according to respective environments. Also, put "test.csv.gz" under /usr/local.Execute a Scenario of ETL ProcessingAfter wrote scenario.yml and set the environment, execute a scenario by as below command.cd sample
poetry run python3 bin/clibomanager.py simple-etlYAML Configurationseeyaml_configuration.mdDefault ETL Modulesseedefault_etl_modules.mdHow to Implement Additional ETL Modulesseeadditional_etl_modules.md
Package: clibuilder
anrosentThis module provides a class`cli.CLI`that simplifies writing Command Line Interfaces for applications. It uses the`argparse`module from the CPython standard library, which provides great help/error messaging, as well as argument validation. You can find a decorator-based alternative in`flask.ext.script.Manager`, but here I’ve tried to emulate the`argparse.ArgumentParser`interface, with the bonus of no external dependencies.### ExampleSee`example.py`for a great intro.
Package: cli-builder
cli-builder: Decorators for building command group CLIscli-builder provides a user-friendly interface to quickly build up command group CLIs.import cli_builder

dispatch = cli_builder.Dispatch()
my_cool_group = dispatch.group("my_cool_group")
my_other_cool_group = dispatch.group("my_other_cool_group")

@my_cool_group.command("do-stuff", arguments={
	"positional": dict(type=str),
	"--named": dict(type=int, default=5)
})
def my_func(args): 
	print(args.positional, args.named)

@my_cool_group.command("do-other-stuff", arguments=dict())
def my_other_func(args):
	pass

@my_other_cool_group.command("do-stuff-in-other-group")
def other_group_command(args):
	passInstallationpip install cli-builderLinksProject home pageGitHubPackage distributionPyPIBugsPlease report bugs, issues, feature requests, etc. onGitHub.
Package: clic
ClicA  cli tool for c/c++ development.RequirementsFirst, you should clone [google/googletest] and installCMakein your local machine.google/googletestCMakeInstall$pipinstallclicHow to useAfter googletest installed, you need to export a environmentGTEST_PATHin your bash config file (e.g.bashrc, .zshrc, etc).$clicmycpp
$cdmycpp

$tree-L1.
├──CMakeLists.txt
├──build
├──lib
├──solution.h
└──test.cpp2directories,3files

$cdbuild
$cmake..&&make
$./mycpp

❯./mycpp
Runningmain()from~/mycpp/lib/googletest/googletest/src/gtest_main.cc[==========]Running1testfrom1testsuite.[----------]Globaltestenvironmentset-up.[----------]1testfromtest[RUN]test.INIT
Hellomycpp[OK]test.INIT(0ms)[----------]1testfromtest(0mstotal)[----------]Globaltestenvironmenttear-down[==========]1testfrom1testsuiteran.(0mstotal)[PASSED]1test.If you don't want to export theGTEST_PATHenvironment,  you can specify the path in the same command as follows:$GTEST_PATH=/path/to/cloned/googletestclicmy-new-app
$cdmy-new-appNow, Enjoy your simple c/c++ project. 😉In thetest.cppfile, you can write your tests.#include"gtest/gtest.h"#include"gmock/gmock.h"#include"solution.h"#include<iostream>TEST(test,INIT){/* write your test */}and in thesolution.hfile you can write your solution.#ifndef MY_SOLUTION__#define MY_SOLUTION__classSolution{public:/* write your solution */};#endif/* ifndef MY_SOLUTION__ */