Saravanan666/pypi-org huggingface dataset:
Package: g85-sentry-auth-oidc
An SSO provider for Sentry which enablesOpenID ConnectApps authentication.This is a fork ofsentry-auth-google.Why fork, instead of adapting sentry-auth-google to work with every OpenID Connect provider?The maintainer has different ideas with sentry-auth-google. See:https://github.com/getsentry/sentry-auth-google/pull/29https://github.com/getsentry/sentry/issues/5650Install$ pip install sentry-auth-oidcExample Setup for GoogleStart bycreating a project in the Google Developers Console.In theAuthorized redirect URIsadd the SSO endpoint for your installation:https://sentry.example.com/auth/sso/Naturally other providers, that are supporting OpenID-Connect can also be used (like GitLab).Finally, obtain the API keys and the well-known account URL and plug them into yoursentry.conf.py:OIDC_CLIENT_ID=""OIDC_CLIENT_SECRET=""OIDC_SCOPE="openid email"OIDC_DOMAIN="https://accounts.google.com"# e.g. for GoogleTheOIDC_DOMAINdefines where the OIDC configuration is going to be pulled from.
Basically it specifies the OIDC server and adds the path.well-known/openid-configurationto it.
That’s where different endpoint paths can be found.Detailed information can be found in theProviderConfigspecification.You can also defineOIDC_ISSUERto change the default provider name in the UI, even when theOIDC_DOMAINis set.If your provider doesn’t support theOIDC_DOMAIN, then you have to set these
required endpoints by yourself (autorization_endpoint, token_endpoint, userinfo_endpoint, issuer).OIDC_AUTHORIZATION_ENDPOINT="https://accounts.google.com/o/oauth2/v2/auth"# e.g. for GoogleOIDC_TOKEN_ENDPOINT="https://www.googleapis.com/oauth2/v4/token"# e.g. for GoogleOIDC_USERINFO_ENDPOINT="https://www.googleapis.com/oauth2/v3/userinfo"# e.g. for GoogleOIDC_ISSUER="Google"
Package: g8core
# G8coreG8Core is the python client used to talk to [G8OS core](https://github.com/g8os/core0)## install```bashpip install g8core```## How to use:```pythonimport g8corecl = g8core.Client(host='ip of docker container running core0')#validate that core0 is reachableprint(cl.ping())#then u can do stuff likeprint(cl.system('ps -eF').get())print(cl.system('ip a').get())#client exposes more tools for disk, bridges, and container mgmtprint(cl.disk.list())```
Package: g8fyi-beancount
A double-entry accounting system that uses text files as input.Beancount defines a simple data format or “language” that lets you define
financial transaction records in a text file, load them in memory and
generate and export a variety of reports, such as balance sheets or income
statements. It also provides a client with an SQL-like query language to
filter and aggregate financial data, and a web interface which renders
those reports to HTML. Finally, it provides the scaffolding required to
automate the conversion of external data into one’s input file in
Beancount syntax.
Package: g8fyi-fava
Fork of beancount/fava with some small modificationsFava is a web interface for the double-entry bookkeeping softwareBeancountwith a focus on features and usability.Check out the onlinedemoand learn more
about Fava on thewebsite.TheGetting Startedguide details the installation
and how to get started with Beancount.  If you are already familiar with
Beancount, you can get started with Fava:pip3 install fava
fava ledger.beancountand visit the web interface athttp://localhost:5000.If you want to hack on Fava or run a development version, see theDevelopmentpage on the
website for details. Contributions are very welcome!
Package: ga2
Genetic Algorithm Utility for pythonWhat is Genetic Algorithm ?Genetic Algorithm is inspired by the natural selection process in our environment. GA is very good for optimisation problems , read more aboutGA here.The ga2 modulega2 is a highly flexible and easy to use utility module implementing Genetic Algorithm.Installationstandard pip3 installation is supportedpip3 install ga2upgradingpip3 install --upgrade --no-cache ga2==1.0.0import the Genetic Algorithm utility asimport ga2.gaDisc as gad

