Saravanan666/pypi-org huggingface dataset:
Package: chalk-diagrams
Chalk is a declarative drawing library built on top ofPyCairo.
The API draws heavy inspiration from
Haskell'sdiagrams,
Scala'sdoodleand
Jeremy Gibbons's lecture notes onFunctional Programming for Domain−Specific Languages.The documentation is available athttps://chalk-diagrams.github.io.⚠️ The library is still very much work in progress and subject to change.InstallationThe library is available on PyPI aschalk-diagramsand can be installed withpip:pipinstallgit+https://github.com/chalk-diagrams/chalk/On Debian (or Colab) you will need to install Cairosudoapt-getinstalllibcairo2-devIf you want to use the LaTeX extension, run:pipinstallchalk-diagrams[latex]For the LaTeX extension you might need to installpdf2svgandtexlive;
on Debian these dependencies can be installed as follows:sudoapt-getinstallpdf2svgtexlivetexlive-sciencetexlive-latex-recommendedtexlive-latex-extraInstallation with CondaYou can install the library withcondafromconda-forgechannel.condainstall-cconda-forgechalk-diagramsOverviewBelow we provide a brief introduction of the main functionality of the library.
These examples are available in theexamples/intro.pyfile.We start by importing thecolourmodule and thediagramsfunctions:fromcolourimportColorfromchalkimport*We also define some colors that will be shortly used:papaya=Color("#ff9700")blue=Color("#005FDB")We can easily create basic shapes (the functionscircle,square,triangle) and style them with various attributes (the methodsfill_color,line_color,line_width).
For example:d=circle(1).fill_color(papaya)The diagram can be saved to an image using therendermethod:d.render("examples/output/intro-01.png",height=64)We can glue together two diagrams using the combinatorsatop(or+),beside(or|),above(or/).
For example:circle(0.5).fill_color(papaya)|square(1).fill_color(blue)which is equivalent tocircle(0.5).fill_color(papaya).beside(square(1).fill_color(blue))This code produces the following image:We also provide combinators for a list of diagrams:hcatfor horizontal composition,vcatfor vertical composition.
For example:hcat(circle(0.1*i)foriinrange(1,6)).fill_color(blue)We can use Python functions to build more intricate diagrams:defsierpinski(n:int,size:int)->Diagram:ifn<=1:returntriangle(size)else:smaller=sierpinski(n-1,size/2)returnsmaller.above(smaller.beside(smaller).center_xy())d=sierpinski(5,4).fill_color(papaya)Gallery of examplesFor more examples, please check theexamplesfolder;
their output is illustrated below:squares.pylogo.pyescher_square.pyhilbert.pykoch.pyhex-variation.pylenet.pytensor.pyhanoi.pytree.pylattice.pyThese scripts can be run as follows:pythonexamples/squares.pyAuthorsDan OneațăAlexander RushSpecial thanks to:Sugato Ray, for his significant contributions and suggestions;Ionuț G. Stan, for providing many useful insights and comments.
Package: chalk-harness
Chalk HarnessThis package wrapsChalk's CLIwith Python to aid with testing.Chalk enables innovative machine learning teams to focus on building
the unique products and models that make their business stand out.
Behind the scenes Chalk seamlessly handles data infrastructure with
a best-in-class developer experience.Example Usageharness=CLIHarness()harness.apply_await(force=True)version=harness.version()assertversion.version=="v0.4.5"==harness.version_tag_only()print(harness.whoami().user)print(harness.token().token)
Package: chalkit
chalkitChalkit is a CLI tool to save ideas/todos by just opening your terminal.
The git repository is automatically committed and pushed.Lets you quickly type your ideas/todos using the terminal and continue on with your work.Initital setupRequires a directory containing git repository with a README.md file in it.
When you run chalkit for the first time, it asks for the absolute path for this directory.The configuration files are stored as determined by user_config_dir mentioned byappdirsHow to install$ pip install chalkitCommands$ eureka    First time setup, edit ur ideasFlags$ --view      View your ideas in read-only mode
$ --reset     Reset your configurationsImprovementsFeel free to raise issues, ask for features. Leave a star if helpful.
Package: chalky
Simple ANSI terminal text coloringYet another terminal text coloring library…Why? Because, I like certain things and I hate certain things about the currently
available solutions.
This here is my attempt to build an interface for simply applying ANSI escape sequences
to strings that I enjoy and can update at my own free will.
That is it, there is nothing new or interesting that this packages adds.
Thanks 🎉For more interesting details, please visit thedocumentation.Style Compositionfromchalkyimportsty,fgmy_style=sty.bold&fg.redprint(my_style|"This is red on black")print(my_style.reverse|"This is black on red")Style Chainingfromchalkyimportchainprint(chain.bold.green|"I'm bold green text")print(chain.white.bg.red.italic|"I'm italic white text on a red background")Truecolorfromchalkyimportrgb,sty,hexprint(rgb(23,255,122)&sty.italic|"Truecolor as well")print(sty.bold&hex("#ff02ff")|"More and more colors")Disable Colorsfromchalkyimportconfigure,fgprint(fg.red|"I am red text")configure(disable=True)print(fg.red|"I am NOT red text")
Package: challenge-4-simple-linear-regression
Challenge 4 Simple Linear RegressionChallenge 4 Simple Linear Regression ModelFree software: MIT licenseDocumentation:https://challenge-4-simple-linear-regression.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2022-12-07)First release on PyPI.
Package: challenge-me
A command line tool for running programming challenges. This is still an early version which can have unwanted side
effects like accidentally deleting a wrong file. Use with care.Installationpip install challenge-meDocumentationhttps://challenge-me.readthedocs.org/en/latest/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.1.0 (2016-01-30)First release on PyPI.
Package: challenge-rlcrt
The module display a Video Feed (From a webcam) with a specified latency.
The user can set a latency up to 5 seconds with a relative precision of 10%UsageCLIThe module can be use by CLICLI HelpYou can use the Help from the CLIchallenge--helpYou can have command specific help by usingchallenge <cmd>--helpFor exemple, here’s the help for the show commandchallenge show--helpDebug ModeAt anytime you can see the debug logs in the console, by passing--debugbefore any commands.
For examplechallenge--debugshowDisplay latent feedTo display live feed from cam and the latent frame, use theshowcommand.
Here’s an example with a latency of 1 seconds with debug mode enablechallenge--debugshow--latency1000To exit press `q`InstallationInstall the Python module with pippip install challenge_rlcrtRequirementsUser must a Python 3 and pip installed.
User must have a Webcam.This module is usingopen_cvdevelopmentthe Python modules requirements needed are in requirements.txt file
Create a virtual environment and install dependencies.pip install-rrequirements.txtAuthorschallenge_rlcrtwas written byRick Lacerte.
Package: challengeutils
Sage Bionetworks Challenge Utilities[!WARNING]Starting early 2024, this package will no longer be maintained.We are  in the process of creating a new-and-improved version ofchallengeutils- more information coming soon!challengeutilsis a set of tools and commands that provides an interface for managing crowd-sourced challenges administered onSynapse, including but not limited to,DREAM Challenges.  Its main purpose is to ease the process of creating, monitoring, and ending a challenge, as well as provide useful functions for post-competition analysis.This package is being actively developed and maintained by DREAM and Informatics & Biocomputing (IBC), Computational Oncology Group at Sage Bionetworks.Documentationchallengeutilsfunctionality is documented,click here to check it out!Installationpip install challengeutils
challengeutils -vThis repository also usespre-committo autolint files according toBlack's coding styles. To run the hook in your local dev environment, enter the following:pip install pre-commit
pre-commit installNowpre-commitwill run automatically ongit commit! For example:$ git commit -m 'update readme' -a
Check Yaml...........................................(no files to check)Skipped
Fix End of Files.........................................................Passed
Trim Trailing Whitespace.................................................Passed
black................................................(no files to check)Skipped
[add-pre-commit 75b4393] update readme
 1 file changed, 23 insertions(+)ContributingThinking about contributing to challengeutils? Get started by reading ourContributor Guide.
