Saravanan666/pypi-org huggingface dataset:
Package: tati-tools
Tati-toolsThis is a set of helper tools for computer vision tasks.IncludesConfigs parsingTools for deep learning modelsCommon PyTorch routines (fix random seed, load, save)Logging setups and examplesLosses: Focal loss, Jaccard loss, Dice losses and combination of losses.Visualization of computer vision predictionsMetrics for CV tasksImage, bboxes and masks helpersSample datasetsInstallationpip install -U tati-toolspip install git+https://github.com/tatigabru/tati-tools
Package: tatoo
tatoo - task toolkitTatoo is python task toolkit, intended to be small and simple, but
powerful and extensible. Out of the box it allows you to programmatically
execute tasks on the local machine:>>> from tatoo import Environment
>>> env = Environment()
>>> @env.task
>>> def hello():
...     print('Hello, world!')
...
>>> hello.apply()
Hello, world!It can be use as a replacement for tools likeMake(a command-line
interface is provided via extensions), but it was developed withCelery’s features in mind, so once there will be extensions for
remote task execution, daemonization and others.Documentation can be found onread the docs.It works under Python 2.6, 2.7, 3.3+ and Pypy (Pypy3 is not yet
supported) on Linux, OSX and Windows. This
ensured on each commit continiously usingTravisCI(Linux & OSX) andAppveyor(Windows).
Package: tatoo-cli
Tatoo CLICommand-line interface fortatoolibrary.Given the followingtasks.pyfile:from tatoo import Environment, parameter
from tatoo.tasks import types

env = Environment('myenv')

@env.task
@parameter('x', type=types.Float)
@parameter('y', type=types.Float)
def add(x, y):
    print(x + y)You can executeaddtask like this:$ tatoo -E tasks apply add 1 2
