Saravanan666/pypi-org huggingface dataset:
Package: condo
condo-adapterConDo Adapter performs Confounded Domain Adaptation, which corrects for
batch effects while conditioning on confounding variables.
We hope it sparks joy as you clean up your data!Using and citing this toolboxIf you use this toolbox in your research and find it useful, please cite ConDo
using the following reference to ourarXiv preprint:In Bibtex format:@misc{https://doi.org/10.48550/arxiv.2203.12720,doi={10.48550/ARXIV.2203.12720},url={https://arxiv.org/abs/2203.12720},author={McCarter, Calvin},title={Towards Backwards-Compatible Data with Confounded Domain Adaptation},publisher={arXiv},year={2022},}InstallationInstallation from pipYou can install the toolbox through PyPI with:pip install condoNote: If you have issues with importingtorchmin, you may need to install from source, as shown below. Or you can try re-installingpytorch-minimizefrom source.Installation from sourceAfter cloning this repo, install the dependencies on the command-line via:pip install -r requirements.txtIn this directory, runpip install -e .UsageImport ConDo and create the adapter:importcondocondoer=condo.ConDoAdapter()Try using it:importnumpyasnpX_T=np.sort(np.random.uniform(0,8,size=(100,1)))X_S=np.sort(np.random.uniform(4,8,size=(100,1)))Y_T=np.random.normal(4*X_T+1,1*X_T+1)Y_Strue=np.random.normal(4*X_S+1,1*X_S+1)Y_S=5*Y_Strue+2condoer.fit(Y_S,Y_T,X_S,X_T)Y_S2T=condoer.transform(Y_S)print(f"before ConDo:{np.mean((Y_S-Y_Strue)**2):.3f}")print(f"after ConDo:{np.mean((Y_S2T-Y_Strue)**2):.3f}")More thorough examples are provided in the examples directory.DevelopmentTestingIn this directory runpytestCode formattingThe Uncompromising Code Formatter:Blackblack {source_file_or_directory}Install it into pre-commit hook to always commit well-formatted code:pre-commit installLicense InformationThis work is licensed under aCreative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
Package: condolence-models
Condolence ModelsIntrocondolence-modelsis a package used to detect condolence and distress
expressions, as well as empathetic comments. It is released with the
EMNLP 2020 paperCondolence and Empathy in Online Commmunities.InstallUse pipIfpipis installed, question-intimacy could be installed directly from it:pip3 install condolence-modelsDependenciespython>=3.6.0
torch>=1.6.0
pytorch-transformers
markdown
beautifulsoup4
numpy
tqdm
simpletransformers
pandas
numpyUsage and ExampleSeeexample.pyfor an example of how to use the classifiers.Note: The first time you run the code, the model parameters will need to be
downloaded, which could take up significant space. The condolence and
distress classifiers are about 500MB each, and the empathy classifier is
about 1GB.The interface for condolence and distress are the same. The interface for
empathy is slightly different, to align with the simpletransformers interface
more closely.Classifying condolence or distress.fromcondolence_models.condolence_classifierimportCondolenceClassifiercc=CondolenceClassifier()# single string gets turned into a length-1 list# outputs probabilitiesprint("I like ice cream")print(cc.predict("I like ice cream"))# [0.11919236]# multiple stringsprint(["I'm so sorry for your loss.","F","Tuesday is a good day of the week."])print(cc.predict(["I'm so sorry for your loss.","F","Tuesday is a good day of the week."]))# [0.9999901  0.8716224  0.20647633]Classifying empathy.fromcondolence_models.empathy_classifierimportEmpathyClassifierec=EmpathyClassifier(use_cuda=True,cuda_device=2)# list of lists# first item is target, second is observer# regression output on scale of 1 to 5print([["","Yes, but wouldn't that block the screen?"]])print(ec.predict([["","Yes, but wouldn't that block the screen?"]]))# [1.098]ContactNaitian Zhou (naitian@umich.edu)
Package: condom
Bravo!  You have received a Medical Diploma in "condom" fromthe Orbital Convergence University International Air and WaterEmbassy of the Tangerine Planet 🍊.You are now officially certified in "condom".🌑 🌘 🌗 🌖 🌕 🌔 🌓 🌒 🌑🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘 🌑🌑 🌘 🌗 🌖 🌕 🌔 🌓 🌒 🌑condomdescriptionThis is a module that can ascertainthe health status of python3 software.It's like a testing framework.installThis utilizes:https://pypi.org/project/xonsh[xonsh] pip install condomdocumentation[xonsh] condom sharesThis opens a server process that can be opened in a browser.internal status tests of the module[xonsh] condom internal-statusThese checks are run with pypi "body_scan";
"condom" is built from a fork of "body_scan".The "body_scan" checks are written with "unittest".TutorialThe structure📁 performance
	📜 status_1.pyThe checks# status_1.py

def check_1 ():
	print ("check 1")
	
def check_2 ():
	print ("check 2")
	
def check_3 ():
	raise Exception ("not 110%")

checks = {
	"check 1": check_1,
	"check 2": check_2,
	"check 3": check_3
}The procedureFrom theperformancedirectory,[xonsh] condom statusThe reportThis is the report that is (hopefully) written to the terminal.paths: [
	{
		"path": "status_1.py",
		"empty": false,
		"parsed": true,
		"stats": {
			"passes": 2,
			"alarms": 1
		},
		"checks": [
			{
				"check": "check 1",
				"passed": true,
				"elapsed": [
					4.054199962411076e-05,
					"seconds"
				]
			},
			{
				"check": "check 2",
				"passed": true,
				"elapsed": [
					1.72930003827787e-05,
					"seconds"
				]
			},
			{
				"check": "check 3",
				"passed": false,
				"exception": "Exception('not 110%')",
				"exception trace": [
					"Traceback (most recent call last):",
					"  File \"/condom/processes/scan/process/keg/check.py\", line 68, in start",
					"    checks [ check ] ()",
					"  File \"<string>\", line 13, in check_3",
					"Exception: not 110%"
				]
			}
		]
	}
]
alarms: [
	{
		"path": "status_1.py",
		"checks": [
			{
				"check": "check 3",
				"passed": false,
				"exception": "Exception('not 110%')",
				"exception trace": [
					"Traceback (most recent call last):",
					"  File \"/condom/processes/scan/process/keg/check.py\", line 68, in start",
					"    checks [ check ] ()",
					"  File \"<string>\", line 13, in check_3",
					"Exception: not 110%"
				]
			}
		]
	}
]
stats: {
	"alarms": 0,
	"empty": 0,
	"checks": {
		"passes": 2,
		"alarms": 1
	}
}NotesChecks are started simultaneously, unless--simultaneous no[xonsh] condom status --simultaneous noThe fractory glob pattern is "**/status_*.py", but can be changed with--glob-string[xonsh] condom status --glob-string "**/performance_*.py"Advanced TutorialIt's recommended to run condom programmatilly.An example of this can be found in the "_book/advanced tutorial"section of the documentation.📡 Contactsbgrace2345@proton.me
Package: condoor
[![Build Status](https://travis-ci.org/kstaniek/condoor.svg?branch=master)](https://travis-ci.org/kstaniek/condoor)CondoorImportant LinksDocumentation: [https://kstaniek.github.io/condoor/index.html](https://kstaniek.github.io/condoor/index.html)LicenseApache 2.0
Package: condor-assistant
Welcome to condor assistant!The condor_booklist can help you submit the condor jobs efficiently!To install the package, do:$ pip install --upgrade condor-assistantTo test the functionality do:$ example.pyclass condor_booklist(Executable = '', JobType = 'default_condor', JobName = '')

Parameters:
  Executable(string): executable
  JobType(string): name of the task (optional)
  JobName(string): name of the job (optional)anddef submit(with_arguments=True)

submit the condor jobs that are booked in the booklist.

Parameters:
  with_arguments: True if argument is required for each job. False if no argument needs to be specified.def add_Argument(Argument)

add one or more argument(s) (representing one or several job(s)) to the booklist

Parameters:
  Argument(string or a list of strings): the arguments to be specified after the executabledef set_Arguments(Arguments)

set the whole arguments (for all of the jobs that are going to be submitted)

Parameters:
  Arguments(list of strings): the argument listdef add_BlankArgument()

if there is no argument to be specified in a certain job. usually used when there is only one job per listdef initialdir_in_arguments()

add the initial directory path as the first argument (before all of the specified arguments)def set_JobFlavour(JobFlavour)

setup the allowed running time.

Parameters:
  JobFavour = 'espresso'     => 20min
            = 'microcentury' => 1hr
            = 'longlunch'    => 2hr
            = 'workday'      => 8hr
            = 'tomorrow'     => 1d
            = 'testmatch'    => 3d
            = 'nextweek'     => 1wdef summary(keyword='')

print out the summary of the current condor booklist

Parameters:
  Keyword = ''(default) => all
          = 'basic'     => basicMore options can be found in the source codes.
Package: condorcet
CondorcetCondorcet is a Python library for evaluating votes usingthe condorcet method.Installationpip install condorcetSynopsisThe library exposes a classCondorcetEvaluatorwhich is called with a list of candidates and a list of votes in order to instantiate an evaluator.# Attention! This is pseudo-code!!CondorcetEvaluator:List[Candidates],List[Votes]->CondorcetEvaluatorThis instantiated evaluator has a methodget_n_winnerswhich takes a (non-negative) integer, n, and returns a list containingat mostthe first n winners in order, along with a table of pairwise wins and losses forthe remainderof the candidates (the ones who are not in the list of winners).At most, because some times there may not be that many winners — a cycle might exist among a set of candidates. This is one of the motivations for returning a table of pairwise wins and losses along with the list of winners.# Attention! This is pseudo-code!!CondorcetEvaluator.get_n_winners:int->List[Candidates],WinsAndLossesTableAnd that is that for that!Quick Start: Rochambeau GamesThis years' edition of the Rochambeau Games had seven people ranking four candidates &mdash Rock, Paper, Scissors, and the relatively unknown Dynamite &mdash from 1 to 4, where candidate 1 on someone's ballot would be their most prefered candidate, and 4, the less preferred.As the election officer you are to evaluate their votes according to the Condorcet method and announce the result.You have the following data:candidates=["Rock","Paper","Scissors","Dynamite"]votes=[{"Rock":1,"Scissors":2,"Dynamite":3,"Paper":4},{"Rock":1,"Dynamite":2,"Scissors":3,"Paper":4},{"Dynamite":1,"Paper":2,"Rock":3,"Scissors":4},{"Paper":1,"Dynamite":2,"Rock":3,"Scissors":4},{"Scissors":1,"Paper":2,"Dynamite":3,"Rock":4},{"Scissors":1,"Dynamite":2,"Paper":3,"Rock":4},{"Rock":1,"Paper":2,"Dynamite":3,"Scissors":4},]You want to announce how the four candidates fared with respect to each other. So, you instantiate a condorcet evaluator using the list of candidates and list of votes, and ask it to produce four winners as shown below:importcondorcetevaluator=condorcet.CondorcetEvaluator(candidates=candidates,votes=votes)winners,rest_of_table=evaluator.get_n_winners(4)Print out the list of winners.print(winners)# ['Dynamite']Four winners were asked for, but only one was returned. Studying the table of wins and losses for the rest of the candidates will throw light on the underlying issue.print(rest_of_table)# {#  'Paper': {#      'losses': ['Scissors'],#      'wins': ['Rock']#   },#  'Rock': {#      'losses': ['Paper'],#      'wins': ['Scissors']#  },#  'Scissors': {#      'losses': ['Rock'],#      'wins': ['Paper']#  }# }The wins and losses table for the rest of the candidates shows that no winner could be picked among them, as each one has lost to at least one of the other.ContributingCondorcet is happy to receive contributions. Please submit a PR/MR containing your contribution (including tests if it's a code contribution) and bug the maintainer to review and merge.Don't forget to add yourself to CONTRIBUTORS.txt
Package: condor-git-config
Hook to dynamically configure an HTCondor node from agitrepository.Hook OverviewThe hook is integrated into a Condor config file to perform the following workflow:Fetch agit repositoryto alocal cacheUse patterns toselect configuration filesDynamicallyinclude configurationin condorTo integrate the hook, use theinclude commandsyntax in any HTCondor config file:include command : condor-git-config https://git.mydomain.com/condor-repos/condor-configs.gitNoteAny arguments ininclude commandare passed directly to the program, without invoking a shell.
This means that escapes and quotes required for passing arguments on the shell mustnotbe used in the configuration.Usage NotesThe hook requires at least Python 3.6 to run. A list of options is available by passing-hor--helpto the executable.InstallationInstallation provides thecondor-git-configexecutable.
All other dependencies are installed automatically.Stable release versionpip3installcondor_git_configCurrent development versionpip3installgit+https://github.com/MatterMiners/condor-git-config.gitWe recommend to install the hook to avirtual environment.
However, the hook is simple enough to not disturb global environments.Configuration SelectionBy default,condor-git-configwill not recurse into sub-directories.
Only top-level files that end in.cfgare included automatically.Which files to use can be controlled by arguments that provide regular expression
patterns to include/exclude files and whether to recurse into directories.In addition, an HTCondor macro is created that points to the root path of the cache.
This allows top-level files to easilyinclude:files from sub-directories.Conditional InclusionUse--blacklistto exclude files by relative name and--whitelistto add exceptions to blacklisted names.This allows you to have additional configuration, which is conditionally integrated.
For example, consider the following git repository tree:|- commong.cfg
|- security.cfg
|- aaaron-cloud.cfg
|- aaaron-cloud/
|  |- overwrites.cfg
|  |- proxy.cfg
|- beebee-cloud.cfgTheaaaron-cloudfolder will be ignored by default.
You can conditionally include the*-cloud.cfgfiles like this:--blacklist'.*-cloud\.cfg'--whitelist'aaaron-cloud\.cfg'This allows you to further include the files inaaaron-cloudby usingincludeinaaaron-cloud.cfg:# aaaron-cloud.cfg
include : $(GIT_CONFIG_CACHE_PATH)/aaaron-cloud/overwrites.cfg
include : $(GIT_CONFIG_CACHE_PATH)/aaaron-cloud/proxy.cfgThis pattern is especially useful when the whitelist is set dynamically,
e.g. by using an argument file that contains the domain name.Argument FilesThecondor-git-configexecutable can use the@prefix characterto read arguments from files.
This allows you to prepare options externally$cat/etc/condor-git-config/branch--branchaaaron-cloudand have them used dynamically to adjust configurationinclude command : condor-git-config @/etc/condor-git-config/branch -- https://git.mydomain.com/condor-repos/condor-configs.git
Package: condor-ir
This is a program to work with examples of Latent Semantic Analysis search
engines, a.k.a.,LSA.
The program is set up so that it understands froac xml documents on input
as well as plain text records from isi web of knowledge.You can find more information about froac repositories athttp://froac.manizales.unal.edu.co/froac/http://froac.manizales.unal.edu.co/froac/and about isi web of knowledge text files atthe thomson reuters websiteInstalling the condor-ir packageThe second thing you will need is to download the program from its pypi
repository,pipinstall-Ucondor-irthe-Uparameter will upgrade the package to the latest version, a very
recommendable step for a unstable package.For specific databases support you can install their appropriate extra package:pipinstall-Ucondor-ir[mysql]pipinstall-Ucondor-ir[postgres]Furthermore, we require a bit of thenltkdata package for the stems and
stop word removal to work.python-mnltk.downloadersnowball_datastopwordsFinally, in order to prepare the database or reset the database in preparation
for a new version ofcondor-iryou can run the database preparation script,condorutilspreparedbIf you need to specify a database other than the default you can do so through
environment variables:exportCONDOR_DB_URL="mysql://localhost/condor"condorutilspreparedb# will now work on mysql://localhost/condorCLI InterfaceAfter installing the program you will have three basic commands at your
disposal, for handling bibliography sets, term document matrices and engines,
the CLI interface gives you most CRUD operations in a hierachical manner.condortriggers the main program and you can get top level help by runningcondor--help.condor bibliographynamespaces the bibliography set related commands, you can
list and get help about those usingcondor bibliography--help.condor modelis a short cut that offers thecondor model createsub command, that creates both a term document matrix and anlsasearch
engine, get help onmodelsusingcondor model--help.condor query<string...>this non crud command search a bibliography set
using a previously created search engine, the search engine can be targeted
figure out how usingcondor query--help.Feel free to check detailed descriptions of these commands using their--helpflag.
Package: condor-kmeans
A Condor-powered K-means implementation---------------------------------------<p align="center"><img src="https://github.com/tansey/condor-kmeans/blob/master/test/results.png?raw=true" alt="Example K-means Solution"/></p>This package lets you run K-means on a really big dataset of vectors. You can even stream the vectors instead of loading them into memory, so long as you can store two lists of doubles the size of your vector count (one list for cluster assignment IDs and one for distance from each vector to its cluster).## InstallationInstallation is available via `pip`:```pip install condor-kmeans```## UsageThe package assumes you have a CSV file of vectors which you wish to cluster, with one vector per row. Once installed, you can simply run the `kmeans` command:```kmeans path/to/mydata.csv path/to/save/centroids.csv path/to/save/assignments.csv --num_clusters 30 --plusplus --stream --condor --condor_workers 100 --condor_username myusername```The above command will run k-means on the vectors stored in `mydata.csv` on condor with no more than 100 jobs at a time. It will save the resulting cluster centroids to `centroids.csv`, and the resulting vector-to-cluster assignments to `assignments.csv`. The `--plusplus` command specifies it should use k++ initialization. `--stream` says to stream `mydata.csv` from disk instead of loading it all into memory.The current directory is used as the working directory. A working subdirectory named `condor` will be created. All temporary worker files are deleted after each batch of jobs is finished successfully, though the directory structure is maintained (feel free to just `rm -rf condor` afterward if you wish). If one of the workers fails, the master will throw an exception and alert you to the job that failed and where to find its output files; the temporary files will not be deleted if a worker fails.
Package: condorpy
condorpy:Python interface for high throughput computing with HTCondorVersion:0.6.0Author:Scott ChristensenTeam:Tethys PlatformHomepage:http://tethysplatform.org/condorpy/License:BSD 2-ClauseDescription:Condorpy is a wrapper for the command line interface (cli) of HTCondor and enables creating submitting and monitoring HTCondor jobs from Python. HTCondor must be installed to use condorpy.Installing:$ pip install condorpyCode Example:>>> from condorpy import Job, Templates
>>> job = Job('job_name', Templates.vanilla_transfer_files)
>>> job.executable = 'job_script'
>>> jobs.arguments = 'input_1 input_2'
>>> job.transfer_input_files = 'input_1 input_2'
>>> job.transfer_output_files = 'output'
>>> job.submit()
Package: condor-pytorch
CONDOR pytorch implementation for ordinal regression with deep neural networks.Documentation:https://GarrettJenkinson.github.io/condor_pytorchAboutCONDOR, short for CONDitionals for Ordinal Regression, is a method for ordinal regression with deep neural networks,
which addresses the rank inconsistency issue of other ordinal regression frameworks.It is compatible with any state-of-the-art deep neural network architecture, requiring only modification of the output layer, the labels, the loss function.This repository implements the CONDOR functionality (neural network layer, loss function, and dataset utilities) for convenient use.
Examples are provided via the "Tutorials" that can be found on the documentation website athttps://GarrettJenkinson.github.io/condor_pytorch.We also haveCONDOR implemented for Tensorflow.Installation or DockerYou can install the latest stable release ofcondor_pytorchdirectly from Python's package index viapipby executing the following code from your command line:pipinstallcondor-pytorchThe dependencies can also be pip installed also using the includedrequirements.txt:pipinstall-rrequirements.txtWe also provide Dockerfile's to help get up and started quickly withcondor_pytorch.
The cpu image can be built and ran as follows, with tutorial jupyter notebooks
built in.# Create a docker image, only done oncedockerbuild-tcpu_pytorch-fcpu.Dockerfile./# run image to serve a jupyter notebookdockerrun-it-p8888:8888--rmcpu_pytorch# how to run bash inside container (with python that will have deps)dockerrun-u$(id-u):$(id-g)-it-p8888:8888--rmcpu_pytorchbashAn NVIDIA based gpu optimized container can be built and run
as follows (without interactive ipynb capabilities).# only needs to be built oncedockerbuild-tgpu_pytorch-fgpu.Dockerfile./# use the image after building itdockerrun-it-p8888:8888--rmgpu_pytorchCite asIf you use CONDOR as part of your workflow in a scientific publication, please consider citing the CONDOR repository with the following DOI:Jenkinson, Khezeli, Oliver, Kalantari, Klee. Universally rank consistent ordinal regression in neural networks, arXiv:2110.07470, 2021.@article{condor2021,
title = "Universally rank consistent ordinal regression in neural networks",
journal = "arXiv",
volume = "2110.07470",
year = "2021",
url = "https://arxiv.org/abs/2110.07470",
author = "Garrett Jenkinson and Kia Khezeli and Gavin R. Oliver and John Kalantari and Eric W. Klee",
keywords = "Deep learning, Ordinal regression, neural networks, Machine learning, Biometrics"
}Acknowledgments: Many thanks tothe CORAL ordinal authorsandthe CORAL pytorch authorswhose repos provided a roadmap for this codebase.