proxyproviders 0.1.0__py3-none-any.whl

models/proxy.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from typing import Optional, List
+from datetime import datetime
+
+
+@dataclass
+class Proxy:
+    """Our shared data model for a proxy object across all providers."""
+
+    id: str
+    """A unique identifier for the proxy"""
+
+    username: str
+    """The username required for authenticating with the proxy"""
+
+    password: str
+    """The password required for authenticating with the proxy"""
+
+    proxy_address: str
+    """The IP address or domain name of the proxy"""
+
+    port: int
+    """The port number through which the proxy connection is established"""
+
+    country_code: Optional[str] = None
+    """The country code where the proxy is located, e.g., 'US', 'FR'. Optional"""
+
+    city_name: Optional[str] = None
+    """The city name where the proxy is located, e.g., 'New York', 'Paris'. Optional"""
+
+    created_at: Optional[datetime] = None
+    """The timestamp when the proxy was created. Optional"""
+
+    protocols: Optional[List[str]] = None
+    """A list of connection protocols supported by the proxy, e.g., ['http', 'https']"""

providers/brightdata.py

@@ -0,0 +1,217 @@
+import requests
+from typing import List, Dict, Optional
+from ..proxy_provider import ProxyProvider, ProxyConfig
+from ..exceptions import ProxyFetchException, ProxyInvalidResponseException
+from ..models.proxy import Proxy
+import threading
+
+
+class BrightData(ProxyProvider):
+    """BrightData (formerly luminati) is a proxy provider that offers residential and datacenter proxies.
+
+    Create an account `here <https://get.brightdata.com/davidteather>`_ (affiliate link).
+
+    You can find your API key in the account settings `here <https://brightdata.com/cp/setting/users>`_ then create "add token" with scope "limit" (`BrightData article <https://docs.brightdata.com/general/account/api-token>`_ for more info)
+
+    The BrightData API documentation is `here <https://docs.brightdata.com/api-reference/account-management-api/Get_active_Zones?playground=open>`_
+
+    :param api_key: Your BrightData API key
+    :param zone: The zone ID/name to fetch proxies for (you can get this from the BrightData dashboard)
+    :param username_suffix: Optional suffix to append to the username `more info <https://docs.brightdata.com/proxy-networks/config-options>`_ allows you to target region, city, etc. (requires use_super_proxy=True)
+    :param use_super_proxy: Optional flag to use super proxy instead of targeting specific IPs, this is enabled by default. If you want to target specific IPs or have consistent IPs for a session, set this to False.
+    :param config: Configuration for the proxy provider. View the ProxyConfig class docs for more information.
+
+    Example:
+
+    .. code-block:: python
+
+        from proxyproviders import BrightData
+
+        # Initialize the BrightData API client with an API key and a zone
+        proxy_provider = BrightData(api_key="your-api-key", zone="my_zone")
+
+        # Fetch proxies
+        proxies = proxy_provider.list_proxies() # returns one proxy for super proxy by default
+
+        # If you want to manage specific IPs
+        proxy_provider = BrightData(api_key="your-api-key", zone="my_zone", use_super_proxy=False)
+        proxies = proxy_provider.list_proxies() # returns multiple proxies for each IP in the zone (potentially thousands)
+    """
+
+    _BASE_URL = "https://api.brightdata.com"
+    _SUPER_PROXY_ADDRESS = "brd.superproxy.io"
+    _SUPER_PROXY_PORT = 33335
+    _PROTOCOLS: List[str] = ["http", "https"]  # BrightData supports both HTTP and HTTPS
+
+    def __init__(
+        self,
+        api_key: str,
+        zone: str,
+        username_suffix: Optional[str] = None,
+        use_super_proxy: Optional[bool] = True,
+        config: Optional[ProxyConfig] = None,
+    ):
+        super().__init__(config)
+        self.api_key = api_key
+        self.zone = zone
+        self.username_suffix = username_suffix
+        self.use_super_proxy = use_super_proxy
+
+    def _fetch_proxies(self) -> List[Proxy]:
+        username = self.get_zone_username(self.zone)
+        if self.username_suffix:
+            username += self.username_suffix
+
+        passwords = self.get_zone_passwords(self.zone)
+
+        if self.use_super_proxy:
+            # Let the super proxy handle the IP rotation
+            return [
+                Proxy(
+                    id="super",
+                    username=username,
+                    password=passwords["passwords"][0],
+                    proxy_address=self._SUPER_PROXY_ADDRESS,
+                    port=self._SUPER_PROXY_PORT,
+                    protocols=self._PROTOCOLS,
+                )
+            ]
+
+        proxies = []
+
+        # Fetch all IPs in the zone, and create a proxy for each
+        # Brightdata doesn't let us target directly so we tell the superproxy what to do
+        ips = self.list_all_ips_in_zone(self.zone)
+
+        for ip in ips:
+            ip_targeted_username = username + f"-ip-{ip['ip']}"
+
+            proxies.append(
+                Proxy(
+                    id=ip["ip"],
+                    username=ip_targeted_username,
+                    password=passwords["passwords"][0],
+                    proxy_address=self._SUPER_PROXY_ADDRESS,
+                    port=self._SUPER_PROXY_PORT,
+                    country_code=ip["country"],
+                    protocols=self._PROTOCOLS,
+                )
+            )
+
+        return proxies
+
+    def get_active_zones(self) -> Dict:
+        """Fetches active zones from BrightData API.
+
+        Response:
+
+        .. code-block:: json
+
+            [
+                {
+                    "name": "zone1",
+                    "type": "dc",
+                }
+            ]
+
+        """
+        return self._make_request("/zone/get_active_zones", "GET")
+
+    def get_zone_username(self, zone: str) -> str:
+        """Fetches zone username for the given zone ID from BrightData API.
+
+        Note: this isn't directly an API endpoint, I'm sort of reconstructing some things here and it seems to behave a little weird.
+
+        :param zone: The zone ID to fetch username for
+        """
+
+        data = self._make_request(f"/status", "GET", params={"zone": zone})
+
+        customer = data.get("customer")
+        if not customer:
+            raise ProxyInvalidResponseException("Failed to fetch customer data")
+
+        return f"brd-customer-{customer}-zone-{zone}"
+
+    def get_zone_passwords(self, zone: str) -> Dict:
+        """Fetches zone passwords from BrightData API.
+
+        :param zone: The zone ID to fetch passwords for
+
+        Response:
+
+
+        .. code-block:: json
+
+            {
+                "passwords": [
+                    "password1",
+                    "password2",
+                ]
+            }
+
+        """
+        return self._make_request(f"/zone/passwords", "GET", params={"zone": zone})
+
+    def list_all_ips_in_zone(self, zone: str, country: Optional[str] = None) -> Dict:
+        """Fetches all IPs in a zone from BrightData API.
+
+        :param zone: The zone ID to fetch IPs for
+        :param country: Optional 2-letter country code to filter IPs by
+
+        Response:
+
+
+        .. code-block:: json
+
+            [
+                {
+                    "ip": "192.168.1.1",
+                    "country": "US",
+                }
+            ]
+
+        """
+        return self._make_request(
+            f"/zone/route_ips",
+            "GET",
+            params={"zone": zone, "list_countries": True, "country": country},
+        )
+
+    def _make_request(
+        self,
+        path: str,
+        method: str,
+        params: Optional[Dict] = None,
+        json: Optional[Dict] = None,
+    ) -> Dict:
+        """Makes a request to the BrightData API.
+
+        :param path: The path to the endpoint
+        :param method: The HTTP method to use
+        :param params: Optional parameters to include in the request
+        :param json: Optional JSON data to include in the request
+        """
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        url = f"{self._BASE_URL}{path}"
+        response = requests.request(
+            method, url, headers=headers, params=params, json=json
+        )
+
+        if response.status_code != 200:
+            raise ProxyFetchException(
+                f"Failed to fetch from BrightData, got status code {response.status_code}, text: {response.text}"
+            )
+
+        try:
+            data = response.json()
+        except Exception as e:
+            raise ProxyInvalidResponseException(
+                f"Failed to parse response: {str(e)}"
+            ) from e
+
+        return data