3.0It works under Python 2.6, 2.7, 3.3+ and Pypy (Pypy3 is not yet supported) on
Linux, OSX and Windows. This ensured on each commit continiously usingTravisCI(Linux & OSX) andAppveyor(Windows).
Package: ta-tooling
TA ToolingVarious tools for teaching assistant who is working withBlackboard, a learning management system.Installationpython -m pip install ta-toolingUsageGet list of students in the classTo get list of students in the class, runta-tooling get-student-listThe program will ask forcourse id,username, andpassword. It will login with the username password you provided
and produce a CSV file of students in the course. Thecourse idcan be the actual course id or a URL to your course.The CSV file will have the following header.emailHandle,firstName,lastName,userId,courseMembershipIdGroup submission filesTo group the submission files by email handle. Download and extract the ZIP file into a directory (callsource-dirin the example).ta-tooling categorize source-dir dest-dirIn version 0.3.x the support for categorizing directly from a ZIP file is added.Download file submitted for a question in a quizNote: Currently, only Firefox is supported, and webdriver is needed.To download file submitted as an answer to a question in a quiz, first get the links by injecting the extraction code. To get the extraction code (and start the server for the code to call back to).ta-tooling serve-injectand follow instruction show on the web page. Obtain the user list if have not done already.ta-tooling get-student-listUse the student list and the download links to download the files.ta-tooling download-links users.json files.jsonSome files will not be automatically downloaded, in that case, you need to confirm the download manually
(within certain time limit; otherwise, you will miss the window of file moving).TODOTheAccept-Originthat the submission download for a question in a quiz is relying on is expected to be
tighten. The plan is to switch to the correct iframe, and execute javascript directly through selenium.(serve-inject) The script injected to the page will get
Package: tatort-schedule
Tatort ScheduleAbout The ProjectThis project contains a Python 3 module that parses the schedule of theTatortwebsite.
After parsing, it returns a list containing the next broadcasts on the channelDas Erste.Built WithBeautifulSoup4Getting StartedTo get a local copy up and running follow these simple steps.PrerequisitesYou will need a working installation of Python 3.InstallationInstall via pip:pipinstalltatort_scheduleUsageImport tatort_schedule and call the get_tatort function:fromtatort_scheduleimportscheduleschedule=schedule.get_tatort_erste()For each schedule element, a dictionary with the following keys is returned:KeyExample Valuetitle"Mord Ex Machina"city"Saarbrücken"inspectors"Stellbrink und Marx"time"2021-07-09T22:15:00+02:00"link"https://www.daserste.de/unterhaltung/krimi/tatort/sendung/mord-ex-machina-104.html"If the schedule for other channels is fetched (using get_tatort_dritte()), every
schedule element has an additionalchannelkey.LicenseDistributed under the GPLv3 License. SeeLICENSEfor more information.ContactKai Anter -@tanikai29-kai.anter@web.deProject Link:https://github.com/Tanikai/tatort-schedule
Package: tat-pulsar
TAT-pulsar (Timing Analysis Toolkit for pulsar astrophysics)Hey there! This is a Python toolbox made for folks interested in messing around with pulsar timing analysis, especially in high-energy scenarios. You know those pesky corrections needed for stuff like the barycentric correction and binary systems? Yeah, we’ve got functions for those. Plus, we’ve included some timing analysis tools and some examples to help you get started with your pulsar timing exploration. Enjoy!Install the Package usingpipOpen your terminal or command prompt.Type in the following command:pip install tat-pulsarInstall the Package using condaDownload the repositoryDownload the whole repository to your local directory usinggit cloneorgit fetch.For example, In you local path execute:git clone https://github.com/tuoyl/tat-pulsar.gitAnd you will get the foldertat-pulsar, in the folder you will see a file namedsetup.py. We will install the whole package based on this script.Create a conda environmentThe most elegant thing to do before installing is to create a new conda environment to avoid conflicts with your existing python environment.conda create -n pulsar-timing python=3after downloading the dependancies, executeconda activate pulsar-timingto enter the pulsar-timing environment of conda, you will see(pulsar-timing)before the shell prompt.Install the repositoryNow you are all set to install the repository. In the directory where the setup.py located, execute:python3 -m pip install -e .Uninstall the repositoryif you want to uninstall the package for generating the product.python3 -m pip uninstall tat-pulsar
Package: tatsu-api
Tatsu API WrapperA lightweight and asynchronous wrapper forTatsu v1 API, written in Python. Supports every documented API endpoint.To get an API key, use the command "t!apikey" on a Discord server with the Tatsu bot present.Note: Modifying a user's scores/points isn't possible without certain Discord permissions. See the API docs for more info.Installingtatsu-api currently requires Python 3.8 or higher.To install the library, run one of the following commands:# Linux/macOSpython3-mpipinstall-Utatsu-api# Windowspy-3-mpipinstall-Utatsu-apiQuick ExampleFor more examples, see theexamples folder.importasyncioimporttatsu_apiastatsuasyncdefmain()->None:"""Example function."""api_key="API_KEY"test_guild=173184118492889089# The Discord ID of the official Tatsu server.test_user=1234567891# Random Discord user ID.# The client can be used as a context manager to handle closing of the# internal HTTP session.asyncwithtatsu.Client(api_key)asclient:profile=awaitclient.get_user(test_user)print(f"{profile.username}currently has{profile.credits}credits and{profile.reputation}reputation.")username=profile.usernameranking=awaitclient.get_member_ranking(test_guild,test_user,"all")print(f"On the Tatsu server,{username}ranks at{ranking.rank}for all time.")before_points=awaitclient.get_member_points(test_guild,test_user)print(f"{username}- Points before update:{before_points.points}")after_points=awaitclient.update_member_points(test_guild,test_user,-10)print(f"{username}- Points after update:{after_points.points}")asyncio.run(main())AcknowledgementsShoutout todiscord.pyfor being an inspiration and providing a strong example for implementation.
Package: tatsu.py
Tatsumaki.pyAn async python api wrapper for theTatsu API.Set up guide:Download the library with thepip install tatsu.pycommandImport the library:from tatsu.wrapper import ApiWrapperCheck the wiki for more information:WikiCode examples:Get the information of a userfromtatsu.wrapperimportApiWrapperasyncdefget_profile():wrapper=ApiWrapper(key="API_KEY_HERE")user_profile=awaitwrapper.get_profile(274561812664549376)returnuser_profile.creditsGet the ranking of a user:fromtatsu.wrapperimportApiWrapperasyncdefget_member_ranking():wrapper=ApiWrapper(key="API_KEY_HERE")result=awaitwrapper.get_member_ranking(573885009820254239,274561812664549376)returnresult.rankGet the rankings of a server with an offsetfromtatsu.wrapperimportApiWrapperasyncdefget_ranks():wrapper=ApiWrapper(key="API_KEY_HERE")result=awaitwrapper.get_guild_rankings(573885009820254239,offset=100)returnresult.rankings[0].rank# This will be 101
Package: tatter
IntroductionTATTER (Two-sAmple TesT EstimatoR) is a tool to perform two-sample hypothesis test.
The two-sample hypothesis test is concerned with whether distributions
p(x) and q(x) are different on the basis of finite samples drawn from each
of them. This ubiquitous problem appears in a legion of applications,
ranging from data mining to data analysis and inference.
This implementation can perform the Kolmogorov-Smirnov test
(for one-dimensional data only), Kullback-Leibler divergence,
and Maximum Mean Discrepancy (MMD) test. The module perform a bootstrap
algorithm to estimate the null distribution, and compute p-value.Dependenciesnumpy,matplotlib,sklearn,joblib,tqdm,pathlibCautionsThe employed implementation of the Kullback-Leibler divergence is slow
and generating a few thousands of bootstrap realizations when the
sample size is large (n, m >1000) is not practical.The provided tests reproduce Figures X, X, and X in the paper. Running
all of these tests takes ~30 minutes. If your are impatient to reproduce
one of the figures trymnist_digits_distance.pyfirst.References[1]. A. Farahi, Y. Chen "TATTER: A hypothesis testing tool for multi-dimensional data." Astronomy and Computing, Volume 34, January (2021).[2]. A. Gretton, B. M. Karsten, R. J. Malte, B. Schölkopf, and A. Smola,
"A kernel two-sample test."
Journal of Machine Learning Research 13, no. Mar (2012): 723-773.[3]. Q. Wang, S. R. Kulkarni, and S. Verdú,
"Divergence estimation for multidimensional densities via k-nearest-neighbor distances."
IEEE Transactions on Information Theory 55, no. 5 (2009): 2392-2405.[4]. W. H. Press, B. P. Flannery, S. A. Teukolsky, and W. T. Vetterling,
"Numerical recipes." (1989).QuickstartTo start using TATTER, simply usefrom tatter import two_sample_testto
access the primary function. The exact requirements for the inputs are
listed in the docstring of the two_sample_test() function further below.
An example for using TATTER looks like this:from tatter import two_sample_test

  test_value, test_null, p_value =
           two_sample_test(X, Y,
                           model='MMD',
                           iterations=1000,
                           kernel_function='rbf',
                           gamma=gamma,
                           n_jobs=4,
                           verbose=True,
                           random_state=0)
