Saravanan666/pypi-org huggingface dataset:
Package: gridemic
gridemicgridemicis a python package for stochastic agent-based epidemic models on a square grid with long-range interactions.In addition to the disease spread,gridemicalso simulates the testing & contact tracing simultaneously.installationpip install gridemicexamplesThe notebooks inexamples/demonstrates basic functionality ofgridemic.publicationsD. Scarselli, N. B. Budanur, M. Timme, and B. Hof "Discontinuous epidemic transition due to limited testing",Nature Communications volume 12, Article number: 2586(2021).arXiv:2006.08005.
Package: grid-extractor
It’s a library to help you take out the text from the grid.Installpip installgrid-extractorTESSERACTIf you want to recognize the text, you man need to download the tesseract.wikidownloadtesseract-ocr-w64-setup-v5.0.0-alpha.20200328.exeTESSDATA_PREFIX:C:Program FilesTesseract-OCRdocREFERENCEimage processing to improve tesseract ocr accuracy
Package: gridfinder
gridfindergridfinder uses night-time lights imagery to as an indicator of settlements/towns with grid electricity access. Then a minimum spanning tree is calculated for these connect points, using a many-to-many variant Dijkstra algorithm and using existing road networks as a cost function. Adapted fromthis work from Facebook. Currently gridfinder only uses road networks, but it would be trivial to add other cost parameters such as slope or terrain.The algorithm looks as follows in process, guessing the grid network for Uganda:Input requirementsgridfinder requires the following data sources:VIIRS data, monthly and annual composites availablehere.OSM highway data, most easily available using theHOT Export Tool, otherwisegeofabrikModel usageTo get to grips with the API and steps in the model, open the Jupyter notebookexample.ipynb.
This repository  includes the input data needed to do a test run for Burundi, so it should be a matter of openening the notebook and running all cells.InstallationInstall with pippipinstallgridfinderNote:On some operating systems (Ubuntu 18.04), you may get an error aboutlibspatialindex. To overcome this on Ubuntu, run:sudoaptinstalllibspatialindex-devDevelopmentDownload or clone the repository and install the required packages (preferably in a virtual environment):gitclonehttps://github.com/carderne/gridfinder.gitcdgridfinder
pipinstall-e'.[dev]'LintingmakelintTestingmaketest
Package: gridfix
GridFixGridFix is a Python 3 toolbox to facilitate preprocessing of scene fixation data for region-based analysis using Generalized Linear Mixed Models (GLMM).Our recently published manuscript[1] describes how this approach can be used to evaluate models of visual saliency above and beyond content-independent biases. Please also see [3] for a previous description of the approach andour ECVP 2016 poster[2] for an overview about the structure and workflow of the GridFix toolbox.FeaturesDefine image parcellations (region masks) based on a grid or bounding box coordinates (RegionSet)Apply these parcellations to collections of images or saliency maps (ImageSet)Calculate per-region fixation status (fixated/not fixated), count, and duration-based dependent measuresDefine features to assign a value to each region X image (e.g., mean saliency of each region)Explicitly model central viewer bias using different approaches (e.g. Euclidean distance, Gaussian)Output the resulting feature vectors for GLMM-based analysis [1,2]Create initial R source code to facilitate GLMM analysis using lme4InstallationGridFix requires Python 3. The following packages need to be installed:numpyscipymatplotlibpandasPIL or Pillow (image library)If you need to first install a Python environment, we recommend the Anaconda distribution which includes all of the listed prerequisites by default, is available for all major platforms (Windows, Mac, Linux) and can be downloaded athttps://www.anaconda.com/products/individual#Downloads.To install GridFix from the Python Package Index (PyPI), simply run:pip install gridfixAlternatively, you can clone this repository using git or download a ZIP file using the "Clone or download" button, then run the following:python3 setup.py installor, in case you want to only install for your user or receive an error regarding permissions:python3 setup.py install --userGridFix was installed correctly if you can executefrom gridfix import *in an interactive Python 3 session without errors.DocumentationSeeGridFix documentation.
Tutorial Jupyter Notebooks and example data areavailable as a separate download.References[1] Nuthmann, A., EinhÃ¤user, W., & SchÃ¼tz, I. (2017). How well can saliency models predict fixation selection in scenes beyond central bias? A new approach to model evaluation using generalized linear mixed models. Frontiers in Human Neuroscience.http://doi.org/10.3389/fnhum.2017.00491[2] SchÃ¼tz, I., EinhÃ¤user, W., & Nuthmann, A. (2016). GridFix: A Python toolbox to facilitate fixation analysis and evaluation of saliency algorithms using Generalized linear mixed models (GLMM). Poster presented at the European Conference on Visual Perception (ECVP), Barcelona.http://doi.org/10.5281/zenodo.571067[3] Nuthmann, A., & EinhÃ¤user, W. (2015). A new approach to modeling the influence of image features on fixation selection in scenes. Annals of the New York Academy of Sciences, 1339(1), 82-96.http://dx.doi.org/10.1111/nyas.12705
Package: gridfrequency
GridFrequencyPython wrapper for obtaining the current frequency of the Swedish national power gridSourceshttps://www.svk.se/drift-av-stamnatet/kontrollrummet/(Swedish National Grid - Inspiration to this project)http://driftsdata.statnett.no/restapi/(Norwegian National Grid - data provider)InstallationThis program only has one dependency; therequestsmodule. The dependency can be be installed withpipusingpipinstall-rrequirements.txtUsageBelow are a few snippets of example usage. For more thorough usage, please see the source code.Continous measurementpollGridFrequency()Polls every 0.5s [default], only printing result [default]. Calls callback only if value changed [default]pollGridFrequency(my_callback,0.1)Polls with custom callback functionmy_callbacktaking ONE argument (frequency). I.e. my_callback(freq) is called. Custom refresh rate.pollGridFrequency(None,2,False)No callback (prints values only), polling every 2s and returning values regardless of whether they have changed.Obtain a single frequency measurementprint("This is freq: "+str(getCurrentFrequency()[1]))Single-capture frequency.CallbackThe data obtained in the continous polling is passed to a provided callback. The format of the callback is as followsdefmy_callback(frequency):desired_freq=50print("We differ by{}Hertz".format((desired_freq-frequency))
Package: gridfs-fuse
# python gridfs fuseA FUSE wrapper around MongoDB gridfs using python and llfuse.## Usage```bashgridfs_fuse --mongodb-uri="mongodb://127.0.0.1:27017" --database="gridfs_fuse" --mount-point="/mnt/gridfs_fuse" # --options=allow_other```### fstab example```mongodb://127.0.0.1:27017/gridfs_fuse.fs  /mnt/gridfs_fuse  gridfs  defaults,allow_other  0  0```Note this assumes that you have the `mount.gridfs` program (or `mount_gridfs` on MacOS X) symlinkedinto `/sbin/` e.g.```bashsudo ln -s $(which mount.gridfs) /sbin/````## Requirements* pymongo* llfuse## InstallUbuntu 16.04:```bashsudo apt-get install libfuse python-llfusesudo -H pip install gridfs-fuse```MacOSX:```bashbrew install osxfusesudo -H pip install gridfs-fuse```## Operations supported* create/list/delete directories => folder support.* read files.* delete files.* open and write once (like HDFS).* rename## Operations not supported* modify an existing file.* resize an existing file.* hardlink* symlink* statfs## Performance### Setup* AWS d2.xlarge machine.* 4 @ 2.40Ghz (E5-2676)* 30 gigabyte RAM* filesystem: ext4* block device: three instance storage disks combined with lvm.```lvcreate -L 3T -n mongo -i 3 -I 4096 ax /dev/xvdb /dev/xvdc /dev/xvdd```* mongodb 3.0.1* mongodb storage engine WiredTiger* mongodb compression: snappy* mongodb cache size: 10 gigabyte### Results* sequential write performance: ~46 MB/s* sequential read performance: ~90 MB/sWrite performance was tested by copying 124 files, each having a size of 9 gigabytes and different content.Compression factor was about factor three.Files were copied one by one => no parallel execution.Read performance was tested by randomly picking 10 files out of the 124.Files were read one by one => no parallel execution.```bash# Simple illustration of the commands used (not the full script).# Writepv -pr /tmp/big_file${file_number} /mnt/gridfs_fuse/# Readpv -pr /mnt/gridfs_fuse${file_number} > /dev/null```
Package: grid-fusion-pytorch
grid_fusion_pytorchEfficient operations for fusing depth maps or point clouds with or without semantic annotation in a 3D voxel grid in pytorch. Corresponding backward passes are WIP.
UsesTORCH.UTILS.CPP_EXTENSIONfollowing the structure ofDirectVoxGO.Setuppip install grid-fusion-pytorchRequirementsPyTorchmust be installed with CUDA support. Also,Ninjais required to load C++ extensions. Install it with pip.pip install ninjaUsageCheck out thecolab demo.
Package: gridgs-sdk
GRID Python SDKPython SDK to simplify integration with GRID services:https://gridgs.comIt's in beta state now. Please expect changes (we'll try to keep them backward-compatible).Main partsGridAuthClient - Used to authorize on GRID SSO server.GridApiClient - Client for GRID RespAPI that can work with main Grid entities (right now with sessions only).GridEventSubscriber - subscriber to receive real-time events about changes in sessions (creation, deletion, starting and so on).GridMQTTClient - Client for GRID MQTT API. It useful for realtime connection (receive downlink frames and send uplink frames).Examples how to useGridAuthClientlogger = logging.getLogger()keycloak_openid = KeycloakOpenID(server_url="https://login.gridgs.com", client_id="grid-api", realm_name="grid")
grid_auth_client = GridAuthClient(open_id_client=keycloak_openid, username="user@gridgs.com", password="userpass", company_id=1, logger=logger)GridApiClientgrid_api_client = GridApiClient(base_url="https://api.gridgs.com" auth_client=grid_auth_client, logger=logger)Get predicted sessionssessions = grid_api_client.get_predicted_sessions()Create a sessionsession = Session() # A session from get_predicted_sessions
session = grid_api_client.create_session(session)GridEventSubscriberReceive statuses of sessionsgrid_event_subscriber = GridEventSubscriber(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logger)