session1 = gad.Session()
print(session1.sessID)this should print the session ID of that sessionUsagega2 is designed to be flexible and also simple to use for a variety of use cases, check theEXAMPLES.mdfor examples. Documentation will be done as soon as a stable stage is reachedCurrent DevelopmentgaDisc (Genetic Algorithm Discrete) is working and is in its first release stage, a lot of planning and designing needs to be done for gaCont (Genetic Algorithm continuous), which I hope will be soon !.[x] gaDisc[ ] gaContOpen to ideas , and contributions !
Package: ga4gh-dos-schemas
Schemas for the Data Object Service (DOS) APIView the schemas in Swagger UIThe goal of DOS is to create a generic API on top of existing object storage systems
so workflow systems can access data in a single, standard way regardless of where it's
stored. It's maintained by theGA4GH Cloud Workstream.Key featuresThe API is split into two sections:data object management, which enables the creation, updating, deletion, versioning,
and unique identification of files and data bundles (flat collections of files); anddata object querying, which can locate data objects across different cloud environments
and DOS implementations.Getting startedInstalling is as easy as:$ pip install ga4gh-dos-schemasThis will install both a demonstration server and a Python client that will allow you to
manage Data Objects in a local server. You can start the demo server usingga4gh_dos_server.
This starts a Data Object Service athttp://localhost:8080.wget http://hgdownload.cse.ucsc.edu/goldenPath/hg38/chromosomes/chr22.fa.gz
md5sum chr22.fa.gz
# 41b47ce1cc21b558409c19b892e1c0d1  chr22.fa.gz
curl -X POST -H 'Content-Type: application/json' \
    --data '{"data_object":
              {"id": "hg38-chr22",
               "name": "Human Reference Chromosome 22",
               "checksums": [{"checksum": "41b47ce1cc21b558409c19b892e1c0d1", "type": "md5"}],
               "urls": [{"url": "http://hgdownload.cse.ucsc.edu/goldenPath/hg38/chromosomes/chr22.fa.gz"}],
               "size": "12255678"}}' http://localhost:8080/ga4gh/dos/v1/dataobjects
