Saravanan666/pypi-org huggingface dataset:
Package: griptape-cli
griptape-cliCLI for the Griptape Framework and Cloud.PrerequisitesCLIcloudcommands require aGriptape Cloudaccount.Quick StartInstall griptape-clipipx install griptape-cliVerify installationgt --helpGriptape CloudConfigure the Cloud:poetryrungtcloudconfigureUse the cloud command to make API calls:poetryrungtcloudlist-organizationsCreate an App from the template using the app command:poetryrungtappnew--directory~/workplacedemo_appTest an App locally:poetryrungtapprun--directory~/workplace/demo_app--arg"what is griptape?"--init-param"key""value"Create an App on the Cloud:poetryrungtcloudcreate-app--name"Demo App"Create a Deployment for the App on the Cloud using the App ID:poetryrungtcloudcreate-deployment--app-id12345678-9e29-4759-b357-dc513821c5b2--directory~/workplace/demo_appRun an App on the Cloud using the App ID:poetryrungtcloudrun--app-id12345678-9e29-4759-b357-dc513821c5b2--arg"what is griptape?"--init-param"key""value"DocumentationPlease refer toGriptape DocsDevelopmentpoetryinstall
poetryrungtTestspoetryrunpytestContributingThank you for considering contributing to Griptape! Before you start, please read the following guidelines.Submitting IssuesIf you have identified a bug, want to propose a new feature, or have a question, please submit an issue through our publicissue tracker. Before submitting a new issue, please check the existing issues to ensure it hasn't been reported or discussed before.VersioningGriptape CLI is in constant development and its APIs and documentation are subject to change. Until we stabilize the API and release version 1.0.0, we will use minor versions (i.e., x.Y.z) to introduce features and breaking features, and patch versions (i.e., x.y.Z) for bug fixes.LicenseGriptape CLI is available under the Apache 2.0 License.
Package: griptape-core
griptape-coregriptape-coreis a Python framework that enables developers to write tools for generative AI middleware once and use it anywhere.griptape-coreis part ofgriptape, a modular Python framework for integrating data, APIs, tools, memory, and chain of thought reasoning into LLMs.griptape-corehas three core components:Tools: call external APIs, access databases, and run arbitrary code or CLI commands.Executors: run your tools safely in any environment: local, containerized, or serverless in the cloud.Adapters: convert tools into underlying middleware abstractions, such as ChatGPT Plugins, LangChain tools, and Fixie.ai agents.DocumentationPlease refer toGriptape Docsfor:Getting started guides.Core concepts and design overviews.Examples.Contribution guidelines.Licensegriptape-core is available under the Apache 2.0 License.
Package: griptape-flow
griptape-flowgriptape-flowis a Python framework for creating workflow DAGs and pipelines that use large language models (LLMs) such as GPT, Claude, Titan, and Cohere.griptape-flowis part ofgriptape, a modular Python framework for integrating data, APIs, tools, memory, and chain of thought reasoning into LLMs.DocumentationPlease refer toGriptape Docsfor:Getting started guides.Core concepts and design overviews.Examples.Contribution guidelines.Licensegriptape-flow is available under the Apache 2.0 License.
Package: griptape-tools
griptape-toolsThis repo is a collection of official Griptape tools for theGriptape Framework.If you are considering contributing a new tool, please make a pull request togriptape-labsfirst.DocumentationPlease refer toGriptape Docsfor:Getting started guides.Core concepts and design overviews.Examples.Contribution guidelines.LicenseGriptape Tools are available under the Apache 2.0 License.
Package: gris
READMEAbout grisgrisis a minimalistic tool to read, parse, and
write reference data inRefman RIS format.RIS format codifies bibliographic data using a series of tags. There
are variations among publishers: this module supports
both the original standard and the RIS output by Web of Knowledge.This module has been updated and tested in Python 3.7+. The documentation
can be found inreadthedocs.InstallInstallgrisdirectly usingpip:pip install grisHow to use itFrom the command line:python -m gris myrefs.ris ABretrieves and prints out the contents of the tagAB(usually used for
abstracts) for all the publications in a reference file.From a script or Python programfrom gris import read_ris

