Saravanan666/pypi-org huggingface dataset:
Package: pyramid_rpc
pyramid_rpcis a package of RPC related add-on’s to make it easier to
create RPC services.frompyramid.configimportConfiguratorfrompyramid_rpc.jsonrpcimportjsonrpc_method@jsonrpc_method(endpoint='api')defsay_hello(request,name):return'hello,%s!'%namedefmain(global_conf,**settings):config=Configurator(settings=settings)config.include('pyramid_rpc.jsonrpc')config.add_jsonrpc_endpoint('api','/api')config.scan(__name__)returnconfig.make_wsgi_app()if__name__=='__main__':fromwsgiref.simple_serverimportmake_serverapp=main({})server=make_server('',8080,app)server.serve_forever()Support and DocumentationSee thepyramid_rpc websiteto view
documentation, report bugs, and obtain support.Licensepyramid_rpcis offered under the BSD-derivedRepoze Public License.Authorspyramid_rpcis made available byAgendaless Consultingand a team of contributors.
Package: pyramids
English Language Semantic ExtractionCopyright (c) Aaron Hosford 2011-2015Available under theMIT LicensePyramids gets its name from the way it constructs parse trees, working
upwards from the leaves towards the root, building up layers of
progressively smaller size but greater scope. It is a rule-based natural
language parser, tailored specifically for English, which builds
multiple competing parses for a sentence from the bottom up using
principles of dynamic programming. The parses are then scored for
quality and presented in order of descending rank. The parser is also
capable of accepting feedback as to which parses are or are not
acceptable, adaptively adjusting its scoring measures to improve future
parse quality and ranking. Parses are returned as trees but can also be
used to generate graphs representing the semantic relationships between
words. The syntactic rules of the parser can also be run in reverse to
generate sentences from semantic graphs resembling those it produces.
Package: pyramid_sacrud
pyramid_sacrudDocumentationhttp://pyramid-sacrud.readthedocs.org/OverviewPyramid CRUD interface. Provides an administration web interface for Pyramid.
Unlike classic CRUD,pyramid_sacrudallows overrides and flexibility to
customize your interface, similar todjango.contrib.adminbut uses a
different backend to provide resources.New Architecturebuilt on the resources and mechanism traversal, allows to use it in various
cases.The list of standard backends:ps_alchemy- provides SQLAlchemy
models.ps_mongo - provides MongoDB.etc..Look how easy it is to use with Pyramid and SQLAlchemy:from.modelsimport(Model1,Model2,Model3,)# add SQLAlchemy backendconfig.include('ps_alchemy')# add sacrud and project modelsconfig.include('pyramid_sacrud')settings=config.registry.settingssettings['pyramid_sacrud.models']=(('Group1',[Model1,Model2]),('Group2',[Model3]))go tohttp://localhost:6543/sacrud/And see…Example can be found herehttps://github.com/sacrud/ps_alchemy/tree/master/exampleInstallingpipinstallpyramid_sacrudSupport and DevelopmentTo report bugs, use theissue tracker.We welcome any contribution: suggestions, ideas, commits with new futures,
bug fixes, refactoring, docs, tests, translations etcIf you have question, contact mesacrud@uralbash.ruor IRC channel #sacrudLicenseThe project is licensed under the MIT license.0.3.3 (2016-03-15)Moved CRUD part tops_crud0.3.2 (2016-02-07)rename CONFIG_MODELS to CONFIG_RESOURCESmake GroupResource as default parentadd exampe with custom resource0.3.1 (2016-01-08)add paginate>=0.5.0 version to requirements.txt (see #117)0.3.0 (2016-01-07)New resources architecturemove SQLAlchemy handler to separate moduleps_alchemymigrate test to py.test (#102 issue)
Package: pyramid-saml
Pyramid SAMLThis is a small library usingOneLogin's SAML Python Toolkitto provide authentication and authorization via SAML for thePyramid Web Framework.For futher information, please refer to thedocumentation.Changelog0.0.2Overwrite SAML request parameters using environment variablesDrop support for Python 3.6Add support for Python 3.100.0.1Initial version
Package: pyramid_scales
pyramid_scalesThe excellentscaleslibrary to collect in-process metrics (see Coda Hale’s
CodeConf talk “Metrics everywhere” among many others for reasons why you
might want use it) comes with aflask-based HTTP server that allows viewing
the collected measurements and dumping them as JSON. But if you already are in
a web application usingpyramid, there’s no real need to spin up yet another
thread, open another port etc. to do this.Instead, you can simply includepyramid_scaleslike so:import pyramid.config
config = pyramid.config.Configurator()
# rest of your configuration goes here
config.include('pyramid_scales')This registeres a view below the URL/scales/where you can view your
application’s metrics. If you need more control, register thepyramid_scales.scales_statsview yourself in whichever way you need.This package is compatible with Python version 2.7 (scales itself does not
support Python3 yet, so there’s no point here).Developing pyramid_scalesAuthor:Wolfgang Schnerring <wosc@wosc.de>PyPI page:https://pypi.python.org/pypi/pyramid_scalesIssues:report via e-mailSource code:https://github.com/wosc/pyramid_scalesChange log for pyramid_scales1.1.1 (2018-11-07)Make current-setuptools compatible1.1 (2015-02-03)Make Python3 compatible (patch by Hynek Schlawack)1.0 (2013-11-06)initial release
Package: pyramid_scss2
pyramid_scssOverviewThis module provides a convenient bit of glue code aroundpyScss, allowing your Pyramid projects to use stylesheets authored inSCSS.InstallationInstall using setuptools, e.g. (within a virtualenv):$ pip install pyramid_scssOr if you prefer to get the latest from Github:$ git clone git://github.com/jessedhillon/pyramid_scss.gitConfigurationThe only setting which is necessary isasset_pathwhich is an asset spec which points to the root folder where your SCSS stylesheets are. An easy way to set that is to add this line to the[app:main]section of yourproject.ini:scss.asset_path = myproject:assets/scssasset_pathcan be a newline delimited string of multiple asset paths. Each path will be searched, in order, until the matching stylesheet is found. An unmatched request will raisepyramid.httpexceptions.HTTPNotFound.static_pathis a path to the static assets (images mainly) necessary to construct a stylesheet. Unlikeasset_path, this setting only accepts one path, and because of this,asset_pathwill be renamed toasset_pathsin the future.There are a couple of other options.compresscontrols whether or not the output documents are compressed (all whitespace stripped):scss.compress = falseThe other option iscache, which will store both the contents of the file and the rendered output in memory:scss.cache = trueUsageFirst, useconfig.includeto initialize the extension:config.include("pyramid_scss")Second, assuming you are using URL dispatch, add a route to serve css:config.add_route('css', '/css/{css_path:.*}.css')
config.add_view(route_name='css', view='pyramid_scss.controller.get_scss', renderer='scss', request_method='GET')TODO:Add a traversal example.In the example above, an SCSS stylesheet located atmyproject/assets/scss/style.scss(using theasset_pathconfigured in the Configuration section) could be accessed by a URL request tohttp://myproject/css/style.css. This route would also resolve stylesheets in subdirectories ofasset_path.Change Log0.11 Feb 2012Initial public release.0.1.13 Feb 2012Fixedissue #1: @import could not resolve paths relative toasset_path.0.219 Feb 2012Fixedissue #3: caching implementation was incomplete/incorrect.Addedstatic_pathconfiguration for indicating location of static assets.0.2.230 Jan 2013Complete upload of code that actually fixesissue #3.0.3.028 Feb 2013Support pyScss 1.1.5 (code move)Fix broken renderer tests (n issues)
Package: pyramid-secure-response
pyramid_secure_responseis a library built on top of the Pyramid Tween to
provide secure response.TweensSSL Redirects (ssl_redirect)HTTP Strict Transport Security Header (hsts_support)HTTP Content Security Policy Header (csp_coverage)Change LogsTue 16 Jan 2018 Yasuhiro Asaka <yasuhiro.asaka@grauwoelfchen.net>Bump version v0.1.3Make csp_coverage tween available by defaultUpdate long_descriptionBump version v0.1.2Update package descriptions (setup.py, doc/DESCRIPTION.rst)Bump version v0.1.1Add csp_coverage (HTTP CSP Header support) tweenTue 09 Jan 2018 Yasuhiro Asaka <yasuhiro.asaka@grauwoelfchen.net>Bump version v0.1.0Make configuration as separated by tweenFri 10 Nov 2017 Yasuhiro Asaka <yasuhiro.asaka@grauwoelfchen.net>Bump version v0.0.4Add Python 2.7 support (Make type hints as comment)Thu 09 Nov 2017 Yasuhiro Asaka <yasuhiro.asaka@grauwoelfchen.net>Bump version v0.0.2, v0.0.3Update package description and classifiersEnable HSTS Header only for ssl requestAdd test case for X-Forwarded-Proto useWed 08 Nov 2017 Yasuhiro Asaka <yasuhiro.asaka@grauwoelfchen.net>Covret README.adoc to README.rstAdd .gitlab-ci.ymlTue 07 Nov 2017 Yasuhiro Asaka <yasuhiro.asaka@grauwoelfchen.net>Initial commit ;)
Package: pyramid_selectable_renderer
this is dirty implementation.## how to use- define selectable renderer.- using selectable renderer as renderer factory- using selectable renderer with view_config settings### sample## define selectable rendererfrom pyramid_selectable_renderer import SelectableRendererSetupfrom pyramid_selectable_renderer.custom import ReceiveTemplatePathCandidatesDictfrom pyramid_selectable_renderer.custom import SelectByRetvalLeftGenValidateTrueOrNot = SelectableRendererSetup(ReceiveTemplatePathCandidatesDict,SelectByRetvalLeftGen.generate(lambda x : x),renderer_name = "validate_true_or_not")## in __init__.pydef includeme(config):ValidateTrueOrNot.register_to(config) # enable to use selectable renderer## in view.py@view_config(route_name="sample.confirm",renderer=ValidateTrueOrNot({True: "foo:success.pt", False: "foo:failure.pt"}))def form_confirm_view(context, request):form = ValidateForm(request.POST):return form.validate(), {"form": form}
Package: pyramid-sendgrid-webhooks
Parses incoming Sendgrid Webhooks in Pyramid  appsFree software: MIT licenseDocumentation:https://pyramid_sendgrid_webhooks.readthedocs.org.FeaturesTo use this app, add a configuration statement with your intended webhook
callback path:config.include('pyramid_sendgrid_webhooks','/sendgrid/webhooks')Then, set up subscribers for any events that you want to be notified of:frompyramid_sendgrid_webhooksimporteventsdefhandle_bounce(event):request=event.requestprintevent.reason...config.add_subscriber(handle_bounce,events.BounceEvent)Currently the app adds a single endpoint at{PREFIX}/receive.  This will be
the webhook path to give to Sendgrid.  In the example above, the full endpoint
would therefore be at/sendgrid/webhooks/receive.CreditsTools used in rendering this package:Cookiecuttercookiecutter-pypackageHistory1.2.2 (2015-12-15)Updating documentation with modules1.2.1 (2015-12-15)Update trove classifiers1.2.0 (2015-12-14)Correct package listing in setup.py1.0.0 (2015-12-07)First release on PyPI.
Package: pyramid-services-autowire
An autowire utility forpyramid_services.before:class IService(Interface):
    pass

