Python pyxform.create_survey_element_from_dict函数代码示例

    def runTest(self):
        for filename in ["select_one_external.xlsx"]:
            path_to_excel_file = os.path.join(DIR, "example_xls", filename)
            #Get the xform output path:
            root_filename, ext = os.path.splitext(filename)
            output_path = os.path.join(
                DIR, "test_output", root_filename + ".xml")
            expected_output_path = os.path.join(
                DIR, "test_expected_output", root_filename + ".xml")
            output_csv = os.path.join(
                DIR, "test_output", root_filename + ".csv")
            #Do the conversion:
            json_survey = pyxform.xls2json.parse_file_to_json(
                path_to_excel_file)

            self.assertTrue(sheet_to_csv(path_to_excel_file, output_csv, "external_choices"))
            self.assertFalse(sheet_to_csv(path_to_excel_file, output_csv, "non-existant sheet"))

            survey = pyxform.create_survey_element_from_dict(json_survey)

            survey.print_xform_to_file(output_path)

            #Compare with the expected output:
            with codecs.open(expected_output_path, 'rb', encoding="utf-8") as\
                    expected_file:
                with codecs.open(output_path, 'rb', encoding="utf-8") as \
                        actual_file:
                    self.assertMultiLineEqual(
                        expected_file.read(), actual_file.read())

    def runTest(self):
        for filename in [
            "new_cascading_select.xls",
            "old_cascades.xls",
            "cascading_select_test.xls",
        ]:
            self.get_file_path(filename)
            expected_output_path = os.path.join(
                DIR, "test_expected_output", self.root_filename + ".xml"
            )

            # Do the conversion:
            json_survey = pyxform.xls2json.parse_file_to_json(self.path_to_excel_file)

            survey = pyxform.create_survey_element_from_dict(json_survey)

            survey.print_xform_to_file(self.output_path)

            # Compare with the expected output:
            with codecs.open(
                expected_output_path, "rb", encoding="utf-8"
            ) as expected_file:
                with codecs.open(
                    self.output_path, "rb", encoding="utf-8"
                ) as actual_file:
                    self.assertXFormEqual(expected_file.read(), actual_file.read())

    def runTest(self):
        filename = "search_and_select.xlsx"
        path_to_excel_file = os.path.join(DIR, "example_xls", filename)
        # Get the xform output path:
        root_filename, ext = os.path.splitext(filename)
        output_path = os.path.join(DIR, "test_output", root_filename + ".xml")
        expected_output_path = os.path.join(DIR, "test_expected_output",
                                            root_filename + ".xml")
        # Do the conversion:
        warnings = []
        json_survey = pyxform.xls2json.parse_file_to_json(
            path_to_excel_file, warnings=warnings)
        survey = pyxform.create_survey_element_from_dict(json_survey)
        survey.print_xform_to_file(output_path, warnings=warnings)

        # Compare with the expected output:
        with codecs.open(expected_output_path, 'rb', encoding="utf-8") \
                as expected_file:
            with codecs.open(output_path, 'rb', encoding="utf-8") \
                    as actual_file:
                self.assertMultiLineEqual(
                    expected_file.read(), actual_file.read())

        # cleanup
        os.remove(output_path)

