lanscape 1.3.2a7__py3-none-any.whl → 1.3.2a9__py3-none-any.whl

lanscape/resources/mac_addresses/convert_csv.py

@@ -0,0 +1,30 @@
+# Only used to import csv data - not during runtime
+
+import csv
+import json
+
+
+def main():
+    ans = {}
+    with open('mac-vendors-export.csv', 'r', encoding='utf-8') as f:
+        data = csv.reader(f)
+        services = csv_to_dict(data)
+    for service in services:
+        if service['Vendor Name'] and service['Mac Prefix']:
+            try:
+                ans[service['Mac Prefix']] = service['Vendor Name']
+            except BaseException:
+                pass
+    with open('mac_db.json', 'w') as f:
+        json.dump(ans, f, indent=2)
+
+
+def csv_to_dict(data):
+    """
+    Convert a CSV file to a dictionary.
+    """
+    header = next(data)
+    return [dict(zip(header, row)) for row in data]
+
+
+main()

lanscape/resources/ports/convert_csv.py

@@ -0,0 +1,30 @@
+# Only used to import csv data - not during runtime
+
+import csv
+import json
+
+
+def main():
+    ans = {}
+    with open('service-names-port-numbers.csv', 'r') as f:
+        data = csv.reader(f)
+        services = csv_to_dict(data)
+    for service in services:
+        if service['Service Name'] and service['Port Number']:
+            try:
+                ans[service['Port Number']] = service['Service Name']
+            except BaseException:
+                pass
+    with open('valid_ports.json', 'w') as f:
+        json.dump(ans, f, indent=2)
+
+
+def csv_to_dict(data):
+    """
+    Convert a CSV file to a dictionary.
+    """
+    header = next(data)
+    return [dict(zip(header, row)) for row in data]
+
+
+main()

lanscape/ui/app.py

@@ -0,0 +1,128 @@
+from flask import Flask, render_template, request
+import traceback
+import threading
+import logging
+import os
+
+from lanscape.libraries.runtime_args import RuntimeArgs, parse_args
+from lanscape.libraries.version_manager import is_update_available, get_installed_version, lookup_latest_version
+from lanscape.libraries.app_scope import is_local_run
+from lanscape.libraries.net_tools import is_arp_supported
+
+app = Flask(
+    __name__
+)
+log = logging.getLogger('flask')
+
+# Import and register BPs
+################################
+from lanscape.ui.blueprints.api import api_bp, tools, port, scan
+from lanscape.ui.blueprints.web import web_bp, routes
+
+app.register_blueprint(api_bp)
+app.register_blueprint(web_bp)
+
+# Define global jinja filters
+################################
+
+
+def is_substring_in_values(results: dict, substring: str) -> bool:
+    return any(substring.lower() in str(v).lower() for v in results.values()) if substring else True
+
+
+app.jinja_env.filters['is_substring_in_values'] = is_substring_in_values
+
+# Define global jinja vars
+################################
+
+
+def set_global_safe(key: str, value):
+    """ Safely set global vars without worrying about an exception """
+    app_globals = app.jinja_env.globals
+    try:
+        if callable(value):
+            value = value()
+
+        app_globals[key] = value
+        log.debug(f'jinja_globals[{key}] = {value}')
+    except BaseException:
+        default = app_globals.get(key)
+        log.debug(traceback.format_exc())
+        log.info(
+            f"Unable to set app global var '{key}'" +
+            f"defaulting to '{default}'"
+        )
+        app_globals[key] = default
+
+
+set_global_safe('app_version', get_installed_version)
+set_global_safe('update_available', is_update_available)
+set_global_safe('latest_version', lookup_latest_version)
+set_global_safe('runtime_args', vars(parse_args()))
+set_global_safe('is_local', is_local_run)
+set_global_safe('is_arp_supported', is_arp_supported)
+
+# External hook to kill flask server
+################################
+
+exiting = False
+
+
+@app.route("/shutdown", methods=['GET', 'POST'])
+def exit_app():
+
+    req_type = request.args.get('type')
+    if req_type == 'browser-close':
+        args = parse_args()
+        if args.persistent:
+            log.info('Dectected browser close, not exiting flask.')
+            return "Ignored"
+        log.info('Web browser closed, terminating flask. (disable with --peristent)')
+    elif req_type == 'core':
+        log.info('Core requested exit, terminating flask.')
+    else:
+        log.info('Received external exit request. Terminating flask.')
+    global exiting
+    exiting = True
+    return "Done"
+
+
+@app.teardown_request
+def teardown(exception):
+    if exiting:
+        os._exit(0)
+
+# Generalized error handling
+################################
+
+
+@app.errorhandler(500)
+def internal_error(e):
+    """
+    handle internal errors nicely
+    """
+    tb = traceback.format_exc()
+    return render_template('error.html',
+                           error=None,
+                           traceback=tb), 500
+
+# Webserver creation functions
+################################
+
+
+def start_webserver_daemon(args: RuntimeArgs) -> threading.Thread:
+    proc = threading.Thread(target=start_webserver, args=(args,))
+    proc.daemon = True  # Kill thread when main thread exits
+    proc.start()
+    log.info('Flask server initializing as dameon')
+    return proc
+
+
+def start_webserver(args: RuntimeArgs) -> int:
+    run_args = {
+        'host': '0.0.0.0',
+        'port': args.port,
+        'debug': args.reloader,
+        'use_reloader': args.reloader
+    }
+    app.run(**run_args)