Package: challonge2elo
This script implements the Elo rating system for Challonge tournament results. The ratings are output to a CSV file, and they are also saved in a JSON file so that you can go back and update them later with future tournament results.Note that this script relies on players having the same name for each tournament. If you are a tournament organizer, make sure your naming scheme is consistent!Installation$pipinstallchallonge2eloConfigurationLog in to your Challonge account andget your API key. Then export your username and API key as environment variables:$exportCHALLONGE_USERNAME="<Your Challonge username>"$exportCHALLONGE_API_KEY="<Your Challonge API key>"UsageCreate your ratings by passing tournament IDs:$challonge2eloggsmash-116_smash4ggsmash-416_smash4
Package: challonge-wrapper
challonge-python-wrapperA wrapper for Challonge's REST API. Its main objective is to provide the ability to create easy-to-read, fast-to-build tools fortournament organizing and analysis, which is also the reason why I decided to leave out fields that do not contribute towards that goal.Featuresfull support for Double Elimination brackets;tournament, match and partecipant classes are totally decoupled, allowing you to istantiate just what you need for your use case;ability to instantiate ChallongeTournament objects with or without attaching matches / participants;players in ChallongeMatch objects are named, despite the matches endpoint not providing names;round names are correctly assigned in Double Elimination brackets.Installationpip install challonge-wrapperUsageMake sure to generate an API keyhere. Then import theset_api_key()function by typingfrom challonge_wrapper import set_api_keyand usingset_api_key()with your API key as a parameter. Make sure to also importinit_tournament(),init_matches()and / orinit_partecipants(). Then, call your desired function as follows:t = init_tournament(
	"evojap19kof14",
    "evo"
)you can just print this object to get:id: 5316434, name: Evo Japan 2019 - The King of Fighters XIV, players: 192, game: The King of Fighters XIV, start: 2019-02-14you can instantiate a tournament object and also retrieve matches and / or players for that tournament like that:t = init_tournament(
	"evojap19kof14",
    "evo",
    matches=False
    participants=True
)you can then access the object's attribute by simply calling his properties:for p in t.participants:
	print('{}, {}'.format(p.id, p.name))Todofully implement Single Elimination and Swiss brackets;implement ability to set timezone;implement POST operations;write docs;
