Saravanan666/pypi-org huggingface dataset:
Package: restframework-serializer-permissions
restframework-serializer-permissionsDrop in replacement forDjango Restframework Serializersto add permission based field serialization.InstallationInstall this module into your environment:$ pip install restframework-serializer-permissionsExampleThis example uses a ModelSerializer as described inDRF Docs# import permissions from rest_frameworkfromrest_framework.permissionsimportAllowAny,IsAuthenticated# import serializers from serializer_permissions instead of rest_frameworkfromserializer_permissionsimportserializers# import you modelsfrommyproject.modelsimportShoppingItem,ShoppingListclassShoppingItemSerializer(serializers.ModelSerializer):item_name=serializers.CharField()classMeta:# metaclass as described in drf docsmodel=ShoppingItemfields=('item_name',)classShoppingListSerializer(serializers.ModelSerializer):# Allow all users to list namelist_name=serializers.CharField(permission_classes=(AllowAny,))# Only allow authenticated users to retrieve the commentlist_comment=serializers.CharField(permissions=(IsAuthenticated,))# show owner only, when the current user has 'auth.view_user' permissionowner=serializers.CharField(permissions=('auth.view_user',),hide=True)# serializer which is only available, when the user is authenticateditems=ShoppingItemSerializer(many=True,permissions=(IsAuthenticated,),hide=True)classMeta:# metaclass as described in drf docsmodel=ShoppingItemfields=('list_name','list_comment','owner','items',)You can also define your own permissions classes as described in theDRF documentationand specify multiple rpermission_classesand rpermissionson a field or serializer: all provided permissions must be satisfied for the visitor to retrieve the given field.CompatibilityThis package should be compatible with:Django Rest Framework 3Django 2.x, 3.xPython 3.6, 3.7, 3.8
Package: rest-framework-smoke
Rest-Framework-SmokeSmoke tests for API built with Django Rest Framework.Installationpipinstallrest-framework-smokeUsageFull example located attestproject.testapp.testsfromrest_framework.testimportAPITestCasefromrest_framework_smoke.tests.mixinsimportReadOnlyViewSetTestsMixinfromrest_framework_smoke.tests.schemasimportget_object_schemafromtestproject.testappimportmodelsTASK_SCHEMA={"id":{"type":["number"]},"name":{"type":["string"]},}PROJECT_SCHEMA={"id":{"type":["number"]},"name":{"type":["string"]},"task_set":{"type":["array"],"minItems":1,"items":get_object_schema(TASK_SCHEMA)}}classProjectViewSetTestCase(ReadOnlyViewSetTestsMixin,APITestCase):object_name='project'basename='projects'schema=details_schema=PROJECT_SCHEMApagination_schema=None@classmethoddefsetUpTestData(cls):cls.project=models.Project.objects.create(name='project')cls.task=models.Task.objects.create(name='task',project=cls.project)Happy API testing :)About schema checksRest-Framework-Smoke usesjsonschemato validate API response format.
When we check format, we should pay attention to:no unexpected properties are found (is so, they are not validated by schema)there are no missing properties (missing properties are not validated)arrays are not empty (because there is nothing to check in empty arrays)all values are not null (because null values mostly are null by default, and
other type variants will never appear in schema validation code)So there are two helpers inrest_framework_smoke.tests.schemasto enforce
these constraints (and they are used internally for format tests):get_object_schemaget_array_schema
Package: restful-api
:rocket: RestfulApi :facepunch:模型部署Installpipinstallrestful_api-UUsageimportjiebafromrestful_apiimportApipred1=lambda**kwargs:kwargs['x']+kwargs['y']pred2=lambdax=1,y=1:x+ypred3=lambdatext='小米是家不错的公司':jieba.lcut(text)# 多服务堆叠api=Api('/post1',pred1)api=Api('/post2',pred2,app=api.app)api=Api('/post3',pred3,app=api.app)api.app.run()Testimportrequestsjson={'x':1,'y':10}requests.post('http://127.0.0.1:5000/post1',json=json).json()requests.post('http://127.0.0.1:5000/post2',json=json).json()requests.post('http://127.0.0.1:5000/post3',json=json).json()
Package: restful-api-guidelines-linter
This is a very basic linter to check whether a given Swagger specification (YAML file)
complies withZalando’s RESTful API Guidelines.Usage:$sudopip3install-Urestful-api-guidelines-linter$restful-api-guidelines-lintermy-swagger-spec.yaml-vThe following guidelines are currently checked:Must: Always Return JSON Objects As Top-Level Data Structures To Support ExtensibilityMust: Avoid Trailing SlashesMust: Do Not Use URI VersioningMust: Pluralize Resource NamesMust: Property names must be snake_case (and never camelCase).Must: Use HTTP Methods CorrectlyMust: Use lowercase separate words with hyphens for Path SegmentsMust: Use snake_case (never camelCase) for Query ParametersRunning Unit Tests$sudopip3install-Utox$tox
Package: restful-aws-lambda
restful-aws-lambdarestful-aws-lambda is a lightweight opinionated framework for building REST API usingAWS LambdaandAPI Gateway.MotivationWhy another framework ?When using API Gateway and python Lambda functions, the most common pattern is to have a unique Lambda function triggered by a proxy API Gateway resource. The Lambda then uses a framework likeFlaskto do all the routing. In an API Gateway + Lambda context, I feel likethe routing should be handled by API Gateway itself, then forwarding the request to specific Lambda functions for each resource or endpoint.FeaturesNo routing. Yes, this is a feature. Routing should be handled by API Gateway.API Gateway event parsing (including request body and path parameters).Cleaner syntax.Customizable JSON dumps behaviorNo schema validationInstallationInstall the package from PyPI using pip:$ pip install restful-aws-lambdarestful-aws-lambda should also be included in the deployment package of your Lambda functions.Getting startedrestful-aws-lambda provides a@routedecorator to parse the API Gateway event into aRequestobject available in the handler function as an argument. It also formats the handler's output to the expected Lambda + API Gateway format seamlessly.Turning this:importjsondefhandler(event,context):body=json.loads(event["body"])query_params=event["queryStringParameters"]path_params=event["pathParameters"]return{"statusCode":200,"body":json.dumps({"message":f"Hello from AWS Lambda{body['name']}!!"})}Into this:fromrestful_aws_lambdaimportroute@routedefhandler(request):body=request.jsonquery_params=request.query_paramspath_params=request.path_paramsreturn200,{"message":f"Hello from AWS Lambda{body['name']}!!"}You can still access the originaleventandcontextarguments from the handler:fromrestful_aws_lambdaimportroute@routedefhandler(request,event,context):print(event)body=request.jsonreturn200,{"message":f"Hello from AWS Lambda{body['name']}!!"}Path parameters defined in API Gateway can also be accessed directly as function argument:fromrestful_aws_lambdaimportroute@routedefget_user(user_id):print(user_id)# get user from dbuser={"id":user_id,"name":"John Doe"}return200,userJSON dumps optionsrestful-aws-lambda uses the defaultjsonlibrary to dump the lambda handler response. You can customize the behavior of it by passingjson.dumps()keyword arguments to thejson=parameter:importjsonimportdatetimefromrestful_aws_lambdaimportrouteclassJSONDatetimeEncoder(json.JSONEncoder):defdefault(self,obj):ifisinstance(obj,(datetime.date,datetime.datetime)):returnobj.isoformat()returnsuper(JSONDatetimeEncoder,self).default(obj)@route(json={"cls":JSONDatetimeEncoder})deflambda_handler(request):today=datetime.date.today()return200,{"today":today}ExampleYou can look at thesamplefor a minimal pylambdarest API.In this sample, we use theserverlessframework to declare the API Gateway -> Lambda routingThe packaging of the Lambda functions is done using theserverless-python-requirementsplugin.
Package: restful_client
==============restful_client==============restful_client is an asychronous library that assists in writing clients forRESTful services.A RESTClient is an extension of a urllib2.Request class that also contains its own HTTP openerso the request can be executed and results passed through an (optional) call back mechanism.The default_callback function in __init__ demonstrates the protocol that should be supported bythe callback function.See http://docs.python.org/library/urllib2.html#request-objects for urllib2 Request documentationand http://www.voidspace.org.uk/python/articles/urllib2.shtmland http://www.doughellmann.com/PyMOTW/urllib2/ for useful usage notes.TODO: Add support for timeouts at per client instance level (via opener).TODO: May need to implement smart exception handling. When YOU start encountering reproducableHTTP exceptions (or others) please contact Ben so he can see what exception handling strategywould work best for this library.
Package: restful-client-lite
restful-client-liteA lite client for RESTFul APIs with limited features.It provides:restful_client_lite.APIClient: client forevetoken-auth appsrestful_client_lite.contrib.AliyunApiGatewayClient: client for apis generated byaliyun DataService(onlyGETis supported)restful_client_lite.contrib.WangduoyunApiClient: client for Wangduoyun apis byWangDuoYunWIP.(not stable before v0.1.0)InstallationLastest releasepipenv:pipenvinstallrestful_client_litepip:pipinstallrestful_client_liteDevpipenv:pipenvinstall-egit+https://github.com/huandzh/restful-client-lite#egg=restful-client-litepip:pipinstall-egit+https://github.com/huandzh/restful-client-lite#egg=restful-client-liteUsageAssume that we have a restful api requiringAuthorization:<token>in the header and using etag to control writes.Create an API client:fromrestful_client_liteimportAPIClientapi=APIClient("<api_root>",{"token":"<token>"})Get from url:res_get=api.get("<url>")Post to url:res_post=api.post("<url>",data={"<key>":"<value>"})Patch url:res_patch=api.patch("<url>","<etag>",data={"<key>":"<value>"})Patch url (fetch etag automatically in advance):res_patch=api.patch_auto_etag("<url>",data={"<key>":"<value>"})Delete url:res_delete=api.delete("<url>","<etag>")Delete url (fetch etag automatically in advance):res_delete=api.delete_auto_etag("<url>")SubclassAPIClientto create custom api client:defsign(url):"""some function return signature"""...return<signedurl>classCustomAPIClient(APIClient):"""custom api client"""defauth_headers(self,f:Callable)->Callable:"""custom auth headers"""@wraps(f)defwrapper(*args,**kwargs):headers=kwargs.get("headers",{}).copy()url=args[0]headers.update({"Signature":sign(url)})kwargs["headers"]=headersreturnf(*args,**kwargs)3rd-party APIsaliyun api gatewayAliyunApiGatewayClient:supportGETfrom aliyun-api-gateway apis (apis may generated by DataService)handle authorization headersdoesn'tsort url paramsfromrestful_client_lite.contrib.aliyunimportAliyunApiGatewayClientapi=AliyunApiGatewayClient('<api_root>',{"app_id":'<app_id>',"app_secret":'<app_secret>'})# make sure params in <url> are sortedres=api.get('<url>')wangduoyun apiWangduoyunApiClient:support account apissupport graphql apis# client adds required authorization data for POSTapi=WangduoyunApiClient("<api_root>",{"user_key":"<user_key>","user_secret":"<user_secret>"})res=api.post("<url>")# client provides `get_sign` to get authorization paramsapi=WangduoyunApiClient("<api_root>",{"user_key":"<user_key>","user_secret":"<user_secret>"})sign,timestamp=api.get_sign()url="?user_key={user_key}&timestamp={timestamp}&sign={sign}&source_id={source_id}&query={query}".format(user_key=api.auth['user_key'],timestamp=timestamp,sign=sign,source_id="<source_id>",query="<query>")res=api.get(url)
Package: restfulContentManager
# RestfulContentManagerA content manager for Jupyter that retrieves data from an external api# ConfigurationThe most basic configuration takes a single parameter that provides the url for the api:```pythonfrom restfulContentManager import RestfulContentManagerc = get_config()# ... other config ...c.NotebookApp.contents_manager_class = RestfulContentManagerc.RestfulContentManager.api_endpoint = 'http:/myawesome.api/v1/"```
Package: restful_model
restful_model is ansqlalchemyauto generate REATful APIExampleSanicapp.pyimportsqlalchemyassafromsanicimportSanicfromsanic.constantsimportHTTP_METHODSfromrestful_modelimportDataBasefromrestful_model.extend.sanicimportApiViewmetadata=sa.MetaData()User=sa.Table('user',metadata,sa.Column('id',sa.Integer,autoincrement=True,primary_key=True,nullable=False,),sa.Column('account',sa.String(16),nullable=False,),sqlite_autoincrement=True,)classUserView(ApiView):__model__=Userapp=Sanic(__name__)db=DataBase("sqlite:///db.db")app.db=db@app.listener('before_server_start')asyncdefsetup_db(app,loop):ifapp.db.loopisNone:app.db.loop=loopapp.db.engine=awaitapp.db.create_engine(echo=True)ifnotawaitapp.db.exists_table(User.name):awaitapp.db.create_table(User)userView=UserView.as_view(app.db)app.add_route(userView,"/user",HTTP_METHODS)app.add_route(userView,"/user/<id:int>",HTTP_METHODS)if__name__=="__main__":app.run(host="0.0.0.0",port=8000)curl test$# create$curl-XPOSThttp://127.0.0.1:8000/user\-H'content-type: application/json'\-d'{ "account": "test1" }'>{"status":201,"message":"Insert ok!","meta":{"count":1}}$# select$curl-XGEThttp://127.0.0.1:8000/user>{"status":200,"message":"Query ok!","data":[{"id":1,"account":"test1"}]}$# update$curl-XPUThttp://127.0.0.1:8000/user\-H'content-type: application/json'\-d'{"where": {"id": 1}, "values": {"account": "test2"}}'>{"status":201,"message":"Update ok!","meta":{"count":1}}$curl-XGEThttp://127.0.0.1:8000/user>{"status":200,"message":"Query ok!","data":[{"id":1,"account":"test2"}]}$# delete$curl-XDELETEhttp://127.0.0.1:8000/user\-H'content-type: application/json'\-d'{"id": 1}'>{"status":200,"message":"Delete ok!","meta":{"count":1}}$curl-XGEThttp://127.0.0.1:8000/user>{"status":200,"message":"Query ok!","data":[]}Links
Package: restful-starlette-admin
Restful Starlette AdminDescription : Admin CLI for restful-starlette1、安装# pip源安装>pipinstallrestful-starlette-admin# git 仓库直接安装>pipinstallgit+https://gitee.com/coldsunset/restful_starlette_admin.git# 使用>rs-admin

