Saravanan666/pypi-org huggingface dataset:
Package: gw-frequencies
gw_frequenciesA convenience package to make reduced frequency arrays for the representation of gravitational waveforms.It makes available the following functions; here they are documented
very shortly, see their docstrings (help(func_name)in an interactive console)
for more details.seglen_from_freq, which computes the duration T(f), in seconds,
of a gravitational wave signal starting at a given frequency, in Hertz.high_frequency_grid, a uniform grid in frequencylow_frequency_grid, a non-uniform grid in frequency satisfying dN/df = 1/T(f) at each frequencymixed_frequency_grid, a grid with the low-frequency specification below some pivot
and the high-frequency specification above it.The main idea here is thelow_frequency_grid, which is a slightly different implementation of the
concepts outlined byVinciguerra et al, 2017.To install this package, do:pipinstallgw-frequenciesTo import the required functions, dofromgw_frequencies.multibandingimport<func_name>where<func name>is the name of the function you want.
Package: gwf-wrangler
Wrangler (0.0.7)LoggingUse the Correct Levels When LoggingIt might be difficult to decide which level to assign each event. Fortunately, the Python logging module presents fewer levels than other logging libraries. This makes things easier by eliminating some potential ambiguity. When it comes to Python levels, here are the general guidelines:DEBUG: You should use this level for debugging purposes in development.INFO: You should use this level when something interesting—but expected—happens (e.g., a user starts a new project in a project management application).WARNING: You should use this level when something unexpected or unusual happens. It’s not an error, but you should pay attention to it.ERROR: This level is for things that go wrong but are usually recoverable (e.g., internal exceptions you can handle or APIs returning error results).CRITICAL: You should use this level in a doomsday scenario. The application is unusable. At this level, someone should be woken up at 2 a.m.Include a Timestamp for Each Log EntryKnowing something happened without knowing when it happened is only marginally better than not knowing about the event at all. Make sure to add a timestamp to your log entries to make the lives of the people who use logs for troubleshooting easier. Doing so also allows developers to analyze the log entries to obtain insights/analytics about user behavior.Adopt the ISO-8601 Format for TimestampsTimestamps are essential in log entries. Unfortunately, people can’t agree on the best way to express instants in time, so we came up with several conflicting formats.Using the format widely used in your country might look like it’s the right choice, especially if you don’t plan to offer your application overseas.But this couldn’t be further from the truth. By simply adopting a standard format for your timestamps, you can prevent problems, as third-party libraries and tools will expect the standard format in the first place.This standard format exists, and it’s called ISO-8601. It’s an international standard for the exchange of date- and time-related data. Here’s an example of a timestamp expressed in ISO-8601 format:2020-03-14T15:00-03:00This is a basic example of how to configure the formatting to allow ISO-8601 timestamps:import logging
logging.basicConfig(format='%(asctime)s %(message)s')
logging.info('Example of logging with ISO-8601 timestamp')Use the RotatingFileHandler ClassA general logging best practice—in any language—is to use log rotation. This is a mechanism designed to automatically archive, compress, or delete old log files to prevent full disks.Fortunately, you don’t have to implement this by hand in Python. Instead, use the RotatingFileHandler class instead of the regular FileHandler one.SourceBuildsapt install python3.10-venvpython -m build
Package: gwgen
testspackageWelcome! This synthesis of FORTRAN and Python is a globally applicable
weather generator inspired by the original WGEN weather generator of[Richardson1981]and parameterized through a global dataset of[GHCN]and[EECRA]data. A paper with the scientific documentation is in progress, thetechnical documentationwith more information is hosted on github.io.AuthorsThis package has been developped byPhilipp S. SommerandJed O. Kaplan.Citing GWGENWhen using GWGEN, we kindly ask you to provide a reference to the corresponding
paper published in Geoscientific Model Development:Sommer, P. S. and Kaplan, J. O.:A globally calibrated scheme for
generating daily meteorology from monthly statistics: Global-WGEN (GWGEN)
v1.0, Geosci. Model Dev., 10, 3771-3791, DOI:10.5194/gmd-10-3771-2017,
2017.AcknowledgementsThis work was supported by the European Research Council (COEVOLVE, 313797) and
the Swiss National Science Foundation (ACACIA, CR10I2_146314). We thankShawn Koppenhoeferfor assistance compiling and querying the weather databases and
Alexis Berne and Grégoire Mariéthoz for helpful suggestions on the analyses. We
are grateful to NOAA NCDC and the University of Washingtion for providing free
of charge the GHCN-Daily and EECRA databases, respectively.References[Richardson1981]Richardson, C. W.:Stochastic simulation of daily
precipitation, temperature, and solar radiation, Water Resources Research,
17, 182–190, doi:10.1029/WR017i001p00182, 1981.[GHCN]T. G.: Global Historical Climatology Network - Daily (GHCN-Daily),
Version 3.22, doi:10.7289/V5D21VHZ, doi:10.7289/V5D21VHZ, 2012[EECRA]Hahn, C. and Warren, S.:Extended Edited Synoptic Cloud Reports from
Ships and Land Stations Over the Globe, 1952-1996 (with Ship data
updated through 2008), doi:10.3334/CDIAC/cli.ndp026c, 1999
Package: gwh
Flask webhook for GitLabA very simple post-receive web hook handler for GitLab based on a project for Github:razius/github-webhook-handlerIt will optionally verify that the POST request originated from a particular IP address.Getting startedInstallationpipinstallgwhRepository ConfigurationCreate a JSON config file (e.g.,repos.json) to configure repositories. Each repository must be keyed by its GitLab homepage.{"https://gitlab.com/pal/spm-batching":{"private_token":"xxxxxxxxxxxxx","webhook_token":"xxxxxxxxxxxxx","push":{"master":{"path":"/home/spm-batching/deploy","actions":["git checkout master","git pull"]},"other":{"actions":["echo A non-master branch was pushed."]}}},"issue":{"user_notify":["\\*\\*Sender\\*\\*\\: ([a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+)","@gitlabuser"],"labels":[]}}}This example handles several types of webhooks.push: After a push event to the repomasterbranch, it executes a couple of command in the local shell to pull in the master HEAD. The special branch keyotherwill run if the pushed branch is not otherwise matched to a key in thepushhash.issue.user_notify: After a new issue event, the handler runs a regex match on the issue body and adds an issue comment to @mention the user by email.issue.labels: Parse the commit message to handle adding or removing labels based on commit messages. For instance, "address #53, #72: carousel accessibility fixes; -browser compat, +accessibility, ~Pending" will add an "accessibility" label (if it already exists for the project) to issues 53 and 72, remove label "browser compat", and add label "Pending" (presumably a list label) while removing other list labels (effectively moving an issue on the GitLab boards kanban).The issue hook uses aGitLab personal access token(private_token) to run API commands to lookup a username by email and add an issue comment. The push hook does not require the private token because it does not use the GitLab API.webhook_tokenallows authorization by matching against asecret token included in the payload headers.Runpython -m gwh --helpExample usage:Assume a self-hosted GitLab server on 192.168.1.44 and a production webserver on 192.168.1.99.  The idea is that a push to the master branch for your project should trigger the production machine to pull in a new copy of the repo.On your webhost (192.168.1.99), bring up the webhook handler:python -m gwh -p 8080 --allow 192.168.1.44 repos.json &Then in your GitLab server (on 192.168.1.44) project settings, create a new webhook with URLhttp://192.168.1.99:8080that's triggered on push events.Testcurl -i -X POST -H "Content-Type: application/json" --data "@test.json" http://localhost:8080
Package: gwlandscape-python
GWLandscapeis a service used to handle both the creation of publication datasets and the submission of COMPAS jobs (todo).Check out thedocumentationfor more information.InstallationThe gwlandscape-python package can be installed withpip install gwlandscape-pythonExample>>> from gwlandscape_python import GWLandscape
>>> gwl = GWLandscape(token='<user_api_token_here>')
Package: gwmemory
GWMemoryGWMemorycalculates the nonlinear (Christodoulou) gravitational-wave memory waveform from arbitrary time-domain gravitational-waveforms.InstallationGWMemoryis available viaconda-forgeandpypi$condainstall-cconda-forgegwmemory$python-mpipinstallgwmemoryYou can also install from this repository in the usual way:$gitclonehttps://github.com/ColmTalbot/gwmemory.git$cdgwmemory$python-mpipinstall.Note that it is no longer to install using$pythonsetup.pyinstallThepipversion is more stable.TODO: make pip/conda installableExamplesDemonstrations of how to calculate memory waveforms can be found in the examples directory.Supported waveformsNRSur7dq2(Blackmanet al.(2017),Phys. Rev. D 96, 024058)Aligned spin waveforms inlalsimulation, e.g.,IMRPhenomD( Khanet al.(2016),Phys. Rev. D 93, 044007,SEOBNRv4(Boheet al.(2017),Phys. Rev. D 95, 044028).Minimal waveform model (Favata (2010),CQG, 27, 8)Any surrogate model available ingwsurrogateTo use these waveform models, you may need to install extra packages, this should be described if the packages aren't available.Additionally users can supply any waveform decomposed onto the basis of spin-2 weighted spherical harmonics.There is basic support for loading numerical relativity waveforms, based on the format of the simulating extreme spacetimeswaveform catalog.
Package: gwnrtools
# gwnrtoolsA collection of tools for academic research in gravitational-wave astronomy & astrophysics## Tutorials[Making useful corner plots to visualize Bayesian posteriors](tutorials/MakingUsefulCornerPlots.html)[Faithfulness between GW template models](tutorials/ComputeFaithfulness.html)[Effectualness of GW search template banks](tutorials/ComputeEffectualness.html)[Inference on GW events](tutorials/BayesianInferenceOnGWEvents.html)[Inference on Injections](tutorials/BayesianInferenceOnGWInjections.html)… more [here](https://github.com/prayush/gwnrtools/tree/master/tutorials)
Package: gwopensci
Thegwopenscipackage provides an interface to querying the
open data releases hosted onhttps://losc.ligo.orgfrom the LIGO and
Virgo gravitational-wave observatories.To install:pip install gwopensciSearching for datasetsTo search for available datasets (correct as of March 14 2018):>>>fromgwopensciimportdatasets>>>datasets.find_datasets()['GW150914','GW151226','GW170104','GW170608','GW170814','GW170817','LVT151012','O1','S5','S6']>>>datasets.find_datasets(detector='V1')['GW170814','GW170817']>>>datasets.find_datasets(type='run')['O1','S5','S6']To query for the GPS time of an event dataset (or vice-versa):>>>datasets.event_gps('GW170817')1187008882.43>>>datasets.event_at_gps(1187008882)'GW170817'Similar queries are available for observing run datasets:>>>datasets.run_segment('O1')(1126051217,1137254417)>>>datasets.run_at_gps(1135136350)# event_gps('GW151226')'O1'Locating data URLs by event nameYou can search for remote data URLS based on the event name:>>>fromgwopensci.locateimportget_event_urls>>>get_event_urls('GW150914')['https://losc.ligo.org//s/events/GW150914/H-H1_LOSC_4_V2-1126259446-32.hdf5','https://losc.ligo.org//s/events/GW150914/L-L1_LOSC_4_V2-1126259446-32.hdf5','https://losc.ligo.org//s/events/GW150914/H-H1_LOSC_4_V2-1126257414-4096.hdf5','https://losc.ligo.org//s/events/GW150914/L-L1_LOSC_4_V2-1126257414-4096.hdf5']You can down-select the URLs using keyword arguments:>>>get_event_urls('GW150914',detector='L1',duration=32)['https://losc.ligo.org//s/events/GW150914/L-L1_LOSC_4_V2-1126259446-32.hdf5']Locating data URLs by GPS intervalYou can search for remote data URLs based on the GPS time interval as
follows:>>>fromgwopensci.locateimportget_urls>>>get_urls('L1',968650000,968660000)['https://losc.ligo.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968646656-4096.hdf5','https://losc.ligo.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968650752-4096.hdf5','https://losc.ligo.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968654848-4096.hdf5','https://losc.ligo.org/archive/data/S6/967835648/L-L1_LOSC_4_V1-968658944-4096.hdf5']This arguments for this function are as followsdetector: the prefix of the relevant gravitational-wave
interferometer, either'H1'for LIGO-Hanford, or'L1'for
LIGO Livingston,start: the GPS start time of the interval of interestend: the GPS end time of the interval of interestBy default, this method will return the paths to HDF5 files for the 4
kHz sample-rate data, these can be specified as keyword arguments. For
full information, run>>>help(get_urls)Query for Timeline segmentsYou can also search for Timeline segments, based on a flag name, and a
GPS time interval as follows:>>>fromgwopensci.timelineimportget_segments>>>get_segments('H1_DATA',1126051217,1126151217)[(1126073529,1126114861),(1126121462,1126123267),(1126123553,1126126832),(1126139205,1126139266),(1126149058,1126151217)]The output is alistof(start, end)2-tuples which each
represent a semi-open time interval.For documentation on what flags are available, for example for the O1
science run, seethe O1 data release
page(Data Quality).
Package: gwot
gWOT: Global Waddington-OTPrincipled trajectory inference for time-series data with limited samples by optimal transport.Important: this README is currently under construction. Check back soon!IntroductionGlobal Waddington-OT (gWOT) is a trajectory inference method for time-series data based on optimal transport (OT).
Given a time-series of snapshot data, gWOT aims to estimate trajectory information in the form of aprobability distributionover possible trajectories taken by cells.As an example, we illustrate below a ground truth process where cell trajectories are known exactly (green). From this, independent snapshots are sampled at various temporal instants, each with limited sample resolution (red). From these data, gWOT aims to reconstruct trajectories as a law on paths (blue).The underlying model assumption on which gWOT is based is that the generative process is a drift-diffusion process with branching, in which the evolution of any cell over an infinitesimal time is described by the stochastic differential equation (SDE).Cells in this process also divide and die at ratesbeta(x, t)anddelta(x, t)respectively.InstallationTo install, usepip install gwot.Alternatively, clone this repository andcd gWOT && pip install .Example application: bistable landscape with branchingPaperThis code accompanies the paper(arXiv link)Lavenant, H., Zhang, S., Kim, Y., & Schiebinger, G. (2021). Towards a mathematical theory of trajectory inference.
Package: gwp
Gabor Wavelet PyramidGabor Wavelet Pyramid model for tensorflow. Tools for constructing sensible sets of
gabor filters, convolving the filters with images using tensorflow, and calculating the
typical rectified ‘energy’ output by summing over squared phase values (Adelson &
Bergen, 1985).Free software: MIT licenseDocumentation: Sadly neglected, but you can find some tutorial notebookshere.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-07-25)First release on PyPI.
Package: gwpopulation
GWPopulationA collection of parametric binary black hole mass/spin population models.These are formatted to be consistent with theBilbyhyper-parameter inference package.For an example using this code to analyse the first gravitational-wave transient catalog (GWTC-1) seehere.Automatically generated docs can be foundhere.If you're using this for production analyses, you may be interested in the associated pipeline codegwpopulation_pipe.AttributionPlease citeTalbotet al(2019)if you find this package useful.@ARTICLE{2019PhRvD.100d3030T,
       author = {{Talbot}, Colm and {Smith}, Rory and {Thrane}, Eric and
         {Poole}, Gregory B.},
        title = "{Parallelized inference for gravitational-wave astronomy}",
      journal = {\prd},
         year = 2019,
        month = aug,
       volume = {100},
       number = {4},
          eid = {043030},
        pages = {043030},
          doi = {10.1103/PhysRevD.100.043030},
