<jupyter_start><jupyter_text>Steps: * Source detection* scanCreate three example stars from real data. The Source object takes as inputs:> Source('name', $\alpha$, $\delta$, parallax, $\mu_{\alpha}$, $\mu_{\delta}$, $\mu_{r}$)with units: [string, deg, deg, mas, mas/yr, mas/yr, km/s]Once the satellite and its correspondent attitude object is created, we need to create a scanner. At the moment, the scaner is only able to perform the search of one single star in the sky.  _**Scanner:**_The scanner takes in two parameters. The first does a scan of the sky taking the dot product of the x-axis of the scanner (with respect to the LMN-frame) and the star's position (also in LMN). Since the scanning law has an almost perfect coverage of the sky (would be interesting to do a density plot of where it scans more in the future), it selects the times when the star is in this circle field of view. For this example we set it to 20 deg. The second input parameters sets the z-axis value threshold for the scanner ccd dimentions. That is to say, the height of the scanning line that swaps the sky.  _**To scan:**_Firstly, the coarse scan is performed, using the desire satellite and the star that we want to scan.Secondly, we search for the optimized solutions with the fine scan, which uses the data from the coarse scan.Good_link for frame transformations: http://www.astronexus.com/a-a/motions-long-term<jupyter_code># # create all the objects we will need:
# parameters for the notebook
t_init = 0 
t_end =  365 # *5
my_dt = 1/24 # [days]

# objects
gaia = Satellite(ti=t_init, tf=t_end, dt= my_dt)
print('Sat created')
alpha_sirio = 101.28  # right ascension
delta_sirio = -16.7161  # declination
sirio = Source("sirio", alpha_sirio, delta_sirio, 379.21, -546.05, -1223.14, -7.6)
sirio2 = Source("sirio2", alpha_sirio, delta_sirio, 379.21, -546.05, -1223.14, -7.6) #98, -15, 350, -500, -1000, -13.9)
print('Source created')
scanSirio = Scanner() 
print('Scanner created')
sirio.reset()
[sirio.alpha, sirio.delta, sirio.parallax, sirio.mu_alpha_dx, sirio.mu_delta]
sirio.func_color(10)
np.random.seed(seed=1)  # numpy seed set to increase reproducibility
my_observations = np.random.randint(low=t_init, high=t_end, size=10)
my_observations = np.sort(my_observations)
print('my_observations: {}'.format(my_observations))
my_angles = []
for t_j in my_observations:
    my_angle = sirio.topocentric_angles(gaia, t_j)
    my_angles.append(my_angle)
    print('my_angle: {}'.format(my_angle))
# print('my_angles: {}'.format(my_angles))
for t in my_observations:
    print(sirio.unit_topocentric_function(gaia,t))
scanSirio.scan(gaia, sirio, ti=t_init, tf=t_end)<jupyter_output><empty_output><jupyter_text>Agis test<jupyter_code>sirio.set_time(0)
print('alpha:    {}'.format(sirio.alpha))
print('delta:    {}'.format(sirio.delta))
print('parallax: {}'.format(sirio.parallax))
print('mu_alpha: {}'.format(sirio.mu_alpha_dx))
print('mu_delta: {}'.format(sirio.mu_delta))
print('mu_radial:{}'.format(sirio.mu_radial))
# initialize the parameters. Here cheating since initializing knowing the real parameters
s = np.zeros(5)
sirio.reset()  # resets the source parameters at time t=0
#for i, t_L in enumerate(my_observations):
noise = 0.02 / 1000
s[0] =  sirio.alpha + noise
s[1] =  sirio.delta + noise
s[2] =  sirio.parallax - sirio.parallax/ 10
s[3] =  sirio.mu_alpha_dx + sirio.mu_alpha_dx*0.01
s[4] =  sirio.mu_delta + sirio.mu_delta*0.01

s2 = np.zeros(5)
sirio2.reset()  # resets the source parameters at time t=0
#for i, t_L in enumerate(my_observations):
deviated_angle = 10 / 360 * (2*np.pi)  # degrees converted in radians
s2[0] =  sirio2.alpha + noise
s2[1] =  sirio2.delta + noise
s2[2] =  sirio2.parallax - sirio2.parallax/ 10
s2[3] =  sirio2.mu_alpha_dx + sirio2.mu_alpha_dx*0.01
s2[4] =  sirio2.mu_delta + sirio2.mu_delta*0.01