Usage:admin.py[OPTIONS]COMMAND[ARGS]...AdminCLI:provideactionstoinitialrestfulstarletteproject

Options:--helpShowthismessageandexit.

Commands:init-envstart-appstart-project2、初始化项目 start-project# 创建项目文件夹并进入>mkdirproject_name&&cdproject_name# 初始化项目结构>rs-adminstart-project--nameproject_name3、生成新应用 start-app# 建议按照项目结构，进入modules包下创建新app>cdmodules# 初始化项目结构>rs-adminstart-app--nameapp_name4、自动生成.env文件# 根据指定的settings对象路径自动生成.env文件，格式>rs-admininit-env--setting_classrestful_starlette.conf.base:GlobalSettings
Package: restful-wos
restful-wosA client for Clarivate Analytics' Web of Science RESTful API.Currently requests and extracts data in RIS format.InstallationFrom PyPI via pip$pipinstallrestful-wosLatest development version:$gitclonegit+https://github.com/ConnectedSystems/restful-wos.git
$cdrestful-wos
$pipinstall-e.UsageFirstly, put your Web of Science access tokens into a yaml file in the following format:restful_wos:wos_lite:YOUR ACCESS TOKEN FOR THE `LITE` APIwos_expanded:YOUR ACCESS TOKEN FOR THE `EXPANDED` APIThen simply pass in the location of the file to the RESTful client:importrestful_wos# Create client and send queryclient=restful_wos.RESTClient('config.yml')search_request='TS=(uncertain* AND (catchment OR watershed OR water))'resp=client.query(search_request,time_span=('2018-11-01','2018-12-31'))# Convert parsed responses into RIS recordsris_data=restful_wos.to_ris_text(resp)# Output to a txt filerestful_wos.write_file(ris_data,'ris_output',overwrite=True)
Package: restfx
restfxPython3 的 RESTful 服务框架。底层基于werkzeug为什么要使用此框架开发此框架的目标是提升开发效率。此框架解决了以下问题：没有繁锁的路由配置，免去路由注册。仅仅需要对模块根进行注册，模块下的所有路由都会自动被收集调用不需要对路由 url 进行显示配置，完全自动解析自动解析/校验请求参数，并填充到路由函数，省去繁锁的参数获取/类型校验。需要做的仅仅是编写一个函数，并添加函数参数的类型声明提供接口列表页面以及接口测试支持，让接口随码更新，不用手动维护API文档。 见截图提供路由注入支持，以通过参数方式向路由指定请求参数外的数据/函数，从而避免一些频繁的import和重复代码此框架的弊端: 不支持将参数作为 url 路径的一部分安装pipinstallrestfxSince 0.7.1安装后，可以通过 CLI 工具restfx命令创建基本项目结构:restfxcreateprojectname使用此命令，可能需要将restfx安装到全局环境中。文档使用文档见Gitee Wiki创建应用importosimportrestfxif__name__=='__main__':root=os.path.dirname(__file__)app=restfx.App(root,api_prefix='any/prefix',debug=True)app.map_routes({'x':'test'})app.map_static(static_map={})app.startup(host='127.0.0.1',port=9127)编写路由test/api/demo.pyfromrestfximportroutefromrestfx.httpimportHttpRequest,HttpFile@route(module='测试名称-模块',name='测试名称-GET')defget(request,param1,param2=None,param3:int=5):# request 会是 HttpRequestreturn{'param1':param1,'param2':param2,'param3':param3,}@route(module='测试名称-模块',name='测试名称-POST_PARAM')defget_param(param1,req:HttpRequest,from_=None,param3=5):# req 会是 HttpRequestreturn{'param1':param1,'from':from_,'param3':param3,}@route(module='测试名称-模块',name='测试名称-PUT_PARAM')defput(request:str,param1,file:HttpFile,param3=5):# request 会是请求参数，参数列表中没有 HttpRequestreturn{'request':request,'param1':param1,'param3':param3,}@route(module='测试名称-模块',name='测试名称-DELETE_PARAM')defdelete(request,param1,from_=None,param3=5,**kwargs):# 未在函数的参数列表中声明的请求参数，会出现在 kwargs 中return{'param1':param1,'from':from_,'param3':param3,'variable_args':kwargs}截图以下截图为接口列表，对应的路由声明源码见test/test/api/init.pytest/test/api/demo.py以下截图仅在Gitee仓库目录可见
Package: restgate
RestGate is a python library for communicating with a RESTful API hosted on AWS API Gateway.UsageYou can add RestGate using the usual PyPI channels. Example:pip install restgateYou can find the package details here:https://pypi.python.org/pypi/restgateAlternatively, if you prefer to install from source:git clone git@github.com:cloudnative/restgate.git
cd restgate
python setup.py installWikiCan be found here:https://github.com/cloudnative/restgate-py/wikiSource CodeThe Python source code for RestGate is available on GitHub:https://github.com/cloudnative/restgate-pyDevelopingA really nice TDD flow can be created by runningdocker-compose run restgate sniffer -x--rednoseAbout CloudNativeCloudNativeis on a mission to codify the best practices for running a service in the cloud. If you are looking for help with AWS, please contact us.LicenseCopyright 2015 CloudNative, Inc.Licensed 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: restgdf
restgdfimproved esri rest io for geopandasgpd.read_file(url, driver="ESRIJSON")does not account for max record count limitationsso if you read a service with 100000 features but there's a limit of 1000 records per query, then your gdf will only have 1000 featuresthese functions use asyncio to read all features from a service, not limited by max record countkeyword arguments toFeatureLayer.getgdfare passed on torequests.Session.post; include query parameters like where str and token str in data dictthis enables enhanced control over queries and allow use of any valid authentication scheme (egrequests_ntlm.HttpNtlmAuth) with use ofrequests.Session.authordata={"token": str}UsagepipinstallrestgdfimportasynciofromaiohttpimportClientSessionfromrestgdfimportFeatureLayerbeaches_url=r"https://maps1.vcgov.org/arcgis/rest/services/Beaches/MapServer/6"zipcodes_url="https://services.arcgis.com/P3ePLMYs2RVChkJx/ArcGIS/rest/services/USA_ZIP_Codes_2016/FeatureServer/0"asyncdefmain():asyncwithClientSession()assession:beaches=awaitFeatureLayer.from_url(beaches_url,session=session)beaches_gdf=awaitbeaches.getgdf()daytona=awaitbeaches.where("LOWER(City) LIKE 'daytona%'")daytona_gdf=awaitdaytona.getgdf()oh_zipcodes=awaitFeatureLayer.from_url(zipcodes_url,where="STATE = 'OH'",session=session)oh_zipcodes_gdf=awaitoh_zipcodes.getgdf()returnbeaches_gdf,daytona_gdf,oh_zipcodes_gdfbeaches_gdf,daytona_gdf,oh_zipcodes_gdf=asyncio.run(main())print(beaches_gdf.shape)# (243, 10)print(daytona_gdf.shape)# (83, 10)print(oh_zipcodes_gdf.shape)# (1026, 8)Documentationhttps://restgdf.readthedocs.io/Usesrestgdf_apigovgis_nov2023
Package: rest-http-client
rest-http-client: Configurable and flexible http(s)-client for your python applicationsDescriptionTherest-http-clientpackage is a basic configurable rest api client. This package is currently tested on Python =< 2.7.
This  package worked on multithreding modeInstallationpip install rest-http-clientordownload thelatest releaseand runpython setup.py installUsageExample in foldertests.The first you can configure http or https clientimport logging

