Saravanan666/pypi-org huggingface dataset:
Package: tweet-requester
Tweet RequesterA python package, published under theMIT License. The package is used to retrieve, cache and interact with tweet status data dictionaries utilizing theTwitter API1.1.#RickyRenuncia ProjectThis package was develop for theRickyRenunciaProject Teamfor their indepent capture preservation and description of manifestations and protests through social media as seen at theirscalar book. This library evolved to function as source code for aCase Modulebut may prove useful for other environments.LicenseThis project is released under anMIT License.How To UseThe main purpose of this library is obtaining data from the Twitter API 1.1 based on a list of tweet IDs.TheTSessclass manages communication and caching and is used as a parameter for theTweetAnalyzer,TweetInteractiveClassifierandJsonLInteractiveClassifier.TweetAnalyzerclass manages most of the automatic data extraction from the data dictionary.TweetInteractiveClassifieris based on the TweetAnalyzer but includes functionality directed to interacting with the tweet in an IPython environment.JsonLInteractiveClassifieris an interactive GUI and database manager that allows capturing additional metadata from user interaction...To seet an example of how to use the library, please visit theCases Moduleor try it at [Not yet published].FutureCurrent approach is project specific but we are working on a proposal to design custom interfaces based onYAML/JSONtemplates.TODO:Include mention oftwitter policies.Continue project description.Include example of usage.Suggest using the Case Module.Mention and show IPython interactive appraisal.
Package: tweets2pdf
Tweet archive parserThis is a simple tool to parse Twitter archived JSON files and convert to PDF document file format.AcknowledgementsIsaac KoiForked fromvrruiz/tweet-jsqedjoeDejaVu FontsInstallationInstallPython.Install this package in your current environment using the command below:pipinstalltweets2pdfUpgradeTo update to the latest version of this software:pipinstall--upgradetweets2pdfUsageDownload your Twitter archiveSee: Twitter Help CentreHow to download your Twitter archive. Once you have downloaded your archive, look for thetweets.jsJSON file which contains all your tweets. This code will process that file.Run the scriptThe basic usage is:tweets2pdf-ftweets.js--images-poutput.pdfThe--imagesoption enables the downloading of pictures from Twitter, which will make the processmuch slower.For more details:tweets2pdf--helpDevelopmentContributingPlease seeCONTRIBUTING.mdfor information about participating in this project.Please submit bug reports usingGitHub Issues.Deployment status
Package: tweetsender
tweet-only Twitter CLIWhen to useWhen you want to tweet while codingBut don’t want to be distracted by your friend’s postsInstallationBefore installing, download and install python3. 3.6 or higher is
required. Installation is done withpip installcommand.
Installation tovenvenvironment is recommended.python -m venv myenv
source myenv/bin/activate
pip install tweetsenderCreating a Twitter appBefore posting tweet, you need to create your Twitter app athttps://apps.twitter.com. After creating an app, open “permissions” tab
and select “Read and Write”. You may need to link your phone number to
your Twitter account. Open “Keys and Access Tokens”, and check your
Consumer Key, Consumer Secret, Access Token, and Access Token Secret. Do
not post them online.ConfigIf you use this CLI for the first time, you need to usetweet configand type your API keys. The keys are saved in.tweetsender_config.jsonon your home directory.Usagetweet send||tweet ssend tweettweet configconfig your API keystweet-sset your Twitter API Tokentweet-hshow help
Package: tweetSentimentAnalysis-MP
Tweet Sentiment AnalysisThis is Assignment #10 as a PyPi package.Running Built-In Examplespython-c"import tweetSentimentAnalysis_MP.examples.example1"python-c"import tweetSentimentAnalysis_MP.examples.example2"External Example 1importtweetSentimentAnalysis_MPastsatsa.analyze("./vaccination_tweets.csv")External Example 2fromtweetSentimentAnalysis_MPimportanalyzeanalyze("./vaccination_tweets.csv")
Package: tweetshot
TweetshotTweetshot is a python library to take screenshots of tweets.Quick guideInstallationpip install tweetshotUsageOpen a command line, or a terminal, and run:tweetshot [TWEET-URL]For example, try the following command:tweetshot https://twitter.com/hideo_kojima_en/status/1002107372091817984You should see a new image file calledscreenshot.pngin the directory from where you run the command.
The image should the following one:
Package: tweets-preprocess
Tweets PreprocessorPreprocessor is a preprocessing library for tweet data written in
Python. When building Machine Learning systems based on tweets and text data like twitter sentiment analysis, topic modelling, etc.,
preprocessing is required. This is required because of quality of the data as well as dimensionality reduction purposes.This library makes it easy to clean the tweets so you don't have to write the same helper functions over and over again ever time.FeaturesCurrently supports cleaning :URLsHashtagsMentionsEmojisSmileysLength constraintremove tweets containing few specific keywords like birthday,congratulations,etc..csvand.xlsxfile supportPython 3.9+ on Windows.UsageBasic cleaning:.. code:: python>>># Import Preprocess from your library
>>>from tweets_preprocess import Preprocess
>>>import pandas as pd
>>>import numpy as np

