def get_temp_location():
    if sys.platform == 'win32':
        return os.path.join(tempfile._get_default_tempdir(),'JModelica.org')
    elif sys.platform == 'darwin':
        return os.path.join(tempfile._get_default_tempdir(),'JModelica.org')
    else:
        return os.path.join(tempfile._get_default_tempdir(),os.environ['USER'],'JModelica.org')

    def test(self):
        temp_name = next(tempfile._get_candidate_names())
        defult_tmp_dir = tempfile._get_default_tempdir()

        filename = os.path.join(defult_tmp_dir, temp_name)

        # Wfuzz results
        with wfuzz.FuzzSession(url=url, **params) as s:
            s.export_to_file(filename)

            if payloads is None:
                fuzzed = s.fuzz()
            else:
                fuzzed = s.get_payloads(payloads).fuzz()

            ret_list = [(x.code, x.history.urlparse.path) for x in fuzzed]

        # repeat test with recipe as only parameter
        with wfuzz.FuzzSession(recipe=[filename]) as s:
            if payloads is None:
                same_list = [(x.code, x.history.urlparse.path) for x in s.fuzz()]
            else:
                same_list = [(x.code, x.history.urlparse.path) for x in s.get_payloads(payloads).fuzz()]

        self.assertEqual(sorted(ret_list), sorted(same_list))

def _TempDirSetup(self, prefix='tmp', update_env=True, base_dir=None):
  """Generate a tempdir, modifying the object, and env to use it.

  Specifically, if update_env is True, then from this invocation forward,
  python and all subprocesses will use this location for their tempdir.

  The matching _TempDirTearDown restores the env to what it was.
  """
  # Stash the old tempdir that was used so we can
  # switch it back on the way out.
  self.tempdir = tempfile.mkdtemp(prefix=prefix, dir=base_dir)
  os.chmod(self.tempdir, 0o700)

  if update_env:
    with tempfile._once_lock:
      self._tempdir_value = tempfile._get_default_tempdir()
      self._tempdir_env = tuple((x, os.environ.get(x))
                                for x in _TEMPDIR_ENV_VARS)
      # Now update TMPDIR/TEMP/TMP, and poke the python
      # internal to ensure all subprocess/raw tempfile
      # access goes into this location.
      os.environ.update((x, self.tempdir) for x in _TEMPDIR_ENV_VARS)
      # Finally, adjust python's cached value (we know it's cached by here
      # since we invoked _get_default_tempdir from above).  Note this
      # is necessary since we want *all* output from that point
      # forward to go to this location.
      tempfile.tempdir = self.tempdir

def get_temp_aln(aln):
    tfname = os.path.join(tempfile._get_default_tempdir(),
                          next(tempfile._get_candidate_names()))
    aln.write(tfname,alignment_format='PIR')
    seqs = get_seqs_from_pir(tfname)
    os.unlink(tfname)
    return seqs

 def tmpName() -> str:
     '''
     Return the path to a temporary file.
     '''
     
     tempdir = tempfile._get_default_tempdir()
     name = next(tempfile._get_candidate_names())
     return '{}/{}'.format(tempdir, name)

    def process(self, fuzzresult):
        temp_name = next(tempfile._get_candidate_names())
        defult_tmp_dir = tempfile._get_default_tempdir()

        filename = os.path.join(defult_tmp_dir, temp_name + ".png")

        subprocess.call(['cutycapt', '--url=%s' % pipes.quote(fuzzresult.url), '--out=%s' % filename])
        self.add_result("Screnshot taken, output at %s" % filename)

def _get_temp_file_name():
    """Generate a temporary file name with an absolute path.
    
    :rtype: str
    """
    return (tempfile._get_default_tempdir()
        + os.sep
        + next(tempfile._get_candidate_names()))

def mktemppath():
    try:
        path = os.path.join(tempfile._get_default_tempdir(), next(tempfile._get_candidate_names()))
        yield path
    finally:
        try:
            os.unlink(path)
        except OSError as e:
            current_app.logger.debug("No file {0}".format(path))

