Saravanan666/pypi-org huggingface dataset:
Package: tunasloth
No release out yet!tunasloth is a game engine for RPGs.tunasloth can be used both as a command line tool and as a Python
module. It requires Python 3.1+.tunasloth is part of the roptoligs project. See the roptoligs wiki athttp://roptoligs.metanohi.org/for details.Licensetunasloth is free software under the terms of the GNU General Public
License version 3 (or any later version). This is version 0.1.0 of the
program.The libraries used by tunasloth are GPL-compatible.InstallationWay #1Just run this (requires that you have python-setuptools installed):easy_install3 tunaslothWay #2Get the newest version of tunasloth athttp://roptoligs.metanohi.org/modules:tunaslothor athttp://pypi.python.org/pypi/tunasloth.Extract the downloaded file and run this in a terminal:python3 setup.py installDependenciesqvikconfigWeb address:http://pypi.python.org/pypi/qvikconfig/License: GPLv3+Installing:easy_install3 qvikconfigAuthor: Niels SerupNote thatqvikconfigis included with tunasloth, so you don’t really
have to install it.Optional extrasIf present, tunasloth will also use these Python modules:termcolorWeb address:http://pypi.python.org/pypi/termcolor/License: GPLv3+Installing:easy_install3 termcolorAuthor: Konstantin Lepa <konstantin lepa at gmail com>Note thattermcoloris included with tunasloth, so you don’t
really have to install it.setproctitleWeb address:http://pypi.python.org/pypi/setproctitle/License: New BSD LicenseInstalling:easy_install3 setproctitleAuthor: Daniele Varrazzo <daniele varrazzo at gmail com>Usetunasloth is merely an engine; it is not an actual game. You will need
a game for tunasloth for it to be useful. A list of such games exists
at theroptoligs wiki. As of
this release, the main game in development is called Symbolic Zinc.Developmenttunasloth uses Git for code management. To get the latest branch,
clone it from gitorious.org like this:$ git clone git://gitorious.org/tunasloth/tunasloth.gitThe logoThe tunasloth logo (found inlogo/) is released under the Creative
Commons Attribution 3.0 Unported license. Its author is Niels
Serup. It is partly based on a picture by Wikimedia Commons userhttp://commons.wikimedia.org/wiki/User:Anasofiapaixao, seehttp://commons.wikimedia.org/wiki/File:Sloth_cartoon.svgfor more
information.This documentCopyright (C) 2010, 2011  Niels SerupCopying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved.  This file is offered as-is,
without any warranty.
Package: tuna-wrap
DescriptionRun Nautilus scripts within Thunar file manager. Tuna-wrap wraps
Nautilus filemanager scripts to run these from Thunars custom actions.LicenseMIT LicenseNotesOnly tested on ubuntu with nautilus scripts written in pythonOnly tested with python3Featuresshare you scripts between Thunar, Nautilus and Nemovery easy useInstallationInstallation / Deinstallationwith pippip3 install tuna-wrap