providers/webshare.py

@@ -0,0 +1,124 @@
+import requests
+from datetime import datetime
+from typing import List, Dict, Optional
+from ..proxy_provider import ProxyProvider, ProxyConfig
+from ..exceptions import (
+    ProxyFetchException,
+    ProxyConversionException,
+    ProxyInvalidResponseException,
+)
+from ..models.proxy import Proxy
+
+
+class Webshare(ProxyProvider):
+    """Webshare is a proxy provider that offers residential and datacenter proxies.
+
+    Create an account for webshare `here <https://www.webshare.io/?referral_code=3x5812idzzzp>`_ (affiliate link) to get started with 10 free data center proxies.
+
+    You can find your API key in the Webshare dashboard `here <https://dashboard.webshare.io/userapi/keys>`_
+
+    You can find a list of all available parameters in the Webshare API documentation `here <https://apidocs.webshare.io/proxy-list/list#parameters>`_
+
+    :param api_key: Your Webshare API key
+    :param search_params: Optional parameters to include in the API requests
+    :param config: Configuration for the proxy provider. View the ProxyConfig class docs for more information.
+
+    Example:
+
+    .. code-block:: python
+
+        from proxyproviders import Webshare
+
+        # Initialize the Webshare API client with an API key and optional parameters
+        proxy_provider = Webshare(api_key="your-api-key", params={"country_code_in": "US"})
+
+        # Fetch proxies
+        proxies = proxy_provider.list_proxies()
+
+        # With config
+        from proxyproviders import ProxyConfig
+
+        config = ProxyConfig(refresh_interval=60)
+        proxy_provider = Webshare(api_key="your-api-key", params={"country_code_in": "US"}, config=config)
+
+        # Fetch proxies
+        proxies = proxy_provider.list_proxies()
+    """
+
+    _BASE_URL = "https://proxy.webshare.io/api/v2"
+    _PROTOCOLS = ["http", "https"]
+
+    def __init__(
+        self,
+        api_key: str,
+        search_params: Optional[dict] = None,
+        config: Optional[ProxyConfig] = None,
+    ):
+        super().__init__(config)
+        self.api_key = api_key
+        self.search_params = search_params or {}
+
+    def _fetch_proxies(self) -> List[Proxy]:
+        """Fetches proxies from Webshare API and converts them to the standardized Proxy format."""
+        headers = {"Authorization": f"Token {self.api_key}"}
+
+        all_proxies = []
+        page = 0
+
+        while True:
+            page += 1
+            default_params = {
+                "mode": "direct",
+                "page": page,
+                "page_size": 100,
+            }
+
+            params = {**default_params, **self.search_params}
+            try:
+                response = requests.get(
+                    f"{self._BASE_URL}/proxy/list", params=params, headers=headers
+                )
+                response.raise_for_status()  # Raises HTTPError for bad responses
+            except requests.exceptions.RequestException as e:
+                raise ProxyFetchException(f"Failed to fetch proxies: {str(e)}") from e
+
+            data = response.json()
+
+            proxy_data = data.get("results")
+            if not proxy_data:
+                raise ProxyInvalidResponseException(response.text)
+
+            all_proxies.extend([self._convert_to_proxy(proxy) for proxy in proxy_data])
+
+            if data.get("next") is None:  # no more pages
+                break
+
+        return all_proxies
+
+    def _convert_to_proxy(self, data: Dict) -> Proxy:
+        """Converts Webshare's proxy data to the shared Proxy format."""
+        try:
+            return Proxy(
+                id=data["id"],
+                username=data["username"],
+                password=data["password"],
+                proxy_address=data["proxy_address"],
+                port=int(data["port"]),
+                country_code=data.get("country_code"),
+                city_name=data.get("city_name"),
+                created_at=self._parse_timestamp(data.get("created_at")),
+                protocols=self._PROTOCOLS,
+            )
+        except (KeyError, ValueError) as e:
+            raise ProxyConversionException(
+                f"Failed to convert proxy data: {str(e)}"
+            ) from e
+
+    def _parse_timestamp(self, timestamp: Optional[str]) -> Optional[datetime]:
+        """Parses an ISO 8601 timestamp string into a datetime object."""
+        if timestamp:
+            try:
+                return datetime.fromisoformat(timestamp)
+            except ValueError:
+                return None
+        return None

