Saravanan666/pypi-org huggingface dataset:
Package: thundercache
========Overview========A distributed redis cache library, which solves the Thundering Herd problem.* Free software: BSD licenseInstallation============::pip install thundercacheDocumentation=============https://python-thundercache.readthedocs.io/Development===========To run the all tests run::toxNote, to combine the coverage data from all the tox environments run:.. list-table:::widths: 10 90:stub-columns: 1- - Windows- ::set PYTEST_ADDOPTS=--cov-appendtox- - Other- ::PYTEST_ADDOPTS=--cov-append toxUsage=====.. code-block:: python# Distributed Lockfrom thundercache import LockFactory, retry_commandfrom redis.sentinel import Sentinelsentinel = Sentinel()redis_sentinel_master_instance = retry_command(sentinel.master_for, "your_sentinel_service_name", socket_timeout=20)locks = LockFactory(expires=720, timeout=10, redis=redis_sentinel_master_instance)with locks('my_lock'):# do stuff with a distributed redis lock across different processes and networks# pretty cool right!pass# Local Redis Cachefrom thundercache import SmartLocalRedisCacheFactory, BaseCacheMixin)import timelcached = SmartLocalRedisCacheFactory()class MyClass(BaseCacheMixin):@lcached("method", max_age=10, critical=2)def method(self, n):time.sleep(n)return n*n@lcached("somefunc', max_age=10, critical=2)def somefunc(n):time.sleep(n)return n*nmc = MyClass()print mc.method(3)# prints "9" after three secondsprint mc.method(3)# prints "9" instantlyprint somefunc(2)# prints "4" after two secondsprint somefunc(2)# prints 4# Distributed Redis Cachefrom thundercache import SmartRedisCacheFactory, retry_commandfrom redis.sentinel import Sentinelsentinel = Sentinel()cached = SmartRedisCacheFactory(sentinel, "your_sentinel_service_name")# you can now use the @cached decorator in the same way you use @lcached# Per process cachefrom thundercache import BaseCacheclass MyClass(BaseCacheMixin):@BaseCache("mymethod", max_age=10)def mymethod(self, n):time.sleep(n)return n*n@BaseCache("otherfunc', max_age=10)def otherfunc(n):time.sleep(n)return n*n# You can also chain these decorators@BaseCache('x', 10)@cached('y', 60)def funct_or_method(*args,  **kwargs):return None::Changelog=========0.1.2 (2017-02-23)-----------------------------------------* First release on PyPI.
Package: thunderclient
A Python library for sending messages to theThunderpushserver.Installpip install thunderclientExamplefrom thunderclient import Thunder

c = Thunder('key', 'secretkey', 'localhost', 8080)

print(c.get_user_count())
print(c.get_users_in_channel('test'))
print(c.send_message_to_user('test', {'msg': 'hello!'}))
print(c.send_message_to_channel('test', {'msg': 'hello!'}))
print(c.is_user_online('test'))
print(c.disconnect_user('test'))
Package: thundercougarfalconbird
Just one word,thundercougarfalconbirdunder developmentSome of the dynamical models available are:DifferentialDriveKinematicsDroneParrotDroneThe list of imported packages can be found in thepyproject.toml.MIT LicenseCopyright (c) 2022 Mom's Friendly Robot CompanyPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: thunderfish
ThunderFishAlgorithms and programs for analysing electric field recordings of
weakly electric fish.Documentation|API ReferenceWeakly electric fish generate an electric organ discharge (EOD).  In
wave-type fish the EOD resembles a sinewave of a specific frequency
and with higher harmonics. In pulse-type fish EODs have a distinct
waveform and are separated in time. The thunderfish package provides
algorithms and tools for analysing both wavefish and pulsefish EODs.
Package: thunderhead
thunderhead is the Python SDK for the VMware vCloud Usage Meter API that allows you to
manage your vCloud Usage Meter system.Getting StartedCheck back soon for more documentationInstallingthunderhead is available at pypi which allows for a simple install using pip:pip install thunderheadTestingTesting requiresvcrpyand its dependencies.python setup.py testContributingTo contribute to thunderhead please follow the fork, branch, pull request work flow. Tests are required where applicable.
All code should follow pep8 standards, and must support python 2.6, 2.7, 3.3 and 3.4 When opening a pull request please
do so against the development branch.Python Supportthunderhead 0.1 and later support Python 2.6, 2.7, 3.3 and 3.4Compatibility Policythunderhead 0.1 and later are compatible with 3.3.x versions of vCloud Usage MeterReporting IssuesTo report a problem with thunderhead or to make a feature request open anissueon Github.Releases0.4Released October 9th 20140.40.4.1Released October 25th 20140.4.10.4.2Released March 5th 20150.4.20.4.3Released April 16th 20150.4.3
Package: thunder-observability-agent
A10's Thunder Observability Agent (TOA) - v2.0.0The TOA is a lightweight autonomous data processing engine that can be externally installed and configured for any Thunder device.
TOA offers the following capabilities on Application Delivery Controller (ADC):

