[LNT] more pep8 code style fixes

[danilaml]

Summary

PEP8 code style issues found by pycodestyle, ignoring "line to long: errors (IMHO it should be fine to set it to something less restrictive project-wide, like 100 or even 120).

[MatzeB]

LGTM.

Out of interest: What version of pycodestyle do you use? I currently seem to have version 2.4.0 here while I do see most of the issues, for example I don't see a message about the regex functions not using raw strings.

[danilaml]

I'm also using pycodestyle 2.4.0. The error/warning was not about raw strings in regexps, rather illegal escape sequences, i.e.:

.\lnt\server\db\regression.py:58:20: W605 invalid escape sequence '\d'

I think using raw strings is better than using something like \\d.

Btw, I doubt that I can commit to llvm repo, so I need somebody to commit this for me. Thanks!

[danilaml]

ping

[kristof.beyls]

In D51862#1229129, @danilaml wrote:

I'm also using pycodestyle 2.4.0. The error/warning was not about raw strings in regexps, rather illegal escape sequences, i.e.:

.\lnt\server\db\regression.py:58:20: W605 invalid escape sequence '\d'

I think using raw strings is better than using something like \\d.

Btw, I doubt that I can commit to llvm repo, so I need somebody to commit this for me. Thanks!

I've just committed this for you.
If you want, you should be able to get commit access, see https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access .

Thanks!

Kristof

lnt/trunk/lnt/server/db/migrations/upgrade_16_to_17.py

 """This upgrade adds a index on the RegressionIndicator.regression_id because we often lookup
 indicators by regression.
 """
 
 import sqlalchemy
 from sqlalchemy import Index, select
 from lnt.server.db.migrations.util import introspect_table
 from lnt.util import logger
 
+
 def _mk_index_on(engine, ts_name):
     fc_table = introspect_table(engine, "{}_RegressionIndicator".format(ts_name))
 
     fast_fc_lookup = Index('idx_fast_ri_lookup', fc_table.c.RegressionID)
     try:
         fast_fc_lookup.create(engine)
     except (sqlalchemy.exc.OperationalError, sqlalchemy.exc.ProgrammingError) as e:
         logger.warning("Skipping index creation on {}, because of {}".format(fc_table.name, e.message))

lnt/trunk/lnt/server/db/migrations/util.py

def introspect_table(engine, name, autoload=True):
 
     Used to make a Table object from something already in the DB."""
     md = sqlalchemy.MetaData(engine)
     target_table = sqlalchemy.Table(name, md, autoload=autoload)
     return target_table
 
 
 def rename_table(engine, old_name, new_name):
-    """Rename table wiht name \p old_name to \p new_name."""
+    """Rename table with name `old_name` to `new_name`."""
     # sqlite refuses to rename "BAR" to "bar" so we go
     # "BAR" -> "BAR_x" -> "bar"
     rename = _RenameTable(old_name, old_name+"_x")
     rename.execute(bind=engine)
     rename = _RenameTable(old_name+"_x", new_name)
     rename.execute(bind=engine)

lnt/trunk/lnt/server/db/regression.py

for fc_id in field_changes:
         ri1 = ts.RegressionIndicator(regression, fc)
         session.add(ri1)
     rebuild_title(session, ts, regression)
     session.commit()
     return regression
 
 
 def rebuild_title(session, ts, regression):
-    """Update the title of a regresson."""
-    if re.match("Regression of \d+ benchmarks.*", regression.title):
+    """Update the title of a regression."""
+    if re.match(r"Regression of \d+ benchmarks.*", regression.title):
         old_changes = session.query(ts.RegressionIndicator) \
             .filter(ts.RegressionIndicator.regression_id == regression.id) \
             .all()
         new_size = len(old_changes)
         benchmarks = set()
         for ri in old_changes:
             fc = ri.field_change
             benchmarks.add(shortname(fc.test.name))
         FMT = "Regression of {} benchmarks: {}"
         title = FMT.format(new_size, ', '.join(benchmarks))
         # Crop long titles.
         title = (title[:120] + '...') if len(title) > 120 else title
         regression.title = title
     return regression
 
 
 def get_all_orders_for_machine(session, ts, machine):
-    """Get all the oredrs for this sa machine."""
+    """Get all the orders for this sa machine."""
     return session.query(ts.Order) \
         .join(ts.Run) \
         .filter(ts.Run.machine_id == machine) \
         .order_by(asc(ts.Order.llvm_project_revision)) \
         .all()
 
 
 def get_ris(session, ts, regression_id):

lnt/trunk/lnt/server/db/rules/rule_update_fixed_regressions.py

def impacts(session, ts, run_id, regression):
     # type: (Session, TestSuiteDB, int, object) -> bool
     """Does this run have a chance of impacting this regression?
 
     This is just to prevent doing a full comparison, so we don't have
     to be toally accurate. For now, compare machines."""
     machine_id = session.query(ts.Run.machine_id).filter(ts.Run.id == run_id).scalar()
 
     regression_machines = [x[0] for x in session.query(ts.FieldChange.machine_id)
                            .join(ts.RegressionIndicator)
                            .filter(ts.RegressionIndicator.regression_id == regression.id)
                            .all()]
 
     regression_machines_set = set(regression_machines)
     return machine_id in regression_machines_set
 
 
 def age_out_oldest_regressions(session, ts, num_to_keep=50):
     # type: (Session, TestSuiteDB, int) -> int
     """Find the oldest regressions that are still in the detected state,
     and age them out.  This is needed when regressions are not manually
     acknowledged, regression analysis can grow unbounded.