from rest_api_client import HttpClient
from .testapis import TestAPIs

logger = logging.getLogger('http_logger')

class TestRestAPI(HttpClient):
    _WRAPPERS = [  # list of api clients
        TestAPIs
    ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.testapis = None

        for e in self._WRAPPERS:
            attr_name = e.__name__.lower()
            setattr(self, attr_name, e(self))classTestAPIswhere you list all api requestsfrom http import HTTPStatus


class TestAPIs:
    def __init__(self, client):
        self.client = client
        self.client.add_headers({
            "Accept": "*/*",
            "Content-Type": "application/json",
        })

    def get_request(self):
        response = self.client.get('/echo')
        assert response.status_code == HTTPStatus.OK, 'Invalid request'
        return response

    def post_request(self, body: dict):
        response = self.client.post('/echo/post/form', json=body)
        assert response.status_code == HTTPStatus.OK, 'Invalid request'
        return responseThen has to create object ofTestRestAPIand use in testsfrom tests.api import TestRestAPI

client = TestRestAPI(address='https://reqbin.com')


def test_check_get_request():
    response = client.testapis.get_request()
    assert 'Simple echo interface for HTTP methods' in response.text, 'Something is wrong'


def test_check_post_request():
    body = {
        'key1': 'value1',
        'key2': 'value2',
    }
    response = client.testapis.post_request(body=body)
    assert 'Success' in response.text, 'Something is wrong'Console Output============================= test session starts =============================
collecting ... collected 2 items

test_apis.py::test_check_get_request 
test_apis.py::test_check_post_request 

======================== 2 passed, 3 warnings in 0.75s ========================

Process finished with exit code 0
PASSED                              [ 50%]
PASSED                             [100%]
Package: restible
restibleis a python library for creating consistent code for REST APIs
across different frameworks. The main motivation was that the framework used
is often dictated by requirements and I wanted to have a concise way of writing
API endpoints no matter the underlying framework.Useful linksDocsSource CodeCI BuildsRelated librariesrestible-flaskrestible-sqlalchemyrestible-appenginerestible-djangoInstallation$pipinstallrestibleContributingNoteThe library has a pretty good test coverage but not yet at 100%. A large
part of the code is documented through docstrings but the general purpose
docs are not written yet nor are any tutorials.Cloning and setting up the development repo$gitclonegit@github.com:novopl/restible.git$cdrestible$virtualenvenv$source./env/bin/activate$pipinstall-rrequirements.txt-rops/devrequirements.txt$peltakgitadd-hooksRunning testsConfig: The types of tests are defined inpelconf.pyand the
pytest configuration is defined inops/tools/pytest.ini.$peltaktestLintingConfig: The list of locations to lint is defined inpelconf.pyand the
linters configuration is defined inops/tools/{pylint,pep8}.ini.$peltaklintGenerating docsConfig: The list of documented files and general configuration is inpelconf.pyand the Sphinx configuration is defined indocs/conf.py.$peltakdocs