Saravanan666/pypi-org huggingface dataset:
Package: grgrlib
This is a library of unspeakably useful functions. It serves as a container for a rather loose collection of tools shared across other projects that may or may not be individually useful.Installation withpipIt’s as simple as typingpipinstallgrgrlibin the terminal (Unix/Mac) or the Anaconda Prompt (Win).Installation of bleeding-edge version usinggitThe handy way is to first installgit. Linux users just use their respective repos. Look intothis repofor details.pipinstallgit+https://github.com/gboehl/grgrlibAlternatively you can clone the repository and then from within the cloned folder run (Windows user from the Anaconda Prompt):pipinstall.
Package: grg-sphinx-theme
grg-sphinx-themeA Sphinx theme for GRG projects and its affiliated packages.Usageinstallpip install grg-sphinx-themeTo start using the theme you need to set the theme inconf.pyhtml_theme="grg_sphinx_theme"To set different navbar-links update the html_theme_optionshtml_theme_options = {
...
  "navbar_center": ["components/navbar-links.html"],
  "navbar_links": [
     {
        "url": "#",
        "name": "Home",
     },
     {
        "name": "Community",
        "children": [
          {
            "url": "https://www.geeksforgeeks.org/python-ways-to-concatenate-two-lists/",
            "name": "GeeksForGeeks",
            "external": True
          }
        ]
     },
     {
        "name": "Multiple",
        "sections": [
            {
              "name": "First",
              "children": [
                  {
                    "name": "First-Hello",
                    "url": "",
                    "external": True
                  },
                  {
                    "name": "First-How",
                    "url": ""
                  }
              ]
            },
            {
              "name": "Second",
              "children": [
                  {
                    "name": "Second-Hello",
                    "url": ""
                  },
                  {
                    "name": "Second-How",
                    "url": "",
                    "external": True
                  }
              ]
            }
        ]
     }
  ]
...
}Contributing GuidelinesFor contribution we are required to have to maintain the same coding standard and formatting. We recommend using VSCode as an editor and use prettier extension on the VSCode.For more steps, you can read ourContributing guidelines
Package: grheat
by Scott PrahlGreen’s Functions for Heat Transfergrheatis a library offering Green’s function solutions for heat transfer
problems in various geometries and boundary conditions. This module provides
solutions for point sources, line sources, plane sources, and exponential heating
in semi-infinite media.Main FeaturesGreen’s function solutions for point, line, and plane sources in semi-infinite media.Solutions for exponential heating of a semi-infinite absorbing medium.Supports different boundary conditions at the surface (z=0): infinite, adiabatic, and zero.Accurate and efficient calculations based on mathematical formulations provided in
recognized literature (e.g., Carslaw and Jaeger).Installationthese don’t work yetUsepip:pip install grheatorconda:conda install -c conda-forge grheator use a Jupyter notebook immediately by clicking the Google Colaboratory button belowLicensegrheatis licensed under the terms of the MIT license.
Package: gribdoctor
gribdoctor==========Utility functions for handling quirks of weather data rasters in `grib2` formatInstallation-------.. role:: console(code):language: console:console:`pip install gribdoctor --pre`Usage - smoosh--------------stack multiple gribs of the same or varying resolutions:console:`Usage: gribdoctor smoosh [OPTIONS] [INPUTS]... OUTPUT`OPTIONS::console:`-dev, --develoment  Dev tag for experimental features`:console:`-uw, --unwrap       Unwrap GFS Rasters`:console:`--help              Show this message and exit.`Use this subcommand to "smoosh" together any number of variable resolution gribs into one tiff. This also effectively performs the below :console:`globewrap` operation on all inputs if indicated with :console:`--unwrap`, and outputs a raster of 2x (due to unwrapping) the highest input resolution.Usage - unwrap--------------:console:`gribdoctor unwrap [OPTIONS] INGRIB OUTRASTER`OPTIONS:console:`-bt, --bandtags  Flag to indicate printing of band tags / band metadata to stdout`:console:`-b, --bidx  Bands to include in output raster. Default = all (use caution - you may inadvertently create ginourmous tif files)`Many gridded weather GRIBs, such as NOAA's `Global Forecast System (GFS) <http://www.ncdc.noaa.gov/data-access/model-data/model-datasets/global-forcast-system-gfs>`_, cover a global extent of -0.5 to 359.5 (or similar, depending on resolution), with the antimeridian (-180 / 180) bisecting a column of pixels.This routine upsamples, slices, and merges these rasters as to convert them to "standard" -180 to 180 extent global grids. Outputs to any raster format supported by `rasterio <https://github.com/mapbox/rasterio>`_.
Package: gribnormalize
Utility functions for handling quirks of weather data rasters ingrib2formatUsage - unwrapgribnormalize unwrap [OPTIONS] INGRIB OUTRASTEROPTIONS-bt, --bandtags  Flag to indicate printing of band tags / band metadata to stdoutMany gridded weather GRIBs, such as NOAA’sGlobal Forecast System (GFS), cover a global extent of -0.5 to 359.5 (or similar, depending on resolution), with the antimeridian (-180 / 180) bisecting a column of pixels.
This routine upsamples, slices, and merges these rasters as to convert them to “standard” -180 to 180 extent global grids. Outputs to any raster format supported byrasterio.
Package: gribscan
gribscanTools to scan GRIB files and create zarr-compatible indices.warningThis repository is still experimental. The code is not yet tested for many kinds of files. It will likely not destroy your files, as it only accesses GRIB files in read-mode, but it may skip some information or may crash. Please file an issue if you discover something is missing.installinggribscanis onPyPI, you can install the recent released version usingpython-mpipinstallgribscanif you are interested in the recent development version, please clone the repository and install the package in development mode:python-mpipinstall-e<pathtoyourclone>docsThe latest documentation can be foundonlineor may be built using sphinx in your local clone:pipinstall-e.[docs]cddocs
makehtmlafterwards, the documentation is available atdocs/build/html/index.html.
Package: gributils
gributils is a set of utilities on top of pygrib for manipulating and
indexing gribfiles. Current features include:Grib index
* Store and query a large set (historical dataset) of grib files
* PostGIS based
* Query by geographical location,, timestamp and parameter name, parameter unit, level and level type.
* Parameter name normalization using a simple CSV fileExtract polygons of areas covered with valid values in a grib layerProvide accurate grid coordinates, even for grib version 1 files where too low precision in Dx / Dy have resulted in a distorted grid.Conversion from values with U and V components (e.g. for wind) to
magnitude and degree north.
Package: grid
Grid contains objects and functions pertaining to 3D volumetric (grid) data.
It was specifically written for 3D-RISM distribution data but is
by no means limited to such data.
Grid requires numpy.Typical usage often looks like this:#!/usr/bin/env python

