markdown stringlengths 0 1.02M | code stringlengths 0 832k | output stringlengths 0 1.02M | license stringlengths 3 36 | path stringlengths 6 265 | repo_name stringlengths 6 127 |
|---|---|---|---|---|---|
check by: | MultiDerived.__mro__
MultiDerived.mro() | _____no_output_____ | MIT | Session 06 - OOP.ipynb | FOU4D/ITI-Python |
Encapsulation we denote private attributes using underscore as the prefix i.e single _ or double __ | class Cars:
def __init__(self):
self.__maxprice = 90000
def sell(self):
print("Selling Price: {}".format(self.__maxprice))
def setMaxPrice(self, price):
self.__maxprice = price
toyota = Cars()
toyota.sell()
# change the price
toyota.__maxprice = 1000
toyota.sell()
# using sette... | Selling Price: 90000
Selling Price: 90000
Selling Price: 1000
| MIT | Session 06 - OOP.ipynb | FOU4D/ITI-Python |
polymorphism | class Parrot:
def fly(self):
print("Parrot can fly")
def swim(self):
print("Parrot can't swim")
class Penguin:
def fly(self):
print("Penguin can't fly")
def swim(self):
print("Penguin can swim")
# common interface
def flying_test(bird):
bird.fly()
#inst... | Parrot can fly
Penguin can't fly
| MIT | Session 06 - OOP.ipynb | FOU4D/ITI-Python |
0. Imports | # Imports
from IPython.display import display, HTML
import os
import pandas as pd, datetime as dt, numpy as np, matplotlib.pyplot as plt
from pandas.tseries.offsets import DateOffset
import sys
# Display options
thisnotebooksys = sys.stdout
pd.set_option('display.width', 1000)
display(HTML("<style>.container { width:1... | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
1. LOB creation | # b_tape = True means the LOB
LOB = mlob.OrderBook(tick_size = 0.5,
b_tape = True, # tape transactions
b_tape_LOB = True, # tape lob state at each tick
verbose = True) | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
2. Data- DTIME : le timestamp de l'ordre- ORDER_ID : l'identifiant de l'ordre- PRICE - QTY- ORDER_SIDE- ORDER_SIDE- ORDER_TYPE : 1 pour Market Order; 2 pour Limit Order; q pour Quote W pour Market On Open;- ACTION_TYPE : I = limit order insertion (passive); C = limit order cacnellations; R = replace order that lo... | df = pd.read_pickle(r'..\data\day20160428.pkl')
df | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
3. Agents Creation | auction_config = {'orderbook' : LOB,
'id' : 'FDR',
'b_record' : False,
'historicalOrders' : df[df.DTIME.dt.hour<7]}
continuousTrading_config = {'orderbook' : LOB,
'id' : 'FDR',
... | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
4. Replay orders 4.1. Auction phase The auction price shall be determined on the basis of the situation of the Central Order Book at the closing of the call phase and shall be the price which produces the highest executable order volume. | %%time
# log
f = open('log_auction.txt','w');
sys.stdout = f
# Close auction
LOB.b_auction = True #Open auction
AuctionReplayer.replayOrders()
# log
sys.stdout = thisnotebooksys | Wall time: 94.1 ms
| MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
4.2. Auction is overClosing the auction will result in transactions and a new LOB with unmatched orders will be set.The price is chosen as the one that maximizes volume of transactions.Trades are executed at the auction price, and according to a time priority. The remaining orders at the auction price are the newest o... | %%time
# log
f = open('log_auctionClose.txt','w');
sys.stdout = f
LOB.b_auction = False
# log
sys.stdout = thisnotebooksys | Wall time: 12.4 ms
| MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
4.3. Lob StateLOB state before opening the continuous trading | LOBstate = AuctionReplayer.getLOBState()
LOBstate = LOBstate.set_index('Price').sort_index()
LOBstate.plot.bar(figsize=(20, 7))
plt.show() | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
4.4. Continuous Trading | %%time
# log
f = open('log_continuousTrading.txt','w');
sys.stdout = f
# Close auction
ContReplayer.replayOrders()
# log
sys.stdout = thisnotebooksys | Wall time: 5min 40s
| MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
5. Price Tape | histoPrices = ContReplayer.getPriceTape().astype(float)
histoPrices.plot(figsize=(20,7))
# OHLC
display(f'open : {histoPrices.iloc[0,0]}')
display(f'high : {histoPrices.max()[0]}')
display(f'low : {histoPrices.min()[0]}')
display(f'close : {histoPrices.iloc[-1, 0]}')
plt.show() | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
Get Transaction Tape | TransactionTape = ContReplayer.getTransactionTape()
TransactionTape | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
Get LOB Tape The LOB tape is the state of the LOB before each order arrival | LOBtape = AuctionReplayer.getLOBTape()
LOBtape | _____no_output_____ | MIT | demo/Classic/2. Demo - Simulation - Replayer.ipynb | FDR0903/mimicLOB |
**Note that this notebook uses private hospita-level data, so can't be run publicly** | %load_ext autoreload
%autoreload 2
import numpy as np
import scipy as sp
import pandas as pd
import matplotlib.pyplot as plt
from os.path import join as oj
import math
import pygsheets
import pickle as pkl
import pandas as pd
import seaborn as sns
import plotly.express as px
from collections import Counter
import plotl... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
severity index | df = severity_index.add_severity_index(df, NUM_DAYS_LIST)
d = severity_index.df_to_plot(df, NUM_DAYS_LIST)
k = 3
s_hosp = f'Predicted Deaths Hospital {k}-day'
s_index = f'Severity {k}-day'
print('total hospitals', df.shape[0], Counter(df[s_index]))
viz_interactive.viz_index_animated(d, [1, 2, 3, 4, 5],
... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
**start with county-level death predictions** | s = f'Predicted Deaths {3}-day' # tot_deaths
# s = 'tot_deaths'
num_days = 1
nonzero = df[s] > 0
plt.figure(dpi=300, figsize=(7, 3))
plt.plot(df_county[s].values, '.', ms=3)
plt.ylabel(s)
plt.xlabel('Counties')
plt.yscale('log')
plt.tight_layout()
plt.show() | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
**look at distribution of predicted deaths at hospitals** | num_days = 1
plt.figure(dpi=300, figsize=(7, 3))
offset = 0
for i in [5, 4, 3, 2, 1]:
idxs = (df[s_index] == i)
plt.plot(np.arange(offset, offset + idxs.sum()),
np.clip(df[idxs][s_hosp].values, a_min=1, a_max=None), '.-', label=f'{i}: {severity_index.meanings[i]}')
offset += idxs.sum()
plt.ys... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
adjustments **different measures of hospital size are pretty consistent** | plt.figure(dpi=500, figsize=(7, 3), facecolor='w')
R, C = 1, 3
plt.subplot(R, C, 1)
plt.plot(df['Hospital Employees'], df['Total Average Daily Census'], '.', alpha=0.2, markeredgewidth=0)
plt.xlabel('Num Hospital Employees')
plt.ylabel('Total Average Daily Census')
plt.subplot(R, C, 2)
plt.plot(df['Hospital Employees'... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
**other measures are harder to parse...** | ks = ['Predicted Deaths Hospital 2-day', "Hospital Employees", 'ICU Beds']
R, C = 1, len(ks)
plt.figure(dpi=300, figsize=(C * 3, R * 3))
for c in range(C):
plt.subplot(R, C, c + 1)
if c == 0:
plt.ylabel('Total Occupancy Rate')
plt.plot(df[ks[c]], df['Total Occupancy Rate'], '.', alpha=0.5)
plt.... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
**different hospital types** | plt.figure(dpi=500, figsize=(7, 3))
R, C = 1, 3
a = 0.5
s = s_hosp
plt.subplot(R, C, 1)
idxs = df.IsUrbanHospital == 1
plt.hist(df[idxs][s], label='Urban', alpha=a)
plt.hist(df[~idxs][s], label='Rural', alpha=a)
plt.ylabel('Num Hospitals')
plt.xlabel(s)
plt.yscale('log')
plt.legend()
plt.subplot(R, C, 2)
idxs = df.IsA... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
**rural areas have lower occupancy rates** | idxs = df.IsUrbanHospital == 1
plt.hist(df['Total Occupancy Rate'][idxs], label='urban', alpha=0.5)
plt.hist(df['Total Occupancy Rate'][~idxs], label='rural', alpha=0.5)
plt.xlabel('Total Occupancy Rate')
plt.ylabel('Count')
plt.legend()
plt.show()
ks = ['ICU Beds', 'Total Beds',
'Hospital Employees', 'Registere... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
look at top counties/hospitals **hospitals per county** | d = df
R, C = 1, 2
NUM_COUNTIES = 7
plt.figure(dpi=300, figsize=(7, 3.5))
plt.subplot(R, C, 1)
c = 'County Name'
county_names = d[c].unique()[:NUM_COUNTIES]
num_academic_hospitals = []
# d = df[outcome_keys + hospital_keys]
# d = d.sort_values('New Deaths', ascending=False)
for county in county_names:
num_academ... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
Hospital severity map | counties_json = json.load(open(oj(parentdir, "data", "geojson-counties-fips.json"), "r"))
viz_map.plot_hospital_severity_slider(
df, df_county=df_county,
counties_json=counties_json, dark=False,
filename = oj(parentdir, "results", "severity_map.html")
) | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
hospital contact info gsheet | ks_orig = ['countyFIPS', 'CountyName', 'Total Deaths Hospital', 'Hospital Name', 'CMS Certification Number', 'StateName', 'System Affiliation']
ks_contact = ['Phone Number', 'Hospital Employees', 'Website', 'Number to Call (NTC)', 'Donation Phone Number', 'Donation Email', 'Notes']
def write_to_gsheets_contact(df, ks_... | _____no_output_____ | MIT | modeling/hospital_quickstart.ipynb | Alicegif/covid19-severity-prediction |
import numpy as np
def BSM_characteristic_function(v, x0, T, r, sigma):
cf_value = np.exp(((x0 / T + r - 0.5 * sigma ** 2) * 1j * v
- 0.5 * sigma ** 2 * v ** 2) * T)
return cf_value
def BSM_call_characteristic_function(v,alpha, x0, T, r, sigma):
res=np.exp(-r*T)/((alpha+1j*v)*(alpha+1j*v+1)... | _____no_output_____ | MIT | haokai/Speed_Comparison.ipynb | songqsh/Is20f | |
Raw data for all_snapshots, student at grade 10 and above use DataFrame `raw` | qry = '''
SELECT * from clean.all_snapshots
where grade >= 10;
'''
cur.execute(qry)
rows = cur.fetchall()
# Build dataframe from rows
raw = pd.DataFrame(rows, columns=[name[0] for name in cur.description])
# Make sure student_id is an int
raw['student_lookup'] = raw['student_lookup'].astype('int')
raw.head()
raw =... | _____no_output_____ | MIT | eda/withdraw_reason.ipynb | Karunya-Manoharan/High-school-drop-out-prediction |
Certain districts in certain years seem to not use `withdraw_reason` for grade 12 Zanesville simply lacks data outside of 2015, but other years where there is effectively total missingness on withdraw reason appear to have `graduation_date` listed for most students, and can likely be used as an imputation. | missing_by_district = all_students.join(withdraw_na.groupby(['district','school_year']).agg({'student_lookup':'count'}), rsuffix='_na')
missing_by_district[missing_by_district['student_lookup_na'].notnull()] | _____no_output_____ | MIT | eda/withdraw_reason.ipynb | Karunya-Manoharan/High-school-drop-out-prediction |
Raw data for withdraw reason for students in 12th grade; also includes any student with a `graduate` withdraw reason since it is possible to graduate early use DataFrame `grad_df` | qry = '''
SELECT student_lookup,
grade,
school_year,
withdraw_reason
from clean.all_snapshots
where grade = 12 or withdraw_reason = 'graduate'
order by student_lookup;
'''
cur.execute(qry)
rows = cur.fetchall()
# Build dataframe from rows
grad_df = pd.DataFrame(rows, columns=[name[0] for name in cur.desc... | _____no_output_____ | MIT | eda/withdraw_reason.ipynb | Karunya-Manoharan/High-school-drop-out-prediction |
All (student, school_year) entering grade 10 | # Gets all students entering grade 10 at school year
qry = '''
SELECT distinct student_lookup,
grade,
school_year
from clean.all_snapshots
where grade = 10
order by student_lookup;
'''
cur.execute(qry)
rows = cur.fetchall()
# Build dataframe from rows
df = pd.DataFrame(rows, columns=[name[0] for name in cur.... | _____no_output_____ | MIT | eda/withdraw_reason.ipynb | Karunya-Manoharan/High-school-drop-out-prediction |
Links the future "withdraw reason" in grade 12 to the student entering 10th grade Use DataFrame `grd_10` |
# Left join means it keeps all 10th grade students, even if they didn't appear in the grad_df
grd_10 = pd.merge(df, grad_df, how='left', on='student_lookup')
grd_10
grd_10.columns = ['student_lookup', 'grade_10', 'yr_grade_10', 'grade_12', 'yr_grade_12', 'grade_12_withdraw']
grd_10
grd_10.groupby(['yr_grade_10', 'grad... | _____no_output_____ | MIT | eda/withdraw_reason.ipynb | Karunya-Manoharan/High-school-drop-out-prediction |
Data obtained by the View (sketch.hs_withdraw_info) WITHOUT further deduplication (grade 10) Use DataFrame `hs_w` | qry = '''
SELECT * from sketch.hs_withdraw_info
WHERE grade=10 and entry_year BETWEEN 2007 AND 2013;
'''
cur.execute(qry)
rows = cur.fetchall()
# Build dataframe from rows
hs_w = pd.DataFrame(rows, columns=[name[0] for name in cur.description])
# Make sure student_id is an int
hs_w ['student_lookup'] = hs_w['studen... | _____no_output_____ | MIT | eda/withdraw_reason.ipynb | Karunya-Manoharan/High-school-drop-out-prediction |
Current data retrieval | cur.execute('''
select *
from (
SELECT *, ROW_NUMBER() OVER
(PARTITION BY student_lookup, grade
ORDER BY student_lookup) AS rnum
FROM sketch.hs_withdraw_info hwi) t
where t.rnum = 1
... | _____no_output_____ | MIT | eda/withdraw_reason.ipynb | Karunya-Manoharan/High-school-drop-out-prediction |
Repairing Code AutomaticallySo far, we have discussed how to track failures and how to locate defects in code. Let us now discuss how to _repair_ defects – that is, to correct the code such that the failure no longer occurs. We will discuss how to _repair code automatically_ – by systematically searching through possi... | from bookutils import YouTubeVideo
YouTubeVideo("UJTf7cW0idI") | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
**Prerequisites*** Re-read the [introduction to debugging](Intro_Debugging.ipynb), notably on how to properly fix code.* We make use of automatic fault localization, as discussed in the [chapter on statistical debugging](StatisticalDebugger.ipynb).* We make extensive use of code transformations, as discussed in [the ch... | import bookutils | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
SynopsisTo [use the code provided in this chapter](Importing.ipynb), write```python>>> from debuggingbook.Repairer import ```and then make use of the following features.This chapter provides tools and techniques for automated repair of program code. The `Repairer()` class takes a `RankingDebugger` debugger as input (s... | from StatisticalDebugger import middle
# ignore
from bookutils import print_content
# ignore
import inspect
# ignore
_, first_lineno = inspect.getsourcelines(middle)
middle_source = inspect.getsource(middle)
print_content(middle_source, '.py', start_line_number=first_lineno) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
In most cases, `middle()` just runs fine: | middle(4, 5, 6) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
In some other cases, though, it does not work correctly: | middle(2, 1, 3) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Validated Repairs Now, if we only want a repair that fixes this one given failure, this would be very easy. All we have to do is to replace the entire body by a single statement: | def middle_sort_of_fixed(x, y, z): # type: ignore
return x | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
You will concur that the failure no longer occurs: | middle_sort_of_fixed(2, 1, 3) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
But this, of course, is not the aim of automatic fixes, nor of fixes in general: We want our fixes not only to make the given failure go away, but we also want the resulting code to be _correct_ (which, of course, is a lot harder). Automatic repair techniques therefore assume the existence of a _test suite_ that can ch... | from StatisticalDebugger import MIDDLE_PASSING_TESTCASES, MIDDLE_FAILING_TESTCASES | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The `middle_test()` function fails whenever `middle()` returns an incorrect result: | def middle_test(x: int, y: int, z: int) -> None:
m = middle(x, y, z)
assert m == sorted([x, y, z])[1]
from ExpectError import ExpectError
with ExpectError():
middle_test(2, 1, 3) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Locating the Defect Our next step is to find potential defect locations – that is, those locations in the code our mutations should focus upon. Since we already do have two test suites, we can make use of [statistical debugging](StatisticalDebugger.ipynb) to identify likely faulty locations. Our `OchiaiDebugger` rank... | from StatisticalDebugger import OchiaiDebugger, RankingDebugger
middle_debugger = OchiaiDebugger()
for x, y, z in MIDDLE_PASSING_TESTCASES + MIDDLE_FAILING_TESTCASES:
with middle_debugger:
middle_test(x, y, z) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
We see that the upper half of the `middle()` code is definitely more suspicious: | middle_debugger | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The most suspicious line is: | # ignore
location = middle_debugger.rank()[0]
(func_name, lineno) = location
lines, first_lineno = inspect.getsourcelines(middle)
print(lineno, end="")
print_content(lines[lineno - first_lineno], '.py') | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
with a suspiciousness of: | # ignore
middle_debugger.suspiciousness(location) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Random Code Mutations Our third step in automatic code repair is to _randomly mutate the code_. Specifically, we want to randomly _delete_, _insert_, and _replace_ statements in the program to be repaired. However, simply synthesizing code _from scratch_ is unlikely to yield anything meaningful – the number of combina... | import string
string.ascii_letters
len(string.ascii_letters + '_') * \
len(string.ascii_letters + '_' + string.digits) * \
len(string.ascii_letters + '_' + string.digits) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Hence, we do _not_ synthesize code from scratch, but instead _reuse_ elements from the program to be fixed, hypothesizing that "a program that contains an error in one area likely implements the correct behavior elsewhere" \cite{LeGoues2012}. Furthermore, we do not operate on a _textual_ representation of the program, ... | import ast
import astor
import inspect
from bookutils import print_content, show_ast
def middle_tree() -> ast.AST:
return ast.parse(inspect.getsource(middle))
show_ast(middle_tree()) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
You see that it consists of one function definition (`FunctionDef`) with three `arguments` and two statements – one `If` and one `Return`. Each `If` subtree has three branches – one for the condition (`test`), one for the body to be executed if the condition is true (`body`), and one for the `else` case (`orelse`). Th... | print(ast.dump(middle_tree())) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
This is the path to the first `return` statement: | ast.dump(middle_tree().body[0].body[0].body[0].body[0]) # type: ignore | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Picking Statements For our mutation operators, we want to use statements from the program itself. Hence, we need a means to find those very statements. The `StatementVisitor` class iterates through an AST, adding all statements to its `statements` list it finds in function definitions. To do so, it subclasses the Pyth... | from ast import NodeVisitor
# ignore
from typing import Any, Callable, Optional, Type, Tuple
from typing import Dict, Union, Set, List, cast
class StatementVisitor(NodeVisitor):
"""Visit all statements within function defs in an AST"""
def __init__(self) -> None:
self.statements: List[Tuple[ast.AST, st... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The function `all_statements()` returns all statements in the given AST `tree`. If an `ast` class `tp` is given, it only returns instances of that class. | def all_statements_and_functions(tree: ast.AST,
tp: Optional[Type] = None) -> \
List[Tuple[ast.AST, str]]:
"""
Return a list of pairs (`statement`, `function`) for all statements in `tree`.
If `tp` is given, return only statements of that cl... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Here are all the `return` statements in `middle()`: | all_statements(middle_tree(), ast.Return)
all_statements_and_functions(middle_tree(), ast.If) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
We can randomly pick an element: | import random
random_node = random.choice(all_statements(middle_tree()))
astor.to_source(random_node) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Mutating StatementsThe main part in mutation, however, is to actually mutate the code of the program under test. To this end, we introduce a `StatementMutator` class – a subclass of `NodeTransformer`, described in the [official Python `ast` reference](http://docs.python.org/3/library/ast). The constructor provides var... | from ast import NodeTransformer
import copy
class StatementMutator(NodeTransformer):
"""Mutate statements in an AST for automated repair."""
def __init__(self,
suspiciousness_func:
Optional[Callable[[Tuple[Callable, int]], float]] = None,
source: Optiona... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Choosing Suspicious Statements to MutateWe start with deciding which AST nodes to mutate. The method `node_suspiciousness()` returns the suspiciousness for a given node, by invoking the suspiciousness function `suspiciousness_func` given during initialization. | import warnings
class StatementMutator(StatementMutator):
def node_suspiciousness(self, stmt: ast.AST, func_name: str) -> float:
if not hasattr(stmt, 'lineno'):
warnings.warn(f"{self.format_node(stmt)}: Expected line number")
return 0.0
suspiciousness = self.suspiciousness_f... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The method `node_to_be_mutated()` picks a node (statement) to be mutated. It determines the suspiciousness of all statements, and invokes `random.choices()`, using the suspiciousness as weight. Unsuspicious statements (with zero weight) will not be chosen. | class StatementMutator(StatementMutator):
def node_to_be_mutated(self, tree: ast.AST) -> ast.AST:
statements = all_statements_and_functions(tree)
assert len(statements) > 0, "No statements"
weights = [self.node_suspiciousness(stmt, func_name)
for stmt, func_name in state... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Choosing a Mutation Method The method `visit()` is invoked on all nodes. For nodes marked with a `mutate_me` attribute, it randomly chooses a mutation method (`choose_op()`) and then invokes it on the node.According to the rules of `NodeTransformer`, the mutation method can return* a new node or a list of nodes, repla... | import re
RE_SPACE = re.compile(r'[ \t\n]+')
class StatementMutator(StatementMutator):
def choose_op(self) -> Callable:
return random.choice([self.insert, self.swap, self.delete])
def visit(self, node: ast.AST) -> ast.AST:
super().visit(node) # Visits (and transforms?) children
if not... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Swapping StatementsOur first mutator is `swap()`, which replaces the current node NODE by a random node found in `source` (using a newly defined `choose_statement()`).As a rule of thumb, we try to avoid inserting entire subtrees with all attached statements; and try to respect only the first line of a node. If the new... | class StatementMutator(StatementMutator):
def choose_statement(self) -> ast.AST:
return copy.deepcopy(random.choice(self.source))
class StatementMutator(StatementMutator):
def swap(self, node: ast.AST) -> ast.AST:
"""Replace `node` with a random node from `source`"""
new_node = self.choo... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Inserting StatementsOur next mutator is `insert()`, which randomly chooses some node from `source` and inserts it after the current node NODE. (If NODE is a `return` statement, then we insert the new node _before_ NODE.)If the statement to be inserted has the form```pythonif P: BODY```we only insert the "header" of... | class StatementMutator(StatementMutator):
def insert(self, node: ast.AST) -> Union[ast.AST, List[ast.AST]]:
"""Insert a random node from `source` after `node`"""
new_node = self.choose_statement()
if isinstance(new_node, ast.stmt) and hasattr(new_node, 'body'):
# Inserting `if P... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Deleting StatementsOur last mutator is `delete()`, which deletes the current node NODE. The standard case is to replace NODE by a `pass` statement.If the statement to be deleted has the form```pythonif P: BODY```we only delete the "header" of the `if`, resulting in```pythonBODY```Again, this applies to all construc... | class StatementMutator(StatementMutator):
def delete(self, node: ast.AST) -> None:
"""Delete `node`."""
branches = [attr for attr in ['body', 'orelse', 'finalbody']
if hasattr(node, attr) and getattr(node, attr)]
if branches:
# Replace `if P: S` by `S`
... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Indeed, Python's `compile()` will fail if any of the bodies is an empty list. Also, it leaves us a statement that can be evolved further. HelpersFor logging purposes, we introduce a helper function `format_node()` that returns a short string representation of the node. | class StatementMutator(StatementMutator):
NODE_MAX_LENGTH = 20
def format_node(self, node: ast.AST) -> str:
"""Return a string representation for `node`."""
if node is None:
return "None"
if isinstance(node, list):
return "; ".join(self.format_node(elem) for ele... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
All TogetherLet us now create the main entry point, which is `mutate()`. It picks the node to be mutated and marks it with a `mutate_me` attribute. By calling `visit()`, it then sets off the `NodeTransformer` transformation. | class StatementMutator(StatementMutator):
def mutate(self, tree: ast.AST) -> ast.AST:
"""Mutate the given AST `tree` in place. Return mutated tree."""
assert isinstance(tree, ast.AST)
tree = copy.deepcopy(tree)
if not self.source:
self.source = all_statements(tree)
... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Here are a number of transformations applied by `StatementMutator`: | mutator = StatementMutator(log=True)
for i in range(10):
new_tree = mutator.mutate(middle_tree()) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
This is the effect of the last mutator applied on `middle`: | print_content(astor.to_source(new_tree), '.py') | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
FitnessNow that we can apply random mutations to code, let us find out how good these mutations are. Given our test suites for `middle`, we can check for a given code candidate how many of the previously passing test cases it passes, and how many of the failing test cases it passes. The more tests pass, the higher the... | WEIGHT_PASSING = 0.99
WEIGHT_FAILING = 0.01
def middle_fitness(tree: ast.AST) -> float:
"""Compute fitness of a `middle()` candidate given in `tree`"""
original_middle = middle
try:
code = compile(tree, '<fitness>', 'exec')
except ValueError:
return 0 # Compilation error
exec(code... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Our faulty `middle()` program has a fitness of `WEIGHT_PASSING` (99%), because it passes all the passing tests (but none of the failing ones). | middle_fitness(middle_tree()) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Our "sort of fixed" version of `middle()` gets a much lower fitness: | middle_fitness(ast.parse("def middle(x, y, z): return x")) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
In the [chapter on statistical debugging](StatisticalDebugger), we also defined a fixed version of `middle()`. This gets a fitness of 1.0, passing all tests. (We won't use this fixed version for automated repairs.) | from StatisticalDebugger import middle_fixed
middle_fixed_source = \
inspect.getsource(middle_fixed).replace('middle_fixed', 'middle').strip()
middle_fitness(ast.parse(middle_fixed_source)) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
PopulationWe now set up a _population_ of fix candidates to evolve over time. A higher population size will yield more candidates to check, but also need more time to test; a lower population size will yield fewer candidates, but allow for more evolution steps. We choose a population size of 40 (from \cite{LeGoues20... | POPULATION_SIZE = 40
middle_mutator = StatementMutator()
MIDDLE_POPULATION = [middle_tree()] + \
[middle_mutator.mutate(middle_tree()) for i in range(POPULATION_SIZE - 1)] | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
We sort the fix candidates according to their fitness. This actually runs all tests on all candidates. | MIDDLE_POPULATION.sort(key=middle_fitness, reverse=True) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The candidate with the highest fitness is still our original (faulty) `middle()` code: | print(astor.to_source(MIDDLE_POPULATION[0]),
middle_fitness(MIDDLE_POPULATION[0])) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
At the other end of the spectrum, the candidate with the lowest fitness has some vital functionality removed: | print(astor.to_source(MIDDLE_POPULATION[-1]),
middle_fitness(MIDDLE_POPULATION[-1])) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
EvolutionTo evolve our population of candidates, we fill up the population with mutations created from the population, using a `StatementMutator` as described above to create these mutations. Then we reduce the population to its original size, keeping the fittest candidates. | def evolve_middle() -> None:
global MIDDLE_POPULATION
source = all_statements(middle_tree())
mutator = StatementMutator(source=source)
n = len(MIDDLE_POPULATION)
offspring: List[ast.AST] = []
while len(offspring) < n:
parent = random.choice(MIDDLE_POPULATION)
offspring.append(... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
This is what happens when evolving our population for the first time; the original source is still our best candidate. | evolve_middle()
tree = MIDDLE_POPULATION[0]
print(astor.to_source(tree), middle_fitness(tree)) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
However, nothing keeps us from evolving for a few generations more... | for i in range(50):
evolve_middle()
best_middle_tree = MIDDLE_POPULATION[0]
fitness = middle_fitness(best_middle_tree)
print(f"\rIteration {i:2}: fitness = {fitness} ", end="")
if fitness >= 1.0:
break | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Success! We find a candidate that actually passes all tests, including the failing ones. Here is the candidate: | print_content(astor.to_source(best_middle_tree), '.py', start_line_number=1) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
... and yes, it passes all tests: | original_middle = middle
code = compile(best_middle_tree, '<string>', 'exec')
exec(code, globals())
for x, y, z in MIDDLE_PASSING_TESTCASES + MIDDLE_FAILING_TESTCASES:
middle_test(x, y, z)
middle = original_middle | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
As the code is already validated by hundreds of test cases, it is very valuable for the programmer. Even if the programmer decides not to use the code as is, the location gives very strong hints on which code to examine and where to apply a fix. However, a closer look at our fix candidate shows that there is some amoun... | quiz("Some of the lines in our fix candidate are redundant. Which are these?",
[
"Line 3: `if x < y`",
"Line 4: `if x > z`",
"Line 5: `return x`",
"Line 13: `return z`"
], '[eval(chr(100 - x)) for x in [49, 50]]') | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Simplifying As demonstrated in the chapter on [reducing failure-inducing inputs](DeltaDebugger.ipynb), we can use delta debugging on code to get rid of these superfluous statements. The trick for simplification is to have the test function (`test_middle_lines()`) declare a fitness of 1.0 as a "failure". Delta debuggin... | from DeltaDebugger import DeltaDebugger
middle_lines = astor.to_source(best_middle_tree).strip().split('\n')
def test_middle_lines(lines: List[str]) -> None:
source = "\n".join(lines)
tree = ast.parse(source)
assert middle_fitness(tree) < 1.0 # "Fail" only while fitness is 1.0
with DeltaDebugger() as dd:
... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Success! Delta Debugging has eliminated the superfluous statements. We can present the difference to the original as a patch: | original_source = astor.to_source(ast.parse(middle_source)) # normalize
from ChangeDebugger import diff, print_patch # minor dependency
for patch in diff(original_source, repaired_source):
print_patch(patch) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
We can present this patch to the programmer, who will then immediately know what to fix in the `middle()` code. CrossoverSo far, we have only applied one kind of genetic operators – mutation. There is a second one, though, also inspired by natural selection. The *crossover* operation mutates two strands of genes, as i... | def p1(): # type: ignore
a = 1
b = 2
c = 3
def p2(): # type: ignore
x = 1
y = 2
z = 3 | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Then a crossover operation would produce one child with a body```pythona = 1y = 2z = 3```and another child with a body```pythonx = 1b = 2c = 3``` We can easily implement this in a `CrossoverOperator` class in a method `cross_bodies()`. | class CrossoverOperator:
"""A class for performing statement crossover of Python programs"""
def __init__(self, log: bool = False):
"""Constructor. If `log` is set, turn on logging."""
self.log = log
def cross_bodies(self, body_1: List[ast.AST], body_2: List[ast.AST]) -> \
Tuple[Li... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Here's the `CrossoverOperatorMutator` applied on `p1` and `p2`: | tree_p1: ast.Module = ast.parse(inspect.getsource(p1))
tree_p2: ast.Module = ast.parse(inspect.getsource(p2))
body_p1 = tree_p1.body[0].body # type: ignore
body_p2 = tree_p2.body[0].body # type: ignore
body_p1
crosser = CrossoverOperator()
tree_p1.body[0].body, tree_p2.body[0].body = crosser.cross_bodies(body_p1, bod... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Applying Crossover on ProgramsApplying the crossover operation on arbitrary programs is a bit more complex, though. We first have to _find_ lists of statements that we a actually can cross over. The `can_cross()` method returns True if we have a list of statements that we can cross. Python modules and classes are excl... | class CrossoverOperator(CrossoverOperator):
# In modules and class defs, the ordering of elements does not matter (much)
SKIP_LIST = {ast.Module, ast.ClassDef}
def can_cross(self, tree: ast.AST, body_attr: str = 'body') -> bool:
if any(isinstance(tree, cls) for cls in self.SKIP_LIST):
r... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Here comes our method `crossover_attr()` which searches for crossover possibilities. It takes to ASTs `t1` and `t2` and an attribute (typically `'body'`) and retrieves the attribute lists $l_1$ (from `t1.`) and $l_2$ (from `t2.`).If $l_1$ and $l_2$ can be crossed, it crosses them, and is done. Otherwise* If there is a ... | class CrossoverOperator(CrossoverOperator):
def crossover_attr(self, t1: ast.AST, t2: ast.AST, body_attr: str) -> bool:
"""
Crossover the bodies `body_attr` of two trees `t1` and `t2`.
Return True if successful.
"""
assert isinstance(t1, ast.AST)
assert isinstance(t2,... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
We have a special case for `if` nodes, where we can cross their body and `else` branches. | class CrossoverOperator(CrossoverOperator):
def crossover_branches(self, t1: ast.AST, t2: ast.AST) -> bool:
"""Special case:
`t1` = `if P: S1 else: S2` x `t2` = `if P': S1' else: S2'`
becomes
`t1` = `if P: S2' else: S1'` and `t2` = `if P': S2 else: S1`
Returns True if success... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The method `crossover()` is the main entry point. It checks for the special `if` case as described above; if not, it searches for possible crossover points. It raises `CrossoverError` if not successful. | class CrossoverOperator(CrossoverOperator):
def crossover(self, t1: ast.AST, t2: ast.AST) -> Tuple[ast.AST, ast.AST]:
"""Do a crossover of ASTs `t1` and `t2`.
Raises `CrossoverError` if no crossover is found."""
assert isinstance(t1, ast.AST)
assert isinstance(t2, ast.AST)
f... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
End of Excursion Crossover in Action Let us put our `CrossoverOperator` in action. Here is a test case for crossover, involving more deeply nested structures: | def p1(): # type: ignore
if True:
print(1)
print(2)
print(3)
def p2(): # type: ignore
if True:
print(a)
print(b)
else:
print(c)
print(d) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
We invoke the `crossover()` method with two ASTs from `p1` and `p2`: | crossover = CrossoverOperator()
tree_p1 = ast.parse(inspect.getsource(p1))
tree_p2 = ast.parse(inspect.getsource(p2))
crossover.crossover(tree_p1, tree_p2); | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Here is the crossed offspring, mixing statement lists of `p1` and `p2`: | print_content(astor.to_source(tree_p1), '.py')
print_content(astor.to_source(tree_p2), '.py') | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Here is our special case for `if` nodes in action, crossing our `middle()` tree with `p2`. | middle_t1, middle_t2 = crossover.crossover(middle_tree(),
ast.parse(inspect.getsource(p2))) | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
We see how the resulting offspring encompasses elements of both sources: | print_content(astor.to_source(middle_t1), '.py')
print_content(astor.to_source(middle_t2), '.py') | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
A Repairer ClassSo far, we have applied all our techniques on the `middle()` program only. Let us now create a `Repairer` class that applies automatic program repair on arbitrary Python programs. The idea is that you can apply it on some statistical debugger, for which you have gathered passing and failing test cases,... | from StackInspector import StackInspector # minor dependency
class Repairer(StackInspector):
"""A class for automatic repair of Python programs"""
def __init__(self, debugger: RankingDebugger, *,
targets: Optional[List[Any]] = None,
sources: Optional[List[Any]] = None,
... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
When we access or execute functions, we ault_functionso \todo{What? -- BM} so in the caller's environment, not ours. The `caller_globals()` method from `StackInspector` acts as replacement for `globals()`. Helper FunctionsThe constructor uses a number of helper functions to create its environment. | class Repairer(Repairer):
def getsource(self, item: Union[str, Any]) -> str:
"""Get the source for `item`. Can also be a string."""
if isinstance(item, str):
item = self.globals[item]
return inspect.getsource(item)
class Repairer(Repairer):
def default_functions(self) -> Lis... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Running TestsNow that we have set the environment for `Repairer`, we can implement one step of automatic repair after the other. The method `run_test_set()` runs the given `test_set` (`DifferenceDebugger.PASS` or `DifferenceDebugger.FAIL`), returning the number of passed tests. If `validate` is set, it checks whether ... | class Repairer(Repairer):
def run_test_set(self, test_set: str, validate: bool = False) -> int:
"""
Run given `test_set`
(`DifferenceDebugger.PASS` or `DifferenceDebugger.FAIL`).
If `validate` is set, check expectations.
Return number of passed tests.
"""
pass... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Here is how we use `run_tests_set()`: | repairer = Repairer(middle_debugger)
assert repairer.run_test_set(middle_debugger.PASS) == \
len(MIDDLE_PASSING_TESTCASES)
assert repairer.run_test_set(middle_debugger.FAIL) == 0 | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The method `run_tests()` runs passing and failing tests, weighing the passed testcases to obtain the overall fitness. | class Repairer(Repairer):
def weight(self, test_set: str) -> float:
"""
Return the weight of `test_set`
(`DifferenceDebugger.PASS` or `DifferenceDebugger.FAIL`).
"""
return {
self.debugger.PASS: WEIGHT_PASSING,
self.debugger.FAIL: WEIGHT_FAILING
... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
The method `validate()` ensures the observed tests can be adequately reproduced. | class Repairer(Repairer):
def validate(self) -> None:
fitness = self.run_tests(validate=True)
assert fitness == self.weight(self.debugger.PASS)
repairer = Repairer(middle_debugger)
repairer.validate() | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
(Re)defining FunctionsOur `run_tests()` methods above do not yet redefine the function to be repaired. This is done by the `fitness()` function, which compiles and defines the given repair candidate `tree` before testing it. It caches and returns the fitness. | class Repairer(Repairer):
def fitness(self, tree: ast.AST) -> float:
"""Test `tree`, returning its fitness"""
key = cast(str, ast.dump(tree))
if key in self.fitness_cache:
return self.fitness_cache[key]
# Save defs
original_defs: Dict[str, Any] = {}
for n... | _____no_output_____ | MIT | notebooks/Repairer.ipynb | bjrnmath/debuggingbook |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.