grid_event_subscriber.on_event(on_event)
grid_event_subscriber.run()

def on_event(self, event: SessionEvent):
    session = event.sessionGridMQTTClientgrid_mqtt_client = GridMQTTClient(host="api.gridgs.com", port=1883, auth_client=grid_auth_client, logger=logger)

grid_mqtt_client.subscribe(session, on_downlink_frame)
grid_mqtt_client.connect()

def on_downlink_frame(frame: Frame):Sending a framegrid_mqtt_client.send(session, b'Uplink frame data')
Package: gridic
A note/time grid that helps create small fragments of music.How to InstallDownload and install Fluidsynth fromhttp://www.fluidsynth.org/Download a soundfont fromHammerSoundUse pip to install Gridicpip install gridicOpen your python interpreter and run gridic>>> import gridic
>>> gridic.run(SOUNDFONT_FILE=YOUR_SOUNDFONT_LOCATION)Alternately, download this package from Github/PyPI and usepython setup.py installSoundfonts, midi mappings and delay is configurableFree software: BSD licenseDocumentation:https://gridic.readthedocs.org.History0.1.0 (2014-12-20)First release on PyPI.
Package: gridify
Gridify takes geometries in a geopandas dataframe to describe areas to in- and exclude. It then generates a grid of box shaped polygons covering the include area.How to useImport packagesimport geopandas as gpd
import shapely.geometry
import matplotlib.pyplot as plt

