Saravanan666/pypi-org huggingface dataset:
Package: serverless-local-debugger
Very convenient debugging tool for serverlessSupport:[x] AWS[x] ALIInstallpythonsetup.pysdistbdist_wheelcddist&&pip3install*.whlORpipinstallserverless-local-debuggerUsageStatic VariableDescriptionDefaultAWS_AK_ENVAWS ACCESS_KEY ENV NAMEAWS_ACCESS_KEY_IDAWS_SK_ENVAWS SECRET_KEY ENV NAMEAWS_SECRET_ACCESS_KEYAWS_ENTRYPOINTAWS Function EntrypointAWS Function EntrypointALI_AK_ENVAliyun ACCESS_KEY ENV NAMEaccessKeyIDALI_SK_ENVAliyun SECRET_KEY ENV NAMEaccessKeySecretALI_ENTRYPOINTAliyun Function EntrypointAliyun Function Entrypoint1.0.3 support ali cloud function decode1.0.4 去除AK SK 环境变了设置， 支持 ali http trigger形式More —>> SeeExamples
Package: serverlessplus
Serverless + Python简介serverlessplus是一个简单易用的工具，它可以帮助你将现有的django/flask等框架构建的应用借助API 网关迁移到腾讯云无服务云函数（Tencent Cloud Serverless Cloud Function）上。开始使用$python3-mpipinstallserverlessplus假设有如下flask应用：# app.pyfromflaskimportFlaskapp=Flask(__name__)@app.route('/')defhello():return'hello world'添加index.py作为服务的入口文件, 内容如下：# encoding: utf8fromserverlessplusimportcreate_environ,create_app,get_response,wrap_response# specify entrypoint, `${file_name}:${callable_object}`APP='app:app'app=create_app(APP)defmain_handler(event,context):environ=create_environ(event,context)response=get_response(app,environ)returnwrap_response(response,{'binary_mime_types':['image/png']})示例flask 示例django 示例支持的框架serverlessplus被设计为通过WSGI与框架进行交互. 理论上, 只要框架支持WSGI, 就可以使用serverlessplus路线图更多 Web 框架的支持与测试serverlessplus处于活跃开发中，API可能在未来的版本中发生变更，我们十分欢迎来自社区的贡献，你可以通过 pull request 或者 issue 来参与。
Package: serverless-sdk
serverless-sdkServerless ConsoleSDK for PythonUse caseEnvironment agnosticServerless Consoleinstrumentation functions for Python applications.This library is safe to use without side-effects in any Python application. It becomes effective once (one of the listed below) environment specific SDK is loaded on top.Environment extensionsAWS Lambda-serverless-aws-lambda-sdkInstallationpipinstallserverless-sdkUsagefromsls_sdkimportserverlessSdkprint(serverlessSdk.name)print(serverlessSdk.version)serverlessSdk.capture_error(Exception("Unexpected"))Setup1. Register withServerless Console2. Initialize and setup SDK specific to your enviromentSeeEnvironment extensions2.1 Configuration optionsCommon options supported by all environments:SLS_ORG_ID(ororg_id)Required setting. Id of your organization in Serverless Console.SLS_DISABLE_HTTP_MONITORING(ordisable_http_monitoring)Disable tracing of HTTP and HTTPS requests. SeeHTTP instrumentationSLS_DISABLE_REQUEST_RESPONSE_MONITORING(ordisable_request_response_monitoring)(Dev mode only) Disable monitoring requests and reponses (function, AWS SDK requests and HTTP(S) requests)SLS_DISABLE_FLASK_MONITORING(ordisable_flask_monitoring)Disable automated flask monitoring. Seeflask app instrumentationSLS_DISABLE_CAPTURED_EVENTS_STDOUT(ordisable_captured_events_stdout)Disable writing captured events registered via.capture_errorand.capture_warningto stdoutInstrumentationThis package comes with instrumentation for following areas.Note: instrumentation is enabled via environment specific SDK instance, relying just onserverless-sdkdoesn't enable any instrumentation)HTTP(s) requestsflask appPython logging moduleAPIserverlessSdk
Package: serverless-sdk-schema
Serverless SDK SchemaThis is the auto generated Python package from the Serverless Protobufs. Serverless uses Protobufs as the required format for all instrumentation libraries that communicate with the Serverless Platform.BuildTo build the sdk-schema package from source, follow these steps:# cd to the root directory of repopython3.9-mvenv.venvsource.venv/bin/activate

