Saravanan666/pypi-org huggingface dataset:
Package: gridly-cli
gridly-cliThis package provides a unified command line interface to GridlyRequirementThe gridly-cli package works on Python version:3.6.x and greater3.7.x and greater3.8.x and greaterInstallationInstallation of the Gridly CLI and its dependencies use a range of packaging features provided by pip and setuptools. To ensure smooth installation, it's recommended to use:pip: 9.0.2 or greatersetuptools: 36.2.0 or greaterThe safest way to install the Gridly CLI is to use pip in a virtualenv:$ python -m pip install gridly-cliConfigurationBefore using the Gridly CLI, you need to configure your API key. You can add the API key to Environment variables in this way:With MacOS and Linux:$ EXPORT GRIDLY_API_KEY=<your-api-key>With Windows:$ SET GRIDLY_API_KEY=<your-api-key>Basic CommandsAn Gridly CLI command has the following structure:gridly [OPTIONS] COMMAND [ARGS]...Options:--help  Show this message and exit.Commands:column    List all columns of a Grid

database  List all Databases

grid      List all Grids / Update Grid name
            -ls To list all Grids
            -u  To update Grid name

project   List all Projects

record    List all records of a view / Delete records
            -ls To list all records of a view
            -d To delete records

view      List all views / Get info of a specified view
            -ls To list all views

export [OPTIONS] VIEW_ID [DEST]
          Export all records of a view to JSON and/or CSV files
            -json To export to JSON file type
            -csv  To export to CSV file type
            -lang To export translation language columns to separate files
            [DEST] Optional. Path of folder where exporter will save files to. Default is current path.For example, to list project, the command would be:$ gridly project -ls
Package: gridmap
A package to allow you to easily create jobs on the cluster directly from
Python. You can directly map Python functions onto the cluster without needing
to write any wrapper code yourself.This is the ETS fork of an older project calledPython Grid. Unlike the older
version, it is Python 2/3 compatible. Another major difference is that you can
change the configuration via environment variables instead of having to modify
a Python file in yoursite-packagesdirectory. We’ve also fixed some bugs.For some examples of how to use it, check outmap_reduce.py(for a simple
example of how you can map a function onto the cluster) andmanual.py(for
an example of how you can create list of jobs yourself) in the examples folder.For complete documentationread the docs.NOTE: You cannot use GridMap on machines that are not allowed to submit jobs
(e.g., worker or edge nodes).RequirementscloudpickledrmaapsutilpyzmqPython 2.7+AcknowledgmentsThank you toMax-Planck-SocietyandEducational Testing Servicefor
funding the development of GridMap.ChangelogSeeGitHub releases.
Package: gridmeld
gridmeldis a Python3 application which consumes session data from
the Cisco ISE pxGrid service, and publishes IP indicators to Palo Alto
Networks MineMeld for consumption by PAN-OS.The pxGrid 2.0 REST and WebSocket APIs available in ISE 2.4 are used
to perform bulk session download, and subscribe to session directory
updates.  Sessions are synchronized to a MineMeldlocalDBminer
using the MineMeld config API as IPv4 or IPv6 indicators with a
TrustSec Security Group Tag (SGT).  The miner is connected to adagPusherNgoutput node which will push IP-SGT mappings to PAN-OS asregistered-ipobjects, which can be used to configure Dynamic
Address Groups (DAGs) for security policy enforcement.
Package: grid-run
GridRunGridRun is a simple tool that helps you to execute and manage similar shell commands. Originally, it is designed to perform grid-search of hyper-parameter in deep learning experiments. However, it can be used for other purposes as well.Installationinstall viapippip install grid_runUsageWhen you want to execute similar shell commands on a multi-gpu machine, you can use GridRun to generate sh commands and run in parallel.Consider a simple use case, you want to find the best learning rate, you can use the following command:fromgrid_run.runnerimportRunnerrunner=Runner(log_name="lr_search")exp_name=["1e-3","1e-2","1e-1","1","10","100"]lr=[0.001,0.01,0.1,1,10,100]# Do not write & to the end of the command, it will be added automatically.template="nohup python -u train.py --exp{}--lr{}"train_instructions=runner.gen_instruction(template,[exp_name,lr])gpus=[0,1]runner.run(train_instructions,gpus=gpus)# if you have less gpu, you can calculate the running time per job (e.g., 10 min), and run in sequence.runner.run(train_instructions,gpus=[0],interval_time=10)Grid runner will log the running status as well as hparams to log directory. For example:.
└── example_run
    ├── exp_0_gpu4.out
    ├── exp_1_gpu5.out
    ├── main.txt
    └── param
        ├── args_train.json
        └── template_train.jsonThis allows you to easily analyze the running status for each of hte experiments, as well as reproducing the experiment.OthersGridRun is written in a extremely simple way (~100 lines). It is originally a custom script that I write in a hour, after finding it is tedious to execute batches of jobs manually. I will add more features later. Also, if you find any bugs or have any suggestions, please open an issue.
