Saravanan666/pypi-org huggingface dataset:
Package: unofficial-xitroo-api
USAGEpip install unofficial-xitroo-apiWhat does it?It will get the latest inbox email and returns their body or subject as string to get for example account verification codesDocumentationArguments.get_bodyText()
.get_bodyHtmlStrict()
.get_bodyHtml()
.get_subject()
>>> returns string from last mail

.get_latest_inbox_raw()
>>> returns json from latest mailParametersYou can also pass in an integer how many times it should check the inboxrefresh_counter=intrefresh_wait=int"refresh_counter" is how many times it should ckeck the inbox (default is 5)"refresh_wait" is how many seconds it should wait between refreshes (default is 5)"http_timeout" If the request doesn't load in 15 seconds it will send a new one (default is 15)Example:xitroo("test@xitroo.de", refresh_counter=5, refresh_wait=5, http_timeout=15)Examplesfrom xitroo.api import xitroo

xitroo_email = xitroo("test@xitroo.de")
print(xitroo_email.get_bodyText())from xitroo.api import xitroo as x

print(x("test@xitroo.de", refresh_counter=5, refresh_wait=5).get_subject())
Package: unopass
unopassWritten byAmado Tejadaunopassis a convenient python module that allows you to retrieve secrets from the 1Password CLI at runtime using your biometrics.This eliminates the need of storing secrets in env, or conf files and provides a more secured local workflow.Note:unopassis early alpha software and should be tested extensively.Requirements:1Password CLIv2.4.1 or higher1Password Appv8.7.1 or higherBiometricsenabledSecurityAuthorization expires after 10 minutes of inactivity in the session. There's a hard limit of 12 hours, after which you must reauthorize.Learn about 1Password BiometricsSecurityInstallpypi repo:pip3installunopassYou can also importunopassfrom source.Examplefromunopassimportunopassassecret"""secret.unopass({VAULT}, {ITEM}, {FIELD})OPTIONAL: signout of the 1Password CLI session:call secret.signout() with deauthorize=True to end of the 1Password session"""username=secret.unopass("personal","server","username")password=secret.unopass("personal","server","password")secret.signout(deauthorize=True)print(f"user:{username}\npass:{password}")DisclaimerThis software {unopass} has not been endorsed or supported by 1Password, AgileBits Inc. and is in no way associated with them and/or its subsidiaries or affiliate.Licenseunopassis released under theMIT License
Package: unophysics
UNO Physics ToolsPython tools collected from data analysis projects at the University of New Orleans.Some of these will be useful in general, some will be specific to our internal systems.TODO: seperate the generally useful parts from the specific parts.TODO: add in proper badgesInstallationRecommended to use a virtualenv.python -m virtualenv *name of directory to put venv*To install:Either clone this repo then install:git clone https://github.com/micha2718l/unophysics.gitcd unophysicspip install .Or usepippip install unophysicsTools for physics from UNO.Free software: MIT licenseDocumentation: TODOFeaturesWavelet noise cleaning functionVarious quantum mechanics formulas implementedJupyter Notebook helper functions for displaying mathCan load LADC GEMM data, for the data access functions to work, credentials for the servers are needed. Contact us if that is desired.Can work with the LADC GEMM data to display spectrographic informationData on various marine mammal species built into the library (currently has Bryde's whale information, in progress to fill in with Fin whale data).TODO: ExamplesCreditsMost of this work has been done by various students and professors at the University of New Orleans Physics department.Special thanks to theLADC GEMM Consortiumfor data to work with and inspire us.This package was created with:Cookiecutterand theaudreyr/cookiecutter-pypackageproject template.relies heavily on numpy, PyWavelets, scipy, etc...History0.1.0 (2018-09-06)First release on PyPI.
Package: unopt
unopt: Utility functions to unwrapOptional[T]Overviewunoptprovides several utility functions to "unwrap" theOptional[T](orT | None)
objects: removes theOptionaltype hint and obtains the underlying object.unoptfunctions are inspired by the Rust'sOption<T>functionality, but the behavior
is tuned to Python's convention. E.g.,unwrap()raises an exception instead of
aborting.InstallpipinstallunoptExamplesfromunoptimport*foo:Optional[int]=123bar:Optional[int]=None# unwrap() returns the given object if it is not None.assertunwrap(foo)==123unwrap(bar)# Raises UnwrapError# unwrap_or() returns the default value if the given object is None.assertunwrap_or(foo,456)==123assertunwrap_or(bar,456)==456# unwrap_or_else() returns the default value obtained by invoking the given function.assertunwrap_or_else(foo,lambda:456)==123assertunwrap_or_else(bar,lambda:456)==456# unwrap_unchecked() just casts the given object without value checking.assertunwrap_unchecked(foo)==123assertunwrap_unchecked(bar)isNone# Unsafe
Package: unormalize
Converts UTF-8 input to the desired UTF-8 in Unicode normalization form.Read about theUnicode Normalization Forms!UsageThere are five executables included, that all have the exact same usage and
arguments:unormalizenfcnfdnfkcnfkdYou may either redirect or pipe input intounormalize(and its buddies), or
provide filenames as arguments.Options-fFORM/--form=FORMSelects the normalization form: one of NFC, NFD, NFKC, or NFKD. The
equivalently named executables imply their respective normalization form;unormalizeis equivilent tonfkwithout the--formarugment.-iEXTENSION/--in-placeEXTENSIONFilenamesmustbe specified as arguments. If so, this opens them, and
converts them into the desired normalization form, in place.EXTENSIONis
the extension given to back-ups of the original files.ExamplesConvert clipboard contents to NFC (macOS):$ pbpaste | nfc | pbcopyConvert a file, in-place, to NFKD:$ nfkd --in-place=.bak file.txt && rm file.txt.bakConvert circled, variants, and half-widths to their compatible forms:$ echo 'ℍ①ｶ' | nfkc
H1カLicense© 2015, 2017 Eddie Antonio Santos. MIT Licensed.
Package: unp
$ unp_unp is a command line tool that can unpack archives easily.  Itmainly acts as a wrapper around other shell tools that you canfind on various POSIX systems.It figures out how to invoke an unpacker to achieve the desiredresult.  In addition to that it will safely unpack files when anarchive contains more than one top level item.  In those cases itwill wrap the resulting file in a folder so that your workingdirectory does not get messed up.All you have to do:$ unp myarchive.tar.gzTo install you can use pipsi:$ pipsi install unpSupports the following archives:- 7zip Archives (*.7z)- AR Archives (*.a)- Apple Disk Image (*.dmg; *.sparseimage)- Bz2 Compressed Files (*.bz2)- Bz2 Compressed Tarballs (*.tar.bz2)- Gzip Compressed Files (*.gz)- Gzip Compressed Tarballs (*.tar.gz; *.tgz)- Uncompressed Tarballs (*.tar)- WinRAR Archives (*.rar)- Windows Cabinet Archive (*.cab)- XZ Compressed Files (*.xz)- XZ Compressed Tarballs (*.tar.xz)- Zip Archives (*.zip; *.egg; *.whl; *.jar)DMG is only supported on OS X where it invokes the hdiutil andcopies out the contents.
Package: unpack200
PythonUnpack200A Python wrapper for the JDK unpack200 utility.UsageThe unpack200.unpack function takes three parameters:infile: string, full path to the pack200 file to extractoutfile: string, full path to the jar file you'd like to extract toremove_source: bool (optional, default False), whether to remove the pack200 file specified in  after extraction is completeFor example:importunpack200unpack200.unpack(r"C:\path	o\packfile",r"C:\path	o\outfile")BuildingSetup.py is currently only set up for Windows at the moment - feel free to contribute a Linux or Mac PR!To build, first download and extract the following dependencies to your PC:Java JDK source code, e.g. from:https://github.com/dmlloyd/openjdkJava JDK builtrun:python3setup.pybuildIt will ask you two questions, enter a full path into both, e.g:WhereistheJDKsourcelocated?C:\JDK\src
WhereistheJDKincludelocated?C:\ProgramFiles\Java\jdk1.8.0_131\includeIt will attempt to derive the correct locations for everything from these paths, and should build the extension.IssuesFound an issue? Please report it either in the issues section of this repo, or to the developers of JDK. Any fix PRs would be welcome!
Package: unpackable
Unpackable: Object destructuring for Pythonunpackableis a module that lets you usePython's destructuring assignmentto unpack an object's attributes.Use caseConsiderJavaScript's destructuring assignmentfeature that allows you to do the following:classUser{constructor(id,email){this.id=id;this.email=email;}}constuser=newUser(1,'example@example.com')const{id,email}=user;// destructureunpackableallows you to do something similar in Python:fromdataclassesimportdataclassfromunpackableimportUnpackable@dataclassclassUser(Unpackable):id:intemail:struser=User(1,'example@example.com')id,email=user# destructureunpackablecan also unpack objects that don't subclassUnpackable:fromunpackableimportunpack@dataclassclassUser:id:intemail:struser=User(1,'example@example.com')id,email=unpack(user)# destructureStatusunpackablecurrently works with iterable objects,dataclassesand simple objects.This is alpha software and is not ready for use beyond limited use cases like inmyapp_pathsproject.InstallationRequirementsPython 3.8+PyPIpython3-mpipinstallunpackableSupportWant to support this project andother open-source projectslike it?LicenseSeeLICENSE. If you'd like to use this project with a different license, please get in touch.
Package: unpackai
unpackAI Library - The library to ease your learning, building and the deployment of state-of-the-art deep learning models to empower your business and career.Who is unpackAI?unpackAI has the mission to make AI education as accessible as possible. Alongside our AI & Machine Learning Bootcamps for Business Professionals, we build this library to remove technical barriers and provide the right tools for individuals and businesses to allow for effective learning, building and deployment of AI projects. Find more information via ourwebsiteand get in touch!🌌 All applications - Build powerful applications in computer vision, natural language processing and tabular data.⏱️ Save time - Don't waste time and utilize our end-to-end implementation process to build a model in hours.🌩️ Learn & Build - Join our Bootcamps to easily master our entry friendly, repeatable and inuitive way to build state-of-the-art deep learning models whereever YOU need it.InstallationYou can install this library with pippipinstallunpackaior with github link to get the latest versionpipinstallgit+https://github.com/unpackai/unpackai/ContentThis package provides utilities for:Computer Vision (CV)Tabular DataNatural Language Processing (NLP)DocumentationDocumentation is availablehere.
Package: unpackqa
unpackqaMethods for unpacking, labelling and masking all common remote sensing QA bands which are stored in bit-wise values.Works with single QA values, 1D arrays (eg. time series), or 2D arrays (eg. full scenes).Get a QA mask in a single line of code:unpackqa.unpack_to_array(qa,'LANDSAT_8_C2_L2_QAPixel','Cloud')The same methods are used for all sensors, with specific product flags specified via arguments.No file reading or writing, everything is handled as pre-loaded arrays.Requires python 3.6+, with numpy and pyyaml as the only dependencies.InstallationInstall via pip:pip install unpackqaDocumentationhttps://sdtaylor.github.io/unpackqa
Package: unpaddedbase64
Encode and decode Base64 without “=” padding.RFC 4648specifies that Base64 should be padded to a multiple of 4 bytes
using “=” characters. However many protocols choose to omit the “=” padding.Installingpython3-mpipinstallunpaddedbase64Usingimportunpaddedbase64assert(unpaddedbase64.encode_base64(b'\x00'))=='AA'assert(unpaddedbase64.decode_base64('AA'))==b'\x00'
Package: unparallel
🔀 UnparallelCreate async HTTP requests with Python in no time.With Unparallel you can easily create thousands of web requests in an efficient way leveraging Python's async capabilities.Unparallel is built on top ofHTTPXand aims to support its rich set of features.InstallationpipinstallunparallelExampleA simple example of doing several GET requests to an HTTP web service:importasynciofromunparallelimportupasyncdefmain():url="https://httpbin.org"paths=[f"/get?i={i}"foriinrange(5)]results=awaitup(url,paths)print([item["args"]foriteminresults])asyncio.run(main())This prints:Making async requests: 100%|███████████| 5/5 [00:00<00:00,  9.98it/s]
[{'i': '0'}, {'i': '1'}, {'i': '2'}, {'i': '3'}, {'i': '4'}]Similarly, we can do a bunch of POST requests. This time we will use a single path but multiple payloads:importasynciofromunparallelimportupasyncdefmain():url="https://httpbin.org"path="/post"payloads=[{"obj_id":i}foriinrange(5)]results=awaitup(url,path,method="post",payloads=payloads)print([item["data"]foriteminresults])asyncio.run(main())This prints:Making async requests: 100%|███████████| 5/5 [00:00<00:00,  9.98it/s]
['{"obj_id": 0}', '{"obj_id": 1}', '{"obj_id": 2}', '{"obj_id": 3}', '{"obj_id": 4}']For more details on the usage and examples, check out thedocs.Why unparallel? Why async?Async is a really powerful feature - especially when you have to wait for I/O.
Here is an example of making 20 web requests synchronously vs. asynchronously viaunparallel.As you can see, the async version finishes in less than a second.Code for syncimporthttpxfromtqdmimporttqdmdefmain():url="https://httpbin.org"paths=[f"/get?i={i}"foriinrange(20)]results=[httpx.get(f"{url}{path}")forpathintqdm(paths,desc="Making sync requests")]assertlen(results)==20if__name__=="__main__":main()Code for asyncimportasynciofromunparallelimportupasyncdefmain():url="https://httpbin.org"paths=[f"/get?i={i}"foriinrange(20)]results=awaitup(url,paths)assertlen(results)==20if__name__=="__main__":asyncio.run(main())ContributingAs this project is still in early development, I'm happy for any feedback and contributions!
Please refer to thecontributing guidelinesfor details.LicenseThis project is licensed under the terms of theMITlicense. SeeLICENSEfor more details.CreditsThis project was heavily inspired by the blog postMaking 1 million requests with python-aiohttpby Paweł Miech.I created this project withpython-package-template.
Package: unpoly
UnpolyUnpoly is a framework agnostic python library implementing theUnpoly server protocol.FeaturesFull protocol implementation: The whole Unpoly server protocol is implemented and well tested.Django support: Out of the box we currently ship a middleware for Django support.Easily extendable: The library abstracts the actual HTTP stuff via adapters and can easily plugged into frameworks like Flask etc.Download & Installpip install unpolyUsage with DjangoAddunpoly.contrib.django.UnpolyMiddlewareto your middlewares and then you can accessrequest.up. Details can be found in the usage section of thedocs.Example usage:defmy_view(request):ifrequest.up:# Unpoly request# Send an event down to unpolyrequest.up.emit("test:event",{"event":"params"})# ... and also clear the cache for certain pathsrequest.up.expire("/users/*")else:...defform_view(request):form=MyForm(request.GET)# When unpoly wants to validate a form it sends# along X-Up-Validate which contains the field# being validated.ifform.is_valid()andnotrequest.up.validate:form.save()returnrender(request,"template.html",{"form":form})Usage with Flask etcSubclassunpoly.adapter.BaseAdapterand initializeunpoly.Unpolywith it for every request (see thedocsfor details).
Package: unpredictableFate
unpredictableFate感谢各位的支持和帮助，所有规则此时已经结束了最终的整合阶段。观看本篇规则书时，请不要惊慌。这个规则书为现有的所有与pl车卡与了解世界观的所有信息和规则的整合，并没有任何全新的内容的更新。
感谢的名单与指正的修改的部分我们将会放到《附录E:感谢名单&更新日志》中。再次感谢任何为了制作规则书，完善规则书而努力，你们花费了最多的时间和精力去完成这个规则，你们是规则书最大的恩人。by 利斯特-里克特（Aru.Pha）其实本人不善言辞，但在本人过往的跑团经历中，经历了很多的不如意，跌跌撞撞最终还是成为了世界主，在写这篇规则书的时候，本人已经尽力优化骰子的相关指令操作了；
所以希望大家能认真看完规则书，这对你接下来的游玩体验帮助非常大；
规则书会不定期更新，目前还有许多工作没有完成，比如优化战斗规则等部分；
希望大家能尽量包容和体量，非常感谢。好了，先礼后兵，现在到兵的部分了，由于本人性格原因，非常讨厌鸽子和不尊重别人的人
所以如果有跑团过程中不遵守游戏规则的，经常擅自消失不说一声的，开团不开完的，对他人恶语相向等等的，第一次警告，第二次飞机票。by 深海（919857696）Site viewhttps://unpredictablefate.jyunko.cn/(recommend)https://unpredictable-fate.vercel.app/https://unpredictable-fate-git-main-retrofor.vercel.app(git branch)LicenseThis project is licensed under the MIT License.
Package: unpushed
This is fork of “uncommitted” project originally created by Brandon Rhodes.“unpushed” adds some features:support for checking branches for unpushed commits,desktop notification.Preface from original authorWhen working on one version-controlled project on my hard drive, I often
flip over quickly to another project to make a quick change.  By the end
of the day I have forgotten about that other change and often find it
months later when I enter that repository again.  I needed a way to be
alerted at the end of each day about any uncommitted changes sitting
around on my system.Thus was born this “uncommitted” script: using either your systemlocate(1)command or by walking a filesystem tree on its own, it will
find version controlled directories and print a report on the standard
output about any uncommitted changes still sitting on your drive.  By
running it from acron(8)job you can make this notification routine.Running “unpushed”By default “unpushed” uses thelocate(1)command to scan for
repositories, which means that it can operate quickly even over very
large filesystems like my home directory:$ unpushed ~But you shouldbe warned:because thelocate(1)database is only
updated once a day on most systems, this will miss repositories which
you have created since its last run.  To be absolutely sure to see all
current repositories, you should instead ask “unpushed” to search the
filesystem tree itself.  To do this on your “devel” directory, for
example, you would type this:$ unpushed -w ~/develNot only will the output of “-w” always be up-to-date, but it is usually
faster for small directory trees.  The default behavior of usinglocate(1)(which can also be explicitly requested, with “-l”) is
faster when the directory tree you are searching is very large.Should you ever want a list of all repositories, and not just those with
uncommitted changes, you can use the “-a” option:$ unpushed -a ~Also you can list exact files or braches was changed using the “-v” verbose
option:$ unpushed -v ~You can always get help by running “unpushed” without arguments or
with the “-h” or “–help” options.Desktop notificationApplication use system depended desktop notification facility. To show desktop
notification run this command:$ unpushed-notify ~On Linux this is done through pynotify library. On OS X through pyobjc. On other systems this feature is
not implemented yet.You can add this line to your crontab (crontab -e):*/10 18-20 * * *   unpushed-notify ~This will show you notification about uncommitted and unpushed changes every
10 minutes starting from 6pm ending at 8pm.Do not forget to add unpushed-notify to cron PATH!Supported VCsAt the moment, “unpushed” supports:Mercurial(.hg directories)Git(.git directories)Subversion(.svn directories)TODOCheck svn existence before using itCheck locate existence before using itChangelog1.2.0(2017 Sep 25)Python 3 Migration1.1.0(2012 May 22)Fix README markupReport untracked files separatelyAdd -t option to ignore untracked filesShow not pushed changesets in Mercurial. Thanks Guilherme Gondim for
testing1.0.2(2012 April 27)Fix setup script
Package: unpy2exe
unpy2exeusage: unpy2exe.py [-h] [-o OUTPUT_DIR] [-p PYTHON_VERSION] filename

