Saravanan666/pypi-org huggingface dataset:
Package: twopasswords
TwoPasswordsTwoPasswords is a simple Python password manager, that uses Face Recognition as a second factor.
It allows you to securely save account credentials with a simple TUI interface.FeaturesAccount credentials stored locally in an encrypted SQLite database withSQLCipherPasswords can be passed to ClipboardPasswords can be generated inXKCD styleImport and Export in JSONBasic UsageTo start using TwoPasswords, you have to register your face and enter your new Master Password.Installation notesTwoPasswords requirescmaketo be installed on your machine.pip3installcmakeTwoPasswords requiressqlcipherto be installed on your machine.On MacOS, you can install it withbrew:brewinstallsqlcipher
pip3installsqlcipher3==0.4.5# If you are getting an error "Failed to build sqlcipher3", you would need to fix the build flags:SQLCIPHER_PATH="$(brew--cellarsqlcipher)/$(brewlist--versionssqlcipher|tr' ''\n'|tail-1)"C_INCLUDE_PATH=$SQLCIPHER_PATH/includeLIBRARY_PATH=$SQLCIPHER_PATH/libpip3installsqlcipher3==0.4.5Also you need to install latest ffmpeg library for a latest OpenCV versionbrewinstallffmpegInstalling via PyPIpip3installtwopasswords# Run setuptwopasswordsInstalling via cloning this project# Clone projectgitclonehttps://github.com/gennadis/twopasswords.gitcdtwopasswords# Installationpython3setup.pyinstall# Run setuptwopasswords
Package: two-phase
Two-phase flowThetwo-phaseflow is a Python library that implements two-phase flows models and make easy to get the flow properties such as flow pattern, elongated bubble velocity, homogenous model properties etc. This library is structured in a way that the user can program using a simple and easy-to-use objects or in a more advanced manner can use the functions of the library directly.The fluid properties are by default automatically obtained from theCoolProp. However, you can also pass your own functions, determined experimentally or from any source you want.The library has also some basic plot utils for some flow pattern maps.InstallationUse the package managerpipto installtwo-phaseflow package.pipinstalltwo-phaseUsagefromtwo_phaseimportTwoPhaseimportpandasaspd# Load your experimental datadf=pd.read_excel("table_exp_points.xlsx")# Configure your experimental setup in SI unitstp=TwoPhase(d=0.0525,l=8.1,theta=90,gas="air",liquid="water")# Set the liquid and gas superficial velocitiestp.v_sl=df["V_sl (m/s)"].valuestp.v_sg=df["V_sg (m/s)"].values# Set the pressure and temperaturetp.P=df["PT-101 (kPa)"].values*1e3+101.325*1e3tp.T=df["TT-101 (C)"].values# Get flow Pattern of each experimental pointptt=tp.ptt.taitel1980(text=True)# Get the elongated bubble velocity for each experimental pointv_tb=tp.eb_vel.ebmodels()v_tb_nicklin=tp.eb_vel.nicklin1962()# Get volumetric flow-rateq_l=tp.Q_lq_g=tp.Q_g# Get experimental propertiesP_0=tp.P[0]# PressureT_0=tp.T[0]# Temperatureq_g0=tp.Q_g[0]# Gas flow ratev_sg0=tp.v_sg[0]# Gas superficial velocityRoadmapCoolProp integrationHomogeneous modelElongated bubble modelsTaitel 1980 - flow pattern map for vertical flows (being developed)Flow pattern map for horizontal flowsLockhart Martinelli modelAlves Anular Flow modelTaitel and Barnea modelDrift modelBeggs and Brill modelHagedorn Brown modelBlack oil modelContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change or add.When contributing, please use theblackcode formatter as it formats the code to looks the  same regardless of the project you are reading.Please make sure to update tests as appropriate.Credits@felipecastrotcLicenseGPLv3
Package: tworavens-preprocess
TwoRavens PreprocessPython package to produce TwoRavens metadata:https://pypi.org/project/tworavens-preprocess/pip install tworavens-preprocessPreprocess a data fileOpen a python shellfrom raven_preprocess.preprocess_runner import PreprocessRunner