lanscape/ui/blueprints/__init__.py

@@ -0,0 +1,7 @@
+from lanscape.libraries.subnet_scan import ScanManager
+import logging
+# defining here so blueprints can access the same
+# manager instance
+scan_manager = ScanManager()
+
+log = logging.getLogger('Blueprints')

lanscape/ui/blueprints/api/__init__.py

@@ -0,0 +1,3 @@
+from flask import Blueprint
+
+api_bp = Blueprint('api', __name__)

lanscape/ui/blueprints/api/port.py

@@ -0,0 +1,33 @@
+from flask import request, jsonify
+from lanscape.ui.blueprints.api import api_bp
+from lanscape.libraries.port_manager import PortManager
+
+# Port Manager API
+############################################
+
+
+@api_bp.route('/api/port/list', methods=['GET'])
+def get_port_lists():
+    return jsonify(PortManager().get_port_lists())
+
+
+@api_bp.route('/api/port/list/<port_list>', methods=['GET'])
+def get_port_list(port_list):
+    return jsonify(PortManager().get_port_list(port_list))
+
+
+@api_bp.route('/api/port/list/<port_list>', methods=['POST'])
+def create_port_list(port_list):
+    data = request.get_json()
+    return jsonify(PortManager().create_port_list(port_list, data))
+
+
+@api_bp.route('/api/port/list/<port_list>', methods=['PUT'])
+def update_port_list(port_list):
+    data = request.get_json()
+    return jsonify(PortManager().update_port_list(port_list, data))
+
+
+@api_bp.route('/api/port/list/<port_list>', methods=['DELETE'])
+def delete_port_list(port_list):
+    return jsonify(PortManager().delete_port_list(port_list))

lanscape/ui/blueprints/api/scan.py

@@ -0,0 +1,75 @@
+from lanscape.ui.blueprints.api import api_bp
+from lanscape.libraries.subnet_scan import ScanConfig
+from lanscape.ui.blueprints import scan_manager
+
+from flask import request, jsonify
+import json
+import traceback
+
+# Subnet Scanner API
+############################################
+
+
+@api_bp.route('/api/scan', methods=['POST'])
+@api_bp.route('/api/scan/threaded', methods=['POST'])
+def scan_subnet_threaded():
+    try:
+        config = get_scan_config()
+        scan = scan_manager.new_scan(config)
+
+        return jsonify({'status': 'running', 'scan_id': scan.uid})
+    except BaseException:
+        return jsonify({'status': 'error', 'traceback': traceback.format_exc()}), 500
+
+
+@api_bp.route('/api/scan/async', methods=['POST'])
+def scan_subnet_async():
+    config = get_scan_config()
+    scan = scan_manager.new_scan(config)
+    scan_manager.wait_until_complete(scan.uid)
+
+    return jsonify({'status': 'complete', 'scan_id': scan.uid})
+
+
+@api_bp.route('/api/scan/<scan_id>', methods=['GET'])
+def get_scan(scan_id):
+    scan = scan_manager.get_scan(scan_id)
+    # cast to str and back to handle custom JSON serialization
+    return jsonify(json.loads(scan.results.export(str)))
+
+
+@api_bp.route('/api/scan/<scan_id>/summary', methods=['GET'])
+def get_scan_summary(scan_id):
+    scan = scan_manager.get_scan(scan_id)
+    if not scan:
+        return jsonify({'error': 'scan not found'}), 404
+    return jsonify({
+        'running': scan.running,
+        'percent_complete': scan.calc_percent_complete(),
+        'stage': scan.results.stage,
+        'runtime': scan.results.get_runtime(),
+        'devices': {
+            'scanned': scan.results.devices_scanned,
+            'alive': len(scan.results.devices),
+            'total': scan.results.devices_total
+        }
+    })
+
+
+@api_bp.route('/api/scan/<scan_id>/terminate', methods=['GET'])
+def terminate_scan(scan_id):
+    scan = scan_manager.get_scan(scan_id)
+    scan.terminate()
+    return jsonify({'success': True})
+
+
+def get_scan_config():
+    """
+    pulls config from the request body
+    """
+    data = request.get_json()
+    return ScanConfig(
+        subnet=data['subnet'],
+        port_list=data['port_list'],
+        t_multiplier=data.get('parallelism', 1.0)
+    )

