Permission denied в Jypyter Notebook

Я работаю на ноутбуке на win11 в visual studio code через jupyter notebook. Мне нужно в цикле создавать файлы вида:

...
filename = "2pm.txt"
...
    for bas in range(1):
        
        bitstr = open(filename, 'w')

 ...
        bitstr.write()
 ...
        bitstr.close()

И когда я запускаю этот код с другого устройства, всё в полрядке, однако с ноута, после нескольких шагов цикла (может быть и около 50 шагов) появляется ошибка

PermissionError                           Traceback (most recent call last)
c:\Users\okate\OneDrive\Рабочий стол\756\random2.ipynb Ячейка 5 in <cell line: 82>()
    111 state = state / np.sqrt(np.sum(np.real(state)**2 + np.imag(state)**2))
    113 for bas in range(2):
--> 115     with open(filename, 'w') as bitstr:    
    116         for iter in range(niter):
    117             kas = []

PermissionError: [Errno 13] Permission denied: '2RE.txt'

В чем может быть проблема?

UPD. Использование метода with open() as ...: в том числе в подфункции hammin не помогло

UPD2. Весь код, который работает на другом устройстве:

import numpy as np
from qiskit import *
from numpy import pi
from random import *
from scipy.spatial import distance
from qiskit import(
  QuantumCircuit,
  execute,
  Aer)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.tools.visualization import circuit_drawer
from qiskit.quantum_info import Statevector, partial_trace, entropy,mutual_information, random_statevector
niter = 1024
ugols = 1000
num_qubits = 8

filename = "2RE.txt"

qr = QuantumRegister(num_qubits)
cr = ClassicalRegister(num_qubits)
simulator = Aer.get_backend('qasm_simulator')
simulatorentr = Aer.get_backend('statevector_simulator')

def join_strs_better(strs):
    return ', '.join(strs)

def dissimilarity():
    f0 = open(filename)
    a0 = f0.read()
    c0=[0]*len(a0)
    d0=[0]*len(a0)
    #mod = 0
    result = list(map(int, a0))
    L0 = len(a0)
    Dsum = 0
    f0.close()

    for h in range(L0):
        if result[h] == 0:
            result[h] = -1

    for k in range(1,10,1):

        step=2**k
        for i in range(0, L0, step):
            for u in range(i,i+step):
                c0[u:u+step] = [sum(result[i:i+step])/step]
        


        step=2**(k+1)
        for i in range(0, L0, step):
            for u in range(i,i+step):
                d0[u:u+step] = [sum(result[i:i+step])/step]

        Ok1k = np.dot(d0,c0)/L0
        Okk = np.dot(c0,c0)/L0
        Ok1k1 = np.dot(d0,d0)/L0
        D = np.abs(Ok1k - 0.5*(Okk + Ok1k1))
        Dsum +=D
    return Dsum

def hammin(num_qubit):
    with open(filename) as f0:
        a = f0.read()
        
        b = list(map(int, a))

        b = np.asarray(b).reshape(-1, num_qubit)
        c = np.zeros((niter,niter))
        for i in range(niter):
            for j in range(niter):
                c[i][j] = distance.hamming(b[i], b[j])

        me_an = np.mean(c)
        s_td = np.std(c)
    return me_an, s_td

f = open('data_2_randRE{}.txt'.format(num_qubits), 'w')
w = open('diss_data_2_randRE{}.txt'.format(num_qubits), 'w')

for u in range(ugols):
    size = choice((1,2,4))
    if size==1:
        niter = 1024
    elif size==2:
        niter = 512
    else:
        niter = 256
    
    qbits = np.arange(0,num_qubits)
    shuffle(qbits)
    subsys = qbits[:size]
    subsys.sort()

    
    massiv = []
    seqr = random()
    statetmp = np.random.sample(2**num_qubits)
    
    state = np.zeros(2**num_qubits).astype(complex)
    
    for i in range(len(statetmp)):
        if statetmp[i] < seqr : 
            state[i] = complex(np.random.choice([-1,1]),0)
        else:
            state[i] = 0
    if sum(np.real(state)) == 0:
        state[randint(0, len(state)-1)] = complex(np.random.choice([-1,1]),0)
    
    state = state / np.sqrt(np.sum(np.real(state)**2 + np.imag(state)**2))
    
    for bas in range(2):
        
        with open(filename, 'w') as bitstr:    
            for iter in range(niter):
                kas = []
                measureZZ = QuantumCircuit(qr,cr)
                

                measureZZ.initialize(state, [qr[7],qr[6],qr[5],qr[4],qr[3],qr[2],qr[1],qr[0]])
                ent = []
                
                            
                job = execute(measureZZ, backend=simulatorentr).result()
                state_vector = job.get_statevector(measureZZ)

                psi = Statevector(state_vector, dims=(2**size,2**(num_qubits-size)))
                ent1 = entropy(partial_trace(psi.copy(),(1,)))
                ent.append(ent1)

                if bas== 0:
                    for i in subsys:
                        measureZZ.measure(i,i)
                elif bas == 1:
                    for i in subsys:
                        measureZZ.h(i)
                        measureZZ.measure(i,i)
                else:
                    for i in subsys:
                        measureZZ.sdg(i)
                        measureZZ.h(i)
                        measureZZ.measure(i,i)

                singletZZ = measureZZ
                circuits = [singletZZ]
                job = execute(circuits, backend=simulator,shots=1)
                result = job.result()
                countsZZ = result.get_counts(singletZZ)
                for bits in countsZZ:
                    for k in subsys:
                        kas.append(bits[(num_qubits-1)-k])
                    das = ''.join(kas)
                    
                    bitstr.write(das) 
                    a = list(map(int, das))
                    massiv.append(a)

        
        Diss = dissimilarity()
        
        
        m = list(zip(*massiv))


        b = [Diss, np.mean(m)]

        sf = []
        for i in range(size):
            sf.append(np.mean(m[i]))

        b.append(np.std(sf))
        me_an, s_td = hammin(size)
        b.append(me_an)
        b.append(s_td)
        b = list(map(str, b))
        
        a = join_strs_better(b)
        f.write(a)
        f.write(', ')
        
        
    ent = join_strs_better(list(map(str, ent)))
    w.write(ent)
        
    f.write('\n')
    w.write('\n')
    
f.close()
w.close()