proxyproviders-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 David Teather
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

proxyproviders-0.1.0.dist-info/METADATA

@@ -0,0 +1,224 @@
+Metadata-Version: 2.2
+Name: proxyproviders
+Version: 0.1.0
+Summary: A unified interface for different proxy providers
+Author-email: David Teather <contact.davidteather@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 David Teather
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: toml; extra == "dev"
+
+# ProxyProviders
+
+The Unified Python Proxy API for managing proxies with support for BrightData, WebShare, and more.
+
+[![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white&style=flat-square)](https://www.linkedin.com/in/davidteather/) [![Sponsor Me](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub)](https://github.com/sponsors/davidteather) [![GitHub release (latest by date)](https://img.shields.io/github/v/release/davidteather/proxyproviders)](https://github.com/davidteather/proxyproviders/releases) [![GitHub](https://img.shields.io/github/license/davidteather/proxyproviders)](https://github.com/davidteather/proxyproviders/blob/main/LICENSE) [![Downloads](https://pepy.tech/badge/proxyproviders)](https://pypi.org/project/proxyproviders/) ![](https://visitor-badge.laobi.icu/badge?page_id=davidteather.proxyproviders) [![Support Server](https://img.shields.io/discord/783108952111579166.svg?color=7289da&logo=discord&style=flat-square)](https://discord.gg/yyPhbfma6f)
+
+## Table of Contents
+
+- [Documentation](#documentation)
+- [Getting Started](#getting-started)
+  - [How to Support The Project](#how-to-support-the-project)
+  - [Installing](#installing)
+- [Quick Start Guide](#quick-start-guide)
+  - [Examples](https://github.com/davidteather/proxyproviders/tree/main/examples)
+
+## Documentation
+
+You can find the full documentation [here](https://davidteather.github.io/proxyproviders)
+
+**Note:** If you want to learn how to web scrape websites check my [free and open-source course for learning everything web scraping](https://github.com/davidteather/everything-web-scraping)
+
+### How to Support The Project
+
+- Star the repo 😎
+- Consider [sponsoring](https://github.com/sponsors/davidteather) me on GitHub
+- Send me an email or a [LinkedIn](https://www.linkedin.com/in/davidteather/) message about what you're doing with it :D 
+- Submit PRs for issues or any new providers/features :)
+
+## Getting Started
+
+To get started using this package follow the instructions below.
+
+### Installation
+
+This package is installable via pip.
+```sh
+python -m pip install proxyproviders
+```
+
+## Quick Start Guide
+
+Here's a quick bit of code to get you started! There's also a few [examples in the folder](https://github.com/davidteather/proxyproviders/tree/main/examples). 
+
+**Note:** If you want to learn how to web scrape websites check my [free and open-source course for learning everything web scraping](https://github.com/davidteather/everything-web-scraping)
+
+### Choose a Proxy Provider
+
+If you already haven't, choose which proxy provider to use. You can find a [list in the documentation](https://davidteather.github.io/proxyproviders/#proxyproviders-supported-providers). After choosing, look at the documentation around the specific provider you've choosen. Where needed, we've laid out steps to get api keys in the documentation. These steps will vary slightly by provider. For this example I'll be using the [Webshare Provider](https://davidteather.github.io/proxyproviders/#proxyproviders.providers.webshare.Webshare) because it's both easy to setup and they give you 10 free data center proxies to test out.
+
+You can create an account on webshare [here](https://www.webshare.io/?referral_code=3x5812idzzzp) (affiliate link), then head into the [API tab](https://dashboard.webshare.io/userapi/keys) on the side and generate a new token. Keep this API token safe and don't post it publically.
+
+### Basic Example
+
+After you can list out your proxies with
+```py
+from proxyproviders import Webshare
+
+proxy_provider = Webshare(api_key="your-api-key")
+
+proxies = proxy_provider.list_proxies()
+
+print(proxies)
+```
+
+Each provider has their own custom options, the `Webshare` class lets you specify url params according to their [api spec](https://apidocs.webshare.io/proxy-list/list#parameters), here's an example which will only return proxies that are based in the US.
+
+```py
+proxy_provider = Webshare(api_key="your-api-key", params={"country_code_in": "US"})
+```
+
+### Using ProxyConfig
+
+For any shared logic across all types of proxy providers, we use the `ProxyConfig` data class to configure them. The full docs for [ProxyConfig are here](https://davidteather.github.io/proxyproviders/#proxyproviders.proxy_provider.ProxyConfig). In this example we will configure it to use a shorter `refresh_interval` than default.
+
+```py
+from proxyproviders import Webshare, ProxyConfig
+import time
+
+config = ProxyConfig(refresh_interval=3)
+ws = Webshare(api_key="your-api-token", config=config)
+
+proxies = ws.list_proxies() # calls API 
+
+ws.list_proxies() # cached
+
+time.sleep(5)
+ws.list_proxies() # calls API since it's more than 3s later
+```
+
+### Function Using Generic ProxyProvider
+
+Since all proxy providers implement the same interface, we can make a function that allows us to easily swap out and utilize different providers. This is the main appeal of having a unified interface. It allows other modules to be provider agnostic, like my [TikTokAPI](https://github.com/davidteather/TikTok-Api) package.
+
+```py
+from proxyproviders import Webshare, BrightData, ProxyProvider, ProxyConfig
+
+def some_function(provider: ProxyProvider):
+    proxies = provider.list_proxies()
+    print(proxies)
+
+webshare = Webshare(api_key="your_api_key")
+brightdata = BrightData(api_key="your_api_key", zone="my_zone")
+
+some_function(webshare)
+some_function(brightdata)
+```
+
+Here's a more meaningful example that takes the `Proxy` class and uses it to create a python requests http proxy.
+
+```py
+from proxyproviders import Webshare, BrightData, ProxyProvider
+import requests
+import os
+
+
+def request_with_proxy(provider: ProxyProvider):
+    requests_proxy = None
+
+    if provider:
+        proxies = provider.list_proxies()
+
+        requests_proxy = {
+            "http": f"http://{proxies[0].username}:{proxies[0].password}@{proxies[0].proxy_address}:{proxies[0].port}",
+            "https": f"http://{proxies[0].username}:{proxies[0].password}@{proxies[0].proxy_address}:{proxies[0].port}",
+        }
+
+    r = requests.get("https://httpbin.org/ip", proxies=requests_proxy)
+    return r.json()
+
+webshare = Webshare(api_key="your_api_key")
+brightdata = BrightData(api_key="your_api_key", zone="your_zone")
+
+print(f"Your IP: {request_with_proxy(None)}")
+print(f"Webshare: {request_with_proxy(webshare)}")
+print(f"BrightData: {request_with_proxy(brightdata)}")
+```
+
+### Making Your Own Proxy Provider
+
+Here's a skeleton of how you can make your very own `ProxyProvider` class. You'll need to implemenet all the required functions of the `ProxyProvider` which may be more than what's here at the time of writing.
+
+If you do find yourself making one of these, consider contributing it back to the repository so everyone can use them :D
+
+```py
+from proxyproviders import ProxyProvider, ProxyConfig, Proxy
+from typing import List, Optional
+
+class MyProxyProvider(ProxyProvider):
+    def __init__(self, config: Optional[ProxyConfig] = None):
+        super().__init__(config=config)
+
+    def _fetch_proxies(self):
+        proxies: List[Proxy] = []
+
+        for i in range(10):
+            # TODO: your real proxy fetching logic
+
+            # There are required fields on the Proxy class, be sure that these are filled out properly
+            # especially if you're using it with another library.
+            proxy = Proxy(
+                id=str(i),
+                username="username",
+                password="password",
+                proxy_address="192.168.1.1",
+                port=80,
+            )
+
+            proxies.append(proxy)
+
+        return proxies
+
+def some_function(provider: ProxyProvider):
+    proxies = provider.list_proxies()
+    for proxy in proxies:
+        print(proxy)
+
+provider = MyProxyProvider()
+some_function(provider) # calls the function with the provider
+```
+

proxyproviders-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+models/proxy.py,sha256=vp8yKPUzfJmLHLoNpzPUB-N5we74jkeddsS1wNOCguw,1075
+providers/brightdata.py,sha256=P91G6EXpwZ659H29yV3PE2GOawQutfPuf7FAMuwfJOg,7466
+providers/webshare.py,sha256=kbGRMpI-nBVbR2PtK0orhyJeCJduAfQCNM4_g3I8BJk,4445
+proxyproviders-0.1.0.dist-info/LICENSE,sha256=ipBQmKG3jqCK2IImmZUrHpq87hhBKynRmEVJh-JXgE4,1070
+proxyproviders-0.1.0.dist-info/METADATA,sha256=74eGGxosp2ArinxeVY1dtGLBw0fcf95E_B9ufgKdTXU,9866
+proxyproviders-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+proxyproviders-0.1.0.dist-info/top_level.txt,sha256=SvI6U3Ww7uWY0dBvinaoVeyPbN8Jd1hjYuxqJKfz_Yk,17
+proxyproviders-0.1.0.dist-info/RECORD,,

proxyproviders-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

proxyproviders-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+models
+providers