wxpath 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

wxpath/http/stats.py

@@ -0,0 +1,96 @@
+"""
+aiohttp request statistics and tracing hooks.
+"""
+
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Optional
+
+from aiohttp import TraceConfig
+
+
+@dataclass
+class CrawlerStats:
+    # ---- Lifecycle counts ----
+    requests_enqueued: int = 0
+    requests_started: int = 0
+    requests_completed: int = 0
+
+    # ---- Concurrency ----
+    in_flight_global: int = 0
+    in_flight_per_host: defaultdict[str, int] = field(default_factory=lambda: defaultdict(int))
+
+    # ---- Queueing ----
+    queue_size: int = 0
+    queue_wait_time_total: float = 0.0
+
+    # ---- Throttling ----
+    throttle_waits: int = 0
+    throttle_wait_time: float = 0.0
+    throttle_waits_by_host: defaultdict[str, int] = field(default_factory=lambda: defaultdict(int))
+
+    # ---- Latency feedback ----
+    latency_samples: int = 0
+    latency_ewma: float = 0.0
+    min_latency: Optional[float] = None
+    max_latency: Optional[float] = None
+
+    # ---- Errors / retries ----
+    retries_scheduled: int = 0
+    retries_executed: int = 0
+    errors_by_host: defaultdict[str, int] = field(default_factory=lambda: defaultdict(int))
+
+
+def build_trace_config(stats: CrawlerStats) -> TraceConfig:
+    """
+    Returns an aiohttp TraceConfig wired to the given stats instance.
+    Tracks detailed per-request, per-host, and queue/throttle metrics.
+    """
+    trace = TraceConfig()
+
+    async def on_request_start(session, context, params):
+        stats.requests_started += 1
+        stats.in_flight_global += 1
+        host = params.url.host
+        stats.in_flight_per_host[host] += 1
+        context._start_time = time.monotonic()
+
+    async def on_request_end(session, context, params):
+        host = params.url.host
+        stats.in_flight_global -= 1
+        stats.in_flight_per_host[host] -= 1
+
+        latency = time.monotonic() - context._start_time
+        stats.latency_samples += 1
+        # EWMA update: alpha = 0.3
+        alpha = 0.3
+        stats.latency_ewma = (alpha * latency) + ((1 - alpha) * stats.latency_ewma)
+        stats.min_latency = latency if stats.min_latency is None \
+            else min(stats.min_latency, latency)
+        stats.max_latency = latency if stats.max_latency is None \
+            else max(stats.max_latency, latency)
+
+        status = getattr(params.response, "status", None)
+        if status is not None:
+            if not hasattr(stats, "status_counts"):
+                stats.status_counts = defaultdict(int)
+            stats.status_counts[status] += 1
+
+        content_length = getattr(params.response, "content_length", None)
+        if content_length:
+            if not hasattr(stats, "bytes_received"):
+                stats.bytes_received = 0
+            stats.bytes_received += content_length
+
+    async def on_request_exception(session, context, params):
+        host = params.url.host
+        stats.in_flight_global -= 1
+        stats.in_flight_per_host[host] -= 1
+        stats.errors_by_host[host] += 1
+
+    trace.on_request_start.append(on_request_start)
+    trace.on_request_end.append(on_request_end)
+    trace.on_request_exception.append(on_request_exception)
+
+    return trace

wxpath/patches.py

@@ -0,0 +1,63 @@
+import elementpath
+from elementpath.xpath3 import XPath3Parser
+from lxml import etree, html
+
+
+def html_element_repr(self):
+    return (f"HtmlElement(tag={self.tag}, "
+            f"depth={self.get('depth', -1)}, "
+            f"base_url={getattr(self, 'base_url', None)!r})")
+
+# Patch lxml.html.HtmlElement.__repr__ to improve debugging with base_url.
+html.HtmlElement.__repr__ = html_element_repr
+
+
+class XPath3Element(etree.ElementBase):
+    def xpath3(self, expr, **kwargs):
+        """
+        Evaluate an XPath 3 expression using elementpath library,
+        returning the results as a list.
+        """
+        kwargs.setdefault("parser", XPath3Parser)
+        kwargs.setdefault(
+            "uri", 
+            getattr(self.getroottree().docinfo, "URL", None) or self.get("base_url")
+        )
+        return elementpath.select(self, expr, **kwargs)
+
+    # --- Convenience property for backward‑compatibility -----------------
+    @property
+    def base_url(self):
+        # 1) Per-element override (keeps our “multiple base URLs” feature)
+        url = self.get("base_url")
+        if url is not None:
+            return url
+        # 2) Fall back to document URL (O(1))
+        return self.getroottree().docinfo.URL
+
+    @base_url.setter
+    def base_url(self, value):
+        # Keep the per-element attribute (used by our crawler)
+        self.set("base_url", value)
+        # Set xml:base attribute so XPath base-uri() picks it up
+        self.set("{http://www.w3.org/XML/1998/namespace}base", value)
+        # Also store on the document so descendants can fetch it quickly
+        self.getroottree().docinfo.URL = value
+
+    @property
+    def depth(self):
+        return int(self.get("depth", -1))
+
+    @depth.setter
+    def depth(self, value):
+        self.set("depth", str(value))
+    
+# Create and register custom parser that returns XPath3Element instances
+lookup = etree.ElementDefaultClassLookup(element=XPath3Element)
+parser = etree.HTMLParser()
+parser.set_element_class_lookup(lookup)
+
+
+# Expose parser for use in parse_html
+html_parser_with_xpath3 = parser
+html.HtmlElement.xpath3 = XPath3Element.xpath3

