Datasets:
semeru
/
code-code-MethodGeneration

Dataset card Data Studio Files
xet
Community
signature
stringlengths
8
3.44k
body
stringlengths
0
1.41M
docstring
stringlengths
1
122k
id
stringlengths
5
17
def _deriv_arctan(x):
return <NUM_LIT:1.0> / (<NUM_LIT:1.0> + x*x)<EOL>
The derivative of arctan(x)
f9525:m4
def _deriv_hypot(x, y):
r = np.hypot(x, y)<EOL>df_dx = x / r<EOL>df_dy = y / r<EOL>return np.hstack([df_dx, df_dy])<EOL>
Derivative of numpy hypot function
f9525:m5
def _deriv_arctan2(y, x):
r2 = x*x + y*y<EOL>df_dy = x / r2<EOL>df_dx = -y / r2<EOL>return np.hstack([df_dy, df_dx])<EOL>
Derivative of the arctan2 function
f9525:m6
def _deriv_tanh(x):
cx = np.cosh(x)<EOL>return <NUM_LIT:1.0> / (cx * cx)<EOL>
Derivative of tanh(x)
f9525:m9
def _deriv_arcsinh(x):
return <NUM_LIT:1.0> / np.sqrt(x*x + <NUM_LIT:1>)<EOL>
The derivative of arcsinh(x)
f9525:m10
def _deriv_arccosh(x):
return <NUM_LIT:1.0> / np.sqrt(x*x - <NUM_LIT:1>)<EOL>
The derivative of arccosh(x)
f9525:m11
def _deriv_arctanh(x):
return <NUM_LIT:1.0> / (<NUM_LIT:1.0> - x*x)<EOL>
The derivative of arctanh(x)
f9525:m12
def _deriv_exp2(x):
return _log2 * np.exp2(x)<EOL>
The derivative of exp2(x)
f9525:m13
def _recip(x):
return <NUM_LIT:1.0> / x<EOL>
Return the reciprocal of x; to be used as the derivative of log(x)
f9525:m14
def _deriv_log10(x):
return <NUM_LIT:1.0> / (_log10 * x)<EOL>
The derivative of log10(x)
f9525:m15
def _deriv_log2(x):
return <NUM_LIT:1.0> / (_log2 * x)<EOL>
The derivative of log2(x)
f9525:m16
def _deriv_log1p(x):
return <NUM_LIT:1.0> / (<NUM_LIT:1.0> + x)<EOL>
The derivative of log1p(x)
f9525:m17
def _deriv_logaddexp(x1, x2):
y1 = np.exp(x1)<EOL>y2 = np.exp(x2)<EOL>df_dx1 = y1 / (y1 + y2)<EOL>df_dx2 = y2 / (y1 + y2)<EOL>return np.vstack([df_dx1, df_dx2]).T<EOL>
The derivative of f(x, y) = log(e^x + e^y)
f9525:m18
def _deriv_logaddexp2(x1, x2):
y1 = np.exp2(x1)<EOL>y2 = np.exp2(x2)<EOL>df_dx1 = y1 / (y1 + y2)<EOL>df_dx2 = y2 / (y1 + y2)<EOL>return np.vstack([df_dx1, df_dx2]).T<EOL>
The derivative of f(x, y) = log2(2^x + 2^y)
f9525:m19
def _deriv_sqrt(x):
return <NUM_LIT:0.5> / np.sqrt(x)<EOL>
The derivative of sqrt(x)
f9525:m20
def _deriv_cbrt(x):
return (<NUM_LIT:1.0> / <NUM_LIT>) / np.cbrt(x*x)<EOL>
The derivative of cbrt(x)
f9525:m21
def _deriv_square(x):
return <NUM_LIT> * x<EOL>
The derivative of square(x)
f9525:m22
def _logistic(x):
return <NUM_LIT:1.0> / (<NUM_LIT:1.0> + np.exp(-x))<EOL>
The standard logistic function
f9525:m23
def _deriv_logistic(x):
y = _logistic(x)<EOL>return y * (<NUM_LIT:1.0> - y)<EOL>
Derivative of the standard logistic function
f9525:m24
def _forward_mode(self, *args):
<EOL>X: np.ndarray<EOL>dX: np.ndarray<EOL>X, dX = self.f._forward_mode(*args)<EOL>val = self.func(X)<EOL>diff = self.deriv(X) * dX<EOL>return (val, diff)<EOL>
Forward mode differentiation for a constant
f9525:c1:m1
def _forward_mode(self, *args):
<EOL>X: np.ndarray<EOL>dX: np.ndarray<EOL>X, dX = self.f._forward_mode(*args)<EOL>Y: np.ndarray<EOL>dY: np.ndarray<EOL>Y, dY = self.g._forward_mode(*args)<EOL>val = self.func(X,Y)<EOL>diff = self.deriv(X,Y)<EOL>return (val, diff)<EOL>
Forward mode differentiation for a constant
f9525:c2:m1
def __init__(self, func: Callable, deriv: Callable, func_name: str):
<EOL>self.func = func<EOL>self.deriv = deriv<EOL>self.func_name = func_name<EOL>
func is the value of the function, deriv is the derivative
f9525:c3:m0
def load_constants():
<EOL>G: float = <NUM_LIT><EOL>body_name =['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']<EOL>mass_earth: float = <NUM_LIT><EOL>mass: Dict[str, float] ={'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>' : mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>': mass_earth * <NUM_LIT>, <EOL>'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>'<STR_LIT>': mass_earth * <NUM_LIT>,<EOL>}<EOL>radius: Dict[str, float] ={'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': <NUM_LIT> <EOL>}<EOL>return G, body_name, mass, radius<EOL>
Load physical constants to simulate the earth-sun system
f9526:m0
def julian_day(t: date) -> int:
<EOL>dt = t - julian_base_date<EOL>return julian_base_number + dt.days<EOL>
Convert a Python datetime to a Julian day
f9526:m1
def calc_mse(q1, q2):
<EOL>dq = q2 - q1<EOL>return np.sqrt(np.mean(dq*dq))/au2m<EOL>
Compare the results of two simulations
f9526:m2
def simulate_leapfrog(config_func: Callable, accel_func: Callable, <EOL>t0: date, t1: date, steps_per_day: int):
<EOL>N: int = (t1 - t0).days * steps_per_day<EOL>q0, v0 = config_func(t0)<EOL>dims: int = q0.shape[<NUM_LIT:1>]<EOL>dt = float(day2sec) / float(steps_per_day)<EOL>dt2: float = dt * dt<EOL>q: np.ndarray = np.zeros((N, dims))<EOL>v: np.ndarray = np.zeros((N, dims))<EOL>q[<NUM_LIT:0>, :] = q0<EOL>v[<NUM_LIT:0>, :] = v0<EOL>a: np.ndarray = np.zeros((N, dims))<EOL>a[<NUM_LIT:0>, :] = accel_func(q[<NUM_LIT:0>])<EOL>print(f'<STR_LIT>')<EOL>for i in tqdm(range(N-<NUM_LIT:1>)):<EOL><INDENT>q[i+<NUM_LIT:1>,:] = q[i,:] + v[i,:] * dt + <NUM_LIT:0.5> * a[i,:] * dt2<EOL>a[i+<NUM_LIT:1>,:] = accel_func(q[i+<NUM_LIT:1>]) <EOL>v[i+<NUM_LIT:1>,:] = v[i,:] + <NUM_LIT:0.5> * (a[i,:] + a[i+<NUM_LIT:1>,:]) * dt<EOL><DEDENT>return q, v<EOL>
Simulate the earth-sun system from t0 to t1 using Leapfrog Integration. INPUTS: config_func: function taking a date or date range and returning position and velocity of bodies accel_func: function taking positions of the bodies and returning their accelerations t0: start date of the simulation; a python date t1: end date of the simulation (exclusive); a python date dt: time step in days. num_bodies: the number of celestial bodies in the simulation
f9526:m3
def flux_r2(q_vars: List[fl.Var], i: int, j: int):
<EOL>k0 = <NUM_LIT:3>*i<EOL>k1 = <NUM_LIT:3>*j<EOL>return fl.square(q_vars[k1+<NUM_LIT:0>] - q_vars[k0+<NUM_LIT:0>]) +fl.square(q_vars[k1+<NUM_LIT:1>] - q_vars[k0+<NUM_LIT:1>]) +fl.square(q_vars[k1+<NUM_LIT:2>] - q_vars[k0+<NUM_LIT:2>])<EOL>
Make Fluxion with the distance between body i and j
f9526:m4
def flux_r(q_vars: List[fl.Var], i: int, j: int):
return fl.sqrt(flux_r2(q_vars, i, j))<EOL>
Make Fluxion with the distance between body i and j
f9526:m5
def flux_v2(v_vars: List[fl.Var], i: int):
<EOL>k = <NUM_LIT:3>*i<EOL>return fl.square(v_vars[k+<NUM_LIT:0>]) + fl.square(v_vars[k+<NUM_LIT:1>]) + fl.square(v_vars[k+<NUM_LIT:2>])<EOL>
Make Fluxion with the speed squared of body i
f9526:m6
def U_ij(q_vars: List[fl.Var], mass: np.ndarray, i: int, j: int):
<EOL>assert len(q_vars) == <NUM_LIT:3> * len(mass)<EOL>mi = mass[i]<EOL>mj = mass[j]<EOL>U = -(G * mi * mj) / flux_r(q_vars, i, j)<EOL>return U<EOL>
Make Fluxion with the gratiational potential energy beween body i and j
f9526:m7
def T_i(v_vars: List[fl.Var], mass: np.ndarray, i: int):
<EOL>assert len(v_vars) == <NUM_LIT:3> * len(mass)<EOL>m = mass[i]<EOL>T = (<NUM_LIT:0.5> * m) * flux_v2(v_vars, i)<EOL>return T<EOL>
Make Fluxion with the kinetic energy of body i
f9526:m8
def plot_energy(time, H, T, U):
<EOL>T0 = T[<NUM_LIT:0>]<EOL>H = H / T0<EOL>T = T / T0<EOL>U = U / T0<EOL>fig, ax = plt.subplots(figsize=[<NUM_LIT:16>,<NUM_LIT:8>])<EOL>ax.set_title('<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.plot(time, T, label='<STR_LIT:T>', color='<STR_LIT:r>')<EOL>ax.plot(time, U, label='<STR_LIT>', color='<STR_LIT:b>')<EOL>ax.plot(time, H, label='<STR_LIT:H>', color='<STR_LIT:k>')<EOL>ax.legend()<EOL>ax.grid()<EOL>plt.show()<EOL>
Plot kinetic and potential energy of system over time
f9526:m9
def configuration_ES(t0: date, t1: Optional[date] = None, <EOL>steps_per_day: int = None) -> Tuple[np.ndarray, np.ndarray]:
<EOL>if steps_per_day is None:<EOL><INDENT>steps_per_day = <NUM_LIT:1><EOL><DEDENT>dt: float = <NUM_LIT:1.0> / float(steps_per_day)<EOL>if t1 is not None:<EOL><INDENT>jd0: int = julian_day(t0)<EOL>jd1: int = julian_day(t1)<EOL><DEDENT>else:<EOL><INDENT>jd0: int = julian_day(t0)<EOL>jd1: int = jd0 + dt<EOL><DEDENT>jd: np.ndarray = np.arange(jd0, jd1, dt)<EOL>sun_id: int = jpl_body_id['<STR_LIT>']<EOL>pos_sun, vel_sun = jpl_kernel[<NUM_LIT:0>, sun_id].compute_and_differentiate(jd)<EOL>earth_id: int = jpl_body_id['<STR_LIT>']<EOL>pos_earth, vel_earth = jpl_kernel[<NUM_LIT:0>, earth_id].compute_and_differentiate(jd)<EOL>q = np.vstack([pos_sun, pos_earth]).T * km2m<EOL>v = np.vstack([vel_sun, vel_earth]).T * (km2m / day2sec)<EOL>return q, v<EOL>
Get the positions and velocities of the earth and sun from date t0 to t1. Returned as a tuple q, v q: Nx3 array of positions (x, y, z) in the J2000.0 coordinate frame.
f9527:m0
def plot_ES(q: np.ndarray, sim_name: str, fname: Optional[str] = None):
<EOL>sun_x = q[:,<NUM_LIT:0>] / au2m<EOL>sun_y = q[:,<NUM_LIT:1>] / au2m<EOL>earth_x = q[:,<NUM_LIT:3>] / au2m<EOL>earth_y = q[:,<NUM_LIT:4>] / au2m<EOL>fig, ax = plt.subplots(figsize=[<NUM_LIT:12>,<NUM_LIT:12>])<EOL>ax.set_title(f'<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>a = <NUM_LIT><EOL>ticks = np.arange(-a, a+<NUM_LIT>, <NUM_LIT>)<EOL>ax.set_xlim(-a, a)<EOL>ax.set_ylim(-a, a)<EOL>ax.set_xticks(ticks)<EOL>ax.set_yticks(ticks)<EOL>radius_earth = radius_tbl['<STR_LIT>']<EOL>markersize_earth = <NUM_LIT><EOL>markersize_sun = cbrt(radius_tbl['<STR_LIT>'] / radius_earth) * markersize_earth<EOL>ax.plot(sun_x, sun_y, label='<STR_LIT>', color='<STR_LIT>', linewidth=<NUM_LIT:0>, markersize = markersize_sun, marker='<STR_LIT:o>')<EOL>ax.plot(earth_x, earth_y, label='<STR_LIT>', color='<STR_LIT:b>', linewidth=<NUM_LIT:0>, markersize = markersize_earth, marker='<STR_LIT:o>')<EOL>ax.legend()<EOL>ax.grid()<EOL>if fname is not None:<EOL><INDENT>fig.savefig(fname, bbox_inches='<STR_LIT>')<EOL><DEDENT>plt.show()<EOL>
Plot the earth-sun orbits. q is a Tx6 array. T indexes time points. 6 columns are sun (x, y, z) and earth (x, y, z)
f9527:m1
def accel_ES(q: np.ndarray):
<EOL>num_bodies: int = <NUM_LIT:2><EOL>dims = <NUM_LIT:3> * num_bodies<EOL>m0 = mass[<NUM_LIT:0>]<EOL>m1 = mass[<NUM_LIT:1>]<EOL>pos_0 = q[slices[<NUM_LIT:0>]]<EOL>pos_1 = q[slices[<NUM_LIT:1>]]<EOL>dv_01: np.ndarray = pos_1 - pos_0<EOL>r_01: float = np.linalg.norm(dv_01)<EOL>udv_01 = dv_01 / r_01<EOL>f_01: float = (G * m0 * m1) / (r_01 ** <NUM_LIT:2>)<EOL>a: np.ndarray = np.zeros(dims)<EOL>a[slices[<NUM_LIT:0>]] += f_01 * udv_01 / m0<EOL>a[slices[<NUM_LIT:1>]] -= f_01 * udv_01 / m1<EOL>return a<EOL>
Compute the gravitational accelerations in the earth-sun system. q in row vector of 6 elements: sun (x, y, z), earth (x, y, z)
f9527:m2
def energy_ES(q, v):
<EOL>m0 = mass[<NUM_LIT:0>]<EOL>m1 = mass[<NUM_LIT:1>]<EOL>q0: np.ndarray = q[:, slices[<NUM_LIT:0>]]<EOL>q1: np.ndarray = q[:, slices[<NUM_LIT:1>]]<EOL>v0: np.ndarray = v[:, slices[<NUM_LIT:0>]]<EOL>v1: np.ndarray = v[:, slices[<NUM_LIT:1>]]<EOL>T0: np.ndarray = <NUM_LIT:0.5> * m0 * np.sum(v0 * v0, axis=<NUM_LIT:1>)<EOL>T1: np.ndarray = <NUM_LIT:0.5> * m1 * np.sum(v1 * v1, axis=<NUM_LIT:1>)<EOL>T: np.ndarray = T0 + T1<EOL>dv_01 = q1 - q0<EOL>r_01 = np.linalg.norm(dv_01, axis=<NUM_LIT:1>)<EOL>U_01: np.ndarray = -G * m0 * m1 / r_01<EOL>U: np.ndarray = U_01<EOL>H = T + U<EOL>return H, T, U<EOL>
Compute the kinetic and potential energy of the earth sun system
f9527:m3
def make_force_ES(q_vars, mass):
<EOL>U = U_ij(q_vars, mass, <NUM_LIT:0>, <NUM_LIT:1>)<EOL>vn_q = np.array([q.var_name for q in q_vars])<EOL>vn_fl = np.array(sorted(U.var_names))<EOL>q2fl = np.array([np.argmax((vn_q == v)) for v in vn_fl])<EOL>fl2q = np.array([np.argmax((vn_fl == v)) for v in vn_q])<EOL>force_func = lambda q: -U.diff(q[q2fl]).squeeze()[fl2q]<EOL>return force_func<EOL>
Fluxion with the potential energy of the earth-sun sytem
f9527:m4
def accel_ES_fl(q: np.ndarray):
<EOL>num_bodies: int = <NUM_LIT:2><EOL>dims = <NUM_LIT:3> * num_bodies<EOL>f = force_ES(q)<EOL>a = np.zeros(dims)<EOL>a[slices[<NUM_LIT:0>]] = f[slices[<NUM_LIT:0>]] / mass[<NUM_LIT:0>]<EOL>a[slices[<NUM_LIT:1>]] = f[slices[<NUM_LIT:1>]] / mass[<NUM_LIT:1>]<EOL>return a<EOL>
Accelaration in the earth-sun system using Fluxion potential energy
f9527:m5
def configuration(t0: date, t1: Optional[date] = None, <EOL>steps_per_day: int = None) -> Tuple[np.ndarray, np.ndarray]:
<EOL>if steps_per_day is None:<EOL><INDENT>steps_per_day = <NUM_LIT:1><EOL><DEDENT>dt: float = <NUM_LIT:1.0> / float(steps_per_day)<EOL>if t1 is not None:<EOL><INDENT>jd0: int = julian_day(t0)<EOL>jd1: int = julian_day(t1)<EOL><DEDENT>else:<EOL><INDENT>jd0: int = julian_day(t0)<EOL>jd1: int = jd0 + dt<EOL><DEDENT>jd: np.ndarray = np.arange(jd0, jd1, dt)<EOL>N: int = len(jd)<EOL>B: int = len(bodies)<EOL>dims: int = B * <NUM_LIT:3><EOL>q: np.ndarray = np.zeros((N, dims))<EOL>v: np.ndarray = np.zeros((N, dims))<EOL>body_ids: List[int] = [jpl_body_id[body] for body in bodies]<EOL>for i, body_id in enumerate(body_ids):<EOL><INDENT>slice_i = slice(<NUM_LIT:3>*i, <NUM_LIT:3>*(i+<NUM_LIT:1>))<EOL>qi, vi = jpl_kernel[<NUM_LIT:0>, body_id].compute_and_differentiate(jd)<EOL>q[:, slice_i] = qi.T * km2m<EOL>v[:, slice_i] = vi.T * (km2m / day2sec)<EOL><DEDENT>return q, v<EOL>
Get the positions and velocities of the sun and eight planets Returned as a tuple q, v q: Nx3 array of positions (x, y, z) in the J2000.0 coordinate frame.
f9529:m0
def plot(q: np.ndarray, bodies: List[str], plot_colors: Dict[str, str],<EOL>sim_name: str, fname: Optional[str] = None):
<EOL>N, dims = q.shape<EOL>x_slice = slice(<NUM_LIT:0>, dims, <NUM_LIT:3>)<EOL>y_slice = slice(<NUM_LIT:1>, dims, <NUM_LIT:3>)<EOL>plot_x = q[:, x_slice] / au2m<EOL>plot_y = q[:, y_slice] / au2m<EOL>fig, ax = plt.subplots(figsize=[<NUM_LIT:12>,<NUM_LIT:12>])<EOL>ax.set_title(f'<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>a = <NUM_LIT><EOL>da = <NUM_LIT:1.0><EOL>ticks = np.arange(-a, a+da, da)<EOL>ax.set_xlim(-a, a)<EOL>ax.set_ylim(-a, a)<EOL>ax.set_xticks(ticks)<EOL>ax.set_yticks(ticks)<EOL>radius_earth = radius_tbl['<STR_LIT>']<EOL>markersize_earth = <NUM_LIT><EOL>markersize_tbl = {body : cbrt(radius_tbl[body] / radius_earth) * markersize_earth for body in bodies}<EOL>for k, body in enumerate(bodies):<EOL><INDENT>ax.plot(plot_x[:, k], plot_y[:, k], label=body, color=plot_colors[body], <EOL>linewidth=<NUM_LIT:0>, markersize = markersize_tbl[body], marker='<STR_LIT:o>')<EOL><DEDENT>fig.legend(loc=<NUM_LIT:7>, bbox_to_anchor=(<NUM_LIT>, <NUM_LIT:0.5>))<EOL>ax.grid()<EOL>if fname is not None:<EOL><INDENT>fig.savefig(fname, bbox_inches='<STR_LIT>')<EOL><DEDENT>plt.show()<EOL>
Plot the planetary orbits. Plot size limited to box of 10 AU around the sun. q is a Nx3B array. t indexes time points. 3B columns are (x, y, z) for the bodies in order.
f9529:m1
def make_frame(fig, ax, plot_x: np.ndarray, plot_y: np.ndarray, frame_num: int, <EOL>bodies: List[str], plot_colors: Dict[str, str], markersize_tbl: Dict[str, float],<EOL>fname: str):
<EOL>ax.clear()<EOL>ax.set_title(f'<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>a = <NUM_LIT><EOL>da = <NUM_LIT:1.0><EOL>ticks = np.arange(-a, a+da, da)<EOL>ax.set_xlim(-a, a)<EOL>ax.set_ylim(-a, a)<EOL>ax.set_xticks(ticks)<EOL>ax.set_yticks(ticks)<EOL>for k, body in enumerate(bodies[<NUM_LIT:0>:<NUM_LIT:5>]):<EOL><INDENT>ax.plot(plot_x[k], plot_y[k], label=body, color=plot_colors[body], <EOL>linewidth=<NUM_LIT:0>, markersize = markersize_tbl[body], marker='<STR_LIT:o>') <EOL><DEDENT>ax.grid()<EOL>fig.savefig(f'<STR_LIT>')<EOL>
Make a series of frames of the planetary orbits that can be assembled into a movie. q is a Nx3B array. t indexes time points. 3B columns are (x, y, z) for the bodies in order.
f9529:m2
def make_movie(q: np.ndarray, step: int, bodies: List[str], plot_colors: Dict[str, str], fname: str):
<EOL>N, dims = q.shape<EOL>x_slice = slice(<NUM_LIT:0>, dims, <NUM_LIT:3>)<EOL>y_slice = slice(<NUM_LIT:1>, dims, <NUM_LIT:3>)<EOL>plot_x = q[:, x_slice] / au2m<EOL>plot_y = q[:, y_slice] / au2m<EOL>radius_earth = radius_tbl['<STR_LIT>']<EOL>markersize_earth = <NUM_LIT><EOL>markersize_tbl = {body : (radius_tbl[body] / radius_earth)**<NUM_LIT> * markersize_earth for body in bodies}<EOL>fig, ax = plt.subplots(figsize=[<NUM_LIT:12>,<NUM_LIT:12>])<EOL>print(f'<STR_LIT>')<EOL>for fn in tqdm(range(N//step)):<EOL><INDENT>rn: int = fn * step<EOL>make_frame(fig, ax, plot_x[rn], plot_y[rn], fn, bodies, plot_colors, markersize_tbl, fname)<EOL><DEDENT>cmd1: List[str] = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>call(cmd1)<EOL>cmd2: List[str] = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', <EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>call(cmd2) <EOL>cmd3: List[str] = ['<STR_LIT>', '<STR_LIT>']<EOL>call(cmd3)<EOL>
Make a series of frames of the planetary orbits that can be assembled into a movie. q is a Nx3B array. t indexes time points. 3B columns are (x, y, z) for the bodies in order.
f9529:m3
def accel(q: np.ndarray):
<EOL>dims: int = len(q)<EOL>a: np.ndarray = np.zeros(dims)<EOL>for i in range(B):<EOL><INDENT>for j in range(i+<NUM_LIT:1>, B):<EOL><INDENT>m0 = mass[i]<EOL>m1 = mass[j]<EOL>pos_0 = q[slices[i]]<EOL>pos_1 = q[slices[j]]<EOL>dv_01: np.ndarray = pos_1 - pos_0<EOL>r_01: float = np.linalg.norm(dv_01)<EOL>udv_01 = dv_01 / r_01<EOL>f_01: float = (G * m0 * m1) / (r_01 ** <NUM_LIT:2>)<EOL>a[slices[i]] += f_01 * udv_01 / m0<EOL>a[slices[j]] -= f_01 * udv_01 / m1<EOL><DEDENT><DEDENT>return a<EOL>
Compute the gravitational accelerations in the system q in row vector of 6 elements: sun (x, y, z), earth (x, y, z)
f9529:m4
def energy(q, v):
<EOL>N: int = len(q)<EOL>T: np.ndarray = np.zeros(N)<EOL>U: np.ndarray = np.zeros(N) <EOL>for i in range(B):<EOL><INDENT>m = mass[i]<EOL>vi = v[:, slices[i]]<EOL>T += <NUM_LIT:0.5> * m * np.sum(vi * vi, axis=<NUM_LIT:1>)<EOL><DEDENT>for i in range(B):<EOL><INDENT>for j in range(i+<NUM_LIT:1>, B):<EOL><INDENT>mi = mass[i]<EOL>mj = mass[j]<EOL>qi: np.ndarray = q[:, slices[i]]<EOL>qj: np.ndarray = q[:, slices[j]]<EOL>dv_ij = qj - qi<EOL>r_ij = np.linalg.norm(dv_ij, axis=<NUM_LIT:1>)<EOL>U -= G * mi * mj * <NUM_LIT:1.0> / r_ij<EOL><DEDENT><DEDENT>H = T + U<EOL>return H, T, U<EOL>
Compute the kinetic and potential energy of the planetary system
f9529:m5
def make_force(q_vars, mass):
<EOL>B: int = len(mass)<EOL>U = fl.Const(<NUM_LIT:0.0>)<EOL>for i in range(B):<EOL><INDENT>for j in range(i+<NUM_LIT:1>, B):<EOL><INDENT>U += U_ij(q_vars, mass, i, j)<EOL><DEDENT><DEDENT>vn_q = np.array([q.var_name for q in q_vars])<EOL>vn_fl = np.array(sorted(U.var_names))<EOL>q2fl = np.array([np.argmax((vn_q == v)) for v in vn_fl])<EOL>fl2q = np.array([np.argmax((vn_fl == v)) for v in vn_q])<EOL>force_func = lambda q: -U.diff(q[q2fl]).squeeze()[fl2q]<EOL>return force_func<EOL>
Fluxion with the potential energy of the eight planets sytem
f9529:m6
def accel_fl(q: np.ndarray):
<EOL>dims: int = len(q)<EOL>B: int = dims // <NUM_LIT:3><EOL>f = force(q)<EOL>a = np.zeros(dims)<EOL>for i in range(B):<EOL><INDENT>a[slices[i]] = f[slices[i]] / mass[i]<EOL><DEDENT>return a<EOL>
Accelaration in the earth-sun system using Fluxion potential energy
f9529:m7
def newtons_method_scalar(f: fl.Fluxion, x: float, tol: float =<NUM_LIT>) -> float:
max_iters: int = <NUM_LIT:100><EOL>for i in range(max_iters):<EOL><INDENT>y, dy_dx = f(x)<EOL>if abs(y) < tol:<EOL><INDENT>break<EOL><DEDENT>dx = -y / dy_dx<EOL>x += float(dx)<EOL><DEDENT>return x, i<EOL>
Solve the equation f(x) = 0 for a function from R->R using Newton's method
f9530:m0
def find_label(label, label_color, label_description):
edit = None<EOL>for name, values in label_list.items():<EOL><INDENT>color, description = values<EOL>if isinstance(name, tuple):<EOL><INDENT>old_name = name[<NUM_LIT:0>]<EOL>new_name = name[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>old_name = name<EOL>new_name = name<EOL><DEDENT>if label.lower() == old_name.lower():<EOL><INDENT>edit = LabelEdit(old_name, new_name, color, description)<EOL>break<EOL><DEDENT><DEDENT>return edit<EOL>
Find label.
f9533:m0
def update_labels(repo):
updated = set()<EOL>for label in repo.get_labels():<EOL><INDENT>edit = find_label(label.name, label.color, label.description)<EOL>if edit is not None:<EOL><INDENT>print('<STR_LIT>'.format(edit.new, edit.color, edit.description))<EOL>label.edit(edit.new, edit.color, edit.description)<EOL>updated.add(edit.old)<EOL>updated.add(edit.new)<EOL><DEDENT>else:<EOL><INDENT>if DELETE_UNSPECIFIED:<EOL><INDENT>print('<STR_LIT>'.format(label.name, label.color, label.description))<EOL>label.delete()<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>'.format(label.name, label.color, label.description))<EOL><DEDENT>updated.add(label.name)<EOL><DEDENT><DEDENT>for name, values in label_list.items():<EOL><INDENT>color, description = values<EOL>if isinstance(name, tuple):<EOL><INDENT>new_name = name[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>new_name = name<EOL><DEDENT>if new_name not in updated:<EOL><INDENT>print('<STR_LIT>'.format(new_name, color, description))<EOL>repo.create_label(new_name, color, description)<EOL><DEDENT><DEDENT>
Update labels.
f9533:m1
def get_auth():
import getpass<EOL>user = input("<STR_LIT>") <EOL>pswd = getpass.getpass('<STR_LIT>')<EOL>return Github(user, pswd)<EOL>
Get authentication.
f9533:m2
def main():
if len(sys.argv) > <NUM_LIT:1> and os.path.exists(sys.argv[<NUM_LIT:1>]):<EOL><INDENT>try:<EOL><INDENT>with open(sys.argv[<NUM_LIT:1>], '<STR_LIT:r>') as f:<EOL><INDENT>user_name, password = f.read().strip().split('<STR_LIT::>')<EOL><DEDENT>git = Github(user_name, password)<EOL>password = None<EOL><DEDENT>except Exception:<EOL><INDENT>git = get_auth()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>git = get_auth()<EOL><DEDENT>user = git.get_user()<EOL>print('<STR_LIT>')<EOL>for repo in user.get_repos():<EOL><INDENT>if repo.owner.name == user.name:<EOL><INDENT>if repo.name == REPO_NAME:<EOL><INDENT>print(repo.name)<EOL>update_labels(repo)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>
Main.
f9533:m3
def create_empty_file(filename):
fd = os.open(filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC)<EOL>os.close(fd)<EOL>
Create an empty file. If the file already exists, truncate it.
f9536:m0
def can_symlink():
global _can_symlink<EOL>if _can_symlink is not None:<EOL><INDENT>return _can_symlink<EOL><DEDENT>symlink_path = TESTFN + "<STR_LIT>"<EOL>try:<EOL><INDENT>os.symlink(TESTFN, symlink_path)<EOL>can = True<EOL><DEDENT>except (OSError, NotImplementedError, AttributeError):<EOL><INDENT>can = False<EOL><DEDENT>else:<EOL><INDENT>os.remove(symlink_path)<EOL><DEDENT>_can_symlink = can<EOL>return can<EOL>
Check if we can symlink.
f9536:m1
def mktemp(self, *parts):
filename = self.norm(*parts)<EOL>base, file = os.path.split(filename)<EOL>if not os.path.exists(base):<EOL><INDENT>retry = <NUM_LIT:3><EOL>while retry:<EOL><INDENT>try:<EOL><INDENT>os.makedirs(base)<EOL>retry = <NUM_LIT:0><EOL><DEDENT>except Exception:<EOL><INDENT>retry -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>create_empty_file(filename)<EOL>
Make temp directory.
f9536:c0:m0
def force_err(self):
raise TypeError<EOL>
Force an error.
f9536:c0:m1
def norm(self, *parts):
tempdir = os.fsencode(self.tempdir) if isinstance(parts[<NUM_LIT:0>], bytes) else self.tempdir<EOL>return os.path.join(tempdir, *parts)<EOL>
Normalizes file path (in relation to temp directory).
f9536:c0:m2
def norm_list(self, files):
return sorted([self.norm(os.path.normpath(x)) for x in files])<EOL>
Normalize file list.
f9536:c0:m3
def setUp(self):
self.tempdir = TESTFN + "<STR_LIT>"<EOL>self.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>self.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.default_flags = wcmatch.R | wcmatch.I | wcmatch.M | wcmatch.SL<EOL>self.errors = []<EOL>self.skipped = <NUM_LIT:0><EOL>self.skip_records = []<EOL>self.error_records = []<EOL>self.files = []<EOL>
Setup.
f9536:c0:m4
def tearDown(self):
retry = <NUM_LIT:3><EOL>while retry:<EOL><INDENT>try:<EOL><INDENT>shutil.rmtree(self.tempdir)<EOL>retry = <NUM_LIT:0><EOL><DEDENT>except Exception:<EOL><INDENT>retry -= <NUM_LIT:1><EOL><DEDENT><DEDENT>
Cleanup.
f9536:c0:m5
def crawl_files(self, walker):
for f in walker.match():<EOL><INDENT>if f == '<STR_LIT>':<EOL><INDENT>self.skip_records.append(f)<EOL><DEDENT>elif f == '<STR_LIT>':<EOL><INDENT>self.error_records.append(f)<EOL><DEDENT>else:<EOL><INDENT>self.files.append(f)<EOL><DEDENT><DEDENT>self.skipped = walker.get_skipped()<EOL>
Crawl the files.
f9536:c0:m6
def setUp(self):
self.tempdir = TESTFN + "<STR_LIT>"<EOL>self.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>self.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.default_flags = wcmatch.R | wcmatch.I | wcmatch.M | wcmatch.SL<EOL>self.errors = []<EOL>self.skipped = <NUM_LIT:0><EOL>self.skip_records = []<EOL>self.error_records = []<EOL>self.files = []<EOL>
Setup.
f9536:c1:m0
def mksymlink(self, original, link):
if not os.path.lexists(link):<EOL><INDENT>os.symlink(original, link)<EOL><DEDENT>
Make symlink.
f9536:c2:m0
def setUp(self):
self.tempdir = TESTFN + "<STR_LIT>"<EOL>self.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>self.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.mktemp('<STR_LIT>')<EOL>self.can_symlink = can_symlink()<EOL>if self.can_symlink:<EOL><INDENT>self.mksymlink('<STR_LIT>', self.norm('<STR_LIT>'))<EOL>self.mksymlink(os.path.join('<STR_LIT>', '<STR_LIT>'), self.norm('<STR_LIT>'))<EOL><DEDENT>self.default_flags = wcmatch.R | wcmatch.I | wcmatch.M<EOL>self.errors = []<EOL>self.skipped = <NUM_LIT:0><EOL>self.skip_records = []<EOL>self.error_records = []<EOL>self.files = []<EOL>
Setup.
f9536:c2:m1
@classmethod<EOL><INDENT>def setup_class(cls):<DEDENT>
cls.flags = fnmatch.DOTMATCH<EOL>
Setup the tests.
f9538:c0:m0
@staticmethod<EOL><INDENT>def assert_equal(a, b):<DEDENT>
assert a == b, "<STR_LIT>"<EOL>
Assert equal.
f9538:c0:m1
@classmethod<EOL><INDENT>def evaluate(cls, case):<DEDENT>
flags = case[<NUM_LIT:3>]<EOL>flags = cls.flags ^ flags<EOL>print("<STR_LIT>", case[<NUM_LIT:0>])<EOL>print("<STR_LIT>", case[<NUM_LIT:1>])<EOL>print("<STR_LIT>", bin(flags))<EOL>print("<STR_LIT>", case[<NUM_LIT:2>], '<STR_LIT:\n>')<EOL>cls.assert_equal(fnmatch.fnmatch(case[<NUM_LIT:1>], case[<NUM_LIT:0>], flags=flags), case[<NUM_LIT:2>])<EOL>cls.assert_equal(<EOL>fnmatch.fnmatch(case[<NUM_LIT:1>], case[<NUM_LIT:0>], flags=flags | fnmatch.SPLIT), case[<NUM_LIT:2>]<EOL>)<EOL>
Evaluate matches.
f9538:c0:m2
@classmethod<EOL><INDENT>def setup_class(cls):<DEDENT>
cls.flags = fnmatch.DOTMATCH<EOL>
Setup the tests.
f9538:c1:m0
@staticmethod<EOL><INDENT>def assert_equal(a, b):<DEDENT>
assert a == b, "<STR_LIT>"<EOL>
Assert equal.
f9538:c1:m1
@classmethod<EOL><INDENT>def evaluate(cls, case):<DEDENT>
flags = case[<NUM_LIT:3>]<EOL>flags = cls.flags ^ flags<EOL>print("<STR_LIT>", case[<NUM_LIT:0>])<EOL>print("<STR_LIT>", case[<NUM_LIT:1>])<EOL>print("<STR_LIT>", bin(flags))<EOL>value = fnmatch.filter(case[<NUM_LIT:1>], case[<NUM_LIT:0>], flags=flags)<EOL>print("<STR_LIT>", value, '<STR_LIT>', case[<NUM_LIT:2>], '<STR_LIT:\n>')<EOL>cls.assert_equal(value, case[<NUM_LIT:2>])<EOL>
Evaluate matches.
f9538:c1:m2
def setUp(self):
self.flags = fnmatch.DOTMATCH<EOL>
Setup the tests.
f9538:c2:m0
def split_translate(self, pattern, flags):
return fnmatch.translate(pattern, flags=flags | fnmatch.SPLIT)<EOL>
Translate pattern to regex after splitting.
f9538:c2:m1
def __init__(self, filelist, append=False):
self.filelist = filelist<EOL>self.append = append<EOL>
File list object.
f9539:c0:m0
def __init__(self, **kwargs):
self._options = kwargs<EOL>
Initialize.
f9539:c1:m0
def get(self, key, default=None):
return self._options.get(key, default)<EOL>
Get option value.
f9539:c1:m1
@classmethod<EOL><INDENT>def setup_class(cls):<DEDENT>
cls.files = []<EOL>cls.flags = glob.NEGATE | glob.GLOBSTAR | glob.EXTGLOB | glob.BRACE<EOL>cls.skip_split = False<EOL>
Setup the tests.
f9539:c2:m0
@staticmethod<EOL><INDENT>def norm_files(files, flags):<DEDENT>
flags = glob._flag_transform(flags)<EOL>unix = _wcparse.is_unix_style(flags)<EOL>return [(util.norm_slash(x) if not unix else x) for x in files]<EOL>
Normalize files.
f9539:c2:m1
@staticmethod<EOL><INDENT>def assert_equal(a, b):<DEDENT>
assert a == b, "<STR_LIT>"<EOL>
Assert equal.
f9539:c2:m2
@classmethod<EOL><INDENT>def _filter(cls, case, split=False):<DEDENT>
if isinstance(case, GlobFiles):<EOL><INDENT>if case.append:<EOL><INDENT>cls.files.extend(case.filelist)<EOL><DEDENT>else:<EOL><INDENT>cls.files.clear()<EOL>cls.files.extend(case.filelist)<EOL><DEDENT>pytest.skip("<STR_LIT>")<EOL><DEDENT>elif isinstance(case, Options):<EOL><INDENT>cls.skip_split = case.get('<STR_LIT>', False)<EOL>pytest.skip("<STR_LIT>")<EOL><DEDENT>files = cls.files if len(case) < <NUM_LIT:4> else case[<NUM_LIT:3>]<EOL>flags = <NUM_LIT:0> if len(case) < <NUM_LIT:3> else case[<NUM_LIT:2>]<EOL>print('<STR_LIT>')<EOL>print(case)<EOL>print(flags, cls.flags)<EOL>flags = cls.flags ^ flags<EOL>pat = case[<NUM_LIT:0>] if isinstance(case[<NUM_LIT:0>], list) else [case[<NUM_LIT:0>]]<EOL>if split and cls.skip_split:<EOL><INDENT>return<EOL><DEDENT>if split:<EOL><INDENT>flags |= glob.SPLIT<EOL><DEDENT>print("<STR_LIT>", case[<NUM_LIT:0>])<EOL>print("<STR_LIT>", files)<EOL>print("<STR_LIT>", bin(flags))<EOL>result = sorted(<EOL>glob.globfilter(<EOL>files,<EOL>pat,<EOL>flags=flags<EOL>)<EOL>)<EOL>source = sorted(cls.norm_files(case[<NUM_LIT:1>], flags))<EOL>print("<STR_LIT>", result, '<STR_LIT>', source, '<STR_LIT:\n>')<EOL>cls.assert_equal(result, source)<EOL>
Filter with glob pattern.
f9539:c2:m3
@classmethod<EOL><INDENT>def setup_class(cls):<DEDENT>
<EOL>cls.flags = glob.NEGATE | glob.GLOBSTAR | glob.EXTGLOB | glob.BRACE<EOL>
Setup default flag options.
f9539:c3:m0
@classmethod<EOL><INDENT>def evaluate(cls, case):<DEDENT>
pattern = case[<NUM_LIT:0>]<EOL>filename = case[<NUM_LIT:1>]<EOL>goal = case[<NUM_LIT:2>]<EOL>flags = cls.flags<EOL>if len(case) > <NUM_LIT:3>:<EOL><INDENT>flags ^= case[<NUM_LIT:3>]<EOL><DEDENT>print("<STR_LIT>", pattern)<EOL>print("<STR_LIT>", filename)<EOL>print("<STR_LIT>", goal)<EOL>print("<STR_LIT>", bin(flags))<EOL>assert glob.globmatch(filename, pattern, flags=flags) == goal, "<STR_LIT>" % goal<EOL>
Evaluate case.
f9539:c3:m1
def setUp(self):
self.flags = glob.NEGATE | glob.GLOBSTAR | glob.EXTGLOB | glob.BRACE<EOL>
Setup default flag options.
f9539:c4:m0
@contextlib.contextmanager<EOL>def change_cwd(path, quiet=False):
saved_dir = os.getcwd()<EOL>try:<EOL><INDENT>os.chdir(path)<EOL><DEDENT>except OSError:<EOL><INDENT>if not quiet:<EOL><INDENT>raise<EOL><DEDENT>warnings.warn('<STR_LIT>' + path,<EOL>RuntimeWarning, stacklevel=<NUM_LIT:3>)<EOL><DEDENT>try:<EOL><INDENT>yield os.getcwd()<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(saved_dir)<EOL><DEDENT>
Return a context manager that changes the current working directory. Arguments: path: the directory to use as the temporary current working directory. quiet: if False (the default), the context manager raises an exception on error. Otherwise, it issues only a warning and keeps the current working directory the same.
f9541:m0
def create_empty_file(filename):
fd = os.open(filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC)<EOL>os.close(fd)<EOL>
Create an empty file. If the file already exists, truncate it.
f9541:m1
def can_symlink():
global _can_symlink<EOL>if _can_symlink is not None:<EOL><INDENT>return _can_symlink<EOL><DEDENT>symlink_path = TESTFN + "<STR_LIT>"<EOL>try:<EOL><INDENT>os.symlink(TESTFN, symlink_path)<EOL>can = True<EOL><DEDENT>except (OSError, NotImplementedError, AttributeError):<EOL><INDENT>can = False<EOL><DEDENT>else:<EOL><INDENT>os.remove(symlink_path)<EOL><DEDENT>_can_symlink = can<EOL>return can<EOL>
Check if we can symlink.
f9541:m2
def __init__(self, **kwargs):
self._options = kwargs<EOL>
Initialize.
f9541:c0:m0
def get(self, key, default=None):
return self._options.get(key, default)<EOL>
Get option value.
f9541:c0:m1
@classmethod<EOL><INDENT>def norm(cls, *parts):<DEDENT>
return os.path.join(cls.tempdir, *parts)<EOL>
Normalizes file path (in relation to temp directory).
f9541:c1:m0
@classmethod<EOL><INDENT>def globjoin(cls, *parts):<DEDENT>
sep = cls.globsep<EOL>return sep.join(list(parts))<EOL>
Joins glob path.
f9541:c1:m1
@classmethod<EOL><INDENT>def mktemp(cls, *parts):<DEDENT>
filename = cls.norm(*parts)<EOL>base, file = os.path.split(filename)<EOL>if not os.path.exists(base):<EOL><INDENT>retry = <NUM_LIT:3><EOL>while retry:<EOL><INDENT>try:<EOL><INDENT>os.makedirs(base)<EOL>retry = <NUM_LIT:0><EOL><DEDENT>except Exception:<EOL><INDENT>retry -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>create_empty_file(filename)<EOL>
Make temp directory.
f9541:c1:m2
@classmethod<EOL><INDENT>def setup_class(cls):<DEDENT>
cls.default_negate = '<STR_LIT>'<EOL>cls.absolute = False<EOL>cls.skip = False<EOL>cls.cwd_temp = False<EOL>cls.just_negative = False<EOL>if os.sep == '<STR_LIT:/>':<EOL><INDENT>cls.globsep = os.sep<EOL><DEDENT>else:<EOL><INDENT>cls.globsep = r'<STR_LIT:\\>'<EOL><DEDENT>cls.tempdir = TESTFN + "<STR_LIT>"<EOL>cls.setup_fs()<EOL>
Setup.
f9541:c1:m3
@classmethod<EOL><INDENT>def setup_fs(cls):<DEDENT>
Setup file system.
f9541:c1:m4
@classmethod<EOL><INDENT>def teardown_class(cls):<DEDENT>
retry = <NUM_LIT:3><EOL>while retry:<EOL><INDENT>try:<EOL><INDENT>shutil.rmtree(cls.tempdir)<EOL>retry = <NUM_LIT:0><EOL><DEDENT>except Exception:<EOL><INDENT>retry -= <NUM_LIT:1><EOL><DEDENT><DEDENT>
Cleanup.
f9541:c1:m5
@staticmethod<EOL><INDENT>def assert_equal(a, b):<DEDENT>
assert a == b, "<STR_LIT>"<EOL>
Assert equal.
f9541:c1:m6
@staticmethod<EOL><INDENT>def assert_count_equal(a, b):<DEDENT>
c1 = len(list(a)) if isinstance(a, types.GeneratorType) else len(a)<EOL>c2 = len(list(b)) if isinstance(b, types.GeneratorType) else len(b)<EOL>assert c1 == c2, "<STR_LIT>" % (c1, c2)<EOL>
Assert count equal.
f9541:c1:m7
@classmethod<EOL><INDENT>def glob(cls, *parts, **kwargs):<DEDENT>
if parts:<EOL><INDENT>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>p = parts[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>p = cls.globjoin(*parts)<EOL><DEDENT>if not cls.absolute:<EOL><INDENT>p = cls.globjoin(cls.tempdir, p)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p = cls.tempdir<EOL><DEDENT>res = glob.glob(p, **kwargs)<EOL>print("<STR_LIT>", res)<EOL>if res:<EOL><INDENT>cls.assert_equal({type(r) for r in res}, {str})<EOL><DEDENT>cls.assert_count_equal(glob.iglob(p, **kwargs), res)<EOL>bres = [os.fsencode(x) for x in res]<EOL>cls.assert_count_equal(glob.glob(os.fsencode(p), **kwargs), bres)<EOL>cls.assert_count_equal(glob.iglob(os.fsencode(p), **kwargs), bres)<EOL>if bres:<EOL><INDENT>cls.assert_equal({type(r) for r in bres}, {bytes})<EOL><DEDENT>return res<EOL>
Perform a glob with validation.
f9541:c1:m8
@classmethod<EOL><INDENT>def nglob(cls, *parts, **kwargs):<DEDENT>
if parts:<EOL><INDENT>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>p = parts[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>p = cls.globjoin(*parts)<EOL><DEDENT>if not cls.absolute:<EOL><INDENT>p = cls.globjoin(cls.tempdir, p)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p = cls.tempdir<EOL><DEDENT>p = '<STR_LIT:!>' + p<EOL>if not cls.just_negative:<EOL><INDENT>if not cls.absolute:<EOL><INDENT>p = [cls.globjoin(cls.tempdir, cls.default_negate), p]<EOL><DEDENT>else:<EOL><INDENT>p = [cls.default_negate, p]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p = [p]<EOL><DEDENT>res = glob.glob(p, **kwargs)<EOL>print("<STR_LIT>", res)<EOL>if res:<EOL><INDENT>cls.assert_equal({type(r) for r in res}, {str})<EOL><DEDENT>cls.assert_count_equal(glob.iglob(p, **kwargs), res)<EOL>bres = [os.fsencode(x) for x in res]<EOL>cls.assert_count_equal(glob.glob([os.fsencode(x) for x in p], **kwargs), bres)<EOL>cls.assert_count_equal(glob.iglob([os.fsencode(x) for x in p], **kwargs), bres)<EOL>if bres:<EOL><INDENT>cls.assert_equal({type(r) for r in bres}, {bytes})<EOL><DEDENT>return res<EOL>
Perform a glob with validation.
f9541:c1:m9
@classmethod<EOL><INDENT>def assertSequencesEqual_noorder(cls, l1, l2):<DEDENT>
l1 = list(l1)<EOL>l2 = list(l2)<EOL>cls.assert_equal(set(l1), set(l2))<EOL>cls.assert_equal(sorted(l1), sorted(l2))<EOL>
Verify lists match (unordered).
f9541:c1:m10
@classmethod<EOL><INDENT>def eval_glob_cases(cls, case):<DEDENT>
eq = cls.assertSequencesEqual_noorder<EOL>if isinstance(case, Options):<EOL><INDENT>absolute = case.get('<STR_LIT>')<EOL>if absolute is not None:<EOL><INDENT>cls.absolute = absolute<EOL><DEDENT>skip = case.get('<STR_LIT>')<EOL>if skip is not None:<EOL><INDENT>cls.skip = skip<EOL><DEDENT>cwd_temp = case.get('<STR_LIT>')<EOL>if cwd_temp is not None:<EOL><INDENT>cls.cwd_temp = cwd_temp<EOL><DEDENT>just_negative = case.get('<STR_LIT>')<EOL>if just_negative is not None:<EOL><INDENT>cls.just_negative = just_negative<EOL><DEDENT>default_negate = case.get('<STR_LIT>')<EOL>if default_negate is not None:<EOL><INDENT>cls.default_negate = default_negate<EOL><DEDENT>pytest.skip("<STR_LIT>")<EOL><DEDENT>if cls.skip:<EOL><INDENT>pytest.skip("<STR_LIT>")<EOL><DEDENT>pattern = case[<NUM_LIT:0>]<EOL>if not cls.absolute:<EOL><INDENT>results = [cls.norm(*x) for x in case[<NUM_LIT:1>]] if case[<NUM_LIT:1>] is not None else None<EOL><DEDENT>else:<EOL><INDENT>results = [os.path.join(*list(x)) for x in case[<NUM_LIT:1>]] if case[<NUM_LIT:1>] is not None else None<EOL><DEDENT>flags = cls.DEFAULT_FLAGS<EOL>if len(case) > <NUM_LIT:2>:<EOL><INDENT>flags ^= case[<NUM_LIT:2>]<EOL><DEDENT>negative = flags & glob.N<EOL>print("<STR_LIT>", pattern)<EOL>print("<STR_LIT>", bin(flags))<EOL>print("<STR_LIT>", bin(negative))<EOL>print("<STR_LIT>", results)<EOL>if cls.cwd_temp:<EOL><INDENT>with change_cwd(cls.tempdir):<EOL><INDENT>res = cls.nglob(*pattern, flags=flags) if negative else cls.glob(*pattern, flags=flags)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>res = cls.nglob(*pattern, flags=flags) if negative else cls.glob(*pattern, flags=flags)<EOL><DEDENT>if results is not None:<EOL><INDENT>eq(res, results)<EOL><DEDENT>print('<STR_LIT:\n>')<EOL>
Evaluate glob cases.
f9541:c1:m11
@classmethod<EOL><INDENT>def setup_fs(cls):<DEDENT>
cls.mktemp('<STR_LIT:a>', '<STR_LIT:D>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT:F>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT:H>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>')<EOL>cls.mktemp('<STR_LIT:a>', '<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT:a>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>cls.can_symlink = can_symlink()<EOL>if cls.can_symlink:<EOL><INDENT>os.symlink(cls.norm('<STR_LIT>'), cls.norm('<STR_LIT>'))<EOL>os.symlink('<STR_LIT>', cls.norm('<STR_LIT>'))<EOL>os.symlink(os.path.join('<STR_LIT:a>', '<STR_LIT>'), cls.norm('<STR_LIT>'))<EOL><DEDENT>
Setup file system.
f9541:c2:m0
@classmethod<EOL><INDENT>def setup_fs(cls):<DEDENT>
cls.mktemp('<STR_LIT:a>', '<STR_LIT:D>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT:F>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT:H>')<EOL>cls.mktemp('<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>')<EOL>cls.mktemp('<STR_LIT>')<EOL>cls.mktemp('<STR_LIT:a>', '<STR_LIT>', '<STR_LIT>')<EOL>cls.mktemp('<STR_LIT:a>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>cls.can_symlink = can_symlink()<EOL>if cls.can_symlink:<EOL><INDENT>os.symlink(cls.norm('<STR_LIT>'), cls.norm('<STR_LIT>'))<EOL>os.symlink('<STR_LIT>', cls.norm('<STR_LIT>'))<EOL>os.symlink(os.path.join('<STR_LIT:a>', '<STR_LIT>'), cls.norm('<STR_LIT>'))<EOL><DEDENT>
Setup file system.
f9541:c3:m0