pip3 uninstall tuna-wrapor setup.pyUnpack your package.Open a terminal and change to the folder which contains the setup.py and typepython setup.py installSetupEdit your Thunar custom actions in following scheme:
tuna-wrap “YOUR NAUTILUS SCRIPT NAME” “%d” “%N”Make sure your scripts are in one of these places:~/.local/share/nautilus/scripts/
~/.scripts/
~/.local/share/nemo/scripts/Do´t forget to make your scripts executableUsageUse it as your other custom actionsget this readme with: tuna-wrap –helpHintsThe logfile is stored in you home directory: ~/.tuna-wrap.logFor a more verbose tuna-wrap output add “DEBUG” as last argument
Package: tundra-xaxlib-python
tundra-xaxlib-pythontundra-xaxlib-python, orTundra-NAT64 external address translation library for Python, enables one to easily
parse and constructs wireformat messages used byTundra-NAT64 external address translation protocol(specification)
in Python programs. Although this library will probably be most commonly used to implement servers, it is also
able to construct request messages and parse response messages, which are actions that only the client, i.e.Tundra-NAT64, needs to perform.NOTE: Some links in this README may not work if the file is not viewed throughGitHub.InstallationThis library targetsPython 3.9 and above. It might work in older Python 3 versions, but nothing is guaranteed.tundra-xaxlib-pythonmay be installed fromPyPIusingpip:python3-mpipinstall--upgradetundra-xaxlib-pythonUsageClasses and variables try to reflect theprotocol specificationas closely as possible in terms of both names and functionality, so I would recommend to start there.This library's central (data)classes areRequestMessage,SuccessfulResponseMessageandErroneousResponseMessage. Each of them can be instantiated the
usual way, or by using thefrom_wireformat()classmethod for parsing wireformat. The instances then have theto_wireformat()method for constructing wireformat. TheRequestMessageclass has additional methods for constructing response message objects which use existing data from the request:generate_successful_response()andgenerate_erroneous_response(). Methods which have it documented in their
docstrings raiseInvalidMessageDataExc(or a subclass thereof) in
case an error occurs. If you, for some reason, needed to detect the appropriate message class from wireformat or
instantiate it straightaway, theWireformatParsingHelpersclass
is there to help with that.Examples001_nat64.py– An example external address translation server which works almost exactly
the same asTundra-NAT64's built-innat64addressing mode, i.e. it is
able to, without the help of a NAT66, statelessly translate packets from one source IPv6 to one source IPv4 and do
the inverse process for packets going the other way.LicensingThis project is licensed under the3-clause BSD license– see theLICENSEfile.Programmed byVít Labuda.
Package: tune
TuneTune is an abstraction layer for general parameter tuning. It is built onFugueso it can seamlessly run on any backend supported by Fugue, such as Spark, Dask and local.InstallationpipinstalltuneIt's recommended to also install Scikit-Learn (for all compatible models tuning) and Hyperopt (to enableBayesian Optimization)pipinstalltune[hyperopt,sklearn]Quick StartTo quickly start, please go through these tutorials on Kaggle:Search SpaceNon-iterative Problems, such as Scikit-Learn model tuningIterative Problems, such as Keras model tuningDesign PhilosophyTune does not follow Scikit-Learn's model selection APIs and does not provide distributed backend for it.We believe that parameter tuning is a general problem that is not only for machine learning, so our abstractions are built from ground up, the lower level APIs do not assume the objective is a machine learning model, while the higher level APIs are dedicated to solve specific problems, such as Scikit-Learn compatible model tuning and Keras model tuning.Although we didn't base our solution on any ofHyperOpt,Optuna,Ray TuneandNevergradetc., we are truly inspired by these wonderful solutions and their design. We also integrated with many of them for deeper level optimizations.Tuning problems are never easy, here are our goals:Provide the simplest and most intuitive APIs for major tuning cases. We always start from real tuning cases, figure out the minimal requirement for each of them and then determine the layers of abstraction. Readthis tutorial, you can see how minimal the interfaces can be.Be scale agnostic and platform agnostic. We want you to worry less aboutdistributed computing, and just focus on the tuning logic itself. Built on Fugue, Tune let you develop your tuning process iteratively. You can test with small spaces on local machine, and then switch to larger spaces and run distributedly with no code change. It can effectively save time and cost and make the process fun and rewarding. And to run any tuning logic distributedly, you only need a core framework itself (Spark, Dask, etc.) and you do not need a database, a queue service or even an embeded cluster.Be highly extendable and flexible on lower level. For exampleyou can extend on Fugue level, for example create an execution engine forPrefectto run the tuning jobs as a Prefect workflowyou can integrate third party optimizers and use Tune just as a distributed orchestrator. We have integratedHyperOpt. AndOptunaandNevergradis on the way.you can start external instances (e.g. EC2 instances) for different training subtasks and to fully utilize your cloudyou can combine with distributed training as long as your have enough compute resourceFocusesHere are our current focuses:A flexible space design and can describe a hybrid space of grid search, random search and second level optimization such as bayesian optimizationIntegrate with 3rd party tuning frameworksCreate generalized and distributed versions ofSuccessive Halving,HyperbandandAsynchronous Successive Halving.CollaborationWe are looking for collaborators, if you are interested, please let us know. Please join ourSlack channel.
Package: tuned-lens
Tuned Lens 🔎Tools for understanding how transformer predictions are built layer-by-layer.This package provides a simple interface for training and evaluatingtuned lenses. A tuned lens allows us to peek at the iterative computations a transformer uses to compute the next token.What is a Lens?A lens into a transformer withnlayers allows you to replace the lastmlayers of the model with anaffine transformation(we call these affine translators). Each affine translator is trained to minimize the KL divergence between its prediction and the final output distribution of the original model. This means that after training, the tuned lens allows you to skip over these last few layers and see the best prediction that can be made from the model's intermediate representations, i.e., the residual stream, at layern - m.The reason we need to train an affine translator is that the representations may be rotated, shifted, or stretched from layer to layer. This training differentiates this method from simpler approaches that unembed the residual stream of the network directly using the unembedding matrix, i.e., thelogit lens. We explain this process and its applications in the paperEliciting Latent Predictions from Transformers with the Tuned Lens.AcknowledgmentsOriginally conceived byIgor OstrovskyandStella BidermanatEleutherAI, this library was built as a collaboration between FAR and EleutherAI researchers.Install InstructionsInstalling from PyPIFirst, you will need to install the basic prerequisites into a virtual environment:Python 3.9+PyTorch 1.13.0+Then, you can simply install the package using pip.pip install tuned-lensInstalling the containerIf you prefer to run the training scripts from within a container, you can use the provided Docker container.docker pull ghcr.io/alignmentresearch/tuned-lens:latest
docker run --rm tuned-lens:latest tuned-lens --helpContributingMake sure to install the dev dependencies and install the pre-commit hooks.$ git clone https://github.com/AlignmentResearch/tuned-lens.git
$ pip install -e ".[dev]"
$ pre-commit installCitationIf you find this library useful, please cite it as:@article{belrose2023eliciting,title={Eliciting Latent Predictions from Transformers with the Tuned Lens},authors={Belrose, Nora and Furman, Zach and Smith, Logan and Halawi, Danny and McKinney, Lev and Ostrovsky, Igor and Biderman, Stella and Steinhardt, Jacob},journal={to appear},year={2023}}WarningThis package has not reached 1.0. Expect the public interface to change regularly and without a major version bumps.
Package: tune-easy
tune-easyA hyperparameter tuning tool, extremely easy to use.This package supports scikit-learn API estimators, such as SVM and LightGBM.UsageExample of All-in-one Tuningfromtune_easyimportAllInOneTuningimportseabornassns# Load Datasetiris=sns.load_dataset("iris")iris=iris[iris['species']!='setosa']# Select 2 classesTARGET_VARIALBLE='species'# Target variableUSE_EXPLANATORY=['petal_width','petal_length','sepal_width','sepal_length']# Explanatory variablesy=iris[OBJECTIVE_VARIALBLE].valuesX=iris[USE_EXPLANATORY].values###### Run All-in-one Tuning######all_tuner=AllInOneTuning()all_tuner.all_in_one_tuning(X,y,x_colnames=USE_EXPLANATORY,cv=2)all_tuner.df_scoresIf you want to know usage of the other classes, seeAPI ReferenceandExamplesExample of Detailed Tuningfromtune_easyimportLGBMClassifierTuningfromsklearn.datasetsimportload_bostonimportseabornassns# Load datasetiris=sns.load_dataset("iris")iris=iris[iris['species']!='setosa']# Select 2 classesOBJECTIVE_VARIALBLE='species'# Target variableUSE_EXPLANATORY=['petal_width','petal_length','sepal_width','sepal_length']# Explanatory variablesy=iris[OBJECTIVE_VARIALBLE].valuesX=iris[USE_EXPLANATORY].values###### Run Detailed Tuning######tuning=LGBMClassifierTuning(X,y,USE_EXPLANATORY)# Initialize tuning instancetuning.plot_first_validation_curve(cv=2)# Plot first validation curvetuning.optuna_tuning(cv=2)# Optimization using Optuna librarytuning.plot_search_history()# Plot score increase historytuning.plot_search_map()# Visualize relationship between parameters and validation scoretuning.plot_best_learning_curve()# Plot learning curvetuning.plot_best_validation_curve()# Plot validation curveIf you want to know usage of the other classes, seeAPI ReferenceandExamplesExample of MLflow loggingfromtune_easyimportAllInOneTuningimportseabornassns# Load datasetiris=sns.load_dataset("iris")iris=iris[iris['species']!='setosa']# Select 2 classesTARGET_VARIALBLE='species'# Target variableUSE_EXPLANATORY=['petal_width','petal_length','sepal_width','sepal_length']# Explanatory variablesy=iris[TARGET_VARIALBLE].valuesX=iris[USE_EXPLANATORY].values###### Run All-in-one Tuning with MLflow logging ######all_tuner=AllInOneTuning()all_tuner.all_in_one_tuning(X,y,x_colnames=USE_EXPLANATORY,cv=2,mlflow_logging=True)# Set MLflow logging argumentIf you want to know usage of the other classes, seeAPI ReferenceandExamplesRequirementsparam-tuning-utility 0.2.1 requiresPython >=3.6Scikit-learn >=0.24.2Numpy >=1.20.3Pandas >=1.2.4Matplotlib >=3.3.4Seaborn >=0.11.0Optuna >=2.7.0BayesianOptimization >=1.2.0MLFlow >=1.17.0LightGBM >=3.3.2XGBoost >=1.4.2seaborn-analyzer >=0.2.11Installing tune-easyUse pip to install the binary wheels onPyPI$pipinstalltune-easySupportBugs may be reported athttps://github.com/c60evaporator/tune-easy/issuesContactIf you have any questions or comments about param-tuning-utility,
please feel free to contact me via
eMail:c60evaporator@gmail.comor Twitter:https://twitter.com/c60evaporatorThis project is hosted athttps://github.com/c60evaporator/param-tuning-utility
Package: tuneflow-devkit-py
tuneflow-devkit-pyEnglish|简体中文Debugger and Runner for tuneflow-py.RequirementsPython >= 3.7Installationpipinstalltuneflow-devkit-pyNote:You may need to make sure the version oftuneflow-pyis compatible with thetuneflow-devkit-pyyou are using. To do that, check therequirements.txtintuneflow-devkit-pyand see if itstuneflow-pyis set to the same version as yourtuneflow-py.Getting StartedVisithttps://help.tuneflow.com/en/developerfor developer documentation.ExamplesThe easiest way to learn how to write plugins is through examples. To view all example projects, check outhttps://github.com/tuneflow/tuneflow-py-demos.ContributingReadContributingResourcesTuneFlow Typescript PluginTuneFlow Typescript Dev KitTuneFlow Basic Plugins in TypescriptHow Does the Plugin System Work?
Package: tuneflow-py
TuneFlow Python SDKEnglish|简体中文What isTuneFlowandtuneflow-py?TuneFlowis a next-gen DAW that aims to boost music making productivity through the power of AI. Unlike traditional DAWs, TuneFlow has a plugin system designed to facilitate music production in almost all areas, including but not limited tosong writing,arrangement,automation,mixing,transcription...... You can easily write your own algorithms or integrate your AI models directly into the song-making process.tuneflow-pyis the Python SDK of TuneFlow plugins.Installationpipinstalltuneflow-pyPrefer another language?Check out the SDKs in other languages:Typescript:https://www.github.com/tuneflow/tuneflowOther: Contributions welcome!Whytuneflow-py?The core idea of TuneFlow's plugin system is that you only care about the data model, NOT the implementation. A plugin's only goal is to modify the song, and the DAW will apply the changes automatically.Unlike traditional DAW plugins where you can only process MIDI/audio signals from one track, this plugin system allows you to access and modify any part of the project, which is perfect for integrating complex algorithms and AI models.What's more exciting is that this execution model allows remote processing, which means you can write and test your plugin locally and deploy it anywhere you like, and the DAW can run your plugin through simple network requests.Below is an illustration of the plugin execution flow:Getting StartedVisithttps://help.tuneflow.com/en/developerfor developer documentation.Examples⌨️ AudioLDMGenerate speech, sound effects, music and more from text prompt.Repo:https://github.com/tuneflow/AudioLDM🎙️ Singing TranscriptionTranscribe a singing vocal from audio to MIDI. Works with background noise or music.Repo:https://github.com/tuneflow/singing-transcription-plugin✂️ DemucsSeparate a raw music audio clip into vocal, drums, bass and others.Repo：https://github.com/tuneflow/tuneflow-plugin-demucs🥁 Pocket DrumGenerate a drum pattern with the given style and optionally a melody midi.Repo: To be updated.For a comprehensive of example plugins, check outhttps://www.github.com/tuneflow/tuneflow-py-demosContributeCheckoutcontribution guidelines.ResourcesTuneFlow WebsiteTypescript SDK
Package: tunein-python
tunein-pythonAn unofficial, highly experimental wrapper around TuneIn.pip?Later.How to useSimple! Importtuneinand you have 3 functions for interfacing with TuneIn:get_popular_stations()- gets the popular stations in your area
query: str - the GuideId for the stations. Still working out what does this mean.
Returns a list with a dict for each radio station
keys:name: the name of the stationid  : the id you can use later in the library. scraped from GuideId of stationlogo: an URL to station's image.get_station_metadata(id)- Get stations data: logo, streaming urls, description, subtitle, frequency, language and if it's explicit
id:str - a GuideId you obtained earlierreturns a dict with all of the data mentioned above
keys:streams: a list of dicts looking like{"reliability": int, "stream_url": str, "media_type": str, "bitrate": int}({"reliability": 99, "stream_url": "http://www.rmfon.pl/tunein/tunein.p[...]", "media_type": "mp3", "bitrate": 128})name: a str with the station name (RMF FM)subtitle: in API called a slogan, a str with the station's subtitle (Najlepsza Muzyka / The Best Music)frequency: if applicable, a float containing most likely FM frequency of the station. May be None (96.0)description: a str with a long description of the station (Rozgłośnia nadaje program muzyczno-informacyjny, emitowany 24 godz...)language: an str of the station's language (Polish)lang: an str of a short-code of the language (pl)search_for_stations()- Gets stations under the query provided
query: str - keywords for the stationsfor returns, look at get_popular_stations
Package: tunepy2
tunepy2Provides a variety of extensible and easy to use bitstring optimizers as well as several machine learning convenience
utilities for model optimization.Dependenciespython >= 3.7numpy >= 1.19.2scikit-learn >= 0.23.2Installationpip install tunepy2Basic UsageAll bitstring optimizers extend the Abstract Base Class (ABC)AbstractOptimizer.
The most basic versions of all optimizers are accessed through static build methods.Importing tunepy2importtunepy2astpBasic Prebuilt OptimizersRandom Restart Hill Climber (tp.new_random_restart_hill_climber)Simulated Annealer (tp.new_simulated_annealer)Basic Hill Climber (tp.new_hill_climber)Genetic Algorithm (tp.new_genetic_optimizer)Fitness functions are assumed have an array-like passed in as the first argument and return a fitness value.
Package: tuneRs
Hyperparameter TuneRstuneRsis a small package for tuning hyperparameters using resampling methods instead of normal crossvalidation.  Estimating model accuracy using resampling methods is much quicker that using k-fold crossvalidation--although resampling tends to underestimate accuracy more that crossvalidation.  Resampling underestimates accuracy in aconsistentfashion, however, which still makes it valuable for tuning hyperparameters.  Due to it's consistency, choosing hyperparameters based on aggregated samples still gets within the neighborhood of maximal while being much, much faster.  This is a package to help you get there.GridSearchResampleuses the grid search method to optimize hyperparameters.RandomSearchResampleuses the random search method to optimize hyperparameters.Current Version is v0.57This package is currently in the beginning stages and is very bare-bonesInstallationUse the package managerpipto install tuneRs.pipinstalltuneRsUsageBoth classes are meant to mimic the scikit-learn tuners (to a certain degree).  A simple example would be:import tuneRs