class Service(object):
    def __init__(self, dep_svc1=None, dep_svc2=None, dep_svc3=None):
        self.dep_svc1 = dep_svc1
        self.dep_svc2 = dep_svc2
        self.dep_svc3 = dep_svc3

def includeme(config):
    config.include('pyramid_services')
    def factory(context, request):
        svc = Service(
            dep_svc1=request.find_service(IDependService1),
            dep_svc2=request.find_service(IDependService2),
            dep_svc3=request.find_service(IDependService3),
        )
        return svc
    config.register_service_factory(factory, IService)after:from pyramid_services_autowire import Autowire

class IService(Interface):
    pass

class Service(object):
    dep_svc1 = Autowire(IDependService1)
    dep_svc2 = Autowire(IDependService2)
    dep_svc3 = Autowire(IDependService3)

def includeme(config):
    config.include('pyramid_services_autowire')
    config.register_autowire(Service, IService)Change History0.1.1 - 2018-06-09fixes relase date.0.1 - 2018-06-09Initial release.
Package: pyramid-services-sqlalchemy
SQLAlchemy factories forpyramid_services.This module provides removingSQLAlchemy’s boiler plates
from yourpyramidapplication codes.In yourpastedeploy.ini:sqlalchemy.url = ENGINE://DBUSER:PASSWORD@DBHOST/DBNAMEIn your application factory:config.include('pyramid_services_sqlalchemy')In your views:from pyramid_services_sqlalchemy import get_tm_session

