Saravanan666/pypi-org huggingface dataset:
Package: graniteloom
granite.Granite is our tool to handle working from foreign devices. It usesGithub Access Tokensto clone, commit and push to your repositories.Install ✅Use thepip installcommand:python-mpipinstall--upgradegraniteloomInstall the test version:python-mpipinstall--index-urlhttps://test.pypi.org/simple/--extra-index-urlhttps://pypi.org/simple--upgradegraniteloomOnce the install is complete, check if it worked:python-mgarniteloomhelpHow to use?The granite CLI uses an eccentric naming system for arguments and argument types:Normals:<cmd><arg1><arg2>...<argn>Normal args don't have a special syntax, it's just the command.Modifiers:<cmd>-modifier<modifier-value>-modifier2"a modifier accepts strings"The modifiers take a value which can be a single word or a string.Tags:<cmd>--tagTags modify the command line experience, but they don't take values.Show the help menu 📜The help menu has explanations for all available commands.python-mgarniteloomhelpClone a repository 📦If the-rand/or-tmodifiers are not provided, the CLI will prompt you to specify the repository url and the access token.python-mgarniteloomcloneWorkspace ⚗️The workspace category contains commands which are helpful when managing previously cloned repositories.Thelogin/joincommand:You can log into a workspace, this means adding the remote origin by providing the access token and the repository's url.If the-rand/or-tmodifiers are not provided, the CLI will prompt you to specify the repository url and the access token.python-mgarniteloomworkspacejoinThelogout/quitcommand:You can logout from a workspace, this removes the remote origin, so you will be able to commit until you sign in again.If the-rand/or-tmodifiers are not provided, the CLI will prompt you to specify the repository url and the access token.python-mgarniteloomworkspacequitModifiers 🛠️The modifiers used to make managing repositories a bit easier.-r- repositoryThe-rmodifier is used to provide the repository's url.If used alone, without-tthe CLI will still prompt you for the access token.python-mgarniteloomclone-rhttps://github.com/example/repository-t- tokenThe-tmodifier is used to provide the personal access token.If used alone, without-rthe CLI will still prompt you for the repository's url.python-mgarniteloomclone-t<token>
Package: granitepy
granitepygranitepy is a python wrapper for theLavalinklike audio provider calledAndesitefor use withdiscord.py.LinksDiscord support serverDocumentationInstallationFrom Pypipipinstall-UgranitepyFrom Githubpipinstall-Ugit+https://github.com/iDevision/granitepyExamplefromdiscord.extimportcommandsimportgranitepybot=commands.Bot(command_prefix="!")bot.granitepy=granitepy.Client(bot)@bot.eventasyncdefon_ready():awaitbot.granitepy.create_node(host="node-ip",port=12345,password="node-password",identifier="node-name")@bot.command()asyncdefconnect(ctx):# Create or fetch a player.player=bot.granitepy.get_player(guild=ctx.guild)# Check is the author is in a voice channel.ifnotctx.author.voice:returnawaitctx.send("You must be connected to a voice channel")# Connect to the authors voice channel.awaitplayer.connect(ctx.author.voice.channel)returnawaitctx.send(f"Connected to{ctx.author.voice.channel.name}!")@bot.command()asyncdefplay(ctx,*,search):player=bot.granitepy.get_player(guild=ctx.guild)# Search for whatever the user has inputted.result=awaitplayer.get_tracks(search)# The users search returned nothing.ifnotresult:returnawaitctx.send("No tracks were found.")# Check if the result is a playlist.ifisinstance(result,granitepy.Playlist):# Play the first track in the playlist.returnawaitplayer.play(result.tracks[0])else:# Play the first track in the list of results.returnawaitplayer.play(result[0])bot.run("token")
Package: grano
granois a social network analysis tool for data-driven news applications. It provides components needed to build domain-specific social network applications. For example, it can be used to track the relations between people, institutions and companies expressed through financial flows and other interactions.Grano is currently developed as a backend toopeninterests.euandnomenklatura.Documentation for grano is available atdocs.grano.cc, including:Installation instructionsTechnical introductionWeb (REST) APIgranois also available on cheeseshop, and can be installed with:pip install grano
Package: granola
GRANOLAGRANOLA (Generating Real-time Autonomous N-device Output without Linked Apparatuses) is a package aiming to mock Pyserial's Serial with the goal of enabling automated testing, faster QA, and faster delivery. The core of this package is the class
Cereal. Cereal allows you to define complicated command and response sequences, getters and setters for commands that set attributes
on your device (such as the serial number), a hook system to inject your own needed functionality, and a Serial Sniffer to capture serial
command output from a real device as the basis of mocking later.warning!This project is still in it's beta, pre 1.0 stage with active development moving towards its 1.0 release.
We try and not break previous interfaces when we move to new releases, but until it is ready for 1.0, it is still
unstable.Package InstallationTo install:pip install granolaA Simple Example>>>fromgranolaimportCereal>>>command_readers={"CannedQueries":{"data":[{"1\r":"1","2\r":["2a","2b"]}]}}>>>mock_cereal=Cereal(command_readers)>>>mock_cereal.write(b"2\r")2>>>mock_cereal.read(2)b'2a'>>>mock_cereal.write(b"1\r")2>>>mock_cereal.read(1)b'1'LinksDocumentation:https://granola.readthedocs.io/en/stable/Examples:https://granola.readthedocs.io/en/stable/examples/examples_notebooks.htmlPyPI:https://pypi.org/project/granola/Source Code:https://github.com/metergroup/GRANOLAIssue Tracker:https://github.com/metergroup/GRANOLA/issues
Package: granola-py
Granola:Granola is a Python library for building apis and backend applications, with an emphasis on reusability and horizontal scaling.FeaturesBuilt for python, a popular and versatile programming language that is easy to learn and use.Monstrously fast performance, thanks to being written in Rust.Object-Oriented, easy-to-use API for building backend applications quickly.Installation:you can install granola usingpipby running the following command:Usage:Contributing:We welcome contributions to Granola. If you have an idea for a new feature or have found a bug, please open an issue on our GitHub repository. If you would like to contribute code, please open a pull request with your changes.License:MIT
Package: grano-ui
# Grano User Interface[grano](http://grano.cc/) is a toolkit for building journalistic social network analysis applications on the web. This package contains an administrative user interface based on [AngularJS](http://angularjs.org/). The interface is intended for managing entities
and analysis for advanced users, not as a general-purpose interface.## Installationgrano-uirequires that you have installed and configured [grano](http://grano.cc/). Please refer to [grano’s documentation](http://docs.grano.cc/) for further instructions. You’ll also need to install these external (non-Python dependencies):Twitter’s [bower](https://github.com/bower/bower) for installing JS dependencies.[UglifyJS](https://github.com/mishoo/UglifyJS/) for JS minification.[Less](http://lesscss.org/) for compiling the CSS resources.To install the package from GitHub, you need to follow these steps from within the virtual environment in whichgranohas been installed:`bash git clonehttps://github.com/granoproject/grano-ui.gitcd [grano dir] virtualenv env source env/bin/activate cd[grano-uidir] python setup.py develop bower install (in docker, use--allow-rootor su app-c"bower install") `After installing the package, you will still need to enable this plugin. Add the entryuito thePLUGINSvariable in your grano settings file. If you have no other plugins installed, try this:`python PLUGINS = ['ui'] `## ConfigurationBy default,grano-uiwill deploy itself to the web root ofgranowhen it has been activated as a plugin. You can change that path by setting aUI_PREFIX, starting with a forward slash.`python UI_PREFIX = '/grano' `Further, asset compilation and minification can be enabled by setting theASSETS_DEBUGvariable toFalse.
Package: granturismo-stats
granturismo-statsStatistics for Gran Turismo online eventsPurposeI started this project because I wanted to see how my qualifying times for the
Gran Turismo Sport daily races compare to other drivers with similar driver and sportsmanship rating.This is a work in progress. Currently, it is possible to do exactly what my original
goal included: get the complete qualifying leaderboard and compute some basic statistics.If you have suggestions what information to add feel free to open an issue and I will
see if it is a) possible and b) I find it interesting as well. ;)ExamplesIf you would like to see example code, look at theexamplesdirectory on github.LimitationsPerformanceThe performance is not the best. While there are probably a few things that can be done
on my side of the code, the main limiting factor when retrieving the qualification
leaderboards is the Gran Turismo Sport API itself which limits the number of entries that
can be obtained in a single request and takes quite some time to respond.
With several ten thousand qualification entries for each race it can easily take 10 seconds or
longer to obtain them all. Just be patient! :)RegionThere is currently no option to change the region for which you want to retrieve the results.
The code uses the API URL for Germany and thus the results are all for the EMEA region.
However, this is something I'd like to change in the future (see issue #1).Further remarksBear in mind that in order to retrieve a full leaderboard somewhat in the region of
50 requests will be sent concurrently to the GT Sport API.
Use this library responsibly. Querying the leaderboard every now and then should be
totally fine, but doing so over and over again without a pause in an endless loop will
generate a lot of traffic on the server side.I intend to implement a caching mechanism so that executing a script multiple times will
become faster on the one hand and produce less traffic on the other.
Until then, check out theget_leaderboardfunction ofgtsport_test_drive.pyin theexamplesdirectory how to do it yourself.KudosThe unofficial GT Sport API documentation from Alex Persian made the whole process a lot easier:https://github.com/alexpersian/gt7sp-api
Package: granula
Granulais a tool that aims to help maintain multi-file configurations for
Python applications (with environments and more).Installation$ pipenv install granulaor just use pip (though you should definitely take a look atpipenv)🌈🌈🌈FeaturesGathers configurations from multiple files or directories.Supports widely used file formats (YAML, JSON).Offers a small DSL that allows to load environment variables into config files.Manages different configuration environments (e.g. testing, production).UsageCreate a config object from a directory with multiple configuration files:>>importgranula>>config=granula.Config.from_directory('examples/multi-file/settings')>>configConfig({'name':'Darth Vader',...})>>config.name'Darth Vader'>>config.familyConfig({'fiancee':'Padme Amidala','children':['Luke Skywalker','Leia Organa']})Files are parsed in lexicographic order. The values specified in the preceding files can be overwritten in the succeeding files.Do the same in a recursive manner:>>config=granula.Config.from_directory(...,recursive=True)Match YAML files using filename pattern:>>config=granula.Config.from_directory(...,pattern=granula.Extension('yaml'))Do the same with a shell-style wildcard pattern:>>config=granula.Config.from_directory(...,pattern=granula.Wildcard('*.yaml'))Match configuration files for different environments:>>directory='examples/environments/settings'>>testing=granula.Config.from_directory(directory,pattern=granula.Environment('testing'))>>production=granula.Config.from_directory(directory,pattern=granula.Environment('production'))Combine patterns in arbitrary ways:>>pattern=granula.All(granula.Environment('testing'),granula.Extension('yaml'))>>config=granula.Config.from_directory(...,pattern=pattern)Load environment variables into config files using a DSL, for example, in YAML:variable: ${env VARIABLE}Do the same with a default value:variable: ${env VARIABLE | val 10}
Package: granular-engine
A Utility Library that assists in Geospatial Machine Learning Experiment
Tracking.Installationpipinstallgranular-engineUsageCLIengine_cliExperiment TrackingfromengineimportEngineengine=Engine("test_config.yaml")forepochinenumerate(epochs):# train# evalengine.log(step=epoch,train_loss=train_loss,val_loss=val_loss)engine.done()LicenseGPLv3DocumentationView documentationhere<https://engine.granular.ai/>_
Package: granulemeta
granulemetaThis code was originally created as a file-level metadata extraction tool for use by the ORNL DAAC. The update to version 3 represents a complete refactoring in the approach taken by the prior version of ORNL DAAC's file level metadata extraction tool. The refactoring of the code put an emphasis on making the codebase more maintainable and extensible while making the code's execution more consistently stable and yet more flexible in how the code could be utilized by the end-user.The default output for granulemeta-v3 is a csv ingmoutformat (as is necessary for ORNL DAAC's ingest process), however the code can easily be extended to accomodate other output formats.installpip install granulemetausageRun from the command line:granulemeta.py -o [OUTPUT_FILE].csv [PATH: directory or file or glob]Run from docker container for local development:./run-docker-dev.sh [PATH TO DATA DIRECTORY] [PATH TO GRANULEMETA CODE DIRECTORY]This will give you a command line environment to run granulemeta in. The first path argument provided will be mounted as/dataand the second path argument as/code. Within the dev container, granulemeta can be run using the following syntax:granulemeta -o [OUTPUT_FILE].csv [PATH: directory or file or glob]requirementsThis script was developed on Python 3. It relies onfivepackages not in Python's standard library:numpy:https://numpy.org/pandas:https://pandas.pydata.org/netCDF4:https://unidata.github.io/netcdf4-python/netCDF4/index.htmltinytag:https://pypi.org/project/tinytag/gdal:https://gdal.org/python/requirements.txtwas last generated on 2022-06-09.notesNotable features added since the creation of version 3:Lines are written to the output file as it processes each granule instead of waiting until all granules have been processed to write the output file.Unless the--overwriteoption is given, the script will skip granules already present in the output file. This (coupled with the feature directly above) will allow the script to pick up where it left off if it crashes partway through processing a dataset.There is a--nfiles(or-n) option that allows the script to automatically stop execution after processing a specified number of granules.Glob syntaxcan now be used for the inputpathargument to allow a user to restrict the files that a given execution of the script processes (i.e. using/path/*.ncas your input path would only process granules with the.ncfile extension).Behind the scenes, the code is better organized to better facilitate redability, maintainability, and extensibility. This has been accomplished by breaking the code up into several modules.authorshipThe following authors have contributed to the granulemeta development process:Kent Campbell, Jack McNelis, Vinny Palandro, Yaxing Wei, Tammy Walker, Matt Donovan, Jessica Welch, Daine Wright, Bruce Wilson, Chris Lindsley, Ketan Patel, Scott Pearson, Rupesh Shrestha, Tom Rugglescontactsauthor:campbellkb@ornl.gov
Package: grapefruit
GrapeFruit is a pure Python module that let you easily manipulate and convert color information.
Its Primary goal is to benaturalandflexible.The following color systems are supported by GrapeFruit:RGB (sRGB)HSLHSVYIQYUVCIE-XYZCIE-LAB (with the illuminant you want)CMYCMYKHTML/CSS color definition (#RRGGBB, #RGB or the X11 color name)RYB (artistic color wheelLicenseCopyright (c) 2008, Xavier Basty

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: grapejuice
Grapejuice⚠️ You need at least Wine 6.11 for the Roblox game client to work!
Please grab an up to date copy from your repositories. If your repositories don't have Wine 6.11, have a look at
WineHQ's official repositories:https://wiki.winehq.org/DownloadThese days Roblox works quite well with Wine, though there are some minor issues running it. Grapejuice fills in the
gaps around these issues, so you can experience Roblox to its fullest on your favourite Linux distribution.The primary gap-filler feature is the fact that Wine by default creates no protocol handlers, which is how Roblox
functions at its core. Without protocol handling, you won't be able to launch Roblox Studio and Experiences from the
website!Installing Grapejuice from sourceInstalling from source differs per distributions, please follow the appropriate installation guide for yours. All the
installation guides can be found in theGrapejuice WikiTroubleshootingAre you experiencing some trouble running Roblox Studio with Grapejuice? Please check out
theTroubleshooting GuideFeaturesContain and automate a Wine prefixEdit Roblox experiences from the websiteEnjoy Roblox experiences by launching them from the website.Expose utility functionsFFlag editor for tweaking Roblox' behaviourRoblox and Wine compatibilityWhat works:Roblox StudioTeam CreatePlay SoloTest ServerRoblox Player, granted you have an up to date version of Wine.What doesn't work:Plugin gui's may cause seizures with some rendering methods. More about this issue is discussed in
theTroubleshooting Guide
Package: grape-mathlab
GRAPE is a Python package that takes advantage of Graph Theory into a High Performance Computing (HPC) environment to develop a screening tool aimed at studying the effect of different kinds of perturbations in interconnected systems, such as indsutrial plants.
The tool allows to represent the dependencies between components and predict the state of health and the residual functionality of degradable systems after a damage, suggesting the proper reconfiguration strategies to mitigate it. The results obtained from the graph analysis can be therefore used to improve topology, robustness, and resilience profile of industrial facilities against domino effect propagation.In particular, the components contribution to the cascade effects resulting from adverse events can be evaluated through centrality and efficiency measures, highlighting the plants major criticalities, vulnerabilities and potential weak points.
Considering that the most computationally expensive parts of the program involve the calculation of shortest paths, parallelization of shortest path computation in large unweighted graphs was integrated in the program. This was done taking advantage of the Python module multiprocessing. Two different sequential algorithms for the solution of the shortest path problem have been parallelized including a Single Source Shortest Path (SSSP) algorythm for sparse graphs and an All Pairs Shortest Path one (APSP) for dense graphs.
Package: grape-model
GRAPEGRAPE is a regression API in Python environmentDescriptionGRAPE makes it easy to fit a regression model with hyperparameter optimization. It strings together the workflow of model fitting, hyperparameter tuning, and model diagnostics. (model interpretability coming soon!).Available Regression MethodsElastic Net (from sklearn)Random Forest (from sklearn)xgboostlightgbmHyperparameter OptimizationGrape Uses Hyperopt's tree parzen estimator
Package: grape.pipeline.runner
Grape (Grape RNA-Seq Analysis Pipeline Environment) is a pipeline for processing
and analyzing RNA-Seq data developed at the Bioinformatics and Genomics unit of
the Centre for Genomic Regulation (CRG) in Barcelona.The grape.buildout packages installs the command line tools of the grape.pipeline.runner
package for automatically running your configured pipelines.To learn more about Grape, and to download and install it, go to the Bioinformatics
and Genomics website at:Grape HomepageLinks:Documentation:http://readthedocs.org/projects/grapepipelinerunner/The repository and issue tracker is at GitHub :https://github.com/maikroeder/grape.pipeline.runnerThe grape.pipeline.runner package is available on PyPi:http://pypi.python.org/pypi/grape.pipeline.runner1.0 (2012-08-16)First release
Package: grape.recipe.pipeline
The grape.recipe.pipeline package is a Buildout recipe used for
configuring Grape, a pipeline used for processing and analyzing RNA-Seq data.
RNA-Seq is a next generation sequencing technology used to sequence cellular RNA.
To run Grape, you need the read files in Fasta, FastQ or prealigned SAM/BAM formats,
as well as a genome and a gene transcript annotation. First, Grape does the quality
control and then aligns the reads to the genome. The core of Grape is the analysis of
the transcriptome. Grape quantifies Gene and transcript expression levels, estimates
exon inclusion levels, and discovers novel splice forms for you, and includes a powerful
web application that allows you to seamlessly publish your summary statistics locally
or on the Internet.
While Grape can run on a standalone machine with modest hardware requirements, it is
designed to run in parallel on a computer cluster. Grape comes with its own default
mapping and quantification tools, and makes it easy to replace any of these tools with
your own, given that they support popular data interchange formats. Grape is being actively
developed at the CRG, and is used in dozens of projects with massive datasets,
like the Illumina Body Map Project (HBM) and the ENCODE project.
Package: grapes
grapesA simple library for dataflow programming in python.
It is inspired bypythonflowbut with substantial modifications.DependenciesThe coregrapesmodule depends onnetworkx, which can be found on PyPI and is included in the Anaconda distribution.For TOML support,tomliis needed before python 3.11 (in python 3.11,tomllibis part of the standard).To visualize graphs,matplotlibandpygraphviz(a wrapper forGraphviz) are also needed.
On  Windows,pygraphvizrequires theVisual Studio C/C++ build toolsto be installed (including MSVC tools), alongsideGraphviz2.46or higher, which should be inPATH.
This is explained in detail in the officialguideofpygraphviz.Finally,pytestis needed to run the tests.Installationgrapesis available onPyPI.
Install it from there withpip install grapesOtherwise you can install from source.
Move to the root directory of the grapes source code (the one wheresetup.pyis located) and runpip install -e .The-eflag creates an editable installation.Note that the dependencies related to graph visualization are not installed automatically and should be installed manually as explained in theDependenciessection.RoadmapFuture plans include:Better explanation of whatgrapesis.Usage examples.Better comments and documentation.Authorship and LicenseThe bulk ofgrapesdevelopment was done by Giulio Foletto in his spare time.
SeeLICENSE.txtandNOTICE.txtfor details on howgrapesis distributed.