from gridify.gridify import gridifyDefine an include area consisting of a polygon and a line part. And put
it in a geodataframe.part1 = shapely.geometry.box(
   minx=0,
   miny=0,
   maxx=0.5,
   maxy=1,
)
part2 = shapely.geometry.LineString(
   [
       (0.5, 0),
       (5 / 6, 1.0),
   ]
)
include_gdf = gpd.GeoDataFrame({"col1": [1, 2]}, geometry=[part1, part2])
ax = include_gdf.plot(column="col1")
ax.set_xlim([-.1, 1.2])
ax.set_ylim([-.1, 1.2])Define an area to excludeexclude = shapely.geometry.box(
    minx=0.5,
    miny=0.5,
    maxx=1.1,
    maxy=1.1,
)
exclude_gdf = gpd.GeoDataFrame({"col1": [1]}, geometry=[exclude])
ax = exclude_gdf.plot(color="red", alpha=0.5)
ax.set_xlim([-.1, 1.2])
ax.set_ylim([-.1, 1.2])Use include area and exclude area to define a grid with (1/3) as grid
size. Include partial overlap with the exclusion area into the grid.grid = gridify(
    include_area=include_gdf,
    exclude_area=exclude_gdf,
    grid_size=((1/3), (1/3)),
    include_partial=False,
)

