Saravanan666/pypi-org huggingface dataset:
Package: chaintool
chaintoolis aGPLv3-licensed tool to manage certain kinds of “toolchain” usecases that require executing a sequence of commandlines.This is not a replacement for a build system, but rather an alternative to creating one-off scripts for usecases that fit the following characteristics:A fixed sequence of command invocations. The sequence may terminate on error, but otherwise the commandlines to invoke are not affected by the output of previous commands.The commands accept a large variety of command-line arguments, and many of those are being used. Some of these arguments will very rarely be changed. Some of these might occasionally be changed but should have sensible defaults. Some will be changed frequently, perhaps even from run to run.For correct usage, certain arguments across different commands must be supplied with the same value, or with related values (e.g. options that reference the same file basename but with different extensions).chaintool provides a way to define and manage that sequence of commandlines, and generate a “shortcut” script that will run it. The arguments you care about surfacing will be available as command-line options for this shortcut, and will flow down to generate the correct arguments for the relevant commands in the sequence.Obviously, you could instead just manually author a script that contains the command invocations. But using chaintool helps you generate a variation on a sequence, or run an existing sequence with different arguments, in a quick and more error-free way. You don’t have to dig through any of the arguments you don’t currently care about, you don’t run the risk of forgetting to edit some commandline as you change occurrences of a common value, you won’t break anything with a copy-and-paste error or accidental deletion, and you won’t have to remember the specific syntax for options that you need to flip between excluding/including.If you’re using the bash shell, another major benefit from chaintool is that the shortcuts you create will have full autocompletion support, for the options that you have defined and chosen to surface.chaintool also helps export definitions for these command sequences that are fairly portable. If there are paths or argument values that are specific to a particular OS, or to a particular user’s environment, those values can be left as required parameters that an importer must fill in before running the sequence.DocumentationXXX Eventually need a link here to the relevant readthedocs page.Changelog0.1.1(2021-04-22)Some metadata fixes.0.1.0(2021-04-22)Initial build and upload to PyPI.
Package: chaintools
chaintoolsFunction chainingchaintools.F를 활용해 함수를 연결하는 할 수 있다.defadd(tar:int)->Callable[[int],int]:def_wrapper(src:int)->int:returnsrc+tarreturn_wrapperf=F>>add(1)>>add(2)assertf(3)==6함수의 반환 형태가Tuple[Tuple, Dict[str, Any]]형태일때 다음 함수의*args, **kwargs에 값을 넣어줄 수 있다.deffunction1()->Tuple[Tuple,Dict[str,Any]]:return(1,2),{'c':1,'d':2}deffunction2(a,b,c,d)->int:returna+b+c+df=F>>function1>>function2assertf()==6
Package: chaintrailapi
Chaintrail API WrapperInstallationpip3installchaintrailapiImport and use the package as demonstrated inexample.pybelow:fromchaintrailapiimportChainTrail,Accounts,Datasetimportmatplotlib.pyplotaspltapi=ChainTrail("localhost:3000",Dataset.JAN_2019)account_data=api.get_accounts(['acct_address'])account_scaled=api.get_accounts(['tx_count','avg_tx_in','avg_tx_out','std_tx_in','std_tx_out']).get_scaled()print(account_scaled.shape)pcadata=ChainTrail.calculate_pca(account_scaled,components=2)inliers,outliers,xx,yy,z_train=ChainTrail.predict_outliers(pcadata)# plot the training pointsplt.contour(xx,yy,z_train,levels=[0],linewidths=2,colors='darkred')plt.scatter(pcadata[inliers,0],pcadata[inliers,1],color='blue',alpha=0.2)plt.scatter(pcadata[outliers,0],pcadata[outliers,1],color='red',alpha=0.4)plt.show()
Package: chainy
ChainyOverviewChainy is a Python package for declarative prompt chaining.
It allows users to define a chain of prompts to be run by a Large Language Model (LLM).
These chains are defined using a YAML configuration file and can include dependencies, which are handled automatically.InstallationTo installchainy, you can use a package manager likepip.pipinstallchainyYou can find the package repositoryhere.UsageConfigurationChainy uses YAML configuration files to define chains of prompts.
Here's an example of what these configuration files look like:inputs:-input_1-input_2prompts:prompt_1:model:my_modeltemplate:tmpl01.mdsubstitute:var_1:input_1var_2:input_2prompt_2:model:my_modeltemplate:tmpl02.mdsubstitute:res_1:prompt_1In this example,prompt_1andprompt_2are the prompts to be run.
Each prompt includes a template file and a dictionary of variables to be substituted into the template.
The dependencies between prompts are defined in the substitute section:prompt_2depends onprompt_1.Expected Directory Structure|- yourproject/
|--- prompts/
|----- tmpl01.md
|----- tmpl02.md
|--- chains/
|----- example-1.yml
|--- entrypoint.pyBring Your Own Model (BYOM)Each prompt must specify the alias of the model that will be used to generate the response.
Models must be added to a chain withChain.add_model(name, model)before the chain is started.Models are user defined classes that adhere to theLanguageModelProtocolorChatModelProtocol,
which can be found in thellmmodule.
Essentially, the model needs to expose the appropriategenerate()method, thenchainywill take it from there.Running a ChainTo run a chain, call theChain.start()method with the required input values:fromchainy.modelimportChain# STEP 1: Load your chain from configurationchain=Chain.from_config("chains/example-1.yml")# STEP 2: Add your model(s)model=...# instantiate your model here!chain.add_model("my_model",model)# STEP 3: Start the chainchain.start("hey","bud")TestingTests are located in thetests/directory. To run them, use your preferred test runner.ContributingWe welcome contributions! Please open an issue or submit a pull request if you have something to add.LicenseMIT
Package: chainz
Chainz is a lightweight library to provide chaining, functional methods
to iterables.To install:pip install chainzBasic example:fromchainzimportChainChain(xrange(10))\.map(lambdax:x+1)\.filter(lambdax:x%2==0)\.omit(lambdax:x%3==0)\.reduce(lambdax,y:x+y)# 30ChainThe fundamental class inchainzisChain, which accepts an
iterable as an argument to its constructor. It is itself an iterable,
just exposing the supplied iterable. It exposes functional methods likemap,filter, andflatten, which return the chain so as to be
chainable. These methods alter the chain;chain.map(f)is the same
aschain = chain.map(f).Some methods, such asreduceandfor_each, are “sinks”, in that
they consume the iterable. These methods do not return the chain, to
make it clear that once they are called, the chain is done.All non-sink methods are lazy, so they don’t result in any evaluation.
Only by using a sink method, or consuming the iterable in another way
(such aslist(chain)or[x for x in chain]), do you actually
evaluate the iterable.You can think ofChainas a way to wrapitertoolsin a more
chainable fashion.ErrorsBy default, aChainwill stop whenever there’s an exception. Often
that is not what you want. When you are processing a long list of items
(something for whichChainwas specifically created for), you just
want to note what went wrong, and move on to the next item. The methodon_errorallows just that. It takes a functionf(exception, object)which itself takes two parameter. The first
parameter is the raised exception. The second parameter is the object
that caused the exception.Exampledefhandle_error(exception,obj):print("%scaused exception:%s"%(obj,exception))defdouble(x):ifx==1:raiseException('Bad')returnx*2chain=Chain(xrange(3)).on_error(handle_error).map(double)list(chain)# "1 caused exception: Exception('Bad')"# [0, 2]APIPlease see thedocs/directory for auto-generated (and thus
up-to-date) documentation. This is generated from the doc strings, so
introspection can also be helpful (eg,print Chain.reduce.__doc__).
Package: chaiprofile
PyPi:https://pypi.org/project/chaiprofile/package ที่อธิบาย profile สามารถนำไปใช้กับผู้อื่นได้วิธีติดตั้งเปิด CMD / Terminalpipinstallchaiprofileวิธีใช้งานแพ็คเพจนี้เปิด IDLE ขึ้นมาแล้วพิมพ์…```python my = Profile(‘Chai’) my.company = ‘aeroth’ my.hobby =
[‘Studying’,‘Reading’,‘Sleeping’] print(my.name) my.show_email()
my.show_myart() my.show_hobby()พัฒนาโดย: ชัย ก. FB:https://www.facebook.com/ChaiMeehMeeh
Package: chaipy
ChaiPyA developer interface for creating Chat AIs for the Chai app.InstallYou can install chai using pip$ pip install -U chaipyDocumentationAn API guide is available on theChai websiteTestingTests can be run usingpytest.$ python -m pytestRequirementsPython 3.7 or later is required.Get InvolvedSpeak to us onWhatsappCome join us onDiscord!
Package: ch-airflow-tools
Airflow ToolsWelcome to Airflow Tools! This package provides a collection of useful tools, utilities, and extensions for working with Apache Airflow, a platform to programmatically author, schedule, and monitor workflows.FeaturesTask Monitoring:Monitor task statuses and execution details easily.Utilities:Helpful utility functions to simplify common Airflow tasks.Extensions:Additional features and integrations to enhance your Airflow workflows.InstallationYou can installch_airflow_toolsusing pip:pipinstallch_airflow_toolsUsageOnce installed, you can import and use the tools provided by this package in your Airflow DAGs and workflows. Here's a quick example of using the task monitoring feature:fromairflowimportDAGfromairflow_tools.monitoringimportget_task_statusdefault_args={'owner':'airflow','depends_on_past':False,'start_date':datetime(2023,8,1),'retries':1,}dag=DAG('example_dag',default_args=default_args,schedule_interval='@daily')# Define your tasks here...# Example of using the task monitoring functiontask_status=get_task_status(dag=dag,task_id='my_task_id',execution_date='2023-08-22T00:00:00+00:00')print("Task Status:",task_status)ContributingContributions are welcome! If you have an idea for a new feature, find a bug, or want to improve the documentation, feel free to open an issue or submit a pull request. Please make sure to follow the contribution guidelines when contributing.LicenseThis project is licensed under the Apache 2.0 License - see the LICENSE file for details.
Package: chaiverse
$1M LLM Prize Hosted ByChaiverseis part of the Chai Prize Competition, accelerating community AGI.It's the world's first open community challenge with real-user evaluations. You models will be directly deployed on theChai Appwhere our over 500K daily active users will be providing live feedback. Get to top of the leaderboard and share the $1 million cash prize!🚀 Quick Start with ColabJoin theChaiverse Discord, our bot will greet you and give you a developer key 🥳Submit a model in < 10 minutes withChaiverse Jupyter Notebook QuickstartRun through ourChaiverse Prompt Engineering Guideto submit models with custom promptsRun through ourChaiverse: Reward Model Guideto submit reward models! ❤️Run through ourChaiverse: Blend Model Guideto submit blended models!Take a look at our #new-joiners #dataset-sharing and #ai-discussions channels for easter eggs📼 Local InstallationRunpip install chaiverseRead through examples shown in the "Quick Start with Colab" section🧠 How Does It Work?Thechaiversepip package provides a way to easily submit your language model, all you need to do is ensure it is on HuggingFace 🤗We will automaticallyTritonizeyour model for fast inference and host it in our internal GPU cluster 🚀Once deployed, Chai users on our platform who enter thearena modewill be rating your model directly, providing you with both quantatitive and verbal feedback 📈Both the public leaderboard anduser feedbackfor your model can be directly downloaded via thechaiversepackage 🧠Cash prizes will be allocated according to your position in the leaderboard 💰Resources🤗Chai HuggingfaceTons of models / datasets for you to finetune on! Including past winner solutions📒Fine tuning guideGuide on language model finetuning💾DatasetsCurated list of open-sourced datasets to get started with finetuning💖Chaiverse DiscordOur Chaiverse Competition discord🚀Deepspeed GuideGuide for training with Deepspeed (faster training without GPU bottleneck)💬Example ConversationsHere you can find 100 example conversations from the Chai Platform⚒️Build with usIf you think what we are building is cool, join us!❗Competition EULACovers terms of use and competition agreementsCHAI RESEARCH CORP. COMPETITION END USER LICENSE AGREEMENT (EULA)
Package: chaiverse-temp
$1M LLM Prize Hosted ByChaiverseis part of the Chai Prize Competition, accelerating community AGI.It's the world's first open community challenge with real-user evaluations. You models will be directly deployed on theChai Appwhere our over 500K daily active users will be providing live feedback. Get to top of the leaderboard and share the $1 million cash prize!🚀 Quick Start with ColabJoin theChaiverse Discord, our bot will greet you and give you a developer key 🥳Submit a model in < 10 minutes withChaiverse Jupyter Notebook QuickstartRun through ourChaiverse Prompt Engineering Guideto submit models with custom promptsRun through ourChaiverse: Reward Model Guideto submit reward models! ❤️Take a look at our #new-joiners #dataset-sharing and #ai-discussions channels for easter eggs📼 Local InstallationRunpip install chaiverseRead through examples shown in the "Quick Start with Colab" section🧠 How Does It Work?Thechaiversepip package provides a way to easily submit your language model, all you need to do is ensure it is on HuggingFace 🤗We will automaticallyTritonizeyour model for fast inference and host it in our internal GPU cluster 🚀Once deployed, Chai users on our platform who enter thearena modewill be rating your model directly, providing you with both quantatitive and verbal feedback 📈Both the public leaderboard anduser feedbackfor your model can be directly downloaded via thechaiversepackage 🧠Cash prizes will be allocated according to your position in the leaderboard 💰Resources🤗Chai HuggingfaceTons of models / datasets for you to finetune on! Including past winner solutions📒Fine tuning guideGuide on language model finetuning💾DatasetsCurated list of open-sourced datasets to get started with finetuning💖Chaiverse DiscordOur Chaiverse Competition discord🚀Deepspeed GuideGuide for training with Deepspeed (faster training without GPU bottleneck)💬Example ConversationsHere you can find 100 example conversations from the Chai Platform⚒️Build with usIf you think what we are building is cool, join us!❗Competition EULACovers terms of use and competition agreementsCHAI RESEARCH CORP. COMPETITION END USER LICENSE AGREEMENT (EULA)
Package: chakula
chakulais a Python library and command-line rss feed monitor with behavior
similar totail-f.chakulais based off ofrsstail.py, but can be used as
a library to call a custom function each time new entries appear in the feed.Usage$ chakula --help
positional arguments:
  urls                  The urls to tail (default: reads from stdin).

