Saravanan666/pypi-org huggingface dataset:
Package: grpphati-rs
GrPPHATI_rs (WIP)Rust implementation of variousGrPPHATIclasses, including:RustRegularPathHomology- an implementation of regular path homology producing a basis in parallel, using custom column types.RustGeneratorSparsifier- a lazy sparsifier written in Rust, meant to work with columns produced byRustRegularPathHomology.RustPreferredSparsifier- a non-lazy sparsifier written in Rust, meant to work with columns produced byRustRegularPathHomology.
Sparsifies columns of each dimension in parallel.UsageNoteRustRegularPathHomologydoes not produce columns in the same order asRegularPathHomology.
This leads to considerable slow down when usingPHATBackend.
As such, the recommended usage is withLoPHATBackend, available ingrpphati.
Eirene has not been tested so far.
It is also recommended to use the provided parallel sparsifier.
Good pipelines are provided ingrpphati_rs.GrPPH_rsandgrpphai_rs.GrPPH_par_wedge_rs.For example usage, please consultexamples/disjoint.pyin the repository.Known issuesGraphs used withRustRegularPathHomologymust be integer indexed.
Package: grprec
GrpRecGrpRec is a pyhon library designed for group recommendation systems.The diffrent task that you can do using this library are:- Generate different types of groups from your dataset using many methods in group recommendation litterature (Random groups, similar groups, divergent groups, etc.)
- Split your ratings dataset with different methods (train/test, train/validation/test, k-fold etc.)
- Generate prediction scores for your generated groups using individual recommendation systems algorithm.
- Use different group score aggregation strategies on the predicted scores to generate the recommendations (Average, Least miery, Borda count, etc.)
- Evaluate the recommendations using diffrent metrics used in litterature (Precision, Recall, First hit, NDCG)InstallationTo install the GrpRec library execute the following command in your python console:pipinstallgrprec
Package: grpu
# grpu[![PyPI version fury.io](https://badge.fury.io/py/grpu.svg)](https://pypi.python.org/pypi/grpu)
[![PyPI license](https://img.shields.io/pypi/l/grpu.svg)](https://pypi.python.org/pypi/grpu/)
[![PyPI status](https://img.shields.io/pypi/status/grpu.svg)](https://pypi.python.org/pypi/grpu/)Python Utilitiesasa
Package: grr
grris a simple utility to make using Gerrit a little less painful. It requires Python 3.5+.The basic workflow involves using a detached head, and pulling down changes from gerrit to
work on them, and re-submitting them. Inspired bygit-review,grrreads from.gitreviewfiles
and will try to use yourgitreview.usernamesetting.Installation:pipinstallgrrgrr init: Adds agerritremote and installs the commit-msg hookgrr fetch12345[:2]: Pulls change 12345. An optional patchset # can be specified, otherwise the latest will be used.grrcherry-pick12345[:2]: Just like fetch, except it cherry-picks the patch on top of HEAD.grr pull [master]: Pulls the latest remote changes and checks out the given branch, defaults to master.grr checkout [master]: Checkout the given branch, defaults to mastergrr review [branch]: Uploads your patches for review, the branch defaults to master.grr [branch]: Shorthand forgrr review.Licensed as GPLv3 or later, see COPYING for details.
Package: grrargparse
<html>
<h2>grrargparse - a common command line argument parser </h2>
<p>
grrargparse is written in Python 3 - for anyone saying “why not just use argparse”, this does use argparse as well as a number of other packages to do the kinds of things that we would want to do.
</p>
<p>
Have a look a the demo.py for an example implementation
</p>
</html>
Package: grrif-tools
GRRIF ToolsA set of tools for Cool Cats™. Allows you to archive GRRIF's play history to a SQLite database (or text files), compute/display some stats (top 10/25/100 artists and tracks), stream the radio live in your console, and scrobble it to last.fm.usage: grrif_tools [-h] {archive,stats,scrobble} ...

A set of tools for Cool Cats™. Allows you to archive GRRIF's play history and scrobble it to last.fm (upcoming).

positional arguments:
  {archive,stats,scrobble}
    archive             Archive GRRIF's play history.
    stats               Get some stats out of the database.
    play                Streams GRRIF to the console and displays the currently playing track.
    scrobble            Scrobble to Last.fm.

options:
  -h, --help            show this help message and exitNOTE:This package is unofficial and meant mostly as a playground to experiment with some new things (argparse, python packaging, etc...). Please do not DDoS GRRIF's website !NOTE2:Last.fm scrobbling is working and active while either streaming ("play") or using "scrobble start". This library will not handle authentification and requires some manual setup for last.fm's API access. Please create your own app on last.fm (https://www.last.fm/api/account/create) to get your API_KEY and API_SECRET, and seehttps://www.last.fm/api/authspecon how to get your SESSION_KEY (hint: it involves getting a token first and some md5 hashing).
Package: grrph
grrph -- Pascals Python Graph LibraryCurrently does nothing but is supposed to collect various useful helpers for loading, transforming, mining, and learning (on) graphs.Installation AdviceMany functions in this package require pytorch and pytorch_geometric. However, it is way too complicated to specify this properly in the requirements (for me, as of now).
So please, install pytorch and pytorch_geometric in the versions required for your environment yourself.
Package: grsched
grschedSummaryInstallationUsageCommand helpDependenciesSummaryA tool to show Garoon schedule at terminals.Installationpip install grschedUsage$ grsched configure
subdomain []: <input>
basic auth info (base64 encoded 'login-name:passowrd'): <input>
$ grsched events
...
$ grsched show next
...Command helpUsage: grsched [OPTIONS] COMMAND [ARGS]...

  common cmd help

Options:
  --version      Show the version and exit.
  --debug        For debug print.
  -q, --quiet    Suppress execution log messages.
  -v, --verbose
  -h, --help     Show this message and exit.

Commands:
  configure  Setup configurations of the tool.
  events     List events.
  show       Show specific event(s).
  users      List users.
  version    Show version informationUsage: grsched events [OPTIONS]

  List events.

Options:
  --user USER_ID    user id of the target. defaults to the login user.
  --since DATETIME  datetime.
  -h, --help        Show this message and exit.

  Issue tracker: https://github.com/thombashi/grsched/issuesUsage: grsched show [OPTIONS] [EVENT_IDS]...

  Show specific event(s). EVENT_IDS must be space-separated IDs of events to
  be shown. You can also use a special specifier "next" to show the next
  upcoming event.

Options:
  --user USER_ID  user id of the target. defaults to the login user.
  -h, --help      Show this message and exit.

  Issue tracker: https://github.com/thombashi/grsched/issuesDependenciesPython 3.5+Python package dependencies (automatically installed)
Package: grscheller.boring-math
PyPI grscheller.boring-math ProjectDaddy's boring math library.Python package of functions of a mathematical natureProject name suggested by my then 13 year old daughter MaryExample of a Python package with both libraries and executablesgrscheller.circular-arrayproject on PyPIDetailed API documentationon GH-PagesSource codeon GitHubOverviewHere are the modules which make up the grscheller.boring_math package.Integer Math ModuleCombinatoricsFibonacci SequencesNumber TheoryPythagorean TriplesRecursive FunctionsInteger Math CLI ModuleAckermann's FunctionPythagorean TriplesInteger Math ModuleCombinatoricsFunctioncomb(n: int, m: int) -> intreturns C(n,m) - the number of n items taken m at a timecontains two additional default parameters that can be adjustedfactorsNumerator = 66factorsDenonator = 4actually comb(n, m, 1, 1) runs faster for reasonably small n and mbetter choice for inner loops and printable resultsabout 3 times slower than C based math.comb(n, m)these default paramenters are better for larger resultsgoal is for it to work reasonably well after math.comb bogs downsuspect it will really shine for pypy when it supports Python 3.11Fibonacci SequencesFunctionfibonacci(f0: int=0, f1: int=1) -> Iteratorreturn an iterator for a Fibonacci sequencedefaults to0, 1, 1, 2, 3, 5, 8, ...Number theoryFunctiongcd(fst: int, snd: int) -> inttakes two integers, returns greatest common divisor (gcd)wheregcd >= 0gcd(0,0)returns0but in this case the gcd does not existFunctionlcm(fst: int, snd: int) -> inttakes two integers, returns least common multiple (lcm)Functionprimes(start: int=2, end_before: int=100) -> Iteratortakes two integers, returns an iterator of primesstarting at first prime at or afterstartending at last prime beforeend_beforePythagorean TriplesThe valuesa, b, c > 0represent integer sides of a right triangle.Functionpythag3(a_max: int=3, all_max: int|None=None) -> IteratorReturn an interator of tuples of Pythagorean TiplesSidea <= a_maxand sidesa, b, c <= all_maxIterator finds all primative pythagorean triples up to a given a_maxRecursive FunctionsFunctionackermann(m: int, n: int) -> intAckermann's function is a doublely recursively defined functionAn example of a computable but not primitive recursive functionBecomes numerically intractable after m=4Integer Math CLI ModuleAckermann's FunctionFunctionackerman_cli(fst: int, snd: int) -> Noneentry point for program ackermannAckermann's function is defined recursively byackermann(0,n) = n+1ackermann(m,0) = ackermann(m-1,1)ackermann(m,n) = ackermann(m-1,ackermann(m, n-1))forn,m > 0Usage:ackerman m nPythagorean Triple Functionentry point for program pythag3A Pythagorean triple is a 3-tuple of integers(a, b, c)such thata*a + b*b = c*cwherea,b,c > 0andgcd(a,b,c) = 1The integersa, b, crepresent the sides of a right triangleUsage:pythag3 n [m]one argument outputs all triples witha <= ntwo arguments outputs all triples witha <= nanda, b, c <= m
Package: grscheller.circular-array
PyPI grscheller.circular-array ProjectPython module implementing an indexable circular array data structure.See thegrscheller.circular-arrayproject on PyPIDetailedAPI documentationall versionsOverviewThe CircularArray class implements an auto-resizing, indexable, double
sided queue data structure. O(1) indexing and O(1) pushes and pops
either end. Useful as an improved version of a Python list. Used in
a has-a relationship by grscheller.datastructure when implementing other
data structures where its functionality is more likely restricted than
augmented.Usagefrom grscheller.circular_array import CircularArray
Package: grscheller.datastructures
PyPI grscheller.datastructures ProjectPython package of data structures which support the use and
implementation of algorithms.Functional & imperative programming styles supportedFP supported but project endeavors to remain PythonicMethods which mutate objects don't return anythinggrscheller.circular-arrayproject on PyPIDetailed API documentationon GH-PagesSource codeon GitHubOverviewThe data structures in this package allow developers to focus on the
algorithms they are using instead of all the "bit fiddling" required to
implement behaviors, perform memory management, and handle edge cases
needed if Python builtin types were used instead. These data structures
allow iterators to leisurely iterate over inaccessible copies of
internal state while the data stuctures themselves safely mutate. Some
of these data structures allow data to be safely shared between multiple
data structure instances by making shared data immutable and
inaccessible to client code.This package does not force functional programming paradigms on client
code, but provide functional tools to opt into. It also does not force
unnecessary exception driven code paths upon client code. Purity is
important, but not at the expense of practicality. Sometimes the real
power of a data structure comes not from what it empowers you to do, but
from what it prevents you from doing to yourself.As a design choice, PythonNoneis semantically used by this package
to indicate the absence of a value. While still freely used as an
implementation detail,Nonevalues are not stored in these data
structures. FunctionalMaybeandEitherclasses are provided in the
core.fp sub-module as better ways to handle "missing" data.
Package: grss
grssGRSS(pronounced "grass"), theGauss-Radau Small-body Simulatoris a Python package with a C++ binding for propagating and fitting the orbits of small bodies in the solar system, such as asteroids and comets.If you use GRSS in your research, please cite the following paper:Makadia et al. (2024), "Measurability of the Heliocentric Momentum Enhancement from a Kinetic Impact: The Double Asteroid Redirection Test (DART) Mission",Planetary Science Journal, 5, 38.Getting StartedThere are currently two different ways to install the GRSS library.Using thePython Package Index (PyPI)Using the source code from theGitHub repositoryInstall via PyPIThe GRSS library is available on PyPI and can be installed using the following command:pip install grssIf this installation fails (i.e., you get an error when importing GRSS), you can try installing it without using the binary wheel on PyPI by using the following command:pip install grss --no-binary grssNOTE: The GRSS library is currently not pip-installable on Intel-based Macs. To use the library on an Intel-based Mac, please install the library using the source code from the GitHub repository (see below for instructions).Install via source codeThe source code for the GRSS library is available on GitHub and can be downloaded using the following command:git clone https://www.github.com/rahil-makadia/grssOnce the source code has been downloaded, the library can be installed using the following command:cd grsssource initialize.shpython3 -m pip install .UsageOnce the GRSS library has been installed, it can be imported into a Python script using the following command:importgrssThe first time the library is imported, it will download some data files such as NAIF SPICE kernels and the data needed to debias optical astrometry. This should should take a few minutes, and if the download was completed, the following message will be printed for each file:YYYY-MM-DD HH:MM:SS URL:url-of-downloaded-file [filesize] -> path/to/downloaded/file [1]Once these files are available to the library, you are ready to use GRSS to its full potential!Check out theexampleson theGRSS websiteto get started.AcknowledgementsGRSS Development Team:Rahil MakadiaSteven R. ChesleySiegfried EgglDavide FarnocchiaThe GRSS library was developed by Rahil Makadia as part of his PhD dissertation at the University of Illinois at Urbana-Champaign. This work was supported by a NASA Space Technologies Graduate Research Opportunities (NSTGRO) Fellowship, Grant #80NSSC22K1173. The author would like to thank his advisor, Dr. Siegfried Eggl as well as his collaborators, Dr. Steven R. Chesley, and Dr. Davide Farnocchia for their guidance and support.
Package: grub
grubA ridiculously simple search engineExample: Search codefromgrubimportSearchStoreimportsklearn# instead of talking any file, let's search the files of sklearn itself!path_format=os.path.dirname(sklearn.__file__)+'{}.py'search=SearchStore(path_format)Let's search for ANN. That stands for Artificial Neural Networks. Did you know? Well search figures it out, pretty early, that I was talking about neural networks.search('ANN')array(['sklearn/tree/_export.py', 'sklearn/linear_model/_least_angle.py',
       'sklearn/feature_selection/_base.py',
       'sklearn/feature_selection/tests/test_variance_threshold.py',
       'sklearn/neural_network/tests/test_stochastic_optimizers.py',
       'sklearn/neural_network/__init__.py',
       'sklearn/neural_network/_stochastic_optimizers.py',
       'sklearn/neural_network/_multilayer_perceptron.py',
       'sklearn/neural_network/rbm.py',
       'sklearn/neural_network/tests/test_rbm.py'], dtype='<U75')Let's search for something more complicated. Like a sentence.
The results show promise promises: It's about calibration, but related are robustness, feature selection and validation...search('how to calibrate the estimates of my classifier')array(['sklearn/covariance/_robust_covariance.py',
       'sklearn/svm/_classes.py',
       'sklearn/covariance/_elliptic_envelope.py',
       'sklearn/neighbors/_lof.py', 'sklearn/ensemble/_iforest.py',
       'sklearn/feature_selection/_rfe.py', 'sklearn/calibration.py',
       'sklearn/model_selection/_validation.py',
       'sklearn/ensemble/_forest.py', 'sklearn/ensemble/_gb.py'],
      dtype='<U75')
Package: grub2-theme-preview
Aboutgrub2-theme-previewcame into life when I was looking around for
available GRUB 2.x themes and wanted a way to quickly see a theme
in action without rebooting real hardware.It takes a theme folder (or just a single picture),
creates a temporary bootable image usinggrub2-mkrescueand launches
that image in a virtual machine using KVM/QEMU, all without root privileges.(Showing themegutsblack-archlinux)InstallationTo install the latest release fromPyPI:#pipinstall--usergrub2-theme-previewTo install from a Git clonefor development:#pipinstall--user--editable.Please make sure to install thesenon-PyPI dependenciesas well:grub-mkrescueofGRUB 2(packagegrub-commonon Debian and Ubuntu)QEMU—hypervisor that performs hardware virtualizationOVMF— EFI bios image for use with QEMUmtools—collection of utilities to access MS-DOSxorrisooflibisoburn—frontend which enables creation and expansion of the ISO formatUsage#grub2-theme-preview--helpusage: grub2-theme-preview [-h] [--grub-cfg PATH] [--verbose][--resolution WxH] [--timeout SECONDS][--add TARGET=/SOURCE] [--version][--grub2-mkrescue COMMAND] [--qemu COMMAND][--xorriso COMMAND] [--no-kvm] [--debug][--plain-rescue-image]PATHpositional arguments:PATH                  path of theme directory (or PNG/TGA image file) topreviewoptional arguments:-h, --help            show this help message and exit--grub-cfg PATH       path of custom grub.cfg file to use (default:/boot/grub{2,}/grub.cfg)--verbose             increase verbosity--resolution WxH      set a custom resolution, e.g. 800x600--timeout SECONDS     set GRUB timeout in whole seconds or -1 to disable(default: 30 seconds)--add TARGET=/SOURCE  make grub2-mkrescue add file(s) from /SOURCE to/TARGET in the rescue image (can be passed multipletimes)--version             show program's version number and exitcommand location arguments:--grub2-mkrescue COMMANDgrub2-mkrescue command (default: auto-detect)--qemu COMMAND        KVM/QEMU command (default: qemu-system-<machine>)--xorriso COMMAND     xorriso command (default: xorriso)arguments related to invokation of QEMU/KVM:--display DISPLAY     pass "-display DISPLAY" to QEMU, see "man qemu" fordetails (default: use QEMU's default display)--full-screen         pass "-full-screen" to QEMU--no-kvm              do not pass -enable-kvm to QEMU (and hence fall backto acceleration "tcg" which is significantly slowerthan KVM)--vga CARD            pass "-vga CARD" to QEMU, see "man qemu" for details(default: use QEMU's default VGA card)debugging arguments:--debug               enable debugging output--plain-rescue-image  use unprocessed GRUB rescue image with no themepatched in; useful for checking if a plain GRUB rescueimage shows up a GRUB shell, successfully.
Package: grudge
grudge helps you discretize discontinuous Galerkin operators, quickly
and accurately.It relies onnumpyfor arraysmodepyfor modes and nodes on simplicesmeshmodefor modes and nodes on simplicesloopyfor fast array operationsleapfor time integrationdagrtas an execution runtimepytestfor automated testingand, indirectly,PyOpenCLas computational infrastructurePyOpenCL is likely the only package you’ll have to install
by hand, all the others will be installed automatically.Resources:documentationwiki home pagesource code via git
Package: gruffy
AboutGruffy is a yet another Python Graphing Library.
inspired byGruff(Ruby Graphing Library).This module usingpgmagick(GraphicsMagick) .InstallInstall from PyPI:$ pip install gruffyRequirepgmagickmodule.package install on Ubuntu:$ apt-get install libgraphicsmagick++-dev
$ apt-get install libboost-python1.40-dev
$ pip install pgmagickBasic UsageBar Graph Sample:from gruffy import Bar

g = Bar()
g.title = "Gruffy's Graph"

g.data("Apples", [1, 2, 3, 4, 4, 3])
g.data("Oranges", [4, 8, 7, 9, 8, 9])
g.data("Watermelon", [2, 3, 1, 5, 6, 8])
g.data("Peaches", [9, 9, 10, 8, 7, 9])

g.labels = {0: '2003', 2: '2004', 4: '2005'}

g.write('sample.png')Getting the sourceDownload fromgithuborPyPIDocumentationGruffy Documentation
Package: grug
# grugA Unified Experience for Python Development## What does grug mean?Grug is an internet slang used to refer to Neanderthals or a caveman
(internet being internet, more things as well).This tool’s name is inspired from the title of [talk by Russell Keith-Magee][1].[1]:https://www.youtube.com/watch?v=UtFHIpNPMPA
Package: grug-test
What is this?Simple automated tests; forgrugdevs like me who don't have time to test.How do I use this?pip install grug_testIn yourmain.pyequivlent:fromgrug_testimportGrugTestimportos# 1. say where the tests will be savedgrug_test=GrugTest(project_folder=".",test_folder="./tests/grug_tests",fully_disable=os.environ.get("PROD")!=None,replay_inputs=os.environ.get("RUN_TEST_CASES")!=None,record_io=os.environ.get("RECORD")!=None,)# 2. slap @grug_test on any of your pure-functions@grug_test(max_io=100)defrepeat(a,times):for_inrange(times):a+=f"{a}"returnaThat's all the setup!RECORD=True         python ./main.pywill record tests for youRUN_TEST_CASES=True python ./main.pywill check your functionsPROD=True           python ./main.pywill run with grug totally disabledMake sure to commit the generated tests to gitWhen you doRUN_TEST_CASES=True, the git-diff will show you any problemsIf you like the changes, well ✨volia✨ the git changes are your freshly-written test casesIf you don't like the changes, well then it looks like you've got some dev work to dothats itQ&ADoes this work with@staticmethod?Yes but you have to put the decorator it on the line BELOW the@staticmethodDoes this work with ANY pure function?Almost, the arguments need to be seralizable. For example, if you pass a lambda function as an argument then grug_test can't really save/load that lambda function whenreplay_inputs=True. However, you can make almost any normal class seralizable, just checkout a tutorial on making a class work with python-pickle, or (even better) dofrom grug_test import yamland make your class be yaml-seralizable (tutorial/examplehere)
Package: grui
GruiGenerated Rest User InterfaceThis package allow developer to expose function to the web. GRUI will generate a Rest API from the class.
An HTTP page will also be generated. The main idea is to focus the code on the functionality.Code examplesfromtypingimport*fromgruiimportGruiServicefromgrui.decoratorimport*classMySuperService(GruiService):"""The documentation will be available to end user.Longer description will be display into the help page of the service."""@Get("my-super-path")@NotFoundIfEmpty# Set the http return code to 404 if it return None.defget_all(self)->Optional[List[int]]:"""The method documentation is display to the user as well"""returnself.whateverIssues/Bug report or improvement ideashttps://gitlab.com/olive007/grui/-/issuesLicenseGNU Lesser General Public License v3 or later (LGPLv3+)