Saravanan666/pypi-org huggingface dataset:
Package: globus-compute-endpoint
Globus Compute EndpointGlobus Computeis a distributed Function as a Service (FaaS) platform that enables flexible, scalable, and high performance remote function execution. Unlike centralized FaaS platforms, Globus Compute allows users to execute functions on heterogeneous remote computers, from laptops to campus clusters, clouds, and supercomputers.This package provides theCompute Endpointagent — the software which receives user-submitted tasks (functions + arguments) and manages their execution on target machines — in addition to command line tools for managing compute endpoints.To submit functions for execution on compute endpoints, use the companionGlobus Compute SDKpackage.
Package: globus-compute-sdk
Globus Compute SDKGlobus Computeis a distributed Function as a Service (FaaS) platform that enables flexible, scalable, and high performance remote function execution. Unlike centralized FaaS platforms, Globus Compute allows users to execute functions on heterogeneous remote computers, from laptops to campus clusters, clouds, and supercomputers.This package contains the Python SDK for interacting with Globus Compute. Notable functionality includes submitting functions to remote compute endpoints via theexecutor, and querying endpoint status.To manage your own compute endpoints, use the companionGlobus Compute Endpointpackage.
Package: globus-identity-mapping
Globus Identity MapperTheGlobus Identity MapperPython library provides two mapping classes that
implement configurable hooks for mapping a Globus Auth Identity resource to
an application- or context-specific username:ExpressionIdentityMappingExternalIdentityMappingAdditionally, the library offers a protocol for implementing custom identity
mapper logic:IdentityMappingProtocolMost consumers of this library will make use of a mapping configuration
document, the.from_mapping_document()method to instantiate the appropriate
class, and then call.map_identity()or.map_identities()thereafter.
This enables administrators to dynamically specify their desired mapping
configuration without having to resort to typing Python code.  For example, a
simple mapping configuration to use theExpressionIdentityMappinglogic to
follow the rules as documented atGlobus Connect Server, Identity Mappingmight be:{"DATA_TYPE":"expression_identity_mapping#1.0.0","mappings":[{"source":"{email}","match":"(.*)@example\\.org","output":"{0}"}]}A hard-coded class instantiation might look like:>>>importjson>>>fromglobus_identity_mappingimportExpressionIdentityMapping>>>fdata=open("example_configuration.json").read()>>>mapping_document=json.loads(fdata)>>>connector_id="..."# see the Identity Mapping Guide, linked above>>>storage_gateway="application-specific-identifier">>>mapper=ExpressionIdentityMapping.from_mapping_document(...mapping_document,storage_gateway=storage_gateway,connector_id=connector_id...)Thereafter, themappermay be used to find a context-aware username by
mapping the source field ofemailfrom a Globus Auth Identity record via
the regular expression logic.  (In the above example, the hostname is stripped
to determine the application-specific username.)  Example:>>>gair={"id":"...","sub":"...","email":"billy@example.org","name":"..."}>>>mapper.map_identity(gair)'billy'For more serious library usage, implements may want to look atglobus_identity_mapping.loader.load_mappersDevelopmentThe high level bits:uses Poetry (pyproject.toml)uses toxtox- enough to run all teststox -e mypyto run mypyReminder to installpre-commitat your first checkout:pre-commit --install
Package: globus-jupyterlab
Globus Jupyterlab is an extension to Jupyterlab for easily submitting Globus Transfers
within a running lab environment. Integration within the Jupyterlab filemanager makes
starting transfers just a few clicks away!Install with the following:pipinstallglobus-jupyterlabFor information on usage, see theRead-The-Docs.DevelopingFor development, use the following instructions:# install the extension in editable modepython-mpipinstall-e.# install your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# build the TypeScript source after making changesjlpmrunbuild# start JupyterLabjupyterlab
Package: globus-nexus-client
Disclaimer: This Is Not An Official Globus.org ProductThis is a personal project for talking to the Globus Nexus API with all of the
benefits of the Globus SDK.
It is not a Globus maintained product.If you don’t know what that is, stop reading here and go away.
Otherwise, this will hopefully alleviate the pains of trying to use Nexus.Globus Nexus ClientWhen Globus added the newSDKit did not include functionality for the Nexus API.This package contains a client for talking to Nexus, based on the same core
client model provided by the SDK.
You should therefore think of this as a third-party extension to the SDK for
talking to Nexus.Importing and UsageWarningBecause this is not part of the SDK, you don’t get at it with a simplefrom globus_sdk import NexusClient.Instead, imports come from the package namespace:from globus_nexus_client import NexusClientYou can then useNexusClientmethods as usual.The client object supports all of the typical Authorizers that the SDK
provides, and this package provides an additional Authorizer for using
Nexus-issued tokens:from globus_nexus_client import NexusClient, LegacyGOAuthAuthorizer