def render_mm(self, code, options, format, prefix='mermaid'):
    """Render mermaid code into a PNG or PDF output file."""

    if format == 'raw':
        format = 'png'

    mermaid_cmd = self.builder.config.mermaid_cmd
    hashkey = (code + str(options) + str(self.builder.config.mermaid_sequence_config)).encode('utf-8')

    basename = '%s-%s' % (prefix, sha1(hashkey).hexdigest())
    fname = '%s.%s' % (basename, format)
    relfn = posixpath.join(self.builder.imgpath, fname)
    outdir = os.path.join(self.builder.outdir, self.builder.imagedir)
    outfn = os.path.join(outdir, fname)
    tmpfn = os.path.join(_get_default_tempdir(), basename)

    if os.path.isfile(outfn):
        return relfn, outfn

    ensuredir(os.path.dirname(outfn))

    # mermaid expects UTF-8 by default
    if isinstance(code, text_type):
        code = code.encode('utf-8')

    with open(tmpfn, 'wb') as t:
        t.write(code)

    mm_args = [mermaid_cmd, '-i', tmpfn, '-o', outfn]
    mm_args.extend(self.builder.config.mermaid_params)
    if self.builder.config.mermaid_sequence_config:
       mm_args.extend('--configFile', self.builder.config.mermaid_sequence_config)

    if format != 'png':
        self.builder.warn('Mermaid SVG support is experimental')
    try:
        p = Popen(mm_args, stdout=PIPE, stdin=PIPE, stderr=PIPE)
    except OSError as err:
        if err.errno != ENOENT:   # No such file or directory
            raise
        self.builder.warn('command %r cannot be run (needed for mermaid '
                          'output), check the mermaid_cmd setting' % mermaid_cmd)
        return None, None

    stdout, stderr = p.communicate(code)
    if self.builder.config.mermaid_verbose:
        self.builder.info(stdout)

    if p.returncode != 0:
        raise MermaidError('Mermaid exited with error:\n[stderr]\n%s\n'
                            '[stdout]\n%s' % (stderr, stdout))
    if not os.path.isfile(outfn):
        raise MermaidError('Mermaid did not produce an output file:\n[stderr]\n%s\n'
                            '[stdout]\n%s' % (stderr, stdout))
    return relfn, outfn

    def generate( self, out_path, aux, idx_in, idx_out ) :
        if self.scheme.version != 1 :
            raise RuntimeError( 'This model requires a "VERSION: STEJSKALTANNER" scheme.' )

        scheme_high = amico.lut.create_high_resolution_scheme( self.scheme, b_scale=1E6 )
        filename_scheme = pjoin( out_path, 'scheme.txt' )
        np.savetxt( filename_scheme, scheme_high.raw, fmt='%15.8e', delimiter=' ', header='VERSION: STEJSKALTANNER', comments='' )

        # temporary file where to store "datasynth" output
        filename_signal = pjoin( tempfile._get_default_tempdir(), next(tempfile._get_candidate_names())+'.Bfloat' )

        nATOMS = len(self.Rs) + len(self.ICVFs) + len(self.d_ISOs)
        progress = ProgressBar( n=nATOMS, prefix="   ", erase=True )

        # Cylinder(s)
        for R in self.Rs :
            CMD = 'datasynth -synthmodel compartment 1 CYLINDERGPD %E 0 0 %E -schemefile %s -voxels 1 -outputfile %s 2> /dev/null' % ( self.d_par*1E-6, R, filename_scheme, filename_signal )
            subprocess.call( CMD, shell=True )
            if not exists( filename_signal ) :
                raise RuntimeError( 'Problems generating the signal with "datasynth"' )
            signal  = np.fromfile( filename_signal, dtype='>f4' )
            if exists( filename_signal ) :
                remove( filename_signal )

            lm = amico.lut.rotate_kernel( signal, aux, idx_in, idx_out, False )
            np.save( pjoin( out_path, 'A_%03d.npy'%progress.i ), lm )
            progress.update()

        # Zeppelin(s)
        for d in [ self.d_par*(1.0-ICVF) for ICVF in self.ICVFs] :
            CMD = 'datasynth -synthmodel compartment 1 ZEPPELIN %E 0 0 %E -schemefile %s -voxels 1 -outputfile %s 2> /dev/null' % ( self.d_par*1E-6, d*1e-6, filename_scheme, filename_signal )
            subprocess.call( CMD, shell=True )
            if not exists( filename_signal ) :
                raise RuntimeError( 'Problems generating the signal with "datasynth"' )
            signal  = np.fromfile( filename_signal, dtype='>f4' )
            if exists( filename_signal ) :
                remove( filename_signal )

            lm = amico.lut.rotate_kernel( signal, aux, idx_in, idx_out, False )
            np.save( pjoin( out_path, 'A_%03d.npy'%progress.i ), lm )
            progress.update()

        # Ball(s)
        for d in self.d_ISOs :
            CMD = 'datasynth -synthmodel compartment 1 BALL %E -schemefile %s -voxels 1 -outputfile %s 2> /dev/null' % ( d*1e-6, filename_scheme, filename_signal )
            subprocess.call( CMD, shell=True )
            if not exists( filename_signal ) :
                raise RuntimeError( 'Problems generating the signal with "datasynth"' )
            signal  = np.fromfile( filename_signal, dtype='>f4' )
            if exists( filename_signal ) :
                remove( filename_signal )

            lm = amico.lut.rotate_kernel( signal, aux, idx_in, idx_out, True )
            np.save( pjoin( out_path, 'A_%03d.npy'%progress.i ), lm )
            progress.update()