Package: tattrdb
DescriptionTattrDB is a simple way to add Tags and Attributes to hostnames for use
as a very generic service management database.Installationpip install tattrdbDatabase CreationTattr uses sqlalchemy underneath and those uses a database url to
connect. Once you’ve constructed your url you can plugin it into the
example below:from tattrdb import models
models._sync(models.connect("sqlite:///tattr.sqlite"))ConfigurationUsing the same url from the example above you’ll need to create a
configuration file at /etc/tattr.yaml as follows:db_uri: "sqlite:///tattr.sqlite"Command-lineOnce you’ve finished installing and configuring tattr you can use the
tattr command line tool to add/rm/modify hosts/tags/attributes. Tattr
uses subcommands and each individual subcommand has it’s own help
messages.
Package: tatts
tattsthis project is a python package that uses google translate to read text (tts) and to translate!InstallationUse the package managerpipto install tatts.pipinstalltattsUsageimporttatts# text to speaktatts.speak("hello world!")# returns a translated text to whatever language you wanttatts.translate("hello world!",'en')notice that if you don't have chrome driver in path/folder that you running the python code from the package will auto-install the chromedriver.exeit will show you a dialog that asks you to install the chrome driver
and if you say y (yes) it will install the last stable version of chrome driverLicensemit
Package: tatu
tatu - Storage of Scientific DataWARNING: This project is still subject to major changes, e.g., in the next rewrite.InstallationExamplesGrantsPart of the effort spent in the present code was kindly supported by Fapesp under supervision of
Prof. André C. P. L. F. de Carvalho at CEPID-CeMEAI (Grants 2013/07375-0 – 2019/01735-0).HistoryThe novel ideias presented here are a result of a years-long
process of drafts, thinking, trial/error and rewrittings from scratch in several languages from Delphi, passing through Haskell, Java and Scala to Python - including frustration with well stablished libraries at the time. The fundamental concepts were lightly borrowed from basic category theory concepts like algebraic data structures that permeate many recent tendencies, e.g., in programming language design.For more details, refer tohttps://github.com/davips/kururu
Package: tatuarvela-magic
MagicMagic is a tool for turning repeated command line tasks and long, hard to
remember commands into quickly callable simple commands,spells.Spells provide a simple and managed alternative to manually created aliases or
scripts.🏃 Quick tourTo add spells, run the built-inwizardmagic addSpells are written into thespellbookfile (~/.spellbook.json)Each spell is available as a command undermagic, which can be listed
withmagic --helpA spell can have one or several command names, which are calledmagic
wordse.g.magic build-appandmagic baSpells can haveargumentspassed to theme.g.magic say abra kadabra💻 InstallationMagic is designed for macOS and common Linux distributions using Bash or Zsh.
Magic also works on Windows Subsystem for Linux.Magic requires Python 3.7 or above, and can be installed using pip:python3 -m pip install tatuarvela-magic🪄 Usage$magic✨ Magic © 2022 Tatu ArvelaA tool for simplifying repeated command line tasksUsage: magic [OPTIONS] COMMAND [ARGS]...Options:-h, --help  Show this message and exit.Commands:add      Add spell to spellbooke        Example echo spell with arguments '$a0' and '$a1'edit     Open spellbook in editorexample  Example echo spell with arguments '$a0' and '$a1'Editing the spellbook is currently done with an external editor (Visual Studio
Codeby default).📚 DocumentationSpell optionsSpell options can be listed with the-hor--helpoption.$magicexample--helpUsage: magic example [OPTIONS]Example echo spell with arguments '$a0' and '$a1'Options:-d, --delete  Delete this spell.-s, --show    Show details of this spell.-h, --help    Show this message and exit.-dor--deleteoption can be used to delete a spell.-sor--showoption can be used to show the details of a spell.Other options are interpreted as arguments for spells.Spell argumentsSpells can have an array of arguments, which are populated according to their
index, starting from 0.Example:{"description":"Example echo spell with arguments '$a0' and '$a1'","magicWords":["e","example"],"commands":["echo $a0","echo $a1"],"argumentCount":2}$magicexamplecatdog✨ Example echo spell with arguments 'cat' and 'dog'catdog✅ 12:30:43 | ⏱ 0:00:00The arguments can be used in the spell description and commands.The description arguments are replaced when displaying the spell message.argumentCountproperty is automatically inferred from the description and
commands.Excessive usage of arguments is considered to be an anti-pattern, it is
recommended to create separate spells instead.Advanced usage: Empty argumentsArgument are handled as an ordered array. If necessary, it is possible to make
an argument an empty string:''.MessagesMessageMagic can print the description of a spell, filled with the provided arguments✨ Example echo spell with arguments 'cat' and 'dog'showMessageproperty defaults totrue.Success messageMagic can show a success message which reports the starting time and duration of
a spell. This may be useful for longer operations.✅ 23:46:43 | ⏱ 0:00:00showSuccessMessageproperty defaults totrue.⚙️ DevelopmentDevelopment instructions and notes can be found
inDEVELOPMENT.md
Package: tau-clients
Threat Analysis Unit ClientsOverviewThreat Analysis Unit Clients (shortened astau-clients) is a set of clients that can be used
to programmatically interface with various VMware products and/or external services or
resources, with a focus on threat analysis and intelligence collection.Try it outNotesA client might require a specific and valid license; for example, bothPortalClientandAnalysisClientrequire a valid NSX Defender license.Support and bug reports are exclusively handled via GitHub.A fully supported commercial implementation ofAnalysisClientis available here:https://analysis.lastline.com/analysis/api-docs/html/analysis_client.htmlBuild & RunThis package can be installed via pip, just runpip install tau-clientsorpip install -e .To run a simple example just create a valid configuration file usingdata/tau_clients.ini.template.importconfigparserfromtau_clientsimportnsx_defenderconf=configparser.ConfigParser()conf.read("./data/tau_clients.ini")portal_client=nsx_defender.PortalClient.from_conf(conf,"portal")result=portal_client.get_tasks_from_knowledgebase(query_string="file_sha1: 'ba81b98f00168b86578e5f5de93d26ed83769432'",)ScriptsThis package includes the following console scripts ready to be used (assuming a valid
configuration file is also provided):download_artifacts.py: download all the available analysis artifacts given a file has or
task uuid.submit_samples.py: submit the samples contained in the provided directory; if a file hash is
provided download the sample from VirusTotal.ContributingThe tau-clients project team welcomes contributions from the community. Before you start working with tau-clients, please
read ourDeveloper Certificate of Origin. All contributions to this repository must be
signed as described on that page. Your signature certifies that you wrote the patch or have the right to pass it on
as an open-source patch. For more detailed information, refer toCONTRIBUTING.md.DevelopmentCreate the virtual env:python3 -m venv venvActivate the virtual env:source ./venv/bin/activateInstalltox:pip install toxRun tests:toxDue to a bug intoxif you update the dependencies insetup.cfgthe environments will not be
re-created, leading to errors when running the tests
(seehttps://github.com/tox-dev/tox/issues/93).
As workaround, pass the--recreateflag after updating the dependencies.Before committing, install the package in dev mode (needed bypylint):pip install -e .Installpylintandpre-commit:pip install pylint pre-commitInstall the hook:pre-commit installIf you want to run pre-commit on all files use the following command:pre-commit run --all-filesLicenseBSD 2-Clause
Package: taufactor
TauFactorTauFactor is an application for calculating tortuosity factors from tomographic data.Free software: MIT licenseDocumentation:https://taufactor.readthedocs.io.RequirementsBefore installing taufactor,download the most recent version of PyTorch. Ensure you havepytorch>=1.10installed in your Python environment.For example, for a Linux machine with CUDA GPUconda install pytorch pytorch-cuda=11.7 -c pytorch -c nvidiaQuickstartTo install TauFactor via PyPIpip install taufactorTo extract effective diffusivity and tortuosity factor from your data:importtaufactorastauimporttifffile# load imageimg=tifffile.imread('path/filename')# ensure 1s for conductive phase and 0s otherwise.# create a solver object with loaded images=tau.Solver(img)# call solve functions.solve()# view effective diffusivity and tauprint(s.D_eff,s.tau)TestsTo run unit tests navigate to the root directory and runpytestCreditsThis package was created by thetldr groupat the Dyson School of Design Engineering, Imperial College London.TauFactor MATLABThe package in this repository refers to a Python implementation of the TauFactor solver. There is a deprecatedMATLAB implementation, which is no longer maintained.History1.1.0 (2023-07-24)Added comments from reviewersAdded examples to documentationAdded API documentationFix test times on comparison1.0.0 (2023-03-23)Migrated to PyTorch from CuPyNew convergence criteriaNew documentation styleCI testingIncludes TauFactor paper0.1.4 (2022-07-11)Add TauE solverAdd triple phase boundary calculationsFix cuboids not convergingFix convergence messaging0.1.3 (2021-03-25)Hotfix code in taufactor.py0.1.2 (2021-03-25)Added multi-phase and periodic solvers and metrics calculations0.1.1 (2021-02-10)Removed CuPy from requirements and added installation instructions to README0.1.0 (2021-02-08)First release on PyPI.
Package: taug
TAug :: Time Series Data Augmentation using Deep Generative ModelsNote!!!The package is under development so be careful for using in production!FeaturesTime Series Data Augmentation using Deep Generative ModelsVisualizing the Latent Space of Generative ModelsTime Series Forecasting using Deep Neural NetworksInstallationYou can install the last stable version using pippip install taugHow to UseAugmentation GuideCreate an augmenterfromtaug.augmenters.vaeimportLSTMVAEfromtaug.augmenters.vaeimportVAEAugmenter# create a variational autoencodervae=LSTMVAE(series_len=100)# use the created vae as an augmenteraugmenter=VAEAugmenter(vae)The above code uses the default settings for the LSTM-VAE model. You can customize its architecture or use your own model for encoder and decoder. Note currently we only support Keras models.Train the augmenteraugmenter.fit(data,epochs=64)Generate new time series!A few strategy for sampling have been implemented.Sampling from wholaugmenter.sample(n=1000)Forecasting Guide[todo] Forecasting guide will be here!Supported AugmentersSupported models for augmentation currently are as follows:ModelTypeSupported Time SeriesDescriptionLSTMVAEVariational AutoencoderUnivariate, fixed lengthA Variational Autoencoder with stacked LSTM layers for encoder and decoderSupported ForecastersSupported models for time series forecasting are as follows:ContributorsThe list of the current contributors:Sasan BarakAmirabbas Asadi
Package: taulukko
TaulukkoTable (Finnish Taulukko) glued together to transform into hands-free living.License: MIT|Country of origin: Switzerland|Export control classification number(ECCN): EAR99Third party dependencies are documented in the folderthird-party.DocumentationUser and developerdocumentation of taulukko.Bug TrackerAny feature requests or bug reports shall go to thetodos of taulukko.Primary Source repositoryThe main source oftaulukkois on a mountain in central Switzerland.
We use distributed version control (git).
There is no central hub.
Every clone can become a new source for the benefit of all.
The preferred public clones oftaulukkoare:on codeberg- a democratic community-driven, non-profit software development platform operated by Codeberg e.V.at sourcehut- a collection of tools useful for software development.ContributionsPlease do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
If you like to share small changes under the repositories license please kindly do so by sending a patchset.
You can either send such a patchset per email usinggit send-emailor
if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork atsourcehut.StatusExperimental.Note: The default branch isdefault.