client = NexusClient(authorizer=LegacyGOAuthAuthorizer('<nexus token>'))DocumentationThere is no web doc or other maintained documentation for this project, but
there are docstrings on all methods of the client object. Either browse the
source or usehelp()in the python REPL.
Package: globus-pilot
Globus PilotA Command Line tool for managing data in Globus Search as well as transferring corresponding data to and from a Globus Endpoint.InstallationPilot requires python 3.6+, you can install with the following:pipinstallglobus-pilotSee theRead-The-Docs Pagefor more options.Quick StartFor a full walkthrough, see theUser Guide.
Administrators can also view theAdmin Guide.A quick walkthrough is below.First, login using Globus:pilotloginSet your Search Index:pilotindexset<myindex>Then choose your project. Seepilot project infofor info on any listed project:pilotprojectpilotprojectset<myproject>You can uselistto get a high level overview of the data:pilotlistIf you want more detail about a specific search record, you can usedescribeto view details:pilotdescribedose_response/rescaled_combined_single_drug_growthYou can also download the data associated with the search record:pilotdownloaddose_response/rescaled_combined_single_drug_growthWhen you want to add more data to the collection, you can use theuploadcommand. This will upload the
data in addition to creating a record in Globus Search to track it.touchmy_data.tsvpilotuploadmy_data.tsvtest_dir--dry-run--verbose-jmy_metadata.jsonThe two flags ‘–dry-run –verbose’ are optional but handy for testing. ‘-j my_metadata.json’
is for providing any extra metadata the pilot tool can’t automatically determine. Here is an example of the metadata:{"title":"Drug Identifiers","description":"Drug identifiers, including InChIKey, SMILES, and PubChem.","data_type":"Drug Response","dataframe_type":"List","source":["InChIKey","SMILES","PubChem"]}Running TestsEnsure packages in test-requirements.txt are installed, then run:pytestAnd for coverage:pytest--covpilot
Package: globus-sdk
Globus SDK for PythonThis SDK provides a convenient Pythonic interface toGlobusAPIs.Basic UsageInstall withpip installglobus-sdkYou can then import Globus client classes and other helpers fromglobus_sdk. For example:fromglobus_sdkimportLocalGlobusConnectPersonal# None if Globus Connect Personal is not installedendpoint_id=LocalGlobusConnectPersonal().endpoint_idTesting, Development, and ContributingGo to theCONTRIBUTINGguide for detail.LinksFull Documentation:http://globus-sdk-python.readthedocs.io/Source Code:https://github.com/globus/globus-sdk-pythonAPI Documentation:https://docs.globus.org/api/Release History + Changelog:https://github.com/globus/globus-sdk-python/releases
Package: globus-sdk-tokenstorage
Globus SDK TokenStorageTh Globus SDK provides a convenient Pythonic interface toGlobusAPIs.This library provides an interface for handling the storage and management of
tokens acquired through the SDK more easily.It takes tokens, stores and loads them to and from files, and additionally
provideson_refreshcallbacks which can be used inglobus_sdk.RefreshTokenAuthorizerandglobus_sdk.ClientCredentialsAuthorizerto keep those files up-to-date.Intentional limitation: this library does not generate Authorizers or Clients,
and is limited only to token and file management.In the future, this may expand to include storage mechanisms which are not
files.LinksFull documentation:https://globus-sdk-tokenstorage.readthedocs.io/en/latest/Changelog0.4.1 (2021-09-29)Allow use with SDK version 30.4.0 (2021-06-03)Bugfix:Set umask to0o177when creating sqlite DB, so that it will only
be readable and writable by the current userAbstract base clases now inherit fromabc.ABCRename abstract base classes toStorageAdapterandFileAdapterSQLiteStorageAdapteris now aFileAdapterwherefilenameis the
db name0.3.0 (2021-05-03)Drop support for python versions < 3.60.2.1 (2019-11-12)Add methods toSQLiteStorageAdapterfor removing tokens and removing config0.2.0 (2019-11-12)AddSQLiteStorageAdapterwhich stores tokens and config under namespaces in
a sqlite db0.1.0 (2018-11-07)Initial version of the library, implementingSimpleJSONStorageAdapter
Package: globus-search-cli
Globus Search CLIA command-line tool for interacting with Globus Search.Provides theglobus-searchcommand.NoteAt a future date, we hope to incorporate this functionality into theglobus-cli. At that time, support for this tool will be dropped.RequirementsYou must have Python 3.6+ andpipinstalled.
There are no other requirements.Installpipinstallglobus-search-cliInstall for Production UsageIf you plan to useglobus-search-cliin a production environment or
workflow, it is strongly recommended that you pin the exact version you are
using while it is in beta.For example,pipinstall'globus-search-cli==0.7.0'Useglobus-search--helpUninstallpipuninstallglobus-search-cliBugs, Feature Requests, and IssuesAll issue tracking is done in the openGlobus Search CLIissue tracker.
Package: globussh
Python wrappers around the globus command line interface using ssh.Example>>>fromglobusshimporttransfer>>>src="globusid#endpoint1/path/to/file1">>>dst="glbousid#endpoint2/path/to/file2">>>transfer("{:s}{:s}".format(src,dst),label="example_transfer")>>>scp(src,dst,label="example_scp")Installglobusshis on the Python Package Index (PyPI):pip install globusshglobushexpects ssh to have a hostglobusin~/.ssh/config, e.g.:host globus
HostName cli.globusonline.org
User maxhutch
Package: globy-webcrawlers
Globy webcrawlers:star: Scrape the world with Globy! :star:Usage$globy-scraper.py-h
usage:globy-scraper.py[-h]-fURLS_FILE[-lLOGLEVEL][-oOUTPUT_FILE][-d][-s][-bBACKEND]options:-h,--helpshowthishelpmessageandexit-fURLS_FILE,--urls_fileURLS_FILENewlineseparatedfileofURLstoscrape-lLOGLEVEL,--loglevelLOGLEVELSetloglevel(1-3)-oOUTPUT_FILE,--output_fileOUTPUT_FILEOutputCSVfilepath-d,--debugDebug/inspectresponses(WillsetPYTHONINSPECTtoTrue)-s,--store_html_to_fileStoreHTMLallcontenttofileperdomaininthe"html_output"folder-bBACKEND,--backendBACKENDSelectbackendtouseforscraping:"globy"(default)or"scrapy".(!)Thescrapybackendwillonlydumpdatatothe"html_output"folderfornow.Nowebsiteanalysisorotherfunctionallityissupportedyet.QuickstartYou can just run globy-scraper as a script (no installation needed):pip3install-rrequirements.txt# Install dependencies if not already installed./globy-scraper.py-fwordpress-top50.txtInstall the globy-webcrawlers packageYou can install the package for development and use with other Globy projects.
It'srecommendedto set up a python virtual environment before installing the package.pip3install-e.Now you can use the package in python:fromgloby_webcrawlers.crawlerimportWebSiteDataCrawler>>>c=WebSiteDataCrawler()>>>c.load_urls_from_file("urls.txt")>>>c.run()Also, after installing globy-scraper, you can just run it:globy-scraper.py -hDebugging/inspecting website contentSince the crawler is asynchronous, it can be a bit tricky to debug the responses. To make it easier, you can use the-dflag. This will allow you to inspect the HTML content and any internal objects from the most recent website.
Here's an example:$./globy-scraper.py-fwordpress-top50.txt-d>>>w=crawler.debug_latest_response()>>>w.url'https://www.thyroid.org/'>>>len(w.html_content)249167>>>w.get_website_info()Change the crawler.urls to get the response you want to debug, or the input url list.Development onlyBuild and & create python package:python3-mbuild
Package: gloc
A simple wrapper for Google's geocoding api.Get address data from coordinates or coordinates from an address in one function call. No need to bother with creation of requests and parsing of responses. Distance from a Location to another is available as a method.from gloc import Location

