Saravanan666/pypi-org huggingface dataset:
Package: jwis
Author: Kiwamu IshikuraLicence: GPLv3What’s this?This is a program to get hydrological data fromWater Information Systemprovided from Japanese Ministry of Land, Infrastructure, Transport and Tourism.
You can retrieve data and, save as csv.Only water level and flow rate data
are available, because this program is still in beta version.RequirementsPython (>= 2.7 or >= 3.3)pandas (>= 0.18.0)InstallationIf you have pip, you can install by pip as below:$ pip install jwisOr, you can install by setup.py:$ python setup.py installUsageJust type as below in your console:$ jwisProgram will ask you the beginning and final date you want, observatory ID
(観測所記号), and file name. Please follow the explanations.
Package: jwkaas
jwkaasPython JSON Web Key Advanced Acquiring StoreIntroduction to JWT, JWS and JWKThis Python module provides JSON Web Token decoding and verification. The validity of a JWT is based on theJSON Web Signature (JWS). A signature is verified using the corresponding JSON Web Key (JWK). Many identify providers publish the JSON Web Keys to verify their signatures as a JSON document on the Internet (these are referred to as the JWKS).
A JWT may contain several claims (seeRFC 7519). jwkaas will check theexpandnbfclaim based on the current time. Theaudandissclaim will be verified based on whether this information was specified on initialization (seeUsagebelow)Introduction to jwkaasThe Python module jwkaas provides the functionality to verify a JWT and decode it to get the information from the JWT. It includes acquiring and storing the JWKS required to verify the signatures.UsageThe functionality is provided by the JWKaas class. On initialization the expected audience and issuer must specified. A JWT will only be accepted if the values match the corresponding token claimsaudandiss. The JWKS can be specified by an url from where the JWKS json can be downloaded, and/or by a file containing the JWKS json. If both sources contain a key with the same key id (kid), the key from the url will precede the key from the file.
Example initialisation:my_jwkaas = JWKaas('https://my.audience'", 
                   'https://my.iam.server/issueing/the/token',
                   jwks_url='https://my.iam.server/well-known/keys.jwks')Verifying and decoding a JWT is done by the JWKaas.get_token_info, like this:token_info = my_jwkaas.get_token_info(token)
if token_info is not None:
    logging.info("Token info: %s", token_info)
