Saravanan666/pypi-org huggingface dataset:
Package: jupyter-helper
QuickstartA helper for jupyter(lab/notebook/console).InstallationInstall via pip:pip install jupyter-helperOr you can use an editable install with:git clonehttps://github.com/lll9p/jupyter-helper.gitcd  jupyter-helper
pip install -e . –no-build-isolationUsageto run:from helper import Helper
helper = Helper(scope=globals())
helper.set_global_values().import_libs().run_magics().done()orhelper.done()
Package: jupyter-helpers
This collection of IPython helpers optimized for JupyterLab users will
help you to:Play a sound once the computations have finished (or failed)Integrate the notifications with your OS (ready for GNOME shell)Enable auto-completion for rpy2 (great for using ggplot2!) - now also
available injupyterlab-lspSummarize dictionaries and other structures in a nice tableSelectively import from other notebooksScroll to the recently executed cell on error or when opening the
notebookUse interactive (following) tail for long outputsThe examples are available indemosdirectory. Please, see theProductivity tips for Jupyter
(Python)article for introduction and more code samples. For jump-to-definition
feature, please visitjupyterlab-lsp.InstallationFor basic functionality:pip3installjupyter_helpersTo include interactive widgets:pip3installipywidgetsjupyterlabextensioninstall@jupyter-widgets/jupyterlab-managerTo use advanced GNOME integration, runsetup.shscript from the
installation directory (PRs welcome to propose a better setup
procedure).To check if you have required system libraries for the better GNOME
integration, seenotify-send.sh
repository.ShowcaseNotificationsNotificationsTailing outputsFollowing tailAuto-completion in R cellsR auto-completionNeat namespacesNeatNamespaceSelective importsSelective imports
Package: jupyterhub-cognitoauthenticator
JijZeptLab Cognito AuthenticatorThis is a relatively simple authenticator for small or medium-sizedJupyterHubapplications. Signup and authentication are implemented as native to JupyterHub without relying on external services.NativeAuthenticator provides the following features:New users can signup on the system;New users can be blocked from accessing the system awaiting admin authorization;Option of enforcing password security by disallowing common passwords or requiring a minimum password length;Option to block users after a set number of failed login attempts;Option of open signup without need for initial authorization;Option of asking more information about users on signup (e-mail).Option of requiring users to agree with given Terms of Service;Option of protection against scripting attacks via reCAPTCHA;Option for users with an org-internal e-mail address to self-approve via secure link;DocumentationThe latest documentation is always on readTheDocs, availablehere.Running testsTo run the tests locally, you can install the development dependencies like so:pipinstall-rdev-requirements.txtThen run tests with pytest:pytestAdd Documentneed enviroment
COGNITO_REGION : Using Cognito Reagion.
COGNITO_CLIENT_ID : Using Cognito ClientId.
COGNITO_USERPOOL_ID : Using Cognito UserPoolId.
Package: jupyterhub-crowd
JupyterHub Crowd AuthenticatorCrowdauthenticator forJupyterHub.InstallationInstall with pip:pip install jupyterhub_crowdSetupInjupyterhub_config.py, add:c.JupyterHub.authenticator_class = 'jupyterhub_crowd.Crowthenticator'
c.Crowthenticator.server_url = 'https://crowd.xxx.yyy/'
c.Crowthenticator.server_appname = 'foo'
c.Crowthenticator.server_password = 'bar'
c.Crowthenticator.username_from_email = True
Package: jupyterhub-datalaboauthenticator
datalaboauthenticatorCustom Oauthenticator to manage the Oauth2 process in thedatalab project. This authenticator gives users coming from the portal an automatic user account to access their jupyter session without having to login again in the OpenID provider.This authenticafor inherits from the Generic Authenticator and it has been tested through our internal Keycloak instance.InstallationManualDownload and install the repository inside the image used to deploy the jupyterhub session.git clone https://github.com/aidaph/datalaboauthenticator
pip install .Configuration in jupyterhub configDefine the following lines in the jupyterhub_config.py file:c.JupyterHub.authenticator_class="datalab-oauth"c.DatalabOAuthenticator.client_id='datalab-client'# oauth2 client id for your appc.DatalabOAuthenticator.client_secret='datalab-secret'# oauth2 client secret for your appc.DatalabOAuthenticator.login_service="SSO"c.DatalabOAuthenticator.authorize_url="https://sso.ifca.es/auth/realms/datalab/protocol/openid-connect/auth"c.DatalabOAuthenticator.token_url='https://sso.ifca.es/auth/realms/datalab/protocol/openid-connect/token'# oauth2 provider's token urlc.DatalabOAuthenticator.userdata_url='https://sso.ifca.es/auth/realms/datalab/protocol/openid-connect/userinfo'# oauth2 provider's endpoint with user datac.DatalabOAuthenticator.oauth_callback_url='https://{}.datalab.ifca.es/hub/oauth_callback'.format(os.environ['NAMESPACE'])c.DatalabOAuthenticator.scope=["profile","openid","email","groups"]c.DatalabOAuthenticator.userdata_params={"state":"state"}# params to send for userdata endpointc.DatalabOAuthenticator.username_claim="email"c.DatalabOAuthenticator.allowed_groups=["dummy"]c.DatalabOAuthenticator.username_key="preferred_username"# username key from json returned from user data endpointc.DatalabOAuthenticator.extra_authorize_params={"token":'{}'.format(os.environ["ACCESS_TOKEN"])}Take into account that the authenticator makes the auto_login as soon as the user comes from the portal without showing the Log in button. This behavior can be swittched off turning theDatalabOAuthenticator.auto_login" option toFalse`.
Package: jupyterhub-fancy-profiles
jupyterhub-fancy-profilesA react based, fancy implementation of user selectable profiles
for use withjupyterhub-kubespawner.FeaturesInterpret aprofileListgiven to kubespawner, and render a better looking
and more featureful selector. This includes descriptions for various options,
as well as better descriptions for allowing users to 'write-in' a choice.If enabled, interact with abinderhubdeployed as a JupyterHub service to allow users todynamicallybuild images
they want to use, without requiring it to be pre-built.LimitationsWhile multipleprofile_optionsare supported, only a singleprofileis
supported.The forms values don't remember their previous state upon refreshHow to useOnce installed, you can have kubespawner use the templates shipped
with this package to provide appropriate UI, by adding the following snippet
to yourjupyterhub_config.pyfile:fromjupyterhub_fancy_profilesimportsetup_uisetup_ui(c)Thesetup_uifunction will setup all the appropriate config as needed. Currently,
it will:Setup extra templates to be made available to kubespawner, to render the
base HTML forprofile_list.Setup extra HTTP handlers, primarily for serving our static assets.What is in here?The primary contents are:jupyterhub_fancy_profiles/templatescontains jinja2 templates, primarilyHTMLfor constructing the form itself. This can contain multiple templates
that are composed together using all of jinja2's composition features (likeinclude)src/contains JS and CSS that are packaged via standard frontend bundling
tools (webpackandbabel), outputing assets intojupyterhub_fancy_profiles/static/.
This allows us to usestandardfrontend tooling to write JS & CSS - for
example,xterm.jscan be used without many complications.Why React?/* If this file gets over 200 lines of code long (not counting docs / comments), start using a framework(from theBinderHub JS Source Code)Dear Reader, the filedidget more than 200 lines long, but alas there was no
time to start using a framework. Lesson learnt from that is we should use avery lightweightframework right from the start, something mainstream that
can attract frontend devs without being so fancy that nobody else can work on
it. Given the size and complexity of this - a complex UI but only a single page -
plain react without typescript seems the correct choice. We willnotmake
this into a super-heavy, complex application - just a fairly simple one that
uses react.
Package: jupyterhub-feishu-oauthenticator
JupyterHub FeiShu OAuthenticatorJupyterHub FeiShu Authenticator is a FeiShu OAuth authenticator built on top ofOAuthenticator.Installingjupyterhub-feishu-oauthenticator is a package available on PyPI and can be installed using pip or cloning the repository.pip3 install jupyterhub-feishu-oauthenticatoror clone the repositorygit clone https://github.com/tezignlab/jupyterhub-feishu-oauthenticator.git

cd jupyterhub-feishu-oauthenticator

pip3 install -e .Setup1、Create FeiShu Appsee feishu docCreate a custom app2、Config Your FeiShu App"Security Settings" --> "Redirect URL" --> Addhttp://[your-host]/hub/oauth_callback3、Edit JupyterHub Config Filejupyterhub_config.pyfromfeishuoauthenticatorimportFeiShuOAuthenticatorc.JupyterHub.authenticator_class=FeiShuOAuthenticatorapp_id='[your-feishu-app-id]'app_secret='[your-feishu-app-secret]'c.FeiShuOAuthenticator.authorize_url='https://open.feishu.cn/open-apis/authen/v1/index'c.FeiShuOAuthenticator.extra_authorize_params={'redirect_uri':'http://[your-host]/hub/oauth_callback','app_id':app_id}c.FeiShuOAuthenticator.client_id=app_idc.FeiShuOAuthenticator.client_secret=app_secretTeamAnoyiQiang JuHarry Wang
Package: jupyterhub-firstuseauthenticator
JupyterHub First Use AuthenticatorAJupyterHubauthenticator that helps new users set their password on their first login to JupyterHub.Are you running a workshop from a single physical location, such as a university seminar or a user group?JupyterHub First Use Authenticator can simplify the user set up for you. It's very useful when using transient
JupyterHub instances in a single physical location. It allows multiple users to log in, but you do not have install a pre-existing authentication setup. With this authenticator, users can just pick a username and password and get to work!InstallationYou can install this authenticator with:pipinstalljupyterhub-firstuseauthenticatorOnce installed, configure JupyterHub to use it by adding the following to yourjupyterhub_config.pyfile:c.JupyterHub.authenticator_class='firstuseauthenticator.FirstUseAuthenticator'ConfigurationFirstUseAuthenticator.dbm_pathPath to thedbmfile, or a UNIX database file such aspasswords.dbm, used to store usernames and passwords. The dbm file should be put where regular users do not have read/write access to it.This authenticator's default setting for the path to thepasswords.dbmis the current directory from which JupyterHub is spawned.FirstUseAuthenticator.create_usersCreate users if they do not exist already.When set to False, users would have to be explicitly created before
they can log in. Users can be created via the admin panel or by setting
whitelist / admin list.Defaults to True.FAQWhy have a password DB and not use PAM ?For security Reasons. Users are likely to set an, insecure password at
login time, and you do not want a brute-force/dictionary attack to manage to
login by attacking via ssh or another mean.How can I change my password?To change your password, you should login in your jupyterhub account,
go to<your_server_ip>/hub/auth/change-passwordand change the password.I'm getting an error when creating my usernameUsernames cannot contain spaces or commas. Please check if your username is free
of these characters.SecurityWhen usingFirstUseAuthenticatorit is advised to automatically prepend the
name of the user with a known-prefix (for examplejupyter). This would prevent
for example, someone to log-in asroot, as the created user would bejupyter-root.
Package: jupyterhub_hook_filemanager
Content Manager for Filemanager Jupyterhub with hooks supportInstallpip install jupyterhub_hook_filemanagerIn your jupyterhub config file:from jupyterhub_hook_filemanager.hook_filemanager import HookFileContentsManager

c.NotebookApp.contents_manager_class = HookFileContentsManagerc.HookFileContentsManager.pre_get_hook = your_function
c.HookFileContentsManager.post_get_hook = your_functionyour_functionshould expect anuser_objectwith attributesnamefor user login andhook_namewith hook called.So in your function:your_function(path, content, type, format, contents_manager):
    send_info(contents_manager.user.name, path)c.HookFileContentsManager.pre_update_hook = your_function
c.HookFileContentsManager.post_update_hook = your_functionyour_functionshould expect anuser_objectwith attributesnamefor user login andhook_namewith hook called.So in your function:your_function(model, path, contents_manager):
    send_info(contents_manager.user.name, path, model)c.HookFileContentsManager.pre_delete_hook = your_function
c.HookFileContentsManager.post_delete_hook = your_functionyour_functionshould expect anuser_objectwith attributesnamefor user login andhook_namewith hook called.So in your function:your_function(path, contents_manager):
    send_info(contents_manager.user.name, path)pre_save_hookandpost_save_hookare specified at default documentation:http://jupyter-notebook.readthedocs.io/en/latest/extending/savehooks.html
Package: jupyterhub-kubespawner
kubespawner(jupyterhub-kubespawner @ PyPI)Thekubespawner(also known as the JupyterHub Kubernetes Spawner) enables JupyterHub to spawn
single-user notebook servers on aKubernetescluster.See theKubeSpawner documentationfor more
information about features and usage. In particular, here isa list of all the spawner options.FeaturesKubernetes is an open-source system for automating deployment, scaling, and
management of containerized applications. If you want to run a JupyterHub
setup that needs to scale across multiple nodes (anything with over ~50
simultaneous users), Kubernetes is a wonderful way to do it. Features include:Easily and elasticly run anywhere between 2 and thousands of nodes with the
same set of powerful abstractions. Scale up and down as required by simply
adding or removing nodes.Run JupyterHub itself inside Kubernetes easily. This allows you to manage
many JupyterHub deployments with only Kubernetes, without requiring an extra
layer of Ansible / Puppet / Bash scripts. This also provides easy integrated
monitoring and failover for the hub process itself.Spawn multiple hubs in the same kubernetes cluster, with support fornamespaces. You can limit the
amount of resources each namespace can use, effectively limiting the amount
of resources a single JupyterHub (and its users) can use. This allows
organizations to easily maintain multiple JupyterHubs with just one
kubernetes cluster, allowing for easy maintenance & high resource
utilization.Provide guarantees and limits on the amount of resources (CPU / RAM) that
single-user notebooks can use. Kubernetes has comprehensiveresource controlthat can
be used from the spawner.Mount various types ofpersistent volumesonto the single-user notebook's container.Control various security parameters (such as userid/groupid, SELinux, etc)
via flexiblePod Security Policies.Run easily in multiple clouds (or on your own machines). Helps avoid vendor
lock-in. You can even spread out your cluster acrossmultiple clouds at the same time.In general, Kubernetes provides a ton of well thought out, useful features -
and you can use all of them along with this spawner.RequirementsJupyterHubRequires JupyterHub 4.0+KubernetesEverything should work from Kubernetes v1.24+.TheKube DNS addonis not strictly required - the spawner usesenvironment variablebased discovery instead. Your kubernetes cluster will need to be configured to
support the types of volumes you want to use.If you are just getting started and want a kubernetes cluster to play with,Google Container Engineis
probably the nicest option. For AWS/Azure,kopsis probably the way to go.Getting helpWe encourage you to ask questions on theJupyter mailing list.
You can also participate in development discussions or get live help onGitter.LicenseWe use a shared copyright model that enables all contributors to maintain the
copyright on their contributions.All code is licensed under the terms of the revised BSD license.ResourcesJupyterHub and kubespawnerReporting IssuesDocumentation for JupyterHubDocumentation for JupyterHub's REST APIJupyterDocumentation for Project Jupyter|PDFProject Jupyter website
Package: jupyterhub-ltiauthenticator
LTI JupyterHub AuthenticatorImplements theLTI 1.3and theLTI v1.1authenticators for use with JupyterHub.This converts JupyterHub into an LTITool Provider, which can be then easily be used with variousTool Consumers, such as Canvas, Open EdX, Moodle, Blackboard, etc.So far,ltiauthenticatorhas been tested withOpen edX,Canvas, andMoodle. Documentation contributions are highly welcome!Note that with theseLTIauthenticators going directly to the hub URL will no longer allow you to log in. Youmustvisit the hub through an appropriate LTI 1.1 compliant Tool Consumer or LTI 1.3 compliant Platform (such as Canvas, Moodle, Open edX, etc.) to be able to log in.Note: LTI 1.1 identifies the LMS as theTool Consumerand LTI 1.3 identifies the LMS as thePlatformfor all practical purposes these terms are equivalent.InstallationYou can install the authenticator from PyPI:pipinstalljupyterhub-ltiauthenticatorUsing the LTI AuthenticatorsFor detailed instructions on how to configure theLTI13AuthenticatororLTI11Authenticatorand integrate it with an LMS, such as Canvas, Open EdX, Moodle, Blackboard, etc., please take a look at thedocumentation.
Package: jupyterhub-multiauthenticator
OAuthAuthenticator + LDAP Autenticator ++... = MultiAuthenticator :heart:The MultiAuthenticator is multiplexer authenticator class that allows to use
more than one authentication option with JupyterHub.Installation$ pip install git+https://github.com/idiap/multiauthenticatorConfigurationThe MultiAuthenticator class only has one configuration point: authenticators.This property shall contain a list of tuple with the following content:Authenticator class (i.e. GitLabAuthenticator, LDAPAuthenticator)The URL scope (i.e. /gitlab, /ldap)A dictionary with the authenticator's configurationAs an example:fromoauthenticator.githubimportGitHubOAuthenticatorfromoauthenticator.googleimportGoogleOAuthenticatorfromoauthenticator.gitlabimportGitLabOAuthenticatorfromjupyterhub.authimportPAMAuthenticatorc.MultiAuthenticator.authenticators=[(GitHubOAuthenticator,'/github',{'client_id':'XXXX','client_secret':'YYYY','oauth_callback_url':'https://jupyterhub.example.com/hub/github/oauth_callback'}),(GoogleOAuthenticator,'/google',{'client_id':'xxxx','client_secret':'yyyy','oauth_callback_url':'https://jupyterhub.example.com/hub/google/oauth_callback'}),(GitLabOAuthenticator,'/gitlab',{"client_id":"ZZZZ","client_secret":"AAAAA","oauth_callback_url":"https://jupyterhub.example.com/hub/gitlab/oauth_callback","gitlab_url":"https://gitlab.example.com"}),(PAMAuthenticator,"/pam",{"service_name":"PAM"}),]c.JupyterHub.authenticator_class='multiauthenticator.multiauthenticator.MultiAuthenticator'
Package: jupyterhub-naasauthenticator
Naas AuthenticatorNaas Authenticator provides the following features:New users can signup on the system;New users can be blocked of accessing the system and need an admin authorization;Option of increase password security by avoiding common passwords or minimum password length;Option to block users after a number attempts of login;Option of open signup and no need for initial authorization;Option of open change password (open_change_password);Option of adding more information about users on signup.DocumentationDocumentation is availablehereRunning testsTo run the tests locally, you can install the development dependencies:$ pip install -e '.[dev]'Then run tests with pytest:$ pytest
Package: jupyterhub-nativeauthenticator
Native AuthenticatorThis is a relatively simple authenticator for small or medium-sizedJupyterHubapplications. Signup and authentication are implemented as native to JupyterHub without relying on external services.NativeAuthenticator provides the following features:New users can signup on the system;New users can be blocked from accessing the system awaiting admin authorization;Option of enforcing password security by disallowing common passwords or requiring a minimum password length;Option to block users after a set number of failed login attempts;Option of open signup without need for initial authorization;Option of asking more information about users on signup (e-mail).Option of requiring users to agree with given Terms of Service;Option of protection against scripting attacks via reCAPTCHA;Option for users with an org-internal e-mail address to self-approve via secure link;DocumentationThe latest documentation is always on readTheDocs, availablehere.Running testsTo run the tests locally, you can install the development dependencies like so:pipinstall-e".[test]"Then run tests with pytest:pytest
Package: jupyterhub-nomad-spawner
Nomad Jupyter SpawnerWarningThis project is currently in betaSpawns a Jupyter Notebook via Jupyterhub.Users can select and image, resource and connect it with volumes (csi / host)pipinstalljupyterhub-nomad-spawnerShow Casehttps://user-images.githubusercontent.com/1607547/182332760-b0f96ba2-faa8-47b6-9bd7-db93b8d31356.mp4TODOs:Document setupNamespace supportUsageConfigimportjsonimportosimportsocketfromjupyterhub.authimportDummyAuthenticatorimporttarfilec.JupyterHub.spawner_class="nomad-spawner"c.JupyterHub.bind_url="http://0.0.0.0:8000"c.JupyterHub.hub_bind_url="http://0.0.0.0:8081"c.JupyterHub.hub_connect_url=f"http://{os.environ.get('NOMAD_IP_api')}:{os.environ.get('NOMAD_HOST_PORT_api')}"c.JupyterHub.allow_named_servers=Truec.JupyterHub.named_server_limit_per_user=5c.JupyterHub.authenticator_class=DummyAuthenticatorc.NomadSpawner.mem_limit="2G"c.NomadSpawner.datacenters=["dc1","dc2","dc3"]Nomad Jobjob"jupyterhub"{type="service"datacenters=["dc1"]group"jupyterhub"{network{mode="host"port"hub"{to=8000static=8000}port"api"{to=8081}}task"jupyterhub"{driver="docker"config{image="mxab/jupyterhub:1"auth_soft_fail=falseargs=["jupyterhub","-f","/local/jupyterhub_config.py",]ports=["hub", "api"]}template{destination="/local/nomad.env"env=truedata=<<EOFNOMAD_ADDR=http://host.docker.internal:4646CONSUL_HTTP_ADDR=http://host.docker.internal:8500EOF}template{destination="/local/jupyterhub_config.py"data=<<EOFimport jsonimport osimport socketfrom jupyterhub.auth import DummyAuthenticatorimport tarfilec.JupyterHub.spawner_class = "nomad-spawner"c.JupyterHub.bind_url = "http://0.0.0.0:8000"c.JupyterHub.hub_bind_url = "http://0.0.0.0:8081"c.JupyterHub.hub_connect_url = f"http://{os.environ.get('NOMAD_IP_api')}:{os.environ.get('NOMAD_HOST_PORT_api')}"c.JupyterHub.log_level = "DEBUG"c.ConfigurableHTTPProxy.debug = Truec.JupyterHub.allow_named_servers = Truec.JupyterHub.named_server_limit_per_user = 3c.JupyterHub.authenticator_class = DummyAuthenticatorc.NomadSpawner.datacenters = ["dc1"]c.NomadSpawner.mem_limit = "2G"c.NomadSpawner.common_images = ["jupyter/minimal-notebook:2022-08-20"]def csi_volume_parameters(spawner):if spawner.user_options["volume_csi_plugin_id"] == "nfs":return {"gid" : "1000","uid" : "1000"}else:return Nonec.NomadSpawner.csi_volume_parameters = csi_volume_parametersdef vault_policies(spawner):return [f"my-policy-{spawner.user.name}"]c.NomadSpawner.vault_policies = vault_policiesEOF}resources{memory="512"}}service{name="jupyter-hub"port="hub"check{type="tcp"interval="10s"timeout="2s"}}service{name="jupyter-hub-api"port="api"check{type="tcp"interval="10s"timeout="2s"}}}}DevelopmentSetupGet poetry:https://python-poetry.org/docs/#installationpoetryinstallRelease
Package: jupyterhub_oauth_spawner
Spawner for OAuth authentication users. This Spawner uses same Jupyterhub user for OS operations, but you can control OAuth Users.Installpip install jupyterhub_oauth_spawnerIn your jupyterhub config file:from jupyterhub_oauth_spawner.oauth_spawner import OAuthSpawner

c.JupyterHub.spawner_class = OAuthSpawner

c.OAuthSpawner.pre_start_hook = your_function
c.OAuthSpawner.pre_stop_hook = your_function
c.OAuthSpawner.post_start_hook = your_function
c.OAuthSpawner.post_stop_hook = your_functionyour_functionshould expect anuser_objectwith attributesnamefor user login andhook_namewith hook called.So in your function:your_function(user, hook_name):
    send_info(user.name, hook_name)