optional arguments:
  -h, --help            show this help message and exit
  -i INTERVAL, --interval INTERVAL
                        Number of seconds between polling (default: 300s).
  -N ITERATIONS, --iterations ITERATIONS
                        Number of times to poll before quiting (default: inf).
  -I INITIAL, --initial INITIAL
                        Number of entries to show (default: all)
  -n DATE, --newer DATE
                        Date by which entries should be newer than
  -s FIELD, --show FIELD
                        Entry field to display (default: title).
  -t FORMAT, --time-format FORMAT
                        The date/time format (default: 'YYYY/MM/DD HH:MM:SS').
  -F FORMAT, --format FORMAT
                        The output format (overrides other format options).
  -c CACHE, --cache CACHE
                        File path to store feed information across multiple runs.
  -r, --reverse         Show entries in reverse order.
  -f, --fail            Exit on error.
  -u, --unique          Skip duplicate entries.
  -H, --heading         Show field headings.
  -v, --version         Show version and exit.
  -V, --verbose         Increase output verbosity.

Format specifiers must have one the following forms:
  %(placeholder)[flags]s
  {placeholder:flags}

Examples:
  chakula <url>
  echo '<url>' | chakula --reverse
  chakula -s pubdate -s title -s author <url1> <url2> <url3>
  chakula --interval 60s --newer "2011/12/20 23:50:12" <url>
  chakula --format '%(timestamp)-30s %(title)s\n' <url>
  chakula --format '%(title)s was written on %(pubdate)s\n' <url>
  chakula --format '{timestamp:<30} {title} {author}\n' <url>
  chakula --format '{timestamp:<20} {pubdate:^30} {author:>30}\n' <url>
  chakula --time-format '%Y/%m/%d %H:%M:%S' <url>
  chakula --time-format 'Day of the year: %j Month: %b' <url>

