Saravanan666/pypi-org huggingface dataset:
Package: http-crawler
http-crawler is a library for crawling websites.  It usesrequeststo speak HTTP.InstallationInstall withpip:$pipinstallhttp-crawlerUsageThehttp_crawlermodule provides one generator function,crawl.crawlis called with a URL, and yields instances ofrequests’sResponseclass.crawlwill request the page at the given URL, and will extract all URLs from the response.  It will then make a request for each of those URLs, and will repeat the process until it has requested every URL linked to from pages on the original URL’s domain.  It will not extract or process URLs from any page with a different domain to the original URL.For instance, this is how you would usecrawlto find and log any broken links on a site:>>>fromhttp_crawlerimportcrawl>>>forrspincrawl('http://www.example.com'):>>>ifrsp.status_code!=200:>>>print('Got{}at{}'.format(rsp.status_code,rsp.url))crawlhas a number of options:follow_external_links(defaultTrue)  If set,crawlwill make a request for every URL it encounters, including ones with a different domain to the original URL.  If not set,crawlwill ignore all URLs that have a different domain to the original URL.  In either case,crawlwill not extract further URLs from a page with a different domain to the original URL.ignore_fragments(defaultTrue)  If set,crawlwill ignore the fragment part of any URL.  This means that ifcrawlencountershttp://domain/path#anchor, it will make a request forhttp://domain/path.  Moreover, it means that ifcrawlencountershttp://domain/path#anchor1andhttp://domain/path#anchor2, it will only make one request.verify(defaultTrue)  This option controls the behaviour of SSL certificate verification.  See therequests documentationfor more details.MotivationWhy another crawling library?  There are certainly lots of Python tools for crawling websites, but all that I could find were either too complex, too simple, or had too many dependencies.http-crawler is designed to be alibrary and not a framework, so it should be straightforward to use in applications or other libraries.ContributingThere are a handful of enhancements on theissue trackerthat would be suitable for somebody looking to contribute to Open Source for the first time.For instructions about making Pull Requests, seeGitHub’s guide.All contributions should include tests with 100% code coverage, and should comply withPEP 8.  The project usestoxfor running tests and checking code quality metrics.To run the tests:$tox
Package: http-csp
python-http-cspHTTP Content Security Policy ManagerA library to make parsing and generating CSP policies a little easier.Read more about Content Security Policies:https://developer.mozilla.org/en-US/docs/Web/HTTP/CSPInstallingInstall this library from PyPI:pip3installhttp-cspUsing this libraryParsing a CSP string:policy=CSP("default-src 'self';")returns a CSP object with adefault_srcattribute with value["'self'"].Generating a CSP string:policy=CSP()policy.default_src=["'self'"]policy.image_src=["*"]policy.media_src=["example.org","example.net"]generated_policy=policy.generate()returns a string with the valuedefault-src 'self'; img-src *; media-src example.org example.net;.
Package: httpdate
httpdatehttpdateis a Python library for parsing and formatting HTTP date fields that are
used in headers likeLast-ModifiedandIf-Modified-Since. It does so in strict
accordance withRFC 9110 Section 5.6.7.It has only one dependency, which is my tinyleapsecondslibrary that just provides
a tuple of official leap seconds.HTTP date formatsAll HTTP dates (eg, inLast-Modifiedheaders) must be sent in this format:#IMF-fixdateSun, 06 Nov 1994 08:49:37 GMTHowever, RFC 9110 states that recipients must also accept two other obsolete formats:#rfc850-dateSunday, 06-Nov-94 08:49:37 GMT#asctime-dateSun Nov  6 08:49:37 1994RFC 9110 criteria for the HTTP date field includes the following:It must represent time as an instance of UTC.It must represent weekday names and month names in English.It is case-sensitive.It must not have any additional whitespace.It must be semantically correct (eg, the weekday must be the correct weekday).It can include leap seconds (eg,23:59:60).It must represent a year of1900or above.It isn't stated explicitly in the RFCs, buthttpdatewill only consider a leap second
semantically correct if it's anofficial leap second.Installationpip install httpdateUsagefromhttpdateimportis_valid_httpdate,httpdate_to_unixtime,unixtime_to_httpdate# Check if an HTTP date (eg, `Last-Modified` header) is valid:is_valid_httpdate("Sun, 06 Nov 1994 08:49:37 GMT")try:# Parse an HTTP date:httpdate_to_unixtime("Sun, 06 Nov 1994 08:49:37 GMT")# Parse an HTTP date (rfc850-date):httpdate_to_unixtime("Sunday, 06-Nov-94 08:49:37 GMT")# Parse an HTTP date (asctime-date):httpdate_to_unixtime("Sun Nov  6 08:49:37 1994")exceptValueError:# Not a valid HTTP date string.pass# Format a Unix timestamp as an HTTP date:try:unixtime_to_httpdate(784111777)exceptValueError:# Outside the range supported by the operating system.passis_valid_httpdate(httpdate):Argshttpdate (str): An HTTP date string.Returnsbool: True ifhttpdateis a valid HTTP date string, otherwise False.RaisesTypeErrorifhttpdateis not of typestr.httpdate_to_unixtime(httpdate):Argshttpdate (str): An HTTP date string.Returnsint: A Unix timestamp (int).RaisesTypeErrorifhttpdateis not of typestr.ValueErrorifhttpdateis not a valid HTTP date string.unixtime_to_httpdate(unixtime):Argsunixtime (int): A Unix timestamp.Returnsstr: An HTTP date string.RaisesTypeErrorifunixtimeis not of typeint.ValueErrorifunixtimerepresents a year before 1900, or if it is outside
the range supported by the operating system.Why Unix timestamps?Unix timestamps are unambiguous, efficient, and can easily be converted to other
date-time formats using only the standard library.When aLast-Modifiedheader is semantically correct, this conversion — from string to
Unix timestamp and back to string — is lossless. (The only exception is leap seconds;
for exampleSat, 31 Dec 2016 23:59:60 GMTwould be returned asSun, 01 Jan 2017 00:00:00 GMT. Recipients should interpret these as being identical anyway.)If you want to store the original string instead, just useis_valid_httpdate()to
validate before storing.Licensehttpdateis distributed under the terms of theMITlicense.
Package: httpd-echo
A Simple Python HTTP server that echos the request in the responseProvide a simple HTTP server that tries to echo the request back in the
response in the most sensible way possible.  This can be useful for, testing,
debugging, stubbing out a local server in systems that have a hard-coded
assumption of making HTTP requests, etc.:$ python -m httpdecho
Echoing HTTP at http://localhost:8000 ...ExamplesWithout specifying a port, the server will try to find the next available port
starting at 8000 to try and be as predictable as possible:>>> import sys
>>> import time
>>> import subprocess
>>> from six.moves import SimpleHTTPServer
>>> startup_delay = 0.5
>>> simple_popen = subprocess.Popen(
...     [sys.executable, '-m', SimpleHTTPServer.__name__]
...     ); time.sleep(1)
>>> echo_popen = subprocess.Popen(
...     [sys.executable, '-m', 'httpdecho']
...     ); time.sleep(1)
>>> echo_popen.poll()
>>> simple_popen.kill()Once running, HTTP requests are echoed in the responses.  The default response
body format is basically HTTP header format, fromhttp.client.HTTPMessage:>>> import io
>>> import requests
>>> import email
>>> get_response = requests.delete('http://localhost:8001')
>>> get_body = email.message_from_string(get_response.text)
>>> print(get_body['Method'])
DELETE
>>> print(get_body['Path'])
/
>>> print(get_body.get_payload())
<BLANKLINE>Query parameters are also included:>>> query_response = requests.get(
...     'http://localhost:8001', params=dict(Foo='foo'))
>>> query_body = email.message_from_string(query_response.text)
>>> print(query_body['Foo'])
fooIf the request is aPOSTor another method that accepts a body on the
request, the body or the responses body will contain the POST body:>>> post_response = requests.patch(
...     'http://localhost:8001', data=dict(Bar='bar'))
>>> post_body = email.message_from_string(post_response.text)
>>> print(post_body.get_payload())
Bar=barShutdown the server:>>> echo_popen.kill()TODOFeatures for future releasesContent-TypeandAcceptsupport for content negotiation:Return the response body in the format specified in theAcceptheader if
given, otherwise in the sameContent-Typeas the request.
Package: httpdogs
httpdogsGetting URLs to your favourite HTTP dogs made easy!InstallationInstallinghttpdogsis easy, just runpip install httpdogs!UsageI've developedhttpdogsto make using HTTP dogs simple and fun.Currently, you can get your dogs using one of two functions -dog_by_nameanddog_by_codedog_by_name(name: str)takes in a sole parameter -name, which is the status code name to get a dog for.
Upon finding a dog matching the name, it returns anHTTPDogobject. Here's an example -fromhttpdogsimportdog_by_namemy_dog=dog_by_name("Success")print(f"My dog has a code of{my_dog.code}and means{my_dog.name}! The URL is{my_dog.url}")# Prints -# My dog has a code of 200 and means Success! The URL is https://http.dog/200dog_by_code(code: int)is extremely similar todog_by_name, just using a status code value.
Upon finding a dog matching the code, it returns anHTTPDogobject. Here's an example -fromhttpdogsimportdog_by_codemy_dog=dog_by_code(404)print(f"My dog has a code of{my_dog.code}and means{my_dog.name}:( The URL is{my_dog.url}")# Prints -# My dog has a code of 404 and means Not Found :( The URL is https://http.dog/404The HTTPDog object also has animageattributeYou can use this attribute to get the image bytes associated with the dog.
You can then save it or view it, like in the example below -fromhttpdogsimportdog_by_codefromPILimportImagefromioimportBytesIOmy_dog=dog_by_code(302)dog_image=Image.open(BytesIO(my_dog.image))dog_image.show()# Output below -ContributingThis package is opensource so anyone with adequate python experience can contribute to this project!Report IssuesIf you find any error/bug/mistake with the package or in the code feel free to create an issue and report ithere.Fix/Edit ContentIf you want to contribute to this package, fork the repository, make your changes and then simply create a Pull Request!ContactIf you want to contact me -Mail -wulf.developer@gmail.comDiscord -wulf#9716
Package: httpd-pyparser
httpd_pyparser is a parser collection library, which uses PLY (Python Lex and Yacc). It
tokenizes the given text, and applies the language rules. If it’s done, then
builds an own structure: a list of dictionary items.The items contains the configuration directives from the original files, and
the number of lines where it founded. Also the items contains other datas about
the configuration line and structure.Therefore, you can make many transformations on the structured data, and can
write back the modified config.
Package: http_dumper
This is a super quick-and-dirty WSGI application that prints out a few
pieces of HTTP info (headers, GET/POST details). I’ve just implemented the
bare minimum needed for a work project, so this is woefully incomplete. Feel
free to fork and hack on it to fit your needs.Pull requests are accepted and encouraged.Installation and UsageInstall and run:$ pip install http_dumper
$ http_dumperPoint traffic at port 8000 and watch stdout.SupportGood luck!LicenseBSD!
Package: httper
使用手册快速开始importhttperparams={"a":1,"b":2}# 发送get请求httper.get("http://localhost:8080/test/get?id=1")httper.get("http://localhost:8080/test/get?id=1",params)httper.get("http://localhost:8080/test/get?id=1",params=params,timeout=10,headers={})# 发送post请求httper.post("http://localhost:8080/test/post?id=1")httper.post("http://localhost:8080/test/post?id=1",params)httper.post("http://localhost:8080/test/post?id=1",params=params,timeout=10,headers={})# 发送post表单请求httper.postForm("http://localhost:8080/test/postForm?id=1",params)httper.postForm("http://localhost:8080/test/postForm?id=1",form=params,timeout=10,headers={})# 下载文件httper.getFile("http://localhost:8080/test/getFile?id=1","test.py")httper.getFile("http://localhost:8080/test/getFile?id=1","test.py",progress=True)httper.postFile("http://localhost:8080/test/postFile?id=1","test.py")httper.postFile("http://localhost:8080/test/postFile?id=1","test.py",progress=True)httper.downloadFile("http://localhost:8080/test/downloadFile?id=1","test.py")httper.downloadFile("http://localhost:8080/test/downloadFile?id=1","test.py",progress=True)# 上传文件httper.uploadFile("http://localhost:8080/test/uploadFile?id=1","file1","./files/test.py")httper.uploadFile("http://localhost:8080/test/uploadFile?id=1","file1",open("./files/test.py"))httper.uploadFile("http://localhost:8080/test/uploadFile?id=1",name="file1",file="[fileBytes]",fname="test.py")httper.uploadFile("http://localhost:8080/test/uploadFile?id=1",name="file1",file=("",open("./files/test.py","rb"),"image/jpeg",{"refer":"localhost"}))httper.uploadFile("http://localhost:8080/test/uploadFile?id=1",name="file1",file=("new_filename.py",open("./files/test.py","rb"),"image/jpeg",{"refer":"localhost"}))httper.uploadImage("http://localhost:8080/test/uploadImage?id=1","file2","./files/img1.py")
Package: httperactor
Async interactor for HTTP requests using a template method.DocumentationSimple example# main.pyimportasyncioimportjsonfromcollections.abcimportSequencefromtypingimportNamedTupleimporthttpximportpydepotfromhttperactorimportHttpClient,HttpInteractor,RequestclassBook(NamedTuple):title:strauthor:strclassState(NamedTuple):books:tuple[Book,...]classStateSubscriber:defon_state(self,state:State)->None:print(f"[StoreSubscriber] on_state called with{state}")classSetBooksAction(pydepot.Action):def__init__(self,books:Sequence[Book]):self.books:Sequence[Book]=booksclassSetBooksReducer(pydepot.Reducer[SetBooksAction,State]):@propertydefaction_type(self)->type[SetBooksAction]:returnSetBooksActiondefapply(self,action:SetBooksAction,state:State)->State:returnState(books=tuple(action.books))classGetBooksRequest(Request[Sequence[Book]]):@propertydefpath(self)->str:return"/books"defmap_response(self,response:str)->Sequence[Book]:returnjson.loads(response,object_hook=lambdares:Book(**res))classGetBooksInteractor(HttpInteractor[httpx.Request,Sequence[Book],State]):@propertydefrequest(self)->Request[Sequence[Book]]:returnGetBooksRequest()defactions(self,response:Sequence[Book])->Sequence[pydepot.Action]:return[SetBooksAction(books=response)]asyncdefmain()->None:store=pydepot.Store(initial_state=State(books=()))store.register(SetBooksReducer())subscriber=StateSubscriber()store.subscribe(subscriber)interactor=GetBooksInteractor(http_client=HttpClient(httpx.AsyncClient(base_url="http://localhost:5000")),store=store,)awaitinteractor.execute()if__name__=="__main__":asyncio.run(main())$curllocalhost:5000/books[{"author":"Alice","title":"foo"},{"author":"Bob","title":"bar"},{"author":"Charlie","title":"baz"}]$python3main.py[StoreSubscriber]on_statecalledwith:State(books=(Book(title='foo',author='Alice'),Book(title='bar',author='Bob'),Book(title='baz',author='Charlie')))InstallationHttperactor is available ashttperactoron PyPI:pipinstallhttperactorUsageFor detailed quickstart and API reference, visit theDocumentation.LicenseCopyright (C) 2023 tombartk 