- Collects, processes and publishes Thunder metrics. 
  The default data collection frequency is 1 minute. 
  Thunder metrics can be sent to the platform where Thunder is deployed, which includes AWS, Azure, and VMware or can be sent to shared platforms like Elasticsearch (Kibana), Prometheus (Grafana), and Splunk. 
  Metrics can be sent to any one platform at a time. For more information on Thunder metrics, see Supported Thunder Metrics.


- Collects, processes, and publishes Thunder Syslogs. 
  The default data collection frequency is 1 minute. 
  The logs can be published on various platforms like AWS, Azure, VMware, Kibana (Elasticsearch), Grafana (Prometheus and Pushgateway), or Splunk. 
  Logs can be sent to any one platform at a time. For more information on Thunder logs, see Supported Thunder Logs.

Supported Monitoring Platforms:
1. AWS.
2. Azure.
3. VMware.
4. Splunk
5. ElasticSearch-Kibana
6. Prometheus-Grafana [PushGateway]

Supported Use Cases:
1. Monitoring thunder adc metrics or logs or both into AWS Cloudwatch.
2. Monitoring thunder adc metrics or logs or both into Azure Application Insight and Log Analytics Workspace.
3. Monitoring thunder adc metrics or logs or both into VMware vRealize Operations and Log Insight.
4. Monitoring thunder adc metrics or logs or both into Splunk Console.
5. Monitoring thunder adc metrics or logs or both into ElasticSearch/Kibana Console.
6. Monitoring thunder adc metrics or logs or both into Prometheus/Grafana Console using PushGateway.


