Saravanan666/pypi-org huggingface dataset:
Package: tactigon-speech
Tactigon SpeechThis package add voice command functionalities to the Tactigon Skin using Bluetooth Low Energy. It is based on the Tactigon Gear.ArchitectureTactigon Speech is a class that inherits from the base TSkin class, which can be found in theTactigon Gear.Here's the definition of the architecture.PrerequisitesIn order to use the Tactigon Gear the following prerequisites needs to be observed:Tactigon Gear: >=5.0.3Platforms:Windows 10 (x86-64 CPU with AVX/FMA)macOS >=12.0 (x86-64 CPU with AVX/FMA)Python version: following versions has been used and tested. It is STRONGLY recommended to use these ones depending on platform.Win10: 3.8.10macOS: 3.8.10It is recommended to create a dedicated python virtual environment and install the packages into the virtual environment:python -m venv venvpip install tactigon-speechDepending on your installation (Mac users) you may need to usepython3andpip3instead ofpythonandpiprespectivelyTactigon Gear complete referenceA complete reference to Tactigon Gear and the Tactigon Skin can be found atTactigon GearTactigon Speech examplesFor a list of example you can go toTactigon SDK repository
Package: tactile
Tactile-PythonTactile-Python is a pure Python port oftactile-js, a library for representing, manipulating, and drawing isohedral tilings on the 2D plane.Craig S. Kaplancreatedtactile-jsbased on hisPhD thesis.Seetactile's original README filefor more information on how to use this library.Installpip install tactileDemoSeeexamples/random_tiles_p5.pywhich requiresp5. It will display random tilings in a window.LicenseBSD 3-Clause License, inherited fromtactile-js.Related Libraries and Projectsturning-function: A shape distance metric, hopefully the same as used in"Escherization"(Kaplan & Salesin, 2000)
Package: tactile-map
Tool for making tactile maps out of OpenStreetMap data.Map of crossing for blind or visually impaired3D map of single crossing may be an useful aid during teaching blind people how to move through city.In this case map is made in a laser cutter from by cutting and engraving plywood and later gluing pieces together to make a map.This repository contains code for generating SVG files that can be used to make such map.GenerationMappingIt is likely that shape of road and footway surfaces is not yet mapped for crossing that is interesting for you.But existing editors (especiallyVespucciandJOSM) will make data collection much easier that it would be with starting new project from scratch.There will be collected set of aerial imagery (on open license), roads itself and nearby buildings may be mapped already. All of that should make things easier than starting from scratch.Processing data.Code in this repository downloads and processes from OpenStreetMap areas tagged withbuilding=*andarea:highway=*tags.It gives SVG files as an output.LaserLaser cuts and engraves plywood pieces as instructed by generated SVG files.AssemblyNow it is time for painting cut pieces (in colours suitable for visually impaired, according to my consultation black for roads and yellow for footways, with zebra pattern for crossings is likely to be a good fit).After that map is ready for final assembly by gluing cut pieces.DisclaimerCurrently this software is a work in progress. Not even a single map was made so far, but first prototype should be ready in a near future :)Seehttps://github.com/matkoniecz/map-carver/issuesfor things that are documented as missing.Mentions of use are welcomeIn case that you used this code or it inspired you to do something - feel free to create an issue with photo and/or description of what was produced! It would be nice to have confirmation that publishing it was useful for somebody.Improving documentationPlease create a new issue if you want to use it but current instructions are insufficient, wrong or can be in some way improved!I know that documentation may be far better, but I am not sure what kind of additional documentation would be most useful.SponsorsTheOpenStreetMap foundationwas funding the development of this project in their first round of themicrogrant programin 2020. It was done as part of makingtactile maps based on OpenStreetMap data, for blind or visually impaired children.If anyone else is also interested in supporting this project via funding -let me know(opening a new issue is also OK) :)
Package: tactile-patterns
DisclaimerPattern here are of pre-alpha quality - not tested, never used on actual laser cutter, not validated in actual use, examples are missing, usage instruction is missing, tested only in LightBurn etc etc.All of that will change.Tactile patterns for laser cutterGenerates patterns recognisable by touch, for use in laser-cut materials.Used for example on maps for blind people.Available as tactile_patterns pip package.If you would use it but "pip package" is too scary - please open an issue to let me know how it can be also published in way that makes it useful.ExamplesSquarefrom tactile_patterns_for_laser_cutter.data_format import Rescale
from tactile_patterns_for_laser_cutter.data_format import Point
from tactile_patterns_for_laser_cutter.data_format import Polygon
from tactile_patterns_for_laser_cutter.data_format import Collection
from tactile_patterns_for_laser_cutter.data_format import LinearRing
from tactile_patterns_for_laser_cutter.data_format import pretty_geojson_string