def json_workbook(request):
    error = None
    warningsList = []

    if not (os.access(SERVER_TMP_DIR, os.F_OK)):
        os.mkdir(SERVER_TMP_DIR)

    # Make a randomly generated directory to prevent name collisions
    temp_dir = tempfile.mkdtemp(dir=SERVER_TMP_DIR)
    form_name = request.POST.get("name", "form")
    output_filename = form_name + ".xml"
    out_path = os.path.join(temp_dir, output_filename)
    if os.access(out_path, os.F_OK):
        os.remove(out_path)
    try:
        json_survey = xls2json.workbook_to_json(
            json.loads(request.POST["workbookJson"]), form_name=form_name, warnings=warningsList
        )
        survey = pyxform.create_survey_element_from_dict(json_survey)
        survey.print_xform_to_file(out_path, warnings=warningsList)
    except Exception as e:
        error = str(e)
    return HttpResponse(
        json.dumps(
            {"dir": os.path.split(temp_dir)[-1], "name": output_filename, "error": error, "warnings": warningsList},
            indent=4,
        ),
        mimetype="application/json",
    )

    def runTest(self):
        for filename in ["select_one_external.xlsx"]:
            self.get_file_path(filename)
            expected_output_path = os.path.join(
                DIR, "test_expected_output", self.root_filename + ".xml"
            )

            output_csv = os.path.join(DIR, "test_output", self.root_filename + ".csv")
            # Do the conversion:
            json_survey = pyxform.xls2json.parse_file_to_json(self.path_to_excel_file)

            self.assertTrue(
                sheet_to_csv(self.path_to_excel_file, output_csv, "external_choices")
            )
            self.assertFalse(
                sheet_to_csv(self.path_to_excel_file, output_csv, "non-existant sheet")
            )

            survey = pyxform.create_survey_element_from_dict(json_survey)

            survey.print_xform_to_file(self.output_path)

            # Compare with the expected output:
            with codecs.open(
                expected_output_path, "rb", encoding="utf-8"
            ) as expected_file:
                with codecs.open(
                    self.output_path, "rb", encoding="utf-8"
                ) as actual_file:
                    self.assertXFormEqual(expected_file.read(), actual_file.read())

    def runTest(self):
        for filename in ["new_cascading_select.xls", "old_cascades.xls",
                         "cascading_select_test.xls"]:
            path_to_excel_file = os.path.join(DIR, "example_xls", filename)
            # Get the xform output path:
            root_filename, ext = os.path.splitext(filename)
            output_path = os.path.join(
                DIR, "test_output", root_filename + ".xml")
            expected_output_path = os.path.join(
                DIR, "test_expected_output", root_filename + ".xml")
            # Do the conversion:
            json_survey = pyxform.xls2json.parse_file_to_json(
                path_to_excel_file)

            survey = pyxform.create_survey_element_from_dict(json_survey)

            survey.print_xform_to_file(output_path)

            # Compare with the expected output:
            with codecs.open(expected_output_path, 'rb', encoding="utf-8") as\
                    expected_file:
                with codecs.open(output_path, 'rb', encoding="utf-8") as \
                        actual_file:
                    self.assertXFormEqual(expected_file.read(),
                                          actual_file.read())

    def runTest(self):
        files_to_test = ["instance_xmlns_test.xls"]
        for file_to_test in files_to_test:
            path_to_excel_file = utils.path_to_text_fixture(file_to_test)
            
            # Get the xform output path:
            directory, filename = os.path.split(path_to_excel_file)
            root_filename, ext = os.path.splitext(filename)
            path_to_output_xform = os.path.join(
                directory, root_filename + "_output.xml")
            path_to_expected_xform = os.path.join(
                directory, root_filename + ".xml")

            # Do the conversion:
            json_survey = xls2json.parse_file_to_json(path_to_excel_file)
            survey = pyxform.create_survey_element_from_dict(json_survey)
            survey.print_xform_to_file(path_to_output_xform)
            
            # Compare with the expected output:
            with codecs.open(path_to_expected_xform, 'rb', encoding="utf-8"
                             ) as expected_file:
                expected = ETree.fromstring(expected_file.read())
                result = ETree.fromstring(survey.to_xml())

                def write_line(x): sys.stdout.write(x + "\n")
                reporter = write_line
                self.assertTrue(xml_compare(
                    expected, result, reporter=reporter))
            os.remove(path_to_output_xform)

 def runTest(self):
     filename = "ODKValidateWarnings.xlsx"
     path_to_excel_file = os.path.join(DIR, "bug_example_xls", filename)
     # Get the xform output path:
     root_filename, ext = os.path.splitext(filename)
     output_path = os.path.join(DIR, "test_output", root_filename + ".xml")
     # Do the conversion:
     warnings = []
     json_survey = pyxform.xls2json.parse_file_to_json(path_to_excel_file, warnings=warnings)
     survey = pyxform.create_survey_element_from_dict(json_survey)
     survey.print_xform_to_file(output_path, warnings=warnings)

