Saravanan666/pypi-org huggingface dataset:
Package: gromacs-py
Gromacs_pyGromacs_pyis a Python library allowing a simplified use of the Gromacs MD simulation software.Gromacs_pycan build a system topologie based on a pdb file, create the simulation system (pbc box, adding water and ions) and run minimisation, equilibration and production runs.
One of the main objective of theGromacs_pywrapper is to automatize routine operations for MD simulation of multiple systems.Gromacs_pyis under active development using continuous integration withTravis Cl.Online Documentation:https://gromacs-py.readthedocs.ioSource code repository:https://github.com/samuelmurail/gromacs_pyQuick installThe latest release can be installed viapiporconda.CondaIf you don’t need a GPU compiled version of Gromacs you can use directly theGromacs_pyconda packageto install both Gromacs software andGromacs_pylibrary:condainstall-cbiocondagromacs_pyPip (Deprecated)If the folowing softwares/modules are installed then you need to install theGromacs_pylibrary usingpypi:pipinstallgromacs_pyGromacs (version >= 5.1)AmbertoolsRdkitAcpypeand add the software path Gromacs in the environmnent variable$PATH,eg.for gromacs:# Add gromacs 'gmx' path:exportPATH='*path_to_gromacs*/bin/':$PATHAuthorsSamuel Murail, Associate Professor -Université Paris Diderot,CMPLI.See also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the GNU General Public License v2.0 - see theLICENSEfile for details.
Package: gromozeka
Gromozeka is distributed task queue, based on RabbitMQ.FeaturesBrokers:RabbitMQResult backends:Redissimple definition of a task as a normal function.ability to retry on error (max_retries and retry_countdown options).ability to bind task as self option to worker function.ability to make control on workers with internal APITODO’s[ ] Tests[x] Workflows (need’s result backend_adapter)InstallationAs usually use pip:pipinstallgromozekaDocumentationSee fulldocumentation
Package: gromp
🔎 Overviewgrompis a holistic wrapper of the publicRiot Games developer API,
written in Python.All public methods are, as of 2023-11-10, implemented.The core principle of the wrapper is to offer a complete, yet simple, interface which implements some of the core functionality that a developer might want to communicate with the Riot Games developer API.For a full list of all available requests, see each respective endpoint documentation.🔑 RequirementsTo perform requests you need an API key from Riot Games, get yourshere.📦 InstallationEither clone this repository and perform a local install withpoetryaccordinglygit clone https://github.com/wilhelmagren/gromp.git
cd gromp
poetry installor install the most recent release from the Python Package Index (PyPI).pip install gromp🚀 Example usageAny HTTP errors that are returned by the requested API are propagated and, as of writing this, not handled.importgrompfromgrompimport(LeaguePlatforms,LeagueRegions,)platform=LeaguePlatforms.euw1region=LeagueRegions.EUROPEtoken='<api-key>'# Here we setup a hook for League of Legends. We specify platform and region# to perform all REST requests to, the length of the RSA keys used to encrypt# our token, and the number of seconds to wait before a timeout.hook=gromp.hook.League(token,platform=platform,region=region,keylen=1024,timeout=10,)# One of the default handlers parses the HTTP response as a JSON# dictionary, see all available attributes for the object at the# Riot Games API documentation https://developer.riotgames.com/apissummoner=hook.summoner.by_name('1 900 976 JUICE')# We can also get the summoner if we know the encrypted# puuid, lets try and see if they are actually the same...summoner_from_puuid=hook.summoner.by_puuid(summoner['puuid'])assertsummoner==summoner_from_puuid# Great, we get the same summoner, me. Let's try and get# some of my played games from the match API endpoint.matches=hook.match.matchlist_by_puuid(summoner['puuid'],start=10,count=5,)assertlen(matches)==5# Now we can request the match data for all the match id's which we# got from the previous request. This is unfortunately the only# process of getting specific match data... it is rather tedious.formatch_idinmatches:m=hook.match.by_id(match_id)forparticipantinm['info']['participants']:ifparticipant['puuid']==summoner['puuid']:print(participant['win'])💡 Gromp factsHis real name is Lord Grompulus Kevin Ribbiton of Croaksworth, and he likes to eat small insects, mushrooms, and people (source).📋 LicenseAll code is to be held under a general MIT license, please seeLICENSEfor specific information.
Package: gron
python-gronMake JSON grep-able, a Python implementation ofgron.Installationgronis available onPyPi, to install it
use:$pipinstallgronDocumentationThe API documentation can be foundhere.UsageGiven a JSON file with the content:{"one":1,"two":2.2,"three-b":"3","four":[1,2,3,4],"five":{"alpha":["fo","fum"],"beta":{"hey":"How's tricks?"}},"abool":true,"abool2":false,"isnull":null,"id":66912849}you can usegronlike this:$grontests/data/one.jsonjson={};json.abool=true;json.abool2=false;json.five={};json.five.alpha=[];json.five.alpha[0]="fo";json.five.alpha[1]="fum";json.five.beta={};json.five.beta.hey="How's tricks?";json.four=[];json.four[0]=1;json.four[1]=2;json.four[2]=3;json.four[3]=4;json.id=66912849;json.isnull=null;json.one=1;json.two=2.2;json["three-b"]="3";``Without any argumentsgronwill read fromSTDIN:$cattests/data/one.json|gronjson={};json.abool=true;json.abool2=false;json.five={};json.five.alpha=[];json.five.alpha[0]="fo";json.five.alpha[1]="fum";json.five.beta={};json.five.beta.hey="How's tricks?";json.four=[];json.four[0]=1;json.four[1]=2;json.four[2]=3;json.four[3]=4;json.id=66912849;json.isnull=null;json.one=1;json.two=2.2;json["three-b"]="3";
Package: grond
Grondis an open source software tool for
robust characterization of earthquake sources. Moment tensors and finite fault
rupture models can be estimated from a combination of seismic waveforms,
waveform attributes and geodetic observations like InSAR and GNSS. It helps you
to investigate diverse magmatic, tectonic, and other geophysical processes at
all scales.It delivers meaningful model uncertainties through aBayesian bootstrap-based
probabilistic joint inversion scheme. The optimisation explores
the full model space and maps model parameter trade-offs with a flexible design
of objective functions.Rapid forward modelling is enabled by using pre-computedGreen’s function
databases, handled through thePyrockosoftware library. They serve synthetic near-field
surface displacements and synthetic seismic waveforms for arbitrary earthquake
source models and geometries.Installation with pipSee also:Grond Manual: InstallationGrond and all its dependencies can be installed by runningpipinstallgrond# read below...but, we recommend to make a conscious decision about how its main
dependencyPyrockoand especially Pyrocko’s own
dependencies are installed. ThePyrocko Installation Manualdescribes different installation
schemes.As a general advice, we recommend to exclusively use either, (1) the system’s
native package manager, (2) Anaconda, or (3) pip only. In (1) and (2), only
resort to use pip for those few packages which are not available as native
packages. Otherwise, competing package managers will ruin your day!To prevent pip from automatically resolving dependencies runpipinstall--no-depsgrondThis assumes thatPyrockoandKitehave been installed beforehand.DocumentationDocumentation and examples can be found in theGrond Manual.CommunityMeet people from all over the world doing awesome research with Grond in our
community chat: use theGrondchannel in the friendlyPyrocko Hive. This is the best place to talk about new features,
special techniques or to get help on setting up your first inversion with
Grond.DevelopmentGrond is open source.Join us at ourGit repositoryand
read theContribution guide.– The Grond Developers
Package: gronpy
GronpyA Python port ofgronto make JSON greppable.InstallationThe recommended way to install is to usepipx:pipx install gronpyUsage% gronpy --help

 Usage: gronpy [OPTIONS] [INPUT_PATH]