my_sirio = Calc_source('sirio', my_observations, s, sirio.mu_radial) 
my_sirio2 = Calc_source('source_test', my_observations, s2, sirio2.mu_radial)
# Solver = Agis(gaia, [my_sirio], [sirio])
Solver = Agis(gaia, [my_sirio, my_sirio2], [sirio, sirio2], updating='source')
Solver.verbose=False
#Solver.reset_iterations()
Solver.iterate(20, verbosity=2)
titles = ['sirio', 'sirio2']

for source_index in range(len(Solver.calc_sources)):
    calc_source = Solver.calc_sources[source_index]
    real_source = Solver.real_sources[source_index]
    
    source_params = np.array(calc_source.s_old)
    fig, axs = plt.subplots(2, 3, figsize=(16,8), sharex='all')
    
    fig.suptitle(titles[source_index], fontsize=40)
    
    num_iters = len(calc_source.errors)
    labels = ['alpha', 'delta', 'parallax', 'mu_alpha', 'mu_delta']
    sirio.set_time(0)
    observed = [real_source.alpha, real_source.delta, real_source.parallax, real_source.mu_alpha_dx, real_source.mu_delta]

    alpha_list = []
    delta_list = []
    for t_L in my_observations:
        real_source.set_time(float(t_L))
        alpha_list.append(real_source.alpha)
        delta_list.append(real_source.delta)
    std_alpha = np.std(alpha_list)
    std_delta = np.std(delta_list)
    min_alpha, max_alpha = (np.min(alpha_list), np.max(alpha_list))
    min_delta, max_delta = (np.min(delta_list), np.max(delta_list))

    for i, x in enumerate(source_params.T):
        if i<3:
            ax = axs[0, i]
        else:
            ax = axs[1, i-3]
        ax.plot(x, 'b--.', label=labels[i])
        ax.hlines(observed[i], xmin=0, xmax=num_iters, color='g')
        ax.grid()
        ax.set_label('labels[i]')
        ax.set_xlabel('Iterations')
        ax.legend()

    axs[0,0].hlines(observed[0]+std_alpha, xmin=0, xmax=num_iters, color='g')
    axs[0,0].hlines(observed[0]-std_alpha, xmin=0, xmax=num_iters, color='g')
    axs[0,0].hlines(min_alpha, xmin=0, xmax=num_iters, color='r')
    axs[0,0].hlines(max_alpha, xmin=0, xmax=num_iters, color='r')

    axs[0,1].hlines(observed[1]+std_delta, xmin=0, xmax=num_iters, color='g')
    axs[0,1].hlines(observed[1]-std_delta, xmin=0, xmax=num_iters, color='g')
    axs[0,1].hlines(min_delta, xmin=0, xmax=num_iters, color='r')
    axs[0,1].hlines(max_delta, xmin=0, xmax=num_iters, color='r')

    # plot evolution of the error
    ax = axs[-1, -1] 
    ax.plot(calc_source.errors, 'b--.', label='objective function')
    # ax.set_xlim((0, num_iters))
    ax.set_xlabel('Iterations')
    ax.grid(alpha= 0.8)  
    ax.legend()


    fig.savefig('./figures/tmp/errors')

f3 = plt.figure()
plt.title('zoom on the error function')
plt.plot(calc_source.errors, 'b--.', label='objective function')
plt.ylim((0,0.9))
'running'<jupyter_output><empty_output><jupyter_text>**Here below we should have:*** real_source_1 = real_source_2<jupyter_code>print(Solver.calc_sources[0].s_params - Solver.real_sources[0].get_parameters()[0:5])

fig, axs = plt.subplots(1, 2, figsize=(16,8))
titles = ['$\\alpha$', '$\\delta$']
for i, ax in enumerate(axs):
    ax.hlines(Solver.real_sources[0].get_parameters()[i], xmin=0, xmax=1, color='g', linestyles='solid', label='real_source_1')
    ax.hlines(Solver.real_sources[1].get_parameters()[i], xmin=0, xmax=1, color='r', linestyles='dashdot', label='real_source_2')
    ax.hlines(Solver.calc_sources[0].s_params[i], xmin=0, xmax=1, color='k', linestyles='dashed', label='modified')
    ax.hlines(Solver.calc_sources[1].s_params[i], xmin=0, xmax=1, color='c', linestyles='dashdot', label='perfect')
    
    ax.set_title(titles[i])
    ax.grid(), ax.legend()


