Saravanan666/pypi-org huggingface dataset:
Package: tarproc
The Tarproc UtilitiesTarfiles are commonly used for storing large amounts of data in an efficient,
sequential access, compressed file format, in particualr for deep learning
applications. For processing and data transformation,
people usually unpack them, operate over the files, and tar up the result again.This library and set of utilities permits operating directly on tar files. This
is faster than operating on files on file systems, and it is usually easier too.tarcats -- concatenate tar files sequentiallytarsplit -- split a tar file by number of records or sizetarpcat -- concatenate tar files in paralleltarproc -- map command line programs over tar filestarshow -- show contents of tar filestarsort -- sort tar files based on some keyThe following are less commonly used utilities that are specifically useful
for deep learning:tarfirst -- extract the first file matching some criteriatargrep -- grep through files inside tar files (this will replace tarfirst)tar2db, tar2lmdb, tar2tsv -- convert tar files to database filestarmix -- mix tar files based on statistical samplingtsv2tar -- build tar files based on a .tsv file planThe utilities allow operating on stdin/stdout when necessary, allowing
command line pipes to be constructed. For example:$gsutilcatgs://bucket/file.tar|tarsort|tarsplit-ooutputPython Interfacefrom tarproclib import reader, gopen
from itertools import islice

gopen.handlers["gs"] = "gsutil cat '{}'"

for sample in islice(reader.TarIterator("gs://lpr-imagenet/imagenet_train-0000.tgz"), 0, 10):
    print(sample.keys())dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