# process a data file
#
run_info = PreprocessRunner.load_from_file('input/path/my-data-file.csv')

# Did it work?
#
if not run_info.success:
    # nope :(
    #
    print(run_info.err_msg)
else:
    # yes :)
    #
    runner = run_info.result_obj

    # show the JSON (string)
    #
    print(runner.get_final_json(indent=4))

    # retrieve the data as a python OrderedDict
    #
    metadata = runner.get_final_dict()

    # iterate through the variables
    #
    for vkey, vinfo in metadata['variables'].items():
        print('-' * 40)
        print(f'--- {vkey} ---')
        print('nature:', vinfo['nature'])
        print('invalidCount:', vinfo['invalidCount'])
        print('validCount:', vinfo['validCount'])
        print('uniqueCount:', vinfo['uniqueCount'])
        print('median:', vinfo['median'])
        print('etc...')Preprocess a single file: output to screen or file# -------------------------
# Preprocess a single file,
# Write output to screen
# -------------------------
from raven_preprocess.preprocess import run_preprocess
run_preprocess('path-to-input-file.csv')

# -------------------------
# Preprocess a single file,
# Write output to file
# -------------------------
from raven_preprocess.preprocess import run_preprocess
run_preprocess('path-to-input-file.csv', 'path-to-OUTPUT-file.csv')
Package: tworg
tworgThis is a small program to convertTiddlyWikitiddler (*.tid) files intoOrg Modefiles.This is not at all production-ready and was written as a one-off thing to convert my TiddlyWiki into a set of org files. As such, it makes a few assumptions:The only metadata it preserves in the org files areTITLE,AUTHOR, andTAGS.It replaces links to other tiddlers with Org-roam links. Thus, it assumes you are usingOrg-roam.Definitely not 100% coverage of the TiddlyWiki markup syntax.Usageusage:tworg[-h][-oOUTPUT]tiddler[tiddler...]Convert.tidTiddlyWikifilesintoOrgModefiles.

positionalarguments:tiddlerTiddlerstoconvert