plt.suptitle('$\\lambda$'), plt.show()<jupyter_output>[ 2.26981767e-10 -3.90672605e-10  2.28687461e-16 -8.43452134e-13
  1.44986196e-12]<jupyter_text>Other parts of the code<jupyter_code># plot_observations(sirio, gaia, scanSirio)
my_t = my_observations[0]
v = spin_axis_from_alpha_delta(sirio, gaia, my_t)
ft.vector_to_adp(v)
#interpolate.InterpolatedUnivariateSpline(t_list, w_list, k=k)
t = my_observations[0]
gaia.s_x.get_knots()[np.where(gaia.s_x.get_knots()>t)][0:4]
gaia.s_x.get_coeffs()[np.where(gaia.s_x.get_knots()>t)][0] = 1
gaia.s_x.get_coeffs()[np.where(gaia.s_x.get_knots()>t)][0]<jupyter_output><empty_output><jupyter_text>Plots:<jupyter_code>x = np.arange(10)
y = x
t = x
plt.scatter(x, y, c=t, marker='.')
plt.grid()
plt.show()
length = 1
point= (0.5, 0.5)
vector=np.array([1, 1, 1])
vec_2D = np.array([-0.5, 0.5])
fig = plt.figure(figsize=(12, 12))
ax = fig.add_subplot(111)
ax.plot(point[0], point[1], 'b+')
ax.set_xlim((0,1.5))
ax.set_ylim((0,1.5))
ax.grid()
to_plot_x = [point[0], point[0]+vec_2D[0]]
to_plot_y = [point[1], point[1]+vec_2D[1]]
ax.plot(to_plot_x, to_plot_y, 'k-')
ax.quiver(point[0], point[1], vec_2D[0], vec_2D[1])
"""
dir_alpha, dir_delta, radius = ft.vector_to_polar(vector)
directions = helpers.rescaled_direction((dir_alpha, dir_delta), length)
to_plot_x = [point[0], dir_alpha]
to_plot_y = [point[1], dir_delta]

ax.plot(to_plot_x, to_plot_y, 'k-', alpha=0.1)
ax.quiver(point[0], point[1], directions[0], directions[1], color=['r'])
"""
# Plot my observatiosn with my angles
plot_stars_trajectory(sirio, gaia, my_observations, equatorial=True)
plot_stars_trajectory_3D(sirio, gaia, my_observations)
p_phi, p_eta = plot_phi_solutions(sirio, gaia, scanSirio.obs_times, ti=t_init, tf=t_end, n=1000)
p_phi.show()
p_eta.show()
p_zeta, p_eta = plot_field_angles(sirio, gaia, my_observations, ti=t_init, tf=t_end, n=10000, limit = False)
p_eta.show()
p_zeta.show()

plot_star(sirio, gaia, scanSirio)
plot_observations(sirio, gaia, scanSirio)
plots = []

for x in np.linspace(0,len(scanSirio.obs_times),10, dtype=int):
    p = plot_prediction_VS_reality(sirio, gaia, scanSirio, x, angle_tolerance=0.2)
    plots.append(p)
    p.savefig('figures/tmp/counting_'+str(x)+'observations',format='png',transparent=False,facecolor='w')<jupyter_output><empty_output><jupyter_text>data exploration and tests<jupyter_code>lsls # to make the full execution stop
sirio.alpha
# sirio.delta