lanscape/ui/blueprints/api/tools.py

@@ -0,0 +1,36 @@
+from flask import request, jsonify
+from lanscape.ui.blueprints.api import api_bp
+from lanscape.libraries.net_tools import get_all_network_subnets
+from lanscape.libraries.ip_parser import parse_ip_input
+from lanscape.libraries.errors import SubnetTooLargeError
+import traceback
+
+
+@api_bp.route('/api/tools/subnet/test')
+def test_subnet():
+    subnet = request.args.get('subnet')
+    if not subnet:
+        return jsonify({'valid': False, 'msg': 'Subnet cannot be blank', 'count': -1})
+    try:
+        ips = parse_ip_input(subnet)
+        length = len(ips)
+        return jsonify({'valid': True,
+                        'msg': f"{length} IP{'s' if length > 1 else ''}",
+                        'count': length})
+    except SubnetTooLargeError:
+        return jsonify({'valid': False, 'msg': 'subnet too large',
+                       'error': traceback.format_exc(), 'count': -1})
+    except BaseException:
+        return jsonify({'valid': False, 'msg': 'invalid subnet',
+                       'error': traceback.format_exc(), 'count': -1})
+
+
+@api_bp.route('/api/tools/subnet/list')
+def list_subnet():
+    """
+    list all interface subnets
+    """
+    try:
+        return jsonify(get_all_network_subnets())
+    except BaseException:
+        return jsonify({'error': traceback.format_exc()})

lanscape/ui/blueprints/web/__init__.py

@@ -0,0 +1,3 @@
+from flask import Blueprint
+
+web_bp = Blueprint('web', __name__)

lanscape/ui/blueprints/web/routes.py

@@ -0,0 +1,78 @@
+from flask import render_template, request, redirect
+from lanscape.ui.blueprints.web import web_bp
+from lanscape.libraries.net_tools import (
+    get_all_network_subnets,
+    smart_select_primary_subnet
+)
+from lanscape.ui.blueprints import scan_manager, log
+
+# Template Renderer
+############################################
+
+
+@web_bp.route('/', methods=['GET'])
+def index():
+    subnets = get_all_network_subnets()
+    subnet = smart_select_primary_subnet(subnets)
+
+    port_list = 'medium'
+    parallelism = 1
+    if scan_id := request.args.get('scan_id'):
+        if scan := scan_manager.get_scan(scan_id):
+            subnet = scan.cfg.subnet
+            port_list = scan.cfg.port_list
+            parallelism = scan.cfg.t_multiplier
+
+        else:
+            log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
+            return redirect('/')
+    return render_template(
+        'main.html',
+        subnet=subnet,
+        port_list=port_list,
+        parallelism=parallelism,
+        alternate_subnets=subnets
+    )
+
+
+@web_bp.route('/scan/<scan_id>', methods=['GET'])
+@web_bp.route('/scan/<scan_id>/<section>', methods=['GET'])
+def render_scan(scan_id, section='all'):
+    if scanner := scan_manager.get_scan(scan_id):
+        data = scanner.results.export()
+        filter = request.args.get('filter')
+        return render_template('scan.html', data=data, section=section, filter=filter)
+    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
+    return redirect('/')
+
+
+@web_bp.route('/errors/<scan_id>')
+def view_errors(scan_id):
+    if scanner := scan_manager.get_scan(scan_id):
+        data = scanner.results.export()
+        return render_template('scan/scan-error.html', data=data)
+    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
+    return redirect('/')
+
+
+@web_bp.route('/export/<scan_id>')
+def export_scan(scan_id):
+    if scanner := scan_manager.get_scan(scan_id):
+        export_json = scanner.results.export(str)
+        return render_template(
+            'scan/export.html',
+            scan=scanner,
+            export_json=export_json
+        )
+    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
+    return redirect('/')
+
+
+@web_bp.route('/shutdown-ui')
+def shutdown_ui():
+    return render_template('shutdown.html')
+
+
+@web_bp.route('/info')
+def app_info():
+    return render_template('info.html')

