async-url-caller-base 0.1.0__tar.gz

async_url_caller_base-0.1.0/LICENSE.txt

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) since 2026: async-url-caller-base Python Module
+description: python async base class for calling URLs
+author:      J. Arrizza   email: cppgent0@gmail.com
+
+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.

async_url_caller_base-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+graft async_url_caller_base
+global-exclude *.py[cod]

async_url_caller_base-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: async-url-caller-base
+Version: 0.1.0
+Summary: python async base class for calling URLs
+Author-email: "J. Arrizza" <cppgent0@gmail.com>
+Maintainer-email: "J. Arrizza" <cppgent0@gmail.com>
+License-Expression: MIT
+Project-URL: Website, https://arrizza.com/async-url-caller-base
+Project-URL: Source, https://bitbucket.org/arrizza-public/async-url-caller-base/src/master
+Project-URL: Download, https://bitbucket.org/arrizza-public/async-url-caller-base/get/master.zip
+Keywords: async,aiohttp
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: falcon-logger
+Dynamic: license-file
+
+* website: [Website](https://arrizza.com/TODO.html)
+* installation: [Common Setup](https://arrizza.com/setup-common.html)
+
+## Summary
+
+***Under Construction***

async_url_caller_base-0.1.0/README.md

@@ -0,0 +1,6 @@
+* website: [Website](https://arrizza.com/TODO.html)
+* installation: [Common Setup](https://arrizza.com/setup-common.html)
+
+## Summary
+
+***Under Construction***

async_url_caller_base-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+description = 'python async base class for calling URLs'
+keywords = ['async', 'aiohttp']
+
+classifiers = [
+    # "Private :: Do Not Upload",   # use to prevent upload
+    # Choose either '3 - Alpha', '4 - Beta' or '5 - Production/Stable'
+    'Development Status :: 1 - Planning',
+    'Environment :: Console',
+    'Topic :: Utilities',
+    'Intended Audience :: Developers',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.12',
+]
+# additional packages to install
+dependencies = [
+    'falcon-logger',
+]
+
+# common values
+name = 'async-url-caller-base'
+version = '0.1.0'
+requires-python = '>=3.9'
+authors = [{ name = 'J. Arrizza', email = 'cppgent0@gmail.com' }]
+maintainers = [
+    { name = 'J. Arrizza', email = 'cppgent0@gmail.com' },
+]
+readme = { file = 'README.md', content-type = 'text/markdown' }
+license = 'MIT'
+
+[project.optional-dependencies]
+# None
+[project.scripts]
+# None e.g. spam-cli = "spam:main_cli"
+
+[project.urls]
+'Website' = 'https://arrizza.com/async-url-caller-base'
+'Source' = 'https://bitbucket.org/arrizza-public/async-url-caller-base/src/master'
+'Download' = 'https://bitbucket.org/arrizza-public/async-url-caller-base/get/master.zip'
+# 'Bug Reports' = 'TODO https://github.com/pypa/sampleproject/issues'
+# 'Funding' = 'TODO https://donate.pypi.org'
+# 'Say Thanks!' = 'TODO http://saythanks.io/to/example'
+
+[tool.setuptools.packages.find]
+where = ['src']
+exclude = ['.gitignore']
+
+[tool.setuptools]
+include-package-data = true
+
+[build-system]
+requires = ['setuptools >=61.0']
+build-backend = 'setuptools.build_meta'

async_url_caller_base-0.1.0/setup.cfg

@@ -0,0 +1,43 @@
+[metadata]
+description_file = README.md
+
+[pylint.MESSAGES CONTROL]
+max-line-length = 140
+disable = C0114,C0115,C0116,C0415,R0801,R0903,R0912,R0913,R0917,W0511
+
+[pycodestyle]
+max-line-length = 140
+ignore = E266,E402,E731,E203
+statistics = True
+exclude = venv/*, out/*, pf_*, setup.py, debug/*, release/*
+
+[coverage:run]
+omit = 
+	./conftest.py
+	./out/*
+	./ut/*
+	./venv/*
+	./ver/*
+	build_info.py
+branch = true
+
+[coverage:report]
+exclude_lines = 
+	pragma: no cover
+	
+	def __repr__
+	if self\.debug
+	
+	raise NotImplementedError
+	
+	if 0:
+	if __main__ == .__main__:
+ignore_errors = True
+
+[coverage:html]
+directory = ./out/coverage
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

async_url_caller_base-0.1.0/src/async_url_caller_base/__init__.py

@@ -0,0 +1 @@
+# TODO add imports as needed

async_url_caller_base-0.1.0/src/async_url_caller_base/async_url_caller_base.py

@@ -0,0 +1,430 @@
+import asyncio
+import os
+import re
+import ssl
+import time
+from dataclasses import dataclass
+
+import aiohttp
+from falcon_logger import FalconLogger
+
+
+# --------------------
+## do async calls for a URL list
+class AsyncUrlCallerBase:
+    # --------------------
+    ## constructor
+    # @param logger    the logger to use. if None, then FalconLogger is used
+    #                  the logger must have these functions:
+    #                     line      - print a line
+    #                     dbg       - print a debug line e.g. prefix "DBG"
+    #                     exception - print exception information
+    def __init__(self, logger=None):
+        if logger is None:
+            ## reference to the logger to use
+            self._log = FalconLogger(mode='immediate')
+            self._log.set_format('prefix')
+        else:
+            self._log = logger
+        ## prefix tax in log lines
+        self._tag = self.__class__.__name__
+
+        ## ip address to use for raw calls
+        self._ip_address = None
+        ## ip port to use for raw calls
+        self._port = None
+
+        ## holds ssl information
+        self._ssl_context = None
+        ## allow redirect status codes
+        self._allow_redirects = True
+
+        ## max time out to wait for a response
+        self._max_timeout = 9.0
+        ## the timeout per wait
+        self._timeout = 4.0
+        ## how long to pause the async thread when a timeout occurs
+        self._delay = 0.300
+
+        ## multiplier for cpu count for total number of threads
+        self._thread_multiplier = 3
+
+    # --------------------
+    ## the thread multiplier.
+    # This is used to calculated the number of threads:
+    #   * number of cpus * this multiplier
+    #
+    # @param new_val   the new multiplier value
+    def _set_thread_multiplier(self, new_val):
+        self._thread_multiplier = new_val
+
+    ## the thread multiplier
+    thread_multiplier = property(fset=_set_thread_multiplier)
+
+    # --------------------
+    ## these are parameters needed for raw calls.
+    # @param ip_address   the IP address to use for these calls
+    # @param port         the IP port to use, typically 443
+    def set_raw_params(self, ip_address, port):
+        self._ip_address = ip_address
+        self._port = port
+
+    # --------------------
+    ## set timeout parameters
+    # @param max_timeout  the maximum total accumulated timeout
+    # @param timeout      the individual timeout for each call
+    # @param delay        the delay between calls
+    def set_timeouts(self, max_timeout, timeout, delay):
+        self._max_timeout = max_timeout
+        self._timeout = timeout
+        self._delay = delay
+
+    # -------------------
+    ## default - exclude a url from running in a normal get()
+    # @param url   the url to skip
+    # @return  if True, the url is skipped, otherwise it is run
+    def is_excluded_get(self, url):
+        # don't exclude
+        return False
+
+    # -------------------
+    ## default - exclude a url from running in a raw request
+    # @param url   the url to skip
+    # @return  if True, the url is skipped, otherwise it is run
+    def is_excluded_raw(self, url):
+        # don't exclude
+        return False
+
+    # --------------------
+    ## run tests on all provided urls.
+    # @param urls             a dict of urls to use;
+    #                         key : the url with no scheme
+    #                         info: a triplet or longer:
+    #                           *  0:  "raw" vs "get"
+    #                           *  1:  full url (including scheme)
+    #                           *  2:  additional info for this call required by cb_xx function
+    # @param cb_get           the callback function for HTTP GETs URLs
+    # @param cb_raw           the callback function for URLs sent to ip_address/port
+    # @param need_content     if True, the content is retrieved; default is False
+    # @param allow_redirects  if True, reports 301 and 302's,
+    #                         otherwise the final result is returned; default is True
+    def run_all_tests(self, urls, cb_get=None, cb_raw=None, need_content=False, allow_redirects=True):
+        self._allow_redirects = allow_redirects
+        self._ssl_context = ssl.create_default_context()
+        self._ssl_context.check_hostname = False
+        self._ssl_context.verify_mode = ssl.CERT_NONE
+
+        if not cb_get:
+            cb_get = self.cb_get_default
+
+        if not cb_raw:
+            cb_raw = self.cb_raw_default
+
+        time_start = time.time()
+        asyncio.run(self._run_tests_async(urls, cb_get, cb_raw, need_content))
+        elapsed = time.time() - time_start
+        return elapsed
+
+    # === callbacks
+
+    # --------------------
+    ## a default callback function for GET URLs
+    # @param url       url w/ no scheme e.g. https://ip_addr
+    # @param info      triplet:
+    #                    *  0:  "raw" vs "get": for this call should be "get"
+    #                    *  1:  full url
+    #                    *  2:  additional callers info for this call e.g. list of IPs
+    # @param response  reference to response from call
+    # @param content   content returned by call
+    def cb_get_default(self, url, info, response, content=None):
+        status_code = response.status
+
+        # url => url with no scheme
+        # info[0] => raw/get call
+        # info[1] => url (with scheme)
+        self._log.dbg(f'{info[0]}: {status_code} {url} {content}')
+
+    # --------------------
+    ## a default callback function for raw URLs
+    # @param url       url w/ no scheme e.g. https://ip_addr
+    # @param info      triplet:
+    #                    *  0:  "raw" vs "get": for this call should be "raw"
+    #                    *  1:  full url
+    #                    *  2:  additional callers info for this call e.g. list of IPs
+    # @param response  reference to response from call
+    # @param content   content returned by call
+    def cb_raw_default(self, url, info, response, content):
+        status_code = response.status
+
+        # url => url with no scheme
+        # info[0] => raw/get call
+        # info[1] => url (with scheme)
+        self._log.dbg(f'{info[0]}: {status_code} {url} {content}')
+
+    # # --- handle exceptions in calls
+
+    # --------------------
+    ## overridable function to handle reporting TimeoutError exceptions
+    # @param excp       reference to the exception
+    # @param call_type  'raw' or 'get'
+    # @param url        the url that was called
+    # @param info       the associated info from the dict for this url
+    # @param loop       which delay loop
+    # @param elapsed    total time elasped since the call was invoked
+    def handle_excp_timeout_error(self, excp, call_type, url, info, loop, elapsed):
+        self._log.err(f'({call_type}) Timeout excp occurred, loop:{loop: >3} elapsed:{round(elapsed, 1)} {type(excp).__name__}')
+        self._log.err(f'      {loop: >3}] {url} {info[1]}')
+
+    # --------------------
+    ## overridable function to handle reporting ClientError exceptions
+    # @param excp       reference to the exception
+    # @param call_type  'raw' or 'get'
+    # @param url        the url that was called
+    # @param info       the associated info from the dict for this url
+    def handle_excp_client_error(self, excp, call_type, url, info):
+        self._log.err(f'({call_type}) Client excp occurred: {type(excp).__name__}')
+        self._log.err(f'      {url} {info[1]}')
+
+    # --------------------
+    ## overridable function to handle reporting ResetError or IncompleteReadError exceptions
+    # @param excp       reference to the exception
+    # @param call_type  'raw' or 'get'
+    # @param url        the url that was called
+    # @param info       the associated info from the dict for this url
+    def handle_excp_reset_error(self, excp, call_type, url, info):
+        self._log.err(f'({call_type}) Reset excp occurred: {type(excp).__name__}')
+        self._log.err(f'      {url} {info[1]}')
+
+    # --------------------
+    ## overridable function to handle reporting general exceptions
+    # @param excp       reference to the exception
+    # @param call_type  'raw' or 'get'
+    # @param url        the url that was called
+    # @param info       the associated info from the dict for this url
+    # @param response   the response from the call
+    def handle_excp_general(self, excp, call_type, url, info, response):
+        self._log.err(f'({call_type}) General excp: unexpected error: {type(excp).__name__}')
+        self._log.err(f'  url  : {url}')
+        self._log.err(f'  full : {info[1]}')
+        redir_url = response.headers.get('Location')
+        if redir_url is not None:
+            self._log.err(f'  redir: {redir_url}')
+        self._log.exception(excp)
+
+    # --------------------
+    ## overridable function to handle responses with unknown status codes
+    # @param call_type    'raw' or 'get'
+    # @param url          the url that was called
+    # @param info         the associated info from the dict for this url
+    # @param content      the returned content
+    # @param status_code  the response status code
+    def handle_unknown_status_code(self, call_type, url, info, content, status_code):
+        self._log.err(f'({call_type}): unknown status code in response: assuming {status_code}')
+        self._log.err(f'   url    : {url} {info[1]}')
+        self._log.err(f'   content: "{content}"')
+
+    # --- private from here on
+
+    ## used to simulate a Response object when there isn't one e.g. nginx 444s
+    @dataclass
+    class MockResponse:
+        status: int
+        history: dict
+        url: str
+        headers: str
+        reason: str
+
+    # --------------------
+    ## run the async tests
+    # @param urls          dict of urls:
+    #                         key : the url with no scheme
+    #                         info: a triplet or longer:
+    #                           *  0:  "raw" vs "get"
+    #                           *  1:  full url (including scheme)
+    #                           *  2:  additional info for this call required by cb_xx function
+    # @param cb_get        callback for "get" urls
+    # @param cb_raw        callback for "raw" urls
+    # @param need_content  if true, get the content and pass it to the cb_xx function
+    async def _run_tests_async(self, urls, cb_get, cb_raw, need_content):
+        num_threads = os.cpu_count() * self._thread_multiplier
+        self._log.line(f'{self._tag}: num cpus: {os.cpu_count()}, threads: {num_threads}')
+        semaphore = asyncio.Semaphore(num_threads)
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+            'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+        }
+        async with aiohttp.ClientSession(headers=headers, connector=aiohttp.TCPConnector(ssl=self._ssl_context)) as session:
+            # --- async call to do a normal get
+            async def bounded_fetch(url, info, cb_get, need_content):
+                # Acquire the semaphore to respect the concurrency limit
+                async with semaphore:
+                    await self._fetch_get(session, url, info, cb_get, need_content)
+
+            # --- async call to do a raw call e.g. CONNECT, PRI, etc.
+            async def raw_fetch(url, info, cb_raw):
+                async with semaphore:
+                    await self._fetch_raw(url, info, cb_raw)
+
+            # load tasks with all calls to do
+            tasks = []
+            for url, info in sorted(urls.items()):
+                if info[0] == 'raw':
+                    tasks.append(raw_fetch(url, info, cb_raw))
+                else:
+                    tasks.append(bounded_fetch(url, info, cb_get, need_content))
+
+            await asyncio.gather(*tasks)
+
+    # --------------------
+    ## do the GET fetch for on the URL
+    # @param session   reference to session object
+    # @param key       raw url, no leading root e.g. https://your_server
+    # @param info      triplet:
+    #                    *  0:  "raw" vs "get": for this call should be "get"
+    #                    *  1:  full url
+    #                    *  2:  additional callers info for this call e.g. list of IPs
+    # @param cb_get        callback function when
+    # @param need_content   if true, then read and return the content of the call's response, else return None for content
+    async def _fetch_get(self, session, key, info, cb_get, need_content):
+        url = info[1]
+
+        if self.is_excluded_get(url):
+            return
+
+        done = False
+        loop = 0
+        start_time = time.time()
+        while not done:
+            loop += 1
+
+            try:
+                async with session.get(
+                    url, timeout=self._timeout, ssl=self._ssl_context, allow_redirects=self._allow_redirects
+                ) as response:
+                    if need_content:
+                        content = await response.read()
+                    else:
+                        content = None
+                    if response.status == 503:
+                        elapsed = time.time() - start_time
+                        if (elapsed) > self._max_timeout:
+                            done = True
+                        else:
+                            time.sleep(self._delay)
+                            self._delay = self._delay * 1.5
+                    else:
+                        cb_get(key, info, response, content)
+                        done = True
+            except asyncio.TimeoutError as excp:
+                elapsed = time.time() - start_time
+                self.handle_excp_timeout_error(excp, 'get', key, info, loop, elapsed)
+                if elapsed > self._max_timeout:
+                    done = True
+                else:
+                    time.sleep(self._delay)
+                    self._delay = self._delay * 1.5
+            except aiohttp.ClientError as excp:
+                if str(excp) in ['Server disconnected', 'Session is closed']:
+                    response = self.MockResponse(status=444, history={}, url=url, headers=None, reason='clienterror excp')
+                    content = b''
+                    cb_get(key, info, response, content)
+                    done = True
+                else:
+                    self.handle_excp_client_error(excp, 'get', key, info)
+                    # give up
+                    done = True
+            except (ConnectionResetError, asyncio.IncompleteReadError) as excp:
+                self.handle_excp_reset_error(excp, 'get', key, info)
+                done = True
+            except Exception as excp:
+                self.handle_excp_general(excp, 'get', key, info, response)
+                done = True
+
+    # -------------------
+    ## do a fetch on a raw url
+    # @param key       raw url, no leading root e.g. https://ip_addr
+    # @param info      triplet:
+    #                    *  0:  "raw" vs "get": for this call should be "get"
+    #                    *  1:  full url
+    #                    *  2:  additional callers info for this call e.g. list of IPs
+    # @param cb_raw    callback function when
+    async def _fetch_raw(self, key, info, cb_raw):
+        url = info[1]
+
+        if self.is_excluded_raw(url):
+            return
+
+        done = False
+        loop = 0
+        start_time = time.time()
+        while not done:
+            loop += 1
+
+            try:
+                request_lines = [
+                    f'{url} HTTP/1.1',
+                    f'Host: {self._ip_address}',
+                    'Content-Length: 0',
+                    '',
+                ]
+                full_request = '\r\n'.join(request_lines)
+                encoded_request = full_request.encode('ascii')
+
+                reader, writer = await asyncio.open_connection(self._ip_address, self._port, ssl=self._ssl_context)
+                writer.write(encoded_request)
+                await writer.drain()  # Ensure buffer is flushed
+
+                response = None
+                try:
+                    response = await asyncio.wait_for(reader.read(10), timeout=self._timeout)
+                except asyncio.TimeoutError as excp:
+                    elapsed = time.time() - start_time
+                    self.handle_excp_timeout_error(excp, 'raw', key, info, loop, elapsed)
+                    if elapsed > self._max_timeout:
+                        done = True
+                    else:
+                        time.sleep(self._delay)
+                        self._delay = self._delay * 1.5
+                except aiohttp.ClientError as excp:
+                    if str(excp) in ['Server disconnected', 'Session is closed']:
+                        response = self.MockResponse(status=444, history={}, url=url, headers=None, reason='clienterror excp')
+                        content = b''
+                        cb_raw(key, info, response, content)
+                        done = True
+                    else:
+                        self.handle_excp_client_error(excp, 'raw', key, info)
+                        done = True
+                except (ConnectionResetError, asyncio.IncompleteReadError) as excp:
+                    self.handle_excp_reset_error(excp, 'raw', key, info)
+                    done = True
+                except Exception as excp:
+                    self.handle_excp_general(excp, 'raw', key, info, response)
+                    done = True
+
+                content = ''
+                if response is not None and response != b'':
+                    remaining_data = await reader.read(4096)
+                    response = response + remaining_data
+                    content = response.decode('utf-8')
+
+                if response is None or response == b'':
+                    # this is an assumption based on what occurs with MKCOL calls
+                    response = self.MockResponse(status=444, history={}, url=url, headers=None, reason='response is empty')
+                else:
+                    m = re.search(r'HTTP/.* (\d+) ', content)
+                    if m:
+                        status_code = m.group(1)
+                    else:
+                        status_code = 600
+                        self.handle_unknown_status_code('raw', key, info, content, status_code)
+                    response = self.MockResponse(status=status_code, history={}, url=url, headers=None, reason='response is empty')
+
+                # close after the wait_for otherwise socket may close
+                writer.close()
+                await writer.wait_closed()
+                cb_raw(key, info, response, content)
+                done = True
+            except Exception as excp:
+                self.handle_excp_general(excp, 'raw', key, info, response)
+                done = True

async_url_caller_base-0.1.0/src/async_url_caller_base/constants.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from .constants_version import ConstantsVersion
+
+
+# -------------------
+## Holds various constants
+@dataclass
+class Constants(ConstantsVersion):  # pylint: disable=too-few-public-methods
+    pass

async_url_caller_base-0.1.0/src/async_url_caller_base/constants_version.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+# --------------------
+## holds constants
+@dataclass
+class ConstantsVersion:
+    ## current App version
+    version = '0.1.0'

async_url_caller_base-0.1.0/src/async_url_caller_base.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: async-url-caller-base
+Version: 0.1.0
+Summary: python async base class for calling URLs
+Author-email: "J. Arrizza" <cppgent0@gmail.com>
+Maintainer-email: "J. Arrizza" <cppgent0@gmail.com>
+License-Expression: MIT
+Project-URL: Website, https://arrizza.com/async-url-caller-base
+Project-URL: Source, https://bitbucket.org/arrizza-public/async-url-caller-base/src/master
+Project-URL: Download, https://bitbucket.org/arrizza-public/async-url-caller-base/get/master.zip
+Keywords: async,aiohttp
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: falcon-logger
+Dynamic: license-file
+
+* website: [Website](https://arrizza.com/TODO.html)
+* installation: [Common Setup](https://arrizza.com/setup-common.html)
+
+## Summary
+
+***Under Construction***

async_url_caller_base-0.1.0/src/async_url_caller_base.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.txt
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+src/async_url_caller_base/__init__.py
+src/async_url_caller_base/async_url_caller_base.py
+src/async_url_caller_base/constants.py
+src/async_url_caller_base/constants_version.py
+src/async_url_caller_base.egg-info/PKG-INFO
+src/async_url_caller_base.egg-info/SOURCES.txt
+src/async_url_caller_base.egg-info/dependency_links.txt
+src/async_url_caller_base.egg-info/requires.txt
+src/async_url_caller_base.egg-info/top_level.txt

async_url_caller_base-0.1.0/src/async_url_caller_base.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

async_url_caller_base-0.1.0/src/async_url_caller_base.egg-info/requires.txt

@@ -0,0 +1 @@
+falcon-logger

async_url_caller_base-0.1.0/src/async_url_caller_base.egg-info/top_level.txt

@@ -0,0 +1 @@
+async_url_caller_base