Package: chama
[![build](https://github.com/sandialabs/chama/workflows/build/badge.svg)](https://github.com/sandialabs/chama/actions/workflows/build_tests.yml)
[![Coverage Status](https://coveralls.io/repos/github/sandialabs/chama/badge.svg?branch=main)](https://coveralls.io/github/sandialabs/chama?branch=main)
[![Documentation Status](https://readthedocs.org/projects/chama/badge/?version=latest)](http://chama.readthedocs.io/en/latest/?badge=latest)
[![Downloads](https://pepy.tech/badge/chama)](https://pepy.tech/project/chama)Continuous or regularly scheduled monitoring has the potential to quickly
identify changes in the environment. However, even with low-cost sensors, only
a limited number of sensors can be used.
The physical placement of these sensors and the sensor technology used can have
a large impact on the performance of a monitoring strategy.Chama is a Python package which includes mixed-integer, stochastic
programming formulations to determine sensor locations and technology that maximize
the effectiveness of the detection program.
The software was developed to design sensor networks for water distribution networks and airborne pollutants,
but the methods are general and
can be applied to a wide range of applications.For more information, go tohttp://chama.readthedocs.ioCiting ChamaTo cite Chama, use the following reference:Klise, K.A., Nicholson, B., and Laird, C.D. (2017). Sensor Placement Optimization using Chama, Sandia Report SAND2017-11472, Sandia National Laboratories.LicenseRevised BSD.  See the LICENSE.txt file.OrganizationDirectorieschama - Python packageci - Travis CI requirementsdocumentation - User manualContactKatherine Klise, Sandia National Laboratories,kaklise@sandia.govSandia National Laboratories is a multimission laboratory managed and operated by National Technology and
Engineering Solutions of Sandia, LLC., a wholly owned subsidiary of Honeywell International, Inc., for the
U.S. Department of Energy’s National Nuclear Security Administration under contract DE-NA-0003525.
Package: chamallow
Chamallow...Install...Local Usage Only...(venv)$pipinstallchamallowDistributed Usage...(venv)$pipinstallchamallow[zmq]Func Dispatching...From YAML...# funcs.pydefping(a,k=None):returnf"{a}and{k}"defpong(a):print(a)...# demo.ymlping:name:"funcs.ping"args:-"foo"kwargs:k:"bar"tags:-"foo"pong:name:"funcs.pong"args:-_from:"ping"...(venv)$CHAMALLOW_TAGS=foochamallowdemo.yml
fooandbarWith Decorators...# demo.pyfromchamallowimportengine,flow@flow(tags=("foo",))defping(a,k=None):returnf"{a}and{k}"@flow()defpong(a):print(a)returnTrueif__name__=="__main__":engine.start()assertpong(ping("foo",k="bar")).result()isTrueengine.stop()...(venv)$CHAMALLOW_TAGS=foopythondemo.py
fooandbarHacking...CLI...(venv)$chamallowDocker...$docker-composeup-d
$docker-composeexecchamallowbash-c"chamallow examples/simple.yml"$docker-composeexecchamallow-clientbash-c"cat simple.csv simple.json"foo;bar
xxx;YYY{"foo":"xxx","bar":"YYY"}SettingsADDRESSCACHE_TTLCONNECT_PORTDEBUGLOCALLOG_FORMATPOLLING_INTERVALNUMBER_OF_CLIENTSNUMBER_OF_REMOTE_CLIENTSTAGSContributing...Linting...(venv)$pipinstallchamallow[lint](venv)$pre-commitrun--all-filesTesting...(venv)$pipinstallchamallow[test](venv)$CHAMALLOW_LOCAL=Truepytesttests/LicenseMIT
Package: chamber-backup-diff
chamber-backup-diffCompare the contents of two local_chamber backup filesFree software: MIT licenseDocumentation:https://chamber-backup-diff.readthedocs.io.CreditsThis package was created with Cookiecutter andrstms/cookiecutter-python-cli, a fork of theaudreyr/cookiecutter-pypackageproject template.audreyr/cookiecutteraudreyr/cookiecutter-pypackagerstms/cookiecutter-python-cliUsage: cbdiff [OPTIONS] OLD NEW

  diff contents of chamber backup tarballs

Options:
  --version                Show the version and exit.
  -d, --debug              debug mode
  --shell-completion TEXT  configure shell completion
  --help                   Show this message and exit.
Package: chamberconnectlibrary
# ChamberConnectLibrary
Python library for interfacing with Espec North America chambers with P300, SCP-220, Watlow F4T &amp; Watlow F4S/D controllers.## Requirements
python 2.7.x## Installation`pip install chamberconnectlibrary`## Updating
Do to some renaming to make the library pep8 compliant some files have been renamed from version 1.x to 2.0.0.
To ensure that the current version is used uninstall and then reinstall the library:`pip uninstall chamberconnectlibrary``pip install chamberconnectlibrary`## TestingTo test run chamberconnectlibrary-test.py(on windows using COM port #3, test script is located in Python2.7Scripts directory)P300:`chamberconnectlibrary-test.pyEspec Serial\\.\COM319200`SCP-220:`chamberconnectlibrary-test.pyEspecSCP220 Serial\\.\COM39600`Watlow F4T:`chamberconnectlibrary-test.pyWatlowF4T RTU\\.\COM338400`Watlow F4:`chamberconnectlibrary-test.pyWatlowF4 RTU\\.\COM319200`## Documentation
See [controllerinterface.md](controllerinterface.md)
Package: chamd
CHAMDConversion and cleaning of CHILDES CHA files into PaQu Plaintext
Metadata Format (to convert to Alpino).Installation and usagepipinstallchamd
chamd--helpRunning from project:python-mchamd--helpImport as libraryThis way the library can be used to read CHAT file (contents) from an external application.fromchamdimportChatReaderreader=ChatReader()chat=reader.read_file('example.cha')# or read_stringforiteminchat.metadata:print(item)forlineinchat.lines:foriteminline.metadata:print(item)print(line.text)Upload to PyPipythonsetup.pysdist
twineuploaddist/*Run testspython-munittestdiscovertests/
Package: chame
chameis a Python module to work with genomic ranges and chromatin accessibility.
Part ofscverse.Documentation|ExamplesInstallchamepip install git+https://github.com/gtca/chameFunctionalityI/O10X Genomics ARC, SnapATAC, ArchR (arrow files).Preprocessing and QCTF-IDF / LSI. TSS enrichment, mono-nucleosome occupancy, etc.PlottingJoint gene + peak visualisation.Other projectsmuonepiscanpySnapATAC2ArchRSignac
Package: chameleon-fetcher
Chameleon fetcherA small wrapper forchameleon page templatesto easily fetch and render templates.Installationpipinstallchameleon_fetcherUsageE.g. you have in template dirmy_template_dira filesimple.ptwith
the following content:<test>${template_name} ${myvar} ${some_var}</test>You can then do:fromchameleon_fetcherimportChameleonFetchercf=ChameleonFetcher('my_template_dir',some_var=42)output=cf('simple',myvar='test')assertoutput=='<test>simple test 42</test>'Please note howsome_varis set "globally", while for the specific template also a
variablemyvaris used.The following parameters are accepted by ChameleonFetcher:template_dir: the directory where the templates are locatedAnd optionally:extension: extension of the template files, defaults to '.pt'boolean_attributes: what boolean attributes should be supported, defaults to all valid html
boolean attributes. Seehttps://meiert.com/en/blog/boolean-attributes-of-html/auto_reload: if the templates should be reloaded on change, defaults to True**kwargs: other params you want to have available in all templates, e.g. flask=flaskFor using the actual templates, check the fantasticchameleon documentation.
Package: chameleon.genshi
This package provides a fast Genshi template implementation based on
the Chameleon template compiler. It’s largely compatible withgenshi.template.Compiler notes1. Match templates defined in included templates are not applied to
the calling document.DevelopmentIf you want to use the code directly from trunk (recommended only for
development and testing usage), providechameleon.genshi==devas your
dependency.The code is maintained in a subversion repository:svn://svn.repoze.org/svn/chameleon.genshiWant to contribute? Join #repoze on Freenode IRC.
Package: chameleon.html
This package implements a template compiler for dynamic HTML
documents. In particular, it supports the XSS rule language which is
used to associate elements with dynamic content.XSS rule languageThe XSS rule language uses a CSS-compliant syntax to let you match HTML
elements using CSS selectors and set up dynamic content
definitions.To associate a template with a rule file, use the <link> tag:<link rel="xss" type="text/xss" src="rules.xss" />XSS files contain rules like the following:html > head > title {
  name: document-heading;
  structure: true;
  attributes: document-attributes;
  mode: content;
}This rule will associate the <title> tag with the dynamic content
identifier “document-heading”, escape the inserted content and apply
the dynamic attributes bound to the “document-attributes” identifier.See the filetemplate.txtwithin the package for documentation on
how to render templates and provide dynamic content and attributes.SyntaxBrief explanation of the properties in the XSS format:@name        dynamic content slot name
@structure   if set to true, inserts content without escaping
@attributes  inserts dynamic attributes into tag
@mode        one of ('content', 'append', 'prepend')Resource rebase functionalityIf a resource location adapter is available (seechameleon.html.interfaces.IResourceLocation), references resources
(e.g. images, stylesheets, javascripts) will be “rebased” to the URL
returned by the component.
Package: chamomile
Chamomile makes it more pleasant to make assertions inside your Python unit
tests. It borrows heavily fromJasmine’s assertion syntax. Take a look:import chamomile

class ExampleTest(chamomile.Test):
    def test_simple_assertions(self):
        self.expect(12).to_equal(12)
        self.expect(False).to_not_be(0)

        with self.expect(ZeroDivsionError):
            4 / 0You can easily browse the full list of available assertions in thesource.
Package: chams
chams - NLP Tasks with OpenAI GPT-3Welcome to chams, a Python package for natural language processing (NLP) tasks such as paraphrasing and email generation using OpenAI's GPT-3 model.Installationyou can install chams by running the following command:pipinstallchamsUsageTo use chams, you will need to set the OPENAI_API_KEY environment variable to your OpenAI API key.You can then use the following command to generate emails with chams:chamsemail"send login for the database to infrastructure team"--language"en"-n3This will generate 3 emails with the subject "send login for the database to infrastructure team" in English.You can also use the paraphrase command to generate paraphrased text. For example:chamsparaphrase--text"Hello, how are you doing?"--language"en"--number2This will generate 2 paraphrased versions of the text "Hello, how are you doing?" in English.Authorchams was created by Zakaria Fellah. You can reach him atfellah.zakaria@yahoo.comLicensechams is released under the MIT license.
Package: chan
Implements Go’s chan type in Python.Install withpip install chanSource athttp://github.com/stuglaser/pychanUsageYou canputonto channels, andgetfrom themc=Chan()# Thread 1c.put("Hello")# Thread 2print"Heard:%s"%c.get()Channels can be closed (usually by the sender).
Iterating over a channel gives all values until the channel is closedc=Chan()# Thread 1c.put("It's")c.put("just")c.put("contradiction")# Thread 2forthinginc:print"Heard:",thingYou can wait on multiple channels usingchanselect.  Pass it a list of input channels and another of output channels, and it will return when any of the channels is readydeffan_in(outchan,input1,input2):whileTrue:chan,value=chanselect([input1,input2],[])ifchan==input1:outchan.put("From 1: "+str(value))else:outchan.put("From 2 "+str(value))You can see more examples in the “examples” directory.