lanscape/ui/main.py

@@ -0,0 +1,137 @@
+
+import socket
+
+
+import threading
+import time
+import logging
+import traceback
+import os
+from lanscape.libraries.logger import configure_logging
+from lanscape.libraries.runtime_args import parse_args, RuntimeArgs
+from lanscape.libraries.web_browser import open_webapp
+from lanscape.libraries.net_tools import is_arp_supported
+from lanscape.libraries.version_manager import get_installed_version, is_update_available
+from lanscape.ui.app import start_webserver_daemon, start_webserver
+# do this so any logs generated on import are displayed
+args = parse_args()
+configure_logging(args.loglevel, args.logfile, args.flask_logging)
+
+
+log = logging.getLogger('core')
+# determine if the execution is an instance of a flask reload
+# happens on file change with reloader enabled
+IS_FLASK_RELOAD = os.environ.get("WERKZEUG_RUN_MAIN")
+
+
+def main():
+    try:
+        _main()
+    except KeyboardInterrupt:
+        log.info('Keyboard interrupt received, terminating...')
+        terminate()
+    except Exception as e:
+        log.critical(f'Unexpected error: {e}')
+        log.debug(traceback.format_exc())
+        terminate()
+
+
+def _main():
+    if not IS_FLASK_RELOAD:
+        log.info(f'LANscape v{get_installed_version()}')
+        try_check_update()
+
+    else:
+        log.info('Flask reloaded app.')
+
+    args.port = get_valid_port(args.port)
+
+    if not is_arp_supported():
+        log.warning('ARP is not supported, device discovery is degraded. For more information, see the help guide: https://github.com/mdennis281/LANscape/blob/main/support/arp-issues.md')
+
+    try:
+        start_webserver_ui(args)
+        log.info('Exiting...')
+    except Exception as e:
+        # showing error in debug only because this is handled gracefully
+        log.critical(f'Failed to start app. Error: {e}')
+        log.debug('Failed to start. Traceback below')
+        log.debug(traceback.format_exc())
+
+
+def try_check_update():
+    try:
+        if is_update_available():
+            log.info('An update is available!')
+            log.info(
+                'Run "pip install --upgrade lanscape --no-cache" to suppress this message.')
+    except BaseException:
+        log.debug(traceback.format_exc())
+        log.warning('Unable to check for updates.')
+
+
+def open_browser(url: str, wait=2) -> bool:
+    """
+    Open a browser window to the specified
+    url after waiting for the server to start
+    """
+    try:
+        time.sleep(wait)
+        log.info(f'Starting UI - http://127.0.0.1:{args.port}')
+        return open_webapp(url)
+
+    except BaseException:
+        log.debug(traceback.format_exc())
+        log.info(f'Unable to open web browser, server running on {url}')
+    return False
+
+
+def start_webserver_ui(args: RuntimeArgs):
+    uri = f'http://127.0.0.1:{args.port}'
+
+    # running reloader requires flask to run in main thread
+    # this decouples UI from main process
+    if args.reloader:
+        # determine if it was reloaded by flask debug reloader
+        # if it was, dont open the browser again
+        log.info('Opening UI as daemon')
+        if not IS_FLASK_RELOAD:
+            threading.Thread(
+                target=open_browser,
+                args=(uri,),
+                daemon=True
+            ).start()
+        start_webserver(args)
+    else:
+        flask_thread = start_webserver_daemon(args)
+        app_closed = open_browser(uri)
+
+        # depending on env, open_browser may or
+        # may not be coupled with the closure of UI
+        # (if in browser tab, it's uncoupled)
+        if not app_closed or args.persistent:
+            # not doing a direct join so i can still
+            # terminate the app with ctrl+c
+            while flask_thread.is_alive():
+                time.sleep(1)
+
+
+def get_valid_port(port: int):
+    """
+    Get the first available port starting from the specified port
+    """
+    while True:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            if s.connect_ex(('localhost', port)) != 0:
+                return port
+            port += 1
+
+
+def terminate():
+    import requests
+    log.info('Attempting flask shutdown')
+    requests.get(f'http://127.0.0.1:{args.port}/shutdown?type=core')
+
+
+if __name__ == "__main__":
+    main()