╭─ Arguments ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│   input_path      [INPUT_PATH]  Input file path or URL. If not specified uses stdin. [default: (stdin)]                                                           │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --gron                    --ungron                                       Transform JSON into GRON or back again [default: gron]                                   │
│ --color                   --no-color                                     Enable colouring in terminal. [default: color]                                           │
│ --version             -v                                                                                                                                          │
│ --install-completion                    [bash|zsh|fish|powershell|pwsh]  Install completion for the specified shell. [default: None]                              │
│ --show-completion                       [bash|zsh|fish|powershell|pwsh]  Show completion for the specified shell, to copy it or customize the installation.       │
│                                                                          [default: None]                                                                          │
│ --help                                                                   Show this message and exit.                                                              │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯Example% gronpy "https://api.tvmaze.com/schedule?country=GB" | grep "show.name" | grep -i "news"
json[34].show.name = "Newsround";
json[40].show.name = "Channel 4 News Summary";
json[43].show.name = "BBC News at One";
json[44].show.name = "ITV Lunchtime News";
json[45].show.name = "5 News Lunchtime";
json[53].show.name = "5 News";
json[56].show.name = "BBC News at Six";
json[58].show.name = "ITV Evening News";
json[59].show.name = "Channel 4 News";
json[76].show.name = "ITV News at Ten";
json[77].show.name = "Newsnight";
Package: groom
Groom, is an easy-to-use command-line application framework.This module defines an even much easier way to make user-friendly command-line interfaces than any others else.
Once you define a function as the entry point of your application, Groom will automatically detect how to parsesys.argvand apply it to your application.
Groom also generates help and usage messages and issue errors when users set invalid arguments to your application.introductionHave you never wanted to create CLI tools with python more easily?
Groom brings you an easier way to create CLI tools.Here is an example:importsysfromgroomimportpositional,optional,Dispatcher__version__='1.0'defcalculate(num1:positional(float,"former number",required=True,var_name='N1'),num2:positional(float,"latter number",required=True,var_name='N2'),operator:optional(str,"operator name",short_name='op')='add'):ifoperator=='add':print(num1+num2)returnifoperator=='sub':print(num1-num2)returnifoperator=='mul':print(num1*num2)returnifoperator=='div':print(num1/num2)returnprint("unknown operator:",operator,file=sys.stderr)if__name__=='__main__':Dispatcher(calculate,"calculate one of four arithmetic operations").dispatch()…and then, you can call the program like this:$pythoncalc.py12-opdivOnce you call this program with-hor--help, Groom displays the help messages:$pythoncalc.py-hcalc.py:1.0calculateoneoffourarithmeticoperationsUsage:calc.py[-v|--version|-h|--help]calc.py<N1><N2>[--operator<OPERATOR>|-op<OPERATOR>]positionalparameters:N1:formernumbertype:floatrequired:TrueN2:latternumbertype:floatrequired:Trueparameters:--operator,-op:operatornametype:strrequired:Falsemultiplevalues:Falsedefault:addGroom can handle 6 primitive types such as str, int, float, complex and bool and list of those types.
If you specify another as a parameter type, Groom will throw TypeError.Groom is licensed under the MIT License, for further details see LICENSE.txt.
Package: groo-ozika
This package simply finds the root of a project based on a filename.UsageCreate a hidden file in the root directory of your project.vim.my_hidden_root_fileTip:Use project-specific name not a generic.rootor even rely on.git. Get creative.Installgroopipinstallgroo-ozikaTip:usecondaand make sure to activate the right environment to install into.Import to your code and usefromgroo.grooimportget_rootroot_folder=get_root(".my_hidden_root_file")Tip:Always useos.path.join()to declare paths. It will make your code run across platforms and you won't get any strange erorrs (e.g., extra/).OptionalIf you want to provide a time limit to the search for the root you can do so by using thetimelimflag (in seconds).root_folder=get_root(".my_hidden_root_file",timelim=10)Example usageLet's say that wee want to keep all project-related files in a specific folder (which can be anywhere on your computer). Let's call thisproject_folder.Then, within it we want to have some datamydata.csvin adatafolder and some scripts in ascriptsfolderrunscript.py.To letgrooidentify the root folder we need to create a file there. I usually prefer to use a dot file because it will remain hidden, however, it can be anything. In this example we will create.my_hidden_root_filein theproject_folder.Once the hidden file is created, one might want to load it in their python script (or a jupyter ntbk). Here we want to loaddata/mydata.csvwithin thescripts/runscript.py.To do that, we can use this example:fromgroo.grooimportget_rootroot_folder=get_root(".my_hidden_root_file")importpandasaspddf=pd.read_csv(os.path.join(root_folder,"data","mydata.csv"))Note that the same code will work foranyscript that is anywhere whithin theproject_folder.Enjoy!Release NotesNew in version 0.0.7Previous versions ofgroocould only search for the root flag above in the directory hierarchy. Starting0.0.7, the flag can be in theory anywhere on the computer. The search algorithm starts from the location of the file and on each iteration moves a level up, performs full search.Since full search can sometimes be unpractical,groonow allows users to specify maximum time limit using thetimelimflagget_root(".my_hidden_root_file", timelim=10).Logo byAbtoCreative:heart:
Package: groove
GroovePython APIs for Groove, a proxy server built for web crawling and unit test mocking. Highlights of its primary features:HTTP and HTTPs support over HTTP/1 and HTTP/2.Local CA certificate generation and installation on Mac and Linux to support system curl and Chromium.Different tiers of caching support - from disabling completely to aggressively maintaining all body archives.Limit outbound requests of the same URL to 1 concurrent request to save on bandwidth if requests are already inflight.Record and replay requests made to outgoing servers. Recreate testing flows in unit tests while separating them from crawling business logic.3rd party proxy support for commercial proxies.Custom TLS Hello Client support to maintain a Chromium-like TLS handshake while intercepting requests and re-forwarding on packets.For more information, see theGithubproject.UsageAdd groove to your project and install the local certificates that allow for https certificate generation:pip install groove
install-caInstantiating Groove with the default parameters is usually fine for most deployments. To ensure we clean up resources once you're completed with the proxy, wrap your code in thelaunchcontextmanager.fromgroove.proxyimportGroovefromrequestsimportgetfrompathlibimportPathproxy=Groove()withproxy.launch():response=get("https://www.example.com",proxies={"http":proxy.base_url_proxy,"https":proxy.base_url_proxy,},verify=str(Path("~/.grooveproxy/ca.crt").expanduser()),)assertresponse.status_code==200Create a fully fake outbound for testing:fromgroove.proxyimportGroovefromgroove.tapeimportTapeRecord,TapeRequest,TapeResponse,TapeSessionfromrequestsimportgetfrompathlibimportPathrecords=[TapeRecord(request=TapeRequest(url="https://example.com:443/",method="GET",headers={},body=b"",),response=TapeResponse(status=200,headers={},body=b64encode("Test response".encode())),)]proxy=Groove()withproxy.launch():proxy.tape_load(TapeSession(records=records))response=get("https://www.example.com",proxies={"http":proxy.base_url_proxy,"https":proxy.base_url_proxy,},verify=str(Path("~/.grooveproxy/ca.crt").expanduser()))assertresponse.content==b"Test response"
Package: groovegenerator
Groove GeneratorA collection of functions for groove researchThis package contains utility functions for generating rhythm patterns, and calculating related measures.Installationpipinstallgroovegeneratoror upgradepipinstallgroovegenerator--upgradeExamplesExample scripts can be found in theGroove Generator examples directory.GUIAn optional GUI is available in theGUI directory.To use it:pythongroovegenerator_gui.pyNote that the GUI requires PyQt5 and qtmodern.
Package: groovy-parser
python-groovy-parserPython package which implements a Groovy 3.0.X parser, using both Pygments, Lark and the corresponding grammar.The tokenizer, lexer and grammar have being tested, stressed and fine tuned
to be able to properly parse both Nextflow (i.e.*.nf),nextflow.config-like files
and real Groovy code from:https://github.com/nf-core/modules.githttps://github.com/nf-core/rnaseq.githttps://github.com/nf-core/viralintegration.githttps://github.com/nf-core/viralrecon.githttps://github.com/wombat-p/WOMBAT-Pipelines.githttps://github.com/nextflow-io/nextflow.gitInstallYou can install the development version of this package through pip just running:pipinstallgit+https://github.com/inab/python-groovy-parser.gitTest programsThis repo contains a couple of test programs calledtranslated-groovy3-parser.pyandcached-translated-groovy3-parser.py,
which demonstrate how to use the parser and digest it a bit.The programs take one or more files as input.gitpullhttps://github.com/nf-core/rnaseq.git
translated-groovy3-parser.py$(findrnaseq-typef-name"*.nf")If an input file is for instancernaseq/modules/local/bedtools_genomecov.nf,
the program generates a log filernaseq/modules/local/bedtools_genomecov.nf.lark,
where the parsing traces are stored (emitted tokens, parsing errors, etc...).Also, when the parsing task worked properly, it condenses and serializes
the parse tree into a file with extension.lark.json(for instance,rnaseq/modules/local/bedtools_genomecov.nf.lark.json).And as a proof of concept, it tries to identify features from Nextflow files,
like the declared processes, includes and workflows, and they are roughly printed
at a file with extension.lark.result(for instancernaseq/modules/local/bedtools_genomecov.nf.lark.result).As parsing task is heavy, the parsing module also contains a method to
be able to cache the parsed tree in JSON format in a persistent store,
like a filesystem. So, next operation would be expensive the first time,
but not the next ones:GROOVY_CACHEDIR=/tmp/somecachedircached-translated-groovy3-parser.py$(findrnaseq-typef-name"*.nf")The caching directory contents depend on the grammar and the implementations, as well as versions of the dependencies.
So, if this software is updated (due grammar is updated or a bug is fixed),
cached contents from previous versions are not reused.AcknowledgementsThe tokenizer is an evolution from Pygments Groovy lexerhttps://github.com/pygments/pygments/blob/b7c8f35440f591c6687cb912aa223f5cf37b6704/pygments/lexers/jvm.py#L543-L618The Lark grammar has been created fromhttps://github.com/apache/groovy/blob/3b6909a3dbb574e66f5d0fb6aafb6e28316033a8/src/antlr/GroovyParser.g4,
converting it to EBNF usinghttps://bottlecaps.de/convert/,
translating the EBNF representation to Lark format partially by hand.Some fixes were inspired onhttps://github.com/daniellansun/groovy-antlr4-grammar-optimized/tree/master/src/main/antlr4/org/codehaus/groovy/parser/antlr4
Package: grop
gropRefresh yourself on what those elusive options do, hassle free!ExampleView the descriptions of -xcf and –format in the given order:python3 optx.py tar -xcfNotesFor the sake of my sanity, I will refer to the optional arguments for this
program as flags, and the positional arguments as options.ContributingThis project is still in the beginning stages. Contributions are very welcome.LicenseThis software is licensed under GPLv3. See theLICENSEfile for more information.
Package: gropen
gropengropen(Git Remote Open) is a simple command line application for opening
local files and directories on remote git repositories.Supported reposBitbucketGitHubGitLabSupported editorsSublimeVim (gropen.vim)VS Code (gropen.vscode)Supported systemsLinuxmacOSWindowsInstallationpip install gropenNOTE:gropenrequires Python 3.6 or greater installed on your local environment.UsageHere are some example of whatgropencan open on your project's remote repo.Open current directory:gropen .Open another directory:gropen gropen/Open a file:gropen gropen/gropen.pyOpen a file pointing out the lines of code to be highlighted:gropen gropen/gropen.py:42
gropen gropen/gropen.py:16,32Open file from an outter directory:cd ~/Dev
gropen python/gropen/gropen/gropen.py:20,30Open file from an inner directory:cd ~/Dev/python/gropen/gropen
gropen gropen.py:20,30TODOAdd support for GitHub repositories;Add support for Bitbucket repositories;Add support for GitLab repositories;Open current directory;Open arbitrary directory and files;Open in a line or range of lines in the file;Open files in a specific commit;Handle relative and absolute paths;Support flag for only displaying the URL instead of opening it on the browser;Create Vim plugin;Create VS Code plugin;Create Sublime plugin.ContributingBug reports and pull requests are welcome on GitHub athttps://github.com/tiagopog/gropen/.
This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to theContributor Covenantcode of conduct.LicenseThis package is available as open source under the terms of theMIT License.
Package: groqflow
GroqFlow 🚀GroqFlow™ is the easiest way to get started with Groq's technology. GroqFlow provides an automated tool flow for compiling machine learning and linear algebra workloads into Groq programs and executing those programs on GroqChip™ processors.We recommend that your system meets the following hardware requirements:To build models: 32GB or more of RAM.To run models: 8 GroqChip processors is recommended, especially for larger models.Installation GuideSign-up onsupport.groq.comto download and install GroqWare™ Suite version >=0.9.2.1.For installation instructions, please have a look at ourInstall Guide.Getting StartedTo Groq a PyTorch model, simply provide your model and inputs to thegroqit()function. Oncegroqit()has built your model, you can execute your Groq model the same way you execute a PyTorch model.groqit()also works with ONNX files and provides many customization options. You can find more information about how to use groqit() in ourUser Guide.Navigating GroqFlowdemo_helpers: Scripts used for GroqFlow demos and proof points.docs: All information you'd need to be successful with GroqFlow.examples: Includes various GroqFlow examples.groqflow: The source code for thegroqflowpackage.proof_points: Machine learning proof points using GroqFlow.readme.md: This readme.setup.py: GroqFlow setup script for installation.ContributorsGroqFlow development is primarily conducted within Groq's internal repo and is periodically synced to GitHub. This approach means that developer contributions are not immediately obvious in the commit log.This project follows theall-contributorsspecification.
Contributions of any kind are welcome!