brewinstallprotobuf
brewinstallbufbuild/buf/bufcd./proto
bufbuild
bufgenerate--template=buf.gen.python.yamlcd../python/packages/sdk-schema
pipinstall.--target=./dist
python-mbuild--wheel--sdist.Unit testsTo run the unit tests, replace the last two steps of theBuildstep with these:pipinstall'.[tests]'python3-mpytest
Package: serverless-thrift
Thrift serverless library for PythonThis package provides an implementation of a Thrift client and server over serverless functions
for PythonInstallationFrom your project directory:pipinstallserverless-thriftGetting started (AWS Lambda)Simply use thecreateLambdaServerfunction to wrap your Thrift handler:from serverless_thrift.server.TLambdaServer import TLambdaServer
from calulator_handler import CalculatorHandler
handler = CalculatorHandler()
processor = Calculator.Processor(handler)
server = TLambdaServer(processor)A full example is located under theexampledirectory
Package: serverlessworkflow.sdk
Serverless Workflow Specification - Python SDKProvides the Python API/SPI for theServerless Workflow SpecificationWith the SDK you can:Programmatically build workflow definitionsParse workflow JSON and YAML definitionsValidate workflow definitionsStatusCurrent sdk version conforms to theServerless Workflow specification v0.8.Install dependencies and run testPython 3 requiredpipenv requiredpip install pipenvpipenv install --dev 

pipenv shell

