Saravanan666/pypi-org huggingface dataset:
Package: theword
Inspired by Python’simport this,The
Trashmen, andThe
Family Guy,thewordis a quirky library to answer that eternal question, “What’s the word?”InstallationFrom any command line:$pipinstallthewordEmulating the Zen of PythonFrom any command line:$python-c"import theword"_Surfin' Bird_, by The Trashmen

A well a everybody'sheardaboutthebirdBird,bird,bird,b-bird's the word
A well a bird, bird, bird, b-bird'sthewordAwellabird,bird,bird,b-bird's the word
A well a bird, bird, b-bird'sthewordGeneral UsageYou can import any of the following:fromthewordimportTheWord,TheBird,what_is_the_wordAsk the question:>>>what_is_the_word()<theword.theword.TheBirdobjectat0x10f582d90># Returns TheBird>>>what_is_the_word().answer'[E]verybody knows that the bird is the word!'>>>printwhat_is_the_word()# We overloaded __str__{"answer":"[E]verybody knows that the bird is the word!","question":"What's the word?","id":"The Bird"}More quirky fun:>>>what_is_the_word().play()# Turn on the volume, ensure your WiFi is on{'artist':'The Trashmen','title':"Surfin' Bird",'question':"What's the word?",'released':1964,'answer':'[E]verybody knows that the bird is the word!','id':'The Bird'}>>>what_is_the_word().celebrate()# Be prepared to laugh{'answer':'[E]verybody knows that the bird is the word!','celebrated_on':"FOX's The Family Guy",'question':"What's the word?",'id':'The Bird','celebrated_by':'Seth MacFarlane'}>>>If you watch all the skits you will recognize this:Sir, our math shows that the Bird is greater than or equal to the
Word!>>>isinstance(TheBird(),TheWord)True>>>issubclass(TheBird,TheWord)True
Package: thext
THExtTransformer-basedHighlightsExtraction from scientific papers (THExt)Examples and demoAll examples provided below have been extracted using the best-performing model reported in the paper. No manual pre- or post- processing has been applied for highlights extraction. The text of the papers has been parsed from PDF files usingGROBID.Highlights forACL 2021 conference papersavailable here:AI model-CS modelHighlights forJournal of Machine Learning Research (Volume 22)available here:AI model-CS modelPre-trained models will be released after paper revision process.InstallationRun the following to installpipinstallgit+https://github.com/MorenoLaQuatra/THExt.gitpython-mspacydownloaden_core_web_lgUsageUsing pretrained modelsfromthextimportSentenceRankerPlusfromthextimportRedundancyManagerfromthextimportHighlighterbase_model_name="morenolq/thext-cs-scibert"model_name_or_path="morenolq/thext-cs-scibert"sr=SentenceRankerPlus()sr.load_model(base_model_name=base_model_name,model_name_or_path=model_name_or_path)h=Highlighter(sr)# Define a set of sentencessentences=["We propose a new approach, based on Transformer-based encoding, to highlight extraction. To the best of our knowledge, this is the first attempt to use transformer architectures to address automatic highlight generation.","We design a context-aware sentence-level regressor, in which the semantic similarity between candidate sentences and highlights is estimated by also attending the contextual knowledge provided by the other paper sections.","Fig. 2, Fig. 3, Fig. 4 show the effect of varying the number K of selected highlights on the extraction performance. As expected, recall values increase while increasing the number of selected highlights, whereas precision values show an opposite trend.",]abstract="Highlights are short sentences used to annotate scientific papers. They complement the abstract content by conveying the main result findings. To automate the process of paper annotation, highlights extraction aims at extracting from 3 to 5 paper sentences via supervised learning. Existing approaches rely on ad hoc linguistic features, which depend on the analyzed context, and apply recurrent neural networks, which are not effective in learning long-range text dependencies. This paper leverages the attention mechanism adopted in transformer models to improve the accuracy of sentence relevance estimation. Unlike existing approaches, it relies on the end-to-end training of a deep regression model. To attend patterns relevant to highlights content it also enriches sentence encodings with a section-level contextualization. The experimental results, achieved on three different benchmark datasets, show that the designed architecture is able to achieve significant performance improvements compared to the state-of-the-art."num_highlights=1highlights=h.get_highlights_simple(sentences,abstract,rel_w=1.0,pos_w=0.0,red_w=0.0,prefilter=False,NH=num_highlights)fori,hinenumerate(highlights):print(f"{i}\t{h}")Developing THExtTo install THExt, along with the tools you need to develop and run tests, run the following in your virtualenv$pipinstall-e.[dev]
Package: thflask
Flask ApplicationA simple Flask Restful application that is using flask and flask-restful for creating the APIs and uWSGI as web serverRequirementspython >= 3.7pip3.7Install and run1. Github# Download the repository
git clone https://github.com/themisAnagno/th-flask.git
cd th-flask
# Install required modules and binaries
pip install .
# Run the application
thflask2. PyPIInstall from PyPIpip install thflaskCreate theuwsgi.inifile:[uwsgi]
http-socket = :$(PORT)
stats = :$(STATSPORT)
master = true
die-on-term = true
module = thflask.app:app
memory-report = trueRun the application:uwsgi uwsgi.ini
Package: thicc
thiccConvert characters to their fullwidth representationUsage ExamplesPipe in text from standard input$echo"foo"|thcｆｏｏPass a filename argument$thcthatfileｂａｒReverse fullwidth text$thc-r<<<ｂａｚ<<<is not special thicc syntax. It is a shell "herestring". It is one of many ways to pass standard input to a
program on your shell.bazInstallation$pipinstall--upgradethiccReleasingBump the version inthicc/__init__.pyGit commit itmake release
Package: thickbrick
Welcome to ThickBrick!ThickBrick is a Python 3 implementation of certain data selection and categorization algorithms originally conceived in the context of data analysis in high energy physics.The algorithms are intended to train event selectors and categorizers that maximize the sensitivity of physics analyses to the presence of a signal being searched for, or to the value of a parameter being measured.Project website:https://prasanthcakewalk.gitlab.io/thickbrick/References and citation guideIf you use the algorithms implemented in ThickBrick in your work, please consider citing the original papers that introduced them.Konstantin K. Matchev, Prasanth Shyamsundar,"Optimal event selection and categorization in high energy physics, Part 1: Signal discovery",arXiv:1911.12299 [physics.data-an].Parts 2 and 3 to follow.This list does not include the now-mainstream algorithms and ideas from mathematics, statistics, machine learning, etc, used in the package. The package documentation mentions the methods used where appropriate.CopyrightCopyright © 2019 Konstantin Matchev and Prasanth ShyamsundarThickBrick is licensed under the MIT License (click to expand).Permission 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: thickforest_sample2
A sample project that exists as an aid to thePython Packaging User Guide’sTutorial on Packaging and Distributing
Projects.This projects does not aim to cover best practices for Python project
development as a whole. For example, it does not provide guidance or tool
recommendations for version control, documentation, or testing.This is the README file for the project.The file should use UTF-8 encoding and be written usingreStructuredText. It
will be used to generate the project webpage on PyPI and will be displayed as
the project homepage on common code-hosting services, and should be written for
that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not
a good idea, although a simple “What’s New” section for the most recent version
may be appropriate.
Package: thickly
LocustLocust is an easy to use, scriptable and scalable performance testing tool. You define the behaviour of your users in regular Python code, instead of using a clunky UI or domain specific language. This makes Locust infinitely expandable and very developer friendly.FeaturesWrite user test scenarios in plain-old PythonIf you want your users to loop, perform some conditional behaviour or do some calculations, you just use the regular programming constructs provided by Python. Locust runs every user inside its own greenlet (a lightweight process/coroutine). This enables you to write your tests like normal (blocking) Python code instead of having to use callbacks or some other mechanism. Because your scenarios are “just python” you can use your regular IDE, and version control your tests as regular code (as opposed to some other tools that use XML or binary formats)fromlocustimportHttpUser,task,betweenclassQuickstartUser(HttpUser):wait_time=between(1,2)defon_start(self):self.client.post("/login",json={"username":"foo","password":"bar"})@taskdefindex_page(self):self.client.get("/hello")self.client.get("/world")@task(3)defview_item(self):foritem_idinrange(10):self.client.get(f"/item?id={item_id}",name="/item")Distributed & Scalable - supports hundreds of thousands of usersLocust makes it easy to run load tests distributed over multiple machines. It is event-based (usinggevent), which makes it possible for a single process to handle many thousands concurrent users. While there may be other tools that are capable of doing more requests per second on a given hardware, the low overhead of each Locust user makes it very suitable for testing highly concurrent workloads.Web-based UILocust has a user friendly web interface that shows the progress of your test in real-time. You can even change the load while the test is running. It can also be run without the UI, making it easy to use for CI/CD testing.Can test any systemEven though Locust primarily works with web sites/services, it can be used to test almost any system or protocol. Justwrite a clientfor what you want to test, orexplore some created by the community.HackableLocust is small and very flexible and we intend to keep it that way. If you want tosend reporting data to that database & graphing system you like, wrap calls to a REST API to handle the particulars of your system or run atotally custom load pattern, there is nothing stopping you!LinksWebsite:locust.ioDocumentation:docs.locust.ioCode/issues:GithubSupport/Questions:StackOverflowChat/discussion:Slack signupAuthorsCarl Bystr(@cgbystromon Twitter)Jonatan Heyman(@jonatanheymanon Twitter)Joakim Hamrén(@Jahaajaon Twitter)Hugo Heyman(@hugoheymanon Twitter)Lars HolmbergLicenseOpen source licensed under the MIT license (seeLICENSEfile for details).
Package: thief-snapshot
Detects motion with a camera and sends snapshots using a telegram
chatbot if your phone is not on wifi.RequirementsAmcrest CameraDD-WRT RouterTelegram API Key & Chat IDInstallationInstall the package:$ pip install thief_snapshot[amcrest]Generate a settings file:$ thief_snapshot_generate_settingsEdit the generated settings.ini and fill in your own settings.Usage$ thief_snapshot settings.iniTODOAdd support for more cameras types.Add support for more presence detection types.Add more notification systems and make telegram notifications
optional.CreditThe ddwrt presence detection code was mostly copied from home-assistant.
Package: thieves
thievesThieves is a concurrent, thread-safe Google Drive uploader library.UsageThieves uses pydrive which requires credentials from a Cloud Platform project. You can create one by clicking 'Enable the Drive API' here:https://developers.google.com/drive/api/v3/quickstart/python. Then save the file 'credentials.json' and rename it to 'client_secrets.json'. Now you can start writing code!First, create a Thief. A Thief is a concurrent, thread-safe uploader that will upload all files in a folder it is given.importthievesfolder=Thief(<path>)Now that you have created a Thief, you have to authenticate with Google Drive.folder=Thief(<path>)folder.auth()The first time you authenticate it will open in a web browser and allow your Cloud Platform project to connect. Afterwards, Thieves will automatically save your credentials to a file and will refer to those instead.folder=Thief(<path>)folder.auth()folder.upload()Now that you have authenticated you can upload the folder.
Package: thinc-apple-ops
thinc-apple-opsMakespaCyandThincup to 8 × fasteron macOS by calling into Apple's native libraries.⏳ InstallMake sure you haveXcodeinstalled and
then install withpip:pipinstallthinc-apple-ops🏫 MotivationMatrix multiplication is one of the primary operations in machine learning.
Since matrix multiplication is computationally expensive, using a fast matrix
multiplication implementation can speed up training and prediction
significantly.Most linear algebra libraries provide matrix multiplication in the form of the
standardizedBLASgemmfunctions. The work behind scences is done by a set of matrix multiplication
kernels that are meticulously tuned for specific architectures. Matrix
multiplication kernels use architecture-specificSIMDinstructions for data-level parallism
and can take factors such as cache sizes and intstruction latency into account.Thincuses theBLISlinear algebra library, which provides
optimized matrix multiplication kernels for most x86_64 and some ARM CPUs.RecentApple SiliconCPUs, such
as theM-seriesused in
Macs, differ from traditional x86_64 and ARM CPUs in that they have a separate
matrix co-processor(s) called AMX. Since AMX is not well-documented, it is
unclear how many AMX units Apple M CPUs have. It is certain that the (single)
performance cluster of the M1 has an AMX unit and there isempirical
evidencethat
both performance clusters of the M1 Pro/Max have an AMX unit.Even though AMX units use a set ofundocumented
instructions,
the units can be used through Apple'sAcceleratelinear
algebra library. Since Accelerate implements the BLAS interface, it can be used
as a replacement of the BLIS library that is used by Thinc. This is where thethinc-apple-opspackage comes in.thinc-apple-opsextends the default Thinc
ops, so thatgemmmatrix multiplication from Accelerate is used in place of
the BLIS implementation ofgemm. As a result, matrix multiplication in Thinc
is performed on the fast AMX unit(s).⏱ BenchmarksUsingthinc-apple-opsleads to large speedups in prediction and training on
Apple Silicon Macs, as shown by the benchmarks below.PredictionThis first benchmark compares prediction speed of thede_core_news_lgspaCy
model between the M1 with and withoutthinc-apple-ops. Results for an Intel
Mac Mini and AMD Ryzen 5900X are also provided for comparison. Results are in
words per second. In this prediction benchmark, usingthinc-apple-opsimproves
performance by4.3times.CPUBLISthinc-apple-opsPackage power (Watt)Mac Mini (M1)6492276765MacBook Air Core i5 20209790109839Mac Mini Core i7 Late 2018163641485831AMD Ryzen 5900X22568N/A52TrainingIn the second benchmark, we compare the training speed of thede_core_news_lgspaCy model (without NER). The results are in training iterations per second.
Usingthinc-apple-opsimproves training time by3.0times.CPUBLISthinc-apple-opsPackage power (Watt)Mac Mini M1 20203.3410.075MacBook Air Core i5 20203.103.2710Mac Mini Core i7 Late 20184.714.9332AMD Ryzen 5900X6.53N/A53
Package: thindf
Usage:thindf.to_thindf(object, indent = 4)Returns string in thindf corresponding to a given object.thindf.parse(str)Converts string in thindf into object.Использование:thindf.to_thindf(object, indent = 4)Возвращает строку в формате thindf соответствующую переданному объекту.thindf.parse(str)Конвертирует строку в формате thindf в объект.
Package: thingdl
thingdlThingiverse is a wonderful place for makers to share their works with the world.However, when makers upload their parts, often they are uploaded in many different pieces, each of which requires a separate download.thingdl is a command line tool that is aimed to simplify that. With a single command, you can download all files related to a given thingInstallationpip3 install thingdlNext, find the thing you wish to download.Click on the "download all files" link, and copy the url
(it will end in /files)Now the base url and the/filesurl are compatible!From a terminal or command prompt:thingdl -u <yourthingurl/files> -d <your destination directory>in a few moments, it will download all the files from that thing into your specified directory.
Package: thingdom
What is Thingdom?Thingdomallows you to mobile-enable your product in four lines of code with no need
to develop the iOS and Android apps or create scalable cloud infrastructure.Get Started Now!.Installationpip install thingdomIdeas for Module UsageProgrammatically trigger push notifications, feed messages, and real-time status updates from your Python app.Remotely monitor any interaction with your Python application.With our quick drop-in integration and simple API calls you can mobile-enable your Python application in a matter of hours, even customizing the mobile experience for your end-users.Getting Startedfrom thingdom import Thingdom