# We can then get the newly created Data Object by id
curl http://localhost:8080/ga4gh/dos/v1/dataobjects/hg38-chr22
# Or by checksum!
curl -X GET http://localhost:8080/ga4gh/dos/v1/dataobjects -d checksum=41b47ce1cc21b558409c19b892e1c0d1For more on getting started, check out thequickstart guideor the rest of the documentation atReadtheDocs!Getting involved!The Data Object Service Schemas are Apache 2 Licensed Open Source software. Please join us
in theissuesor check out the
contributing docs!
Package: ga4gh-drs-client
ga4gh-drs-clientThe GA4GH DRS Client is a Python-based command-line application for requesting
omics data and metadata from web services that are compliant with theData Repository Service (DRS) API Specification. The DRS API specification, developed
by theGlobal Alliance for Genomics and Health, serves to provide a standardized
API framework to allow for interoperability of datasets hosted at different
institutions.Installation and UsagePlease review theGA4GH DRS Client Documentationfor instructions on how to install and use the command-line application.Additional ResourcesPyPI- The DRS Client is
available on the Python Package Index (PyPI)Docker- The DRS Client
can be run through a preconfigured image
Package: ga4ghmongo
# ga4gh-mongoA document based Variant database inspired by ga4gh Variants schema.https://github.com/ga4gh/schemas## Usagefrom ga4ghmongo.schema import Variant
v = Variant.create(start=0,reference_bases=”A”, alternate_bases=[“T”])
v.to_mongo().to_dict(){‘info’: {}, ‘is_snp’: True, ‘is_insertion’: False, ‘reference_bases’: u’A’, ‘created_at’: datetime.datetime(2016, 3, 16, 15, 11, 43, 989088), ‘updated_at’: datetime.datetime(2016, 3, 16, 15, 11, 43, 989189), ‘start’: 0, ‘var_hash’: u’b819f0202b6a9dff2821bbcf7dac87536bc9cb08be6eb96c8dad3fd4fd2a6fd6’, ‘names’: [u’A0T’], ‘is_indel’: False, ‘length’: 0, ‘alternate_bases’: [u’T’], ‘is_deletion’: False, ‘variant_sets’: []}### Changes from ga4gh v0.5.1 APIIn ga4gh schema each Variant must belong to one and only one VariantSet. Here we allow Variants to belong to multiple VariantSets
Package: ga4gh-rnaget-compliance
RNAget Compliance SuiteThe RNAget Compliance Suite determines a server's compliance with theRNAget API specificationfor serving RNAseq datasets. The specification, developed by
theGlobal Alliance for Genomics and Health, serves to provide a standardized API framework and data structure to allow for interoperability of datasets hosted at different institutions.Please review theRNAget Compliance Documentationfor instructions on how to
prepare and test an RNAget-compliant server.RNAget maintains an up-to-date report of the compliance status of its reference implementers.Click here to view the latest report.Installation and UsagePlease review theCompliance Documentationfor
installation and usage instructions.Additional ResourcesPyPI- The RNAget Compliance Utility is available on the Python Package Index (PyPI)
Package: ga4gh-schemas
GA4GH SchemasThis is the GA4GH schemas compiled as Protocol Buffers descriptors. It can be used
describe and serialize genomics data using a standard interchange format.importga4gh.schemas.ga4gh.variants_pb2asvariantsmy_variant=variants.Variant(reference_name="1",start=1832,end=4123,reference_bases="A",alternate_bases=["C"])Full documentation is available atread-the-docs.org.To read more about how the GA4GH API uses Protocol Buffers, see herehere.
Package: ga4gh-testbed-lib
GA4GH Testbed LibPython library for creating GA4GH testbed reports according to a harmonized, cross-workstream schemaInstallationAs a prerequisite, please ensure you have Python 3 installed on your machine.ga4gh-testbed-libis tested on the following Python versions:v3.7v3.8v3.9v3.10ga4gh-testbed-libis a library that can be imported into your Python project.
To do so, first install it viapip:pip install ga4gh-testbed-libNote: We recommend using a Python virtual environment when building any Python project to avoid dependency conflicts with other projects on your system.UsageOnce installed, you may import thega4gh-testbed-libin your Python modules. We recommend only importing theReportclass directly:from ga4gh.testbed.report.report import Report
...
report = Report()More documentation to come on how to use the report libraryTestTo contribute to the testbed library, you will need to clone the repository:git clone https://github.com/ga4gh/ga4gh-testbed-lib.gitTo run tests, you will need to install test dependencies (i.e. pytest):pip install -r requirements.txtTests can be run viapytest:python -m pytest --covChangelogv0.2.0Able to submit reports to Testbed API via standardPOSTrequestv0.1.2Test level entity now has amessageattribute for capturing test result summary in a single message
Package: ga4gh.vrsatile.pydantic
vrsatile-pydanticTranslation of the GA4GHVRSandVRSATILEschemas to a Pydantic data modelThe ga4gh/vrsatile/pydantic repo depends on VRS and VRSATILE models, and therefore each ga4gh.vrsatile.pydantic package on PyPI uses a particular version of VRS and VRSATILE. The correspondences between the packages may be summarized as:ga4gh.vrsatile.pydantic branchga4gh.vrsatile.pydantic versionVRS versionVRSATILE versionmain0.2.X1.X.Xmainmetaschema-update0.1.Xmetaschema-updatemetaschema-updateInstallationvrsatile-pydantic is available via PyPI:pip install ga4gh.vrsatile.pydanticDeveloper InstructionsFollowing are sections include instructions specifically for developers.InstallationFor a development install, we recommend using Pipenv. See thepipenv docsfor direction on installing pipenv in your compute environment.Once installed, clone the repo and initialize the environment:git clone https://github.com/ga4gh/vrsatile-pydantic
cd vrsatile-pydantic
pipenv shell
pipenv update
pipenv install --devInit coding style testsCode style is managed byflake8and checked prior to commit.We usepre-committo run conformance tests.This ensures:Check code styleCheck for added large filesDetect AWS CredentialsDetect Private KeyBefore first commit run:pre-commit installRunning unit testsRunning unit tests is as easy as pytest.pipenv run pytest tests
Package: gaabumbo
Bumbo: Python Web Framework built for learning purposesBumbo is a Python web framework built for learning purposes.It's a WSGI framework and can be used with any WSGI application server such as Gunicorn.Installationpipinstallgaa-bumboHow to use itBasic usage:frombumbo.apiimportAPIapp=API()@app.route("/home")defhome(request,response):response.text="Hello from the HOME page"@app.route("/hello/{name}")defgreeting(request,response,name):response.text=f"Hello,{name}"@app.route("/book")classBooksResource:defget(self,req,resp):resp.text="Books Page"defpost(self,req,resp):resp.text="Endpoint to create a book"@app.route("/template")deftemplate_handler(req,resp):resp.body=app.template("index.html",context={"name":"Bumbo","title":"Best Framework"}).encode()Unit TestsThe recommended way of writing unit tests is withpytest. There are two built in fixtures
that you may want to use when writing unit tests with Bumbo. The first one isappwhich is an instance of the mainAPIclass:deftest_route_overlap_throws_exception(app):@app.route("/")defhome(req,resp):resp.text="Welcome Home."withpytest.raises(AssertionError):@app.route("/")defhome2(req,resp):resp.text="Welcome Home2."The other one isclientthat you can use to send HTTP requests to your handlers. It is based on the famousrequestsand it should feel very familiar:deftest_parameterized_route(app,client):@app.route("/{name}")defhello(req,resp,name):resp.text=f"hey{name}"assertclient.get("http://testserver/matthew").text=="hey matthew"TemplatesThe default folder for templates istemplates. You can change it when initializing the mainAPI()class:app=API(templates_dir="templates_dir_name")Then you can use HTML files in that folder like so in a handler:@app.route("/show/template")defhandler_with_template(req,resp):resp.html=app.template("example.html",context={"title":"Awesome Framework","body":"welcome to the future!"})Static FilesJust like templates, the default folder for static files isstaticand you can override it:app=API(static_dir="static_dir_name")Then you can use the files inside this folder in HTML files:<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><title>{{title}}</title><linkhref="/static/main.css"rel="stylesheet"type="text/css"></head><body><h1>{{body}}</h1><p>This is a paragraph</p></body></html>MiddlewareYou can create custom middleware classes by inheriting from thebumbo.middleware.Middlewareclass and overriding its two methods
that are called before and after each request:frombumbo.apiimportAPIfrombumbo.middlewareimportMiddlewareapp=API()classSimpleCustomMiddleware(Middleware):defprocess_request(self,req):print("Before dispatch",req.url)defprocess_response(self,req,res):print("After dispatch",req.url)app.add_middleware(SimpleCustomMiddleware)
Package: ga-api-client
GenieAnalytics Python ClientThis package is the official Python client to access GenieAnalytics API server.Installationpip install ga-api-clientImport Modulesfromga_apiimportRepository,HyperLogLogTop Level Patternfromga_apiimportRepository,System,HyperLogLogimportasyncioimportpandasaspdasyncdefmain():try:repo=Repository('https://rdlab-214.genie-analytics.com/api','api','default','api123!@#')# ...# access API server to do whatever you need# ...finally:awaitrepo.close()if__name__=='__main__':asyncio.run(main())
Package: gaarf-exporter
gaarf exporterPrometheus exporter for Google Ads metrics with customizable metrics collectors.Installation and usageLocallyInstallgaarf-exporterfrom pip:pip install gaarf-exporterRungaarf-exporter:gaarf-exporterDockerdocker run --network=host \
  -v /path/to/google-ads.yaml:/root/google-ads.yaml \
  -v `pwd`/gaarf_exporter.yaml:/app/gaarf_exporter.yaml \
  gaarf_exporterdocker run --network=host gaarf_exporter \
  --config gs://path/to/gaarf_config.yaml \
  --ads-config gs://path/to/google-ads.yaml--network=host