python setup.py pytestProgrammatically build workflow definitionsworkflow = Workflow(
        id="greeting",
        name="Greeting Workflow",
        description="Greet Someone",
        version='1.0',
        specVersion='0.8',
        start="Greet",
        states=[
            OperationState(
                name="Greet",
                type="operation",
                actions=[
                    Action(
                        functionRef=FunctionRef(
                            refName="greetingFunction",
                            arguments={
                                "name": "${ .person.name }"
                            }
                        ),
                        actionDataFilter=ActionDataFilter(
                            results="${ .greeting }"
                        )
                    )
                ],
                end=True
            )
        ],
        functions=[
            Function(name="greetingFunction",
                     operation="file://myapis/greetingapis.json#greeting")
        ]
    )You can see a full example in thetest_workflow.pyfileParse workflow JSON and YAML definitionsConvert from JSON or YAML sourceswf_content = """id: greeting
name: Greeting Workflow
version: '1.0'
description: Greet Someone
specVersion: '0.8'
start: Greet
states:
- name: Greet
  type: operation
  actions:
  - functionRef:
      refName: greetingFunction
      arguments:
        name: ${ .person.name }
    actionDataFilter:
      results: ${ .greeting }
  end: true
functions:
- name: greetingFunction
  operation: file://myapis/greetingapis.json#greeting
"""
  workflow = Workflow.from_source(swf_content)You can see a full example in thetest_workflow.pyfileParse workflow to JSON / YAMLworkflow = Workflow(id_="greeting",
                    name="Greeting Workflow",
                    description="Greet Someone",
                    version='1.0',
                    specVersion='0.8',
                    start="Greet",
                    states=[],
                    functions=[]
)                
print(workflow.to_json())
print(workflow.to_yaml())You can see a full example in thetest_workflow.pyfileValidate workflow definitionsworkflow = Workflow(id_="greeting",
                    name="Greeting Workflow",
                    description="Greet Someone",
                    version='1.0',
                    specVersion='0.8',
                    start="Greet",
                    states=[],
                    functions=[]
)
WorkflowValidator(Workflow(workflow)).validate()Thevalidatemethod will raise an exception if the provided workflow does not complaint specification.You can see a full example in thetest_workflow_validatorfile
Package: serverlla
serverllaConfigure your linux server and check for vulnerabilities with serverlla.Serverlla has a menu with options and allows you to configure your server through that menu but you can also import the adminserver module in another file.Pre-requirementsThe requirements to use the system is to have the following python modules installed:colorama
requestsThe apt packages that you must have installed are:curl
wget
net-tools 
strace 
iftop 
lsof 
chkrootkit 
inxi 
lshw 
git 
python3 
python3-pip 
build-essential 
libssl-dev 
libffi-dev 
python3-devInstallationTo install serverlla on linux run these commands on your Linux Terminal.pip3installserverllaOnce done, it begins to install.to start serverlla you just have to put theserverllacommand in the terminal.ReadyUsage:To use the serverlla command you just have to put theserverllacommand, and once that is done the system menu will be loaded.Custom scriptIf you want to create your own menu and your own code using the adminserver module you must do the following:importadminserverasserverserver.systeminfo()# Shows you system informationserver.verifylogin()# Check who logged inserver.addnewuser()# Add new users# Removing information from my websitelink="127.0.0.1"server.scanweb(link)# Get information from a websiteAuthorsDylan Meca-Initial Work-dylanmecaYou can also look at the list of allcontributorswho have participated in this project.ContributingPlease readCONTRIBUTING.mdfor details of our code of conduct, and the process for submitting pull requests.LicenseThe license for this project isMIT
Package: server-manager
Server manageris a simple server monitoring web dashboard with a couple of management features.InstallationWith pippip install server-managerBuild from sourcegit clone https://gitlab.com/serverman-group/serverman
cd serverman
python -m build
pip install .Running the dashboardTo run the dashboard you have to use gunicorn (installed as a dependency)run syntax:python -m gunicorn -b host:port servermanager.wsgi:appif you have gunicorn installed as a system-wide package you can simply usegunicornremovingpython -mrun command example:python -m gunicorn -b 0.0.0.0:8080 servermanager.wsgi:appExplanationpython -mruns a python package, in this casegunicorn, the-bflag specifies bind,--bind can also be used, this binds thewsgiserver to a certain host and port, in this case0.0.0.0and port8080.The host0.0.0.0is used so the server can be accessible network wide.
The port really can be specified to anything except ports like80or443, that require escalated
privileges. For the server to be accessible on port80or443both theflaskandgunicorndocumentations
recommend using a reverse proxy likeapache httpdandnginx.Accessing the webpageTo see the webpage simply go to ip address of the device the dashboard is running on.example:localhost:8080or192.168.xx.xx:8080. If you are using a reverse proxy setup as mentioned before
you can access the dashboard from the reverse proxy server ip and port (this can be the same machine running the dashboard)
, make sure that if the reverse proxy server and the dashboard are running on the same machine, they are not running on the same port.Once you open the webpage you will see this:This is the start page of the serverman dashboard.
Once you navigate to one of the links you will be prompted to log in:In this login page you are required to log in as one of the system users with their username and password
to proceed with the server's monitoring and management.After the login the links do not redirect you to login anymore and you can start monitoring. The login system
is session based and made with flask-login.This app features adashboardsettingsprocess managementpage.Short description for each pageDashboardThe dashboard page provides the ability to view system metrics like cpu clock speed, memory and swap usage.Systime blockDashboard settingsThe dashboard settings page or justsettingsallows you to make simple adjustments to what the dashboard page displays.
The page also allows the the interval at witch the information to be updated.
This can really help lower end systems like older raspberry pi's.ProcessesThe processes tab shows the currently running processes and also kill them.The update interval of the processes table can also be adjusted in the settings page.
Package: servermgr
Servermgr is a collection of classes that make it easier to manage external programs that are running for the sole benefit of your application.Sample use cases:Your program wants to run its own copy of Postgres with a separate data directory on its own port;Your program wants to control its own dedicated copy of Nginx to use as a front-end;In either of these cases, there is no need to configure multiple programs to run your application -
you can simply configure the appropriate server manager object and go!
Package: servermon
servermonServermon is a Django project with the aim of facilitating server monitoring
and management through Puppet.Servermon at this point offers two applicationsA Web frontend to the Puppet database.hwdoc: A simple datacenter hardware documentation databaseIf you have no idea what Puppet is, it is possible that you don’t need
this software. Do note however that hwdoc will still be usable even
without a Puppet infrastructureCompatibilityFor an up to date list of the Django version we support, take a look into
requirements.txt. Those are the version tested and developed forInstallGet the python modules:pipinstall-rrequirements.txtCopy servermon/settings.py.dist to servermon/settings.pySee doc/install.rst for details../manage.pysyncdb./manage.pymigrateRun!./manage.pyrunserverMore details in theinstallation tutorial.DocumentationThe documentation is maintained using Sphinx (under /doc/) and is automatically
generated athttps://servermon.readthedocs.org/.DemoDemo athttp://servermon.herokuapp.com
Package: servermonitor
Installation# pip install servermonitorUsage examplesimport servermonitor# Maintain the config file# Mention the server details in the excel sheet# Mention the mount point and command for the server# Mention the Path(s) and file(s) for the house-keeping# Perform the housekeeping based on the disk usage# Save the server statistic details in the output excel file# Check the logs for operational processesCompatibilityPython 2 Tested: Python 2.6+
servermonitor Tested: UnixAuthorCreated by chandresh soni <chndsoni00@gmail.com> in 2017
Package: serverpath
Platform-independent server-share path discovery.To install:pip install serverpathExamples:from serverpath import get_path

# from Windows machine without mapped network drive
get_path("server", "share")
>>> \\server\share