Extract pyc files from py2exe executable.

positional arguments:
  filename              The py2exe executable

optional arguments:
  -h, --help            show this help message and exit
  -o OUTPUT_DIR, --output-dir OUTPUT_DIR
                        Output directory
  -p PYTHON_VERSION, --python-version PYTHON_VERSION
                        Python version for pyc
  -v, --verbose         Verbose outputYou can install it from PyPI:$ pip install unpy2exeInstall from sourceDependencies:pefilesixargparse (Python < 2.7)You can install dependencies throughpip install -r requirements.txtNotesFor .exe files generated with Python 2.x, you will need to run unpy2exe with
Python 2.x; similarly, for Python 3.x .exe files, you will need to run unpy2exe
with Python 3.x. Note the same unpy2exe source code works for both, but you
will need to install the dependencies accordingly.On the other hand, to be able to run the extracted .pyc file, you will need the
same Python version used to generate the .exe, or at least the same major
version (although it is highly probable you could still get some issues or
crashes if the version doesn't match the original bytecode).TODO:Extract archived files (from zip/from exe)See also:http://py2exe.svn.sourceforge.net/viewvc/py2exe/trunk/py2exe/py2exe/build_exe.py?view=markup
Package: unqlitepy
unqlitepy=============UnQLite for Python Binding## Install```sh> sudo pip install unqlitepy...Successfully installed UnQLitePyCleaning up...```or```sh> virtualenv sample> cd sample> bin/pip install git+https://github.com/nobonobo/unqlitepy.git...Successfully installed UnQLitePyCleaning up...```## Usage```pythonfrom unqlitepy import UnQLitewith UnQLite(':mem:') as db:db.store('test', 'hello!')print db.fetch('test') # -> hello!db.append('test', ' world!')print db.fetch('test') # -> hello! world!db.delete('test')for i in range(25):db.store('test{0}'.format(i), 'hello!')db.store('etst{0}'.format(i), 'hello!')if i%5==0:db.delete('etst{0}'.format(i))@UnQLite.FetchCallbackdef f(output, outlen, udata):output = (c_char*outlen).from_address(output).rawprint locals()return UNQLITE_OKdb.fetch_cb('test0', f)sample = ("print 'hello!\n';""db_create('users'); /* Create the collection users */""db_create('hoges');"" /* Store something */ ""db_store('users',{ 'name' : 'dean' , 'age' : 32 });""db_store('hoges',{ 'name' : 'dean' , 'age' : 32 });""db_store('users',{ 'name' : 'chems' , 'age' : 27 });""db_store('hoges',{ 'name' : 'chems' , 'age' : 27 });""print db_fetch_all('users')..'\n';""/*print db_reset_record_cursor('users')..'\n';*/""while( ($rec = db_fetch('users')) != NULL ){""  print $rec; print '\n';""}")with db.compile(sample) as vm:vm.execute()with vm.new_scalar() as sv, vm.new_array() as av:print sv, sv.is_scalar()print av, av.is_json_array()db.fetch_cb('users', f)with db.cursor() as cursor:cursor.first()cursor.seek('test20')while cursor.valid():print repr(cursor.key()), repr(cursor.value())cursor.next()```
Package: unrar
python-unrarWork with RAR archive files through unrar library using ctypes.Install UnRAR librarypython-unrar requires UnRAR library. You can download UnRAR library sources from:http://www.rarlab.com/rar_add.htmand compile (you may need to rename the makefile that you want to use according to your OS) and install it from there:$ make lib
$ make install-lib(latest tested sources:http://www.rarlab.com/rar/unrarsrc-5.2.6.tar.gz)For Windows you can also download the already compiled library (http://www.rarlab.com/rar/UnRARDLL.exe).If you prefer not to install the library, you should make it "findable" by adding the library file to a directory where libraries are searched (or change required environment variable).As an alternative, you can also set UNRAR_LIB_PATH variable in your environment to the library path and python-unrar will try to load the UnRAR library from there.Testing without installingYou can build from source with:$ python setup.py buildAnd then run a Python shell with unrar available:$ PYTHONPATH=`pwd`/build/lib pythonOr you could also directly add theunrardirectory from this repo to yourPYTHONPATH. In any case you will still need to make the unrar library available as mentioned above.Install python-unrarTo install python-unrar:$ pip install unrarExamples>>> from unrar import rarfile
>>> rar = rarfile.RarFile('sample.rar')
>>> rar.namelist()
[u'test_file.txt']
>>> rar.printdir()
File Name                                             Modified             Size
test_file.txt                                  2013-04-14 08:20:28           17
>>> rar.testrar()
>>> info = rar.infolist()[0]
>>> info.filename
u'test_file.txt'
>>> info.file_size
17L
>>> info.date_time
(2013L, 4L, 14L, 8L, 20L, 28L)
>>> rar.extractall()
>>> rar.read('test_file.txt')
'This is for test.'DocsCheck full documentation inhttp://python-unrar.readthedocs.org.