ax = grid.boundary.plot()
ax.set_xlim([-.1, 1.2])
ax.set_ylim([-.1, 1.2])Plot the grid overlapping the include area in green, and the exclude
area in red.ax = include_gdf.plot(color="green", alpha=0.5)
exclude_gdf.plot(ax=ax, color="red", alpha=0.5)
grid.boundary.plot(ax=ax, color="blue")Alternatively, partial overlap may be included into the final grid.grid_include_partial = gridify(
    include_area=include_gdf,
    exclude_area=exclude_gdf,
    grid_size=((1/3), (1/3)),
    include_partial=True,
)

ax = include_gdf.plot(color="green", alpha=0.5)
exclude_gdf.plot(ax=ax, color="red", alpha=0.5)
grid_include_partial.boundary.plot(ax=ax, color="blue")InstallationTo install gridify, do:git clone https://gitlab.com/rwsdatalab/public/codebase/image/gridify.git
cd gridify
pip install .Run tests (including coverage) with:pip install -r requirements-dev.txt
python setup.py testDocumentationFind the full documentation athttps://rwsdatalab.gitlab.io/public/codebase/image/gridifyLicenseCopyright 2022 RijkswaterstaatLicensed 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 athttp://www.apache.org/licenses/LICENSE-2.0Unless 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: gridijkstra
gridijkstraPython package wrapping scipy's dijkstra with a grid-based interface>>>importgridijkstra>>>importnumpyasnp>>>costs=np.ones((50,60))>>>costs[10:15,:20]=1e30# np.inf also works, but is less convenient for plotting>>>costs[20:25,25:55]=1e30>>>costs[30:40,30:40]=1e30>>>start=(2,2)>>>target=(48,58)>>>total_cost,path=gridijkstra.plan(costs,start,target,return_path=True)>>>print(f'Full path length:{total_cost}')'Full path length: 102.0'Three use cases are shown below. See scripts/examples.ipynb for a notebook with examples
Package: gridikjstra
# gridijkstra
Python package wrapping scipy’s dijkstra with a grid-based interface`python >>> import gridijkstra >>> import numpy as np >>> costs =np.ones((50,60)) >>> costs[10:15, :20] = 1e30  # np.inf also works, but is less convenient for plotting >>> costs[20:25, 25:55] = 1e30 >>> costs[30:40, 30:40] = 1e30 >>> start = (2, 2) >>> target = (48, 58) >>> total_cost, path = gridijkstra.plan(costs, start, target, return_path=True) >>> print(f'Full path length:{total_cost}')'Full path length: 102.0' `Three use cases are shown below. See scripts/examples.ipynb for a notebook with examples![](scripts/example1.svg)![](scripts/example2.svg)![](scripts/example3.svg)
Package: grid-instrument
Did you ever wish you could use your Launchpad as a MIDI instrument? Do
you covet theScale Modeon the Launchpad Pro or Ableton Push, but
not have the cash to buy them? Now you can play scales on any Novation
Launchpad.Here’s a quickvideo demo.There is also an iOS app version of this code
`here <https://itunes.apple.com/us/app/gridinstrument/id1296511558?mt=8>`__.At it’s core,GridInstrumentis a library that allows you to display
a scale grid on your Novation Launchpad. It functions very similarly to
the scale mode on Henri David’sfantasticLaunchpad95scripts for Ableton Live, and also similarly to thescale
modeon a
Launchpad Pro.Features:Can be used as a standalone app or incorporate into another Python
project.Key switching (you know, so that you’re not stuck in the key of C)Scale switching between the same 26 musical modes as Launchpad95Works on Raspberry Pi and Mac OS (probably Windows, too, but not
tested).Two layouts (Diatonic 4th and Chromatic)Works with all Novation LaunchpadsRequirementsBefore you try to do anything, make sure you havePython 2andpipinstalled.How to Use it as a Standalone AppDownload the source code from github and install prerequisites:git clone https://github.com/dhilowitz/GridInstrument
cd GridInstrument; pip install launchpad_rtmidi_pyRun the app:python play.pyIf all goes well, you should see your grid light up. Next, go into
another piece of software that can receive MIDI signals (sforzando is a
good, free choice), and you should see a new MIDI device called “Grid
Instrument (Virtual Port)”How to Use it as a Python LibraryYou have two options for how to install it.Option 1: Install it ManuallyDownload the source code from github:git clone https://github.com/dhilowitz/GridInstrument
cd GridInstrumentInstall it:python setup.py installOption 2: Install it with Pippip install grid_instrument
Package: gridiron
This is a package that has useful machine vision for use with CarsCHANGE LOGRELEASE 10.0.0.1  (7/27/2021)First Release\RELEASE 20.0.0.2 –> 7/27/2021Just wanted to test some things outreally didn’t don anything\-RELEASE 3
-0.0.0.3–> 7/27/2021
-Just wanted to test some things out
-really didn’t don anything
Package: gridit
GriditDescriptionGridit provides spatial tools to translate raster or vector geometry data to regular grids.InstallationThis package primarily depends on NumPy and SciPy, and has several optional dependencies.Pip can be used to install all optional dependencies:$pipinstallgridit[optional]Or from a clone of this repository, create an "editable" install:$pipinstall-e.[optional]TestingRunpytest -v.ExamplesPython>>>importmatplotlib.pyplotasplt# optional>>>fromgriditimportGrid>>>grid=Grid.from_vector("tests/data/Mana_polygons.shp",100)>>>print(grid)<Grid:resolution=100.0,shape=(24,18),top_left=(1748600.0,5451200.0)/>>>>ar_vec=grid.array_from_vector("tests/data/Mana_polygons.shp","K_m_d")>>>plt.imshow(ar_vec)<matplotlib.image.AxesImageat0x7fb6c7dacf10>>>>ar_rast=grid.array_from_raster("tests/data/Mana.tif")>>>plt.imshow(ar_rast)<matplotlib.image.AxesImageat0x7fb6bc4ad6d0>Command lineGrid and array from vector, write PNG image and shapefile grid:$gridit--grid-from-vectortests/data/Mana_polygons.shp--resolution100\--array-from-vectortests/data/Mana_polygons.shp\--array-from-vector-attribute=K_m_d\--write-image/tmp/Mana_Kmd.png\--write-vector/tmp/Mana_Kmd.shpGrid from bounding box, array from raster, write GeoTIFF raster:$gridit--grid-from-bbox1748600544880017504005451200--resolution100\--array-from-rastertests/data/Mana.tif\--write-raster/tmp/Mana_100m.tifGrid from vector, array from netCDF, write text array file for each time stat:$gridit--grid-from-vectortests/data/waitaku2.shp--resolution250\--array-from-vectortests/data/waitaku2.shp\--array-from-vector-attributerid\--array-from-netcdftests/data/waitaku2.nc:rid:myvar:0\--time-stats"quantile(0.75),max"\--write-text/tmp/waitaku2_cat.refGrid from MODFLOW, array from vector, write text array file:$gridit--grid-from-modflowtests/data/modflow/mfsim.nam:h6\--array-from-vectortests/data/waitaku2.shp\--array-from-vector-attributerid\--write-text/tmp/waitaku2_rid.txtSee other options with:$gridit-hFundingFunding for the development of gridit has been provided by New Zealand Strategic Science Investment Fund as part of GNS Science’s (https://www.gns.cri.nz/) Groundwater Research Programme.
Package: gridkit
GridKitGridKit is a tool to work with grids on a high abstraction level.Note: the api is likely to change between versions until release 1.x.xDocumentationFind the docs onGitHub Pages.ExamplesFind examples in theExample Gallerysection of the documentation.SourceFind me onGitHubInstallationTo install through PyPi, runpip install gridkit.Alternatively, install from source (GitHub). Please refer to theContributing guide
Package: gridlib
GRIDLibPython package to perform GRID analysis on fluorescence survival time distributions. Genuine Rate IDentification (GRID) analysis can be used to infer the dissociation rates of molecules from fluorescence survival time distributions retrieved with single-molecule tracking[1]. This package is based on work and research performed during my Bachelor end project in theIhor Smal labunder the supervision of Ihor Smal and Maarten W. Paul.GitHub repo:https://github.com/boydcpeters/gridlib.gitDocumentation:https://gridlib.readthedocs.ioFree software: GNU General Public License v3FeaturesSimulate fluorescence survival time distributions with user-defined parameters.Perform GRID analysis on fluorescence survival time distributions.Plot analysis results with matplotlib.Perfrom GRID resampling on fluorescence survival time distributions.Plot resampling results with matplotlib.Load and save fluorescence survival time distributions and analysis and resampling results.QuickstartInstall the package:pipinstallgridlibThere are a number of example scripts to perform some analyses in theexamplesfolder with more
extensive explanations provided in thedocumentation.ReferencesThe GRID fitting procedure implemented in this package is based on the following paper:[1]Reisser, M., Hettich, J., Kuhn, T., Popp, A.P., Große-Berkenbusch, A. and Gebhardt, J.C.M. (2020). Inferring quantity and qualities of superimposed reaction rates from single molecule survival time distributions. Scientific Reports, 10(1). doi:10.1038/s41598-020-58634-y.BibTex entry for the paper:@article{reisser2020inferring,
  title ={Inferring quantity and qualities of superimposed reaction rates from single molecule survival time distributions},
  author ={Reisser, Matthias and Hettich, Johannes and Kuhn, Timo and Popp, Achim P and Gro{\ss}e-Berkenbusch, Andreas and Gebhardt, J Christof M},
  journal ={Scientific reports},
  volume ={10},
  number ={1},
  pages ={1--13},
  year ={2020},
  publisher ={Nature Publishing Group}}In the above BibTex entry, the version number is the current version number and the year corresponds to the
project's open-source release.CreditsThis package was created withCookiecutterand thefedejaure/cookiecutter-modern-pypackageproject template.
Package: gridlock
Gridlock READMEGridlock is a Python module for drawing on coupled grids.Gridlock is used primarily for 'painting' shapes in 3D on multiple grids which represent the
same spatial region, but are offset from each other. It does straightforward natural <-> grid unit
conversion and can handle non-uniform rectangular grids (the entire grid is generated based on
the coordinates of the boundary points along each axis).Source repositoryPyPiInstallationRequirements:python 3 (written and tested with 3.9)numpyfloat_rastermatplotlib (optional, used for visualization functions)mpl_toolkits.mplot3d (optional, used for isosurface visualization)skimage (optional, used for isosurface visualization)Install with pip:pip3installgridlockAlternatively, install via gitpip3installgit+https://mpxd.net/code/jan/float_raster.git@release
pip3installgit+https://mpxd.net/code/jan/gridlock.git@release