# from Windows machine with mapped network drive X
get_path("server", "share")
>>> X:\\

# from Windows machine where server is local machine and drive D is shared over network 
get_path("my-computer", "share")
>>> D:\\

# from Unix machine with Samba mount in /mnt without share
get_path("server")
>>> /mnt/server

# from Unix machine with Samba mount in /mnt with share
get_path("server", "share")
>>> /mnt/server/share

# from Unix machine with mount in custom path
get_path("server", "share", unix_path_prefix="/mymount")
>>> /mymount/server/share
Package: serverPKI
serverPKI is a tool to issue and distribute SSL certificates for internet
servers. Distribution to target hosts and reloading of server configuration
is done via ssh/sftp. Configuration and cert/key data is stored in a relational
database.serverPKI includes support forlocal CALetsEncrypt CA (supports only acme v2 api, seehttps://letsencrypt.org/docs)FreeBSD service jails via ssh access to hostpublishing of DANE RR in DNS, using BIND 9 and TLSA key rollover (see RFC 6698)controlling DNS zone info for LetsEncrypt challenges und TLSA RR via dynamic
DNS updates (recommended) or via zone files.unattended operation via cronjobextensive loggingalerting via mailRequired packages:PostgreSQLRequired Python3 packages:configobj>=5.0.6,
cryptography>=2.9.2,
automatoes>=0.9.5,
dnspython>=1.16.0,
py-postgresql>=1.2.1,
paramiko>=2.4.2,
prettytable>=0.7.2,
iso8601To install the development version,pip install-egit+https://github.com/mc3/serverPKI/#egg=serverPKI.Additional requirements for testing:pytest>=5.4.3
pytest-console-scripts>=0.2.0
pytest-cov>=2.10.0
pytest-pycharm>=0.6.0
pytest-runner>=5.2
Package: server-reloader
Server Reloader===============It is common task in all web frameworks — to provide an easy way to reload developmentserver on code changes. Most of these frameworks are carrying a reloader's code withthemselves. And there isn't any python module, simple enougth to use in a small project.Some times ago, I started to write a chat bot called [TheBot][] and begun to look fora separate server reloader's implementation. And found nothing suitable.Then, I extracted autoreloader from the Django's codebase and put it into a separatemodule, which README you are reading now. Code was partly modified, now it allowsnot only to watch on file changes but also to reload upon a some event.Reload on some event is a quite useful feature for [TheBot][], because now he can updatehimself on a push to the GitHub. A pseudocode for this procedure will look like:def on_push_to_the_github_master_branch():make_git_pull()run_pip_install()trigger_code_reload()And I don't need an external watcher to run bot, because now he uses [server-reloader][].Example usage-------------Here is a simple example, how to use a reloader.```pythondef run_server():"""Some function, which creates and runs your server."""passdef main():server_reloader.main(run_server,before_reload=lambda: print('Reloading code…'))if __name__ == '__main__':main()```If you want to trigger code reloading on some custom event, then just do:```pythonfrom server_reloader import trigger_reloadtrigger_reload()```Credentials-----------Many thanks to original authors of the autoreloader, I took as the basis.[TheBot]: http://github.com/svetlyak40wt/thebot[server-reloader]: http://github.com/svetlyak40wt/server-reloader
Package: serverseeker
ServerSeeker Python WrapperThis is a Python wrapper forServerSeekerdesigned to be used as aCLI. The original API was written by a user going byDAMand theAPI documentationcan be found here:LinkInstallationInstallation bypipwill be supported in the near future. However, for right now: you can download the.exefile found on thereleasestab and drag it to a folder that is added to the PATH environment variable.QuickstartAPI Keyserverseeker auth <api_key>will configure your API key. This information is stored locally and the credentials are not sent to anybody./whereisNow tryserverseeker whereis <username> [--copy]to search players via username orserverseeker whereis <uuid> --uuid [--copy]to search players via UUID (remember the--uuidoption!)For example:serverseeker whereis 069a79f4-44e9-4726-a5be-fca90e38aaf5 --uuidwhich can be substituted withserverseeker whereis NotchYou can append the--copyoption to any API call command (i.e. all commands except forserverseeker auth <api_key>) to copy the response to your clipboard if it gets very long./server_infoNow tryserverseeker info <ip> <port: 25565> [--copy]. Theportargument is 25565 by default, therefore it is optional.For example:serverseeker info 109.123.240.84 --copywill copy the returned information about109.123.240.84:25565to your clipboard./serversNow tryserverseeker search <online_players: [0, "inf"]> <max_players: [0, "inf"]> <protocol: 764> <online_after: 0> <software: "any"> <country_code: ""> <description: ""> [--cracked] [--copy]. Append the--crackedoption to search for cracked servers
Package: server-templates
server_templates (v0.2.1)DESCRIPTION_SHORTtemplates for serversDESCRIPTION_LONGdesigned for keep all servers templates in one placeFeaturesserver_aiohttpclient_requests item+stackLicenseSee theLICENSEfile for license rights and limitations (MIT).Release historySee theHISTORY.mdfile for release history.Installationpip install server-templatesImportfromserver_templatesimport*USAGE EXAMPLESSee tests and sourcecode for other examples.1. example1.pyimportserver_templatesimportpathlibimporttimeserver=server_templates.ServerAiohttpBase()server.start()server.wait()
Package: server-thread
⚙️ Server ThreadLaunch a WSGI or ASGI Application in a background thread with werkzeug or uvicorn.This application was created forlocaltileserverand provides the basis for how it can launch an image tile server as a
background thread for visualizing data in Jupyter notebooks.While this may not be a widely applicable library, it is useful for a few
Python packages I have created that require a background service.🚀 UsageUse theServerThreadwith any WSGI or ASGI Application.Start by creating a application (this can be a flask app or a simple app
like below):# Create some WSGI ApplicationfromwerkzeugimportRequest,Response@Request.applicationdefapp(request):returnResponse("howdy",200)Then launch the app with theServerThreadclass:importrequestsfromserver_threadimportServerThread# Launch app in a background threadserver=ServerThread(app)# Perform requests against the server without blockingrequests.get(f"http://{server.host}:{server.port}/").raise_for_status()⬇️ InstallationGet started withserver-threadto create applications that require a
WSGIApplication in the background.🐍 Installing withcondaConda makes managingserver-thread's dependencies across platforms quite
easy and this is the recommended method to install:condainstall-cconda-forgeserver-thread🎡 Installing withpipIf you prefer pip, then you can install from PyPI:https://pypi.org/project/server-thread/pip install server-thread💭 FeedbackPlease share your thoughts and questions on theDiscussionsboard.
If you would like to report any bugs or make feature requests, please open an issue.If filing a bug report, please share a scoobyReport:importserver_threadprint(server_thread.Report())🚀 ExamplesMinimal examples for usingserver-threadwith common micro-frameworks.💨 FastAPIfromfastapiimportFastAPIapp=FastAPI()@app.get("/")defroot():return{"message":"Howdy!"}server=ServerThread(app)requests.get(f"http://{server.host}:{server.port}/").json()⚗️ FlaskfromflaskimportFlaskapp=Flask("testapp")@app.route("/")defhowdy():return{"message":"Howdy!"}server=ServerThread(app)requests.get(f"http://{server.host}:{server.port}/").json()
Package: server-timing-profiler
# HTTP Server-Timing for Python FlaskThis is a library including middleware for using[HTTP Server-Timing](https://www.w3.org/TR/server-timing) with Python. This headerallows a server to send timing information from the backend, such as databaseaccess time, file reads, etc. The timing information can be then be inspectedin the standard browser developer tools:![Server Timing Example](https://github.com/PammyS/server-timing-profiler/blob/master/example/ScreenShot.png)## Features* Middleware for injecting the server timing into the request `Context`and writing the `Server-Timing` header.* Concurrency-safe structures for easily recording timings of multipleconcurrency tasks.* Parse `Server-Timing` headers as a client.* Note: No browser properly supports sending the Server-Timing header asan [HTTP Trailer](https://tools.ietf.org/html/rfc7230#section-4.4) sothe Middleware only supports a normal header currently.## Browser SupportBrowser support is required to **view** server timings easily. Because servertimings are sent as an HTTP header, there is no negative impact to sendingthe header to unsupported browsers.* **Chrome 65 or higher** is required to properly display server timingsin the devtools.## UsageExample usage is shown below. A fully runnable example is available inthe `example/` directory.```pythonfrom flask import Flask, jsonifyimport timefrom profiler.profile_manager import ProfileManagerapp = Flask(__name__)profiler = ProfileManager(app, 'debug')@app.route("/test", methods=["GET"])def hello():print 'test start sleep'profiler.start('App 1')time.sleep(1)profiler.stop('App 1')profiler.start('App 2')time.sleep(2)profiler.stop('App 2')profiler.start('App 3')time.sleep(3)profiler.stop('App 3')profiler.start('App 4')time.sleep(4)profiler.stop('App 4')print 'test stop sleep'return jsonify({'success':True})app.run(host="0.0.0.0",port=8080,debug=True)```