validate can read from stdin

import argparse

# filename = sys.argv[1]

# def load_json (path):    

#     with open(path) as f:

#         s = json.load(f)

#     return s

# schema_store = {}

# json_instance = load_json(filename)

# print (json_instance)

# etsi_schema = load_json('response.schema.json')

# ext_schema = load_json('extended.schema.json')

# ext_ent_schema = load_json("extended_entities.schema.json")

# schema_store = {

#     etsi_schema['$id'] : etsi_schema,

#     ext_schema['$id'] : ext_schema,

#     ext_ent_schema['$id'] : ext_ent_schema

# }

# resolver = RefResolver(None, referrer=None, store=schema_store)

# print (etsi_schema)

# v = Draft202012Validator(ext_schema, resolver=resolver)

# v.validate(json_instance)

# validate(json_instance, ext_schema)

# print ("OK")

def handle_uri(u):

    print(u)

    parser.add_argument('-s','--schemadir', action="append", help="Directory containing supporting schema files to use for validation")

    parser.add_argument('-v', '--verbose', action="count", help="Verbose logging (can be specified multiple times)")

    parser.add_argument('-i', '--input', type=argparse.FileType('r'), default=sys.stdin, help="Path to input file (if absent, stdin is used)")

    parser.add_argument('schema', help="Primary schema to validate against")    

    parser.add_argument('filename', help="JSON instance document to validate")

    args = parser.parse_args()

    logging.debug(f"Arguments: {args}")

    instance_doc = load_json(args.filename)

    instance_doc = json.loads(args.input.read())

    args.input.close()

    main_schema = load_json(args.schema)    

    schema_dict = { main_schema['$id'] : main_schema }

    logging.debug(f"Arguments: {args}")

    # if (args.input):

    #     logging.info(f"Reading from {args.input}")

    #     with open(args.input) as f:

    #         s = f.read()

    # else:

    #     logging.info(f"Reading from stdin")

    #     s = sys.stdin.read()

    s = args.input.read()

    args.input.close()