refs = read_ris("myrefs.ris")Backgroundgriswas developed by AYG during his personal time, as a way of transforming
bibliographic data into more machine-readable formats and preserving
all bibliographic data. It eventually found its way to various publications where the work required processing large amounts of bibliographic data.grisimports RIS files with multiple references into a list of dictionaries.LicenseCopyright (C) 2013 Angel Yanguas-GilThis program is free software, licensed under GPLv2 or later.
A copy of the GPLv2 license is provided in the root directory of the source code.
Package: grispy
GriSPy (Grid Search in Python)GriSPyis a regular grid search algorithm for quick nearest-neighbor lookup.This class indexes a set of k-dimensional points in a regular grid providing a fast aproach for nearest neighbors queries. Optional periodic boundary conditions can be provided for each axis individually.GriSPy has the following queries implemented:bubble_neighbors: find neighbors within a given radius. A different radius for each centre can be provided.shell_neighbors: find neighbors within given lower and upper radius. Different lower and upper radius can be provided for each centre.nearest_neighbors: find the nth nearest neighbors for each centre.And the following method is available:set_periodicity: define the periodicity conditions.RequirementsYou need Python 3.6 or later to run GriSPy. You can have multiple Python
versions (2.x and 3.x) installed on the same system without problems.Standard InstallationGriSPy is available atPyPI. You can install it via the pip command$ pip install grispyDevelopment InstallClone this repo and then inside the local directory execute$ pip install -e .CitationIf you useGriSPyin a scientific publication, we would appreciate citations to the following paper:Chalela, M., Sillero, E., Pereyra, L., García, M. A., Cabral, J. B., Lares, M., & Merchán, M. (2020).
GriSPy: A Python package for fixed-radius nearest neighbors search. 10.1016/j.ascom.2020.100443.Bibtex@ARTICLE{Chalela2021,author={{Chalela}, M. and {Sillero}, E. and {Pereyra}, L. and {Garcia}, M.~A. and {Cabral}, J.~B. and {Lares}, M. and {Merch{\'a}n}, M.},title="{GriSPy: A Python package for fixed-radius nearest neighbors search}",journal={Astronomy and Computing},keywords={Data mining, Nearest-neighbor search, Methods, Data analysis, Astroinformatics, Python package},year=2021,month=jan,volume={34},eid={100443},pages={100443},doi={10.1016/j.ascom.2020.100443},adsurl={https://ui.adsabs.harvard.edu/abs/2021A&C....3400443C},adsnote={Provided by the SAO/NASA Astrophysics Data System}}Full-text:https://arxiv.org/abs/1912.09585AuthorsMartin Chalela (E-mail:mchalela@unc.edu.ar),
Emanuel Sillero, Luis Pereyra, Alejandro Garcia, Juan B. Cabral, Marcelo Lares, Manuel Merchán.
Package: grist-api
Thegrist_apiis a Python client for interacting with Grist.Installationgrist_api is available on PyPI:https://pypi.python.org/pypi/grist_api/:pip install grist_apiThe code is on GitHub:https://github.com/gristlabs/py_grist_api.The API Reference is here:http://py_grist_api.readthedocs.io/en/latest/api-index.html.UsageTO BE DOCUMENTED.TestsTests are in thetests/subdirectory. To run all tests, run:nosetests
Package: grist-jupyterlab-widget
grist_jupyterlab_widgetCustom Grist widget for a JupyterLite notebookRequirementsJupyterLab >= 4.0.0InstallTo install the extension, execute:pipinstallgrist_jupyterlab_widgetUninstallTo remove the extension, execute:pipuninstallgrist_jupyterlab_widgetContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the grist_jupyterlab_widget directory# Install package in development modepipinstall-e"."# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstallpipuninstallgrist_jupyterlab_widgetIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedgrist-widgetwithin that folder.Packaging the extensionSeeRELEASE
Package: grit
1 OverviewGrit is a simple and light-weight git repository manager or git-compatible digital asset management
system with limited remote object proxying, a http back-end and easy to use command line, python and
cli user interfaces.NoteThis is early prototype code, is missing many important features and probably won’t work for you.Documentation:http://rsgalloway.github.com/grit1.1 FeaturesPython WSGI “Smart HTTP” serverLimited remote object proxyingStream blob data from remote repositoriesHierarchical repos with top-down inheritanceCheck out individual blobsPython and HTTP+JSON read/write APISupports a centralized workflowCommand line, Python and web UIsGit not required1.2 Known IssuesKnown issues as of this release:Currently no support for diff, status, submodule or tagPoor performance with large binary filesCan only checkout repos and blobs, not trees1.3 RequirementsPython (2.6.5)Dulwich (0.7.0)Git (optional)1.4 Noted differences from gitA branch in grit is different from a branch in git in that a branch is a child of a repo and inherits its files automatically. Files can be overwritten at the branch level.Grit supports (limited) remote object proxying, so you can browse and get information about an object without checking it out.Checkouts in grit are different in that you can check out a given version (latest by default) of a repo, or a single file.2 Installation$ easy_install gritor, download the source and$ sudo python setup.py install2.1 Environment VariablesThe following environment variables are used, but not required.GRIT_LOG_LEVEL     logging level (default is 20)
GRIT_SERVER_PORT   default port to run the grit server on (default is 8080)
GRIT_STATIC_DIR    filesystem location for serving web UI elements3 Basic Usagegrit COMMAND [OPTIONS]

Commands:

new     make new repo at url
co      check out files from repo at url
ci      check in files to repo at url
serve   serve a repo or directory of repos4 LicenseSee file named LICENSE for license terms governing over the entire project.Some, explisitely labeled so constituent files/works are licensed under separate, more-permissive
terms. See disclaimers at the start of the files for details.
Package: gritic
A tool for timing complex copy number gains in cancer. Provides gain timing estimates for segments with a total copy number of up to 9. Only copy number segments with 10 or more SNVs will be timed.Each gain timing is measured in mutation time, a scale that ranges from 0 to 1. A timing of 0 indicates that the gain occured close to conception and 1 that the gain occurred very close to the emergence of the tumour's most recent common ancestor.
Package: grits
gritsStatic blog generator that creates a single page app.  Dynamic routes are possible for some hosts (not GH-Pages).Change Log[0.5.1] - 2017.07.16prettify_htmlis a noop for now, sinceBeautifulSoup.prettifywas
inserting significant whitespace into elements.[0.5] - 2017.06.14Rewrote the content splitting mechanism.  Each source html file can have the following format:
* at most one <head> section
* exactly one <main> section (with any number of inner scripts)
* any number of top-level <script> sections.grits-buildtakes--src,--dst, and--tpl.  Use--tplto provide your own templates for eg.__full.htmlor__partial.html.Source scripts are broken up and the pieces stored in the rendering context as"head","main",
and"scripts".  These are each strings.The simplest way to userender.Rendereris throughRenderer.process()which runs through the source folder
and generates the necessary mapp-specific components like_dynamicRoutes.json.  If you manually generate files,
make sure to callRenderer.render_scaffolding()to produce those files.AddedSplit src_dir from templates_dircontents of src_dir are always rendered to output while templates_dir are only used to find extra templates[0.4] - 2017.06.11AddedRenderer.renderhandles binary files, usescontext["is_binary"]function to decide if file should be copied directly.
Defaults togrits.render.default_is_binary.Properly copytemplates/staticfor rendering.[0.2] - 2017.1.30Addedgrits.buildscriptsgrits-buildandgrits-serve[0.1] - 2017.1.29 [YANKED]AddedInitial commit
Package: griznog
GriznogUsageI'm a redneck, I never read the instructions.
--Griznog 4/26/2019Well, there are still several use cases you might want to read about!InstallCommand Line UsagePython UsageContainer UsageInstallInstall your Griznog from pypipipinstallgriznogor install from the repository directly:$gitclonehttps://github.com/vsoch/griznog
$cdgriznog
$pythonsetup.pyinstallCommand Line UsageThe main utility of Griznog is to speak:$griznog--help
usage:griznog[-h][--version]{speak}...

Griznog,capturedincode

optionalarguments:-h,--helpshowthishelpmessageandexit--versionprinttheversionandexit.

actions:actionsforGriznog{speak}griznogactionsspeakaskGriznogtospeakhiswisdom.and specifically, we can ask for a random quote (no arguments), filter to a
topic (--topic <topic>), disable color, or have him dump all of his wisdom
(with some pause between quotes).$griznogspeak--help

usage:griznogspeak[-h][--topicTOPIC][--pausePAUSE][--dump][--no-color]optionalarguments:-h,--helpshowthishelpmessageandexit--topicTOPICsubsettoparticulartopic.--pausePAUSEsecondstoallowGriznogtobreathebetweenspurts(default3seconds).--dumpJustheareverything.Optionallyseta--pause(seconds)--no-colordisablecolor1. Random Quote$griznogspeak

griznoghopeseveryonehasananxietyattackandleaveshimalonewith10pizzas.

--Griznog11/28/20182. Quote filtered to topic$griznogspeak--topicpizza

Wearefairlysimplecreatures,throwustheoccasionalbeer,donutandpizza,sendushardware(inquantitiesthatarepowersof2!)andlockusinthebasementandwearehappy.

--Griznog8/31/20183. Quote Dump$griznogspeak--dumpDisable color (also works for previously mentioned commands)$griznogspeak--dump--no-colorPython Usage1. Create your GriznogFirst, create your Griznog.fromgriznogimportGriznog>human=Griznog()2. WisdomAsk your Griznog for a random point of wisdom!>human.speak()Thesadrealityisthattheuniversedoesn't work this way. In the same way we carry DNA and RNA that is billions of years old, we are stuck with legacy code. Organisms aren'trewardedbyevolutionformakinggiantrewrites,andprogrammersaren't rewarded by HR for making things simpler or starting over fresh.--Griznog10/11/2018Optionally you can filter to a particular topic.>human.speak(topic='container')Isaidtheyweresurprisinglypowerful,Ididn't mean container fanbois couldn'tscrewthemup.--Griznog9/13/2018For an entertaining stream of wisdom, you know what to do:>human.dump()You can also dump with a filtered set:>human.dump(topic='container')For any of the above, if your terminal doesn't support color, just disable it.>human.speak(add_color=False)Container UsageGriznog is... trapped in a container!dockerrun-itquay.io/vanessa/griznogspeak

jobsecurity.Igetscaredwhenanyofthisworkstoowell.

--Griznog4/12/2018Do you have a question? Or want to suggest a feature to make it better?
Pleaseopen an issue!
Package: grizzlies
Grizzlies   Parseador de un archivo csv a json, y de un archivo json a csv.¿Qué es Grizzlies?Es una librería capaz de leer archivos tanto en formatocsvcomojson, además de convertirlos acsvojsony guardarlos en un directorio especificado por el usuario.¿Qué aporta la librería grizzlies?Ser capaz de leer archivoscsvpor el delimitador que se le indique.Detección automatica del tipo de archivo introducido.Dependiendo del tipo de archivo introducido, sabe a que lo debe convertir y como guardarlo.Sencilla utilización. El usuario solo debe llamar a la clase y añadir el método que desea realizar.Código fuente y cómo instalarlo.El repositorio github donde se encuentra el código fuente es el siguiente:https://github.com/JonJarrinVitoria/Grizzlies.git.Para instalar la libreria grizzlies:https://pypi.org/project/grizzlies/.pip install grizzlies¿Cómo funciona grizzlies?Ejemplo de configuración y utilización con un archivo csv:Para el primer paso, se importara la librería y se configurara.import grizzlies as gz
 conversor = gz.grizzlies()Se procede a leer el arhivocsv. En este caso, al ser un archivocsv, se debe introducir el nombre del archivo y el delimitador en caso de ser diferente a ";".conversor.leer('./MiDirectorio/archivo.csv', delimitador=',')En el siguiente paso, se convierte el archivocsva tipojson. En este caso, no hace falta que se introduzca nada, ya que coge la información del paso anterior, y sabe identificar que tipo de archivo es, y por ende, a cual debe convertirlo:conversor.convertir()Finalmente, para poder guardar el arhivo, se le debe indicar el directorio donde se quiere guardar, el nombre con el que se quiere guardar, junto con la extensión a la cual se ha convertido:conversor.guardar('./MiDirectorio/archivo.json')Dependenciasflatten_json - poner que hace esta libreria.pip install flatten_json.LicenciaEste proyecto se encuentra bajo los terminos de la licenciaMIT- más información sobre los detalles enLICENSE.txt.
Package: grizzly-framework
GrizzlyGrizzly is a modular general purpose browser fuzzing framework. The goal is to create a platform that can be extended via the creation of plug-ins to support multiple combinations of browsers and fuzzers. An Adapter is used to add support for a fuzzer and a Target to add support for a browser. Generated test cases are intended to be standalone and not require Grizzly.Cross platform compatibility is available for Windows, Linux and MacOS.
However not all features may be available.For additional information please check out thewikior theannouncement.Quick StartInstall the latest version from PyPI. For more details seegetting startedon the wiki.python3 -m pip install grizzly-frameworkFuzz- Run theno-optest adapter to check everything is working.python3 -m grizzly <browser-binary> no-opReduce-Grizzly Reducecan reduce a test case.python3 -m grizzly.reduce <browser-binary> <testcase>Replay-Grizzly Replaycan replay a test case with different builds and debuggers.python3 -m grizzly.replay <browser-binary> <testcase>
Package: grk
groka silly tool to query Github repository metadataGetting startedCreate a personal access tokenGenerate a public read-onlypersonal access token. Back up the token somewhere safe, then use it in our configuration in the next stepCreate a configuration~/.config/grok.tolmcat<< EOF > ~/.config/grok.toml[system]auth_key = "your key goes here"default_org = "holmanb"default_repo = "grok"default_mode = "all"EOFBe sure to set your key, default organization, and default repo in the configuration.Install grokpipinstall--usergrkRun grokgrok
Package: gr_lora_sdr_profiler
gr-lora_sdr-profilerProfile different flowgraph configurations ofgr-lora_sdrSummaryThis is a python cli package to be able to load a config yml file and change values to the flowgraph and run the flowgraph.Installation$pipinstallgr_lora_sdr_profilerDocumentation[-h][--version][-m{multi_stream,frame_detector-sim,frame_detector-usrp,cran-sim,cran-usrp}][-s{pandas,wandb,both}][-nNAME][-pFILE][-oOUTPUT][-tTIMEOUT][--no_remove_temp][--sequential_spreading_factor][-v][-vv]FILE[FILE...]Usageconfigthe config files are parsed on launch of the script and are fed into the flowgraph script.cliRun flowgraph$python-mprofiler--mframe_detector-spandasexample_config.ymlPlot all values by using$python-mprofiler--mframe_detector-presults/out.csvexample_config.ymlDevelopment setup$python3-mvenvenv
$.env/bin/activate
$makedeps
$toxChangelogLicenseMIT
Package: grm
GitRoom Manager allows instructors to more easily manage a GitHub-based
virtual classroom. From within the program, the user can:Initialize student repositories, locally and remotely, from a CSV
roster and a local master repositoryAdd students to an existing courseAdd administrators to the course (other instructors)Associate each student with a personal private repositoryUpdate student repositories with new course contentPull from/push to student repositoriesGrade assignmentsRequirementsPython >= 3.3Git >= 2.0Ownership of aGitHub ClassroomGitHub Personal
Tokenwith full permissionsClass roster with columns for student: first name, last name, GitHub
IDInstallationTo install thegrmmodule, clone the repository to your local
machine andcdinto the top-level directory. From the terminal,
type:python setup.py installNOTE:You may need to usepython3orpython3.xin place ofpythonin order to utilize a Python 3.x installation.You may also install with pip:pipinstallgrmNOTE:Depending on your installation may need to usepip3in place ofpip.UsageYou can call GitRoom Manager from within an interactive Python session
by calling:importgrmgrm.main()The installation also adds an executable script to your path. You can
call GitRoom Manager from terminal using:$gitroomNOTE:The command line script is just a wrapper for the first set of
commands above. The script searches your environment for your Python 3.x
interpreter. If it cannot find it, the script may revert to your system
Python interpreter—which is often 2.x—and may fail. If you have
trouble with the command line script, first make sure that your Python
3.x interpreter is in your system path and callable bypython3.ManualA more complete manual for GitRoom Manager can be found atbtskinner.me/grm