optionalarguments:-h,--helpshowthishelpmessageandexit-oOUTPUT,--outputOUTPUTDirectorytowriteorgfilestoExample, converting all TiddlyWiki files in~/tiddlywiki/to Org Mode files in~/org/:tworg-o~/org/~/tiddlywiki/*.tid
Package: twork
twork=====twork is a Tornado Application FrameWork, it supports plug-in moduleinjection, the module called TworkApp.Features--------Plug-in~~~~~~~+ TworkApp as a plug-in injected to TworkWeb App Framework~~~~~~~~~~~~~~~~~+ Control(WebApplication)/Model(RequestHandler) separation, userssimply writing Handler Model+ Web RequestHandler should be Inherited fromtwork.web.action.base.BaseHandlerUnified Infrastructure~~~~~~~~~~~~~~~~~~~~~~+ Web access logging+ Status statistics+ Overload protection+ IP checking+ OthersOpen Design~~~~~~~~~~~+ Not only for web application framework+ Can be directly embedded other control model, like that the customprotol server-app+ Custom Logging SupportScaffold Support~~~~~~~~~~~~~~~~+ Build your own Tornado Application+ As a app module injected to tworkEasy Maintainable~~~~~~~~~~~~~~~~~+ Script Tools: log cut, log reopen, tworkd kill and others+ Consistent process name: twork::hello/1.0.0.0Usage-----Environment~~~~~~~~~~~virtualenv is recommend.+ `virtualenv <http://www.virtualenv.org/en/latest>`_ is a tool to create isolated Python environments+ Initialize and enter the app virtualenv+ For example, creating the hello application hereInstall twork~~~~~~~~~~~~~+ pip install `twork <https://pypi.python.org/pypi/twork>`_+ easy_install `twork <https://pypi.python.org/simple/twork>`_TworkApp Build~~~~~~~~~~~~~~Create your own tornado application based on twork.+ twork-admin -app=hello -prefix=~/workspace+ cd ~/workspaceWeb Handler(Optional)`````````````````````+ write your web request handler in hello/hello/web/action directory,the handler should be Inherited from twork.web.action.base.BaseHandler+ add uri:handler map to HANDLERS in hello/hello/app.pyRun TworkApp within twork~~~~~~~~~~~~~~~~~~~~~~~~~+ make install+ tworkd -app_module=hello.app OR tworkd -config_file=conf/twork.confAccess the web server~~~~~~~~~~~~~~~~~~~~+ http://localhost:8000/v1.0/hello/stats+ http://localhost:8000/v1.0/twork/statsCheck Htpp Response~~~~~~~~~~~~~~~~~~~~+ Server: TWS/2.0.0.5+ TworkApp: HELLO/1.0.0.0Requirements------------The following libraries are required+ tornado==4.2.1+ setproctitle==1.1.8+ nose==1.3.3Issues------Please report any issues via `github issues <https://github.com/bufferx/twork/issues>`_
Package: two-sample-binomial
TwoSamplesBinomial: Two-sample testing for counts dataUsually in the context of a multiple testing approach to compare two or more
frequency tables.References:[1] D. L. Donoho and A. Kipnis. (2022) Higher criticism to compare two large frequency tables,
with sensitivity to possible rare and weak differences. Annals of Statistics.[2]  C. B. Dean. (1992) Testing for Overdispersion in Poisson and Binomial Regression Models.
Journal of the American Statistical AssociationMethods:bin_allocation_test(the test from [1])bin_variance_test(test from [2])bin_variance_test_dfthe same asbin_variance_testplus additional informationAdditional auxiliary function of independent interest:poisson_testVectorized one-sided Poisson test with an option to do a randomized testbinom_testVectorized one-sided binomial test with an option to do a randomized testbinom_test_two_sidedVectorized Two-sided binomial test with an option to do a randomized testbinom_test_two_sided_slowVectorized two-sided binomial test using scipy.stats.binom_testExample:from twosample import bin_allocation_test, bin_variance_test
from scipy.stats import poisson

n = 100

P = np.ones(n) / n
Q = P.copy()
  
smp1 = np.random.multinomial(n, P)  # sample form P
smp2 = np.random.multinomial(n, Q)  # sample from Q

pvals_alloc = bin_allocation_test(smp1, smp2) # binomial P-values
pvals_var = bin_variance_test(smp1, smp2) # binomial P-values
Package: twoSenses
twoSensestwoSenses is a python library which can give your python program the ability to speak and listen.
twoSenses can also be used to greet the user.How to install this projectOpen your terminalTypepip install twoSensesand hit enterHow to use this projectUse.wish()to wish good morning, good afternoon or good eveningUse.speak()to speakUse.listen()to listenExampleimport twoSenses
twoSenses.wish()import twoSenses
twoSenses.speak()import twoSenses
twoSenses.listen()
Package: twosheds
twosheds is a command language interpreter (shell), written in Python.Most existing shells are written in C which makes extension difficult. Python
is comparatively easy to learn, read, and write, and is fast enough to operate
as a day-to-day shell:>>> import twosheds
>>> shell = twosheds.Shell()
>>> shell.interact()
$ ls
AUTHORS.rst       build             requirements.txt  test_twosheds.py
LICENSE           dist              scripts           tests
Makefile          docs              setup.cfg         twosheds
README.rst        env               setup.py          twosheds.egg-infoFeaturesHighly extensibleHistoryCompletionInstallationTo install twosheds, simply:$pipinstalltwoshedsYou may need tosudoif you intend to install system wide.DocumentationDocumentation is available athttp://twosheds.readthedocs.org/en/latest/.ContributeCheck for open issues or open a fresh issue to start a discussion around a feature idea or a bug.Forkthe repositoryon GitHub to start making your changes to themasterbranch (or branch off it).Write a test which shows that the bug was fixed or that the feature works as expected.Send a pull request and bug the maintainer until its get merged and published. :) Make sure to add yourself toAUTHORS.
Package: twosigma-memento
Two Sigma MementoMemento is a framework and lightweight set of standards that encourage discipline in the way data
is incrementally transformed through code. The goal of Memento is to ensure that data is
reproducible and that accurate provenance is maintained in metadata. The Memento Framework
does not pin itself to a specific programming language, back-end storage technology or compute
framework. Rather, it focuses on a technique for generating and accessing data that preserves
accurate metadata throughout.Memento can be extended with plugins which customize where memoized data is stored and how
distributed compute is executed.This codebase hosts several independent products, which are all synchronized in their version.
This product is the core memento framework, which is usable by itself or in combination with
various plugins.The core framework includes three storage backends, filesystem (the default), memory, and
null (never store). The core framework also includes two runner backends, local (in-process),
and null (never run). To use memento for distributed computation or shared storage, other
plugins can be used.Quick StartThe following instructions should get you from a git clone to a working build of Memento.
These instructions are tested on Linux and Windows but should work in other environments
as well.PrerequisitesYou need a Python environment with hatch installed:$python--version
Python3.11.1
$pipinstallhatchBuild MementoTo build, simply run the following command. You will get a dist directory with a pip package.$hatchbuildTest MementoMemento has an extensive suite of unit tests. To run the tests to ensure the build is working,
run the following.$hatchruncovThere are some tests that will not run by default because they require a lot of RAM and are slow
to run. To include those tests, include the--runslowparameter.Run MementoIf you have an existing environment, you can install memento with:$pipinstall-e.If you prefer to start an isolated environment with a barebones Python with just Memento installed:$hatchshell
$pythonQuick exampleTry a simple cached function definition in a python repl:$hatchrunpython
Python3.11.1(tags/v3.11.1:a7a450f,Dec62022,19:58:39)[MSCv.193464bit(AMD64)]onwin32Type"help","copyright","credits"or"license"formoreinformation.
>>>fromtwosigma.mementoimportmemento_function
>>>@memento_function
...deff(x):
...print("eval f")...returnx+1...
>>>f(1)evalf2>>># The second time we run it should not print "eval f" because it reads the cached result>>>f(1)2>>>
Package: twostage
=============================Two Stage Euclidean Domains=============================-----------------------------Algorithms for proving that class-number-one real quadratic fields are 2-stage euclidean, and to find continued fraction expansions in them.-----------------------------Installation~~~~~~~~~~~~To install the package use the following command::sage -pip install --user --upgrade twostageIf you rather install the cutting-edge version from the github repository (which is likely to be broken), then use the following command::sage -pip install --user --upgrade -v git+https://github.com/mmasdeu/twostage.git
Package: twostream
This package provides Python wrappers for the 2stream radiative transfer model by Bernard Pinty. The original Fortran code was downloaded formhere. The model is described inPinty *et al.* (2006), the full reference beingcode:@article{67,
    author = { Pinty, B. and Lavergne, T. and Dickinson, R. E. and Widlowski, J.-L. and Gobron, N. and Verstraete, M. M.},
    year = {2006},
    title = {Simplifying the Interaction of Land Surfaces with Radiation for Relating Remote Sensing Products to Climate Models},
    journal = {Journal of Geophysical Research – Atmospheres},
    volume = {111},
    number = {2},
    doi = {10.1029/2005JD005952},
  }Please visit theTwo Stream webpagefor conditions and restrictions in using this software. Remember to cite and acknowledge the authors of the original model.Any problems about the Python wrappers, get in touch withme <mailto:j.gomez-dans@ucl.ac.uk>.
Package: twot
twot - The Twitter Bot APIAboutThis is a Python package that provides an easy-to-use interface to
Twitter using Selenium to emulate actions that a Twitter user might make,
such as liking, following, and tweeting. In addition, it provides a
Tweet Search implementation that uses Twitter's Advanced Search to
scrape for tweets.Getting StartedPrerequisitesTo use this package, you will need:Python 3.7+Selenium 4.0+Chrome BrowserTwitter AccountInstallationpip install twotUsageImportTwitterAPIclass, create an instance and login:fromtwot.classesimportTwitterAPIapi=TwitterAPI('my_username','my_password')api.login()Use theTwitterAPIinstance to interact with Twitter:# Tweet somethingapi.post_tweet('Hello World!')# Like a tweetapi.like_tweet('https://twitter.com/twitter/status/1234567890')# Quote retweet a tweetapi.quote_retweet('https://twitter.com/twitter/status/1234567890','Foo bar')Scrape for tweets:# First five options are required for every searchOPTIONS={"limit":500,"replies":False,"only-replies":False,"links":True,"only-links":False,"from":['BarackObama']}# Links to the last 500 tweets from Obamaobama_tweets=api.search(OPTIONS)FeaturesYou must have a Twitter account to use all features (including search).
Class methods return the results of their actions. For example, methods
that post a tweet return a link to the new tweet. Likeing and following
return whether that tweet/account is now liked/followed or unliked/unfollowed
(true/false).Methods
    -------
    status()
        Prints general info about the class state
    login()
        Uses `username` and `password` to login to Twitter
    logout()
        Logs out from Twitter
    post_tweet(message)
        Posts a tweet to users timeline
    reply_to_tweet(tweet_id, message)
        Posts a reply to the specified tweet
    like_tweet(tweet_id)
        Likes/Unlikes the tweet
    retweet(tweet_id)
        Retweets/Unretweets the tweet
    quote_retweet(tweet_id, message)
        Quote retweets the tweet with the specified message
    follow(user_handle)
        Follows the user with the specified handle
    unfollow(user_handle)
        Unfollows the user with the specified handle
    search(options)
        Searches for tweets using Advanced Search
    quit()
        Ends the browser sessionContributingPull requests are welcome. For major changes, please open an issue first to
discuss what you would like to change.
Package: twottle
twottleA web gui for browsing twitch.tv streams and videos on demand. Search for categories or users, and view followed streamers' activity. Requires user login.InstallationWorks on all platforms (Win/Mac/Linux/BSD)Dependenciespython >=3.10(Can relax requirement upon request)streamlink(via pip/binaries/brew/source explainedhere)yt-dlprepomultimedia player listedhereWindows: player must be in system PATHPyPi:pip install twottleFrom source:Follow dependencies listed belowBuild requiresflitClone repository and runflit installin root directoryUsagetwottle [-h] [--reset | --logout | -c | -d | -v]

options:
  -h, --help        show this help message and exit
  --reset           reset config file
  --logout          remove user from app, prompt login again
  -c, --clear-data  remove all user data and cache
  -d, --debug       Add debug logs to output stream
  -v, --version     show program's version number and exitRuntwottleto begin. On first startup you will be prompted to login and will be redirected to Twitch oauth.
Package: twoup
twoupList page number sequence to print a small folded double sided bookletDescriptionTo consult the gnome guide for two sided booklet printing, please visitthislink. As part of the guide, you will require a listing of page numbers in a specific order, which this package provides.Usage$ twoupNumber of pages in your booklet (must be a multiple of four)? 88,1,2,7,6,3,4,5NoteThis project has been set up using PyScaffold 3.1.post0.dev48+gfeb1042. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: twpl
Two-phase locking with lockfilesInitial releaseCurrently supports Linux/POSIX onlyDocumentation coming soonRelies on modifying the number of open file descriptors for a lockfile.Currently implements the 2PL lock compatibility table:Lock typeread-lockwrite-lockread-lockYNwrite-lockNNRead locks are called "concurrent," and write locks are called "exclusive."The API, the naming, and the implementation are all subjects to change until
the firststablerelease (i.e. until version 1.0.0, or earlier if explicitly
stated).
Package: twps
A python package to preprocess text files with embedded Python code snippets:
evaluate or execute them and replace with the result of evaluation/execution.This package provides theppp.pyscript. The script reads the file
specified in the command line, finds python snippets, evaluates or executes
them and writes out the file with the pyhton code replaced with the
evaluateion/execution result.The following example shows a template file (i.e. the file to be processed with ppp.py) and the result.Template (test/t1.t)Resulting file (test/t1.res.t)``
The  characters on the 1-st line define
the delimiters, used to mark the python
snippets. In this case, both the begin
of the snippet and its end are denoted
with the backtick.

This is an evaluation snippet: `2*7`,
and this is an execution snippet:
`from math import pi; pi2=pi*2`.

Check that the definitions made in the
previous snippets are accessible: `pi2`.The  characters on the 1-st line define
the delimiters, used to mark the python
snippets. In this case, both the begin
of the snippet and its end are denoted
with the backtick.

This is an evaluation snippet: 14,
and this is an execution snippet:
`from math import pi; pi2=pi*2`.

Check that the definitions made in the
previous snippets are accessible: 6.28318530718.InstallThe package is published on PyPI:https://pypi.org/project/twps/. The preffered way to install is:>pip install twpsGetting helpFor command line options seereadme.rstin thetwpsfolder or run the
script without command line arguemnt.General description with examples (somewhat outdated) can be found in thedocsfolder.
Package: twpy
TwpyTwitter High level scraper for humans.FeaturesNO LIMIT, NO API requiredFast and easy to useWorking with python 3.5+Integrated with pandas for data science researchInstallationManual install via git :$gitclonehttps://github.com/0x0ptim0us/twpy.git
$cdtwpy
$pythonsetup.pyinstallInstall using pip:$pipinstalltwpy# or$python-mpipinstalltwpyUsageCreate Twpy object :fromtwpyimportTwpyClient# create twpy client objecttc=TwpyClient()with proxy :# or you can pass proxytc=TwpyClient(proxy="127.0.0.1:8080")Get twpy current version :tc.__version__# '1.2.4'Get user followers:# get user followers, limited up to 50# interval : delay between each request, default is 0 for no delay# proxy : send traffic through proxy, default is nonefollowers_data=tc.get_followers(username="elonmusk",limit=50,interval=1)Get user timeline:tweets=tc.get_timeline(username="elonmusk",limit=50)Get user profile:user_info=tc.get_user(username="elonmusk")Convert result object to other data structures :fromtwpy.serializersimportto_pandas,to_json,to_list# convert result to pandas data frame, json and list# pandaspandas_sample=to_pandas(followers_data)# jsonjson_sample=to_json(followers_data)# listlist_sample=to_list(followers_data)Search example:# search user tweets until 2015tweets=tc.search(username="elonmusk",until="2015")# add limit and intervaltweets=tc.search(username="elonmusk",until="2015",limit=100,interval=1)# search tweets contains `love` wordtweets=tc.search(query="love",limit=100,interval=1)# search tweets which contains `love` word and were tweeted since 2015-01-01tweets=tc.search(query="love",since="2015-01-01",limit=10)Supported methodsmethoddescriptionget_friends()get user followings/friendsget_timeline()get user timeline/tweetsget_user()get user profile infosearch()search tweets with query and usernameMetaFardin Allahverdinazhand -@0x0ptim0us-0x0ptim0us@gmail.comDistributed under the MIT license. seeLICENSE.txtfor more information.https://github.com/0x0ptim0us/twpy