import grid

mygrid = grid.dx2Grid("mydxfilename")Some files can be converted now using gridconvert.py:gridconvert.py mydxfile.dx grdWill yield an Accelrys DS .grd file
Package: grid2fp
grid2fpA tool to eat grid diagrams and generate its front projections.DisclaimerThe tool is lightly tested. I would expect bugs and strange behavior. If you find something make an issue.InstallationInstall with pip:pip install grid2fpUsageCLIDoesn't exist.Scriptingfromgrid2fpimportgrid2fpimportdrawsvgasdrawcsv_path="path"svg_path="path"diagram=[["x","","o"],["","",""],["o","","x"]]# Option 1g=grid2fp(csv_file=csv_path,draw_crossings=False)d=g.draw()d.save_svg(svg_path)# Option 2grid2fp(csv_file=csv_path,out_file=svg_path)# Option 3g=grid2fp(diagram=diagram)d=g.draw()d.save_svg(svg_path)# Option 4g=grid2fp(csv_file=csv_path,string_color="pink",crossing_color="purple")d=g.draw()# make some changes to d with drawsvgd.save_svg(svg_path)Sample imagesxoxoxooxoxxoxoxooxxoox‎oxoxxooxxooxxoToDoCLI interfacefit canvas to drawing better.(still not perfect)set string color???
Package: grid3
Grid3.pyThis is a collection of Python modules for working with ThreeFold Grid v3. It's designed foremostly for interactive use on the REPL and joyful scripting. We value conciseness and trying to do what youmeant, even at the expense of a few extra CPU cycles.If you're looking for a Grid v3 SDK for writing efficient and maintainable code bases, check outGo. For code that must execute in the user's browser, seeTypescript.InstallationTldr:pip install grid3RequirementsMost of the functionality just requirespython3.8or newer.The Reliable Message Bus functionality is Linux only and also depends on:redis-serverrmb-peerDetailed installAssuming thatpythonispython3andpipispip3, install the latest release from PyPI into avenvusingpip:python -m venv venv
source venv/bin/activate
pip install grid3Quick tourWith thegraphqlmodule, you can easily answer questions like, how many nodes are currently in the standby state that were online in the last 36 hours?import time, grid3.network
mainnet = grid3.network.GridNetwork()
sleepers = mainnet.graphql.nodes(['nodeID'], power={'state_eq': 'Down'}, updatedAt_gt=int(time.time()) - 24 * 60 * 60)
print(len(sleepers))We just executed a query against the mainnet GraphQL endpointnodeswithout even sweating a line break. Pretty cool!
Package: grid3d-maps
grid3d-mapsVarious scripts for generating maps from 3D grid properties.Scripts includedScriptDescriptiongrid3d_hc_thicknessMake Hydrocarbon thickness maps from Eclipse and/or Roff inputgrid3d_average_mapMake average maps from a 3D grid parameter, Eclipse or Roff inputgrid3d_aggregate_mapMake aggregated maps (min/max/mean/sum) from a 3D grid parameter, Eclipse or Roff inputgrid3d_migration_timeMake migration time maps aimed at tracking plume migration in CCS applicationsFeaturesFrom Eclipse files (EGRID, INIT, UNRST) and/or RMS binary ROFF
make HCPV thickness maps, or make weighted average mapsNo need to invoke RMSEfficient in FMU work flowsHC thickness maps and average maps for property differences is
supported (see examples in YAML config files)Outputs PNG figures and Irap (RMS) binary mapsSimple configuration through a YAML fileConfiguration from YAML can be overriden by command line optionsFrom version 1.3, output viafmu-dataio_ (tosumo_) is supported.
Seefmu-dataioandfmu-sumo
Package: gridaurora
Grid for Auroral modelsDiscretizations of space (grids) and time conversions useful for aeronomy and auroral modeling.Installpython -m pip install -e .Note: you will need a Fortran compiler on your system forf2pymodules.
It works on Linux, Mac,Windows, etc.EigenprofilesCurrently GLOW and Rees-Sergienko-Ivanov are available (Transcar in future).
You can install these models withpipinstall-e.[models]Once installed, select model by:-M reesRees-Sergienko-Ivanov-M glowStan Solomon's GLOW modelCommand Line Options-t time, format yyyy-mm-ddTHH:MM:SSZ where Z sets UTC time zone -c lat,
lon WGS84 geodetic degrees -o output, hDF5 ends in .h5 -M model select
(see table above) -z min,max altitude to plot [km]Example Commandpython MakeIonoEigenprofile.py -t 2013-01-31T09:00:00Z -c 65 -148 -o out.h5 -M reesAuroral Data FilesThe functions ingridaurora/calcemissions.py, based on work by
Zettergren, computes per-wavelength volume emission rate along a flux
tube as a function of altitude along the tube. Starting with quantities
such as neutral densities computed by MSIS, differential number flux as
a function of energy and altitude along the tube (this is what TRANSCAR
computes), excitation cross sections as a function of energy,
Franck-Condon factors and Einstein coefficients, thepromptvolume
emission rate may be computed.precompute/vjeinfc.h5This file is compiled from tables in Vallance JonesAurora1974 and other sources
by Matthew Zettergren, and corrected and put into HDF5 format by Michael Hirsch.
The information within concerns:N2+1NG:   N2^+^ first negative groupN2_1PG:   N2first positive groupN2_2PG:   N2second positive groupN2+Meinel:   N2^+^ Meinel bandatomic:   atomic oxygenmetastable:   metastable O and O^+^Einstein coefficient matrix Aarranged A(𝜈',𝜈'') where:𝜈' upper state vibrational levels, excited from ground state 𝜈''' by particle impact𝜈'' lower state vibrational levels, decayed into from the upper stateas discussed in Appendix C of Zettergren PhD thesis, Eqn. (C.2), photon
volume emission rate follows the relation P𝜈',𝜈''= A(𝜈',𝜈'')
n𝜈'lamdbawavelength in nanometers corresponding to the Einstein coefficient
matrixAexceptatomicthat uses the reaction rates directly.Franck-Condon factor fcas described in Zettergren thesis Appendix C, specifically for Eqn
(C.6-C.8), the Franck-Condon factors modify the total upper state
excitation cross section multiplicitively.Function Descriptionfunctiondescriptionztanh.pycontinuously varying grid using hyperbolic tangent. Inspired by suggestion from Prof. Matt Zettergren of ERAU.
Package: gridcells
What are grid cellsGrid cells are a type of cells found in some mammalian species that have very
regular spatial firing fields. When these animals forage in experimental
arenas, grid cells are active only in certain places and the locations where
they are active form a hexagonal lattice. More information can be found in[MOSER2007]or in[HAFTING2005].What doesgridcellsdogridcellsis a simple Python library that aims to provide an open source code
repository related to analysis of grid cell related experiments and simulation
of models of grid cells.Downloadgridcellscan be downloaded fromhttps://github.com/lsolanka/gridcells.DependenciesThere are a number of dependencies you need to install this package:setuptools (>= 3.6)SWIG  (ideally >= 3.0; earlier versions not tested)numpy (>= 1.8)scipy (>= 0.13.3)matplotlib (>= 1.3.1)For Linux, simply install these using the package manager.For Mac OS the
easiest way is probably to usehomebrewand pip. This
package has not been tested on Windows but if you manage to install the
dependencies there should be no problems.InstallationAfter installingSWIG, run:python setup.py installLicensegridcellsis distributed under the GPL license. See LICENSE.txt in the root
of the source directory.armadillo, which is part of this source, is
distributed under theMozilla Public License 2.0. This packages also uses a
modified version ofarmanpy.armanpyis distributed under the LGPL license.References[MOSER2007]Edvard Moser and May-Britt Moser (2007). Grid cells.
Scholarpedia, 2(7):3394.[HAFTING2005]Hafting, T. et al., 2005. Microstructure of a spatial map in
the entorhinal cortex. Nature, 436(7052), pp.801–806.Build Status
Package: gridcreator
What does that library can do?This library is designed for creating grids to facilitate the decentralization of different products. It is currently being developed as a gridnet library with integrated network functions.How to install?pip install gridcreatorHow to use?import grid.grid as grid

your_grid = grid.Grid("example_grid", (3, 3, 3))

your_grid.genesis()
your_grid.add("example_element", "example")
Package: griddb-python
GridDB (https://github.com/griddb/griddb) is Database for IoT with both NoSQL interface and SQL Interface.
This is Python Client Library for GridDB.Installation1. Package dependenciesGridDB C ClientOn LinuxDownload and install RPM or DEB package in GridDB C Client (https://github.com/griddb/c_client/releases).Install RPM package by this command:$ sudo yum localinstall package_name.rpmInstall DEB package by this command:$ sudo dpkg -i package_name.debOn MacOSBecause GridDB Python Client already included C Client Library, so don’t need install GridDB C Client on MacOS.GridDB C Client Libraries installed atpath/to/python/sites-package/GridDB C Client licenses and header installed atpath/to/python/sites-package/griddb/griddb-c-clientExample:~/.pyenv/versions/3.6.9/lib/python3.6/site-packages/griddb/Pandas and NumpyInstall Pandas and Numpy by these commands:$ python -m pip install numpy
$ python -m pip install pandas2. Install griddb_pythonInstall the griddb_python by this command:$ python -m pip install griddb_python
Package: griddb-python-client
GridDB (https://github.com/griddb/griddb_nosql) is a highly scalable NoSQL database best suited for IoT and Big Data.
This is Python Client Library for GridDB.InstallationBuild dependenciesSWIGGridDB C ClientDownload and install SWIG (http://swig.org/).Download GridDB C Client (https://github.com/griddb/c_client/releases/tag/v3.0.1).
Extract the file and set the LIBRARY_PATH environment variable.export LIBRARY_PATH = <C Client Library directory path>Install the package by the following:pip install griddb_python_client
Package: gridder
GridderGridder can generate grids in image form according to the specified settings,
either as brand-new images or drawing on existing ones. Grids can have various
shapes, such as square or hexagonal, and are highly configurable.For a REST-ful interface, check outGridder-REST.Suggestions and appreciation are welcome! Feel free to email me or open an
issue on Gitlab.UsageGridder can draw either on an empty background or on an existing image.To use anempty background, runmain.py <width> <height> <grid size>,
where:<width>is the width of the image in pixels.<height>is the height of the image in pixels.<grid size>is the interval, in pixels, at which each line of the
grid will be generated. This effectively corresponds to the side of each
square of the grid.To draw on anexisting image, runmain.py --file <file path> <grid size>,
where:<file path>is the path to the image on which Gridder will paint a grid.<grid size>is as described above.Note that the--file(or-f) optionmust be the first argumentif specified.The result of the above will be a file namedgrid.pngin the same
directory. If used, the existing image will not be modified.OptionsThe following optional arguments (or their aliases) can be provided:--gridtype, alias:-gtspecifies the shape of the grid. Possible options:squaresquares (default),vhexvertical hexes (flat side on top and bottom),hhexhorizontal hexes (flat side on left and right),vlinevertical lines,hlinehorizontal lines.--linewidth, alias:-lwspecifies the line width of the elements of
the grid. Default: 1.--gridcol <colour>, alias:-grcspecifies a  for the grid,
as the name of a colour or a string format recognised by Pillow, such as
hex values like#000000.--bgcol <colour>, alias:-bgcspecifies a  for the background,
as the name of a colour or a string format recognised by Pillow, such as
hex values like#000000.
For a transparent background, omit this argument or specifytransparent.NOTE:This cannot be used when drawing on an existing image using-f.--padding <size>, alias-pspecifies a padding of  pixels around
the grid, i.e. a padding between the borders of the image and the actual grid.--paddingtop <size>, ..right, ..bottom, ..left, alias:-pt,-pr,-pb,-plspecify each a padding of  specific to the indicated side.
Each can be used separately, and they will take priority over the
generic--paddingoption above.--destination, alias-dspecifies the file name of the finished image.
Do not include an extension, as it will always be .png automatically.
The default file name isgrid.png.UnitsBy default, all size arguments,<width>,<height>,<grid size>and
all applicable optional parameters usepixels, but other units are
also allowed, namely:cm,mm,in.These units all assume a resolution on300dpias customary for printing.For example, a grid created using the arguments12cm 12cm 1inwill be
1417x1417 pixels and have 300-pixels wide squares.Known issuesDue to rounding errors, hex grids may have some unwanted bold edges.
Package: griddify
GriddifyRedistribute tabular data into a grid for easy visualization and image-based deep learning. This library is greatly inspired by the excellentMolMaplibrary.Installationgit clone https://github.com/ersilia-os/griddify.git
cd griddify
pip install -e .Step by stepGet a multidimensional dataset and preprocess itIn this example, we will use a dataset of 200 physicochemicaldescriptorscalculated for about 10k compounds. You can get these data with the following command.fromgriddifyimportdatasetsdata=datasets.get_compound_descriptors()It is important that you preprocess your data (impute missing values, normalize, etc.). We provide functionality to do so.fromgriddifyimportPreprocessingpp=Preprocessing()pp.fit(data)data=pp.transform(data)Create a 2D cloud of data featuresStart by calculating distances between features.fromgriddifyimportFeatureDistancesfd=FeatureDistances(metric="cosine").calculate(data)You can now obtain a 2D cloud of your data features. By default,UMAPis used.fromgriddifyimportTabular2Cloudtc=Tabular2Cloud()tc.fit(fd)Xc=tc.transform(fd)It is always good to inspect the resulting projection. The cloud contains as many points as features exist in your dataset.fromgriddify.plotsimportcloud_plotcloud_plot(Xc)Rearrange the 2D cloud onto a gridDistribute cloud points on a grid using alinear assignmentalgorithm.fromgriddifyimportCloud2Gridcg=Cloud2Grid()cg.fit(Xc)Xg=cg.transform(Xc)You can check the rearrangement with an arrows plot.fromgriddify.plotsimportarrows_plotarrows_plot(Xc,Xg)To continue with the next steps, it is actually more convenient to get mappings as integers. The following method gives you the size of the grid as well.mappings,side=cg.get_mappings(Xc)Rearrange your flat data points into gridsLet's go back to the original tabular data. We want to transform the input data, where each data sample is represented with a one-dimensional array, into an output data where each sample is represented with an image (i.e. a two-dimensional grid). Please ensure that data are normalize or scaled.fromgriddifyimportFlat2Gridfg=Flat2Grid(mappings,side)Xi=fg.transform(data)Explore one sample.fromgriddify.plotsimportgrid_plotgrid_plot(Xi[0])Full pipelineYou can run the full pipeline described above in only a few lines of code.fromgriddifyimportdatasetsfromgriddifyimportGriddifydata=datasets.get_compound_descriptors()gf=Griddify(preprocess=True)gf.fit(data)Xi=gf.transform(data)You can find more examples as Jupyter Notebooks in thenotebooksfolder.Learn moreTheErsilia Open Source Initiativeis on a mission to strenghten research capacity in low income countries. Please reach out to us if you want to contribute:hello@ersilia.io
Package: griddle
griddleTurn tabular data into a printable grid.Wraps thetabulateto streamline usage as well as
automatically reduce column widths to fit the grid to the current terminal width.InstallationInstall with:pip install griddleUsage>>> from griddle import griddy
>>> data = [{"a": i, "b": i+1, "c": i+2} for i in range(10)]
>>> print(griddy(data, "keys"))
╭─────┬─────┬─────╮
│ a   │ b   │ c   │
├─────┼─────┼─────┤
│ 0   │ 1   │ 2   │
├─────┼─────┼─────┤
│ 1   │ 2   │ 3   │
├─────┼─────┼─────┤
│ 2   │ 3   │ 4   │
├─────┼─────┼─────┤
│ 3   │ 4   │ 5   │
├─────┼─────┼─────┤
│ 4   │ 5   │ 6   │
├─────┼─────┼─────┤
│ 5   │ 6   │ 7   │
├─────┼─────┼─────┤
│ 6   │ 7   │ 8   │
├─────┼─────┼─────┤
│ 7   │ 8   │ 9   │
├─────┼─────┼─────┤
│ 8   │ 9   │ 10  │
├─────┼─────┼─────┤
│ 9   │ 10  │ 11  │
╰─────┴─────┴─────╯
Package: griddly
Griddly PythonThis module contains all you need to run the Griddly AI research environment using python.InstallationCurrently the library supports any python > 3.6.
It is recommended to use a conda environment:conda create --name griddly_env python=3.7
conda activate griddly_env
pip install griddlyUsageFull documentation can be found here:https://griddly.readthedocs.org
Package: griddypower
griddypowerPython API for Griddy Wholesale ElectricityFree software: BSD licenseDocumentation:https://griddypower.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-03-08)First release on PyPI.