Saravanan666/pypi-org huggingface dataset:
Package: commandtoolutils
commandtoolutilscommandtoolutilsis a Python utility package for creating interactive command line menus.InstallationYou can install thecommandtoolutilspackage from GitHub using pip:pip install git+https://github.com/jobordu/menutools.gitUsageHere's a simple example that shows how you can use thecommandtoolutilspackage:fromcommandtoolutilsimportmenu,ask_questionsdefmain():# Define the menu structuremenu_structure=[{'message':'Say Hello','function':say_hello,},{'message':'Sub Menu','function':menu,'sub_menu':[{'message':'Say Hi','function':say_hi,},],},{'message':'Ask Questions','function':ask_some_questions,}]# Display the menumenu(menu_structure)defsay_hello():print('Hello!')defsay_hi():print('Hi!')defask_some_questions():questions_and_actions=[{'question':'Do you like Python?','function':say_yes,'message':'Great! You selected Yes.',},{'question':'Do you like Java?','function':say_no,'message':'Too bad! You selected No.',}]ask_questions(questions_and_actions)defsay_yes():print('Yes!')defsay_no():print('No!')if__name__=='__main__':main()In this example, themainfunction defines the menu structure and then calls themenufunction to display the menu. Themenufunction takes a list of dictionaries that define the menu options. Each dictionary can contain the following keys:message: The text to display for the menu option.function: The function to call when the menu option is selected.sub_menu: A list of dictionaries that define a sub-menu.Theask_questionsfunction takes a list of dictionaries that define a set of questions to ask the user. Each dictionary can contain the following keys:question: The text of the question to ask.function: The function to call if the user answers 'yes'.message: The message to display if the user answers 'yes'.LicenseMIT
Package: command_watcher
command_watcherModule to watch the execution of shell scripts. Both streams (stdoutandstderr) are captured.watch=Watch()watch.log.critical('msg')watch.log.error('msg')watch.log.warning('msg')watch.log.info('msg')watch.log.debug('msg')watch.run(['rsync','-av','/home','/backup'])fromcommand_watcherimportWatchwatch=Watch(config_file='/etc/command-watcher.ini',service_name='texlive_update')tlmgr='/usr/local/texlive/bin/x86_64-linux/tlmgr'watch.run('{}update --self'.format(tlmgr))watch.run('{}update --all'.format(tlmgr))installed_packages=watch.run('{}info --only-installed'.format(tlmgr),log=False)all_packages=watch.run('{}info'.format(tlmgr),log=False)watch.final_report(status=0,performance_data={'installed_packages':installed_packages.line_count_stdout,'all_packages':all_packages.line_count_stdout,},)[email]subject_prefix=[cwatcher]from_addr=to_addr=logs@example.comto_addr_critical=critical@example.comsmtp_login=mailersmtp_password=1234smtp_server=mail.example.com:587[nsca]remote_host=1.2.3.4password=asdf1234encryption_method=8; port = 5667[icinga]url=https://icinga.example.com:5665user=userpassword=1234[beep]activated=True
Package: commanger
Commanger for pythonA easy to use, extremely configurable shell/terminal command manager for python.At first it may just look like any other command line parser but it has so much more!
You don't have to ever configure the parsing yourself, you can just tell it what you wan't.
It also deals with stray non specfied arguments and I am always adding more!Basic example:Importation and initializationfromcommangerimportcommangercmd=commanger("cmd")The main Function and configcmd.basicConfig([1,2,"b"])#set a basic config@cmd.command#Attach the main funcdefmain(args):#Take in the argsprint(args)Places:DocsGithub
Package: comma-py
commais a generic library for efficient processing of fixed-width
(comma-separated or binary) data mostly written in C++comma-pyis the part ofcommawritten in python; the main part of
it iscsv-evalcommand line utility for efficientnumpy-style
conversions on an input stream of comma-separated or fixed-width binary
data.comma-pyalso has useful modules for dictionary and signal manipulations.for more details, run:csv-eval --help --verbosedocumentation:https://gitlab.com/orthographic/comma/-/wikis/home
Package: commasearch
When we search for ordinary written documents, we send words into a search
engine and get pages of words back.What if we could search for spreadsheets
by sending spreadsheets into a search engine and getting spreadsheets back?
The order of the results would be determined by various specialized statistics;
just as we use PageRank to find relevant hypertext documents, we can develop
other statistics that help us find relevant spreadsheets.
Read morehereIndexingTo index a new spreadsheet, run this., --index [csv file]For example,, --index /home/tlevine/Math Scores 2009 Copy (1).csv \
  http://opendata.comune.bari.it/storage/f/2013-09-02T163858/2012_comune_assessori.csvCaches from the indexing process are stored in the~/.,directory.By default, CSV files that have already been indexed will be skipped; to index