By default it will start http_server onlocalhost:8000and will push some basic metrics to it.Customization--ads-config- path togoogle-ads.yaml--config- path togaarf_exporter.yaml--http_server.address- address of your http server (localhostby default)--http_server.port- port of your http server (8000by default)--pushgateway.address- address of your pushgateway service (Noneby default)--pushgateway.port- port of your pushgateway (Noneby default)--delay-minutes- delay in minutes between scrapings (15by default)CollectorsYou can specify collectors with--collectors <collector_name>CLI argument. Some collectors available by default, other you need to specify explicitly.Default collectorsperformance- extractclicks,impressions,cost,conversionson byad_networkandad_group_iddisapprovals- extractapproval_status,review_status,topic,topic_typebyad_group_idandad_idonly for not approved adsconversion_action- extractall_conversionsbyconversion_idandaccount_idmapping- performance mapping betweenad_group_id,ad_group_name,campaign_id,campaign_name,campaign_status,account_id,account_nameAvailable collectorssearch_terms- extractclicks,impressions,cost,conversionson bysearch_termandad_group_idsearch_terms_conversion_split- extractall_conversionsbysearch_termandconversion_idonad_group_idlevelplacements- extractclicks,impressions,cost,conversionson byplacement_nameandplacement_typebid_budgets- extract current values of bid (target_cpa, target_roas) and budget
Package: ga-attribution-scrape
ga-attribution-scrapeScrapes attribution data from GA through JS Network in Python for CSV exports.NotesThe program assumes separate conversions and does not currently try to sum conversions together from separate conversion IDs.When dealing with GA goals, will pull all goals as separate requests.Works on a Service Account for authentication.Will fill in missing dates in Bigquery if they exist. For example if a date is to be configured on 2020-12-01 and the earliest date in bq is 2020-12-03 then a dates list is generated for all dates between the two.How to runFirst import the Scrape function:from ga_attribution_scrape import ScrapeThen initialise ga_attribution_scrape with the Scrape() function which must contain aconfigdictionary, which can be found athttps://github.com/lewisaustinbryan/ga-attribution-scrape/blob/main/empty_config.yamlScrape().Goals(congig)configService AccountYou have to create a service account in Google Cloud Platform that has Bigquery access and GA access if you want to use a goal as a kpi for attribution reports.
Help on creating one can be found here.https://cloud.google.com/iam/docs/creating-managing-service-accountsSeparate Service accounts can be created for GA and BigqueryThere are four main parts to theconfiguration:GAHere you need to include account ID, Property ID and view ID.BigqueryFor including the dataset ID and Table ID to tell Bigquery where to put the attribution reports.BackdateIfbackdateisTruethen will just pull yesterdays data, otherwise it will loop through each day on the specifiedstart_dateandend_dateUnless you explicitly set GOOGLE_APPLICATION_CREDENTIALS in the environment (e.g. usingosmodule), be aware that the program expects you tobackdate firstwith service account, then whenbackdateisFalseit refreshes the service used. There is no other option but it makes it very easy to put into a Cloud/Gamma Function.RequestThis is where we copy the request from the JS network in Google analytics in the "Conversions -> Multi Channel Funnels -> Model Comparison Tool" report for the request urlhttps://analytics.google.com/analytics/web/exportReport/, which will have various query parameters associated with it.Copy everything from Request Headers and and Form Data, which is included in the empty_config.Get Attribution Report and send to Bigqueryfrom from ga_attribution_scrape import Scrape
ga_attribution  = Scrape().Goals(config)
ga_attribution.to_bq()
Package: gab
# Gab.com API Client[![BuildStatus](https://travis-ci.org/a-tal/gab.svg?branch=master)](https://travis-ci.org/a-tal/gab)[![Coverage Status](https://coveralls.io/repos/github/a-tal/gab/badge.svg?branch=master)](https://coveralls.io/github/a-tal/gab?branch=master)Based on the popular requests module, this is a minimal Gab.com API client.There is a `help` method available on all created objects, which canbe used to discover API methods and their call arguments.The client object is dynamically created during init time. To speed thingsup, you can create a Client object with a cached copy of the collections.jsonobject. Please see the [example.py](example.py) for one such example. To primea new cache, save the response of `gab.Client()._get_api_collections()`.Basic usage example:```python>>> import gab>>> client = gab.Client(gab.Options(...   ...... ))>>>>>> client.help()Gab.com API Client 0.0.1.The following collections are known:creating_postsengaging_with_other_usersfeedsgroupsnotificationspopularreacting_to_postsuser_details>>>>>> client.groups.help()Gab.com API collection Groups.These are the endpoints to access groups.The following operations are defined:group_detailsgroup_moderation_logsgroup_userspopular_groups>>>>>> client.groups.group_users.help()Gab.com API collection Groups method Group Users.Returns a list of given group's members. Requires read scope.Requires the following path parameters:group-idThe following headers are defined:AuthorizationAdditional optional parameters defined:before: (example: 0)>>>>>> client.groups.group_users(1234)Traceback (most recent call last):File "<console>", line 1, in <module><snipped>requests.exceptions.HTTPError: 401 Client Error: Unauthorized for url: <snip>>>>```Wow! The example ran into an auth error? What the heck?Yeah, this client library doesn't do auth, never write your own auth.Instead, use someone else's auth, and pass in a session object.Please see [example.py](example.py) for a full working CLI example with authentication.
Package: gabb
GabbA Python wrapper around the services powering the Gabb smartwatch/smartphone. This API is not publically documented, so use at your own risk, as there may be unexpected results of interacting with it directly. The underlying API is the FiLIP service owned by Smartcom (https://smartcom.com/filip-paas/)CompatibilityThis library was built on, and only ever tested with, Python 3.11 and depends heavily on therequestslibrary.