Links:
License				: https://www.a10networks.com/wp-content/uploads/EULA_Thunder_Observability_Agent.pdf
Open Source (Notice)            : https://github.com/a10networks/thunder-observability-agent/tree/release/v2.0.0/OPEN-SOURCE-DISCLAIMER.pdf
Documentation		        : https://documentation.a10networks.com/docs/Install/Software/thunder-observability-agent/
Repository			: https://github.com/a10networks/thunder-observability-agent/tree/release/v2.0.0
Example				: https://github.com/a10networks/thunder-observability-agent/tree/release/v2.0.0/examples
Package: thunderpath
thunderpathProbabilistic modeling framework to define, experiment with, and critique models in service of iterating through Box's loop.Documentation:https://cameronraysmith.github.io/thunderpath/Source Code:https://github.com/cameronraysmith/thunderpathUsagethunderpathis pre-development. Please see the document outlining thespecification proposal.Installationpython -m pip install "thunderpath @ git+https://github.com/cameronraysmith/thunderpath.git@main"DevelopmentSetup environmentWe usehatchto manage the development environment and production build. Ensure it's installed on your system. It is often convenient to do this withpipx.Run unit testsYou can run all the tests with:hatchruntestFormat the codeExecute the following command to apply linting and check typing:hatchrunlintPublish a new versionYou can check the current version with:hatchversionYou can bump the version, create a commit and associated tag with one command such ashatch version patchorminorormajor. Your git default text editor will open so you can add information about the release.When you push the tag on github, the workflow will automatically publish it on PyPI and a github release will be created as draft.Serve the documentationYou can serve the mkdocs documentation with:hatchrundocs-serveIt'll automatically watch for changes in your code.LicenseThis project is licensed under the terms of the GNU Affero 3.0-only license.
Package: thunder-remote
Thunder-RemoteInstallInstall through pypi:pip install thunder-remoteAfter the setup is complete run the following command to patch the inputs library for non-blocking controller input.
Otherwise the library blocks until there is an input from the controller.python -m thunder_remote --patchOr clone this repo:git clone https://github.com/Schrotty/thunder-remote
cd thunder-remote
python setup.py installUsageFor examples see theexamples/directory.LicenseThunder-Remote is licensed under the MIT-License.The 3rd-party module licenses can be found inLICENSE-3RD-PARTY.md
Package: thunders
Thunders迅雷非官方批量下载SDK。感谢使用。版本记录0.1.6: 新增"完整实例"0.1.5: 修复Windows下批量任务启动失效的问题0.1.3: 新增版本记录0.1.2: 更新ReadMe新增obj.dump，为了简洁、美观，无需再调用__repr__新增"获取批量任务中的子任务"示例新增"内存中获取URL Scheme"示例0.1.1: 更新ReadMe新增"创建批量自定义任务"示例快速入门创建批量自定义任务fromthundersimportTask,GroupTaskgroup_task=GroupTask(name="test")group_task.append(Task("https://ahamega.com/1.mp4"))group_task.append(Task("https://ahamega.com/2.mp4",name="自定义重命名2.mp4"))group_task.run()# 执行完后，迅雷会打开并弹出上面创建的批量任务，点击下载即可# 也可以这么用group_task.extend([Task("https://ahamega.com/1.mp4"),Task("https://ahamega.com/2.mp4",name="自定义重命名2.mp4")])group_task.run()# 执行完后，迅雷会打开并弹出上面创建的批量任务，点击下载即可获取批量任务中的子任务fortaskingroup_task:print(task.name,task.origin_url,task.url,sep="\n")# 也可以直接索引取出task1=group_task[0]内存中获取URL Schemeurl_scheme=group_task.dump()完整实例importjsonimportrefromleto.core.crawlerimportCrawlerfromthundersimportTask,GroupTaskcrawler=Crawler()task=GroupTask("xxxxxx第1季")defdownload(url,current_no=1):res=crawler.crawl(url)data=json.loads(re.search("xxxxxx",res.text).group())crawler.log.debug(res.text)# 添加至批量任务task.append(Task(**{"name":f"{task.name}-{str(current_no).zfill(2)}.mp4",# 文件（子任务）重命名"url":data["url"],}))next_url=data["next"]ifnotnext_url:returntaskreturndownload(next_url,current_no+1)download("https://xxxxxx.com/xxxxxx/xxxxxx").run()# 执行完后，迅雷将自动打开并弹出生成的批量任务，点击下载即可。
Package: thunder-speech
Thunder speechA Hackable speech recognition library.What to expect from this project:End-to-end speech recognition modelsSimple fine-tuning to new languagesInference support as a first-class featureDeveloper oriented apiWhat it's not:A general-purpose speech toolkitA collection of complex systems that require thousands of gpu-hours and expert knowledge, only focusing on the state-of-the-art resultsQuick usage guideInstallInstall the library from PyPI:pip install thunder-speechLoad the model and train itfromthunder.registryimportload_pretrainedfromthunder.quartznet.compatibilityimportQuartznetCheckpoint# Tab completion works to discover other QuartznetCheckpoint.*module=load_pretrained(QuartznetCheckpoint.QuartzNet5x5LS_En)# It also accepts the string identifiermodule=load_pretrained("QuartzNet5x5LS_En")# Or models from the huggingface hubmodule=load_pretrained("facebook/wav2vec2-large-960h")Export to a pure pytorch model using torchscriptmodule.to_torchscript("model_ready_for_inference.pt")# Optional step: also export audio loading pipelinefromthunder.data.datasetimportAudioFileLoaderloader=AudioFileLoader(sample_rate=16000)scripted_loader=torch.jit.script(loader)scripted_loader.save("audio_loader.pt")Run inference in productionimporttorchimporttorchaudiomodel=torch.jit.load("model_ready_for_inference.pt")loader=torch.jit.load("audio_loader.pt")# Open audioaudio=loader("audio_file.wav")# transcriptions is a list of strings with the captions.transcriptions=model.predict(audio)More quick tipsIf you want to know how to access the raw probabilities and decode manually or fine-tune the models you can access the documentationhere.ContributingThe first step to contribute is to do an editable installation of the library:git clone https://github.com/scart97/thunder-speech.git
cd thunder-speech
poetry install
pre-commit installThen, make sure that everything is working. You can run the test suit, that is based on pytest:RUN_SLOW=1 poetry run pytestHere theRUN_SLOWflag is used to run all the tests, including the ones that might download checkpoints or do small training runs and are marked as slow. If you don't have a CUDA capable gpu, some tests will be unconditionally skipped.InfluencesThis library has heavy influence of the best practices in the pytorch ecosystem.
The original model code, including checkpoints, is based on the NeMo ASR toolkit.
From there also came the inspiration for the fine-tuning and prediction api's.The data loading and processing is loosely based on my experience using fast.ai.
It tries to decouple transforms that happen at the item level from the ones that are efficiently implemented for the whole batch at the GPU.
Also, the idea that default parameters should be great.The overall organization of code and decoupling follows the pytorch-lightning ideals, with self-contained modules that try to reduce the boilerplate necessary.Finally, the transformers library inspired the simple model implementations, with a clear separation in folders containing the specific code that you need to understand each architecture and preprocessing, and their strong test suit.
Package: thunet
THUNET: A simple deep learning framework for scientific and education purpose.Neural networks[1]Layers / Layer-wise opsAddFlattenMultiplySoftmaxFully-connected/DenseSparse evolutionary connectionsLSTMElman-style RNNMax + average poolingDot-product attentionEmbedding layerRestricted Boltzmann machine (w. CD-n training)2D deconvolution (w. padding and stride)2D convolution (w. padding, dilation, and stride)1D convolution (w. padding, dilation, stride, and causality)ModulesBidirectional LSTMResNet-style residual blocks (identity and convolution)WaveNet-style residual blocks with dilated causal convolutionsTransformer-style multi-headed scaled dot product attentionRegularizersDropoutNormalizationBatch normalization (spatial and temporal)Layer normalization (spatial and temporal)OptimizersSGD w/ momentumAdaGradRMSPropAdamLearning Rate SchedulersConstantExponentialNoam/TransformerDlib schedulerWeight InitializersGlorot/Xavier uniform and normalHe/Kaiming uniform and normalStandard and truncated normalLossesCross entropySquared errorBernoulli VAE lossWasserstein loss with gradient penaltyNoise contrastive estimation lossActivationsReLUTanhAffineSigmoidLeaky ReLUELUSELUExponentialHard SigmoidSoftplusModelsBernoulli variational autoencoderWasserstein GAN with gradient penaltyword2vec encoder with skip-gram and CBOW architecturesUtilitiescol2im(MATLAB port)im2col(MATLAB port)conv1Dconv2Ddeconv2DminibatchBERTVanilla BERTSimple BERTREFERENCEOur contribution is implementation of the vanilla BERT and simple BERT.All other codes following the licence claimed by (ddbourgin)[https://github.com/ddbourgin]  in his (Numpy_ML)![https://github.com/ddbourgin/numpy-ml]  project.Release Frequent Asked QuestionsQ: Python2.7:    LookupError: unknown encoding: cp0A: Setting environment in the shell: set PYTHONIOENCODING=UTF-8Product ReleaseSupported Python versions:| Python ||--------|| 2.7    || 3.5    || 3.6    || 3.7    || 3.8    || 3.9    || 3.10   |[1] David Bourgin. Machine learning, in numpy.https://github.com/ddbourgin/numpy-ml.
Package: thunkapi
Introductionthunkapi.py is a python library and command line client for
interacting with thethunk.usweb service.Usagethunk.py can be imported into any python module:import thunkapi

thunkapi.create()
thunkapi.poke(UID, state, payload)
thunkapi.check(uid)There is also a command line client to use:thunk.py UID
thunk.py -x check UID
thunk.py -x check "UID1,UID2,UID3"
thunk.py -x poke -s state -p payload UID
thunk.py -x createHistory0.1.0 (2010-06-02)add basic API access
Package: thunk-dict
thunk-dictDictionaries that enable the lazy evaluation and memoization of callable entries. thunk-dict is meant to serve as a convenient wrapper the lazy evaluation of potentially computationally expensive calls.Use caseBecause Python eagerly evaluates expressions, it is not possible include calls to functions within a dictionary without evaluating those calls first. To mimic lazy evaluation, one may turn to tricks like:dictionary={"key1":computationally_expensive_function}# Call the function later onresult=dictionary["key1"]()or alternatively, if you also wanted to pass in arguments later on,dictionary={"key1":lambda*args,**kwargs:computationally_expensive_function(*args,**kwargs)}# Call the function later onresult=dictionary["key1"]("blah",parameter=100)However, this approach suffers from two issues:It complicates the typing of your dictionaries and its entries and creates boilerplate (as in the second example).Reaccess requires the computationally expensive functions to be called again (i.e. the call isn't memoized)thunk-dict attempts to resolve both of these issues.fromthunk_dictimportThunkDictdictionary=ThunkDict({"key1":computationally_expensive_function})# Get result from call via simple accessresult=dictionary["key1"]# Subsequent accesses use the memoized result.For noncallable entries, thunk-dict works just like a regular dict. thunk-dict also features the same API as regular Python dictionaries, meaning you don't have to sacrifice anything by using its wrapper.FeaturesConvenient thunk-like behavior in dictionariesWorks for any objects that register with dictVery low overheadInstallationFrom PyPipipinstallthunk-dictFrom source distributiongitclonehttps://github.com/kevalii/thunk-dict.gitcdhttps://github.com/kevalii/thunk-dict.git
pipinstall.
Package: thunor
ThunorThunor(pronounced THOO-nor) is a free software platform for managing,
visualizing, and analyzing high throughput screen (HTS) data, which measure
the dose-dependent response of cells to one or more drug(s).
Thunor has a web interface for drag-and-drop upload of cell count data,
automatic calculation of dose response curves, and an interactive
multi-panelled plot system.This repository, Thunor Core, is a Python package which can be used for
standalone analysis or integration into computational pipelines. There
is also a web interface,Thunor Web,
built around this package with added database and multi-user capabilities.ImplementationThunor is written in pure Python and is compatible with Python 3 only.
It makes extensive use ofpandasandplotly.InstallationInstall usingpip:pip install thunorExamples and documentationThe Thunor Core documentation is availableonline,
or you can build it locally for offline use. To do so, clone this git
repository and change into thethunordirectory.To build documentation locally, you'll need a few software dependencies:pip install -r doc/requirements.txtThen, you can build the documentation like so:cd doc
make htmlAfter the build completes, open _build/html/index.html in your web browser.TutorialTo manually work through the tutorial from the documentation above, you can
open the file with Jupyter Notebook:jupyter notebook --NotebookApp.iopub_data_rate_limit=1.0e10 doc/tutorial.ipynbCitationLubbock A.L.R., Harris L.A., Quaranta V., Tyson D.R., Lopez C.F.Thunor: visualization and analysis of high-throughput dose–response datasetsNucleic Acids Research (2021), gkab424.Further help and resourcesSee theThunor websitefor further links,
documentation and related projects.
Package: thursday
ThursdayThursday reduces the time it takes to get up and running withSelenium.InstallationUsepipto installthursdayas follows:pip install thursdayUsage (Examples)Instantiating ChromeDriverfromthursdayimportBy,ChromeDriver,KeysclassWebsite(ChromeDriver):def__init__(self):super().__init__()Finding WebElementsArguments:by — a selenium locator strategycriteria — the search criteria to the locator strategyfoo=self.element_is_present(By.TAG_NAME,"input")bar=self.element_is_clickable(By.XPATH,'//button[text()="bar"]')Getting Field ValuesArguments:field — the name of the field@propertydefemail_address(self):returnself.get_field_value("Email:")Pressing KeysArguments:key — a selenium Keys objectnumber_of_times — the number of times to press the keyself.press_key(Keys.TAB,3)Setting Field ValuesArguments:field — the name of the fieldvalue — the value to set the field todeflogin(self,username,password):self.set_field_value("Username:","foo")self.set_field_value("Password:","bar")ExceptionsSelenium'sElementNotInteractable,StaleElementReference, andTimeoutexceptions can be imported from thursday as follows:fromthursday.exceptionsimportElementNotInteractableException,StaleElementReferenceException,TimeoutExceptionLicenseGNU General Public License (v3 only)
Package: thu-rsvp-dataset
Tsinghua University RSVP Benchmark DatasetThis repo provides Python code for loading publicly-available data fromA Benchmark Dataset for RSVP-Based Brain–Computer Interfacesby Shangen Zhang, Yijun Wang, Lijian Zhang, and Xiaorong Gao. Note that this repo is not affiliated or endorsed by the authors.See the full paper at:https://www.frontiersin.org/articles/10.3389/fnins.2020.568000/fullAbstract:This paper reports on a benchmark dataset acquired with a brain–computer interface (BCI) system based on the rapid serial visual presentation (RSVP) paradigm. The dataset consists of 64-channel electroencephalogram (EEG) data from 64 healthy subjects (sub1,..., sub64) while they performed a target image detection task. For each subject, the data contained two groups ("A" and "B"). Each group contained two blocks, and each block included 40 trials that corresponded to 40 stimulus sequences. Each sequence contained 100 images presented at 10 Hz (10 images per second). The stimulus images were street-view images of two categories: target images with human and non-target images without human. Target images were presented randomly in the stimulus sequence with a probability of 1∼4%. During the stimulus presentation, subjects were asked to search for the target images and ignore the non-target images in a subjective manner. To keep all original information, the dataset was the raw continuous data without any processing. On one hand, the dataset can be used as a benchmark dataset to compare the algorithms for target identification in RSVP-based BCIs. On the other hand, the dataset can be used to design new system diagrams and evaluate their BCI performance without collecting any new data through offline simulation. Furthermore, the dataset also provides high-quality data for characterizing and modeling event-related potentials (ERPs) and steady-state visual evoked potentials (SSVEPs) in RSVP-based BCIs. The dataset is freely available fromhttp://bci.med.tsinghua.edu.cn/download.html.Citation:@article{zhang2020benchmark,
  title={A benchmark dataset for RSVP-based brain--computer interfaces},
  author={Zhang, Shangen and Wang, Yijun and Zhang, Lijian and Gao, Xiaorong},
  journal={Frontiers in Neuroscience},
  pages={1042},
  year={2020},
  publisher={Frontiers}
}SetupInstall from PyPI with:pipinstallthu-rsvp-datasetOr install from github with:gitclonehttps://github.com/nik-sm/thu-rsvp-dataset.gitcdthu-rsvp-dataset
python3-mvenvvenvsourcevenv/bin/activate
venv/bin/pipinstall-Ue.UsageSeeload_dataset.pyfor example usage.