model = SVC(kernel='rbf')

parameters = {["gamma": [0.001, 0.01, 0.1, 1.0, 10.0],
		"C": [0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]}

# Set up for a random hyperparameter search
tuner = tuneRs.RandomSearchResample(model, parameters, num_iters=300, sample_size=0.3, num_samples=12)

# Fit the tuner
tuner.fit(X_train, y_train)

# Display the best parameters found
tuner.best_params_

# Display the aggregate resample score of the best parameters <br/>
tuner.best_score_

# Define our new model
model = tuner.best_estimator_

# Plot the resample accuracy distribution for the model with best hyperparameters <br/>
tuner.plot_best()Future PlansMultiple tuners are currently planned to be added.  The next one will be a Bayesian search method.  A dynamic version of grid search and random search is currently being worked on that iterates fit multiple times on increasingly small areas of the data space.LicenseLol
Package: tunet
# TUNETTUNET is a python tool to login and logout Tsinghua University Network (tunet).To use this do as below:```python# install from pippip install tunet# import tunet packageimport tunet# set login/logout optionsoptions = {'name': 'user_name',    # required, 'user_name' and 'user_name@tsinghua' are for access public internet and tunet, respectively'pwd': 'user_password', # required, password for tunet account 'user_name''ip': '192.168.1.1'     # optional, the ip you want to authenticate, and default is the client ip}# do logintunet.login(options['name'], options['pwd'], options['ip'])# Login is successful.# do logouttunet.logout(options['name'], options['ip'])# Logout is successful.```
Package: tune-the-model
Tune The Model python wrapperTune The Modelis a few-shot AutoML system.Tune The Model can do almost anything that requires understanding or generating natural language. It is able to solve tasks in 12 languages: English, Spanish, Portuguese, Russian, Turkish, French, German, Italian, Arabic, Polish, Dutch, and Hebrew.This package provides a simple wrapper for using our api.Usingtune-the-modelpackage allows you to train and apply models.DocumentationYou can find the documentation at ourTune The Model API docs site.Just tryWe have fine-tuned several models. You can use thenotebookto try them out. You canget the tokento fine tune your own model.Getting startedFirstly fill out theformto get a key to access the API. We will send you the key within a day.InstallationTo install the package just usepip install -U tune-the-model.Usageimporttune_the_modelasttmimportpandasaspdttm.set_api_key('YOUR_API_KEY')# load datasetstdf=pd.read_csv('train.csv')vdf=pd.read_csv('test.csv')# Call one method. It will do everything for you:# create a model, save it to the file, upload datasets and put the model in the queue for training.model=ttm.tune_generator('filename.json',tdf['inputs'],tdf['outputs'],vdf['inputs'],vdf['outputs'])# wait...# a few hours# while our GPUs train your modelmodel.wait_for_training_finish()print(model.status)print(model.is_ready)# inference!the_answer=model.generate('The Answer to the Ultimate Question of Life, the Universe, and Everything')print(the_answer)