Saravanan666/pypi-org huggingface dataset:
Package: gae-impersonate-credentials
gae-impersonate-credentialsGet an GCP Credentials instanceApp runs in GCP, return None for use Application Default Credentials(ADC).
When runs in local, impersonate requested service account by ADC.
(In local environment, ADC is developer's own google account that signed in withgcloud auth application-default loginin normal usage.)If use this function on Cloud Functions Python 3.9 Runtime, this function cannot detect actual run environment, because not supplied toGOOGLE_CLOUD_PROJECTorGCP_PROJECTenvironment variables.
You need to supply these value in deploy Cloud Functions deployment parameter or setis_run_on_gcpparameter in this function.Example usagefrom gae_credentials import get_credentials
from google.cloud import ndb


credentials = get_credentials(
    service_account='example@appspot.gserviceaccount.com',
    scopes=[
      'https://www.googleapis.com/auth/datastore'
    ]
)

client = ndb.Client(credentials=credentials)
Package: gaeio
GAEIOGAEIOis a Python GUI for geoscientific data analysis (i.e., seismic).DependencyGAEIOuses a number of open source projects to work properly:PyQt5- GUIsVispy- VisualizationsInstallationpip install --upgrade gaeioRunimport gaeio as gogo.start()DevelopersGAEIOis developed byCognitive Geo.SupportContact usif you have any problem with usingGAEIOand/or want to be a developer.LicenseGNU Affero General Public License v3 or later (AGPLv3+)
Package: gaenv
InstallSimply run the following:$ python setup.py installorPyPi:$ pip install gaenvExample UsageNote that this not run “pip install -r requirements.txt” so you’ll have to run it manually first before running this:Create a requirements.txt and put all requirements then run
$ gaenv
For more
$ gaenv -h
or with python extracted source
$ python gaenv-0.x.x/gaenv -hThis will create symbolic links from your default python version packages to
the current directory that you execute it on. By default it will create
gaenv_lib folder with all packages in your requirements.txt and will
ask you if you want this utility to insert the import statement that updates
your sys.path, or you can just do it manually.Change log0.1.10 (2016-01-04)Improved package lookup (fixed ubuntu/linux)0.1.9 (2015-07-27)Added -c copy option instead of symlink (thanks hnovikov)0.1.8 (2014-10-12)Allows for recursive requirements files via the -r flagCorrectly ignores other pip flags within requiremenst files0.1.7bug fix on git repo on requirements.txtsymlink fix for windowsadded –no-import to skip auto import statement0.1.6 (2013-09-03)switched to appengine_config.py sys.path0.1.5 (2013-06-25)improved lookup using setuptools0.1.4 (2013-06-15)added run from source0.1 (2013-06-13)Linksgithub.com- source codealtlimit.com- website
Package: gaeo
ContentsAboutLicenseEasy Install  & UsageMore InformationAboutGAEO (Goole App Engine Oil) is a simple framework that normalize the code layout and coding style for Google App Engine.LicenseGAEO is released under Apache License 2.0.http://www.apache.org/licenses/LICENSE-2.0Easy Install  & Usageinstall gaeo with easy_install command (if you already installed setuptools):$ easy_install gaeoCreate new project by using “gaeo hello” to create a “hello/” directory and a project with the same name as you applied in Google App Engine:gaeo helloFor more tutorial, please visit:http://doc.gaeo.org/More InformationProject homehttp://code.google.com/p/google-app-engine-oil/Discussion Grouphttp://groups.google.com/group/google-app-engine-oilDocumentationshttp://doc.gaeo.org/Bloghttp://blog.gaeo.org/
Package: gaepytz
pytz has a severe performance problem that impedes its usage on Google App
Engine. This is caused because pytz.__init__ builds a list of available
zoneinfos checking the entire zoneinfo database (which means: it tries to open
hundreds of files). This is done in the module globals, so it is not easily
avoidable. And it is far from ideal to do this in App Engine - app
initialization becomes unacceptable if every time we import pytz it checks
500+ files.In this alternative version, pytz is highly optimized for App Engine, following
ideas from several recipes around:database files are not automatically reads when the module is importedthe database files are loaded using zipimport to reduce number of filesit uses memcache to cache already loaded zoneinfosThis results in almost unnoticeable load time and makes pytz usable on App
Engine.
Package: gae-pytz
A fork of pytz which works on [Google App Engine][1].Based on [http://appengine-cookbook.appspot.com/recipe/caching-pytz-helper/][2] but modified so that it can be imported normally withimport pytz.[1]:https://developers.google.com/appengine/[2]:http://appengine-cookbook.appspot.com/recipe/caching-pytz-helper/
Package: gaerpytz
gaerpytz is like gaepytz (a version of pytz that works well on Google App
Engine) but automated so zoneinfo is up-to-date.The problempytz has more than 500 zoneinfo files. This many files is a problem when using
pytz on Google App Engine because “an application is limited to 10,000 uploaded
files per version” according to the documentation.The workaround is to package all zoneinfo files in a zip archive. gae-pytz is
the most well-known example of this approach but it has not been updated in a
long time.The solutiongaerpytz uses the same idea and makes 2 changes to pytz:Package all zoneinfo files in zoneinfo.zipModify __init__.py to read from zoneinfo.zipJust download the modified code and put it in yourpytzdirectory.You
don’t need to change the code that uses pytz.(The package name gaerpytz is
superficial and the package structure has not been changed.)Import the package withimport pytzUse it like you would pytzIn practice, gaerpytz runs slightly slower due to the zip file.So what? You can do this yourself, right?Time zones are magic (change frequently based on local laws), so pytz is
updated often. Applying these modifications to every new pytz release is
tedious. This is why you see many out-of-date or abandoned packages that patch
pytz on PyPI.gaerpytz takes people out of the process.gaerpytz watches pytz. When a new
version of pytz is released, gaerpytz automatically fetches a copy and builds
itself.This is what makes gaerpytz Google App Engine-rthan the pytz
patches that came before.You can view the code directly athttps://gaerpytz.appspot.com/.Even if you don’t use the code, please help me by contributing location data
to the time zone database. Thank you!
Package: gaes3
To accessAmazon AWS S3fromGoogle App Engine, you not only need an S3
interface likesimples3, but you’ll also need a ported version of that
interface that works with Google’s ownurlfetchextension API.gaes3is exactly that, and is layered on top ofsimples3.Usage is exactly likesimples3, but with a different class:>>> from gaes3 import AppEngineS3Bucket
>>> bucket = AppEngineS3Bucket("foo", access_key, secret_key)
>>> bucket.info("foo")["mimetype"]
'text/plain'
Package: gaesynkit
The gaesynkit framework enables Google App Engine application developers to
create entities in the client’s Web Storage and synchronize them with the
server-side Datastore at a later point of time. So, offline editing becomes
easier and more secure through a higher level API.Copyright and LicenseCopyright 2011 Tobias RodaebelThis software is released under the Apache License, Version 2.0. You may obtain
a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Google App Engine is a trademark of Google Inc.InstallationThe easiest way to install gaesynkit is (provided that you have setuptools
installed) to use:$ easy_install gaesynkitDevelopingIf you want to tinker with the most recent development version of gaesynkit,
install the development environment by typing following commands:$ hg clone https://gaesynkit.googlecode.com/hg gaesynkit-dev
$ cd gaesynkit-dev
$ ./configure
$ makeTheconfigurecommand takes a number of options:Usage: configure [options]

Options:
   -h,--help                display this message
      --gae-sdk=PATH        path to the Google App Engine SDK
      --with-python=PATH    use this Python interpreterRunning TestsIf you have checked out the development sources, you can run all unit tests
with the following commands.Running the Python unit tests:$ make testGetting a test coverage report:$ make coverageThe coverage HTML report will be placed into thehtmlcovdirectory.In order to run the Javascript unit tests, enter following command and openhttp://localhost:8080with your web browser:$ make testjsCHANGESVersion 1.0.0a2 (2011-04-12)Using HTML5 Session Storage for storing RPC IDs.Supports more property value types.More efficient synchronization behaviour.Version 1.0.0a1 (2011-02-08)First alpha release.
Package: gaet
Gene-based assembly evaluation tool - evaluate a single assembly or
compare two assemblies using their annotations.Getting Startedpip install [--user] gaet

gaet assembly.gff
gaet --reference reference.gff assembly.gffGaet is written in python 3. If you would prefer, there is aprecompiled
version of gaetwhich runs on Linux systems.DocumentationSeegaet(1)for a description of how to run gaet. Seegaet-format(5)for a description of the output metrics generated by gaet.Running the testsGaet has both unit tests and feature tests. The unit tests check individual
python functions within the code. The feature tests are run against the
compiled version of gaet and ensure the program works as a whole.make test
make featureUpon a successful pull request onto the master branch, where all tests
pass, a new version of gaet will be released to pypi, and a new precompiled
version released to S3.Built Withfuncy- functional
programming for pythongffutils- Utilities for
accessing GFF datapyfaidx- Accessing
substrings of FASTA dataruamel.yaml- actively
maintained YAML parsing for pythonAuthorsMichael BartonLicenseThis project is licensed under the BSD License - see theLICENSE.txtfile for details.See alsoQUAST- check the completeness of
an assembly or compare with a reference using size metrics such
nga50.checkm- checks the
completeness of an assembly using the expectation of certain
essential genes.
Package: gaetestbed
This library provides a set of base test cases that can be mixed into your existing test cases.They provide additional features to sandbox each test (by clearing the DataStore, Memcache, etc)
and also add in additionalassertstyle statements.MailTestCase example:import unittest
from gaetestbed import MailTestCase

class MyTestCase(unittest.TestCase, MailTestCase):
    def test_email_sent(self):
        send_email_to('test@example.org') # Some method that sends e-mail...
        self.assertEmailSent(to='test@example.org')
        self.assertEqual(len(self.get_sent_messages()), 1)MemcacheTestCase example:import unittest
from gaetestbed import MemcacheTestCase

class MyTestCase(unittest.TestCase, MemcacheTestCase):
    def test_memcache_gets_hit(self):
        self.assertMemcacheItems(0)
        self.assertMemcacheHits(0)

        add_to_memcache('something', 'something') # Add something to memcache somehow...
        self.assertMemcacheItems(1)
        self.assertMemcacheHits(0)

        get_page('/page_that_hits_memcache/')
        self.assertMemcacheItems(1)
        self.assertMemcacheHits(1)
Package: gae-virtualenv
Using virtualenv with zipimport on Google App Engine.InstallationCopy build dir to you gae application root directory.Usage1. Edit build/pipreq.txt and run:$ cd build
$ ./buildenv.sh
$ python ziping.py2. Modify the load path at the top of each handler script:import sys
sys.path.insert(0, 'virtualenv.zip')3. Add build directory to skip_files in app.yamlskip_files:
    - ^(.*/)?build/.*
Package: gaffe
Introducing Gaffe: Streamlined Exception Handling for PythonAre you tired of managing messy, unstructured exceptions in your Python projects? Gaffe is here to save the day! This elegant library offers a metaclass-based approach for highly extensible and easy-to-integrate custom exceptions, leading to better error handling and improved code readability.🔥 Key Features🎯 Simple, concise syntax for defining custom errors with optional subtypes🧩 Clean integration through metaclass-based approach🌳 Supports inheritance and composition of custom errors🏗️ Automatic generation of error classes with custom attributes🧮 Easy error comparison with theeqmethod, supporting both class and instance comparisons🕵️‍♂️ raises decorator to inspect and validate exceptions raised by functions or methods🚀 Quick InstallationFor pip enthusiasts:pipinstallgaffeFor poetry aficionados:poetryaddgaffe💡 Getting StartedTo employ Gaffe's custom error system, import the Error class and create custom errors by inheriting from it:fromgaffeimportErrorclassNotFoundError(Exception):...classMyError(Error):not_found:NotFoundErrorinvalid_input:...authentication_error="authentication_error"With this example, you'll get three custom errors under the MyError class, ready to be used just like any other Python exceptions.🎩 Raises DecoratorHarness the power of the raises decorator to define and validate the types of exceptions a function or method can raise:fromgaffeimportraises@raises(TypeError,ValueError)defmy_function(x:int,y:int)->float:ifx<=0ory<=0:raiseValueError("x and y must be positive")returnx/yThe raises decorator ensures that my_function can only raise TypeError and ValueError. If it tries to raise an unlisted exception, an AssertionError will be raised with a suitable error message.🤖 Mypy IntegrationTo keep mypy happy, use the gaffe.mypy:plugin in your config file, and ensure that error properties are annotated withExceptiontype instead of...[tool.mypy]plugins="gaffe.mypy:plugin"Ready to revolutionize your Python exception handling? Get started with Gaffe today and check out the test scenarios for more examples!
Package: gaffer
**NOTICE**: Since the 2013/05/25, a deep rewrite on the gaffer code isin progress.**2013-10-29 - 0.5.1 released.**> slow progress on the new version. Have been distracted by some due> work. The new design is in place now and the new branch will be> created soon,# GafferControl, Watch and Launch your applications and jobs over HTTP.Gaffer is a set of Python modules and tools to easily maintain andinteract with your applications or jobs launched on different machines overHTTP and websockets.It promotes distributed and decentralized topologies without single points offailure, enabling fault tolerance and high availability.## Features- RESTful HTTP Api- Websockets and [SOCKJS](http://sockjs.org) support to interact with a gaffer node from any browser or SOCKJS client.- Framework to manage and interact your applications and jobs on- differerent machines- Server and command-line tools to manage and interract with your processes- manages topology information. Clients query gaffer_lookupd to discover  gaffer nodes for a specific job or application.- Possibility to interact with STDIO and PIPES to interact with yourapplications and processes- Subscribe to process statistics per process or process templates and get them in quasi RT.- Procfile applications support but also JSON config support.- Supervisor-like features.- Fully evented. Use the libuv event loop using the [pyuv library](http://pyuv.readthedocs.org)- Flapping: handle cases where your processes crash too much- Easily extensible: add your own endpoint, create your client, embed gaffer in your application, ...- Compatible with python 2.7x, 3.x## Documentationhttp://gaffer.readthedocs.org## Getting Startedhttp://gaffer.readthedocs.org/en/latest/getting-started.html## InstallationGaffer requires Python superior to 2.6 (yes Python 3 is supported)To install gaffer using pip you must make sure you have arecent version of distribute installed:$ curl -O http://python-distribute.org/distribute_setup.py$ sudo python distribute_setup.py$ easy_install pipTo install from source, run the following command:$ pip install git+https://github.com/benoitc/gaffer.gitFrom pypi:$ pip install gaffer## Build status<a href="https://travis-ci.org/benoitc/gaffer"><img src="https://travis-ci.org/benoitc/gaffer.png?branch=master" alt="Build Status" /></a>## Licensegaffer is available in the public domain (see UNLICENSE). gaffer is alsooptionally available under the MIT License (see LICENSE), meantespecially for jurisdictions that do not recognize public domainworks.
Package: gaframework
Genetic Algorithm FrameworkThe Genetic Algorithm Framework (GaFramework) is designed to be the simplest way to implement a genetic algorithm in Python 3. The framework is distributed as a Python package and allows a genetic algorithm based solution to be implemented in Python 3 using only a few lines of code.The GAF has been designed to be as generic and extensible as possible whilst at the same time being simple to use. The package contains all that is needed for many combinations of genetic algorithm. Many popular genetic operators are provided within the framework, in addition, external operators can be defined and added to the genetic algorithm process pipeline as required by the consumer.
Package: gaft
AGeneticAlgorithmFramework in pyThonIntroductionGAFTis a general Python Framework for genetic algorithm computation. It provides built-in genetic operators for target optimization and plugin interfaces for users to define your own genetic operators and on-the-fly analysis for algorithm testing.GAFTis now accelerated using MPI parallelization interfaces. You can run it on your cluster in parallel with MPI environment.Python SupportGAFTrequires Python version 3.x (Python 2.x is not supported).InstallationVia pip:pip install gaftFrom source:python setup.py installIf you want GAFT to run in MPI env, please install mpi4py explicitly:pip install mpi4pySeeINSTALL.mdfor more installation details.TestRun unit test:python setup.py test
Package: gaga-phsp
GAGA = GAN for GATEpip install gaga-phspScripts associated with the publication :
Phys Med Biol. 2019 doi:https://doi.org/10.1088/1361-6560/ab3fc1Generative adversarial networks (GAN) for compact beam source modelling in Monte Carlo simulations
Sarrut D, Krah N, Letang JM.https://www.ncbi.nlm.nih.gov/pubmed/31470418A method is proposed and evaluated to model large and inconvenient phase space files used in Monte Carlo simulations by a compact Generative Adversarial Network (GAN). The GAN is trained based on a phase space dataset to create a neural network, called Generator (G), allowing G to mimic the multidimensional data distribution of the phase space. At the end of the training process, G is stored with about 0.5 million weights, around 10MB, instead of few GB of the initial file. Particles are then generated with G to replace the phase space dataset.&#13; &#13; This concept is applied to beam models from linear accelerators (linacs) and from brachytherapy seed models. Simulations using particles from the reference phase space on one hand and those generated by the GAN on the other hand were compared. 3D distributions of deposited energy obtained from source distributions generated by the GAN were close to the reference ones, with less than 1% of voxel-by-voxel relative difference. Sharp parts such as the brachytherapy emission lines in the energy spectra were not perfectly modeled by the GAN. Detailed statistical properties and limitations of the GAN-generated particles still require further investigation, but the proposed exploratory approach is already promising and paves the way for a wide range of applicationsTests in opengate (https://github.com/OpenGATE/opengate): see test066.
Package: gaggle
gaggleAn aiohttp-based Google API client.The google-api-python-client requirement is because this library uses it to
discover services and prepare requests, leveraging the prepare+execute pattern
implemented in googleapiclient.HttpRequest.UsageJSONimportasyncioimportaiohttpfromgaggleimportClientasyncdefmain():asyncwithaiohttp.ClientSession()assession:drive=Client(session=session,token=access_token,# the following are optional and only required if the access_token is expired and can be refreshedrefresh_token=refresh_token,client_id=client_id,client_secret=client_secret).drive('v3')resp=awaitdrive.files.list(q="parents in 'root'")# resp is an instance of aiohttp.ClientResponseifresp.status==200:data=awaitresp.json()files=data.get('files',[])forobjinfiles:print(obj)if__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(main())Results in something like:{'kind': 'drive#file', 'id': '...', 'name': 'test.csv', 'mimeType': 'text/csv'}
{'kind': 'drive#file', 'id': '...', 'name': 'Test Folder', 'mimeType': 'application/vnd.google-apps.folder'}
{'kind': 'drive#file', 'id': '...', 'name': 'spreadsheet.xlsx', 'mimeType': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'}
{'kind': 'drive#file', 'id': '...', 'name': 'spreadsheet', 'mimeType': 'application/vnd.google-apps.spreadsheet'}Installation$ pip install gaggleTesting and developingI've included a handy Makefile to make these things fairly easy.$ make setup
$ make test
Package: gagrab
gagrabThe official Google Analytics API is very powerfull and
extensive. Sometimes, though, you just want to grab some data and have
it returned in a clean format.fromservice_account_authimportAuthorizedServicefromgagrabimportGrabbermy_ga_service=AuthorizedService('my-project-555','analytics','v3')grabber=Grabber(my_ga_service)data=grabber.query(view='UA-000000-1',metrics=['sessions','pageviews'],dimensions=['browser','userAgeBracket']start_date='2014-07-01',end_date='2014-08-15',)InstallationTo install the latest release, type:pip install gagrabTo install the latest code directly from source, type:pip install git+git://github.com/ambitioninc/gagrab.gitThegagrab.Grabberobject requires aservice_account_auth.AuthorizedServiceobject during
initialization. Installation and setup instructions for
gclient-service-account-auth can be found on the github pagehttps://github.com/ambitioninc/gclient-service-account-auth.DocumentationFull documentation is available athttp://gagrab.readthedocs.orgLicenseMIT License (see LICENSE)
Package: gaia-beet
gaia-beetBeet plugin to generate Minecraft worldgen filesIntroductionWriting density functions in JSON by hand can be tiring and confusing. This package allows you to write them as natural looking expressions.gaia.df("basic:foo",abs(const(4)**3)+ref("basic:bar"))InstallationThe package can be installed withpip.$pipinstallgaia-beetGetting startedWhen using withbeet, a simplebeet.ymlis enough:output:outpipeline:-mainThis references amain.pyplugin file where the density functions will be defined:frombeetimportContextfromgaia_beetimportGaiafromgaia_beet.density_functionsimport*defbeet_default(ctx:Context):gaia=ctx.inject(Gaia)blah=slide(const(2))foo=gaia.df("basic:foo",abs(const(4)**3)+blah)gaia.df("basic:bar",blah*foo)Then install beet and run the watch command:$pipinstallbeet
$beetwatchContributingContributions are welcome. Make sure to first open an issue discussing the problem or the new feature before creating a pull request. The project usespoetry.$poetryinstallYou can run the tests withpoetry run pytest.$poetryrunpytestThe project must type-check withpyright. If you're using VSCode thepylanceextension should report diagnostics automatically. You can also install the type-checker locally withnpm installand run it from the command-line.$npmrunwatch
$npmruncheckThe code follows theblackcode style. Import statements are sorted withisort.$poetryrunisortgaia_beetexamplestests
$poetryrunblackgaia_beetexamplestests
$poetryrunblack--checkgaia_beetexamplestestsLicense -MIT