-    
     :param session: db session
     :param ts: testsuite
     :param num_to_keep: the number of newest regressions to keep in the detected state.
     :returns: the number of regressions changed.
     """
 
     regression_orders = session.query(ts.Regression.id, ts.FieldChange.end_order_id) \
         .filter(ts.Regression.state == RegressionState.DETECTED) \

lnt/trunk/lnt/server/reporting/summaryreport.py

def _build_final_data_tables(self):
                 items = self.grouped_table[group_key] = self.grouped_table.get(
                     group_key, [])
 
                 items.append((test_name, arch,
                               normalized_value.getvalue()))
                 continue
 
             # Add to the single file stack.
-            stage_name, = re.match('Single File \((.*)\)', test_name).groups()
+            stage_name, = re.match(r'Single File \((.*)\)', test_name).groups()
             try:
                 stack_index = self.single_file_stage_order.index(stage_name)
             except ValueError:
                 stack_index = None
 
             # If we don't have an index for this stage, ignore it.
             if stack_index is None:
                 continue

lnt/trunk/lnt/server/ui/api.py

def common_fields_factory():
     }
     return common_data
 
 
 def add_common_fields(to_update):
     """Update a dict with the common fields."""
     to_update.update(common_fields_factory())
 
+
 class Fields(Resource):
     """List all the fields in the test suite."""
     method_decorators = [in_db]
 
     @staticmethod
     def get():
         ts = request.get_testsuite()
 
         result = common_fields_factory()
         result['fields'] = [{'column_id': i, 'column_name': f.column.name}
                             for i, f in enumerate(ts.sample_fields)]
 
         return result
 
+
 class Tests(Resource):
     """List all the tests in the test suite."""
     method_decorators = [in_db]
 
     @staticmethod
     def get():
         ts = request.get_testsuite()
 
         result = common_fields_factory()
         tests = request.session.query(ts.Test).all()
         result['tests'] = [t.__json__() for t in tests]
 
         return result
 
+
 class Machines(Resource):
     """List all the machines and give summary information."""
     method_decorators = [in_db]
 
     @staticmethod
     def get():
         ts = request.get_testsuite()
         session = request.session

lnt/trunk/lnt/testing/__init__.py

if 'run' not in data:
         logger.info(pprint.pformat(data))
         raise ValueError("No 'run' section in submission")
     if 'machine' not in data:
         raise ValueError("No 'machine' section in submission")
     if 'tests' not in data:
         raise ValueError("No 'tests' section in submission")
 
     run = data['run']
-    if not 'start_time' in run:
+    if 'start_time' not in run:
         time = datetime.datetime.utcnow().replace(microsecond=0).isoformat()
         run['start_time'] = time
         run['end_time'] = time
-    elif not 'end_time' in run:
+    elif 'end_time' not in run:
         run['end_time'] = run['start_time']
 
     return data
 
 
 __all__ = ['Report', 'Machine', 'Run', 'TestSamples']