plt.figure()
plt.subplot(111, projection="hammer")
plt.plot( sirio.alpha, sirio.delta,'r+', label='sirio')
plt.title("Hammer Projection of the Sky")
plt.legend()
plt.grid(True)
from scipy.interpolate import interp1d
x = np.linspace(0, 10, num=11, endpoint=True)
y = np.cos(-x**2/9.0)
f = interp1d(x, y, kind='linear')
f2 = interp1d(x, y, kind='cubic')
from scipy.interpolate import LSQUnivariateSpline, UnivariateSpline
import matplotlib.pyplot as plt
x = np.linspace(-3, 3, 50)
y = np.exp(-x**2) + 0.1 * np.random.randn(50)
t = [-1, -0.5, 0, 0.5, 1]
spl = LSQUnivariateSpline(x, y, t)
xs = np.linspace(-3, 3, 1000)
plt.plot(x, y, 'ro', ms=5)
plt.plot(xs, spl(xs), 'g-', lw=3)
plt.grid()
plt.show()
print('knots: {}'.format(spl.get_knots()))
def deBoor(k, x, t, c, p):
    """
    Evaluates S(x).

    Args
    ----
    k: index of knot interval that contains x
    x: position
    t: array of knot positions, needs to be padded as described above
    c: array of control points
    p: degree of B-spline
    """
    d = [c[j + k - p] for j in range(0, p+1)]
    for r in range(1, p+1):
        for j in range(p, r-1, -1):
            alpha = (x - t[j+k-p]) / (t[j+1+k-r] - t[j+k-p])
            d[j] = (1.0 - alpha) * d[j-1] + alpha * d[j]
    return d[p]
def B(x, k, i, t):
    if k == 0:
        return 1.0 if t[i] <= x < t[i+1] else 0.0
    if t[i+k] == t[i]:
        c1 = 0.0
    else:
        c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
    if t[i+k+1] == t[i+1]:
        c2 = 0.0
    else:
        c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
    return c1 + c2

def bspline(x, t, c, k):
    n = len(t) - k - 1
    assert (n >= k+1) and (len(c) >= n)
    return sum(c[i] * B(x, k, i, t) for i in range(n))
from scipy.interpolate import BSpline
k = 2
t = [0, 1, 2, 3, 4, 5, 6]
c = [-1, 2, 0, -1]
spl = BSpline(t, c, k)
spl(2.5)

bspline(2.5, t, c, k)

import matplotlib.pyplot as plt
fig, ax = plt.subplots()
xx = np.linspace(1.5, 4.5, 50)
ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
ax.grid(True)
ax.legend(loc='best')
plt.show()
a = np.sort(np.random.rand(3))
a
from scipy.interpolate import InterpolatedUnivariateSpline

k = 4
length = 10
xv = [0, 1, 2, 3, 4, 4.5, 5]
x = np.sort(list(set(xv)))
y = [3, 6, 5, 7, 9, 9, 1]
spline = InterpolatedUnivariateSpline(x, y, k=4)
spline_list = [spline]
from scipy.interpolate import splrep
from scipy.interpolate import splev
from scipy.interpolate import InterpolatedUnivariateSpline
from scipy.interpolate import BSpline

x = [0, 1, 2, 3, 4, 4.5, 5]
y = [3, 6, 5, 7, 9, 9, 1]

k = 4
my_spline = InterpolatedUnivariateSpline(x, y, k)
my_spline
from scipy.interpolate import BSpline
def extend_knots(internal_knots, k):
    extended_knots = []
    for i in range(k):
        extended_knots.append(internal_knots[0])
    extended_knots += list(internal_knots)
    for i in range(k):
        extended_knots.append(internal_knots[-1])
    return extended_knots

def spline_from_coeffs(coeffs, knots, k):
    """
    :param k: B-spline order"""
    # extended_knots = extend_knots(knots, k=order)
    print('LLLLLLLLLLLLLLLLLLLLLLLL', len(knots))
    return BSpline(knots, coeffs, k) 
a = [[0,1], [0,1]]
np.array(a).shape
my_spline.get_coeffs().shape
my_spline.get_knots().shape
knots
basis_bsplines.t
print(coeffs.shape,'\n',knots.shape,'\n', np.array(internal_knots).shape)
import numpy as np
import matplotlib.pyplot as plt
import scipy.interpolate as si

points = [[0, 0], [0, 2], [2, 3], [4, 0], [6, 3], [8, 2], [8, 0]];
points = np.array(points)
x = points[:,0]
y = points[:,1]
y
t = range(len(points))
list(t)
ipl_t = np.linspace(0.0, len(points) - 1, 100)