This program is free software: you can redistribute it and/or modify it under the terms
of the GNU Affero General Public License as published by the Free Software Foundation,
either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License along with this program.
If not, see https://www.gnu.org/licenses/.
Package: httperfpy
=========httperfpy=========A python port of httperfrb http://github.com/jmervine/httperfrb.Built and tested using:$ python --versionPython 2.7.3$ uname -s -r -mLinux 3.2.0-29-generic x86_64Installing 'httperf'====================Requires httperf, of course...Mac------sudo port install httperfDebian / Ubuntu---------------sudo apt-get install httperfRedhat / CentOS---------------sudo yum install httperfMy 'httperf'------------** This is required for proper verbose handling. **See: http://mervine.net/httperf-0-9-1-with-individual-connection-times.Installation / Setup====================Perferred Method----------------$ sudo pip install httperfpySee: http://pypi.python.org/pypi/httperfpy/From Source-----------Simply clone code and add checkout location to your PYTHONPATH.Running tests...----------------1. sudo apt-get install python-unit2. git clone https://github.com/jmervine/httperfpy.git3. cd httperfpy4. ./scripts/unitUsage-----#!/usr/bin/env pythonfrom httperfpy import Httperfperf = Httperf(server="www.example.com",port=8080,num_conns=100)# replace dashes ("-") with underscores ("_") in httperf optionsperf.parser = Trueresults = perf.run()print results["connection_time_avg"] + " is avg"print results["connection_time_max"] + " is max"You can use `Httperf.display_options` to print a list of all available options.Passing variables and key-values to httperf#!/usr/bin/env pythonfrom httperfpy import Httperf# arguments, key-value argumentsperf = Httperf('hog', 'ssl', path='/path/to/httperf',server='www.example.com'...)# or only key-value argumentsperf = Httperf(hog=True, ssl=True, path='/path/to/httperf',server='www.example.com'...)...Stand-alone parser...---------------------#!/usr/bin/env pythonfrom httperfpy import HttperfParserresults = HttperfParser.parse(httperf_result_string)print results["connection_time_avg"] + " is avg"print results["connection_time_max"] + " is max"Parser Keys:------------- command- max_connect_burst_length- total_connections- total_requests- total_replies- total_test_duration- connection_rate_per_sec- connection_rate_ms_conn- connection_time_min- connection_time_avg- connection_time_max- connection_time_median- connection_time_stddev- connection_time_connect- connection_length- request_rate_per_sec- request_rate_ms_request- request_size- reply_rate_min- reply_rate_avg- reply_rate_max- reply_rate_stddev- reply_rate_samples- reply_time_response- reply_time_transfer- reply_size_header- reply_size_content- reply_size_footer- reply_size_total- reply_status_1xx- reply_status_2xx- reply_status_3xx- reply_status_4xx- reply_status_5xx- cpu_time_user_sec- cpu_time_system_sec- cpu_time_user_pct- cpu_time_system_pct- cpu_time_total_pct- net_io_kb_sec- net_io_bps- errors_total- errors_client_timeout- errors_socket_timeout- errors_conn_refused- errors_conn_reset- errors_fd_unavail- errors_addr_unavail- errors_ftab_full- errors_other
Package: httperrors
Http errors provide a list of easy to test and descriptive set of python
errors.Code exampleRaising exceptionfrom httperrors import BadRequestError
class View(BaseView):
    def validate(self, request):
        ...
        if not request.body.is_json():
            raise BadRequestError(
                error_message="You must provide a JSON body",
                error_code="NOT_A_JSON_BODY_ERROR",
            )
    def run(self,request):
        ...SerializationYou will be able to catch this exception somewhere in the flow of your