def aview(request):
    db = get_tm_session(request)or you can userequest.find_service:from pyramid_services_sqlalchemy import IDBSession

def aview(request):
    db = request.find_service(IDBSession)If you want to use multiple connections,pastedeploy.ini:sqlalchemy.names = readonly readwrite
sqlalchemy.readonly.url = ENGINE://READ_DBUSER:PASSWORD@DBHOST/DBNAME
sqlalchemy.readwrite.url = ENGINE://WRITE_DBUSER:PASSWORD@DBHOST/DBNAMEand in your views:from pyramid_services_sqlalchemy import get_tm_session

def aview(request):
    db = get_tm_session(request, name='readonly')

def a_write_view(request):
    db = get_tm_session(request, name='readwrite')Change History0.1.1 - 2018-08-11Update README0.1 - 2018-08-11Initial release.
Package: pyramid-services-viewmapper
pyramid_services_viewmapperAn extension for the Pyramid web framework.pyramid_services_viewmapperprovides aview mapperfor use in conjunction withpyramid_services.
It extends the functionality ofpyramid_servicesto providedependency
injection: you can add custom arguments to your view functions, and
the view mapper will automatically populate those arguments with matching
services.SetupRegister the view mapper in yourConfigurator:from pyramid_services_viewmapper import ServiceViewMapper
config.set_view_mapper(ServiceViewMapper)UsageServices registered by interface alone are injected by a simple type
annotation. For example this...@view_config(route_name="home", renderer="json")
def home(request, login_svc: ILoginService):
    token = login_svc.create_token_for_login(name)
    return {"access_token": token}...is equivalent to this:@view_config(route_name="home", renderer="json")