>>># Instantiate a Preprocess object
>>>data = pd.read_excel(r"D:\Ipac_new\My_Python_Lib\tweet_preprocess\sample.xlsx")
>>>data['pre_text'] = ""

>>>rem = ["happy birthday","birthday","congratulations","rip","thank you","congrats","thanks"]  ## sample keywords
>>>length = 35 
>>>p = Preprocess(data,'Text',rem,length)
>>>d = p.process()

>>>data['pre_text'] = pd.Series(d)

>>>d1 = data.loc[data['pre_text']!='']
>>>#save cleaned tweets to csv file
d1.to_csv('pre-data.csv')Example:Raw Tweet: 'Tweet Preprocessor is #awesome 👍https://github.com/anusha-ipac/tweets_preprocess'Cleaned Tweet: 'Preprocessor is'Removed hashtags, emojis, URLs from the raw tweet and returned clean tweet.Removes tweets containing specific keywords.Processing files:Preprocessor currently supports processing.csvand.xlsxformats.InstallationUsing pip:.. code:: bash$ pip install tweets-preprocessUsing manual installation:.. code:: bash$ python setup.py build
$ python setup.py install
Package: tweetstreamer
tweetstreamerA Tweepy streamer to collect tweets from Twitter's Streaming API based on criteria, with an extremely simple APIRequirementsYou will need the following from Twitter:CONSUMER_KEYCONSUMER_SECRETACCESS_KEYACCESS_SECRETFor this you can visithttps://apps.twitter.comto setup the access keysInstallpip install tweetstreamerUsageFor example if you want to listen for tweets about $AAPL stocksfrom tweetstreamer import auth, listen