x_tup = si.splrep(t, x, k=3)
y_tup = si.splrep(t, y, k=3)
y_tup
x_list = list(x_tup)
xl = x.tolist()
x_list[1] = xl + [0.0, 0.0, 0.0, 0.0]

y_list = list(y_tup)
yl = y.tolist()
y_list[1] = yl + [0.0, 0.0, 0.0, 0.0]

x_i = si.splev(ipl_t, x_list)
y_i = si.splev(ipl_t, y_list)

#==============================================================================
# Plot
#==============================================================================

fig = plt.figure(figsize=(12,6))

ax = fig.add_subplot(231)
plt.plot(t, x, '-og')
plt.plot(ipl_t, x_i, 'r')
plt.xlim([0.0, max(t)])
plt.title('Splined x(t)')

ax = fig.add_subplot(232)
plt.plot(t, y, '-og')
plt.plot(ipl_t, y_i, 'r')
plt.xlim([0.0, max(t)])
plt.title('Splined y(t)')

ax = fig.add_subplot(233)
plt.plot(x, y, '-og')
plt.plot(x_i, y_i, 'r')
plt.xlim([min(x) - 0.3, max(x) + 0.3])
plt.ylim([min(y) - 0.3, max(y) + 0.3])
plt.title('Splined f(x(t), y(t))')

ax = fig.add_subplot(234)
for i in range(7):
    vec = np.zeros(11)
    vec[i] = 1.0
    x_list = list(x_tup)
    x_list[1] = vec.tolist()
    x_i = si.splev(ipl_t, x_list)
    plt.plot(ipl_t, x_i)
plt.xlim([0.0, max(t)])
plt.title('Basis splines')
plt.show()
my_Bspline = BSpline(internal_knots, coeffs, k=k)
basis_bsplines = my_Bspline.basis_element(knots, extrapolate=False)
basis_bsplines.k                                 
b = BSpline.basis_element([0, 1, 2, 3, 4, 5])
b.k

import numpy as np
from scipy.interpolate import splrep
from scipy.interpolate import splev
from scipy.interpolate import InterpolatedUnivariateSpline
from scipy.interpolate import BSpline

t  = [ 1, 2, 3, 4]
xv = [0, 1, 2, 3, 4, 4.5, 5]
xv = np.sort(list(set(xv)))
yv = [3, 6, 5, 7, 9, 9, 1]

k = 4
tck = splrep(xv, yv, s=0, k=k)
t,c,k = tck
my_spline = InterpolatedUnivariateSpline(xv, yv, k=k)
coeffs = my_spline.get_coeffs()
knots = my_spline.get_knots()
print(knots, t)
print('extended knots', extend_knots(knots, k))
internal_knots = []
for i in range(k):
    internal_knots.append(knots[0])
internal_knots += list(knots)
for i in range(k):
    internal_knots.append(knots[-1])

print('len xv and coeffs', len(xv), len(coeffs))
print('splrep knots: {}'.format(tck[0]))
print('internal_knots: {}'.format(internal_knots))
print('old_coeffs: {}'.format(tck[1]))
print('coeffs: {}'.format(coeffs))
print('knots: {}'.format(knots))
xx = np.linspace(min(xv), max(xv), 500)
bsplines = []
f1 = plt.figure()
for j in range(len(xv)):
    new_coeffs = np.arange(len(xv)+2*k-2) == j
    # print('new_coeffs: {}'.format(new_coeffs))
    tck_mod = (list(tck[0]), new_coeffs, k)
    print('tck mod:', tck_mod)
    current_bspline = splev(xx, tck_mod)
    my_x = 1.90
    bsplines.append(current_bspline)
    plt.plot(xx, current_bspline, label=str(j))
    plt.plot(my_x, splev(my_x, tck_mod), 'k+', label=str(j))
plt.grid()
plt.legend()
plt.xticks(np.arange(0, len(xv)))
f1.show()

# my_Bspline = BSpline(internal_knots, coeffs, k=k)
my_Bspline = BSpline(t, c, k=k)
basis_bsplines = my_Bspline.basis_element(knots, extrapolate=False)

bsplines2 = []
f3 = plt.figure()
for j, coeff in enumerate(coeffs):
    bool_array = np.arange(len(coeffs)) == j
    tck_mod = (internal_knots, bool_array, k)
    print('tck mod:', tck_mod)
    current_bspline2 = splev(xx, tck_mod)
    #print(current_bspline2[:,0])
    bsplines2.append(current_bspline2)
    plt.plot(xx, current_bspline2, label=str(j))