def home(request):
    login_svc = request.find_service(ILoginService)
    token = login_svc.create_token_for_login(name)
    return {"access_token": token}Services registered by name can be injected using aServiceInjectorobject.
For example this...from pyramid_services_viewmapper import ServiceInjector as S

@view_config(route_name="users", renderer="json")
def users(request, db: S(name="db")):
    users = db.query(User)
    return {"users": users}...is equivalent to this:@view_config(route_name="users", renderer="json")
def users(request):
    db = request.find_service(name="db")
    users = db.query(User)
    return {"users": users}TheServiceInjectorclass can be used as a shortcut for this:from pyramid_services_viewmapper import ServiceInjector as S

@view_config(route_name="users", renderer="json")
def users(request, db: S):
    users = db.query(User)
    return {"users": users}
Package: pyramid_settings
pyramid_settings================`pyramid_settings` is simplest package (2 functions to be fair) that enablesyou to load python modules as pyramid settings files.TL;DR; You can ditch most of your .ini files and store your settings inclean python.Usage-----from pyramid.config import Configuratorfrom pyramid_settings import load_settingsdef main(global_config, **settings):""" This function returns a Pyramid WSGI application."""load_settings(__name__, settings, config=global_config)config = Configurator(settings=settings)config.scan()return config.make_wsgi_app()and this is all you need (if you use paster ini files and pserv) to be able to use:$ pserv development.ini pysettings=settings.py,base.py,roman.pyWarning-------Everything you see here is work in progress and should not be ever used inproduction (trust me - don't trust me). Contributions, critique, angry lettersand such are welcome.Installation------------Install with pip::$ pip install pyramid_settingsIssues and questions--------------------Have a bug? Please create an issue on GitHub!https://github.com/niktto/pyramid_settings/issuesContributing------------EasyEmail is an open source software and your contribution is very muchappreciated.1. Check for`open issues https://github.com/niktto/pyramid_settings/issues or`open a fresh issue https://github.com/niktto/pyramid_settings/issues/newto start a discussion around a feature idea or a bug.2. Fork the`repository on Github https://github.com/niktto/pyramid_settingsand make your changes.3. Follow these rules: PEP8, PEP257 and TheZen of Python.4. Make sure to add yourself to AUTHORS and send a pull request.Licence-------EasyEmail is available under the New BSD License. SeeLICENSE https://github.com/niktto/pyramid_settings/blob/master/LICENSEfile.
Package: pyramid_shopify_oauth
# pyramid_shopify_oauth### in your .ini file, add the following```shopify.oauth.login_url = /oauth_login	            # The entry point of your shopify app, defaults to shopify_oauth_login_url (different from App Home)shopify.oauth.redirect_url = /oauth_redirect        # The redirect app url for OAuth, defaults to shopify_oauth_redirect_urlshopify.oauth.scope = read_products,read_orders     # Permission scope you need from the shop (comma seperated)shopify.oauth.app_home = /		            # Your app home urlshopify.oauth.api_key = *************               # Your api keyshopify.oauth.secret = *************                # Your api secret```### in your app __init__ file, add the following```config.include('pyramid_shopify_oauth')```### after oauth login, you can get shopify instance from request```shopify = request.shopifyif shopify is None:# the user is not signed in# you can access shopify API nowshopify.Shop.current()......```### To make oauth work, make sure you have pre-configured a session factory, for example```from pyramid_beaker import session_factory_from_settingssession_factory = session_factory_from_settings(settings)config.set_session_factory(session_factory)```#Release Notes0.0.1==========- Initial release
Package: pyramid-sms
===============SMS for Pyramid===============.. image:: https://img.shields.io/pypi/v/pyramid_sms.svg:target: https://pypi.python.org/pypi/pyramid_sms.. image:: https://img.shields.io/travis/websauna/pyramid_sms.svg:target: https://travis-ci.org/websauna/pyramid_sms.. image:: https://readthedocs.org/projects/pyramid_sms/badge/?version=latest:target: https://readthedocs.org/projects/pyramid_sms/?badge=latest:alt: Documentation StatusSMS text messaging services for `Pyramid <http://trypyramid.com>`_ web framework.* Free software: ISC license* Documentation: https://pyramid_sms.readthedocs.org.Features--------* Configurable SMS backend* Send outbound SMS using `Twilio <https://twilio.com>`_ , `OVH <https://www.ovh.com>`_ or dummy backend for unit testing* Asynchronous operations that do not block HTTP response with `Websauna <https://websauna.org>`_* API type hintingAuthor------`Mikko Ohtamaa <https://opensourcehacker.com>`_.Credits-------This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template... _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage=======History=======0.1.4 (unreleased)------------------- Python 3.7 compatibility0.1.3 (2016-09-09)------------------* Update to Websauna new Celery APIs0.1.2 (2016-06-29)------------------* Added validation and normalization for international phone number0.1.1 (2016-06-25)------------------* Added validator :py:func:`pyramid_sms.validators.valid_us_phone_number`0.1.0 (2016-04-28)------------------* First release on PyPI.
Package: pyramid_sna
pyramid_sna is a Pyramid library for authenticating users using OAuth2
providers.It is released under the terms of a 3 clause BSD license and it is
based on code originally from theYith Library Serverproject.You can learn how to use it reading the documentation in thedocsdirectory.0.3.2 (2015-07-25)Remove pyramid_beaker dependency and just require any valid
Pyramid Session Factory.0.3.1 (2014-01-08)Don’t pin requirement versions so applications using pyramid_sna
can decide what version they want.0.3 (2013-12-30)Add support for Microsoft Live Connect. Contributed by
Antonio Perez-Aranda Alcaide0.2 (2013-04-30)Add documentation.0.1.2 (2013-04-24)Make the library easier to depend on by not pinning the versions
of all our indirect dependencies.0.1.1 (2013-04-23)Fix a crash with Facebook auth because its response is not JSON.0.1 (2013-04-23)Initial release with code from Yith Library ServerLicense change with the agreement of original YLS copyright holdersMake the scope configurableMake the [google,facebook]_callback views return the result of
a configurable callback function.
Package: pyramid_soap
pyramid_soapThepyramid_soappackage adaptsSoapboxfor pyramid framework, to build SOAP Web Services.Source code athttps://bitbucket.org/artgins/pyramid_soapExamplefrom pyramid_soap import SOAPService, SOAPVersion, xsd

class GetStockPrice(xsd.ComplexType):
    company = xsd.Element(xsd.String, minOccurs=1)
    hora = xsd.Element(xsd.String)


class StockPrice(xsd.ComplexType):
    price = xsd.Element(xsd.Integer)


Schema = xsd.Schema(
    #Should be unique URL, can be any string.
    targetNamespace="http://127.0.0.1:8000/utsx/pid.xsd",
    #Register all complex types to schema.
    complexTypes=[GetStockPrice, StockPrice],
    elements={
        "getStockPrice": xsd.Element(GetStockPrice),
        "stockPrice": xsd.Element(StockPrice)
    }
)


soap_hello = SOAPService(
    targetNamespace="http://127.0.0.1:8000/utsx/pid.wsdl",
    location="http://127.0.0.1:8000/utsx",
    path="/utsx",
    schema=Schema,
    version=SOAPVersion.SOAP11)


@soap_hello.api(soapAction="GetStockPrice", input="getStockPrice",
                output="stockPrice", operationName="GetStockPrice")
def get_stock_price(request, gsp):
    print gsp.company
    print gsp.hora
    return StockPrice(price=139)Licensepyramid_soap is released under terms of The MIT
LicenseMIT.Copyright (c) 2012, Ginés Martínez Sánchez <ginsmar@artgins.com>
Package: pyramid_socketio
DOCUMENTATION: https://github.com/abourget/pyramid_socketio---Changelog=========0.9 (2012-03-06)----------------- ``socketio-serve-reload`` did not not find the ``socketio-serve``-executablein some cases.[WouterVH]- Release in preparation sontek's talk at PyCon 2012- Fixes so that it works with the latest gevent-socketio.- Renamed 'resource' to 'namespace', following new Socket.IO protocol- Bug fixes0.8 (2011-05-30)----------------- Fixed a bug when killing sessions.0.7 (2011-05-17)----------------- Added on_disconnect callbacks.- Improved kill() which will make it recursive by default, and call the on_disconnect callbacks.- spawn() now allows paramters (*args, **kwargs) to be passed in.- Improved documentation- msg() and error() now use send() which has all the connection state verification, and killing mechanism.0.6 (2011-05-11)----------------- Fixed a bug with .ini files with no logging sections (like formatters)0.5 (2011-02-15)----------------- Added JavaScript example.- Fixed setup.py (having not included CHANGES.txt in the sdist)0.4 (2011-02-15)----------------- Updated docs.0.3 (2011-02-15)----------------- CHANGES and README added to description.0.2 (2011-02-15)----------------- Help updated0.1 (2011-02-15)----------------- Initial release- Support for paster server plugin- Provide with command-line servers- socketio-serve- socketio-serve-reload
Package: pyramid_soy
pyramid_soy-----------pyramid_soy is a simple wrapper of `Soy` (closure-template-python).It provides simple cache for soy template file and pyramid directive for convenient.##ConfigOpen your project config file `***.ini`.Add include settings in your config file```pyramid.includes =pyramid_soy```Or include it in your pyramid init script.```def includeme(config):config.include('pyramid_soy')```##UsageUse `config.add_soy_searchpath` to add search path of complied soy template file(ends with `.py`).Use `request.soy_render_tostring(template_name, name_space, **data)`More docs detail in source code.##About[Github](https://github.com/winkidney/pyramid_soy)