outer = LinearRing([
            Point(x=0, y=0),
            Point(x=1, y=0),
            Point(x=1, y=1),
            Point(x=0, y=1),
            Point(x=0, y=0),
        ])
polygon = Polygon(outer)
collection = Collection([polygon])
print(pretty_geojson_string(collection.to_geojson()))SponsorsTheOpenStreetMap foundationwas funding the development of this project in their first round of themicrogrant programin 2020. It was done as part of makingtactile maps based on OpenStreetMap data, for blind or visually impaired children.If anyone else is also interested in supporting this project via funding -let me know(opening a new issue is also OK) :)
Package: tactis
TACTiS-2: Better, Faster, Simpler Attentional Copulas for Multivariate Time SeriesArjun Ashok, Étienne Marcotte, Valentina Zantedeschi, Nicolas Chapados, Alexandre Drouin (2023).TACTiS-2: Better, Faster, Simpler Attentional Copulas for Multivariate Time Series. (Preprint)We introduce a new model for multivariate probabilistic time series prediction, designed to flexibly address a range of tasks including forecasting, interpolation, and their combinations. Building on copula theory, we propose a simplified objective for the recently-introduced transformer-based attentional copulas (TACTiS), wherein the number of distributional parameters now scales linearly with the number of variables instead of factorially. The new objective requires the introduction of a training curriculum, which goes hand-in-hand with necessary changes to the original architecture. We show that the resulting model has significantly better training dynamics and achieves state-of-the-art performance across diverse real-world forecasting tasks, while maintaining the flexibility of prior work, such as seamless handling of unaligned and unevenly-sampled time series.[Preprint]InstallationYou can install the TACTiS-2 model withpip:pip install tactisAlternatively, theresearchversion installsgluontsandpytorchtsas dependencies which are required to replicate experiments from the paper:pip install tactis[research]Note:tactishas been currently tested with Python 3.10.8.InstructionsWith theresearchversion of the code,train.pycan be used to train the TACTiS-2 model for a specific dataset. The arguments intrain.pycan be used to specify the dataset, the training task (forecasting or interpolation), the hyperparameters of the model and a whole range of other training options.There are notebooks in the that are useful in guiding training and evaluation pipeline setups:random_walk.ipynbdemonstrates TACTiS-2 on a simple low-dimensional random walk dataset, andgluon_fred_md_forecasting.ipynbdemonstrates how to train and evaluate TACTiS-2 on theFRED-MD datasetused in the paper. Note that thegluon_fred_md_forecasting.ipynbnotebook requires GluonTS and PyTorchTS to be installed.NoteFor an implementation of theoriginal version of TACTiS, please seehere.Citing this workPlease use the following Bibtex entry to cite TACTiS-2.@misc{ashok2023tactis2,
      title={TACTiS-2: Better, Faster, Simpler Attentional Copulas for Multivariate Time Series}, 
      author={Arjun Ashok and Étienne Marcotte and Valentina Zantedeschi and Nicolas Chapados and Alexandre Drouin},
      year={2023},
      eprint={2310.01327},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
Package: tactivos-databricks-cicd
Databricks CI/CDForked from Manol Manolov's original databricks-cicd repo to use with tactivos/data-databricks repoThis is a tool for building CI/CD pipelines for Databricks. It is a python package that
works in conjunction with a custom GIT repository (or a simple file structure) to validate
and deploy content to databricks. Currently, it can handle the following content:Workspace- a collection of notebooks written in Scala, Python, R or SQLJobs- list of Databricks jobsClustersInstance PoolsDBFS- an arbitrary collection of files that may be deployed on a Databricks workspaceInstallationpip install tactivos-databricks-cicdRequirementsTo use this tool, you need a source directory structure (preferably as a private GIT repository)
that has the following structure:any_local_folder_or_git_repo/
├── workspace/
│   ├── some_notebooks_subdir
│   │   └── Notebook 1.py
│   ├── Notebook 2.sql
│   ├── Notebook 3.r
│   └── Notebook 4.scala
├── jobs/
│   ├── My first job.json
│   └── Side gig.json
├── clusters/
│   ├── orion.json
│   └── Another cluster.json
├── instance_pools/
│   ├── Pool 1.json
│   └── Pool 2.json
└── dbfs/
    ├── strawbery_jam.jar
    ├── subdir
    │   └── some_other.jar
    ├── some_python.egg
    └── Ice cream.jpegNote:All folder names represent the default and can be configured. This is just a sample.UsageFor the latest options and commands run:cicd -hA sample command could be:cicddeploy\-wsample_12432.7.azuredatabricks.net\-ujohn.smith@domain.com\-tdapi_sample_token_0d5-2\-lp'~/git/my-private-repo'\-tp/blabla\-cDEV.ini\--verboseNote:Paths for windows need to be in double quotesThe default configuration is defined indefault.iniand can be overridden with a
custom ini file using the -c option, usually one config file per target environment. (sample)Create contentNotebooks:Add a notebook to sourceOn the databricks UI go to your notebook.Click onFile -> Export -> Source file.Add that file to theworkspacefolder of this repowithout changing the file name.Jobs:Add a job to sourceGet the source of the job and write it to a file. You need to have theDatabricks CLIandJQinstalled.
For Windows, it is easier to rename thejq-win64.exetojq.exeand place it
inc:\Windows\System32folder. Then on Windows/Linux/MAC:databricks jobs get --job-id 74 | jq .settings > Job_Name.jsonThis downloads the source JSON of the job from the databricks server and pulls only the settings from it,
then writes it in to a file.Note:The file name should be the same as the job name within the json file. Please, avoid spaces
in names.Add that file to thejobsfolderClusters:Add a cluster to sourceGet the source of the cluster and write it to a file.databricks clusters get --cluster-name orion > orion.jsonNote:The file name should be the same as the cluster name within the json file. Please, avoid spaces
in names.Add that file to theclustersfolderInstance pools:Add an instance pool to sourceSimilar to clusters, just useinstance-poolsinstead ofclustersDBFS:Add a file to dbfsJust add a file to the thedbfsfolder.
Package: tacto
TACTO: A Fast, Flexible and Open-source Simulator for High-Resolution Vision-based Tactile SensorsThis package provides a simulator for vision-based tactile sensors, such asDIGIT.
It provides models for the integration with PyBullet, as well as a renderer of touch readings.NOTE: the simulator is not meant to provide a physically accurate dynamics of the contacts (e.g., deformation, friction), but rather relies on existing physics engines.For updates and discussions please join the #TACTO channel at thewww.touch-sensing.orgcommunity.InstallationThe preferred way of installation is through PyPi:pipinstalltactoAlternatively, you can manually clone the repository and install the package using:gitclonehttps://github.com/facebookresearch/tacto.gitcdtacto
pipinstall-e.ContentThis package contain several components:A renderer to simulate readings from vision-based tactile sensors.An API to simulate vision-based tactile sensors in PyBullet.Mesh models and configuration files for theDIGITand Omnitact sensors.UsageAdditional packages (torch,gym,pybulletX) are required to run the following examples.
You can install them bypip install -r requirements/examples.txt.For a basic example on how to use TACTO in conjunction with PyBullet look at [TBD],For an example of how to use just the renderer engine look atexamples/demo_render.py.For advanced examples of how to use the simulator with PyBullet look at theexamples folder.examples/demo_pybullet_digit.py: rendering RGB and Depth readings with aDIGITsensor.examples/demo_pybullet_allegro_hand.py: rendering 4 DIGIT sensors on an Allegro Hand.examples/demo_pybullet_omnitact.py: rendering RGB and Depth readings with aOmniTactsensor.examples/demo_pybullet_grasp.py: mounted on parallel-jaw grippers and grasping objects with different configurations.examples/demo_pybullet_rolling.py: rolling a marble with two DIGIT sensors.examples/demo_pybullet_digit_shadow.py: enable shadow rendering.NOTE: the renderer requires a screen. For rendering headless, use the "EGL" mode with GPU and CUDA driver or "OSMESA" with CPU.
SeePyRenderfor more details.Operating SystemWe recommend to conduct experiments onUbuntu.FormacOS, there exists some visualization problem between pybullet.GUI and pyrender as we know of. Please let us know if it can be resolved, and we will share the information at the repo!LicenseThis project is licensed under MIT license, as found in theLICENSEfile.CitingIf you use this project in your research, please cite:@Article{Wang2020TACTO,author={Wang, Shaoxiong and Lambeta, Mike and Chou, Lambeta and Calandra, Roberto},title={TACTO: A Fast, Flexible and Open-source Simulator for High-Resolution Vision-based Tactile Sensors},journal={Arxiv},year={2020},url={https://arxiv.org/abs/2012.08456},}
Package: tactus-data
TACTUS - data pipelineThreatening activities classification toward users' securityUseful ressourcesWrite a better commit messagePEP 8 – Style Guide for Python CodeInstallationHardware accelerated TorchYou can install torch and torchvisionwith cudavia pip. Get the pip install command fromthe official website.tactus-dataYou can create an editable install of this library (see more) with the following command:python-mpipinstalltactus_dataThe library will be added to your Python's import path and  you will be able to import this package from anywhere usingimporttactus_dataData sourcesnamedescriptionurlhandled in the data pipelineUT-Interaction Dataset​This dataset contains videos of continuous executions of 6 classes of human-human interactions: shake-hands, point, hug, push, kick and punch.https://paperswithcode.com/dataset/ut-interaction✅Surveillance camera fights dataset​This dataset is benefited for developing a fight detection system which is aimed to use in surveillance cameras in public areas such as streets, underground stations and more.https://github.com/seymanurakti/fight-detection-surv-dataset🚫UCF-Crime​It consists of 1900 long and untrimmed real-world surveillance videos, with 13 realistic anomalies including Abuse, Arrest, Arson, Assault, Road Accident, Burglary, Explosion, Fighting, Robbery, Shooting, Stealing, Shoplifting, and Vandalism. These anomalies are selected because they have a significant impact on public safety.​https://paperswithcode.com/dataset/ucf-crime🚫Weapon detection dataset​This dataset contains various categories of knives, guns, and other weapons with their annotations​https://github.com/ari-dasci/OD-WeaponDetection🚫Anomaly Detection Dataset​This dataset contains training and test videos for abuse detection​https://www.dropbox.com/sh/75v5ehq4cdg5g5g/AABvnJSwZI7zXb8_myBA0CLHa?dl=0🚫Hockey Fight Detection Dataset​It’s a video database containing 1000 sequences divided in two groups: fights and non-fights​https://paperswithcode.com/dataset/hockey-fight-detection-dataset🚫Real life violence situation datasetThis dataset contains about 1000 videos of real street fights as well as non-fights.​https://www.kaggle.com/datasets/mohamedmustafa/real-life-violence-situations-dataset🚫
Package: tacty
TactyAn extensible command bus for Python 3 inspired by theTacticianProject.IntroductionAcommand busis a software component that performs operations in which the data and the execution steps are decoupled. The data for the operation is contained in aCommandobject and the execution steps are contained in aHandler. The responsibility of the command bus is matching a Command with its Handler and execute it.Tactyis a library that provides a command bus implementation that is extensbile and easy to use.Basic Usage# A Command class containing the required data for the operation is defined.classPrintNumberCommand:def__init__(self,number):self.number=number# A Handler class that receives an instance of the command and contains the execution steps is defined.classPrintNumberHandler(Handler):defhandle(self,command:PrintNumberCommand):print(command.number)# An instance of the Command is passed to the command bus for its execution.command=PrintNumberCommand(300)command_bus.handle(command)Initialization# A Resolver is a class that given a Command returns its Handler. The InMemoryResolver receives pairs of Command and Handlers keeping them connected in memory.resolver=InMemoryResolver()resolver.add_handler(PrintNumberCommand,PrintNumberHandler())# The CommandHandlerMiddleware uses a resolver to match a Command with its Handler and executes it.command_handler_middleware=CommandHandlerMiddleware(resolver)# The CommandBus receives a list of middlewares that are executed when processing a Command. In order to fulfill its minimum functionality (executing a Handler given a Command) an instance of the CommandHandlerMiddleware must be passed as the last element.command_bus=CommandBus([command_handler_middleware])ExamplesFind next some examples using Tacty:Using Tacty with the in memory resolverUsing Tacty with a custom middlewareUsing Tacty with a Handler that retuns a value
Package: tada
This python module is a wrapper module for any DBAPI 2 compatible database
module. It wraps all functions and methods of the origional module and forces
the return of deferreds instead. tada can therefore be considered to be ‘almost’
DBAPI compatible as it inherits the compatiblity level of the wrapped module,
but returns twisted deferreds.
tadah - is an additional class: “Tada with Helpers”. This class adds some helper
functionality to tada, but breaks strict DBAPI 2 spec.
tao - uses tada and tadah to create an object model for DB access.  It is loosly
based on the SQLObject project’s usage model, but asynchronous.
Package: tadam
TAdamThe Pytorch implementation of TAdam algorithm in：'A decreasing scaling transition scheme from Adam to SGD'https://arxiv.org/abs/2106.06749UsagefromtadamimportTAdam...optimizer=TAdam(model.parameters(),iters=required,lr=1e-3,moment=1/4,up_lr=0.3,low_lr=0.01)#iters(int, required): iterations#	iters = (testSampleSize / batchSize) * epoch##moment(float, optional): transition moment#       moment = transition_iters / iters#set default value: moment=1/4, up_lr=0.3, low_lr=0.01The code will be uploaded as soon as possible
Package: tadasets
TaDAsetsData sets apt for Topological Data Analysis. This project is a part of scikit-tda.MotivationAt SoCG 2018, there was discussion about the need for data sets for two main purposesBenchmarking new algorithmsDemonstrating benefits of TDAData generationWe provide constructors for some synthetic data sets that are popular in development and testing of TDA techniques.TorusKlein BottleSwiss RollSetup and UsageYou can install from Pypipip install tadasetsor from sourcegit clone https://github.com/scikit-tda/tadasets
cd tadasets
pip install -e .Examples of usage isimport tadasets
data = tadasets.sphere(n=1000, r=10)
tadasets.plot3d(data)orimport tadasets
data = tadasets.swiss_roll(n=1000, r=10)
tadasets.plot3d(data)ContributionsThis package is in the very early stages of development. As I think of shapes and data sets, I add them.  If you have ideas, please do suggest them in an issue and submit a pull request! All contributions are welcome.
Package: tado-overseer
tado-overseerLight automation and management for Tado systemsDocumentationFull documentation can be found onRead the Docs.DevelopmentPre-commit hooksThis repo usespre-committo ensure that all code checked in follows proper Python styling guidelines.  The configuration used can be foundhere.TestingThis repo usespytestto define and execute unit tests.  Tests can run using thetestsDocker Compose service:docker-compose run tests
Package: tadpole
Tadpoleflask starter, provide simple flask app start and management,
integration with some useful flask extensions and frequently
used python packages,support restful view, auto restful
sqlalchemy model, auth and permission.InstallationTadpole requiresPython 2.x >= 2.6.Install from PyPI:$ pip install tadpoleUsageBasic usage:$ tadpole init -n PROJECT_NAME -v PROJECT_VERSION -o PROJECT_OWNER -e PROJECT_EMAILWherePROJECT_NAMEis your own project name andPROJECT_VERSIONis your project init version,PROJECT_OWNERis the project owner name andPROJECT_EMAILis email address of this project
（the logging email maybe sendto this address).Licensetadpole is released under the MIT License. See theLICENSEfile for more
details.
Package: tadr
ToR Auto Done ReplierThis is anunofficialprogram and is not officially endorsed by the Transcribers of Reddit; they are in no way involved with this program and are not liable for any matters relating to it. This is developed unofficially, in my capacity as a volunteer, NOT a moderator.Also known as TADR, this program monitors the Reddit inbox of its user and detects comment from the r/TranscribersOfReddit bot notifying them that it could not find their transcription. Upon receiving such a message, TADR checks the parent comment of the message. If that comment is "done", TADR will reply to it with its own automated response, triggering it to look for the transcription again. If the parent comment is TADR's automated reply, it will send a desktop notification to the user to tell them that something is wrong.TADR's documentation is hosted at readthedocs.For emergency contact, I'm reachable throughmurdomaclachlan@duck.com. You can also open an issue on GitHub if needed.