# instantiate Thingdom object and authenticate
thingdom = Thingdom( 'YOUR_API_SECRET' )

# look-up Thing and get back object
thing = thingdom.get_thing( 'YOUR_THING_NAME' )

# send a feed message
thing.feed( 'FEED_CATEGORY', 'MESSAGE' )

# send a status update
thing.status( 'KEY', 'VALUE' )
Package: thingflow
ThingFlow is a (Python3) framework for building IOT event processing
dataflows. The goal of this framework is to support the
creation of robust IoT systems from reusable components. These systems must
account for noisy/missing sensor data, distributed computation, and the
need for local (near the data source) processing.ThingFlow is pure Python (3.4 or later). The packaged distribution
(e.g. on PyPi) only includes the core Python code. The source repository athttps://github.com/mpi-sws-rse/thingflow-pythoncontains the core Python
code plus the documentation, examples, and tests. There is also a port
of ThingFlow for micropython available in the source repo.
Package: thingsboard-gateway
ThingsBoard IoT GatewayThe ThingsboardIoT Gatewayis an open-source solution that allows you to integrate devices connected to legacy and third-party systems with Thingsboard.Thingsboard is an open-source IoT platform for data collection, processing, visualization, and device management. SeeWhat is Thingsboard?if you are new platform user.What is ThingsBoard IoT Gateway?Getting started with ThingsBoard IoT GatewayGateway featuresThingsboard IoT Gateway provides following features:OPC-UAconnectorto collect data from devices that are connected to OPC-UA servers.MQTTconnectorto collect data that is published to external MQTT brokers.Modbusconnectorto collect data from Modbus servers and slaves.BLEconnectorto collect data from BLE devices.Requestconnectorto collect data from HTTP API.RESTconnectorto collect data using REST API.CANconnectorto collect data using CAN protocol.BACnetconnectorto collect data from devices using BACnet protocol.SNMPconnectorto collect data from SNMP managers objects.ODBCconnectorto collect data from ODBC databases.FTPconnectorto collect data from files via FTP.Socketconnectorto collect data from devices using sockets.XMPPconnector to collect data from XMPP devices.Customconnectorto collect data from custom protocols.Persistenceof collected data to guarantee data delivery in case of network and hardware failures.Automatic reconnectto Thingsboard cluster.Simple yet powerfulmappingof incoming data and messagesto unified format.Remote logging featureto monitor the gateway status through the ThingsBoard WEB interface.RPC gateway methodsto control and get information from the gateway through ThingsBoard WEB interface.Remote shellto control operating system with ThingsBoard IoT Gateway from your ThingsBoard platform instance.Device renaming/removing handlingto keep the device list in actual state.Gateway Configuratoreasy-to-use CLI configurator.HOT Reloadfor developers.ArchitectureThe IoT Gateway is built on top ofPython, however is different from similar projects that leverage OSGi technology.
The idea is distantly similar to microservices architecture.The gateway supports custom connectors to connect to new devices or servers and custom converters for processing data from devices.Especially, when we are talking about language APIs and existing libraries to work with serial ports, GPIOs, I2C, and new modules and sensors that are released every day.The Gateway provides simple integration APIs, and encapsulates common Thingsboard related tasks: device provisioning, local data persistence and delivery, message converters and other.For processing data from devices you also can write custom converter, it will receive information from device and send it to converter to convert to unified format before sending it to the ThingsBoard cluster.SupportCommunity chatQ&A forumStackoverflowDon't forget to star the repository to show your ❤️ and support.LicensesThis project is released underApache 2.0 License.
Package: thingsboard-micropython
ThingsBoard MQTT MicroPython clientThis project is a MicroPython library that provides an client for theDeviceAPI ofThingsBoardopen-source IoT Platform.The library consists of a thin wrapper around the MicroPython MQTT module,umqtt.robust.InstallationTo install using pip:importupipupip.install('thingsboard-micropython')Getting StartedClient initialization and telemetry publishing:fromuthingsboard.clientimportTBDeviceMqttClient# See examples for more authentication optionsclient=TBDeviceMqttClient('demo.thingsboard.io',access_token='test01')# Connecting to ThingsBoardclient.connect()# Sending telemetrytelemetry={'temperature':41.9,'enabled':False}client.send_telemetry(telemetry)# Checking for incoming subscriptions or RPC call requests (non-blocking)client.check_msg()# Disconnecting from ThingsBoardclient.disconnect()ExamplesMore examples can be found inexamplesdirectory.SupportSSL and QoS (0 or 1) as supported by the backend MQTT library,umqtt.robust.AllDeviceAPI's, except Provisioning.Tested only on ESP32 board running MicroPython v1.16 generic.AcknowledgmentThis library is an adapted version of the officialThingsBoard client SDK for Python,
to run in MicroPython.LicenseThis project is released underApache 2.0 License.
Package: thingscli
Overview - ThingsStatsA command line tool forThings. The tool has a functionality to add checklist items to a daily todo (things add) and interactive reporting to explore incomplete tasks (things report).How To UseInstall with:pip install thingscliTypethingsto see a list of commands. Currently support add and report.Typethings reportto access the interactive reporting functionality.CommandsaddAdd is a command that creates a daily todo and can add checklist items to it. For example,things add 'hello'will create a todo of the format "weekday mm/dd/yyyy" and a checklist item with the title 'hello'. Currently it will only do this if there is a project titled 'Daily Tracker'.Personally, I use this to support my own workflow of adding tasks as they come up to a daily todo.Example coming soon.reportReport is an interactive tool that presents the user with different information on their things usage.Example coming soon.