def main():
    question = sys.argv[1]
    code = sys.argv[2]
    print("Variables:")
    print(question)
    print(code)
    temp_name = next(tempfile._get_candidate_names())
    default_tmp_dir = tempfile._get_default_tempdir()
    filename = default_tmp_dir + "/" + sys.argv[3]
    if question == "pregunta11":
        pregunta11(code, filename)

    def test_no_files_left_behind(self):
        # use a private empty directory
        with tempfile.TemporaryDirectory() as our_temp_directory:
            # force _get_default_tempdir() to consider our empty directory
            def our_candidate_list():
                return [our_temp_directory]

            with support.swap_attr(tempfile, "_candidate_tempdir_list", our_candidate_list):
                # verify our directory is empty after _get_default_tempdir()
                tempfile._get_default_tempdir()
                self.assertEqual(os.listdir(our_temp_directory), [])

                def raise_OSError(*args, **kwargs):
                    raise OSError()

                with support.swap_attr(io, "open", raise_OSError):
                    # test again with failing io.open()
                    with self.assertRaises(FileNotFoundError):
                        tempfile._get_default_tempdir()
                    self.assertEqual(os.listdir(our_temp_directory), [])

                open = io.open

                def bad_writer(*args, **kwargs):
                    fp = open(*args, **kwargs)
                    fp.write = raise_OSError
                    return fp

                with support.swap_attr(io, "open", bad_writer):
                    # test again with failing write()
                    with self.assertRaises(FileNotFoundError):
                        tempfile._get_default_tempdir()
                    self.assertEqual(os.listdir(our_temp_directory), [])

