The d8s-networking package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-hashes package. The affected version is 0.1.0.

**Project description**

**Democritus Networking**

      

Democritus functions\[1\] for working with network requests.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s as an abbreviation for democritus (you can read more about this here).

**Functions**

*   def requests\_basic\_auth(user, password):
        """Return an instance of request's basic auth."""
    
*   def get(
        url,
        \*,
        use\_common\_user\_agent: bool \= True,
        process\_response: bool \= False,
        process\_response\_as\_bytes: bool \= False,
        \*\*request\_kwargs,
    ):
        """Make a GET request to the given URL."""
    
*   def head(url, \*, process\_response: bool \= False, \*\*kwargs):
        """Make a head request."""
    
*   def post(
        url,
        \*,
        update\_headers\_for\_datatype: bool \= True,
        process\_response: bool \= False,
        process\_response\_as\_bytes: bool \= False,
        \*\*request\_kwargs,
    ):
        """Make a POST request to the given URL with the given data."""
    
*   def headers\_update(headers: Dict\[str, str\], new\_header\_key: str, new\_header\_value: Any, \*, overwrite: bool \= True):
        """."""
    
*   def put(
        url,
        \*,
        update\_headers\_for\_datatype: bool \= True,
        process\_response: bool \= False,
        process\_response\_as\_bytes: bool \= False,
        \*\*request\_kwargs,
    ):
        """Make a PUT request to the given URL with the given data."""
    
*   def delete(
        url,
        \*,
        process\_response: bool \= False,
        process\_response\_as\_bytes: bool \= False,
        \*\*request\_kwargs,
    ):
        """Make a DELETE request to the given URL with the given data."""
    
*   def url\_hash(url, hash\_type\='sha256'):
        """Return the hash of the url."""
    