Package: grids
grids - The Grids Python Tool for Querying Spatiotemporal Multidimensional DatasetsA python tool for extracting time series subsets from multi-dimensional data arrays developed by Riley Hales as part of a Master's Thesis in Civil and Environmental Engineering at Brigham Young University.CitinggridsIf you use this code, please cite the following academic journal article and source code doi's:https://doi.org/10.3390/w13152066https://doi.org/10.5281/zenodo.5225437Documentation and DemosRead documentation on ReadTheDocsUse a live demo notebook on Google Collaboratory
Package: gridsim
Gridsim is a Python 3 library for simulating robots in a grid-based world. It has a simple, well-documented API, making it easy to implement your own algorithms with minimal overhead.Key features include:Viewer for debugging and visualizing your simulationsBuilt-in data logging to HDF5 filesSupport for YAML configuration filesExtendable robot classes to avoid repeating your codeComprehensive documentation and examplesQuick Install$pipinstallgridsimFor more information and instructions, check out thedocumentation.LinksDocumentation:Read the DocsPyPi:gridsimContactIf you have questions, or if you’ve done something interesting with this package, send me an email:julia@juliaebert.com.If you find a problem or want something added to the library,open an issue on Github.
Package: gridslice
gridsliceCommand line tool for slicing an image on a grid. Good for spritesheets and that kind of thing.Installpip install gridsliceUsageusage: gridslice [-h]
                 input_image_path start_x start_y width height slices_x slices_y

Command line tool for slicing an image on a grid.

positional arguments:
  input_image_path  Path to the input image file
  start_x           Start x
  start_y           Start y
  width             Slice width
  height            Slice height
  slices_x          Number of x slices
  slices_y          Number of y slices

optional arguments:
  -h, --help        show this help message and exitstart_xandstart_yrepresent the top corner of the area to take slices from.widthandheightare the size of each slice.slices_xandslices_yare the number of slices of the specified size to make in each direction.