archivePrefix = {arXiv},
       eprint = {1904.02863},
 primaryClass = {astro-ph.IM},
}Additionally, please consider citing the original references for the implemented models which should be include in docstrings.Most of the models implemented are derived from models presented in one of:Talbot & Thrane (2017)Talbot & Thrane (2018)Wysocki et al. (2018)Fishbach et al. (2019)
Package: gwp-uncertainties
Welcome to gwp_uncertainties!This package allows computation of uncertainties in GWP and AGWP values for environmental flows with known radiative efficiencies, lifetimes and their respective perturbations.Table values for all flows are stored in the data/ipcc2013.json file and have been taken from the following resourcesMolecular weights fromhttps://pubchem.ncbi.nlm.nih.gov/Radiative efficiencies and lifetimesfor most flows can be found in the IPCC Climate Change report from 2013, Chapter 8 and Table 8.A.1data/ipcc2013.json contains "_comment" field with the exact source table and matching name of a given flow in the IPCC reportHere we only consider flows that are present in the Life Cycle Assessment method ("IPCC 2013", "climate change") with time horizons of 20 and 100 years.For the uncertainty calculations we employ a method based on first-order Taylor expansion as suggested in the Supplementary Material of the IPCC Climate Change report from 2013 (see Chapter 8.SM). Given a function $$y = f(x_1,...,x_k),$$ the uncertainty infcan be computed as follows:$$\Delta f = \sqrt{\sum_i (\Delta f_i)^2} = \sqrt{\sum_i \big( \frac{\partial f}{\partial x_i} \Delta x_i  \big)^2}, $$where in our case,fis a function that computes GWP values, and inputsxdepend on the flow:x = (lifetime, radiative efficiency)for all flows except for methane and nitrous oxidex = (lifetime, radiative efficiency, f1, f2)for methane and nitrous oxide (see 8.SM.11.3.2 and 8.SM.11.3.3 of the IPCC supplementary materials), wheref1is added due to effects on ozone andf2is due to stratospheric H2O.Uncertainties in the inputsxare given in Table 8.SM.12 and Section 8.3.1. Uncertaintycorresponds to a 90% confidence interval, and is converted to standard deviation of normal distribution by scaling it down by 1.645.A special case is carbon monoxide, where we assume uniform distribution (see Table 8.A.4).Note thatUncertainties in NOx and VOC have not been taken into account in the current implementation. GWP values are given in Tables 8.A.3 and 8.A.5 respectively.Results
Package: gwpy
GWpy is a collaboration-driven Python package providing tools for
studying data from ground-based gravitational-wave detectors.GWpy provides a user-friendly, intuitive interface to the common
time-domain and frequency-domain data produced by the LIGO and Virgo
observatories and their analyses, with easy-to-follow tutorials at each
step.https://gwpy.github.ioRelease statusDevelopment statusInstallationTo install, you can do:conda install -c conda-forge gwpyorpython -m pip install gwpyYou can test your installation, and its version bypython -c "import gwpy; print(gwpy.__version__)"LicenseGWpy is released under the GNU General Public License v3.0 or later, seeherefor a description of this license, or see theLICENSEfile for the full text.
Package: gw-remnant
gw_remnantDuring binary-black-hole (BBH) mergers, energy and momenta are carried away from the binary system as gravitational radiation. Access to the radiated energy and momenta allows us to accurately predict the properties of the remnant black hole.gw_remnantis an easy-to-use python package to efficiently extract the remnant mass, remnant spin, peak luminosity and the final kick imparted on the remnant black hole directly from the gravitational radiation.Github repo for this project is :https://github.com/tousifislam/gw_remnantCurrently it has the ability to generate waveforms fromNRHybSur3dq8andBHPTNRSur1dq1e4. However, it can take waveforms generated by other methods by the user too.TutorialsExample notebook is provided inhttps://github.com/tousifislam/gw_remnant/tutorialsdirectory.You can find examples with deafult waveforms (BHPTNRSur1dq1e4 and NRHybSur3dq8) here :https://github.com/tousifislam/gw_remnant/blob/main/tutorials/example_with_default_waveforms.ipynbIf you do not already have gwsurrogate and BHPTNRSurrogate(s) installed, you can use the example with customed waveforms for nowExamples with custom waveforms are given here :https://github.com/tousifislam/gw_remnant/blob/main/tutorials/example_with_customized_waveform.ipynbBHPTNRremnantgw_remnantpackage has been used in developing NR-tuned perturbation based remnant model that can provide faithful estimates of the remnant properties for binaries with mass ratios ranging fromq=3toq=1000.Citation guidelineIf you make use of any module from the Toolkit in your research please acknowledge using:This work makes use of the Black Hole Perturbation Toolkit.If you make use of thegw_remnnatpackage orBHPTNRremnantsurrogate models please cite the following paper:@article{Islam:2022laz,
    author = "Islam, Tousif and Field, Scott E. and Khanna, Gaurav.",
    title = "{Remnant black hole properties from numerical-relativity-informed perturbation theory and implications for waveform modelling}",
    eprint = "https://arxiv.org/abs/2301.07215",
    archivePrefix = "arXiv",
    primaryClass = "gr-qc",
    month = "1",
    year = "2023"
}
Package: gwr-inversion
Gaver-Wynn-Rho AlgorithmThis is a Python reproduction of the Mathematica package that provides the GWR
function,NumericalLaplaceInversion.m.https://library.wolfram.com/infocenter/MathSource/4738/This package provides only one function:gwr. The function calculates the
value of the inverse of a Laplace transform at a specified time value,Sequenceof time values, or numpy array of time values.The Laplace transform should be provided as a function that uses thempmathlibrary for a scalar value of the Laplace parameter.  Themathlibrary andnumpyfunctions do not support multiprecision math and will return invalid
results if they are used.Simple Example>>>importmath>>>fromgwr_inversionimportgwr>>>frommpmathimportmp>>>deflap_ln_fn(s:float):...# log function...return-mp.log(s)/s-0.577216/s>>>gwr(lap_log_fn,time=5.0,M=32)mpf('1.6094375773356333')>>>math.log(5.0)1.6094379124341003See the notebooks intest\for other use examples.The method is described in: ValkÃ³, P.P., and Abate J. 2002. Comparison of
Sequence Accelerators for the Gaver Method of Numerical Laplace Transform
Inversion.Computers and Mathematics with Application48(3): 629â€“636.https://doi.org/10.1016/j.camwa.2002.10.017.More information on multi-precision inversion can be found in: ValkÃ³, P.P.and
Vajda, S. 2002. Inversion of Noise-Free Laplace Transforms: Towards a
Standardized Set of Test Problems.Inverse Problems in Engineering10(5):
467-483.https://doi.org/10.1080/10682760290004294.
Package: gwsa
gwsa - git work space automationRuns common git commands on every git repo in a workspaceUsagestatusThis command showsstatus of repo: dirty or clean,if rebase, merge or cherry-pick is in progresscommit difference with remote: ahead + behind commitsstatus of remote: gone or okif forced push happendfetchrebaseRebase local tracking branches. In case of a conflict, it aborts rebase.InstallationpipinstallgwsaDevelopment[[-dvenv]]||virtualenvvenv;.venv/bin/activate
makeclean
makebuild
maketestmakeinstall
deactivateCreditsThis project was inspired bygwsby Fabien Dubosson.The reason for writing my own is a language. I prefer python over bash: better syntax, a lot of libraries, and easy install withpip