def index(request):
    if request.method == 'POST': # If the form has been submitted...
        form = UploadFileForm(request.POST, request.FILES) # A form bound to the POST data
        if form.is_valid(): # All validation rules pass
            
            error = None
            warnings = None
            
            filename, ext = os.path.splitext(request.FILES['file'].name)
            
            #Make a randomly generated directory to prevent name collisions
            temp_dir = tempfile.mkdtemp(dir=SERVER_TMP_DIR)
            xml_path = os.path.join(temp_dir, filename + '.xml')
            
            #Init the output xml file.
            fo = open(xml_path, "wb+")
            fo.close()
            
            try:
                #TODO: use the file object directly
                xls_path = handle_uploaded_file(request.FILES['file'], temp_dir)
                warnings = []
                json_survey = xls2json.parse_file_to_json(xls_path, warnings=warnings)
                survey = pyxform.create_survey_element_from_dict(json_survey)
                survey.print_xform_to_file(xml_path, warnings=warnings)
                
            except Exception as e:
                error = 'Error: ' + str(e)
            
            return render_to_response('upload.html', {
                'form': UploadFileForm(),
                'xml_path' : '.' + xml_path,
                'xml_url' : request.build_absolute_uri('.' + xml_path),
                'success': not error,
                'error': error,
                'warnings': warnings,
                'result': True,
            })
    else:
        form = UploadFileForm() # An unbound form
        
    return render_to_response('upload.html', {
        'form': form,
    })

    def runTest(self):
        filename = "widgets.xls"
        self.get_file_path(filename)
        expected_output_path = os.path.join(
            DIR, "test_expected_output", self.root_filename + ".xml"
        )

        # Do the conversion:
        warnings = []
        json_survey = pyxform.xls2json.parse_file_to_json(
            self.path_to_excel_file, warnings=warnings
        )
        survey = pyxform.create_survey_element_from_dict(json_survey)
        survey.print_xform_to_file(self.output_path, warnings=warnings)
        # print warnings
        # Compare with the expected output:
        with codecs.open(expected_output_path, "rb", encoding="utf-8") as expected_file:
            with codecs.open(self.output_path, "rb", encoding="utf-8") as actual_file:
                self.assertXFormEqual(expected_file.read(), actual_file.read())

    def runTest(self):
       
        path_to_excel_file = utils.path_to_text_fixture("xlsform_spec_test.xls")
        
        #Get the xform output path:
        directory, filename = os.path.split(path_to_excel_file)
        root_filename, ext = os.path.splitext(filename)
        path_to_xform = os.path.join(directory, root_filename + ".xml")

        #Do the conversion:
        json_survey = xls2json.parse_file_to_json(path_to_excel_file)
        survey = pyxform.create_survey_element_from_dict(json_survey)
        survey.print_xform_to_file(path_to_xform)
        
        #Compare with the expected output:
        expected_path = utils.path_to_text_fixture("spec_test_expected_output.xml")
        with codecs.open(expected_path, 'rb', encoding="utf-8") as expected_file:
            expected = etree.fromstring(expected_file.read())
            result = etree.fromstring(survey.to_xml())
            self.assertTrue(xml_compare(expected, result))

 def runTest(self):
     filename = "default_time_demo.xls"
     path_to_excel_file = os.path.join(DIR, "bug_example_xls", filename)
     # Get the xform output path:
     root_filename, ext = os.path.splitext(filename)
     output_path = os.path.join(DIR, "test_output", root_filename + ".xml")
     expected_output_path = os.path.join(
         DIR, "test_expected_output", root_filename + ".xml"
     )
     # Do the conversion:
     warnings = []
     json_survey = pyxform.xls2json.parse_file_to_json(
         path_to_excel_file, warnings=warnings
     )
     survey = pyxform.create_survey_element_from_dict(json_survey)
     survey.print_xform_to_file(output_path, warnings=warnings)
     # print warnings
     # Compare with the expected output:
     with codecs.open(expected_output_path, "rb", encoding="utf-8") as expected_file:
         with codecs.open(output_path, "rb", encoding="utf-8") as actual_file:
             self.assertXFormEqual(expected_file.read(), actual_file.read())

