Saravanan666/pypi-org huggingface dataset:
Package: conveiro
# ConveiroConveiro (convolutional + oneiro, Greek for "dream") is an open source library for feature visualization in deep convolutional networks. It implements multiple techniques for visualization, such as laplace, multiscale,  deep dream and CDFS.All of these methods are based on:### Deep dreamDeep dream is implementation of technique based on* https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/tutorials/deepdream/deepdream.ipynb* https://ai.googleblog.com/2015/06/inceptionism-going-deeper-into-neural.htmlHow it works:* We create random image (or we can use seed image)* We feed this image to network and optimize it based on calculated gradients* We employ few clever tricks based on scaling and frequenciesThere are few more steps but this is the essence of this technique.### CDFSCDFS (color-decorrelated fourier space) is custom implementation of technique based on* https://distill.pub/2017/feature-visualization/* https://github.com/tensorflow/lucidHow it works:* We generate random complex coefficient* We use said coefficients to generate image by inverse fourier transformation* After we feed this image to network we can calculate gradients and use gradient descent to optimize these coefficientThere are few more steps but this is the essence of this technique.## Requirements* Python 3.4 and above* Tensorflow (CPU or GPU variant)* Numpy* Matplotlib* click, tensornets, pillow, graphviz (if you want to use the command-line tool with examples)## Installation```pip install conveiro```Development version```pip install -e .    # from cloned repository```## Command-line usageThis library comes with a command-line tool called `conveiro`that can visualize and hallucinate networks from `tensornets` library.```Usage: conveiro COMMAND [OPTIONS] [ARGS]...Commands:graph     Create a graph of the network architecture.layers    List available layers (operations) in a network.networks  List available network architectures (from tensornets).render    Hallucinate an image for a layer / neuron.```Run `conveiro --help` or `conveiro [command-name] --help` toshow the list of capabilities and options.## ExamplesFor examples how to use this library please take a look at jupyter notebooks in `docs/` folder:* https://github.com/Showmax/conveiro/tree/master/docs/deep_dream.ipynb* https://github.com/Showmax/conveiro/tree/master/docs/cdfs.ipynbSimplest example:```pythonimport tensorflow as tfimport tensornets as netsfrom conveiro import cdfsinput_t, decorrelated_image_t, coeffs_t = cdfs.setup(224)model = nets.Inception1(input_t)graph = tf.get_default_graph()with tf.Session() as sess:sess.run(model.pretrained())objective = graph.get_tensor_by_name("inception1/block3b/concat:0")image = cdfs.render_image(sess, decorrelated_image_t, coeffs_t, objective[..., 55], 0.01)cdfs.show_image(cdfs.process_image(image))```![CDFS output](docs/example.png)**Note** The API is preliminary and may change in future versions.
Package: convenience
ConvenienceTools for everyday use.Source and install files are available under BSD License here:https://gitlab.com/sylvainraybaud/convenienceThis packageHAS NOTbeen tested with Python 2.APIxopen: a wrapper aroundopenandgzip.openreturning anXFileobject, which is a wrapper aroundFileandgzip.GzipFile.XFileimplements methodsopen,close,read,readline,readlines,writewith the same parameters asFilemethods. It also implements__iter__and__next__to make it iterable and__enter__and__exit__to make it usable inwithstatements. Files whose names end with.gzare treated as gzip files, all other files are treated as uncompressed files.Logger: a wrapper aroundloggingmodule. ALoggerobject is intialized with averbosityparameter which is translated into aloggingvalue (WARNING,INFOorDEBUG). It implementsdebug,info,warninganderrormethods. They all take a string as first argument argument.errortakes an extra argument,code. When called,errorprint its first parameter then callsexit(code).header, blue, green, yellow, orange, red, bold, underline: apply decoration to string (seeexample.py)UsingA good example being worth a thousand words, please seeexample.pyInstallingpipinstallconvenienceTODOUse magic number instead of file extension to detected gzipped files, when applicable.Handle more compression format.Double check handling of various text encodings.Python 2 compatibility.Add more magic.ContributingPlease make a pull request on gitlab. You can mail me atfirst_name [dot] family_name [at] crans [dot] org
Package: convenient-datascience-tools
Useful tools for handling data, using many known data science packages.Basic UsageInstall the packagepip install convenient-datascience-toolsImport the packagefrom convenient_datascience_tools.tools import <TOOL> as <ABBREVIATED_TOOL>_toolsFor example:from convenient_datascience_tools.tools import pandas as pd_toolsWhere 'pandas' is the TOOL nd 'pd' the abbreviated tool.For more usage cases, please go toexamplesfolder.We have not yet implemented test cases, though it is going to be implemented in a near future.DeployTo deploy a new version, you need:Versioning is not automated, so you will always need to change it in setup.py.
It will be a future improvement to make it automatic.In order to install build (dev) dependenciespip install --upgrade build twineIn order to build. This will create a/distfolder.python -m buildIn order to upload to PyPa (to be able to fetch via pip)python -m twine upload dist/*
Package: conventional-commit
gitcommita tool for writing conventional commits, convenientlyInstallTo installpip install conventional-commitTo use, run the following command from within a git repositorygitcommitOverviewThe purpose of this utility is to expedite the process of committing with a conventional message format in a user friendly way. This tool is not templated, because it sticks rigidly to theConventional Commit standard, and thus not designed to be 'altered' on a case by case basis.Commit messages produced follow the general template:<type>[(optional scope)]: <description>

[BREAKING CHANGE: ][optional body / required if breaking change]

[optional footer]Additional rules implemeted:Subject line (i.e. top) should be no more than 50 characters.Every other line should be no more than 72 characters.Wrapping is allowed in the body and footer, NOT in the subject.DevelopmentThe old distribution method is documented indocs/dev_distibution_legacy.mdNote: if modifying.travis.ymlyou should verify it by runningtravis lint .travis.ymlGetting startedMake sure you havepre-commitinstalled.Make sure you havepyenvinstalled.Make sure you havePoetryinstalled.git clonepre-commit installIt is highly recommend you enable setting for storing the venvs within your projects.poetry config virtualenvs.in-project trueInstall project dependencies.poetry installRunning the package locallyActivate the virtual environment.source .venv/bin/activateRun the package as a module.python -m gitcommitAlternatively,Run the package using Poetry's venv as contextpoetry run python -m gitcommitOr, if in another directory,~/GitHub/gitcommit/.venv/bin/python -m gitcommitDeployDeployment is handled automatically by Travis CI. It has been linked to the
repository and is automatically watching for pushes to master. It will build
and test every commit to master. It will also build every tagged commit as
if it was a branch, and since its a tagged commit, will attempt to publish
it to PyPI.Don't forget to increment version number set inpyproject.toml. This can be
done with poetry.poetry version [patch|minor|major]Update the version number as stored in thegitcommit/__version__.pyfile to match that designated by Poetry.Tag the commit (by default applies to HEAD commit - make sure you are on the latestdevelopcommit).git tag v#.#.#When pushing commits to remote, you must explicitly push tags too.git push origin --tagsAcknowledgementsThis work takes inspiration fromanother repository porting Commitizen to Python. This repository however uses none of the same source code and is focusing on a different approach.LicenseThis work is published underGNU GPLv3.
Package: conventional-commits-check
Conventional Commits Checkconventional-commits-checkis a Python pre-commit hook that enforces Conventional Commits rules on your commit messages and automatically adds relevant emojis based on the commit type.Conventional Commits is a lightweight convention that provides a set of rules for creating an explicit commit history. This pre-commit hook helps ensure your commit messages adhere to the convention and provides additional context with emojis.Automatic Emoji InsertionAutomatic emoji insertion at the beginning of the Commit 🎉{"feat":"✨","fix":"🐛","docs":"📚","style":"💎","refactor":"🧹","perf":"🚀","test":"🧪","build":"🏗️","ci":"👷","chore":"♻️","revert":"⏪",}Customizationtouchconventional_commits_check_config.yamlNOTE: Please do not leave it blank if you create it.To add custom commit types and emojis, update yourconventional_commits_check_config.yamlfile with the additional_commands and additional_emojis fields. Here's an example:additional_commands:database:"^database(\\(.+\\))?:"design:"^design(\\(.+\\))?:"additional_emojis:database:"🗃️"design:"🎨"Customization Current EmojiThis is how you can change the emojis of existing commands.additional_commands:fix:"^fix(\\(.+\\))?:"feat:"^feat(\\(.+\\))?:"additional_emojis:fix:"🗃️"feat:"🎨"FeaturesChecks if commit messages follow the Conventional Commits rules.Adds an emoji to the commit message based on the commit type.Blocks commits with non-conforming messages.InstallationFollow these steps to add theconventional-commits-checkpre-commit hook to your project:In your project's root directory, open the existing.pre-commit-config.yamlfile (or create one if it doesn't exist) and add the following content:repos:-repo:https://github.com/AliYmn/conventional-commits-checkrev:v0.3.0# Use the latest release versionhooks:-id:conventional-commits-checkstages:[commit-msg]Update the pre-commit hooks in your project:pre-commitinstall--hook-typecommit-msg-fInstall the conventional-commits-check package:pipinstall-Uconventional-commits-checkYou may need to update the pre-commit package;pre-commitautoupdateUsageOnce the hook is added to your project, it will automatically run every time you create a commit. The hook will check the commit messages according to the Conventional Commits rules and add the corresponding emojis. If a commit message does not follow the rules, the commit will be blocked.
Package: conventionalish
ConventionalishPatch Commitizen's Conventional Commits implementation with additional prefixes.By default, Commitizen will use its Conventional Commits implementation, so when you runcz commit, you will get a choice offix:feat:docs:style:refactor:perf:test:build:ci:Commitizen has a robust system for building your own commit patterns, and it's great if you want to start from scratch. But if you want to make a small change to the defaults and keep the nice prompts, commit-message linting, and changelog-building provided by Commitizen, you will have to create or update six patterns or regexps. This script inherits from ConventionalCommitsCz and patches in new choices and associated properties. FWIW, despite theishin the name conventionalish, these changes will still meet the Conventional Commits standard (at least as much as Commitizen does) as long as thefeat:andfix:prefixes remain.Should you want to accomplish this by hand:inherit from ConventionalCommitsCzoverload.questions()# for commit promptsoverload.schema_pattern()# for commit-message lintingWill your addition affect versioning?overload.bump_pattern# for commitizen bumpoverload.bump_map# for commitizen bumpoverload.commit_parser# for commitizen changelogoverload.change_type_map# for commitizen changelogoverload.changelog_pattern# for commitizen changelogUsageTo make these changes using a script:clone this project into your project rootedit theQUESTIONSvalue at the top ofquestions.py. The default value will give near-identical behavior to the Commitizen default.install conventionalish in your project venv (poetry add .\conventionalish;pip install .\conventionalish; ...) or upload to PyPi with a new name.run withcz -n cz_conventionalishor add the following topyproject.toml[tool.commitizen]
name = "cz_conventionalish"Troubleshooting, Q&AI updated the file, but Commitizen doesn't recognize the changes.This is an installed package, depending how you installed it, you may need to:delete anycommitizenish/buildorcommitizenish/egg-infodirectoriesuninstallreinstallHow can I change the project name (conventionalish)?change the name of this folder after you clone itupdate the linename="conventionalish"inconventionalish/pyproject.tomltoname="new_folder_name"How can I change the commit-rule name (cz_conventionalish)?change the filenameconventionalish/cz_conventionalish.pytoconventionalish/cz_new_name.pychange the line{ include = "cz_conventionalish.py" }inconventionalish/pyproject.tomlto{ include = "cz_new_name.py" }AuthorShay Hill (shay_public@hotmail.com)
Package: conventional_semver
Bump your Semantic Version using Conventional CommitsA Python CLI tool for calculating how to bump a Semantic Version based on a commit message.Installation and Usage$>pipinstallconventional_semverConfigurationCreate a.tomlfile and modify the settings you want to be different from the PCCC defaults.
An exampleconfig.tomlfile is present in this repository.UsageThe most basic usage of this tool is to create a config file as described above
and pass a conventional commit message as input to the script.$>conventional_semver"fix: ensure /api/list-all returns properly"$>0.0.1It is also possible to provide a SemVer as an argument and have the
script calculate the next version:$>conventional_semver--semver1.0.8"feat: add new cool feature"$>1.1.0The tool also supports the SemVer options for pre-releases and build metadata,
using--pre-releaseand--build-meta, which will append the provided
strings in a SemVer compatible manner.$>conventional_semver--semver1.0.8--pre-releasealpha.1--build-meta$(date-u+"%Y-%m-%dT%H:%M:%SZ")"feat: add new cool feature"$>1.1.0-alpha.1+2024-01-11T07:21:57ZNote that the lib used for SemVer parsing is a bit more relaxed than the
official documentation, w.r.t. pre-release and build metadata.
Make sure the strings provided follow the SemVer specification!Pipeline exampleThis tool is particularly useful if you work trunk based, as you can use it in
combination with the information already present in your git repository to
automatically tag your new commit.
I have createda sample
projectwhere I
show how to use the tool in a GitHub Workflow, both for validating PRs and for
tagging new commits onmain.DependenciesThe tool relies onThe Python Conventional Commit Parserfor the
validation of the commit message and onPython SemanticVersionfor
managing the Semantic Version. The former of these usethe Enchant C Library used by PyEnchant.
Package: convergence-api
Python Converge APIA simple, easy to use wrapper for Elavon's Converge API via key value pairs instead of XML.CompatibilityThis package will work with python 2 and 3Installationpip install convergence-apiOr to get masterwget https://github.com/wontonst/python-converge-api/archive/master.zip
unzip python-converge-api-master.zip
pip install python-converge-api-masterExample usageConstruct a new instance with your merchant ID, user ID, PIN and if you're using demo credentials or not.c = Converge('your merchant id', 'your user id', 'your pin', is_demo=True)You can then call any of the Converge transaction type with->request()and provide the transaction type as well as an array of key value pairs to send to the API. The package will use the demo or live endpoint automatically based on how you constructed the object.ccsaleresponse = c.request(
    'ccsale',
    ssl_card_number='***********7813',
    ssl_exp_date='0124',
    ssl_cvv2cvc2='1234',
    ssl_amount='10.00',
    ssl_avs_address='123 easy st',
    ssl_avs_zip='94041',
    ssl_3dsecure_value='false'
)
print(response)
{'errorCode': '5000', 'errorMessage': 'The Credit Card Number supplied in the authorization request appears to be invalid.', 'success': False, 'errorName': 'Credit Card Number Invalid'}All Transaction Types* ccauthonly
* ccavsonly
* ccsale
* ccverify
* ccgettoken
* cccredit
* ccforce
* ccbalinquiry
* ccgettoken
* ccreturn
* ccvoid
* cccomplete
* ccdelete
* ccupdatetip
* ccsignature
* ccaddrecurring
* ccaddinstall
* ccupdatetoken
* ccdeletetoken
* ccquerytoken
Package: convergence-entropy-metric
Entropy-conVergence MetricThe following is a full implementation of the convergence-entropy measurement framework (here referred to as Entropy-conVergence Metric, or EVM) as described in Rosen and Dale 2023. We've taken strides to make this package as easy to implement as possible.At its core there are two things that researchers need to define for the most basic version of the EVM algorithm. Those are:A word vector model (we suggest those implemented in the HuggingFace transformer library)An entropy objectDemonstrating how this would look in code:fromEVMimportEVM,languageModelLayersfromtransformersimportAutoTokenizer,AutoModelwv=languageModelLayers('roberta-base',layers=[7])mod=EVM(word_vector_model=wv)mod('No political action can be taken without first consulting the populace','it is the prerogative of the political class to make decisions'),\mod('No political action can be taken without first consulting the populace','Ultimately the populace has to have the right to decide their own fate')The above returns the entropy for the first sentence upon having read the second sentence, consistent with the equations and formulation listed in Rosen and Dale 2023.Any use of this package should cite it using the following:@article{rosen_berts_2023,
	title = {{BERTs} of a feather: {Studying} inter- and intra-group communication via information theory and language models},
	shorttitle = {{BERTs} of a feather},
	url = {https://link.springer.com/10.3758/s13428-023-02267-2},
	doi = {10.3758/s13428-023-02267-2},
	journal = {Behavior Research Methods},
	author = {Rosen, Zachary P and Dale, Rick},
	year = {2023},
}
Package: conversation-analytics-toolkit
Watson Assistant Dialog Flow AnalysisNote: help us stay in touch and improve this notebook by clicking on the :star: star icon (top right).This repository hosts the the Watson Assistant Dialog Flow Analysis Notebook and the underlying conversation analytics toolkit library.Table of ContentsIntroductionGetting StartedGuidesFrequently Asked QuestionsLicenseContributingIntroductionThe Watson Assistant Dialog Flow Analysis Notebook can help you assess and analyze user journeys and issues related to the dialog flow of ineffective (low quality) conversations based on production logs.  The notebook can help you with questions such as:What are the common conversation steps and flows within the assistantWhich flows have low task completion rates and high abandonment (ineffective conversations)Where along the dialog steps users lose engagement with your assistantWhat are common terms and steps that may lead to abandonmentThis notebook extends theMeasure and Analyze notebooksby providing additional capabilities to assess and analyze effectiveness - focused more on issues related to the dialog flow.  For more details, check outIBM Watson Assistant Continuous Improvement Best Practices.Getting StartedThe notebook requires a Jupyter Notebook environment and Python 3.6+.   You can either install Jupyter Notebook to run locally or you can use Watson Studio on the cloud.Using Jupyter NotebookInstall Python 3.6+Install Jupyter notebook. Checkout theJupyter/IPython Notebook Quick Start Guidefor more detailsDownload thenotebooks/Dialog Flow Analysis Notebook.ipynbfile.Start jupyter serverjupyter notebookRun theDialog Flow Analysis Notebook.ipynbUsing Watson StudioIn Watson Studio, selectAdd to Project-->Notebook.  ChooseFrom URLand paste thisurl.  Alternately you can selectFrom fileand upload thenotebooks/Dialog Flow Analysis Notebook.ipynbfile.Alternately, you can import and modify thesample notebook on Watson Studio Gallery.GuidesLearn more about the Dialog Flow Analysis in thisblogSee a live example output of the notebook onWatson Studio GalleryFrequently Asked QuestionsSeeFAQ.mdfor frequently asked questionsLicenseThis library is licensed under theApache 2.0 license.ContributingSeeCONTRIBUTING.mdandDEVELOPER.MDfor more details on how to contributeContributor ListAvi YaeliSergey ZeltynZhe ZhangEric WayneDavid Boaz
Package: conversation-qa
Conversational QAThis framework is trained on theCoQA dataset.Installpip install conversation-qaExamplefromconversation_qaimportQA,Dialogueqa=QA("fractalego/conversation-qa")dialogue=Dialogue()dialogue.add_dialogue_pair("Where was the cat?","The fence.")text="A white cat is on the fence."query="What color is it?"qa.get_answer(text,dialogue.get_text(),query)
Package: converse
ConverseSentiment analysis and charting library supporting Messenger data dumpsConverse is a flexible charting library in python that makes sentiment analysis and charting easier. The aim is to provide strong functionality out of the box with minimal code while being configurable enough to support larger projects.Getting StartedpipinstallconverseThat's all, really. For a full walkthrough of the basic features, look here -Converse: An easy sentiment analysis library for Messenger- or indocker/messages/Demo.ipynb. For a ready-to-go installation with a (really small, faked) conversation, run:dockerpullhrishioa/converseQuickstartConverse currently supports only facebook messenger (Whatsapp dump support is planned).The first step is to download your chat data (useoneofthese guides to do so - make sure to pick JSON over HTML as the format), and unzip the archive. Converse is completely offline (even for plotting), and all your information is local.Create new jupyter notebook (ideally in the messages directory) withjupyternotebookThe following piece of code should have you up and plotting:fromconverseimportConversationfromtqdmimporttqdm_notebookastqdmfromplotly.offlineimportinit_notebook_mode,iplotinit_notebook_mode(connected=True)convo=Conversation()convo.load("path-to-message.json")# structure is usually archive-root/convo-name/message.jsoniplot(convo.plot())Built WithTextblob- Sentiment AnalysisPandas- data managementPlotly- graphingFuzzyWuzzy- string searchingLicenseThis project is licensed under GPLv3.This project was cobbled together from tools built by the author in a weekend to do some standard sentiment analysis. Still very much in alpha, maybe even pre-alpha. Do submit any issues or problems, I'll do my best to patch!