wxpath/util/logging.py

@@ -0,0 +1,91 @@
+import logging
+from logging.config import dictConfig
+from typing import Any, Mapping
+
+
+class KeyValueFormatter(logging.Formatter):
+    """
+    Formatter that automatically renders any 'extra' context added to the record
+    as key=value pairs at the end of the log line.
+    """
+    # Reserved keys that already exist in LogRecord and shouldn't be printed again
+    _RESERVED = {
+        'args', 'asctime', 'created', 'exc_info', 'exc_text', 'filename',
+        'funcName', 'levelname', 'levelno', 'lineno', 'message', 'module',
+        'msecs', 'msg', 'name', 'pathname', 'process', 'processName',
+        'relativeCreated', 'stack_info', 'thread', 'threadName', 'taskName'
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        # 1. Format the standard message first
+        s = super().format(record)
+        
+        # 2. Find all 'extra' keys
+        extras = {k: v for k, v in record.__dict__.items() if k not in self._RESERVED}
+        
+        # 3. Append them as key=value
+        if extras:
+            # Sort for deterministic logs
+            context_str = " ".join(f"{k}={v}" for k, v in sorted(extras.items()))
+            s = f"{s} | {context_str}"
+            
+        return s
+
+
+_DEFAULT_LOGGING_CONF = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "kv": {
+            # Note: We use the class path to our custom class
+            "()": KeyValueFormatter, 
+            "format": "%(asctime)s [%(levelname).1s] %(name)s | %(funcName)s | %(message)s"
+        }
+    },
+    "handlers": {
+        "stderr": {
+            "class": "logging.StreamHandler",
+            "formatter": "kv",
+        }
+    },
+    "loggers": {
+        "wxpath": {"level": "INFO", "handlers": ["stderr"]},
+    },
+}
+
+def configure_logging(level: str | int = "INFO", **overrides) -> None:
+    """
+    Configure wxpath's logger.
+
+    Call this once in an application entry-point **or** rely on defaults.
+
+    Parameters
+    ----------
+    level
+        "DEBUG"|"INFO"|... or `logging.DEBUG`, overrides the root wxpath logger.
+    overrides
+        Dict that is merged (shallow) into the default dictConfig.
+        Lets advanced users swap formatters/handlers.
+    """
+    conf = {**_DEFAULT_LOGGING_CONF, **overrides}
+    conf["loggers"]["wxpath"]["level"] = level
+    dictConfig(conf)
+    
+    
+class CrawlAdapter(logging.LoggerAdapter):
+    """
+    Inject crawl context (depth, op, url) so the handler/formatter
+    never needs to know scraping internals.
+    """
+    def process(self, msg: str, kwargs: Mapping[str, Any]):
+        extra = self.extra.copy()
+        extra.update(kwargs.pop("extra", {}))
+        kwargs["extra"] = extra
+        return msg, kwargs
+
+def get_logger(name: str, **ctx) -> CrawlAdapter:
+    base = logging.getLogger(name)
+    # default placeholders so formatter never blows up
+    defaults = {"depth": "-", "op": "-", "url": "-"}
+    defaults.update(ctx)
+    return CrawlAdapter(base, defaults)

wxpath/util/serialize.py