def json_workbook(request):
    error = None
    warningsList = []
    #Make a randomly generated directory to prevent name collisions
    temp_dir = tempfile.mkdtemp(dir=SERVER_TMP_DIR)
    form_name = request.POST.get('name', 'form')
    output_filename = form_name + '.xml'
    out_path = os.path.join(temp_dir, output_filename)
    fo = open(out_path, "wb+")
    fo.close()
    try:
        json_survey = xls2json.workbook_to_json(json.loads(request.POST['workbookJson']), form_name=form_name, warnings=warningsList)
        survey = pyxform.create_survey_element_from_dict(json_survey)
        survey.print_xform_to_file(out_path, warnings=warningsList)
    except Exception as e:
        error = str(e)
    return HttpResponse(json.dumps({
        'dir': os.path.split(temp_dir)[-1],
        'name' : output_filename,
        'error': error,
        'warnings': warningsList,
    }, indent=4), mimetype="application/json")

def index(request):
    if request.method == "POST":  # If the form has been submitted...
        form = UploadFileForm(request.POST, request.FILES)  # A form bound to the POST data
        if form.is_valid():  # All validation rules pass

            error = None
            warnings = None

            filename, ext = os.path.splitext(request.FILES["file"].name)

            if not (os.access(SERVER_TMP_DIR, os.F_OK)):
                os.mkdir(SERVER_TMP_DIR)

            # Make a randomly generated directory to prevent name collisions
            temp_dir = tempfile.mkdtemp(dir=SERVER_TMP_DIR)
            xml_path = os.path.join(temp_dir, filename + ".xml")
            itemsets_url = None

            relpath = os.path.relpath(xml_path, SERVER_TMP_DIR)

            # Init the output xml file.
            fo = open(xml_path, "wb+")
            fo.close()

            try:
                # TODO: use the file object directly
                xls_path = handle_uploaded_file(request.FILES["file"], temp_dir)
                warnings = []
                json_survey = xls2json.parse_file_to_json(xls_path, warnings=warnings)
                survey = pyxform.create_survey_element_from_dict(json_survey)
                survey.print_xform_to_file(xml_path, warnings=warnings)

                if has_external_choices(json_survey):
                    # Create a csv for the external choices
                    itemsets_csv = os.path.join(os.path.split(xls_path)[0], "itemsets.csv")
                    relpath_itemsets_csv = os.path.relpath(itemsets_csv, SERVER_TMP_DIR)
                    choices_exported = sheet_to_csv(xls_path, itemsets_csv, "external_choices")
                    if not choices_exported:
                        warnings += ["Could not export itemsets.csv, " "perhaps the external choices sheet is missing."]
                    else:
                        itemsets_url = request.build_absolute_uri("./downloads/" + relpath_itemsets_csv)
            except Exception as e:
                error = "Error: " + str(e)

            return render_to_response(
                "upload.html",
                {
                    "form": UploadFileForm(),
                    "xml_path": request.build_absolute_uri("./downloads/" + relpath),
                    "xml_url": request.build_absolute_uri("./downloads/" + relpath),
                    "itemsets_url": itemsets_url,
                    "success": not error,
                    "error": error,
                    "warnings": warnings,
                    "result": True,
                },
            )
    else:
        form = UploadFileForm()  # An unbound form

    return render_to_response("upload.html", {"form": form})