else:
    logging.info("Token is invalid")Using jwkaas with Connexion OpenAPI First framework for PythonJWKaas also provides JWKaas.get_connexion_token_info. This returns the token_info extended with thescopekey as used byConnexion. The value ofscopewill be copied from thescpclaim, which is the claim used by Azure AD to specify the scopes. Other IAM servers might use yet another claim to specify the scopes, those are currently not implemented.Acknowledgementsjwkaas is build aroundPyJWT, a Python implementation ofRFC 7519.TestingRun ```python -m nose
Package: jwk-theme
JWK-Theme themeThis is the theme use in my personal website, forked and modified fromnice-blog.Sites Using JWK-Themehttps://jwkennington.comExtrasPages can have subtitles, just add:Subtitle: Put your subtitle hereArticles can have one cover image, just add:Image: image_name.extensionImage must be on/content/imagesArticle image gallery:gallery:<galleryname>Images must be on./content/images/gallery/<galleryname>SettingsThis settings must be onpelicanconf.pyChange theme color:THEME_COLOR = 'blue'Available colors is on./static/css/colorsMenu left side Logo:LOGO = 'logo.extension'If No logo specified, Blog title will be used instead.Logo must be inside./content/imagesTo select what to show on sidebar:SIDEBAR_DISPLAY = ['about', 'categories', 'tags']The text in sidebar About:SIDEBAR_ABOUT = "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Sequi quae hic dicta eius ad quam eligendi minima praesentium voluptatum? Quidem quaerat eaque libero velit impedit dicta, repudiandae sapiente. Deserunt, excepturi."Copyright text:COPYRIGHT = "Text Here "To enable gallery plugin support:PLUGINS_PATHS = ['PluginsRelativePath', 'or/absolute/path/to/plugins/dir']
PLUGINS = ['gallery']
GALLERY_PATH = 'images/gallery/'To enable Piwik analytics support:#Piwik mandatory variables
DOMAIN = "yourdomain.com"
PIWIK_URL = "//analytics.address.com"
PIWIK_SITE_ID ="ID_NUMBER"PIWIK_URL should be as in the example without http: or https:To enable Piwik tracking code options:#Track visitors across all subdomains
TRACK_SUBDOMAINS = True

#Prepend the site domain to the page title when tracking
PREPEND_DOMAIN = True

#In the "Outlinks" report, hide clicks to know alias URLs
HIDE_CLICK_KNOWN_ALIAS = True

#Track users with JavaScript disabled
TRACK_NO_JAVA = True
Package: jw-nx
jw-nxAbout packageThis package provides an authentication mechanism forDjango Rest Frameworkbased on JSON Web Tokens in the browser-backed upKnox-powered tokens in the database.This package aims to take the better parts of both worlds, includingExpirable tokens: The tokens may be manually expired in the database, so a user can log out of all other logged-in places, or everywhere.Different tokens per login attempt (per user-agent): A user's session is tied to the specific machine and logging can be segregated per usage.JWT-base tokens: The token can have an embedded expiration time and further metadata for other applications.Only the tokens' hashes are stored in the database: So that even if the database gets dumped, an attacker cannot impersonate people through existing credentials.Access and refresh token: Like therest-framework-simplejwt package, this package creates refresh token and access token in login attempt and authentication is working with the access token.Other applications sharing the JWT private key can also decrypt the JWT.This package provides some endpoint for getting some data about the statuses of tokens.Note: Token_key provided by Knox, is set in the payload of access and refresh token.InstallationFor installing this package in your environment run these commands:pip install jw-nx
 pip install django-rest-knoxQuick startAdd "jw_nx and knox" to your INSTALLED_APPS setting like this:INSTALLED_APPS = [   
    ...  
    'knox',   
    'jw_nx',  
    ...   
]Include the polls URLconf in your project urls.py like this:path('jw_nx/', include('jw_nx.urls')),Runpython manage.py makemigrations.Runpython manage.py migrate.Add 'jw_nx.auth.JSONWebTokenKnoxAuthentication' to REST_FRAMEWORK like this:REST_FRAMEWORK = [ 
   ... 
   'DEFAULT_AUTHENTICATION_CLASSES': 
       ('jw_nx.auth.JSONWebTokenKnoxAuthentication',),
   ...
]
Package: jwpo
Jared Warner’s Personalized Opportunities (JWPO) is an Apache2 licensed tool
for generating personalized tests.QuickstartInstallingJWPOis simple withpip:$ python -m pip install jwpoYou can run the tool with:$ python -m jwpo --helpReferenceJWPO DocumentationJWPO at PyPIJWPO at GitHubJWPO Issue TrackerLicenseCopyright 2019 Grant JenksLicensed under the Apache License, Version 2.0 (the “License”); you may not use
this file except in compliance with the License.  You may obtain a copy of the
License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied.  See the License for the
specific language governing permissions and limitations under the License.
Package: jwrap
jwrapjwrap— is a single-file micro-library that implements JSON wrapper. Its mission is to make interacting with JSON a little bit easier without writing extra code.More information is available in docstrings:>>> import jwrap
>>> help(jwrap)QuickstartFor example, you can write some data to json file by this:fromjwrapimportJwrapj=Jwrap('myfile.json')j.json['mykey']='my value'# or: j.ins('mykey', 'my value')j.commit()# write data to file
Package: jws2txt
jws2txtA program to convert binary JASCO SpectraManager (JWS and JWB) files to text files.Introductionjws2txt is a simple command line tool that allows for the conversion of JWS and JWB files from JASCO SpectraManager software to text files. These text files can be used in any data analysis workflows and software.Unlike JASCO SpectraManager software, jws2txt enables batch conversion of JWS/JWB files.Data unpacking is based on Víctor M. Hernández-Rocamora's jwsProcessor (https://github.com/vhernandez/jwsProcessor).Installation and UsageDownload Python.Run thepip install jws2txtcommand in the command line.To convert the files, run thejws2txt --in-path path_to_folder --out-dir output_folder_pathcommand, where path_to_folder is the folder containing the JWS or JWB files.The converted files will be located in the folder containing the source JWS or JWB files.
Package: jwstapipy
JWSTapipySimple python library for access to data from jwstapi.comJWSTapipyDescriptionGet JWSTapipyExamplesGet list of programsGet part of program data by IDDescriptionJWSTapipy is a simple python library to work with data provided by the sitehttps://jwstapi.com/The site provides James Webb Space Telescope data. Data is sourced from MAST, processed and exposed through API.Get JWSTapipypipinstalljwstapipyExamplesGet list of programsimportasyncioimportjwstapipyasyncdefmain(api_key):jwst=JwstAPI(api_key)programs=awaitjwst.get_programs_list()print(programs)if__name__=="__main__":asyncio.run(main('api_key'))Get part of program data by IDimportasyncioimportjwstapipyasyncdefmain(api_key):jwst=JwstAPI(api_key)program_data=awaitjwst.get_program_data(program_id=2731,first_page=1,last_page=2)print(program_data)if__name__=="__main__":asyncio.run(main('api_key'))
Package: jwst-backgrounds
jwst_backgrounds is a a simple program to predict the levels of background emission
in JWST observations, for use in proposal planning.It accesses a precompiled background cache prepared by Space Telescope Science Institute. The background cache is hosted by the
Mikulski Archive for Space Telescopes (MAST), so you need internet access to run the tool with the remote cache. It is possible to
download the full background cache to your local machine. Instructions for downloading the background cache can be found athttp://archive.stsci.edu/archive_news/2017/08-Aug/index.html#article1For a given target (RA, DEC), and wavelength, jwst_backgrounds does the following:Plot the spectrum of the background for that target on a given calendar day.Plot the total background for that target versus calendar day.Compute the number of days per year that the target is observable at low background,
for a given wavelength and a selectable threshold.Save the retrieved background data to file.This code was written by Jane Rigby (GSFC,Jane.Rigby@nasa.gov) and Klaus Pontoppidan (STScI,pontoppi@stsci.edu)
The background cache was prepared by Wayne Kinzel at STScI, and is the same as used by the JWST Exposure Time Calculator.This software is provided as-is, with no warranty.INSTALLATIONUsing pip:pip install jwst_backgroundsNote: healpy (version >= 1.10) is a required dependency, so if you don't have it pip will install it automatically.Note: to upgrade the JBT with pip usepip install jwst_background --upgradeUsing CondaFirst clone the repositorygit clone git@github.com:spacetelescope/jwst_backgrounds.git
cd jwst_backgrounds
conda create --name <env> --file requirements.txtwhere<env>is the name of the environment you wish to create and requirements is therequirements.txtin the package directory.
To activate your JBT enter the following command:source activate <env>ManuallyClone the repository from github and install usingeasy_install.git clone git@github.com:spacetelescope/jwst_backgrounds.git
cd jwst_backgrounds
easy_install .RUNNING THE CODE:python			# Start python.
from jwst_backgrounds import jbt 	# Import the background moduleBelow is an example that plots a background curve for a given RA, DEC, wavelength, thresholdjbt.get_background(261.6833333, -73.33222222, 2.15, thresh=1.1, \
                        plot_background=True, plot_bathtub=True, write_bathtub=True)Contributingjwst_backgroundsfollows the STScI"forking workflow".TROUBLESHOOTING:If matplotlib does not display the images, then try editing your ~/.matplotlib/matplotlibrc file,
and choosing a different backend:backend: MacOSX
backend: TkAgg
backend: GTKCairoCitationThis code was written by Jane Rigby (GSFC,Jane.Rigby@nasa.gov) and Klaus Pontoppidan (STScI,pontoppi@stsci.edu) The background cache was prepared by Wayne Kinzel at STScI, and is the same as used by the JWST Exposure Time Calculator.
Package: jwstinfo
jwstinfois a small Python module and command line tool that provides a
simple summary of JWST data files. It is intended to be a lightweight tool that
does not require the JWST pipeline or data models.To use the command line tool, simply run thejwstinfocommand:$ jwstinfo /path/to/jwst/data.fitsAn example summary will look something like the following:original filename : jw10001001001_01101_00001_mirifushort_s3d.fits
file creation date: 2018-11-13T14:33:33.924
pipeline version  : 0.12.2a.dev45+g91aabdd6
instrument        : MIRI
detector          : MIRIFUSHORT
model type        : IFUCubeModel
target name       : NGC 104
observation id    : M103-Q3-SHORT-6020222141InstallationStable releases of the package are registeredat PyPi. The latest stable version can be
installed usingpip:$ pip install jwstinfoThe latest development version is available from themasterbranchon github. To clone the project:$ git clone https://github.com/spacetelescope/jwstinfoTo install:$ cd jwstinfo
$ pip install .To install indevelopment
mode:$ pip install -e .ContributingWe welcome feedback and contributions to the project. Contributions of
code, documentation, or general feedback are all appreciated. Please
follow thecontributing guidelinesto submit an
issue or a pull request.We strive to provide a welcoming community to all of our users by
abiding to theCode of Conduct.
Package: jwst-novt
The NIRSpec Observation Visualization Tool (NOVT) visualizes projected footprints
for the NIRSpec and NIRCam instruments on the James Webb Space Telescope (JWST).
It is intended to aid in planning NIRCam pre-imaging for NIRSpec MOS observations,
by allowing simultaneous display and configuration of the NIRSpec and NIRCam
fields of view for a given sky position.Available modulesThe NOVT package includes tools for calculating footprints and visibility timelines
and tools for interactively configuring and displaying them.  The dependencies for
the interactive tools are much more extensive than the core tools require, so the
package allows installation of the core tools without the optional dependencies
required by the interactive tools.See theonline documentationfor more information on the contents of the software modules.Core tools: jwst_novtThe top-level package (jwst_novt) contains lightweight interfaces to thepysiafandjwst_gtvttools to compute aperture projections by target position and
target visibility and position angle by date, respectively. This package may
be installed and used directly to create inputs for preferred visualization
tools (e.g.SAO DS9orImviz).See thenovt_toolsnotebook in thenotebooksdirectory of the source
distribution for an example of this usage.Display and interactive tools: jwst_novt.interactThejwst_novt.interactpackage contains tools to configure, visualize, and interact
with the instrument apertures and visibility timeline in a Jupyter notebook
context. A default application is provided that can be run in a local notebook
server, or as a remote web application.  STScI plans to serves this application for the
public soon.  In the meantime, the default application can be run locally by following the
installation instructions below, then running the command:$ novtSee also thenovt_interactnotebook in thenotebooksdirectory of the source
distribution for an example of using NOVT tools with the Imviz display tool in
a custom notebook.See theNOVT JDox articlefor usage information for the web application.InstallationIt is highly recommended that the user install the NOVT package into a virtual
environment.  For example, use conda to create and activate a virtual environment
before following the installation steps:$ conda create -n jwst_novt python
$ conda activate jwst_novtCore tools onlyTo install the top-level package from source via GitHub:$ git clone https://github.com/spacetelescope/jwst_novt
$ pip install -e jwst_novtTo install via pip:$ pip install jwst_novtEither method will also download and install the required software dependencies.Core tools + display and interactive toolsTo install the display and interactive tools along with the base package from
source via GitHub:$ git clone https://github.com/spacetelescope/jwst_novt
$ pip install -e jwst_novt[interact]Or via pip:$ pip install jwst_novt[interact]Either method will download and install the additional required software dependencies
for the interact module.LicenseSeeLICENSE.rstin thesource distributionfor more information.ContributingSeeCONTRIBUTING.mdin thesource distributionfor more information.
Package: jwst-proposal-helper
JWST Proposal HelperThis package provides helpers for JWST proposal preparation. (pip install jwst_proposal_helper)2020 JWST Cycle 1prepare_KN_nebular_spc function prepares a spectrum file to be in a format recognizable by JWST ETC.append_spc is a function to append a spectral profile from one dataset (ap_spc) to another (in_spc). By append, it means ap_spc would be rescaled to in_spc. The function returns values by appending rescaled ap_spc to in_spc using only the wavelength from ap_spc that is greater than in_spc.read_spc_at2017gfo is a specific function to read .dat files of AT2017gfo's spectra prepared for JWST ETC. (from jwst_proposal_helper.read_spc_at2017gfo import read_spc_at2017gfo)read_spc_even2020 is a specific function to read .dat files of Even et al. 2020's spectra of KN with Lanthanide, prepared for JWST ETC. (from jwst_proposal_helper.read_spc_even2020 import read_spc_even2020)rescale_spc is a function to rescale a spectrum. Given a spectrum (wavelength,flux), the function will compute a mean (wavelength,flux) given the bound. And, rescale the spectrum by setting the mean flux to the rescale_value by using a multiplicative factor: rescale_flux = flux * rescale_factor. (from jwst_proposal_helper.rescale_spc import rescale_spc)
Package: jwt
python-jwtpython-jwtis a JSON Web Token (JWT) implementation in Python developed byGehirn Inc.Examplesimportjsonfromdatetimeimportdatetime,timedelta,timezonefromjwtimport(JWT,jwk_from_dict,jwk_from_pem,)fromjwt.utilsimportget_int_from_datetimeinstance=JWT()message={'iss':'https://example.com/','sub':'yosida95','iat':get_int_from_datetime(datetime.now(timezone.utc)),'exp':get_int_from_datetime(datetime.now(timezone.utc)+timedelta(hours=1)),}"""
Encode the message to JWT(JWS).
"""# Load a RSA key from a JWK dict.signing_key=jwk_from_dict({'kty':'RSA','e':'AQAB','n':'...','d':'...'})# Or load a RSA key from a PEM file.withopen('rsa_private_key.pem','rb')asfh:signing_key=jwk_from_pem(fh.read())# You can also load an octet key in the same manner as the RSA.# signing_key = jwk_from_dict({'kty': 'oct', 'k': '...'})compact_jws=instance.encode(message,signing_key,alg='RS256')"""
Decode the JWT with verifying the signature.
"""# Load a public key from PEM file corresponding to the signing private key.withopen('rsa_public_key.json','r')asfh:verifying_key=jwk_from_dict(json.load(fh))message_received=instance.decode(compact_jws,verifying_key,do_time_check=True)"""
Successfuly retrieved the `message` from the `compact_jws`
"""assertmessage==message_receivedInstallationYou can install python-jwt with pip.$pipinstalljwtImplementation DetailsSupported AlgorithmsUnsecurednone (disabled by default for security)SymmetricHS256HS384HS512AsymmetricPS256PS384PS512RS256RS384RS512Supported Python VersionsPython 3.6+Licensepython-jwt is licensed under the Apache License version 2.  See ./LICENSE.rst.
Package: jwt4auth
jwt4authlibraryThis repository contains a library that implements user session, authentication,
and authorization. It is based on the use of theJWTaccess token and refresh
token.The access token is passed to the http only cookie by default, which should
protect it from theft during a cross-site scripting attack.The refresh token is passed in the body of the response on theloginandrefreshrequests. It is stored in local storage. The refresh token need for update an access
token.Currently available:Server side Python module for aiohttpTypescript client libraryReact component libraryHow to start sample application and check itThe best option is to download the repository and run an application into a virtual
environment. Run the following commands:git clone git@github.com:Alesh/jwt4auth.git
cd jwt4auth
python3.8 -m venv .venv
source .venv/bin/activate
pip install -U setuptools
pip install -U pip
pip install -U wheel
pip install nodeenv
nodeenv -p
npm install yarn -g
yarn install
yarn build
python setup.py develop
python -m sample.backend --static-path sample/buildHow to use itThere is a good example of aReactbased app frontend andaiohttpbased backend.
I hope the sample application helps you get started using this set of libraries.
For more information, see the source code, which is enough documented
Package: jwt_apns_client
JWT APNs ClientAPNs client using JWTFree software: MIT licenseDocumentation:https://jwt-apns-client.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2016-11-17)First release on PyPI.
Package: jwt-authenticator
jwt_authenticatorjwt_authenticator is a simply python library for adding JWT token authentication/authorization in flask web sites/services. It controls access either by checking for just a validated token, or optionally, a single role claim from the token. Access is controlled by decorating the endpoint functions with an attribute.InstallationUse the package managerpipto install jwt_authenticator.pipinstalljwt_authenticatorUsageIn the main application initialization areafromFlaskimportFlaskfromjwt_authenticatorimportAuthenticationHandlerAPP=Flask(__name__)AuthenticationHandler.load_configuration()In the endpointsfromjwt_authenticatorimportAuthenticationHandler,AuthError@api.route('/<name>',methods=['GET'])@AuthenticationHandler.requires_auth("admin")defget_one(name):returnf"Hello{name}"@api.route('/<name>',methods=['GET'])@AuthenticationHandler.requires_auth()defget_one(name):returnf"Hello{name}"Configurationjwt_authenticator requires two configuration values to work. These can be specified either in the normal Flask application configuration or as environment variables. Environment variable values will override application configuration values, whenAuthenticationHanlder.load_configuration()is called.APP.config (i.e. flask application configuration)SECRET - the key used to sign the JWT tokenAUDIENCE - the audience claim used in the JWT tokenEnvironment VariablesJWT_SECRET - will override SECRETJWT_AUDIENCE - will override AUDIENCEContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.BuildingRequires 'make'makeinit
maketestmakepackageLicenseMIT