@@ -0,0 +1,22 @@
+from wxpath.core.ops import WxStr
+
+
+def simplify(obj):
+    """
+    Recursively convert custom wrapper types (e.g., WxStr / ExtractedStr,
+    lxml elements) into plain built-in Python types so that printing or
+    JSON serialising shows clean values.
+    """
+    # Scalars
+    if isinstance(obj, WxStr):
+        return str(obj)
+
+    # Mapping
+    if isinstance(obj, dict):
+        return {k: simplify(v) for k, v in obj.items()}
+
+    # Sequence (but not str/bytes)
+    if isinstance(obj, (list, tuple, set)):
+        return type(obj)(simplify(v) for v in obj)
+
+    return obj

{wxpath-0.1.1.dist-info → wxpath-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wxpath
-Version: 0.1.1
+Version: 0.2.0
 Summary: wxpath - a declarative web crawler and data extractor
 Author-email: Rodrigo Palacios <rodrigopala91@gmail.com>
 License-Expression: MIT
@@ -9,8 +9,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.0
 Requires-Dist: lxml>=4.0
-Requires-Dist: elementpath>=5.0.0
-Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: elementpath<=5.0.3,>=5.0.0
+Requires-Dist: aiohttp<=3.12.15,>=3.8.0
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 Requires-Dist: pytest-asyncio>=0.23; extra == "test"
@@ -27,10 +27,11 @@ By introducing the `url(...)` operator and the `///` syntax, **wxpath**'s engine
 
 NOTE: This project is in early development. Core concepts are stable, but the API and features may change. Please report issues - in particular, deadlocked crawls or unexpected behavior - and any features you'd like to see (no guarantee they'll be implemented).
 