def main():
    question = sys.argv[1]
    code = sys.argv[2]
    temp_name = next(tempfile._get_candidate_names())
    default_tmp_dir = tempfile._get_default_tempdir()
    filename = default_tmp_dir + "/" + sys.argv[3]

    if question == "pregunta11":
        pregunta11(code, filename)
    elif question == "pregunta21":
        pregunta21(code, filename)
    elif question == "pregunta22":
        pregunta22(code, filename)

 def uploadFile(self):
     self.form.labelStatus.setText("")
     if (self.form.comboProjects.currentIndex() >= 0) and (len(self.Projects) > self.form.comboProjects.currentIndex()) and (self.form.comboRoot.currentIndex() >= 0):
         project = self.Projects[self.form.comboProjects.currentIndex()]
         import requests
         url,token = self.getPrefs()
         if url and token:
             url += "/json"
             deserializer = None
             FreeCAD.Console.PrintMessage("Saving file...\n")
             self.form.labelStatus.setText("Checking available deserializers...")
             import ifcopenshell
             schema = ifcopenshell.schema_identifier.lower()
             data = { "token": token, "request": { "interface": "PluginInterface",  "method": "getAllDeserializers", "parameters": { "onlyEnabled": "true" } } }
             resp = requests.post(url,json = data)
             if resp.ok:
                 try:
                     for d in resp.json()["response"]["result"]:
                         if schema in d["name"].lower():
                             deserializer = d
                             break
                 except:
                     pass
             if not deserializer:
                 FreeCAD.Console.PrintError("Unable to get a valid deserializer for the "+schema+" schema\n")
                 return
             tf = QtGui.QFileDialog.getSaveFileName(QtGui.qApp.activeWindow(), "Save the IFC file before uploading?", None, "IFC files (*.ifc)")
             if tf:
                 tf = tf[0]
             if not tf:
                 tf = os.path.join(tempfile._get_default_tempdir(),next(tempfile._get_candidate_names())+".ifc")
             import importIFC
             self.form.labelStatus.setText("Saving file...")
             importIFC.export([self.RootObjects[self.form.comboRoot.currentIndex()]],tf)
             f = open(tf,"rb")
             ifcdata = base64.b64encode(f.read())
             f.close()
             FreeCAD.Console.PrintMessage("Uploading file to Bimserver...\n")
             self.form.labelStatus.setText("Uploading file...")
             data = { "token": token, "request": { "interface": "ServiceInterface", "method": "checkin", "parameters": { "poid": project["oid"], "comment": self.form.editComment.text(), "deserializerOid": deserializer["oid"], "fileSize": os.path.getsize(tf), "fileName": os.path.basename(tf), "data": ifcdata, "merge": "false", "sync": "true" } } }
             resp = requests.post(url,json = data)
             if resp.ok:
                 if resp.json()["response"]["result"]:
                     FreeCAD.Console.PrintMessage("File upload successful\n")
                     self.getRevisions(self.form.comboProjects.currentIndex())
                 else:
                     FreeCAD.Console.PrintError("File upload failed\n")
     self.form.labelStatus.setText("")

    def test_hook_event_substitution(self):
        temporary_directory = tempfile._get_default_tempdir()
        event_names = ["test_event_event_{0}".format(i) for i in range(self.TEST_HOOK_COUNT)]

        for event in event_names:
            self._add_hook(event, 'touch "{0}/{{event}}"'.format(temporary_directory))

        self.load_plugins("hook")

        for event in event_names:
            plugins.send(event)

        for event in event_names:
            path = os.path.join(temporary_directory, event)

            self.assertTrue(os.path.isfile(path))
            os.remove(path)

    def process(self):
        tmp_filename = next(tempfile._get_candidate_names())
        tmp_dir = tempfile._get_default_tempdir()
        result_file = os.path.join(tmp_dir, tmp_filename)
        if not os.path.exists(result_file ):
            password = self.field.text()
            try:
                cmd = ['/usr/local/bin/aescrypt', '-e' if self.encrypt else '-d', '-p', password, '-o', result_file, self.filename]
                p = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
                self.close()
                if self.encrypt:
                    dest_file = os.path.join(os.path.dirname(self.filename), self.filename + ".aes")
                    if os.path.exists(dest_file):
                        msgBox = QMessageBox()
                        msgBox.setText("File " + dest_file + " already exists")
                        msgBox.setInformativeText("Overwrite?")
                        msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
                        ret = msgBox.exec_();
                        if ret == QMessageBox.No:
                            return
                    shutil.move(result_file, dest_file)
                    msgBox = QMessageBox()
                    msgBox.setText("Encryption successful")
                    msgBox.setStandardButtons(QMessageBox.Ok)
                    ret = msgBox.exec_();
                else:
                    cmd = ['xdg-open', result_file]
                    p = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
            except subprocess.CalledProcessError as e:
                self.error_label = QLabel("<font color='#FF0000'>" + e.output.decode("utf-8") + "</font>")
                self.grid.addWidget(self.error_label, 2, 2)
                #print(e.cmd)
                #print(e.returncode)
                #print(e.output)

                # Shake the window
                i = 6
                dir = 1
                while i > 0:
                    self.move(self.x()+dir*10, self.y())
                    self.repaint()
                    dir = -dir
                    i = i - 1
                    time.sleep(0.04)