connection = auth(<CONSUMER_KEY>, <CONSUMER_SECRET>, <ACCESS_KEY>, <ACCESS_SECRET>)
listen(connection, <TRACK>, on_status, on_error, on_timeout, on_disconnect)
Package: tweet-suite
Tweet SuiteThis package, when run, will execute a query every day that collects all tweets from Wales for the past 7 days (if running for the first time), or since the last tweet collected.
It uses Twitter's V2 API.When run it will set up an SQLite3 database in the location specified to the main script which saves tweets, their basic information and their sentiment scores from theVADER sentiment algorithmin a table calledtweets.A table calledplacesthen saves the geo expansion information requested in the query.Finally, a table calledmatchedplacessaves the result of each place matched to a Welsh local authority using an algorithm defined in thetweets/geo.pyfile.AuthorsThis package was written byninadicara,altanner, andleriomaggio.Good to knowAPI TokensThis uses the academic API, so you need an approved account with a bearer token.If you'd like this to work out the box then you'll need to set
the bearer token as an environment variable calledSEARCHTWEETS_BEARER_TOKEN.QueryCurrently the query returns tweets with basic information and requests the geo expansion.If you change the query you'll also need to edit the SQL tables and data entry functions.
These are intweets/database.py, calledcreate_tweets_tables()andadd_tweet_json().DatabaseThe database is SQLite3, for ease and as an alternative to CSV.
The schema for the database can be seen in the setup functions as part of theDatabaseclass intweets/database.py.
There is a foreign key betweenplace_idin thetweetsandmatchedplacestables that link to the primaryidentry in theplacestable.Data statementSource: Office for National Statistics licensed under theOpen Government Licence v.3.0.Contains OS data © Crown copyright and database right 2019.This package usesboundary data of Welsh Local Authorities(seeutils/la_keys.geojson).
Package: tweettr
Tweettr - thin attrdict like wrapper around (a few) Tweet objectsTweettr gives you a convenient attribute interface to (some) tweet objects without any copying overhead.
And if your editor or IDE understands type annotations it let's you do attribute auto completion.It also add a way to provide emoji parsing with a similar interface to.entities.hashtags. :sparkling_heart:So when you receive a json object from the twitter streaming api you can access it in a nicer way:# json blob returned from twitter streaming api{"id":11223344556677889900,"id_str":"11223344556677889900","created_at":"SunFeb1613:16:19+00002020","user":{"id":11223344556677889900,"id_str":"11223344556677889900","screen_name":"AAAAAAAA",# ...},"entities":{"hashtags":[{"indices":[12,21],"text":"MyHashTag"}]},"text":"HelloWorld#MyHashTag","favorite_count":0,"favorited":false,"timestamp_ms":"1500000000000","truncated":false,# ...}becomes:>>>importtweettr>>>tweet=tweettr.Tweet(json_blob)>>>tweet.user.id11223344556677889900>>>tweet.user.screen_name'AAAAAAAA'>>>tweet.emojis# extract emojis like HashTags and Urls...[Emoji(...),Emoji(...)]>>>...# etc, etc...
Package: tweetwatcher
Tweet WatcherA simple graphical user interface for searching and storing tweets in real time.DependenciesPandasOpenpyxlPyQt5Python Twitter ToolsInstallation$python3-mpipinstallgit+git://github.com/sixohsix/twitter.git#twitter
$python3-mpipinstalltweetwatcherAdd to~/.local/bintoPATHif it isn't already.UsageYou will need a Twitter developer account to get the API tokens. You can create thathere.Then just type tweetwatcher on your terminal emulator to open the app.$tweetwatcherOnce you open the app, you will need to fill the fields with the tokens and keys you got before searching for anything.
You can also create acredentialsfile at your user home (~/orC:\Users\username) like this:<access token>
<access token secret>
<consumer key>
<consumer key secret>
<path to database to store tweets>
Package: tweetworks
What is Tweetworks?Tweetworks is a service and site built on top of Twitter allowing a user to create public
and private groups (instead of hashtags) with threaded conversations and more.Tweetworks is a Boston-area startup created by @MikeLangford, and it features a
full-fledged web service API.Using the PackageYou’ll need a Tweetworks account in order to use this API.Obtain a Tweetworks API key:http://www.tweetworks.com/pages/contactRead the Tweetworks API documentation:http://www.tweetworks.com/pages/apiimport tweetworksapi = tweetworks.API(“your api key”)Start calling API methods!That’s the gist of it! For more detailed information, see the
documentation:http://www.ultranurd.net/code/tweetworks/doc.htmlContributingThe easiest way to help out is to interact with the project on github:http://github.com/UltraNurd/tweetworks-py/. If you’re not able to dive
into the code yourself, contact me with suggestions, bugfixes, and the like.
Package: tweety
tweetyTwitter's API is annoying to work with, and has lots of limitations. tweety scrape all the tweets using python and selenium - No API rate limits. No restrictions. Extremely fast.SourceLinkPyPI:https://pypi.org/project/tweety/Repository:https://santhoshse7en.github.io/tweety/Documentation:https://santhoshse7en.github.io/tweety_doc/Average TweetsIt appears you can ask for up to 25 pages around tweets reliably (~1200 tweets)Dependenciesbeautifulsoup4seleniumchromedriver-binaryvaderSentimenttextblobpandasDependencies InstallationUse the package managerpipto install followingpipinstall-rrequirements.txtUsageDownload it by clicking the green download button here on Github. You only need to parse argument specific Twitter keyword.>>>fromtwitter.tweetyimporttweets>>>tweety=tweets('Super Deluxe')Directory of tweetyOutput>>>print("Polarity Scores"+" : "+str(tweety.final_sentiment_scores))ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: tweety-ns
tweetyReverse Engineered Twitter Frontend API.PrerequisitesBefore you begin, ensure you have met the following requirements:Internet ConnectionPython 3.6+httpxopenpyxlInstallation:pipinstalltweety-nsKeep synced with latest fixesPip might not be always updated , so to keep everything synced.pipinstallhttps://github.com/mahrtayyab/tweety/archive/main.zip--upgradeA Quick Example:fromtweetyimportTwitterapp=Twitter("session")# assuming app is authenticated class instanceall_tweets=app.get_tweets("elonmusk")fortweetinall_tweets:print(tweet)[!IMPORTANT]
Even Twitter Web Client has a lot of rate limits now, Abusing tweety can lead toread_onlyTwitter account.Full Documentation and Changelogs arehere
Package: tweetypy
TweetyPy is a direct descendant of the FEX frequency excursion calculator.
Frequency excursion is the first (and only in v1) analysis that TweetyPy is
capable of, but there are plans for adding several additional calculations
starting with trill rate and bandwidth followed by multi-song comparisons for
similarity and eventually clustering and categorizations.The current code is still in an alpha state.  This means it should only be used
for testing and cannot be considered reliable for analyses yet.  Please report
any bugs, but do not be surprised ifthishappens while using the alpha/beta
releases.
Package: tweezepy
TweezepyThis isTweezepy, a Python package for calibrating forces in single-molecule force spectroscopy video-tracking experiments using the power spectral density (PSD) and Allan variance (AV).DocumentationRead the documentation forTweezepy.How to installThe simplest method of installing theTweezepypackage is via thePython Package Index(PyPI). To install from PyPI, you will need to be able to run python from the command line and make sure you havepipavailable.Install from PyPI:pip install tweezepyAn alternative method to installTweezepyis with setuptools.  Clone the repository onto a local machine, then navigate to the directory.Using setuptools:cd path/to/tweezepy