Package: gridstatus
gridstatusis a Python library that provides a uniform API for accessing electricity supply, demand, and pricing data for the major Independent System Operators (ISOs) in the United States. It currently supports data from CAISO, SPP, ISONE, MISO, Ercot, NYISO, and PJM.GridStatus.io and Hosted APITo preview some of the data this library provide access to, visitGridStatus.io.If you are trying to use our hosted API, you might want to check out the gridstatusio libraryhere.To learn more about our hosted API visit:https://www.gridstatus.io/api.CommunityNeed Help? Post aGitHub issueWant to chat? Join ourSlackWant to stay updated? Follow us on Twitter@grid_statusWant to contribute? Read ourContributing GuideInstallationgridstatussupports python 3.9+. Install with pippython -m pip install gridstatusUpgrade using the following commandpython -m pip install --upgrade gridstatusDocumentation and ExamplesTo learn more, visit thedocumentationand viewexample notebooks.Get HelpWe'd love to answer any usage or data access questions! Please let us know by posting a GitHub issue.
Package: gridstatusio
GridStatus.io Hosted APIPython client for accessing theGridStatus.io Hosted API.Installationgridstatusio supports python 3.8+. Install with pip:pipinstallgridstatusioUpgrade using the following commandpython -m pip install --upgrade gridstatusioGetting StartedCheck out this example notebook:Getting StartedOther Examples:Stacked Net Load VisualizationCAISO April Net Load AnalysisResample Data to Different FrequenciesOpen SourceIf you prefer to use an open source library that fetches data directly from the source, you can check out thegithub repo. For more information on Hosted API vs Open Source API, please see thisguideGet HelpWe'd love to answer any usage or data access questions! Please let us know by emailing us atcontact@gridstatus.io
Package: grid-strategy
grid-strategyGrid-strategy is a python package that enables the user
organizematplotlibplots using differentgrid strategies.AbstractThis package would add a mechanism for creating a grid of
subplots based on the number of axes to be plotted and
a strategy for how they should be arranged, with some
sensible strategy as the default.Detailed DescriptionIt is often the case that you have some number of
plots to display (and this number may be unknown
ahead of time), and want some sensible arrangement
of the plots so that they are all roughly equally
aligned. However, thesubplotsandgridspecmethods for creating subplots require both anxand aydimension for creation and population of
a grid. This package would allow users to specify a
strategy for the creation of a grid, and then specify
how many axes they want to plot, and they would
get back a collection of axes arranged according
to their strategy.A proof of concept was implemented for the 'squarish'
strategy, which arranges plots in alternating rows
ofxandx-1objects. Some examples featuring this
technique:This makes use of aGridStrategyobject, which populates aGridSpec. In general, this concept can likely be implemented as a layer of abstractionabovegridspec.GridSpec.Some basic strategies that will be included in the first release:"Squarish"(name subject to change) - As implemented in the demo code above - currently this is centered, but the baseSquarishStrategyobject could have options likejustificationwhich could include:'center'(default),'left','right'- empty spaces either center the plots or leave them ragged-left or ragged-right'fill-space'andfill-grow'(names subject to change) - These would fill every column as "fully-justified", withfill-spaceincreasing the interstitial space andfill-growmodifying the width of the plots themselves to fill the row."Rectangular"- Similar to"Squarish", this would find the largest pair of factors of the number of plots and use that to populate a rectangular grid - so6would return a 3x2 grid,7would return a 7x1 grid, and10would return a 5x2 grid.Since many of these grid strategies would likely have at leastsomeasymmetries, a mechanism for transposing any grid structure should be implemented in the baseGridStrategyobject.Higher dimensionsCurrently the package is limited to 2-dimensional
grid arrangements, but a "nice-to-have" might be
a higher-order API forGridStrategythat also allows
for the proliferation of additionalfigures(e.g.
"if I have more than 10 axes to plot, split them
up as evenly as possible amongn / 10different
figures"). This would be no harder to implement
in terms of the creation of such strategies, but
may be harder to work with since it would
necessarily spawn axes across multiple figures.
Package: grid-table-py
grid-table-pygrid_table_pyinput.mdoutput.mdArguments(Positional):Path to input Markdown filePath to file to place output MarkdownThis is a library and command-line tool for converting Markdown files with pipe tables to Markdown files with grid
tables. Both the pipe tables and the grid tables must be compatible withPandoc's Markdown.
(This notably supports tables formatted for github-flavored markdown.)Released under MIT License. Author @FSharp4
Package: gridtest
GridTestSimple grid parameterization and testing setup for Python functions and modules.
SeeDocumentationto get started.OverviewGridTest is a library that specializes in generatingparameter grids. The grids are most obviously used for testing, but can extend to other use cases.
In the context of testing, GridTest makes it easy to discover functions,
classes, and arguments for your python scripts or modules, and then generate
a template for you to easily populate. Outside of testing, you can define
grids that are version controlled, programatically defined with functions,
and easy to interact with from the command line or Python interpreter.
You might be interested in GridTest if you need:low overhead tests for Python scripts and small packagesto generate input data for reproducible computationsTo learn more, it's recommended to reference thedocumentation,
take a look at thegetting startedpages,
or browse one of the manytutorialsavailable.Free software: MPL 2.0 LicenseSupportIf you have any questions or requests for examples or tutorials, please don't hesitate
toopen an issue.ContributingPlease see thedocumentation contributing guidefor details on how to contribute to documentation or code, or the GitHubCONTRIBUTING.mdfor a list of checks when opening a pull request.Known IssuesThe following are known to not work, and development will depend on how useful
the average user will assess each of these points. The developer @vsoch has not
added them yet because she doesn't think them overall useful.support for system libraries (e.g., sys) or anything without a filename in site-packages
Package: gridThingz
Grid ThingZGrid ThingZ is a lightweight python library created to manage 2d data structures in a simple and user-friendly way.WikiInstallationUse the package managerpipto install Grid Things.pipinstallgridThings-ZephyrrusContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: grid-toolkit
This toolkit implements the model described in the following paper for generating scenarios of grid-frequency deviations over 15-minute time steps:Mercier, J. Jomaux, and E. De Jaeger, “Stochastic Programming for Valuing Energy Storage Providing Primary Frequency Control”.# Installationpip install grid_toolkit# Useimport grid_toolkitscenarios = grid_toolkit.generate(n,length,[start_year,start_month,start_day,start_hour])# Note on argumentsAll arguments are integers with n the number of scenarios you want to generate, length the number of time steps of the generated scenarios, start_year,start_month,start_day,start_hour] the starting date of the scenarios.[start_year,start_month,start_day,start_hour] = [2015,1,1,0] corresponds to 1 January 2015 at midnight.Note that daylight saving time is taken into account.
Package: gridtools
gridtoolsA small Python library to convert between maidenhead grid locators and lat/long coördinates.Installationgridtoolsrequires Python 3.8 at minimum.$ pip install gridtoolsDocumentationDocumentation is available atgridtools.miaow.io.CopyrightCopyright 2020-2021 classabbyamp, 0x5cReleased under the BSD 3-Clause License.SeeLICENSEfor the full license text.
Package: gridtools-cpp
Python package for GridTools headers and CMake filesUsageUse the following when compiling C++ code with GridTools programmatically from Python.
Either by calling a compiler directly or by generating a CMake project and calling CMake on it.importgridtools_cppinclude_dir=gridtools_cpp.get_include_dir()# header files can be found herecmake_dir=gridtools_cpp.get_cmake_dir()# cmake files can be found here
Package: gridtree
gridtreeGeneralized quadtree.Installationpip install gridtreeUsageTODO: expandpoints:Collection[tuple[NormalizedFloat,...]]# between 0 and 1 inclusivetree=GTree(max_leaf_size=2)(points)tree_as_list=GTreeList(max_leaf_size=2)(points)tree_as_list=GTreeList.gtree_to_list(tree)ExamplesTODO
Package: gridview
GridViewVisualize your 2D iterable. See our usageexamplesnow!Documentation:https://gergelyk.github.io/python-gridviewRepository:https://github.com/gergelyk/python-gridviewPackage:https://pypi.python.org/pypi/gridviewAuthor:Grzegorz KrasońLicense:MITRequirementsThis package requires CPython 3.8 or compatible. If you have other version already installed, you can switch usingpyenv. It must be installed as described in themanual.pyenvinstall3.8.2
pyenvlocal3.8.2InstallationpipinstallgridviewDevelopment# Preparing environmentpipinstall--userpoetry# unless already installedpoetryinstall# Auto-formattingpoetryrundocformatter-rigridviewtests
poetryrunisort-rcgridviewtests
poetryrunyapf-r-igridviewtests# Checking coding stylepoetryrunflake8gridviewtests# Checking composition and qualitypoetryrunvulturegridviewtests
poetryrunmypygridviewtests
poetryrunpylintgridviewtests
poetryrunbanditgridviewtests
poetryrunradonccgridviewtests
poetryrunradonmigridviewtests# Testing with coveragepoetryrunpytest--covgridview--covtests# Rendering documentationpoetryrunmkdocsserve# Building packagepoetrybuild# Releasingpoetryversionminor# increment selected componentgitcommit-am"bump version"gitpush
gittag${$(poetryversion)[2]}gitpush--tags
poetrybuild
poetrypublish
poetryrunmkdocsbuild
poetryrunmkdocsgh-deploy-bgh-pagesDonationsIf you find this software useful and you would like to repay author's efforts you are welcome to use following button:
Package: gridworks
GridworksGridWorks uses distributed actors to balance the electric grid. What does this mean? In today's world, more
power comes from highly variable power sources such as wind and solar. And yet, the number
of electrons going into the grid must match the number coming out. This is where GridWorks comes in.
GridWorks technology enables electrical devices with some embedded storage or with flexibility to provide grid
balancing. Furthermore, GridWorks allows these appliances to be more thrifty, using electricity when
it is cheap and green.To learn how using and contributing to GridWorks can support a cost-effective and rapid transition to a sustainable future:Try some simpleHello Worldexamples;Read theMillinocket Storyto learn how to exploit the synergy between wind power and space heating;Go through the partnerMillinocket Tutorial.GridWorks SDKsgridworks:packageprovides basic shared mechanics for communication and GNode structure. It is used as a package in all of our other repos.gridworks-atn:packageand associateddocumentationfor the GridWorks PythonAtomicTNodesSDK. AtomicTNodes are the GridWorks actors that make electrical devicestransactive. This SDK is a great place to learn about blockchain mechanics, as it introduces some of the simpler structures (NFTs, stateless contracts, and then some simple stateful smart contracts constructed usingbeaker) required for establishing the link between physical reality on the electric grid and the actors that play their avatars in GridWorks.gridworks-marketmaker:packageand associateddocumentationfor our PythonMarketMakerSDK. GridWorks uses distributed actors to balance the electric grid, and MarketMakers are the actors brokering this grid balancing via the markets they run for energy and balancing services.There are several other open source GridWorks repos to explore onour github page,
including the code running on theSCADA systemsthat Efficiency Maine is deploying in Millinocket this winter.
TheGNodeFactorycurrently hosts the demo,
and does most of the heavy lifting in terms of identity management and authentication in GridWorks. Finally, since the demo
is a distributed simulation, it needs a method of handling time. That's done by aTimeCoordinatorGNode.Usagepip install gridworksto install the foundational package.RabbitMQ InfrastructureGridWorks uses therabbitsubfolder for maintaining dev rabbit brokers as well as their own live rabbit brokers.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Gridworksis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: gridworks-atn
Gridworks AtnThis is theGridWorksPython SDK for building Atomic Transactive Nodes, orAtomicTNodes.AtomicTNodes are the most fun and interesting GridWorks actors to design and build. They are what make electrical devicestransactive. More specifically, each AtomicTNode is dedicated to the job of operating its very ownTransactive Device, and simultaneously bidding on its behalf into electricity markets.To learn about using this SDK, visit theGridworks Atn docs. To explore the rest of GridWorks, visit theGridWorks docs.LicenseDistributed under the terms of theMIT license,Gridworks Atnis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: gridworks-cert
gwcertTools for creating TLS certificates for use with, e.g. MQTT and RabbitMQ.NOTE: these are temporary tools fornon-productiondeployments. This library is more or less equivalent to a README
containingOpenSSLcommands, but less manual.This library is a thin wrapper aroundownca, which wrapspyca/cryptography, which wraps theOpenSSLC library.
See alsotls-gen, a repo fromrabbitmq, which performs a similar task using a stack of make/python/OpenSSL CLI.FeaturesCreate a local Certificate Authority directory with a self-signed certificate, viagwcert ca create.Create named key pairs, CSRs and certificates witharbitraryinput and output paths, viagwcert key add.Build cli commands visually withgwcert tui.InstallationThe recommended way to installgwcertis withpipxfromPyPI:$pipxinstallgridworks-certUsageGet help with any of:gwcert
gwcertca
gwcertkeyCreate a Certificate Authority directory with a self-signed certificate via:gwcertcacreateShow information about the locally created ca and keys with:gwcertcainfoAdd a named set of keys (public, private, certificate) via, for example:gwcertkeyaddKEY_NAMEShow information about a certificate:gwcertkeyinfoKEY_NAMEBuild CLI commands visually:gwcerttuiPlease see theCommand-line Referencefor more details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,gwcertis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.