Python URL Parser Challenge

Web applications frequently deal with URLs, which are structured strings that represent addresses on the internet. Being able to reliably extract different components of a URL (like the scheme, hostname, path, etc.) is a fundamental skill for many web-related programming tasks. This challenge will test your ability to parse a URL string and break it down into its constituent parts.

Problem Description

Your task is to implement a Python function that takes a URL string as input and returns a dictionary containing its parsed components. The function should be robust enough to handle common URL structures.

Specifically, you need to extract the following components:

• scheme: The protocol used (e.g., http, https).
• netloc: The network location, which typically includes the hostname and optionally a port number (e.g., www.example.com, localhost:8080).
• path: The path component of the URL, starting from the first slash after the netloc (e.g., /users/profile, /data.json).
• params: Parameters for the last path segment (often present in older URL formats, but less common now).
• query: The query string, which follows the path and starts with a ? (e.g., user_id=123&sort=asc).
• fragment: The fragment identifier, which follows the #' (e.g., section1, top).

Expected Behavior: The function should return a dictionary where keys are the names of the URL components (as strings) and values are the extracted string representations of those components. If a component is not present in the URL, its corresponding value in the dictionary should be an empty string.

Edge Cases to Consider:

• URLs with and without ports.
• URLs with and without query strings.
• URLs with and without fragments.
• URLs with just a scheme and netloc.
• URLs with a path that includes special characters (though for this challenge, you don't need to percent-decode them).
• Invalid or malformed URLs (for this challenge, assume valid URLs unless specified in constraints).

Examples

Example 1:

Input: "https://www.example.com:8080/users/profile?user_id=123&sort=asc#section1"
Output: {
    'scheme': 'https',
    'netloc': 'www.example.com:8080',
    'path': '/users/profile',
    'params': '',
    'query': 'user_id=123&sort=asc',
    'fragment': 'section1'
}
Explanation: All components are present and extracted correctly.

Example 2:

Input: "http://localhost/about"
Output: {
    'scheme': 'http',
    'netloc': 'localhost',
    'path': '/about',
    'params': '',
    'query': '',
    'fragment': ''
}
Explanation: Query and fragment are absent.

Example 3:

Input: "ftp://files.server.org"
Output: {
    'scheme': 'ftp',
    'netloc': 'files.server.org',
    'path': '',
    'params': '',
    'query': '',
    'fragment': ''
}
Explanation: Only scheme and netloc are present.

Example 4:

Input: "mailto:user@example.com"
Output: {
    'scheme': 'mailto',
    'netloc': '',
    'path': 'user@example.com',
    'params': '',
    'query': '',
    'fragment': ''
}
Explanation: The 'path' here is the email address itself, as there's no netloc in the typical sense for mailto URIs.

Constraints

• The input url_string will be a string.
• You should aim to handle typical URL formats as described. For this challenge, you can assume input URLs will generally follow standard RFC 3986 structures, but robust parsing for all edge cases of malformed URLs is not strictly required.
• Your solution should be reasonably efficient, but extreme performance optimization is not the primary focus.

Notes

• Python's standard library offers a powerful urllib.parse module that can perform this task. However, for this challenge, you are expected to implement your own parsing logic from scratch to demonstrate your understanding of string manipulation and URL structure. You may not use urllib.parse or any other external URL parsing library.
• Consider how you will delineate each part of the URL. Look for common delimiters like ://, /, ?, and #.
• The order of parsing is important. For example, the query string always comes after the path and before the fragment.
• Remember to handle cases where a delimiter might appear within a component (e.g., a / in the path).