def text2aln(env, seqs):
    """Write text sequences to temporary FASTA and read them back with MODELLER"""
    tfname = os.path.join(tempfile._get_default_tempdir(), next(tempfile._get_candidate_names()))
    # tfname = 'tempfile.pir'
    outf = open(tfname, "w")
    for ns, seq in enumerate(seqs):
        sfix = seq.replace("\n", "")
        print "seq num", ns, "len", len(seq)
        # outf.write('>%i\n'%ns)
        # outf.write(sfix+'\n')
        outf.write(">P1;%s\nsequence::     : :     : :::-1.00:-1.00\n" % ns)
        num_groups = len(seq) / 80 + 1
        for ngroup in range(num_groups):
            if ngroup < num_groups - 1:
                outf.write(seq[ngroup * 80 : (ngroup + 1) * 80] + "\n")
            else:
                outf.write(seq[ngroup * 80 : (ngroup + 1) * 80] + "*\n\n")
    outf.close()
    aln = alignment(env, file=tfname, alignment_format="PIR")
    os.unlink(tfname)
    return aln

    def test_no_files_left_behind(self):
        # use a private empty directory
        our_temp_directory = tempfile.mkdtemp()
        try:
            # force _get_default_tempdir() to consider our empty directory
            def our_candidate_list():
                return [our_temp_directory]

            with support.swap_attr(tempfile, "_candidate_tempdir_list",
                                   our_candidate_list):
                # verify our directory is empty after _get_default_tempdir()
                tempfile._get_default_tempdir()
                self.assertEqual(os.listdir(our_temp_directory), [])

                def raise_OSError(*args, **kwargs):
                    raise OSError(-1)

                with support.swap_attr(io, "open", raise_OSError):
                    # test again with failing io.open()
                    with self.assertRaises(IOError) as cm:
                        tempfile._get_default_tempdir()
                    self.assertEqual(cm.exception.errno, errno.ENOENT)
                    self.assertEqual(os.listdir(our_temp_directory), [])

                open = io.open
                def bad_writer(*args, **kwargs):
                    fp = open(*args, **kwargs)
                    fp.write = raise_OSError
                    return fp

                with support.swap_attr(io, "open", bad_writer):
                    # test again with failing write()
                    with self.assertRaises(IOError) as cm:
                        tempfile._get_default_tempdir()
                    self.assertEqual(cm.exception.errno, errno.ENOENT)
                    self.assertEqual(os.listdir(our_temp_directory), [])
        finally:
            shutil.rmtree(our_temp_directory)

 def tearDown(self):
     r = tempfile._get_default_tempdir()
     l = [os.path.join(r, i) for i in os.listdir(r) if i.startswith("tmp") and i.endswith("TempDirCont")]
     self.assertLessEqual(len(l), 3)

def _getTempDirName(prefix=""):
    return os.path.join(tempfile._get_default_tempdir(),
                        prefix + next(tempfile._get_candidate_names()))