{lanscape-1.3.2a7.dist-info → lanscape-1.3.2a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 1.3.2a7
+Version: 1.3.2a9
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT

{lanscape-1.3.2a7.dist-info → lanscape-1.3.2a9.dist-info}/RECORD

@@ -1,11 +1,37 @@
 lanscape/__init__.py,sha256=CpU5C1IdJ9mkGAwJakvnpaFNiQhnTYoOwtSJI-1xUG4,239
 lanscape/__main__.py,sha256=mxgOewoYiNlUCb-QNFKBUqXoPVjMyMIVuLrqg4tNBJk,179
+lanscape/libraries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lanscape/libraries/app_scope.py,sha256=LTvCD60NFBDqZTAMWFDDyBFNuilli52cWj-Q2K6KezQ,2628
+lanscape/libraries/decorators.py,sha256=wVOC7Wv6mEQIkLlpPJbbxFk_dS3RkLWfYq1ep6oPeYI,5217
+lanscape/libraries/errors.py,sha256=oBMcgPVWL5_O7OgpOf3NkUObCubA6xNkusM3AqIrbX8,972
+lanscape/libraries/ip_parser.py,sha256=sMiACqmIy-uvWoCNhTCYxZ37521nFAeoihRftR1_5DU,2220
+lanscape/libraries/logger.py,sha256=WlUg1y88iqjNgUarbyEUWxsc5pgm4KU5lnfTqK-kNWc,1451
+lanscape/libraries/mac_lookup.py,sha256=m0uxVPxLR8-vkWnqd3ZoauUXYWRBlUntzltfWjiRN5w,3481
+lanscape/libraries/net_tools.py,sha256=M-ZfCCHvS4ABNlmVBHLVSNvrFMQ3TaBVHmgVZUhGd30,18324
+lanscape/libraries/port_manager.py,sha256=CStw-xgwCi9a7dmYL_Ox78K5vUCExjOZyUg3LEf6Afc,2085
+lanscape/libraries/runtime_args.py,sha256=vqspmExhqnyT_vs7FIM3Fe1I8iQUGe2v9Qz0jmyMWjU,2122
+lanscape/libraries/scan_config.py,sha256=KcBLsxo5RK8M5tyId9WfF5MvKb1Nr9TCCYLnAXrmnZI,2660
+lanscape/libraries/service_scan.py,sha256=KVbw2pjie6hrGl092KRM-FtduB9Id8fg1g3SqP-PsfE,1920
+lanscape/libraries/subnet_scan.py,sha256=N5Db3zUdzlF0OyGlYv0Z5YSIItTxw0NxzmbcfF5vtCc,12075
+lanscape/libraries/version_manager.py,sha256=drVagoN9KcxDl4I0Y8JnurBQZlW0u2ViPz6Pmk5cl7w,1756
+lanscape/libraries/web_browser.py,sha256=CIztmodX8o8Is-0ZiM7JQ3vf4olKhCo9VjpQkzJleVM,5007
+lanscape/resources/mac_addresses/convert_csv.py,sha256=35yBKtRPlUK4O1hjHqfRTAa7CgEz4t49sUYovSh88Rs,740
 lanscape/resources/mac_addresses/mac_db.json,sha256=ygtFSwNwJzDlg6hmAujdgCyzUjxt9Di75J8SO4xYIs8,2187804
+lanscape/resources/ports/convert_csv.py,sha256=YB189V2vcbCYIloCHq9A1hXeSTtEYmJT30g66zezrBI,739
 lanscape/resources/ports/full.json,sha256=Abfbi-b5yZF4jR5NS6CT6QpIDfx4Vk04gIC1fKH2ws0,1506980
 lanscape/resources/ports/large.json,sha256=jK4gkzlPT74uv4y0TvFjsaOaUcX7Cy8Zxe2bh5FYcc0,144496
 lanscape/resources/ports/medium.json,sha256=3yHAca0_pEWXK4k1wmda1eNVM6ftzcpKn5VspVwmkRs,3667
 lanscape/resources/ports/small.json,sha256=Mj3zGVG1F2eqZx2YkrLpTL8STeLcqB8_65IR67MS1Tg,397
 lanscape/resources/services/definitions.jsonc,sha256=71w9Q7r4RoBYiIMkzzO2KdEJXaSIchNccYQueqAhD4E,8842
+lanscape/ui/app.py,sha256=AVSfsKCipukx22cCOkK_9bUdSIrLtBknu0znJHJM7lI,3758
+lanscape/ui/main.py,sha256=qerJS6NQt6r6zM34j3saY6Ek57bKf3W11BBxDqgZ7ho,4341
+lanscape/ui/blueprints/__init__.py,sha256=fBrihVUCYryi-f5QpR73mQBFcgEjr40S4EcCVUuRXGs,214
+lanscape/ui/blueprints/api/__init__.py,sha256=wPhNBIriIz9SCfMuDQsPeuv2dUh6N40GD81-J1sHYwY,68
+lanscape/ui/blueprints/api/port.py,sha256=0FU6UNH8z7mfR8JwZHrPV-Vi6nuL2As9AU0NzYPyvlQ,1061
+lanscape/ui/blueprints/api/scan.py,sha256=sYu_-6nykCcEkNmWNQaBW_b1L34d9KigOlQALw2vJZc,2303
+lanscape/ui/blueprints/api/tools.py,sha256=NSSijS2F_kNlQ1NNjWQ3-OBpe2NlUdgg3ho6ist3hcE,1328
+lanscape/ui/blueprints/web/__init__.py,sha256=cz1cHN0FOtTlewVbMN9VsmPWAfqAZPT8YybTszZpTpY,68
+lanscape/ui/blueprints/web/routes.py,sha256=ndKcraNQ2cFRm_NRK5vjL5d0SDNOOUVG0hPKZmgDmAk,2464
 lanscape/ui/static/lanscape.webmanifest,sha256=0aauJk_Bybd0B2iwzJfvPcs7AX43kVHs0dtpV6_jSWk,459
 lanscape/ui/static/css/style.css,sha256=lu9078sZKrMBmT_tM6084_DDnEEMXVMziO6E-gVYkhk,16372
 lanscape/ui/static/img/ico/android-chrome-192x192.png,sha256=JmFT6KBCCuoyxMV-mLNtF9_QJbVBvfWPUizKN700fi8,18255
@@ -36,8 +62,8 @@ lanscape/ui/templates/scan/ip-table-row.html,sha256=ptY24rxJRaA4PEEQRDncaq6Q0ql5
 lanscape/ui/templates/scan/ip-table.html,sha256=ds__UP9JiTKf5IxCmTMzw--eN_yg1Pvn3Nj1KvQxeZg,940
 lanscape/ui/templates/scan/overview.html,sha256=FsX-jSFhGKwCxZGKE8AMKk328UuawN6O9RNTzYvIOts,1205
 lanscape/ui/templates/scan/scan-error.html,sha256=Q4eZM5ThrxnFaWOSTUpK8hA2ksHwhxOBTaVUCLALhyA,1032
-lanscape-1.3.2a7.dist-info/licenses/LICENSE,sha256=cCO-NbS01Ilwc6djHjZ7LIgPFRkRmWdr0fH2ysXKioA,1090
-lanscape-1.3.2a7.dist-info/METADATA,sha256=PFGPM9sDGS1x0l4YtYz-271PASz4ZM56osk7M2rT1bo,2586
-lanscape-1.3.2a7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lanscape-1.3.2a7.dist-info/top_level.txt,sha256=E9D4sjPz_6H7c85Ycy_pOS2xuv1Wm-ilKhxEprln2ps,9
-lanscape-1.3.2a7.dist-info/RECORD,,
+lanscape-1.3.2a9.dist-info/licenses/LICENSE,sha256=cCO-NbS01Ilwc6djHjZ7LIgPFRkRmWdr0fH2ysXKioA,1090
+lanscape-1.3.2a9.dist-info/METADATA,sha256=zff6Z0fOwHfLVn5uEUoYzwZvx-MAaCNVBs5DhAa6stc,2586
+lanscape-1.3.2a9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lanscape-1.3.2a9.dist-info/top_level.txt,sha256=E9D4sjPz_6H7c85Ycy_pOS2xuv1Wm-ilKhxEprln2ps,9
+lanscape-1.3.2a9.dist-info/RECORD,,