plt.plot(xx, basis_bsplines(xx) ,'+k', label='test')
plt.grid()
plt.title('Version 2')
plt.legend()
plt.xticks(np.arange(0, len(coeffs)))
f3.show()

f4 = plt.figure()
tck_mod = ([internal_knots[2]], [True], k)
plt.plot(xx, splev(xx, tck_mod), 'k', label = 'test')
plt.title('Vesrion 3')
plt.grid()
f4.show()

# internal_knots = [knots.]
f2 = plt.figure()
print('internal_knots: ', internal_knots)


print('basis_bsplines: ', len(basis_bsplines.t))
print('coeff 0: ', coeffs[0])
#print(bsplines[0], ' || ', coeffs[0])
my_basis = splev(xx, my_Bspline)
print('splev: ',len(my_basis))
interp_spline = sum([coeff*bspline for coeff, bspline in zip(c, bsplines)])

plt.plot(xv, yv, 'ro', label='points')
plt.plot(xx, interp_spline, 'b:', label='interp spline' )
plt.plot(xx, my_Bspline(xx, extrapolate=False), 'k-', label='with Bspline')
plt.plot(xx, my_spline(xx), 'm:', label='IUS')
plt.legend()

plt.grid()
f2.show()
print(my_spline(2.5))
my_spline.get_knots()<jupyter_output><empty_output><jupyter_text>gaia archive:<jupyter_code># This is an example how to make a plot in the Aitoff projection using data
# in a SkyCoord object. Here a randomly generated data set will be used. The
# final script can be found below.

# First we need to import the required packages. We use
# `matplotlib <http://www.matplotlib.org/>`_ here for
# plotting and `numpy <http://www.numpy.org/>`_  to get the value of pi and to
# generate our random data.
from astropy import units as u
from astropy.coordinates import SkyCoord
import matplotlib.pyplot as plt
import numpy as np

# We now generate random data for visualisation. For RA this is done in the range
# of 0 and 360 degrees (``ra_random``), for DEC between -90 and +90 degrees
# (``dec_random``). Finally, we multiply these values by degrees to get an
# `~astropy.units.Quantity` with units of degrees.
ra_random = np.random.rand(100)*360.0 * u.degree
dec_random = (np.random.rand(100)*180.0-90.0) * u.degree

# As next step, those coordinates are transformed into an astropy.coordinates
# astropy.coordinates.SkyCoord object.
c = SkyCoord(ra=ra_random, dec=dec_random, frame='icrs')

# Because matplotlib needs the coordinates in radians and between :math:`-\pi`
# and :math:`\pi`, not 0 and :math:`2\pi`, we have to convert them.
# For this purpose the `astropy.coordinates.Angle` object provides a special method,
# which we use here to wrap at 180:
ra_rad = c.ra.wrap_at(180 * u.deg).radian
dec_rad = c.dec.radian

# As last step we set up the plotting environment with matplotlib using the
# Aitoff projection with a specific title, a grid, filled circles as markers with
# a markersize of 2 and an alpha value of 0.3.
plt.figure(figsize=(8,4.2))
plt.subplot(111, projection="aitoff")
plt.title("Aitoff projection of our random data", y=1.08)
plt.grid(True)
plt.plot(ra_rad, dec_rad, 'o', markersize=2, alpha=0.3)
plt.plot(0, 1, 'r+', markersize=10, alpha=1)
plt.subplots_adjust(top=0.95,bottom=0.0)
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.17410288582183187, 'fraction_numerical': 0.034981179422835636, 'mean_word_length': 4.636775106082037, 'pattern_counts': {'":': 0, '<': 33, '<?xml version=': 0, '>': 36, 'https://': 0, 'lorem ipsum': 0, 'www.': 3, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '81600', 'license': 'MIT', 'n_tokens_mistral': 8833, 'n_tokens_neox': 8376, 'n_words': 1878, 'path': 'notebooks/Drafts/3-luca-tests.ipynb', 'repo_name': 'bombrun/GaiaLab', 'size': '19925'}