Saravanan666/pypi-org huggingface dataset:
Package: dnsimple-zoneimport
This script allows you to import a Bind zone file into your DNSimple account.InstallingTo install current version using pip, issue:$ sudo pip install dnsimple-zoneimportUsagednsimple_zoneimport--help:DNSimple Zone File Importer.

Usage:
    dnsimple_zoneimport -e <email> -t <api-token> <zonefile>
    dnsimple_zoneimport -h | --help
    dnsimple_zoneimport -v | --version

Options:
    -e            DNSimple email address.
    -t            DNSimple API token (see https://dnsimple.com/account).
    -h --help     Show this screen.
    -v --version  Show version.DevelopmentIf you have checked out the source code, start the script withpython -m dnsimple_zoneimport.importerTestingTo test, the pytest library is required:$ pip install pytestThen run the tests:$ py.testSourcecodeThe sourcecode is available on Github:https://github.com/wbrp/dnsimple-zoneimportCoding GuidelinesPEP8 viaflake8with max-line-width set
to 99 and E126-E128 ignored.VersioningThis project usesSemantic Versioning.LicenseThe code is licensed under the MIT license. SeeLICENSEfile for more details.
Package: dnskeeper
# dnskeeper-cloudflareTool for managing DNS records in cloudflare and storing them locally in JSON.## Installation:`sudo pip install dnskeeper`## Usage:```~#: dnskeeper --helpusage: dnskeeper <command> [<args>]The available dnskeeper commands are:config          Create config file for dnskeeperdiff            Display differences between local state and Cloudflarepull            Overwrite local records with current statepush            Deploy changes to Cloudflareshow            Show current state in Cloudflarevalidate        Test records file for proper formattingversion         Display versionTool for managing Cloudflare DNS, by Liferaypositional arguments:command     Subcommand to runoptional arguments:-h, --help  show this help message and exit```### Subcommands:Each subcommand has its own parameters that can be shown with a `-h`/`--help` flagExample:```~#: dnskeeper push -husage: dnskeeper [-h] [-d] [-o {json,simple,table}] domainDeploy changes to Cloudflarepositional arguments:domainoptional arguments:-h, --help            show this help message and exit-d, --dry-run         simulates the actions that would occur-o {json,simple,table}, --output {json,simple,table}```
Package: dnskeys
A Python Library for Authenticating Keys using DNS. This library was
written by Iain Learmonth and Sathyanarayanan Gunasekaran at the
Kings of Code Hack Battle 2014 with the support of Versign.The library provides functions to retrieve and validate fingerprints
for the following crypto systems:OTR (via otr1 TXT records)OpenPGP (via pka1 TXT records)DNSSEC validation information is passed to the application to allow for
the application to make trust decisions based on the user’s
preferences instead of hard-coding trust decisions.
Package: dns-lexicon
Manipulate DNS records on various DNS providers in a standardized/agnostic way.Table of ContentsWhy using Lexicon?Supported providersDocumentationContributingLicensingWhy using Lexicon?Lexicon provides a way to manipulate DNS records on multiple DNS providers in a standardized way.Lexicon can be used as:a CLI tool:# Create a TXT entry in domain.net zone hosted by CloudFlarelexiconcloudflarecreatedomain.netTXT--namefoo--contentbaror a Python library:# Create a TXT entry in domain.net zone hosted by CloudFlarefromlexicon.clientimportClientfromlexicon.configimportConfigResolverconfig=ConfigResolver().with_env().with_dict({"provider_name":"cloudflare","domain":"domain.net",})withClient(config)asoperations:operations.create_record("TXT","foo","bar")Lexicon was designed to be used in automation, specifically letsencrypt.Generating Intranet & Private Network SSL Certificates using Lets Encrypt & LexiconSupported providersOnly DNS providers who have an API can be supported bylexicon.The current supported providers are:aliyunauroraazurecloudflarecloudnscloudxnsconohaconstellixddnsdigitaloceandinahostingdirectadmindnsimplednsmadeeasydnsparkdnspoddnsservicesdreamhostduckdnsdynueasydnseasynameeuservexoscaleflexibleenginegandigehirnglesysgodaddygoogleclouddnsgransygratisdnshenethetznerhostingdehoverinfobloxinfomaniakinternetbsinwxjokerlinodelinode4localzoneluadnsmemsetmisakamythicbeastsnamecheapnamecomnamesilonetcupnfsnnjallansoneocionapponlineovhpleskpointhqporkbunpowerdnsrackspacerage4rcodezeroroute53safednssakuracloudsoftlayertransipultradnsvaluedomainvercelvultrwebgowedosyandexyandexcloudzeitzilorezonomiDocumentationOnline documentation (user guide, configuration reference) is available in theLexicon documentation.For a quick start, please have a look in particular at theUser guide.ContributingIf you want to help in the Lexicon development, you are welcome!Please have a look at theDeveloper guidepage to know how to start.LicensingMITLogo: transform by Mike Rowe from the Noun Project
Package: dnslink
DNSLink for PythonPython implementation of DNSLink protocol.DescriptionDNSLink is a very simple protocol to link content and services directly from DNS. DNSLink leverages the powerful distributed architecture of DNS for a variety of systems that require internet-scale mutable names or pointers. For more details seeDNSLink website.This package provides a simple way to get and resolve DNSLink TXT records for any domain name.InstallationRequirementsDNSLink requires Python 3.4 or higher.From PyPIThe recommended way to install DNSLink is from PyPI with PIP.pipinstalldnslinkFrom SourceAlternatively, you can also install it from the source.gitclonehttps://github.com/filips123/DNSLinkPy.gitcdDNSLinkPy
pythonsetup.pyinstallUsageYou can use aresolvefunction to resolve DNSLink records for a specific domain. It first tries to resolve the domain's_dnslinksubdomain and then fall back to the main domain if no records were found.Note:To illustrate examples, we will assume that domains are using this example DNSLink configuration.$dig+shortTXTexample.comdnslink=/ipfs/QmaYRVyPKpN8FXy9HS1t9Zhtjo4RpYXgiuNj1ins9fiLuWdnslink=/ipns/website.ipfs.io

$dig+shortTXTfoo.comdnslink=/dnslink/bar.com

$dig+shortTXTbar.comdnslink=/ipfs/QmaYRVyPKpN8FXy9HS1t9Zhtjo4RpYXgiuNj1ins9fiLuWThe function takes a domain name as a first (domain) argument and returns a list of all DNSLink records for that domain.importdnslinkdomain='example.com'records=dnslink.resolve(domain=domain)forrecordinrecords:print(record)# /ipfs/QmaYRVyPKpN8FXy9HS1t9Zhtjo4RpYXgiuNj1ins9fiLuW# /ipns/website.ipfs.ioIt is also possible to get only DNSLink records containing a specific protocol type. You can specify it as a second (protocol) argument.importdnslinkdomain='example.com'protocol='ipns'records=dnslink.resolve(domain=domain,protocol=protocol)forrecordinrecords:print(record)# /ipns/website.ipfs.ioAs RFC 1034 specifies, DNSLinks also supports chaining. If the record's protocol type isdnslink, it will try to resolve records of the domain that it is specified in it. The default recursion limit is 16. It is possible to change it with a third (depth) argument. When a recursion limit is reached, a record will be returned as is, without any future resolving.importdnslinkprint(dnslink.resolve(domain='foo.com')[0])# /ipfs/QmaYRVyPKpN8FXy9HS1t9Zhtjo4RpYXgiuNj1ins9fiLuWprint(dnslink.resolve(domain='foo.com',depth=1)[0])# /dnslink/bar.comYou can specify a custom DNSPython resolver object as a fourth (resolver) argument. This can be used to provide a custom resolver configuration.importdns.resolverimportdnslinkdomain='example.com'resolver=dns.resolver.Resolver()records=dnslink.resolve(domain=domain,resolver=resolver)forrecordinrecords:print(record)# /ipfs/QmaYRVyPKpN8FXy9HS1t9Zhtjo4RpYXgiuNj1ins9fiLuW# /ipns/website.ipfs.ioVersioningThis library usesSemVerfor versioning. For the versions available, seethe tagson this repository.LicenseThis library is licensed under the MIT license. See theLICENSEfile for details.
Package: dnslist
Author:Elie ROUDNINSKIdnslistis a Python package that allows to easily load domain list from
various sources and merge them together. It is mainly used for merging
ads/malware domain list together.Contents1Installation1.1Requirements1.2From github1.3From pip2Usage2.1Configuration2.2Generation2.3Template2.4Examples1Installation1.1Requirementsdnslistrequires Python 3. It has been tested on Python 3.6 on Linux.
For dependencies, see requirements.txt file.1.2From githubYou can clone this repository and install it with setuptools directly:$ python3 setup.py install --user1.3From pipAs every pip available package, you can install it easily with the pip package:$ python3 -m pip install --user dnslist2Usagednslistcomes with both a Python module and an executable tool.
You will more lilely want to use the executable directly.2.1ConfigurationFirst, you will need to create a configuration file with toml syntax:[source.yoyo]
url = "https://pgl.yoyo.org/adservers/serverlist.php?hostformat=nohtml&showintro=0"This file should most likely resides in ~/.config/dnslst/config.toml2.2GenerationThen you can just execute the dnslist executable tool:$ dnslist domains.txtThis should generate a domain.txt file in the current working directory.2.3TemplateYou can customize how the generated file looks like by providing a moustache
template:$ dnslist -t <path/to/template.moustache> domains.txtIf you need help with moustache syntax, you can check out the:Officiel moustache website:https://mustache.github.io/Underlying rendering module:https://github.com/noahmorrison/chevron2.4ExamplesTake a look at theexamples/directory for some classic configurations
or templates.
Package: dns-local
DescriptionSimple python3 DNS serverInstallationpython3-mpipinstalldns_localOr directly from sources:gitclonegit@github.com:doronz88/dns_local.gitcddns_local
python3-mpipinstall-e.UsageUsage: python -m dns_local [OPTIONS]

  Start a DNS implemented in Python

Options:
  --bind TEXT      bind address
  --tcp            enable TCP server
  --udp            enable UDP server
  --domain TEXT    domain reply (e.g. example\\.com:127.0.0.1)
  --fallback TEXT  fallback dns server (e.g. 8.8.8.8)
  --help           Show this message and exit.For example, consider the following usage:python3-mdns_local--bind192.168.2.1:53--udp--fallback8.8.8.8--domainkaki:192.168.2.1--domainkaki2:192.168.2.1This will start audpDNS server listening at192.168.2.1:53with the two entries:kaki1->192.168.2.1kaki2->192.168.2.1And use Google's DNS server (8.8.8.8) as a fallback for any entry not in given domain list.Domains also support regex patterns. For example, the following will forward all domains to 127.0.0.1, except for google.com which will be forwarded to 8.8.8.8:python3-mdns_local--bind192.168.2.1:53--udp--domain"google\\.com:8.8.8.8"--domain".*:127.0.0.1"
Package: dnslookup
DNSlookupdnslookup is a simple command line interface to check on the status of your world wide resolutions. It relies on the system installed nslookup to make requests.Installation:pip install dnslookupUsage:dnslookup facebook.com
Result for facebook.com
Country 	DNS IP 		Result
BD 	203.112.202.195 	 173.252.110.27
BE 	   195.35.110.4 	 173.252.110.27
BG 	  213.169.55.10 	 173.252.110.27
BM 	   206.53.177.3 	 173.252.110.27
BO 	  200.58.161.25 	 173.252.110.27
JP 	221.186.252.130 	 173.252.110.27
JM 	    200.9.115.2 	 173.252.110.27positional arguments:
  domain                The domain that you would like to use.

optional arguments:
  -h, --help            show this help message and exit
  --level LEVEL, -l LEVEL
                        This option allows you to: (1) use a large database of
                        DNS Servers from public-dns.info (2) Use just the
                        google DNS Servers. (3) Use your own server list.
                        
  --file FILE, -f FILE  If provided, it will output to the file instead of
                        console. File must be a csv
  --url URL             URL to use with option (3) of levelPlease let me know if there are other features you'd like
Package: dnslookup-module
DNSLookupThe DNSLookup module provides a simple interface for performing DNS lookups in Python. It allows you to easily retrieve the IP addresses associated with a given domain name.InstallationTo install the DNSLookup module, simply clone the repository and run the following command:gitclonehttps://github.com/melihteke/dnslookup-module.gitUsageHere's an example of how to use the DNSLookup module to perform a DNS lookup:pipinstalldnslookup-module(.venv)MTeke1@APKM2W42362BA4dnslookup-module%ipython
Python3.8.9(default,Apr132022,08:48:06)Type'copyright','credits'or'license'formoreinformation
IPython8.12.0--AnenhancedInteractivePython.Type'?'forhelp.

In[1]:fromdnslookupimportDNSLookup

In[2]:query=DNSLookup(domain="www.mteke.com")In[3]:query.get_ip()Out[3]:['81.129.175.158']In[4]:API ReferenceDNSLookupThe DNSLookup class represents a DNS lookup object.Constructorinit(self, domain: str) -> None
Creates a new DNSLookup object for performing DNS lookups.Argumentsdomain (str): The domain name to look up.Methodsget_ip(self) -> List[str]
Performs a DNS lookup and returns the IP address(es) associated with the domain.Returnslist (str): A list of IP addresses associated with the domain.
Raises
socket.gaierror: If the DNS lookup fails.
Package: dns-manager
dns-manager一个可扩展的 DNS 管理工具。安装使用 pip/pipx 安装在此之前请确保安装Python3.10及以上版本，并安装了pip。pipinstalldns-manager[all]如果想要尝试 Nightly 版本，可尝试（需确保使用Python3.12）pipinstallgit+https://github.com/zrr1999/dns-manager@main在此之前请确保安装了pipx。pipxinstalldns-manager[all]源码安装（需确保使用Python3.12）gitclonehttps://github.com/zrr1999/dns-managercddns-manager
pipinstall.使用说明首先创建一个配置文件，例如sdns.json，内容如下：{"domain":"mydomain.com","records":[["test",// 也就是 test.mydomain.com 指向的路径"baidu.com"// 解析值，目前只支持 A 记录和 CNAME 记录，会根据此处的值自动判断],]}然后执行以下命令：dns-managerupdate--path~/.config/dns-manager/sdns.json此时，你的解析记录就会增加一条test.mydomain.com的 CNAME 记录指向baidu.com。维护者@zrr1999如何贡献非常欢迎你的加入！提一个 Issue或者提交一个Pull Request。贡献者感谢以下参与项目的人：使用许可GNU© Rongrui Zhan
Package: dnsmeapi
Dnsmeapi Python clientsimplify dnsmadeeasy api calls :-https://api-docs.dnsmadeeasy.com/?version=latest#6a7eef29-27fb-4f37-af89-e3ec4a3dcf66Python 3.7TestsFrom the project root directoryexport PYTHONPATH=$(pwd)
pytest .Dnsmeapi Classclass Dnsmeapi:
    hmac = None
    request_date = None
    api_key = ""
    api_secret_key = ""

    def __init__(self, api_key, api_secret_key):
        self.api_key = api_key
        self.api_secret_key = api_secret_key

    def make_request(self, method_type, url, payload):
        self.request_date = formatdate(timeval=None, localtime=False, usegmt=True)
        try:
            self.hmac = hmac.new(
                bytes(self.api_secret_key, "UTF-8"),
                bytes(self.request_date, "UTF-8"),
                hashlib.sha1,
            ).hexdigest()
        except Exception as e:
            raise e

        headers = {
            "Content-Type": "application/json",
            "x-dnsme-hmac": self.hmac,
            "x-dnsme-apiKey": self.api_key,
            "x-dnsme-requestDate": self.request_date,
        }

        try:
            response = requests.request(method_type, url, headers=headers, data=payload)
            return response.text.encode('utf-8')
        except Exception as e:
            raise eImportfrom dnsmeapi import DnsmeapiInitalise classdnsmeapi = Dnsmeapi(
"api_key", "api_secret_key"
)Send Requestdnsmeapi.make_request(
"GET", "URL", {}
)
Package: dnsmock
DNS MockPython DNS Mock to bypass current DNS resolution. Emulates /etc/hosts inside a container.RequirementsThe dnsmock segment requires the standard library modulesocket. It provides access to the BSD socket interface.InstallationUsing pippipinstalldnsmockUsage exampleimportdnsmockimportrequestsdnsmock.bind_ip('www.example.com',443,'127.0.0.1')response=requests.get('https://www.example.com',verify=True)print(response.text)AuthorsOriginally created by@imjoseangelLicenseLicensed underthe MIT License.
Package: dns-mollusc
dns-molluscA simple, synchronous, rate-limiting DoH client to check if a given response is filtered by the specified resolver.dns-mollusc does the bare minimum to reliably accomplish the above job, and isnotintended as a general purpose DoH client. For excellent DNS shenanigans in Python, I'd recommenddnspython.Usagedns-mollusc uses Cloudflare's secure DNS as default, which blocks known-malicious domains, with a rate limit of 100 queries per second. If no query type is given, dns-mollusc will query for an A record (IPv4 address). The simplest usage of dns-mollusc would be:from dns_mollusc import mollusc_client

client = mollusc_client()
result = client.query("malware.testcategory.com")
result.is_blocked_by_server()  # returns TrueHowever, you can set your preferred resolver and/or rate limit, such as using Adguard DNS and a QPS limit of 10 requests/s:client = mollusc_client("https://dns.adguard.com/resolve?", 10)And when querying, you can request any record type (though resolvers may not filter all request types):result = client.query("malware.testcategory.com", "AAAA")Known-Supported Resolversdns-mollusc uses a non-standard DoH JSON API popularized by Google's public DNS service. It does not (and will not in the future) implement RFC 8484, which limits the number of resolves that work with dns-mollusc. The following resolvers are tested and working, sorted by what they filter.Filters malware:Cloudflare Secure DNS,https://security.cloudflare-dns.com/dns-query?Filters adult content and malware:Cloudflare Family DNS,https://family.cloudflare-dns.com/dns-query?Filters ads:Adguard DNS,https://dns.adguard.com/resolve?Filters (almost) whatever you want:NextDNS, subscription-only (copy the "DNS-over-HTTPS" endpoint from your account's Setup tab)Unfiltered:Google DNS (8.8.8.8),https://dns.google/resolve?Cloudflare DNS (1.1.1.1),https://cloudflare-dns.com/dns-query?NextDNS public,https://dns.nextdns.io/dns-query?Why?A bot used on r/cybersecurity checks any live links in comments and posts for obviously malicious or unwanted content (the logic included here was originally ripped from that bot). This allows us to get low-grade but constantly-updated protection as asupplementto other tools that we have.The name "dns-mollusc" stems from the fact that molluscs can be used to monitor water for contamination, often in conjunction with more sophisticated methods. FromWikipedia:Bivalve molluscs are used as bioindicators to monitor the health of aquatic environments in both fresh water and the marine environments. Their population status or structure, physiology, behaviour or the level of contamination with elements or compounds can indicate the state of contamination status of the ecosystem. ... Potamopyrgus antipodarum is used by some water treatment plants to test for estrogen-mimicking pollutants from industrial agriculture.I was going to go with "dns-clam" but didn't want people to associate it with ClamAV.
Package: dnsmule-plugins
Plugins for DNSMuleIt is recommended to look through each module to see what arguments they take.CertcheckArguments:rules:-name:certcheckrecord:Atype:'ip.certs'config:ports:# Ports to scan-443-8443timeout:1# timeout for cert fetchingstdlib:false# Prefer STDLIB implementationcallback:false# Whether a callback should be called for resolved domainsScans any resolvedAorAAAArecord for certificates from a given list of ports.
There are two ways to scan for certificates, a Python stdlib solution and one withcryptographylibrary parsing certs.Tags are produced for cert issuer:IP::CERTS::{rule_name}::ISSUER::{issuer_rfc_string}More data is available inresult.data:result.data['resolvedCertificates']=certificates_as_list_of_dictsSee theCertificatedataclassto_jsonmethod incertificates.py.The plugin takes a callback argument for any domains resolved from certificate common and alternative names.This plugin requires the following dependencies:cryptography(optional)IPRangesArguments:rules:-name:iprangesrecord:Atype:'ip.ranges'config:providers:# Lowercase only-amazon-google-microsoftScans any resolvedAorAAAArecord for addresses in the major cloud provider ranges.
Currently, supports the following providers:MicrosoftGoogle CloudAmazon AWSProvider IP ranges are refreshed on one hour intervals.This provides tags like:IP::RANGES::{rule_name}::{provider}::{service}::{region}
IP::RANGES::SAMPLE_RULE::AMAZON::LAMBDA::US-WEST-1This plugin requires the following dependencies:httpxPTRScanArguments:rules:-name:ptrscanrecord:Atype:'ip.ptr'Scans any resolvedAorAAAArecord for a matchingPTRrecord.
The pointer is used to discover automatically generated cloud provider pointer records for services.
The plugin tries to detect pointer records where the ip of theAorAAAArecord is present in any of the following
forms:dot separateddot separated reverseddash separateddash separated reversedAny of the above anywhere in the stringThis resolves to a provider with the prefix removed from the record.For example aPTRof the form with a rule namesample_rule123.456.789.000 IN PTR CDN-123-456-789-000.area.hoster.example.comwould produce a tag of the formIP::PTR::SAMPLE_RULE::AREA.HOSTER.EXAMPLE.COMAny resolvedPTRrecords are also added toresult.data['resolvedPointers'].ExampleIn YAML the plugins are placed in their ownpluginsblock:plugins:-name:dnsmule_plugins.PTRScanPlugin-name:dnsmule_plugins.IPRangesPlugin-name:dnsmule_plugins.CertCheckPluginconfig:callback:falseHere is an example of how to add a ruleset containing all plugins to aDNSMuleinstance.fromdnsmuleimportDNSMule,RRType,Rulesfromdnsmule.backends.dnspythonimportDNSPythonBackendfromdnsmule.loaderimportload_and_append_rulefromdnsmule_pluginsimportcertcheck,ipranges,ptrscanmule=DNSMule.make(Rules(),DNSPythonBackend())certcheck.CertCheckPlugin(callback=False).register(mule)ipranges.IPRangesPlugin().register(mule)load_and_append_rule(mule.rules,RRType.A,'ip.certs',{'name':'certcheck',},)load_and_append_rule(mule.rules,RRType.A,'ip.ranges',{'name':'ipranges','providers':['amazon','microsoft','google',]},)ptrscan.PTRScanPlugin().register(mule)load_and_append_rule(mule.rules,RRType.A,'ip.ptr',{'name':'ptrscan'},)
Package: dns-observe
dns-observea simple client to observe dns pollution network situation under The Great Firewall of China.So far, only type A DNS queries have been implemented.installpip install dns-observeusagecli> dns-observe -h
usage: dns-observe [-h] [-s SERVER] [-w WAIT] [-v] domain

Observing DNS pollution

positional arguments:
  domain                query domain

options:
  -h, --help            show this help message and exit
  -s SERVER, --server SERVER
                        DNS server (default: 1.1.1.1)
  -w WAIT, --wait WAIT  wait time (default: 3)
  -v, --version         show program's version number and exitpythonfrom dns_observe import DNSQuery
dns = DNSQuery('1.1.1.1')
dns.query('api.openai.com')

""" output
Time: 2023-04-08 23:16:19.217111, Name: api.openai.com, TTL: 280, Data: 199.96.61.1
Time: 2023-04-08 23:16:19.218111, Name: api.openai.com, TTL: 433, Data: 204.79.197.217
Time: 2023-04-08 23:16:19.358490, Name: api.openai.com, TTL: 7, Data: 104.18.7.192
Time: 2023-04-08 23:16:19.358490, Name: api.openai.com, TTL: 7, Data: 104.18.6.192
"""How to Packaging Python Projectshttps://packaging.python.org/en/latest/tutorials/packaging-projects/python -m build

# testpypi
py -m twine upload --repository testpypi dist/*

# pypi
py -m twine upload dist/*
Package: dns_over_https
Simple Python client for Google’s PublicDNS-over-HTTPSservice.Quickstart>>>fromdns_over_httpsimportSecureDNS>>>r=SecureDNS()>>>r.gethostbyname('www.breakpoint-labs.com')u'37.60.235.49'>>>r=SecureDNS(query_type='AAAA')>>>r.gethostbyname('www.google.com')u'2607:f8b0:400d:c02::6a'>>>r.resolve('www.mit.edu')[u'2001:590:100b:182::255e',u'2001:590:100b:18b::255e']>>>InstallationTo install dns_over_https, simply:$pipinstalldns_over_httpsDocumentationComing soon.LicenseMIT
Package: dnspod-sdk
A dnspod api SDK.官方API文档安装pipinstalldnspod-sdk使用fromdnspod_sdkimportDnspodClienttoken_id=0token="<your token>"user_agent="程序英文名称/版本(联系邮箱))"dc=DnspodClient(token_id,token,user_agent)r=dc.post("/Info.Version")print(r.json())r=dc.post("/Domain.List",data={"type":"all","length":1})print(r.json())