python setup.py installContentsTheTweezepypackage includes the following modules:'smmcalibration' - classes for calibration methods using the PSD and AV'expressions' - functions with closed-form expressions for thermal motion in the PSD and AV'MLE' - classes for maximum likelihood estimation (MLE) and Monte Carlo Markov chain (MCMC) sampling'allanvar' - tools for calculating the AV and equivalent degrees of freedom'simulations' - tools to simulate bead thermal motion
Package: tweezers
TweezersLightweight Python library for scraping data via the Twitter search API.fromtweezersimportTweezersCreate an instance of Tweezers with API credentials# Loading Twitter auth credentials from a local JSON file. Get yours here:# https://developer.twitter.com/en/apps/importjsonimportosfp=os.path.join(os.getcwd(),"credentials.json")withopen(fp)asf:credentials=json.load(f)t=Tweezers(api_key=credentials["api_key"],api_secret_key=credentials["api_secret_key"],access_token=credentials["access_token"],access_token_secret=credentials["access_token_secret"])Perform a searchSearching returns an instance of a classTweezerSearch, which contains various data attributes returned by the Twitter API:s=t.search(search_term="bitcoin",total=1000,result_type="recent")# All the tweet results are returned in a Pandas DataFrame:s.results_df.head()
Package: twelve-step
Twelve-StepA python tool to analyse dependencies of python projects.InstallationThis package requires python3.7 or more.pip3.7installtwelve-step--userExample usagesBy default twelve step generates a DOT graph and prints it in console.To generate a dot filetwelve-stepa_project_path>dependency-graph.dotortwelve-stepa_project_path-odependency-graphTo generate a graph .svg in one commandtwelve-stepa_project_path|dot-Tsvg-odependency-graph.svg
Package: twelve-tone
Twelve-tone matrix to generate dodecaphonic melodies.Following a process created by the composer Arnold Schoenberg, this library
computes a matrix to create twelve-tone serialism melodies which compose each
of the 12 semitones of the chromatic scale with equal importance.Save your compositions to MIDIFree software: BSD licenseInstallationpip install twelve-toneQuick StartYou can quickly generate a random twelve-tone melody with the CLI$ twelve-tone
['C# / Db', 'A# / Bb', 'F', 'D', 'G# / Ab', 'D# / Eb', 'F# / Gb',
    'A', 'C', 'G', 'B', 'E']Or you can use the following methods in a script:>>> from twelve_tone.composer import Composer
>>> c = Composer()
>>> c.compose()
>>> c.get_melody()
['C# / Db', 'A# / Bb', 'F', 'D', 'G# / Ab', 'D# / Eb', 'F# / Gb',
    'A', 'C', 'G', 'B', 'E']After you have composed a matrix of tone rows, you can save the composition to