Useful flags in this context are:
  %(placeholder)-10s - left align and pad
  %(placeholder)10s  - right align and pad
  {placeholder:<10}  - left align and pad
  {placeholder:>10}  - right align and pad
  {placeholder:^10}  - center align and pad

Available fields: author, comments, created, desc, description,
expired, id, link, pubdate, timestamp, title, updated, urlInstallingThe latest stable version of chakula can be installed frompypi:$pipinstallchakulaSimilar projectsrsstail.pyrsstailfeedstailtheyokewagLicensechakulais released under the terms of theRevised BSD License.
Package: chalan
ChalanChalan is a migration tool designed and developed for Elasticsearch and
inspired from AlembicInstallationpipinstallchalanInitializeSetup migration tool, configuration files and migration folders using below
commandchalaninitThis will create a directoryes_migrations/versionsthat will have all the
migrations file andchalan.inithat will contain all the configuration of the
migration tools---es_migrations/|--versions/
---chalan.iniCreate RevisionCreate revision file with migration changes in version directory with below
command.chalanrevision-m"<some message>"Above command will create a migration file underversions/folder with
upgrade and downgrade function. That will help in upgrade/downgrade of the
migration tool.UpgradeCommand used to upgrade the migration level to head(current level). Or you can
also specify specific version where you want upgrade the version to.chalanupgrade# orchalanupgrade<specificversion>DowngradeCommand used to downgrade the migration level to base(initial version). Or
specify the level you want to downgrade to.chalandowngrade# Downgrade 1 level down# orchalandowngrade--versionbase# Downgrade to base version
Package: chalicedoc
Chalicedoc makes documenting Chalice applications easier.This module adds a “chalice” domain for reStructuredText, which can be
used by Sphinx/docutils to autogenerate documentation of your chalice routes
using the docstrings in your Chalice app.Usage (Sphinx)Usage is simple. First, you must include thechalicedocmodule in your
extensions list inconf.py:extensions = [
    ...,
    'chalicedoc',
]Next, within your .rst source, use the “chalice:project” directive to scan your
app for docstrings:.. chalice:project:: path/to/chalice/projectThis will product output as follows:The title will be adapted from the chaliceapp_nameThe docstring of your module will be included as a summaryFor each route:The path will be added as a section titleThe method will be added as a section subtitleThe docstring of the corresponding function will be used as the section
content
Package: chalice-http-toolkit
chalice-http-toolkitchalice-http-toolkit enables a Flask like website building experience usingChalice, AWS Lambda, API Gateway & CloudFront. It does this by bolting on Jinja2 templates, and CloudFront cache management layer.For full setup guide see thedocumentation.Licensechalice-http-toolkit is licensed under theGNU AGPLv3license.
Package: chalice-jwt
Json Web Token based authentication for Python Chalice# Maintainers wantedChalice-JWTchalice-jwtprovides a simple interface for jwt based authentication with AWS Chalice microframework(serverless).
source code available at:https://github.com/marktennyson/chalice-jwtUsagefromchaliceimportChalicefromchalice_jwtimportJWTManagerfromdatetimeimporttimedeltaapp=Chalice(app_name='test-jwt')jwt=JWTManager(jwtSecret="top-secret-key",app=app)@app.route('/')defindex():return{'hello':'world'}@app.route('/get-token')deftoken():Identity:dict={"email":"aniketsarkar@yahoo.com"}return{'token':jwt.create_access_token(identity=Identity,expires_in=timedelta(seconds=60)),}@app.route('/get-identity')@jwt.its_requireddeflogin():returnjwt.get_jwt_identity()Installationchalice-jwtis available frompypi.install using pippipinstallchalice-jwtinstall from source codegitclonehttps://github.com/marktennyson/chalice-jwt&&cdchalice-jwt
pythonsetup.pyinstall--userCompatibilitychalice-jwtis compatiable with all python3 versions.
Not available for Python version 2.ContributingWe welcome contributions of all types!
Package: chalice-spec-pr07
chalice-specChalice × APISpec × Pydantic plug-insCombines the power of Chalice, APISpec, and Pydantic to make AWS Chalice apps easily documentedInstallationFirst, add chalice-spec:poetryaddchalice_specWe consider Chalice, APISpec, and Pydantic "peer dependencies." We only include them as dev
dependencies in our codebase, and you may need to install them in yours if you haven't
already.poetryaddchaliceapispecpydanticSetupFirst, instantiate your APISpec object withboththe Pydantic and Chalice plug-ins, assuming
you need the functionality of each. While the Pydantic plugin can be used alone, you currently must use
the Pydantic plugin with the Chalice plugin.app=Chalice(app_name="hello_world")spec=APISpec(chalice_app=app,...,plugins=[PydanticPlugin(),ChalicePlugin()])If you use:ChalicePlugin(generate_default_docs=True)the plugin will generate empty docs (with empty request and response schemas) for every endpoint that you've defined in your app. This can be useful as a starting point / overview while developing.UsageTo document your API, use your existing Pydantic models and add kwargs to Chalice decorators.Before:@app.route('/',methods=["POST"])defexample():body=MySchema.parse_obj(app.current_request.json_body)After:@app.route('/',methods=["POST"],docs=Docs(post=Operation(request=MySchema)))defexample():body=MySchema.parse_obj(app.current_request.json_body)If you have multiple methods supported, you may have something like:@app.route('/',methods=["POST","PUT"],docs=Docs(post=Operation(request=MyCreateSchema,response=MyReadSchema),put=Operation(request=MyEditSchema,response=MyReadSchema))defexample():# code goes herepassAPITODO: this section coming soon!