dict_keys(['__key__', 'cls', 'jpg', 'json', '__source__'])
Package: tar-progress
![alt text](doc/logo/tar-progress-logo.png “tar-progress”)
[![Build Status](https://travis-ci.com/henri9813/tar-progress.svg?branch=master)](https://travis-ci.com/henri9813/tar-progress)This utility is an adaptation from the GNU TAR program, it provide a progress-bar with a simply command :tar-progress [OPTIONS] File## Installationpip install tar-progressThis tool is cross-platform, available on Windows ( New ! ) And also Linux”. Please note that in Linux, it only launch thetarprogram with apvcommandThis program can be launched on these plateforms:LinuxWindows>Warning: On Windows i used the tarfile module from Python wich is very slow. I’m open to suggest about this performance problem## Usagetar-progress -cjf myArchive.tar.bz2 myfiles0## LinuxPlease install thepvpackage.
Package: tarraz
Tarraz | طرّازA cross-stitch image generator.
Generates a cross stitch pattern from an image of your choice. The generated pattern is DMC colored.Takes an image file and generates a cross stitch pattern using a user specified color..Supported image extensionsJPEG (.jpg, .jpeg)PNG (.png)WebP (.webp)Current color providersDMCResultsUsageInstallationpip install tarrazCLI Exampletarrazimages/palestine.png--colors4--stitches-count200Python Examplefromtarrazimportconstantsfromtarraz.processorimportTarrazfromtarraz.providersimportDMCProviderfromtarraz.stitcherimportSVGStitcherfromtarraz.modelsimportRGB# Choose a color providerimage_path="images/palestine.png"provider=DMCProvider()tarraz=Tarraz(image_path,provider=provider,# Optional if not using a custom providerx_count=100,# Default 50colors_num=6,# default 3result_width=200,# Default 1000cleanup=True,# Default True)# Process the imagepattern,colors=tarraz.process()# Stitch the resultSVGStitcher.stitch(pattern,colors,tarraz.size,transparent=[RGB(255,255,255)],configs=constants.SVG_VARIANTS,cell_size=10,save_to="/tmp/test/",)Options$tarraz--help
usage:tarraz[-h][--version][-cCOLORS][-nSTITCHES_COUNT][-wWIDTH][-mDMC][-tTRANSPARENT[TRANSPARENT...]][-oDIST][-zCELL_SIZE][--no-cleanup][--svg]image

GenerateaDMC-coloredcross-stitchpatternfromagivenimage.

positionalarguments:imageInputimage

optionalarguments:-h,--helpshowthishelpmessageandexit-v,--versionshowprogram's version number and exit-c COLORS, --colors COLORSNumber of colors to use in the pattern.-n STITCHES_COUNT, --stitches-count STITCHES_COUNTNumber of stitches to use in the x axis.-w WIDTH, --width WIDTHResult pattern width.-m DMC, --dmc DMC     DMC json color path.-t TRANSPARENT [TRANSPARENT ...], --transparent TRANSPARENT [TRANSPARENT ...]A Color to ignore from the end result.-o DIST, --dist DIST  DMC json color path.-z CELL_SIZE, --cell-size CELL_SIZEThe size of the generated Aida fabric cell.--no-cleanup          Don'truncleanupjobongeneratedimage.--svgExportresulttosvgfiles.DevelopmentPre-requisitespip3install-Upipsetuptools
pip3installpoetry# Optional Auto-completionpoetrycompletionszsh>~/.zfunc/_poetryInstall dependenciespoetryshell
poetryinstall
pre-commitinstall[!NOTE]
If you don't want to keep the current package installed runpip uninstall tarraz. However, you might want to add the project
to yourPYTHONPATHusingexport PYTHONPATH="${PYTHONPATH}:/path/to/tarraz"UsageContinue usage as listed above
Package: tarsafe
# Tarsafe![Unit Tests](https://github.com/beatsbears/tarsafe/workflows/Unit%20Tests/badge.svg)Tarsafe is a drop-in replacement for the tarfile module from the standard library to safely handle the vulnerable `extractall()` method. Inspired by a [6 year old security bug](https://bugs.python.org/issue21109).## Installation```$ pip install tarsafe```## Usage```from tarsafe import TarSafetar = TarSafe.open("example.tar", "r")tar.extractall()tar.close()# ORwith TarSafe.open("example.tar", "r") as tar:tar.extractall()```
Package: tarski
Tarski - An AI Planning Modeling FrameworkWhat is TarskiTarski is a framework for the specification, modeling and manipulation ofAI planningproblems.
Tarski is written in Python and includes parsers for major modeling languages
(e.g.,PDDL,FSTRIPS,RDDL),
along with modules to perform other common tasks such as logical transformations,
reachability analysis, grounding of first-order representations and problem reformulations.Installation: Check theinstallation instructions.Documentation: Read thedocumentation of the project.Testing: Most tests can be run by executingpyteston the root directory.
Alternatively, they can be run throughtox, for which several testing environmentsare defined.How to CiteIf you findtarskiuseful in your research, you can cite it with the followingbibtexentry:@misc{tarski:github:18,
  author = {Guillem Franc\'{e}s and Miquel Ramirez and Collaborators},
  title = {Tarski: An {AI} Planning Modeling Framework},
  year = {2018},
  publisher = {{GitHub}},
  journal = {{GitHub} repository},
  howpublished = {\url{https://github.com/aig-upf/tarski}}
}LicenseTarski is licensed under theApache-2.0 License.
Package: tarski-lapkt
Tarski-lapkt - A fork of tarski for lapktThe tarski-lapkt package is an minor extension ofTarski. It includes additional modules to integratelapktandtarskiNote - Users should follow the copyright and license requirements ofTarskiwhich are as follows.How to CiteIf you findtarskiuseful in your research, you can cite it with the followingbibtexentry:@misc{tarski:github:18,
  author = {Guillem Franc\'{e}s and Miquel Ramirez and Collaborators},
  title = {Tarski: An {AI} Planning Modeling Framework},
  year = {2018},
  publisher = {{GitHub}},
  journal = {{GitHub} repository},
  howpublished = {\url{https://github.com/aig-upf/tarski}}
}LicenseTarski is licensed under theApache-2.0 License.
Package: tarsplit
TarsplitA utility to split tarballs into smaller pieces along file boundaries.This is useful for gigantic tarballs that need to need to be split up so that they can fit on USB sticks, more reasonably sized Docker layers, or whatever.InstallationPreferred methodpython3 -m pip install tarsplitManuallypython3 -m pip install git+https://github.com/dmuth/tarsplit.gitUsagetarsplit [ --dry-run ] tarball num_filesExample run:FAQHow does it work?This script is written in Python, and uses thetarfile moduleto read and write tarfiles.  This has the advantage of not having to extract the entire tarball,
unlike the previous version of this app which was written in Bash Shell Script.Why?While working onSplunk Lab, I kept running into
an issue where a particular layer in the Docker image was a Gigabyte in size.  This was a challenge because
there was a number of wallclock seconds wasted when processing the large layer after a push or pull.  If
only there was a way to split that layer up into multiple smaller layers, which Docker would then
transfer in parallel...While investigating, the culprit turned out to be a very large tarball.  I wanted a way to split that
tarball into multiple smaller tarballs, each of which contained a portion of the filesystem.  Then, I could
build multiple Docker containers, each with a portion of the original tarball's files, with each container
inheriting the previous container.  This would leverage one of the things Docker is good at: layered filesystems.This is slow on large files.  Ever hear of multithreading?Yeah, I tried that after release 1.0.  It turns out that even when using every trick I knew that
a multithreaded approach consisting of one thread per chunk to be written wasslowerthan just
doing everything in a single thread.  I observed this on a 10-core machine with an SSD, so I'm
just gonna go ahead and point the finger at the GIL and remind myself that threading in Python is cursed.What about asyncio?I used asyncio successfully for another project and haven't ruled it out.  I am however skeptical because of the
very high level of disk usage.  Async I/O would be more approiate for dozens/hundreds of writers hitting
the disk occasionally, and this is not the case here.DevelopmentSupport scriptsbin/create-test-tarball.sh- Create a test tarball with directories and files inside.sha1-from-directory.sh- Get a recursive list of all files in a directory, sort it, SHA1 each file, then concatenate all SHA1s and SHA1 that!sha1-from-tarball.sh- Extract a tarball, then do the same thing to the contents assha1-from-directory.sh.Publishing a new packagerm -rfv distBump version number insetup.pypython3 ./setup.py sdisttwine upload dist/*TestsTests can be run withtests.sh.  A successful run looks something like this:
Package: tart
TART: Radio-telescope operating softwareThis module is used for the operation and imaging from the open-source Transient Array Radio Telescope (TART).For more information see theTART Github repository, and (https://tart.elec.ac.nz)AuthorsTim Molteno (tim@elec.ac.nz)Max Scheel (max@max.ac.nz)Development workIf you are developing this package, this should be installed usingmake developin which case changes to the source-code will be immediately available to projects using it.NEWSChangelog:1.2.0b1 TART tools update (new tart_get_archive_data super-handy tool)1.1.2b8 TART tools update1.1.2b7 Handle expiration of JWT tokens better (in tart_tools)1.1.2b6 Pass the lat and lon to catalog_url1.1.2b5 Require the python-dateutil library1.1.2b4 Require the requests library1.1.2b3 Change API of catalog_url to use lon and lat explicitly1.1.2b0 make h5 to json compatible with tart2ms json import.1.1.1b1 Make sure all get_all_uvw() return meters rather than wavelengths.1.1.0b9 Switch to new based utc class,
Fix up some old tests1.1.0b8 Move to separate repository.
Better tests.1.1.0b7 Better dealing with h5 files, returning a dict with sufficient information to generate calibrated visibilities.1.1.0b6 Save calibration gains and phases.1.1.0b5 Use raw docstrings for those that contain escape sequences.1.1.0b4 Fix hdf5 visibility output.1.1.0b3 Rework empirical antenna model.1.1.0b0 Add hdf5 IO0.15.5  Added EPHEMERIS_SERVER_HOST, POSTGRES_HOST, POSTGRES_USER, POSTGRES_PASSWORD environment variable.
Package: tartan
tartanRenders tartan images from threadcount definitions.Free software: MIT licenseDocumentation:https://tartan.readthedocs.io.FeaturesCommand line interface to generate a PNG image from a threadcount.Generate a PIL image in memory.Generate images with your preferred size.Repeating and reflective setts.See alsoGuidance about threadcountsfrom the Scottish Register of Tartans.@RandomTartan,a Twitter bot that uses this library.filly-more,a Glitch project that demonstrates this application.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-03-03)First release on PyPI.0.1.1 (2020-03-07)threadcount_to_image can now be imported from tartan, rather than tartan.tartanBetter CLI help
Package: tartare
TartareTartare is a toolkit for curating multimodal datasets.DevelopmentFollow these steps to setup your development environment:Step 1: Create an environmentUse Python 3.8 or higher.condacreate-ntartarepython=3.8Step 2: Activate the environmentcondaactivatetartareStep 3: Install CMakecondainstall-cconda-forgecmakeStep 4: Setup development environmentmakedevelop
Package: tartaruga
tartarugaTartaruga is another ratelimiter library, based on Redis. It allows for distributed rate-limiting accross different processess, or even hosts.Getting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes.PrerequisitesPython 3.x, PIP, Redis server up and runningInstallingLibrary can be installed simply with pip:pip install tartarugaor by running:make installUsage examplesExample usage.
Ratelimiting 10 requests per second + 120 requests per minute + 240 requests
per hour:from tartaruga.ratelimiter import rate_limit

limits = [(1, 10), (60, 120), (3600, 240)]

@rate_limit(api_id='MyShinyAPI', limits=limits)
def somefunction():
    # here you can call the APIContributingTBDAuthors**Devmons s.r.o. -Initial work-crypkitLicenseCommercial
Package: tartes
TARTES is a fast and easy-to-use optical radiative transfer model used
to compute snow albedo (spectral and broadband) and energy absorption
profile. TARTES represents the snowpack as a stack of horizontal
homogeneous layers. Each layer is characterized by the snow specific
surface area (SSA), snow density, impurities amount and type, and two
parameters for the geometric grain shape: the asymetry factor g and
the absorption enhancement parameter B. The albedo of the bottom
interface can be prescribed. The model is fast and easy to use
compared to more elaborated models like DISORT - MIE (Stamnes et
al. 1988). It is based on the Kokhanovsky and Zege (2004) formalism
for weakly absorbing media to describe the single scattering
properties of each layers and the delta-eddington approximation to
solve the radiative transfer equation. Despite its simplicity, it is
accurate in the visible and near-infrared range for pristine snow as
well as snow containing impurities represented as Rayleigh scatterers
(their size is assumed much smaller than the wavelength) whose
refractive indices and concentrations can be prescribed.TARTES is compatible with Python 2.7x and 3.4+.
Package: tart-hardware-interface
This module is used for low-level interfacing to the open-source
Transient Array Radio Telescope (TART).For more information see theTART github
repositoryAuthorsTim Molteno (tim@elec.ac.nz)Max Scheel (max@max.ac.nz)Pat Suggate (ihavenolimbs@gmail.com)Development workIf you are developing this package, this should be installed usingpython setyp.py developin which case changes to the source-code will be immediately available
to projects using it.NEWSVersion 0.1.6. Python3 supportVersion 0.1.7. Further python3 supportVersion 0.1.8. Remove unused routines
Package: tartiflette
Tartifletteis a GraphQL Server implementation built withPython 3.6+.SummaryMotivationStatusUsageInstallationBuilding from sourceHTTP server implementationsRoadmapsHow to contribute to the documentation?How to run the website locally?MotivationRead this blogpost about our motivationsTL; DR
We reached the limits of Graphene, we wanted to build something which met certain requirements:Offers a better developer experiencethat respects the Python mindsetUses SDL(Schema Definition Language)Usesasyncioas the sole execution engineBe 100% open sourceStatusThefirst milestoneis behind us, we are nowon the road to the milestone 2.DNADefine theGraphQL schemawith the brand newSDL(Schema Definition Language).Performance oriented:Performance is the core of our work.Simple is better than complex:Built withthe Zen of Pythonin mind. No over-engineering.Discover Tartiflette with our fabulous tutorial onhttps://tartiflette.io/docs/tutorial/getting-startedUsageimportasynciofromtartifletteimportResolver,create_engine@Resolver("Query.hello")asyncdefresolver_hello(parent,args,ctx,info):return"hello "+args["name"]asyncdefrun():engine=awaitcreate_engine("""type Query {hello(name: String): String}""")result=awaitengine.execute(query='query { hello(name: "Chuck") }')print(result)# {'data': {'hello': 'hello Chuck'}}if__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(run())More details on theAPI DocumentationInstallationTartiflette is available onpypi.org.While the project depends onlibgraphqlparser,
wheels are provided since version 1.4.0, ensuring that no system dependency is required.To install the library:pipinstalltartifletteBuilding from sourceIf you use a platform incompatible with the provided wheels, you'll need to installcmaketo buildlibgraphqlparserin order to install the library.macOSbrewinstallcmakeDebian/Ubuntuapt-getinstallcmakeHTTP server implementationstartiflettelibrary itself is transport agnostic, but to simplify integration with existing HTTP servers, two
different libraries are available:tartiflette-aiohttp: integration withaiohttptartiflette-asgi: integration with ASGI compatible HTTP serversRoadmapsMilestone 1(Released)Milestone 2 -Work in progressHow to contribute to the documentation?As you may know, the documentation is hosted onhttps://tartiflette.io. Thisfabulouswebsite is built thanks to another amazing tool,docusaurus.The content of the documentation is hosted in this repository, to be as close as possible to the code. You will find everything you need/want in the folder/docs.How to run the website locally?We built a docker image for the documentation(tartiflette/tartiflette.io on docker hub), which allow us to provide you an easy way to launch the documentation locally, without installing a specific version of node.prerequisite:DockerDocker ComposeMakemakerun-docsEvery change you will make in the/docsfolder will be automatically hot reloaded. :tada:
Package: tartiflette-middleware
Tartiflette MiddlewareFramework to facilitate the creation of middleware forTartiflettewith
resolver context variable assignment using python context managers.Allows for processing of request/response headers, dependent on the
http server you're using.Installationpipinstalltartiflette-middlewareUsageThis requires:Creation of your middleware.Configuration of your middleware in your application.Update your resolvers to access your data.1 - Creation of your middlewareCreate a context manager to run on each request.Example:fromtartiflette_middlewareimportBaseMiddlewareclassMyMiddleware(BaseMiddleware):# required short arbitrary unique middleware labellabel='MyMware'def__init__(self,my_middleware_params):BaseMiddleware.__init__(self)# do things necessary for repeated use across all of the requests, e.g.# configure factoriesasyncdef__aenter__(self):# provide the data or method to be used in all queries for a single# request.your_method_or_data=...# store the data/method to be reused for this requestawaitself.store_request_data(your_method_or_data)asyncdef__aexit__(self,exc_type,exc_val,exc_tb):# optional: for if you need to do something when the request is# completeddata=awaitself.get_request_data()data.close_or_whatever()There are more examples in the examples directory including one with access to
AIOHTTP request headers.You can set the response http status using something like:asyncdef__aenter__(self):self.status=4012 - Configuration of your middleware in your appCurrently only AIOHTTP is supported but the library is extensible if others
would like to submit a pull request to support other servers that Tartiflette
supports.Limited AIOHTTP setup example, imports and configuration kept to middleware specific
details:fromtartiflette_middlewareimportMiddleware,serverimportMyMiddleware# your Middleware as defined earliermy_middleware=Middleware(context_manager=MyMiddleware(my_middleware_params={},),server_middleware=server.aiohttp)app=web.Application(middlewares=[my_middleware.middleware])ctx={'my_session_service':my_middleware.service,}web.run_app(register_graphql_handlers(# your configurationexecutor_context=ctx,))3 - Access data in your resolvers' contextWorks in queries, mutations, and subscriptions.@Resolver('Query.whatever')asyncdefresolve_query_user_login(parent,args,ctx,info):my_data=awaitctx['my_session_service']()
Package: tartiflette-plugin-apollo-federation
Seehttps://github.com/remorses/tartiflette-apollo-federation-examplefor an example
For now the plugin only supports simple sharing of types with the same fields and merging of the query and mutation fileds,
In the near future there will be support for the@keydirective and a new@ResolveReference('TypeName')decorator to resolve the types between servers, similar to how Apollo__resolveReferenceworks.To suggest other better api ideas on how to implement__resolveReferenceopen a issue.Installationpip install tartiflette_plugin_apollo_federationUsagefromtartiflette_aiohttpimportregister_graphql_handlersfromtartiflette_plugin_apollo_federationimportApolloFederationPlugindefrun():engine_sdl="./sdl/"app=register_graphql_handlers(app=web.Application(),engine_sdl=engine_sdl,engine_modules=[ApolloFederationPlugin(engine_sdl=engine_sdl)],executor_http_endpoint="/graphql",graphiql_enabled=True,)web.run_app(app,port=PORT)run()Then usexmorse/apollo-federation-gatewayto glue together your servicesversion: '3'
services:
    service1:
        build: ./service1
    service2:
        build: ./service2
    gateway:
        image: xmorse/apollo-federation-gateway
        ports:
            - 8000:80
        environment: 
            URL_0: "http://service1:8001/graphql"
            URL_1: "http://service2:8002/graphql"