location = Location.from_coordinates(57.696994, 11.986500)

same_location = Location.from_address("Skånegatan 59, 412 52 Göteborg, Sweden")

distance = location.distance_to(same_location)Put an api-key in a file named google_api_key.txt in working directory or set environment variable GOOGLE_API_KEY.
Package: glocaltokens
Google home local authentication token extractionPython 3 package to extract google home devices local authentication tokens from google servers.
These local authentication tokens are needed to control Google Home devices
(See@rithvikvibhu'sGoogle Home (2.0) API).Please note:
Once you have local google authentication tokens they only live about 1 day long.
After that you will need to obtain new ones.
You will probably need to run the script repeatedly storing the tokens somewhere convenient.QuickstartNote: the package was written and tested on Python 3.Install the python packagepip install glocaltokensUse in your program as (see examples folder for detailed example):fromglocaltokens.clientimportGLocalAuthenticationTokens# Using google username and password## ONLY CALL THIS ONCE## If you call this too often, google will disconnect your android devices and other weird things will happen## Call get_google_devices_json() afterwards to get timers/alarms as oftens as you want to update.client=GLocalAuthenticationTokens(username="<YOUR_GOOGLE_USERNAME>",password="<YOUR_GOOGLE_PASSWORD>")# Get master tokenprint("[*] Master token",client.get_master_token())# Get access token (lives 1 hour)print("\n[*] Access token (lives 1 hour)",client.get_access_token())# Get google device local authentication tokens (live about 1 day)print("\n[*] Google devices local authentication tokens")google_devices=client.get_google_devices_json()# You can also select specific models to select when calling get_google_devices or get_google_devices_json with the models_list parameter.# For example, we have pre-defined a constant with some Google Home Models (WARNING! Not all of them may be present)# This could be used this wayfromglocaltokens.constimportGOOGLE_HOME_MODELSgoogle_devices_select=client.get_google_devices_json(GOOGLE_HOME_MODELS)# But if you need to select just a set of models, or add new models, you can use a list of strgoogle_devices_select_2=client.get_google_devices_json([f"Google Home",f"Google Home Mini",f"Google Nest Mini",])Predefined models listThere are some pre-defined models list inscanner.py, feel free to
add new lists, or add models to a list with a pull-request.GOOGLE_HOME_MODELS:Google HomeGoogle Home MiniGoogle Nest MiniLenovo Smart ClockSecurity RecommendationNever store the user's password nor username in plain text, if storage is necessary, generate a master token and store it.
Example approach:fromglocaltokens.clientimportGLocalAuthenticationTokens# Using google username and password first, and only onceclient=GLocalAuthenticationTokens(username="<YOUR_GOOGLE_USERNAME>",password="<YOUR_GOOGLE_PASSWORD>")# Get master tokenmaster_token=client.get_master_token()print("[*] Master token",master_token)"""Now store master_token somewhere"""ContributingSeeContributing guidelines.
This is an open-source project and all countribution is highly welcomed.CreditsMuch credits go to@rithvikvibhufor doing most of the heavy work like finding a way to
extract master and access tokens
(See his gisthere).Also, thank you very much to the guys atpychromecastwhich provided the code required to scan devices in the network.
Package: glocate
This program accepts any text and searchs inside every IP address. With
each of those IP addresses, geolocate queries Maxmind GeoIP database (http://www.maxmind.com)_to look for the city and country where IP address or URL is located.Geolocate is designed to be used in console with pipes and redirections along
with applications like traceroute, etc. Geolocate’s output is the same text
than input but IP addresses are going to have appended its country and city and long-lat
coordinates (depending on verbosity level).More info in:https://github.com/dante-signal31/geolocate
Package: glock
# Glock - a Clock abstraction for gevent #Most likely your application is in some way working with the concept
of time. It can be timeouts, it can be tasks that should be executed
within regular intervals.Glock (Gevent cLOCK) tries to encapsulate time-related functionality
into a simpleClockclass.  Also provided is a mock Clock class
allowing deterministic testing.Usage:from glock.clock import Clockc = Clock()
c.call_later(1, fn)API:Thecall_later(seconds, fn, *args, **kw)method callsfnsecondsfrom now.  ADelayedCallinstance is returned that can be used to
reschedule the call (usingreset) or cancel it (usingcancel).The clock also have asleepmethod that acts just likegevent.sleep.  To read out the current time, use thetimemethod.TheMockClockmethod also has anadvancemethod that is used to
advance time in a controlled manner.
Package: glog
A simple Google-style logging wrapper for Python.This library attempts to greatly simplify logging in Python applications.
Nobody wants to spend hours pouring over the PEP 282 logger documentation, and
almost nobody actually needs things like loggers that can be reconfigured over
the network.  We just want to get on with writing our apps.Styled somewhat after thetwitter.common.loginterface, which in turn was
modeled after Google’s internal python logger, which wasnever actually
releasedto the wild, and which in turn was based on theC++ glog library.Core benefitsYou and your code don’t need to care about how logging works. Unless you
want to, of course.No more complicated setup boilerplate!Your apps and scripts will all have a consistent log format, and the same
predictable behaviours.This library configures the root logger, so nearly everything you import that
uses the standard Python logging module will play along nicely.BehavioursMessages are always written to stderr.Lines are prefixed with a google-style log prefix, of the formE0924 22:19:15.123456 19552 filename.py:87] Log message blah blahSplitting on spaces, the fields are:The first character is the log level, followed by MMDD (month, day)HH:MM:SS.microsecondsProcess IDbasename_of_sourcefile.py:linenumber]The body of the log message.Example useimportglogasloglog.setLevel("INFO")# Integer levels are also allowed.log.info("It works.")log.warn("Something not ideal")log.error("Something went wrong")log.fatal("AAAAAAAAAAAAAAA!")If your app usesgflags, it will automatically gain a--verbosityflag,
and you can skip callinglog.setLevel.  Just import glog and start logging.Check macros / assert helpersLike the C++ version of glog, python-glog provides a set of check macros[1]that help document and enforce invariants.  These provide a detailed
message indicating what values caused the assertion to fail, along with a stack
trace identifying the code-path that caused the failure, hopefully making it
easier to reproduce the error.  Failed checks raise the FailedCheckException.
You may find these more convenient and/or more familiar than standard Python
asserts, particularly if you are working in a mixed C++ and Python codebase.importglogaslogimportmathdefcompute_something(a):log.check_eq(type(a),float)# require floating point typeslog.check_ge(a,0)# require non-negative valuesvalue=math.sqrt(a)returnvalueif__name__=='__main__':compute_something(10)Provided check functions:check(condition)check_eq(obj1,obj2)check_ne(obj1,obj2)check_le(obj1,obj2)check_ge(obj1,obj2)check_lt(obj1,obj2)check_gt(obj1,obj2)check_notnone(obj1,obj2)Happy logging![1]Technically these are functions, not macros.  Python does not have
syntactic macros in the sense that C++ and most lisp-like languages do.
Package: glog2
A simple Google-style logging wrapper for Python.This library attempts to greatly simplify logging in Python applications.
Nobody wants to spend hours pouring over the PEP 282 logger documentation, and
almost nobody actually needs things like loggers that can be reconfigured over
the network.  We just want to get on with writing our apps.Styled somewhat after thetwitter.common.loginterface, which in turn was
modeled after Google’s internal python logger, which wasnever actually
releasedto the wild, and which in turn was based on theC++ glog library.Core benefitsYou and your code don’t need to care about how logging works. Unless you
want to, of course.No more complicated setup boilerplate!Your apps and scripts will all have a consistent log format, and the same
predictable behaviours.This library configures the root logger, so nearly everything you import that
uses the standard Python logging module will play along nicely.BehavioursMessages are always written to stderr.Lines are prefixed with a google-style log prefix, of the formE0924 22:19:15.123456 19552 filename.py:87] Log message blah blahSplitting on spaces, the fields are:The first character is the log level, followed by MMDD (month, day)HH:MM:SS.microsecondsProcess IDbasename_of_sourcefile.py:linenumber]The body of the log message.Example useimportglogasloglog.setLevel("INFO")# Integer levels are also allowed.log.info("It works.")log.warn("Something not ideal")log.error("Something went wrong")log.fatal("AAAAAAAAAAAAAAA!")If your app usesgflags, it will automatically gain a--verbosityflag,
and you can skip callinglog.setLevel.  Just import glog and start logging.Check macros / assert helpersLike the C++ version of glog, python-glog provides a set of check macros[1]that help document and enforce invariants.  These provide a detailed
message indicating what values caused the assertion to fail, along with a stack
trace identifying the code-path that caused the failure, hopefully making it
easier to reproduce the error.  Failed checks raise the FailedCheckException.
You may find these more convenient and/or more familiar than standard Python
asserts, particularly if you are working in a mixed C++ and Python codebase.importglogaslogimportmathdefcompute_something(a):log.check_eq(type(a),float)# require floating point typeslog.check_ge(a,0)# require non-negative valuesvalue=math.sqrt(a)returnvalueif__name__=='__main__':compute_something(10)Provided check functions:check(condition)check_eq(obj1,obj2)check_ne(obj1,obj2)check_le(obj1,obj2)check_ge(obj1,obj2)check_lt(obj1,obj2)check_gt(obj1,obj2)check_notnone(obj1,obj2)Happy logging![1]Technically these are functions, not macros.  Python does not have
syntactic macros in the sense that C++ and most lisp-like languages do.
Package: glogger
gloggerA python library for logging loguru messages straight to a gelf instance, for example Sematext via HTTPInstall gloggerSimply install it via pip:pip install gloggerGetting startedMake sure the following environment variables have been set:ENVIRONMENT,LOGGING_URLandLOG_FACILITYfromgloggerimportloggerlogger.info('go')logger.bind(custom='field').info('yay')
Package: glog-ntfy
GLogA logging system based on structlog with ntfy supportFree software: MIT licenseDocumentation:https://glog.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History1.0.0 (2022-09-24)Official release.Add pydantic supportNew structure0.1.0 (2022-09-24)First release on PyPI.