application, map it and serialize it to the corresponding request.from httperrors import BadRequestError
class BaseView:
def __init__(self):
    try:
        self.validate()
    except BadRequestError as e:
        return json_response(
            status_code=e.status_code,
            body=e.serialize()
        )TestingYou will be able to easily test your applicationfrom httperrors import BadRequestError
class TestView:
def test_it_raises_bad_request_error_not_json_body(self):
    view = View()
    request = Mock()
    request.body.is_json.return_value = False
    with pytest.raises(BadRequestError) as error:
        view.validate()
        assert error.error_code == "NOT_A_JSON_BODY_ERROR"
Package: httpexceptor
httpexceptorWSGI middleware to handle HTTP responses using exceptionsprovides a group of exception classes representing non-2xx HTTP statuses, along
with a WSGI middleware to turn the exceptions into proper HTTP headersoriginally extracted fromTiddlyWebsource repository:https://github.com/tiddlyweb/httpexceptorUsagefrom httpexceptor import HTTPExceptor, HTTP404

# register middleware
app = HTTPExceptor(app)

# ...

if unavailable:
    raise HTTP404('resource unavailable')
Package: httpfaker
http-faker介绍灵活又简单的mock服务gitee地址：https://gitee.com/guojongg/http-fakerhttpfaker基于faker和flask库，提供强大的逻辑处理能力；通过对配置文件（yaml/json）的描述，可返回想要的任意数据。支持反向代理模式，只需要设置一个目标服务器地址，即可变成一个反向代理服务器；当匹配到mock规则时返回mock数据；未命中时做代理请求并返回请求结果。httpfaker针对返回数据的规则编写灵活，简单。除了可以满足传统的接口mock外，还支持处理业务逻辑，可实现真正的业务功能。适用于：前端人员： 前后端分离开发，无需等到后台接口实现即可开始进行页面请求测试人员： 提前进行接口测试代码编写；服务未至，用例先行其他需要写一个简单api的人员： 通过yaml文件配置，可减少开发代码；无需关注请求处理部分，只需关注自己的业务逻辑即可。简单使用# 安装pipinstallhttpfaker# 简单使用httpfakerinitcdhttpfaker-project
httpfaker--proxyhttp://example.com# 指定代理地址时，将作为代理服务器对未命中的请求自动转发到指定的服务器中上面例子中使用httpfaker init预生成了一个example.yml文件，yaml文件中描述了一个登录的场景：前端通过post方法调用/api/login这个地址，并在请求body中传来了username和password两个参数。httpfaker接收到请求后会按照logic中描述的逻辑进行业务处理：先打印了请求参数，再调用verify_accont方法，
来验证用户名和密码是否匹配；然后调用gen_token方法，生成token。（verify_account和gen_token方法已经注册到httpfaker调用函数中了，注册方法见自定义方法的注册）在逻辑处理完成后，httpfaker按照response中描述的内容进行字段返回，headers中引用了在env中定义的content_type;body中的code、msg、data等字段直接引用logic中已经生成的结果。在上述流程中完成了用户登录到返回数据的一个完整流程，包含了业务处理部分，使mock服务不仅仅只是mock，还可以包括真实的业务逻辑。配套工具http2api: httpfaker支持录入接口数据，使用http2api，只需要在前端进行请求，可以自动将请求内容转换为httpfaker可读的模板。swagger2api: 支持将swagger格式的接口数据直接转换为httpfaker可读的模板。其它使用httpfaker实现文件上传下载yaml文件编辑说明同时使用代理与mock说明
Package: http-file
http_fileUsageInstall using pip:$pipinstallhttp_fileРџСЂРёРјРµРЅРµРЅРёРµ.. РєРѕРґРѕРІС‹Р№ Р±Р»РѕРє :: python#РёРјРїРѕСЂС‚ РІСЃРїРѕРјРѕРіР°С‚РµР»СЊРЅС‹С… Р±РёР±Р»РёРѕС‚РµРє
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
import requests
#РёРјРїРѕСЂС‚ http_file
from http_file import download_file
#СЃРѕР·РґР°РЅРёРµ РЅРѕРІРѕР№ СЃРµСЃСЃРёРё
s = requests.Session()
#СЃРѕРµРґРµРЅРµРЅРёРµ СЃ СЃРµСЂРІРµСЂРѕРј С‡РµСЂРµР· СЃРѕР·РґР°РЅРЅСѓСЋ СЃРµСЃСЃРёСЋ
s.get('URL_MAIN', verify=False)
"""
Р·Р°РіСЂСѓР·РєР° С„Р°Р№Р»Р° РІ 'local_filename' РёР· 'fileUrl' С‡РµСЂРµР· СЃРѕР·РґР°РЅРЅСѓСЋ СЃРµСЃСЃРёСЋ
download_file('local_filename', 'fileUrl', s)
Package: httpfile-py
Python httpfile import loaderHow to use?Create http file, such ashttpbin.http### print my ip
//@name my-ip
GET https://httpbin.org/ipAddhttpfile-pypackage inrequirements.txtor other configuration fileWrite your code:importhttpfile.loader# noinspection PyUnresolvedReferencesimporthttpbinfromhttpximportResponseif__name__=='__main__':r:Response=httpbin.my_ip()print(r.json())Async supportIf you want to use async feature, please addasync_prefix to request name, code as following:importhttpfile.loader# noinspection PyUnresolvedReferencesimporthttpbinimportasynciofromhttpximportResponseasyncdefmy_ip():r:Response=awaithttpbin.async_my_ip()print(r.json())if__name__=='__main__':asyncio.run(my_ip())Attention: don't forget to addasynciopackage!Python HTTP Clientsurllib3:https://urllib3.readthedocs.io/Requests:https://requests.readthedocs.io/aiohttp:https://docs.aiohttp.org/GRequests:https://github.com/spyoungtech/grequestsHTTPX:https://www.python-httpx.org/httpfile-py uses HTTPX as http client.Referenceshttps://servicex.sh/