MIDI:>>> c.compose()
>>> c.save_to_midi(filename='TWELVE_TONE.mid')The new MIDI file will be created in your current working directory. If you do
not specify afilenamefor your file, it will default toexample.mid.Documentationhttps://python-twelve-tone.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.4.2 (2021-03-11)### 0.4.1 (2021-3-11)requirements: added missing dependency click - (#22) - @jgarte0.4.1 (2019-12-31)### 0.4.1 (2019-12-31)composer: matrix should only hold values of type ‘int’ (#20)0.4.0 (2018-7-08)composer: added/fixed column tonerow support0.3.0 (2018-7-04)cli: added random melody generator command0.2.1 (2016-8-27)build: addedmiditimeto setup install requirements0.2.0 (2016-8-27)composer: Added save to MIDI capability0.1.0 (2016-8-20)First release on PyPI.
Package: twentiment
twentiment==========Research project on twitter sentiment analysis using the Naïve BayesClassificator.Installation------------Install from PyPI (soon) or github with::pip install -e git+https://github.com:passy/twentiment.gitUsage-----First, start the twentiment server that loads the data from a JSON file. Asample is available `in the repository <https://github.com/passy/twentiment/blob/623f4064469850b40b50db4707f12a07047f022b/samples/few_tweets.json>`_.::twentiment_server samples/few_tweets.jsonAfter that, you can use ``twentiment_client`` to query the server using thesyntax ``GUESS my tweet to be scored``.Example-------::twentiment> GUESS hello worldOK 0.0twentiment> GUESS This car is amazing.OK 0.5twentiment> GUESS My best friend is great.OK 0.9285714285714286twentiment> GUESS Whatever.OK 0.0twentiment> GUESS This car is horrible.OK -0.5twentiment> GUESS I am not looking forward to my appointment tomorrow.OK -0.9852941176470597Wishlist--------(Ranked by importance)* Have a web-frontend that searches for tweets and rates their sentiment.* Give the server an option to fork the server process into the backgroundand launch a shell like twentiment_client right away.* Restructure the Classifier to allow adaptive retraining, i.e. provide aTRAIN command that adds new samples at runtime.* At the moment, most of the calculations are done at start-up time, soquerying is rather cheap. Could be difficult to find a good balance.* Persistence of the server state. Maybe through redis? Only important withTRAIN functionality.* Add some sort of parallelism to the server, so querying doesn't block.* Add a way of importing live training data from twitter (like fromanalysing emoticons)Motivation----------This is a project report for the Business Intelligence course. To increase thelearning potential, I tried to reuse as little as possible from the excellent`NLTK <http://nltk.org/>`_ project and reimplemented the relevant parts myself.
Package: twentytab-cked
Django CKEd===========A django application that use django-cked as texteditor. It update RichTextField with config parameterFor more informations about django-cked follow this link: https://bitbucket.org/ssbb/django-cked/overview**IMPORTANT! The application is no longer supported. Please do not use it!**CKEditor and elFinder integration for Django Framework.**Provides a ``RichTextField`` and ``CKEditorWidget`` with upload andbrowse support.|CKEditor| |elFinder|Installation------------::pip install twentytab-ckedConfiguration-------------Add ``cked`` to your ``INSTALLED_APPS`` setting.Then set ``ELFINDER_OPTIONS`` in your settings:::ELFINDER_OPTIONS = {## required options'root': os.path.join(PROJECT_ROOT, 'media', 'uploads'),'URL': '/media/uploads/',}And add CKEd URL include to your project ``urls.py`` file:::url(r'^cked/', include('cked.urls')),Settings---------  **CKEDITOR\_OPTIONS**: CKEditor config. Seehttp://docs.ckeditor.com/#!/guide/dev_configuration-  **ELFINDER\_OPTIONS**: elFinder config. Seehttps://github.com/Studio-42/elFinder/wiki/Client-configuration-optionsUsage-----Model field~~~~~~~~~~~::from django.db import modelsfrom cked.fields import RichTextFieldEASY_CKE = {'height': 200,'width':400,'enterMode': 2, #Remove the default <p> tag around text'forcePasteAsPlainText': True,'toolbar': [['Bold', 'Italic', 'Underline', '-','JustifyLeft', 'JustifyCenter', 'JustifyRight','JustifyBlock', '-', 'Link', 'Unlink', '-', 'Source']],}class Entry(models.Model):text = RichTextField(config=EASY_CKE)Widget~~~~~~::from django import formsfrom cked.widgets import CKEditorWidgetclass MyForm(forms.Form):text = forms.CharField(widget=CKEditorWidget)**NOTE**: If you are using custom forms, dont’r forget to include formmedia to your template:::{{ form.media }}.. |CKEditor| image:: https://bitbucket.org/ssbb/django-cked/raw/default/img/ckeditor.jpg.. |elFinder| image:: https://bitbucket.org/ssbb/django-cked/raw/default/img/elfinder.jpg
Package: twentytab-colorful
twentytab-colorful================It's a fork of "django-colorful"**django-colorful** is an extension to the Django web framework that providesdatabase and form color fields (only RGB atm).Written by Simon CharetteInspired by http://djangosnippets.org/snippets/1261/Built with https://github.com/laktek/really-simple-color-pickerUsage-------------In order to use a color field you just have to add it to your model definition:from django.db import modelsfrom colorful.fields import RGBColorFieldclass Tag(models.Model)color = RGBColorField()The extension will take care of providing the custom widget, just make sure youinclude the static files and jQuery >= 1.6.In order to use with django.contrib.staticfiles add 'colorful' toproject's INSTALLED_APPS.