+
 ## Contents
 
 - [Example](#example)
-- [`url(...)` and `///` Explained](#url-and---explained)
+- [`url(...)` and `///url(...)` Explained](#url-and---explained)
 - [General flow](#general-flow)
 - [Asynchronous Crawling](#asynchronous-crawling)
 - [Output types](#output-types)
@@ -39,11 +40,13 @@ NOTE: This project is in early development. Core concepts are stable, but the AP
 - [Hooks (Experimental)](#hooks-experimental)
 - [Install](#install)
 - [More Examples](#more-examples)
+- [Comparisons](#comparisons)
 - [Advanced: Engine & Crawler Configuration](#advanced-engine--crawler-configuration)
 - [Project Philosophy](#project-philosophy)
 - [Warnings](#warnings)
 - [License](#license)
 
+
 ## Example
 
 ```python
@@ -51,7 +54,7 @@ import wxpath
 
 path = """
 url('https://en.wikipedia.org/wiki/Expression_language')
- ///main//a/@href[starts-with(., '/wiki/') and not(contains(., ':'))]/url(.)
+ ///url(//main//a/@href[starts-with(., '/wiki/') and not(contains(., ':'))])
  /map{
     'title':(//span[contains(@class, "mw-page-title-main")]/text())[1],
     'url':string(base-uri(.)),
@@ -86,10 +89,11 @@ The above expression does the following:
 4. Streams the extracted data as it is discovered.
 
 
-## `url(...)` and `///` Explained
+## `url(...)` and `///url(...)` Explained
 
 - `url(...)` is a custom operator that fetches the content of the user-specified or internally generated URL and returns it as an `lxml.html.HtmlElement` for further XPath processing.
-- `///` indicates infinite/recursive traversal. It tells **wxpath** to continue following links indefinitely, up to the specified `max_depth`. Unlike repeated `url()` hops, it allows a single expression to describe unbounded graph exploration. WARNING: Use with caution and constraints (via `max_depth` or XPath predicates) to avoid traversal explosion.
+- `///url(...)` indicates infinite/recursive traversal. It tells **wxpath** to continue following links indefinitely, up to the specified `max_depth`. Unlike repeated `url()` hops, it allows a single expression to describe unbounded graph exploration. WARNING: Use with caution and constraints (via `max_depth` or XPath predicates) to avoid traversal explosion.
+
 
 ## General flow
 
@@ -99,14 +103,13 @@ The above expression does the following:
 
 XPath segments operate on fetched documents (fetched via the immediately preceding `url(...)` operations).
 
-`///` indicates infinite/recursive traversal - it proceeds breadth-first-*ish* up to `max_depth`.
+`///url(...)` indicates infinite/recursive traversal - it proceeds breadth-first-*ish* up to `max_depth`.
 
 Results are yielded as soon as they are ready.
 
 
 ## Asynchronous Crawling
 
-
 **wxpath** is `asyncio/aiohttp`-first, providing an asynchronous API for crawling and extracting data.
 
 ```python
@@ -116,7 +119,7 @@ from wxpath import wxpath_async
 items = []
 
 async def main():
-    path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')///url(@href[starts-with(., '/wiki/')])//a/@href"
+    path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')///url(//@href[starts-with(., '/wiki/')])//a/@href"
     async for item in wxpath_async(path_expr, max_depth=1):
         items.append(item)
 
@@ -125,16 +128,16 @@ asyncio.run(main())
 
 ### Blocking, Concurrent Requests
 
-
 **wxpath** also supports concurrent requests using an asyncio-in-sync pattern, allowing you to crawl multiple pages concurrently while maintaining the simplicity of synchronous code. This is particularly useful for crawls in strictly synchronous execution environments (i.e., not inside an `asyncio` event loop) where performance is a concern.
 
 ```python
 from wxpath import wxpath_async_blocking_iter
 
-path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')///url(@href[starts-with(., '/wiki/')])//a/@href"
+path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')///url(//@href[starts-with(., '/wiki/')])//a/@href"
 items = list(wxpath_async_blocking_iter(path_expr, max_depth=1))
 ```
 
+
 ## Output types
 
 The wxpath Python API yields structured objects, not just strings.
@@ -158,7 +161,7 @@ The Python API preserves structure by default.
 ```python
 path_expr = """
     url('https://en.wikipedia.org/wiki/Expression_language')
-    ///div[@id='mw-content-text']//a/url(@href)
+    ///url(//div[@id='mw-content-text']//a/@href)
     /map{ 
         'title':(//span[contains(@class, "mw-page-title-main")]/text())[1], 
         'short_description':(//div[contains(@class, "shortdescription")]/text())[1],
@@ -178,15 +181,18 @@ path_expr = """
 # ...]
 ```
 
+
 ## CLI
 
 **wxpath** provides a command-line interface (CLI) to quickly experiment and execute wxpath expressions directly from the terminal. 
 
+The following example demonstrates how to crawl Wikipedia starting from the "Expression language" page, extract links to other wiki pages, and retrieve specific fields from each linked page.
+
+WARNING: Due to the everchanging nature of web content, the output may vary over time.
 ```bash
 > wxpath --depth 1 "\
     url('https://en.wikipedia.org/wiki/Expression_language')\
-    ///div[@id='mw-content-text'] \
-    //a/url(@href[starts-with(., '/wiki/') \
+    ///url(//div[@id='mw-content-text']//a/@href[starts-with(., '/wiki/') \
         and not(matches(@href, '^(?:/wiki/)?(?:Wikipedia|File|Template|Special|Template_talk|Help):'))]) \
     /map{ \
         'title':(//span[contains(@class, 'mw-page-title-main')]/text())[1], \
@@ -258,90 +264,13 @@ pip install wxpath
 
 ## More Examples
 
-```python
-import wxpath
+See [EXAMPLES.md](EXAMPLES.md) for more usage examples.
 
-#### EXAMPLE 1 - Simple, single page crawl and link extraction #######
-#
-# Starting from Expression language's wiki, extract all links (hrefs) 
-# from the main section. The `url(...)` operator is used to execute a 
-# web request to the specified URL and return the HTML content.
-#
-path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')//main//a/@href"
-
-items = wxpath.wxpath_async_blocking(path_expr)
-
-
-#### EXAMPLE 2 - Two-deep crawl and link extraction ##################
-#
-# Starting from Expression language's wiki, crawl all child links 
-# starting with '/wiki/', and extract each child's links (hrefs). The
-# `url(...)` operator is pipe'd arguments from the evaluated XPath.
-#
-path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')//url(@href[starts-with(., '/wiki/')])//a/@href"
-
-#### EXAMPLE 3 - Infinite crawl with BFS tree depth limit ############
-#
-# Starting from Expression language's wiki, infinitely crawl all child
-# links (and child's child's links recursively). The `///` syntax is
-# used to indicate an infinite crawl. 
-# Returns lxml.html.HtmlElement objects.
-#
-path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')///main//a/url(@href)"
-
-# The same expression written differently:
-path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')///url(//main//a/@href)"
-
-# Modify (inclusive) max_depth to limit the BFS tree (crawl depth).
-items = wxpath.wxpath_async_blocking(path_expr, max_depth=1)
-
-#### EXAMPLE 4 - Infinite crawl with field extraction ################
-#
-# Infinitely crawls Expression language's wiki's child links and 
-# childs' child links (recursively) and then, for each child link 
-# crawled, extracts objects with the named fields as a dict.
-#
-path_expr = """
-    url('https://en.wikipedia.org/wiki/Expression_language')
-     ///main//a/url(@href)
-     /map {
-        'title':(//span[contains(@class, "mw-page-title-main")]/text())[1], 
-        'short_description':(//div[contains(@class, "shortdescription")]/text())[1],
-        'url'://link[@rel='canonical']/@href[1],
-        'backlink':wx:backlink(.),
-        'depth':wx:depth(.)
-    }
-"""
 
-# Under the hood of wxpath.core.wxpath, we generate `segments` list, 
-# revealing the operations executed to accomplish the crawl.
-# >> segments = wxpath.core.parser.parse_wxpath_expr(path_expr); 
-# >> segments
-# [Segment(op='url', value='https://en.wikipedia.org/wiki/Expression_language'),
-#  Segment(op='url_inf', value='///url(//main//a/@href)'),
-#  Segment(op='xpath', value='/map {        \'title\':(//span[contains(@class, "mw-page-title-main")]/text())[1],         \'short_description\':(//div[contains(@class, "shortdescription")]/text())[1],        \'url\'://link[@rel=\'canonical\']/@href[1]    }')]
-
-#### EXAMPLE 5 = Seeding from XPath function expression + mapping operator (`!`)
-#
-# Functionally create 10 Amazon book search result page URLs, map each URL to 
-# the url(.) operator, and for each page, extract the title, price, and link of
-# each book listed.
-# 
-base_url = "https://www.amazon.com/s?k=books&i=stripbooks&page="
-
-path_expr = f"""
-    (1 to 10) ! ('{base_url}' || .) !
-    url(.)
-        //span[@data-component-type='s-search-results']//*[@role='listitem']
-            /map {{
-                'title': (.//h2/span/text())[1],
-                'price': (.//span[@class='a-price']/span[@class='a-offscreen']/text())[1],
-                'link': (.//a[@aria-describedby='price-link']/@href)[1]
-            }}
-"""
+## Comparisons
+
+See [COMPARISONS.md](COMPARISONS.md) for comparisons with other web-scraping tools.
 
-items = list(wxpath.wxpath_async_blocking_iter(path_expr, max_depth=1))
-```
 
 ## Advanced: Engine & Crawler Configuration
 
@@ -366,7 +295,7 @@ engine = WXPathEngine(
     crawler=crawler,
 )
 
-path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')///main//a/url(@href)"
+path_expr = "url('https://en.wikipedia.org/wiki/Expression_language')//url(//main//a/@href)"
 
 items = list(wxpath_async_blocking_iter(path_expr, max_depth=1, engine=engine))
 ```
@@ -394,6 +323,7 @@ items = list(wxpath_async_blocking_iter(path_expr, max_depth=1, engine=engine))
 - Automatic proxy rotation
 - Browser-based rendering (JavaScript execution)
 
+
 ## WARNINGS!!!
 
 - Be respectful when crawling websites. A scrapy-inspired throttler is enabled by default.
@@ -401,6 +331,7 @@ items = list(wxpath_async_blocking_iter(path_expr, max_depth=1, engine=engine))
 - Deadlocks and hangs are possible in certain situations (e.g., all tasks waiting on blocked requests). Please report issues if you encounter such behavior.
 - Consider using timeouts, `max_depth`, and XPath predicates and filters to limit crawl scope.
 
+
 ## License
 
 MIT

wxpath-0.2.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+wxpath/__init__.py,sha256=w1hFE_VSIYq_TSFLoPfp6MJbG1sA6BeChX6PYsXIK4o,265
+wxpath/cli.py,sha256=CHOFWH_WHsJ30aItIQw9c5jzjl2Y64DmW2K942OGwpo,1668
+wxpath/patches.py,sha256=u0dOL-K-gvdO9SJvzGrqR9Zou6XduWjl6R7mzIcZtJg,2130
+wxpath/core/__init__.py,sha256=U9_In2iRaZrpiIVavIli1M59gCB6Kn1en-1Fza-qIiI,257
+wxpath/core/dom.py,sha256=X0L3n8jRfO5evEypDaJTD-NQ3cLXWvnEUVERAHo3vV0,701
+wxpath/core/errors.py,sha256=q56Gs5JJSC4HKImUtdZhOHcqe8XsoIrVhsaaoJ2qhCQ,4198
+wxpath/core/models.py,sha256=3KYt-UwfLY2FlSRUHeA_getnYaNUMPW9wRrl2CRbPso,1611
+wxpath/core/ops.py,sha256=8hc8VTqsxGFpizOyPTgzxjc8Y5srHd2aaOugQ9fJ3sE,8918
+wxpath/core/parser.py,sha256=0VQCkuznd4dYYzEeTAMFs1L2SmvTgSp1JWz-Um0uEjM,9911
+wxpath/core/runtime/__init__.py,sha256=_iCgkIWxXvxzQcenHOsjYGsk74HboTIYWOtgM8GtCyc,86
+wxpath/core/runtime/engine.py,sha256=Pn5wzPkBwp8bq48Ie0O0DVQzUFEAAzWIj1PHgChm2bo,10825
+wxpath/core/runtime/helpers.py,sha256=NCL4Wl8Hpc1VTfERSthCen9wlVd5J0eS8th4gqEPmRg,1578
+wxpath/hooks/__init__.py,sha256=9JG63e4z_8CZLWugFcY786hebaEEPZ5FmZhyDHat-98,294
+wxpath/hooks/builtin.py,sha256=GJ4w1C9djWNzAmAA3U0qI9OoCOeC5R8tEGtWXJVHSYs,4125
+wxpath/hooks/registry.py,sha256=q4MxYwDUv7LH4-WJGO_unXbBRFXXxsBCU4vU1co0gC4,4136
+wxpath/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wxpath/http/stats.py,sha256=FrXbFrnms113Gapf-Z5WiD5qaNiJ0XuOqjSQhwXfuEo,3172
+wxpath/http/client/__init__.py,sha256=QpdmqzcznUeuFvT3IIo-LmBUUHEa2BDq9sHGAHJnDLI,202
+wxpath/http/client/crawler.py,sha256=hN7EJXP102nsMA9ipaNPc9fWwDVpm_LJdGo6LSlAQp0,6996
+wxpath/http/client/request.py,sha256=3nwwPQ2e_WycJQnSA6QieWJ2q3qg40jkGrp2NUDPsLI,888
+wxpath/http/client/response.py,sha256=mDo3FswiVnulV1l5qjio5OQpGlT0-tfkR7daPSgSUuE,324
+wxpath/http/policy/backoff.py,sha256=NwdUR6bRe1RtUGSJOktj-p8IyC1l9xu_-Aa_Gj_u5sw,321
+wxpath/http/policy/retry.py,sha256=WSrQfCy1F7IcXFpVGDi4HTphNhFq12p4DaMO0_4dgrw,982
+wxpath/http/policy/throttler.py,sha256=wydMFV-0mxpHSI5iYkLfE78oY4z_fF8jW9MqCeb8G54,3014
+wxpath/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wxpath/util/logging.py,sha256=oQi8sp7yKWgXkkcJ4U4WHp7TyBCQiK4VhSXOSb8pGw0,2965
+wxpath/util/serialize.py,sha256=uUs4C9VErpFd97smBM2bRWo2nW25kCgKdsMrVtVxhg8,575
+wxpath-0.2.0.dist-info/licenses/LICENSE,sha256=AVBZLhdWmqxm-f-dy5prVB1E-solHWoP2EXEIV_o-00,1076
+wxpath-0.2.0.dist-info/METADATA,sha256=6CdIcq82gNqvXVIpBzhGCk_Q0eqDvok1JmEKWQkFals,14662
+wxpath-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wxpath-0.2.0.dist-info/entry_points.txt,sha256=FwoIOnUTl-DjPqVw-eb9EHHiiXCyRZy_mEQKFu2eb5Y,43
+wxpath-0.2.0.dist-info/top_level.txt,sha256=uFCcveG78mnefxRGvYsR2OexDlKR_Z1UD4vZijUcex8,7
+wxpath-0.2.0.dist-info/RECORD,,

wxpath-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wxpath

wxpath-0.1.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-wxpath-0.1.1.dist-info/licenses/LICENSE,sha256=AVBZLhdWmqxm-f-dy5prVB1E-solHWoP2EXEIV_o-00,1076
-wxpath-0.1.1.dist-info/METADATA,sha256=-CZQ3N2wjoO2ArbQ5JSdtMtMUrnLwiOGnQMtnBdzleE,17719
-wxpath-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wxpath-0.1.1.dist-info/entry_points.txt,sha256=FwoIOnUTl-DjPqVw-eb9EHHiiXCyRZy_mEQKFu2eb5Y,43
-wxpath-0.1.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-wxpath-0.1.1.dist-info/RECORD,,

wxpath-0.1.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-