*   def urllib3\_backoff\_factor\_executions(backoff\_factor: float, number\_of\_requests: int):
        """Return the times (in seconds) of the first n requests with the given backoff\_factor. See https://urllib3.readthedocs.io/en/latest/reference/index.html#urllib3.Retry under the "backoff\_factor" argument."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

CVE-2022-42042: d8s-networking

The d8s-file-system package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-hashes package. The affected version is 0.1.0.

Democritus functions\[1\] for working with files and directories.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

Once imported, you can use any of the functions listed below.

*   def is\_file(path: str) \-> bool:
        """Determine if the given path is a file."""
    
*   def file\_read(file\_path: str) \-> str:
        """Read the file at the given file\_path as a string."""
    
*   def file\_read\_bytes(file\_path: str) \-> bytes:
        """Read the file at the given file\_path as bytes."""
    
*   def file\_write(file\_path: str, file\_contents: Any) \-> bool:
        """Write the given content to the file at the given path (including a file name)."""
    
*   def file\_append(file\_path: str, file\_contents: Any) \-> bool:
        """Append the given content to the file at the given path (including a file name)."""
    
*   def file\_move(starting\_path: str, destination\_path: str):
        """Move the file from the starting path to the destination path."""
    
*   def file\_copy(starting\_path: str, destination\_path: str, \*, preserve\_metadata: bool \= False):
        """Copy the file from the starting\_path to the destination path."""
    
*   def file\_delete(file\_path: str):
        """Delete the given file."""
    
*   def file\_owner\_name(file\_path: str) \-> str:
        """Find the owner of the file at the given path."""
    
*   def file\_change\_owner(file\_path: str):
        """Change the ownership of the given file."""
    
*   def file\_ssdeep(file\_path: str) \-> str:
        """Find the ssdeep fuzzy hash of the file."""
    
*   def file\_md5(file\_path: str) \-> str:
        """Find the md5 hash of the given file."""
    
*   def file\_sha1(file\_path: str) \-> str:
        """Find the sha1 hash of the given file."""
    
*   def file\_sha256(file\_path: str) \-> str:
        """Find the sha256 hash of the given file."""
    
*   def file\_sha512(file\_path: str) \-> str:
        """Find the sha512 hash of the given file."""
    
*   def file\_name\_escape(file\_name\_arg: str) \-> str:
        """Escape the name of a file so that it can be used as a file name in a file path."""
    
*   def file\_name(file\_path: str) \-> str:
        """Find the file name from the given file path."""
    
*   def file\_name\_windows(windows\_file\_path: str) \-> str:
        """Find the file name from the given windows\_file\_path."""
    
*   def file\_name\_unix(unix\_file\_path: str) \-> str:
        """Find the file name from the given unix\_file\_path."""
    
*   def file\_size(file\_path: str) \-> int:
        """Find the file size."""
    
*   def file\_directory(file\_path: str) \-> str:
        """Return the directory in which the given file resides."""
    
*   def file\_details(file\_path: str) \-> Dict\[str, Union\[str, int\]\]:
        """Get file hashes and file size for the given file."""
    
*   def file\_exists(file\_path: str) \-> bool:
        """Check if the file exists."""
    
*   def file\_is\_readable(file\_path: str) \-> bool:
        """Check if the file is readable."""
    
*   def file\_is\_writable(file\_path: str) \-> bool:
        """Check if the file is writable."""
    
*   def file\_is\_executable(file\_path: str) \-> bool:
        """Check if the file is executable."""
    
*   def file\_contains(file\_path: str, pattern: str, \*, pattern\_is\_regex: bool \= False) \-> bool:
        """Return whether or not the file contains the given pattern."""
    
*   def file\_search(file\_path: str, pattern: str, \*, pattern\_is\_regex: bool \= False) \-> List\[str\]:
        """Search for the given pattern in the file."""
    
*   def file\_name\_matches(file\_path: str, pattern: str) \-> bool:
        """Return whether or not the file name contains the given pattern."""
    
*   def is\_directory(path: str) \-> bool:
        """Determine if the given path is a directory."""
    
*   def directory\_exists(directory\_path: str) \-> bool:
        """Check if the directory exists."""
    
*   def directory\_file\_names(directory\_path: str, \*, recursive: bool \= False) \-> List\[str\]:
        """List files at the given directory\_path."""
    
*   def directory\_file\_paths(directory\_path: str, \*, recursive: bool \= False) \-> List\[str\]:
        """List the file paths at the given directory\_path."""
    
*   def directory\_copy(src\_path: str, dst\_path: str):
        """Copy the directory from the src\_path to the destination path."""
    
*   def directory\_delete(directory\_path: str):
        """Delete the given directory."""
    
*   def directory\_create(directory\_path: str, mode\=0o777):
        """Create a directory."""
    
*   def directory\_disk\_usage(directory\_path: str):
        """Return the disk usage for the given directory."""
    
*   def directory\_disk\_free\_space(directory\_path: str):
        """Return the free space in the given directory."""
    
*   def directory\_disk\_used\_space(directory\_path: str):
        """Return the used space in the given directory."""
    
*   def directory\_disk\_total\_space(directory\_path: str):
        """Return the total space in the given directory."""
    
*   def home\_directory() \-> str:
        """Return the home directory."""
    
*   def home\_directory\_join(path: str) \-> str:
        """Join the given path with the home directory."""
    
*   def directory\_move(src\_path: str, dst\_path: str):
        """Move the directory from the src\_path to the dst\_path."""
    
*   def directory\_files\_details(directory\_path: str, \*, recursive: bool \= False) \-> Dict\[str, Dict\[str, Union\[str, int\]\]\]:
        """Return the file details for each file in the directory at the given path."""
    
*   def directory\_files\_read(directory\_path: str, \*, recursive: bool \= False) \-> Iterable\[Tuple\[str, str\]\]:
        """Read all files in the directory\_path."""
    
*   def directory\_subdirectory\_names(directory\_path: str, \*, recursive: bool \= False) \-> List\[str\]:
        """List the names of all subdirectories in the given directory."""
    
*   def directory\_files\_containing(
        directory\_path: str, pattern: str, \*, pattern\_is\_regex: bool \= False, recursive: bool \= False
    ) \-> Dict\[str, List\[str\]\]:
        """Search for the given pattern in all files in the given directory\_path."""
    
*   def directory\_file\_paths\_matching(directory\_path: str, pattern: str, \*, recursive: bool \= False) \-> List\[str\]:
        """Return the paths of all of the files in the given directory which match the pattern."""
    
*   def directory\_file\_names\_matching(directory\_path: str, pattern: str, \*, recursive: bool \= False) \-> List\[str\]:
        """Return the names of all of the files in the given directory which match the pattern."""
    
*   def directory\_read\_files\_with\_path\_matching(
        directory\_path: str, pattern: str, \*, recursive: bool \= False
    ) \-> Iterable\[Tuple\[str, str\]\]:
        """Read all of the files in the given directory whose paths match the given pattern."""
    
*   def atomic\_write(fpath, \*, overwrite: bool \= True, \*\*cls\_kwargs):
        """Create a context manager to write atomically using the AtomicWriterPerms class to update file permissions."""
    

👋  If you want to get involved in this project, we have some short, helpful guides below:

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

CVE-2022-42041: d8s-file-system

The d8s-algorithms package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-dicts package. The affected version is 0.1.0.

Democritus functions for working with Python dictionaries.

*   Project description
*   Project details
*   Release history
*   Download files

**Project description**

  

Democritus functions\[1\] for working with Python dictionaries.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

**Usage**

Coming soon...

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Project details**  

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution**

Close

**Hashes for democritus\_dicts-2021.1.2101.tar.gz**

Hashes for democritus\_dicts-2021.1.2101.tar.gz

Algorithm

Hash digest

SHA256

75026b9b2dd8e7eca93e14c63c30b57cfa6100336f31a2ac76b298b027046b4a

MD5

e17d127d3e5cc574ceacb1771edeea75

BLAKE2-256

8dcb81fb37479bbea57a84b7c2cce66cc5e09c9e616ae6862acb4899f4ce934f

CVE-2022-42040: democritus-dicts

The d8s-ip-addresses package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-csv package. The affected version is 0.1.0.

We discovered a potential code execution backdoor in version 0.1.0 of the project, the backdoor is the democritus-csv package. Attackers can upload democritus-csv packages containing arbitrary malicious code. For the safety of this project, the democritus-csv package has been uploaded by us.

The democritus-csv package can be successfully installed using pip install d8s-ip-addresses==0.1.0

Suggestion: remove version 0.1.0 of this project in PyPI

CVE-2022-42038: code execution backdoor · Issue #14 · democritus-project/d8s-ip-addresses

The d8s-asns package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-csv package. The affected version is 0.1.0.

We discovered a potential code execution backdoor in version 0.1.0 of the project, the backdoor is the democritus-csv package. Attackers can upload democritus-csv packages containing arbitrary malicious code. For the safety of this project, the democritus-csv package has been uploaded by us.

The democritus-csv package can be successfully installed using pip install d8s-asns==0.1.0

Suggestion: remove version 0.1.0 of this project in PyPI

CVE-2022-42037: code execution backdoor · Issue #9 · democritus-project/d8s-asns

The d8s-urls package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-csv package. The affected version is 0.1.0.

**Project description**

**Democritus Urls**

      

Democritus functions\[1\] for working with URLs.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

**Installation**

    pip install d8s-urls
    

**Usage**

You import the library like:

from d8s\_urls import \*

Once imported, you can use any of the functions listed below.

**Functions**

*   def url\_scheme(url: str) \-> str:
        """Return the scheme of the url."""
    
*   def url\_fragment(url: str) \-> str:
        """Return the fragment of the url."""
    
*   def url\_examples(n: int \= 10) \-> List\[str\]:
        """Create n URLs."""
    
*   def urls\_find(text: str, \*, domain\_name: str \= '', \*\*kwargs) \-> List\[str\]:
        """Parse URLs from the given text. If a domain name is given, only urls with the given domain name will be returned."""
    
*   def url\_canonical\_form(url: str) \-> str:
        """Get the canonical url."""
    
*   def url\_scheme\_remove(url: str):
        """Remove the scheme from the given URL."""
    
*   def url\_query\_strings\_remove(url: str) \-> str:
        """Return the URL without any query strings."""
    
*   def url\_query\_strings(url: str) \-> Dict\[str, List\[str\]\]:
        """Return all of the query strings in the url."""
    
*   def url\_query\_string(url: str, query\_string: str) \-> List\[str\]:
        """Return the value of the given query string in the given url."""
    
*   def url\_query\_string\_add(url: str, query\_string\_field: str, query\_string\_value: str) \-> str:
        """."""
    
*   def url\_query\_string\_remove(url: str, query\_string\_field\_to\_remove: str) \-> str:
        """Remove the query string at the given field."""
    
*   def url\_query\_string\_replace(url: str, query\_string\_field: str, query\_string\_value: str) \-> str:
        """."""
    
*   def url\_path(url: str) \-> str:
        """Return the path of the url."""
    
*   def url\_path\_segments(url: str) \-> List\[str\]:
        """Return all of the segments of the url path."""
    
*   def url\_fragments\_remove(url: str) \-> str:
        """Return the URL without any fragments."""
    
*   def url\_file\_name(url: str) \-> str:
        """Get the file name of the URL."""
    
*   def url\_domain(url: str) \-> str:
        """Return the domain of the given URL."""
    
*   def get\_first\_arg\_url\_domain(func):
        """If the first argument is a url, get the domain of the url and pass that into the function."""
    
*   def url\_domain\_second\_level\_name(url: str) \-> str:
        """Find the second level domain name for the URL (e.g. 'http://example.com/test/bingo' => 'example') (see https://en.wikipedia.org/wiki/Domain\_name#Second-level\_and\_lower\_level\_domains)."""
    
*   def url\_join(url: str, path: str):
        """Join the URL to the URL path."""
    
*   def is\_url(possible\_url: str) \-> bool:
        """Check if the given string is a URL."""
    
*   def url\_screenshot(url: str, output\_file\_path: str \= '') \-> bytes:
        """."""
    
*   def url\_as\_punycode(url: str) \-> str:
        """Convert the domain name of the URL to Punycode."""
    
*   def url\_as\_unicode(url: str) \-> str:
        """Convert the domain name of the URL to Unicode."""
    
*   def url\_simple\_form(url: str) \-> str:
        """Return the URL without query strings or fragments."""
    
*   def url\_schemes() \-> List\[str\]:
        """Get the url schemes from https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml."""
    
*   def url\_from\_google\_redirect(url: str) \-> Optional\[str\]:
        """Get the url from the google redirect."""
    
*   def url\_encode(url: str) \-> str:
        """Encode the URL using percent encoding (see https://en.wikipedia.org/wiki/Percent-escape)."""
    
*   def url\_decode(url: str) \-> str:
        """Decode a percent encoded URL (see https://en.wikipedia.org/wiki/Percent-escape)."""
    
*   def url\_base\_form(url: str) \-> str:
        """Get the base URL without a path, query strings, or other junk."""
    
*   def url\_rank(url: str) \-> int:
        """."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

CVE-2022-42036: d8s-urls

The d8s-pdfs package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-urls package. The affected version is 0.1.0.

**Project description**

**Democritus Pdfs**

      

Democritus functions\[1\] for working with PDFs.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

**Installation**

    pip install d8s-pdfs
    

**Usage**

You import the library like:

from d8s\_pdfs import \*

Once imported, you can use any of the functions listed below.

**Functions**

*   def pdf\_read(pdf\_path: str) \-> Iterable\[str\]:
        """Get the string from the PDF at the given path/URL."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

CVE-2022-41387: d8s-pdfs

The d8s-utility package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-urls package. The affected version is 0.1.0.

Democritus functions for working with URLs.

*   Project description
*   Project details
*   Release history
*   Download files

**Project description**

  

Democritus functions\[1\] for working with URLs.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

**Usage**

Coming soon...

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Project details**  

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution**

Close

**Hashes for democritus\_urls-2021.1.2501.tar.gz**

Hashes for democritus\_urls-2021.1.2501.tar.gz

Algorithm

Hash digest

SHA256

b829e62e43629fe7082ef108c36a7002bb02860a19d8b760257d92af6b13c3de

MD5

ff906539588371bd27c7ab381e0f4953

BLAKE2-256

ce6ada2bfa7fa8c51f5ad34d3934e524cf4a6b1e4f2b09ed23108b8476270bb6

CVE-2022-41386: democritus-urls

The d8s-html package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-urls package. The affected version is 0.1.0.

**Project description**

**Democritus Html**

      

Democritus functions\[1\] for working with HTML.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

**Installation**

    pip install d8s-html
    

**Usage**

You import the library like:

from d8s\_html import \*

Once imported, you can use any of the functions listed below.

**Functions**

*   def html\_text(html\_content: StringOrBeautifulSoupObject) \-> str:
        """."""
    
*   def html\_unescape(html\_content: StringOrBeautifulSoupObject) \-> str:
        """."""
    
*   def html\_escape(html\_content: StringOrBeautifulSoupObject) \-> str:
        """."""
    
*   def html\_to\_markdown(html\_content: StringOrBeautifulSoupObject, \*\*kwargs) \-> str:
        """Convert the html string to markdown."""
    
*   def html\_find\_comments(html\_content: StringOrBeautifulSoupObject) \-> str:
        """Get a list of all of the comments in the html strings."""
    
*   def html\_soupify(html\_string: str, parser: str \= 'html.parser') \-> bs4.BeautifulSoup:
        """Return an instance of beautifulsoup with the html."""
    
*   def html\_remove\_tags(html\_content: StringOrBeautifulSoupObject) \-> bs4.BeautifulSoup:
        """."""
    
*   def html\_remove\_element(html\_content: StringOrBeautifulSoupObject, element\_tag: str) \-> bs4.BeautifulSoup:
        """."""
    
*   def html\_find\_css\_path(html\_content: StringOrBeautifulSoupObject, css\_path: str) \-> ListOfBeautifulSoupTags:
        """Find the given css\_path in the html\_content."""
    
*   def html\_elements\_with\_class(
        html\_content: StringOrBeautifulSoupObject, html\_element\_class: str
    ) \-> ListOfBeautifulSoupTags:
        """Find all elements with the given class from the html string."""
    
*   def html\_elements\_with\_id(html\_content: StringOrBeautifulSoupObject, html\_element\_id: str) \-> ListOfBeautifulSoupTags:
        """Find all elements with the given html\_element\_id from the html\_content."""
    
*   def html\_elements\_with\_tag(html\_content: StringOrBeautifulSoupObject, tag: str) \-> ListOfBeautifulSoupTags:
        """."""
    
*   def html\_headings\_table\_of\_contents(html\_content: StringOrBeautifulSoupObject) \-> ListOfBeautifulSoupTags:
        """."""
    
*   def html\_headings\_table\_of\_contents\_string(
        html\_content: StringOrBeautifulSoupObject, \*, indentation: str \= '  '
    ) \-> str:
        """."""
    
*   def html\_headings(html\_content: StringOrBeautifulSoupObject) \-> ListOfBeautifulSoupTags:
        """."""
    
*   def html\_to\_json(html\_content: StringOrBeautifulSoupObject, \*, convert\_only\_tables: bool \= False):
        """Convert the html to json using https://gitlab.com/fhightower/html-to-json."""
    
*   def html\_soupify\_first\_arg\_string(func):
        """Return a Beautiful Soup instance of the first argument (if it is a string)."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

CVE-2022-41385: d8s-html

The d8s-domains package for Python, as distributed on PyPI, included a potential code-execution backdoor inserted by a third party. The backdoor is the democritus-urls package. The affected version is 0.1.0.

**Project description**

**Democritus Domains**

      

Democritus functions\[1\] for working with domains.

\[1\] Democritus functions are _simple, effective, modular, well-tested, and well-documented_ Python functions.

We use d8s (pronounced "dee-eights") as an abbreviation for democritus (you can read more about this here).

**Installation**

    pip install d8s-domains
    

**Usage**

You import the library like:

from d8s\_domains import \*

Once imported, you can use any of the functions listed below.

**Functions**

*   def is\_domain(possible\_domain: str) \-> bool:
        """Check if the given string is a domain."""
    
*   def domain\_examples(n: int \= 10) \-> List\[str\]:
        """Create n domain names."""
    
*   def domains\_find(text: str, \*\*kwargs: bool) \-> List\[str\]:
        """Parse domain names from the given text."""
    
*   def domain\_dns(domain: str) \-> str:
        """Get the DNS results for the given domain."""
    
*   def domain\_certificate\_peers(domain: str) \-> List\[str\]:
        """Return a list of all domains sharing a certificate with the given domain."""
    
*   def domain\_whois(domain: str) \-> Optional\[Dict\[str, Any\]\]:
        """."""
    
*   def domain\_subdomains(domain\_name: str) \-> str:
        """Get the subdomains for the given domain name."""
    
*   def domain\_second\_level\_name(domain\_name: str) \-> str:
        """Get the second level name for the given domain name (e.g. google from https://google.co.uk)."""
    
*   def domain\_tld(domain\_name: str) \-> str:
        """Get the top level domain for the given domain name."""
    
*   def domain\_rank(domain\_name: str) \-> int:
        """."""
    
*   def domain\_is\_member(domain\_to\_check: str, domain\_base: str) \-> bool:
        """Given two domains, check if the first domain is a member of the second domain.
    A member means it is either the domain itself, or a subdomain of the domain."""
    
*   def domain\_as\_punycode(domain\_name: str) \-> str:
        """Convert the given domain name to Punycode (https://en.wikipedia.org/wiki/Punycode)."""
    
*   def domain\_as\_unicode(domain\_name: str) \-> str:
        """Convert a given domain name to Unicode (https://en.wikipedia.org/wiki/Unicode)."""
    
*   def tlds() \-> List\[str\]:
        """Get the top level domains from https://iana.org/."""
    
*   def is\_tld(possible\_tld: str) \-> bool:
        """Return whether or not the possible\_tld is a valid tld."""
    

**Development**

👋  If you want to get involved in this project, we have some short, helpful guides below:

*   contribute to this project 🥇
*   test it 🧪
*   lint it 🧹
*   explore it 🔭

If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.

**Credits**

This package was created with Cookiecutter and Floyd Hightower's Python project template.

**Download files**

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

**Source Distribution****Built Distribution**

Tag

#backdoor