the same CSV file again, run with the--forceor-foption., --index --force [csv file]Once you have indexed a bunch of CSV files, you can search., [csv file]You’ll see a bunch of data tables as results.$ , 'Math Scores 2009.csv'
/home/tlevine/math-scores-2010-gender.csv
/home/tlevine/Math Scores 2009.csv
/home/tlevine/Math Scores 2009 Copy (1).csv
/home/tlevine/math-scores-2009-ethnicity.csv
http://opendata.comune.bari.it/storage/f/2013-09-02T163858/2012_comune_assessori.csv
mysql://bob:password@localhost/schoolsTo doAdd non-exact column matches so that there can be more matches.Store distributions of values (collections.Counterobjects) instead
of just distinct values (setobjects) so that I can run more interesting
comparisons.Store a preview of the table in the db or load it from the cache so that
the web interface can show the preview.
Package: commbank-api-client
Commbank API ClientA fully asynchronous (unofficial) API client for theCommonwealth Bank of Australia.InstallThe following libraries are required:beautifulsoup4(bs4)aiohttpThe following libraries are recommended:asyncio(to run asynchronous code)Install via PyPIDocumentationFor sample usages, seemain.pyFor type documentation, seecommbank-api-client/types.py. Note that the unique identifier for a transaction can be eitherTransaction.idorTransaction.transaction_details_request.
Some transactions do not have an ID, so transaction_details_request is used instead to uniquely identify said transaction, and vice versa. Each transaction is identified by one or the other.
Package: commcare-api
CommCare API Python PackageOverviewThecommcare_apipackage is a Python library that simplifies interaction with the CommCareHQ API. It provides convenient methods for performing operations such as retrieving cases, forms, and performing bulk uploads. This package is designed to streamline CommCareHQ integration tasks in Python applications.InstallationYou can easily install thecommcare_apipackage usingpip:pipinstallcommcare-apiUsageTo use this package, follow these steps:Import theCommCareAPIclass from the package:fromcommcare_api.commcare_apiimportCommCareAPICreate an instance of theCommCareAPIclass by providing your CommCare domain and API version:api=CommCareAPI(domain="your_domain",version="your_version")Utilize the methods of theCommCareAPIclass for various operations. For example, to retrieve cases:cases=api.get_cases(type="case_type",limit=10)# ... (perform other operations)Customize the package according to your application's needs.Example: Printing Case Dataforcaseincases:print(case)Remember to replace"your_domain"and"your_version"with your actual CommCare domain and version.DocumentationFor in-depth documentation, detailed usage examples, and API reference, please refer to theofficial documentation.ContributingWe welcome contributions to improve this package. Please read ourContributing Guidelinesfor more information on how to contribute.LicenseThis package is distributed under theMIT License.AcknowledgmentsWe would like to express our gratitude to the open-source community and all contributors for their valuable contributions to this project.ContactIf you have any questions, suggestions, or encounter issues, please don't hesitate to reach out to us atpierrerobentz.cassion@gmail.com.Make sure to replace placeholders likeyour_domain,your_version,link-to-your-documentation,your-email@example.com, and customize the content as needed for your package.# commcare-api
Package: commedagh-circuitpython-pypi-version-testing
Introductiontesting pypi versioningDependenciesThis driver depends on:Adafruit CircuitPythonPlease ensure all dependencies are available on the CircuitPython filesystem.
This is easily achieved by downloadingthe Adafruit library and driver bundleor individual libraries can be installed usingcircup.Installing from PyPIOn supported GNU/Linux systems like the Raspberry Pi, you can install the driver locallyfrom
PyPI.
To install for current user:pip3installcommedagh-circuitpython-pypi-version-testingTo install system-wide (this may be required in some cases):sudopip3installcommedagh-circuitpython-pypi-version-testingTo install in a virtual environment in your current project:mkdirproject-name&&cdproject-namepython3-mvenv.envsource.env/bin/activatepip3installcommedagh-circuitpython-pypi-version-testingInstalling to a Connected CircuitPython Device with CircupMake sure that you havecircupinstalled in your Python environment.
Install it with the following command if necessary:pip3installcircupWithcircupinstalled and your CircuitPython device connected use the
following command to install:circupinstallpypi-version-testingOr the following command to update an existing version:circupupdateUsage ExampleAdd a quick, simple example. It and other examples should live in theexamples folder and be included in docs/examples.rst.ContributingContributions are welcome! Please read ourCode of Conductbefore contributing to help this project stay welcoming.DocumentationFor information on building library documentation, please check outthis guide.
Package: commentaire
CommentaireCommentaire is a Python program that generates comments and optional
translations for Python code. It uses OpenAI's GPT-3 language model to
add high-level explanatory comments and docstrings to Python code.UsageTo use Commentaire, you must first set up an OpenAI API key. If you
already have an API key, you can set it as an environment variable
calledOPENAI_API_KEY. Otherwise, you can pass your API key as an
argument to thecommentairecommand. (If you do not have one yet,
you can get a key here:https://openai.com/api/.)$ export OPENAI_API_KEY=<your-api-key>or$ commentaire <file> <api-key>Commentaire takes a path to a Python file and an optional language
parameter. If language is specified, Commentaire translates each
docstring and comment in the code to the specified language and
includes the translated text in the output. If language is not
specified, Commentaire does not include any translations in the
output.InstallationTo install Commentaire, you can use pip:$ pip install commentaireFunctionalityCommentaire has a single function,process, which takes in a string
of Python code and an optional language parameter. If language is
specified, the function translates each docstring and comment in the
code to the specified language and includes the translated text in the
output. If language is not specified, the function does not include
any translations in the output. The output text includes the original
code, high-level explanatory comments, and any translated text (if
language is specified).Thecommentairecommand usesprocessto add comments and
translations to Python code in a file. It processes each file in a
list of files passed as arguments to thecommentairecommand.ExampleSuppose you have a file calledexample.pywith the following code:def foo(x):
    y = x + 1
    return yYou can run Commentaire on this file to add comments (and optionally, translations to another language):$ commentaire example.py --language SpanishThe resulting code will be:"""
This function takes in a value x and returns its incremented value.

Esta función toma un valor x y devuelve su valor incrementado.
"""
def foo(x):
    y = x + 1
    return yNote that Commentaire has added high-level explanatory comments and
translated the existing docstring and comment to Spanish.
Package: commentary
CommentaryCommentary is a command line document conversion tool and pandoc filter that preserves native-style comments between Markdown and docx files.InstallationpipinstallcommentaryBasic Usageecho'Hello <!-- this is a comment --> world'>doc.md# convert from md to docx using the CLIcommentarydoc.md-oout.docx# or invoke as a filter from pandocpandocdoc.md-Fcommentary-filter--wrap=none-oout.docx# add metadata to your markdown commentscommentarydoc.md-odoc.mdSeedocumentationfor full usage guide.
Package: commentator
WSGI commenting middlewareTo useMake a factory wrapping your app in the commentator middleware.
Currently, commentator only pickles comments.  To the constructor of
Commentator, pass a database (the path to the pickle) and a pattern.
The pattern is in the form of<URL pattern>#<xpath pattern> -> URLThe URL pattern is apython regular expressionto match against the request’s PATH_INFO.The xpath pattern is where you want to place the comments on the
page.  Seehttp://www.w3schools.com/XPath/for more about xpath
expressions.The URL is apython string templatethat is substituted for groups in the URL regular expression and
element attributes in the found nodes.  The element attributes are
referenced by name (${id},${class}, etc) and the groups are
referenced by number (${1}, …).ExampleA reference implementation is illustrated in the commentator.ini
file.  This uses the pattern:commentator.pattern =(.*)#.//div[@id='comment_on_this']->${1}What this pattern says iscomment on every PATH_INFO(.*)append the rendered content template todiv[@id='comment_on_this']reference the PATH_INFO as the canonical URL${1}To comment on every HTML page at the end of the body, you would usecommentator.pattern =(.*)#.//body->${1}A more complex example is in the.inifile, commented out, for use withbitsyblog:commentator.pattern =/blog/.*#.//div[@class='blog-entry']->/blog/${id}This pattern says:comment on all paths under blogput the comments at the end of eachdiv[@class='blog-entry']get the URI from thediv’s id, not from thePATH_INFOTODOThis is very alpha.  I’d be happy to work more on this if anyone wants
it.  A few outstanding issues:fix weird lxml issue where you have to put .// for elementsallow commenting on multiple resources (multiple patterns per instance)locking pickle filesfix couch….not sure what’s wrongallow use of CSS classes, not just xpath–http://k0s.org
Package: comment-creator
Comment generatorWhen passed a word, this piece of code transforms the text into a B I G hashtag style word.Great for printing little pieces of code when running long pieces of code.Example:# pip install comment-creatorfromcomment_creatorimportcomment_creatorcomment_creator.generate_comment("dates started")Function can output letters and white space at the moment. Will add numbers.Output:####   #####  #####  #####   ###          ###   #####  #####  #####  #####  #####  ######  #  #   #    #    ##     #            #        #    #   #  ##  #    #    ##     ##  ###  #  #####    #    ####    ###          ###     #    #####  #####    #    ####   ##  ###  #  #   #    #    ##         #            #    #    #   #  ## #     #    ##     ##  #####   #   #    #    #####   ###          ###     #    #   #  ##  #    #    #####  ####Improvement since 0.0.5Added numbers to the character dictionaryYou can pass an optional second string argument: "warn"(yellow), "success"(green) or "fail"(red) and the output will be in the respective color. Default color is the default print color statement of your IDE.
Package: commentdater
commentdater is a command line tool that reminds you to update your comments when you change a line of code.Installationpip install commentdaterUsageusage: commentdater [-h] -f FILECheck if your comments are out of dateoptional arguments:-h,--helpshow this help message and exit-fFILE,--fileFILEfile to checkAuthor<lsingh@college.harvard.edu>
Package: commented-out-code
commented out codeThis library can detect both inline or block commented out code.It sends rpc to the server which uses LSTM model to predict commented out code.
The server runs on my school data center, and will be migrated to a private machine.Only support c/c++ now. More language support is about to comeHow to usesample codetext =  '''
    void DropoutLayer::updateB(){

        int num = this->numUnit;
        //cout<<"Error!!!!!!!!!!!!!!!!in DropoutLayer!!!!!!!"<<endl;
        if (this->z == NULL){ // embeddings
            // gradB += dE_dy, because y = b
            iXpY( num , this->dE_dy, gradBiases + bidx );

            return;
        }

        if (fprime != dummy){

            // dy_dz = f', evaluated at y
            ( * this->fprime)(this->y, this->dy_dz, num);
            // dE_dz = dE_dy .* dy_dz

            pointwise_dot(this->dE_dy, this->dy_dz, this->dE_dz, num);
            //cout<<"dropout backward"<<endl;
            for( int i = 0; i < num; ++i){

                this->dE_dz[i] *= this->indicator[i];

            }

        }// else if fprime == softmaxprime{
            // do nothing, because we assume dE_dz is given by softmax

        //}

    //		ReLUPrime(float * y, float * dy_dz, int n);
    }
'''
print(client.search(text, 'cpp')) # return OrderedDict object, key is line_number, value is the commented code itself

# output
# OrderedDict([(4, 'cout<<"Error!!!!!!!!!!!!!!!!in DropoutLayer!!!!!!!"<<endl;'),
#             (19, 'cout<<"dropout backward"<<endl;'),
#             (26, 'else if fprime == softmaxprime{'),
#             (29, '}'),
#             (31, 'ReLUPrime(float * y, float * dy_dz, int n);')])
Package: comment-header-creator
Comment Header CreatorCreate a "header" for separating/describing sections of your Python code.I don't know about you but I like to "organize" my Python methods and functions by putting some sort of comment
seperator between them.  This helps me when scrolling through my code to find particular categories of routines.There are basically 2 main methods:  Basic or FancyBasic (the uniline() method) returns a formatted string that is a single line with the 'title' centered.Fancy (the multiline() method) returns a formatted string that is 3 lines long with the 'title' centered in the
center line.There is a "hidden" function, _generate_line(), is the secret sauce to generating the lines.  You can call this
directly but bear in mind it returns a Tuple (string and a boolean).InstallationFor some reason that I cannot figure out PyPi changes "comment_header_creator" into "comment-header-creator".  This
causes issues in that you have to use "dashes" to pip install but then use "underscores" to import.pip install comment-header-creatorExample UsesSee example.py for how to use or:Create a single-line header but input title from user input:importcomment_header_creatoraschcprint(chc.uniline())yields:EnterTitle:titleofsection# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- TITLE OF SECTION -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #Create a multi-line header but input title from user input:importcomment_header_creatoraschcprint(chc.multiline())yields:EnterTitle:AnotherSection# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- ## -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- ANOTHER SECTION -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- ## -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #Create a single-line (or multi-line) header by passing title in function call:importcomment_header_creatoraschcprint(chc.uniline(title='Greatest Hits'))yields:# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- GREATEST HITS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #You can also set your own 'expander' string:import comment_header_creator as chc
chc.uniline(title="it's a flesh wound", expander='0i')
"# i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i IT'S A FLESH WOUND i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i0i #"NOTE:  In the previous example notice that we didn't use the print() function.  This will return a string, which you
then need to "strip" the quotes off the front and end.  Thus, I suggest print()'ing your outputs.
Package: commentjson
commentjson(Comment JSON) is a Python package that helps you create JSON
files with Python and JavaScript style inline comments. Its API is very similar
to the Python standard library’sjsonmodule.Installationpip install commentjsonBasic Usage>>>importcommentjson>>>>>>json_string="""{
...     "name": "Vaidik Kapoor", # Person's name
...     "location": "Delhi, India", // Person's location
...
...     # Section contains info about
...     // person's appearance
...     "appearance": {
...         "hair_color": "black",
...         "eyes_color": "black",
...         "height": "6"
...     }
... }""">>>>>>json_loaded=commentjson.loads(json_string)>>>printjson_loaded{u'appearance':{u'eyes_color':u'black',u'hair_color':u'black',u'height':u'6'},u'name':u'Vaidik Kapoor',u'location':u'Delhi, India'}DocumentationComplete documentation can be foundhere.Testspython setup.py testLicenseSeelicense.
Package: comment-object
commentThecommentPython library provides an explicit object for comments.Installpip install comment-objectUsageYou can useCommentas a context. It does nothing but expell all comments
from your source code!from comment import Comment

with Comment("seconds") as c:
    DAY = 60 * 60 * 24PhilosophyA comment should have its scope inside some other code scope.For example,DAY = 60 * 60 * 24 # secondsThe comment "# seconds" explainsDAYconstant that it has the unit second.
The scope of this comment is this one line, inside module scope maybe.A comment can be replaced with an object which does not have any effects on
the code around.If a comment breaks the principle, then it is not a comment.
The coding comment, for example, can be such a type; it should be called a pragma.LicenseSee LICENSE.txt.