Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Nicolas MAILLET
rpg
Commits
99b0a848
Commit
99b0a848
authored
Mar 07, 2019
by
Nicolas MAILLET
Browse files
Modify argument names of rule
parent
9677a774
Changes
2
Hide whitespace changes
Inline
Side-by-side
rpg/rule.py
View file @
99b0a848
...
...
@@ -33,22 +33,22 @@ class Rule:
"""Definition of a principal rule defining where a cleavage occurs.
:param index: position where to look for a specific amino acid
:param
letter
: amino acid to look for
:param c
ut: cut
or not at this position on this amino acid
:param pos: c
ut
before (0) of after (1) amino acid. -1 for unused value
:param
amino_acid
: amino acid to look for
:param c
leavage: cleavage
or not at this position on this amino acid
:param pos: c
leavage
before (0) of after (1) amino acid. -1 for unused value
:type index: signed int
:type
letter
: char
:type c
ut
: bool
:type
amino_acid
: char
:type c
leavage
: bool
:type pos: int
:var rules: additional sub-rules of this rule
:vartype rules: list(:py:class:`Rule`)
"""
def
__init__
(
self
,
index
,
letter
,
cut
,
pos
):
def
__init__
(
self
,
index
,
amino_acid
,
cleavage
,
pos
):
self
.
index
=
index
# where to look for this aa?
self
.
letter
=
letter
# the aa
self
.
c
ut
=
cut
# if letter
detected at index, c
ut
or not?
self
.
pos
=
pos
# c
ut
before (0) of after (1)
letter
(-1 if not used)
self
.
amino_acid
=
amino_acid
# the aa
self
.
c
leavage
=
cleavage
# if amino_acid
detected at index, c
leavage
or not?
self
.
pos
=
pos
# c
leavage
before (0) of after (1)
amino_acid
(-1 if not used)
self
.
rules
=
[]
# List of additional rules
# self representation for print
...
...
@@ -60,10 +60,10 @@ class Rule:
ret
+=
"index="
+
str
(
self
.
index
)
+
"
\n
"
for
_
in
range
(
lvl
):
ret
+=
"
\t
"
ret
+=
"amino_acid="
+
str
(
self
.
letter
)
+
"
\n
"
ret
+=
"amino_acid="
+
str
(
self
.
amino_acid
)
+
"
\n
"
for
_
in
range
(
lvl
):
ret
+=
"
\t
"
ret
+=
"cleavage="
+
str
(
self
.
c
ut
)
+
"
\n
"
ret
+=
"cleavage="
+
str
(
self
.
c
leavage
)
+
"
\n
"
for
_
in
range
(
lvl
):
ret
+=
"
\t
"
ret
+=
"position="
+
str
(
self
.
pos
)
+
"
\n
"
...
...
@@ -84,7 +84,7 @@ class Rule:
def
equ
(
self
,
other
):
"""Test equality with another rule **without taking into
account sub-rules nor `c
ut
`**.
account sub-rules nor `c
leavage
`**.
:param other: rule to compare with
:type other: :py:class:`Rule`
...
...
@@ -94,12 +94,12 @@ class Rule:
:note: use '==' for complete equality including sub-rules.
"""
return
(
self
.
index
==
other
.
index
)
and
(
self
.
letter
==
other
.
letter
)
\
return
(
self
.
index
==
other
.
index
)
and
(
self
.
amino_acid
==
other
.
amino_acid
)
\
and
(
self
.
pos
==
other
.
pos
)
def
contains
(
self
,
other
):
"""Test if another rule is contains in sub-rules **without
taking into account sub-rules nor `c
ut
`** and return the
taking into account sub-rules nor `c
leavage
`** and return the
sub-rule if founded.
:param other: rule to compare with
...
...
@@ -116,7 +116,7 @@ class Rule:
def
contains_any_level
(
self
,
other
,
ret
=
False
):
"""Test if another rule is contains within **without taking into
account sub-rules nor `c
ut
`** no matter what level.
account sub-rules nor `c
leavage
`** no matter what level.
:param other: rule to compare with
:type other: :py:class:`Rule`
...
...
@@ -139,8 +139,8 @@ class Rule:
:return: header of this rule in Python
:rtype: str
"""
return
'rule.Rule('
+
str
(
self
.
index
)
+
', "'
+
str
(
self
.
letter
)
+
\
'", '
+
str
(
self
.
c
ut
)
+
', '
+
str
(
self
.
pos
)
+
')'
return
'rule.Rule('
+
str
(
self
.
index
)
+
', "'
+
str
(
self
.
amino_acid
)
+
\
'", '
+
str
(
self
.
c
leavage
)
+
', '
+
str
(
self
.
pos
)
+
')'
def
get_all_headers
(
self
):
"""Format header of the rule and sub-rules in Python.
...
...
@@ -174,14 +174,14 @@ class Rule:
ret_name
=
str
(
self
.
pos
).
upper
()
else
:
ret_name
=
prev_name
# Should we add the new
letter
of the rule before or
# Should we add the new
amino_acid
of the rule before or
# after the prev_name?
if
self
.
index
>
0
:
ret_name
+=
self
.
letter
ret_name
+=
self
.
amino_acid
elif
not
ret_name
:
ret_name
=
self
.
letter
ret_name
=
self
.
amino_acid
else
:
ret_name
=
self
.
letter
+
"_"
+
ret_name
ret_name
=
self
.
amino_acid
+
"_"
+
ret_name
# Add the index on the name to avoid same name
if
self
.
index
!=
0
:
ret_name
+=
str
(
self
.
index
)
...
...
@@ -191,23 +191,23 @@ class Rule:
ret_com
=
prev_com
# Modify the prev_com if needed
if
prev_com
!=
" # "
:
if
self
.
c
ut
:
if
self
.
c
leavage
:
ret_com
=
ret_com
.
replace
(
"Never"
,
"Always"
)
else
:
ret_com
=
ret_com
.
replace
(
"Always"
,
"Never"
)
# Order of
letter
# Order of
amino_acid
if
self
.
index
>
0
:
ret_com
=
ret_com
.
replace
(
", except..."
,
", followed by "
+
self
.
letter
+
", except..."
)
self
.
amino_acid
+
", except..."
)
else
:
ret_com
=
ret_com
.
replace
(
", except..."
,
", preceded by "
+
self
.
letter
+
", except..."
)
self
.
amino_acid
+
", except..."
)
# First comment
else
:
ret_com
+=
"Always"
if
self
.
c
ut
else
"Never"
ret_com
+=
"Always"
if
self
.
c
leavage
else
"Never"
ret_com
+=
" cleaves "
ret_com
+=
"after "
if
self
.
pos
>
0
else
"before "
ret_com
+=
self
.
letter
ret_com
+=
self
.
amino_acid
ret_com
+=
", except..."
# Full line to write
ret_total
=
ret_name
+
" = "
+
self
.
get_header
()
+
ret_com
...
...
@@ -297,7 +297,7 @@ def check_rule(exprule):
core
.
handle_errors
(
to_print
+
"^"
,
2
)
ret
=
""
# No
letter after a letter
(all UPPER except or)
# No
amino_acid after a amino_acid
(all UPPER except or)
if
ret
!=
""
:
res
=
re
.
search
(
r
"[A-Z][A-Z]"
,
clean_exprule
)
if
res
:
...
...
@@ -471,7 +471,7 @@ def add_rule(rules_list, a_rule):
# Flag this conflicting rules
to_remove
.
add
(
k
)
# Edit the rule
a_rule
.
c
ut
=
not
a_rule
.
c
ut
a_rule
.
c
leavage
=
not
a_rule
.
c
leavage
# Add it to the sub-rule that already exist
# without modifying it
add_rule
(
i
.
rules
,
a_rule
)
...
...
@@ -499,18 +499,18 @@ def create_rules(all_rules):
# All rules correctly added, ready to be printed
correct_rules
=
[]
# handle " or " keyword and split it into several rules
for
tmp_rule
,
tmp_c
ut
in
list
(
all_rules
.
items
()):
for
tmp_rule
,
tmp_c
leavage
in
list
(
all_rules
.
items
()):
# Remove this rule from main list
all_rules
.
pop
(
tmp_rule
)
# Split this rule on " or "
tmp_rules
=
split_complex_rule
(
tmp_rule
)
# Add all the cleaned rules corresponding
for
rul
in
tmp_rules
:
all_rules
[
rul
]
=
tmp_c
ut
all_rules
[
rul
]
=
tmp_c
leavage
# handle multiple "," in one parenthesis
#so we got only ONE "," per rule
for
tmp_rule
,
tmp_c
ut
in
list
(
all_rules
.
items
()):
for
tmp_rule
,
tmp_c
leavage
in
list
(
all_rules
.
items
()):
if
tmp_rule
.
count
(
","
)
>
1
:
# Remove this complex rule
all_rules
.
pop
(
tmp_rule
)
...
...
@@ -518,18 +518,18 @@ def create_rules(all_rules):
# Beginning of the complex rule
begpos
=
tmp_rule
.
find
(
"(,"
)
# Should be like ...('
beg_c
ut
=
tmp_rule
[:
begpos
+
2
]
beg_c
leavage
=
tmp_rule
[:
begpos
+
2
]
# Should be like ...(
beg_no_c
ut
=
tmp_rule
[:
begpos
+
1
]
beg_no_c
leavage
=
tmp_rule
[:
begpos
+
1
]
# Ending of the complex rule
endpos
=
tmp_rule
.
find
(
",)"
)
# Should be like ...')
end_c
ut
=
tmp_rule
[
endpos
:]
end_c
leavage
=
tmp_rule
[
endpos
:]
# Should be like ...)
end_no_c
ut
=
tmp_rule
[
endpos
+
1
:]
end_no_c
leavage
=
tmp_rule
[
endpos
+
1
:]
# Add rules
all_rules
[
beg_c
ut
+
tmp_rule
[
begpos
+
2
]
+
end_no_c
ut
]
=
tmp_c
ut
all_rules
[
beg_no_c
ut
+
tmp_rule
[
begpos
+
2
]
+
end_c
ut
]
=
tmp_c
ut
all_rules
[
beg_c
leavage
+
tmp_rule
[
begpos
+
2
]
+
end_no_c
leavage
]
=
tmp_c
leavage
all_rules
[
beg_no_c
leavage
+
tmp_rule
[
begpos
+
2
]
+
end_c
leavage
]
=
tmp_c
leavage
# Sort rules, smaller first
all_rules_keys
=
list
(
all_rules
.
keys
())
...
...
@@ -561,23 +561,23 @@ def create_rules(all_rules):
# Create rule for the cleaving zone
if
dict_rule
[
0
][
0
]
==
","
:
# Before
letter
# Before
amino_acid
cleaving_zone
=
Rule
(
0
,
str
(
dict_rule
[
0
][
1
]),
all_rules
[
rul
],
0
)
else
:
# After
letter
# After
amino_acid
cleaving_zone
=
Rule
(
0
,
str
(
dict_rule
[
0
][
0
]),
all_rules
[
rul
],
1
)
# Is there sub-rule?
if
len
(
dict_rule
)
>
1
:
# Reverse the c
ut
ting boolean
cleaving_zone
.
c
ut
=
not
cleaving_zone
.
c
ut
# Reverse the c
leavage
ting boolean
cleaving_zone
.
c
leavage
=
not
cleaving_zone
.
c
leavage
# Upper-rule
previous_rule
=
cleaving_zone
# Only the deeper rule should have the correct boolean
cleav
=
not
all_rules
[
rul
]
# Exceptions to handle
if
cleaving_zone
.
c
ut
and
len
(
dict_rule
)
>
1
:
if
cleaving_zone
.
c
leavage
and
len
(
dict_rule
)
>
1
:
# Backup this exception
exceptions
.
append
(
dict_rule
)
# No exception
...
...
@@ -608,10 +608,10 @@ def create_rules(all_rules):
for
dict_exc
in
exceptions
:
# Create rule for the cleaving zone
if
dict_exc
[
0
][
0
]
==
","
:
# Before
letter
# Before
amino_acid
cleaving_zone
=
Rule
(
0
,
str
(
dict_exc
[
0
][
1
]),
all_rules
[
rul
],
0
)
else
:
# After
letter
# After
amino_acid
cleaving_zone
=
Rule
(
0
,
str
(
dict_exc
[
0
][
0
]),
all_rules
[
rul
],
1
)
# Default main_rule
...
...
@@ -718,15 +718,15 @@ def add_missing_rule(main_rule, dict_of_rule, rule_to_add):
where_to_add
=
reachable_pos
[
min
(
reachable_pos
)]
# Create the Rule for this exception
tmp_rule
=
Rule
(
rule_to_add
[
0
],
rule_to_add
[
1
],
False
,
-
1
)
# Change upper rules to c
ut
# Dangerous, works because .equ doesn't look c
ut
ting position.
# Change upper rules to c
leavage
# Dangerous, works because .equ doesn't look c
leavage
ting position.
# I can't find an upper rule that should be at F with sub-rule at F
# Something like '(D,)(G)': False, '(X)(D,)(G)': False
# But it is none sens, but this actually BUG...
# What I should do is checking if the rule already exist. If so, add
# a new one. But I will end-up with two identical rules at the same
# level saying T and F.
where_to_add
.
c
ut
=
True
where_to_add
.
c
leavage
=
True
# If it is not already there
if
not
where_to_add
.
contains
(
tmp_rule
)
and
not
where_to_add
.
equ
(
tmp_rule
):
# Add manually the rule
...
...
@@ -773,56 +773,56 @@ def find_rechable_pos(main_rule, dict_of_rule):
ret
[
len
(
dict_of_rule
)]
=
main_rule
return
ret
def
handle_rule
(
seq
,
pos
,
a_rule
,
c
ut
):
def
handle_rule
(
seq
,
pos
,
a_rule
,
c
leavage
):
"""Recursive handling of a :py:class:`Rule` determining if a
sequence must be c
ut
ted at a given position according to the rule.
sequence must be c
leavage
ted at a given position according to the rule.
:param seq: sequence to test
:param pos: position on the sequence
:param a_rule: the rule
:param c
ut
: boolean telling if it must be c
ut
ted or not
:param c
leavage
: boolean telling if it must be c
leavage
ted or not
:type seq: str
:type pos: int
:type a_rule: :py:class:`Rule`
:type c
ut
: bool
:type c
leavage
: bool
:return: `True` if sequence must be c
ut
ted
:return: `True` if sequence must be c
leavage
ted
:rtype: bool or None
"""
# return of the function: should we c
ut
this?
ret
=
c
ut
# Need to try because it can be the first/last
letter
# return of the function: should we c
leavage
this?
ret
=
c
leavage
# Need to try because it can be the first/last
amino_acid
# and we need to look before/after
# After is handle by try, but before, because python like str[-x],
# we need an if :-/
try
:
# If the rule applies, i.e. the
letter
to watch is the good one
# If the rule applies, i.e. the
amino_acid
to watch is the good one
if
(
pos
+
a_rule
.
index
)
>=
0
and
\
seq
[
pos
+
a_rule
.
index
]
==
a_rule
.
letter
:
# If no previous 'False' and this is c
ut
ting
if
a_rule
.
c
ut
and
ret
is
not
False
:
seq
[
pos
+
a_rule
.
index
]
==
a_rule
.
amino_acid
:
# If no previous 'False' and this is c
leavage
ting
if
a_rule
.
c
leavage
and
ret
is
not
False
:
ret
=
True
# Handle the sub-rules (exceptions)
for
rul
in
a_rule
.
rules
:
# Apply the rule: do we need to c
ut
?
# Apply the rule: do we need to c
leavage
?
ret
=
handle_rule
(
seq
,
pos
,
rul
,
ret
)
# Is is not c
ut
ting
elif
not
a_rule
.
c
ut
:
# Is is not c
leavage
ting
elif
not
a_rule
.
c
leavage
:
# Reinit
ret
=
None
# Handle sub-rules
if
a_rule
.
rules
:
# Handle the rules (exceptions)
for
rul
in
a_rule
.
rules
:
# Apply the rule: do we need to c
ut
?
# Apply the rule: do we need to c
leavage
?
ret
=
handle_rule
(
seq
,
pos
,
rul
,
ret
)
# No sub-rules and not c
ut
ting
# No sub-rules and not c
leavage
ting
else
:
# We are at the end a of rule that applies
# and say to NOT c
ut
. So it will never c
ut
.
# and say to NOT c
leavage
. So it will never c
leavage
.
ret
=
False
# Doesn't work: begin or end of sequence, don't change c
ut
value
# Doesn't work: begin or end of sequence, don't change c
leavage
value
except
IndexError
:
pass
return
ret
tests/test_rule.py
View file @
99b0a848
...
...
@@ -8,10 +8,10 @@ def test_rule():
"""Test class 'Rule'"""
# Simple rule0
index
=
0
letter
=
"D"
c
ut
=
True
amino_acid
=
"D"
c
leavage
=
True
pos
=
0
rule0
=
rule
.
Rule
(
index
,
letter
,
cut
,
pos
)
rule0
=
rule
.
Rule
(
index
,
amino_acid
,
cleavage
,
pos
)
# Test function '__repr__()'
print_res
=
rule0
.
__repr__
()
...
...
@@ -19,19 +19,19 @@ def test_rule():
# Simple rule1
index
=
2
letter
=
"Q"
c
ut
=
False
amino_acid
=
"Q"
c
leavage
=
False
pos
=
1
rule1
=
rule
.
Rule
(
index
,
letter
,
cut
,
pos
)
rule1
=
rule
.
Rule
(
index
,
amino_acid
,
cleavage
,
pos
)
print_res
=
rule1
.
__repr__
()
assert
print_res
==
"index=2
\n
amino_acid=Q
\n
cleavage=False
\n
position=1
\n
"
# Simple rule2 identical to 1
index
=
0
letter
=
"D"
c
ut
=
True
amino_acid
=
"D"
c
leavage
=
True
pos
=
0
rule2
=
rule
.
Rule
(
index
,
letter
,
cut
,
pos
)
rule2
=
rule
.
Rule
(
index
,
amino_acid
,
cleavage
,
pos
)
# Test function '__eq__()'
assert
rule0
==
rule2
...
...
@@ -140,7 +140,7 @@ def test_check_rule():
res
=
rule
.
check_rule
(
expr
)
assert
res
==
expr
# No UPPER
letter after a letter
# No UPPER
amino_acid after a amino_acid
expr
=
"(AB,)"
res
=
rule
.
check_rule
(
expr
)
assert
res
==
""
...
...
@@ -235,12 +235,12 @@ def test_split_complex_rule():
def
test_add_rule
():
"""Test function 'add_rule(rules_list, rule)'."""
rules_list
=
[]
# Add a basic rule that c
ut
before 'A'
# Add a basic rule that c
leavage
before 'A'
rule1
=
rule
.
Rule
(
0
,
"A"
,
True
,
0
)
rule
.
add_rule
(
rules_list
,
rule1
)
assert
rules_list
[
0
].
index
==
0
assert
rules_list
[
0
].
letter
==
"A"
assert
rules_list
[
0
].
c
ut
is
True
assert
rules_list
[
0
].
amino_acid
==
"A"
assert
rules_list
[
0
].
c
leavage
is
True
assert
rules_list
[
0
].
pos
is
0
assert
len
(
rules_list
)
==
1
assert
rules_list
[
0
]
==
rule1
...
...
@@ -257,7 +257,7 @@ def test_add_rule():
rule
.
add_rule
(
rules_list
,
rule3
)
assert
len
(
rules_list
)
==
1
# Add a rule that c
ut
after 'B' and a sub-rule (except if Y after)
# Add a rule that c
leavage
after 'B' and a sub-rule (except if Y after)
rule4
=
rule
.
Rule
(
0
,
"B"
,
True
,
1
)
rule4
.
rules
.
append
(
rule
.
Rule
(
2
,
"Y"
,
False
,
1
))
rule
.
add_rule
(
rules_list
,
rule4
)
...
...
@@ -265,24 +265,24 @@ def test_add_rule():
assert
rules_list
[
0
]
==
rule1
assert
rules_list
[
1
]
==
rule4
assert
len
(
rule4
.
rules
)
==
1
# It doesn't change rule4.c
ut
assert
rule4
.
c
ut
is
True
# It doesn't change rule4.c
leavage
assert
rule4
.
c
leavage
is
True
assert
rules_list
[
1
].
rules
[
0
].
index
==
2
assert
rules_list
[
1
].
rules
[
0
].
letter
==
"Y"
assert
rules_list
[
1
].
rules
[
0
].
c
ut
is
False
assert
rules_list
[
1
].
rules
[
0
].
amino_acid
==
"Y"
assert
rules_list
[
1
].
rules
[
0
].
c
leavage
is
False
assert
rules_list
[
1
].
rules
[
0
].
pos
==
1
# Add a rule that DOESN'T c
ut
after 'C'
# Add a rule that DOESN'T c
leavage
after 'C'
rule5
=
rule
.
Rule
(
0
,
"C"
,
False
,
True
)
# Add a sub-rule in rule5 that is c
ut
ting before 'A' (same as rule1)
# Add a sub-rule in rule5 that is c
leavage
ting before 'A' (same as rule1)
rule5
.
rules
.
append
(
rule
.
Rule
(
0
,
"A"
,
True
,
0
))
rule
.
add_rule
(
rules_list
,
rule5
)
# It is NOT recorded as the rule already exist
assert
len
(
rules_list
)
==
2
# But it modify rule5.c
ut
assert
rule5
.
c
ut
is
True
# But it modify rule5.c
leavage
assert
rule5
.
c
leavage
is
True
# And rule5 is added to rule1 sub-rules
assert
rules_list
[
0
].
rules
[
1
].
letter
==
"C"
assert
rules_list
[
0
].
rules
[
1
].
amino_acid
==
"C"
# create a complex rule containing B
rule6
=
rule
.
Rule
(
0
,
"D"
,
True
,
1
)
...
...
@@ -293,20 +293,20 @@ def test_add_rule():
rule
.
add_rule
(
rules_list
,
rule6
)
# It is NOT added
assert
len
(
rules_list
)
==
2
# rule6.c
ut
should have change
assert
rule6
.
c
ut
is
False
# rule6.c
leavage
should have change
assert
rule6
.
c
leavage
is
False
# rule6 should have only 3 sub-rules, 'E', 'F' and 'G'
assert
len
(
rule6
.
rules
)
==
3
# Those have been added to rule4
assert
rule4
.
rules
[
1
].
rules
[
0
].
letter
==
"E"
assert
rule4
.
rules
[
1
].
rules
[
1
].
letter
==
"F"
assert
rules_list
[
1
].
rules
[
1
].
rules
[
2
].
letter
==
"G"
# Same as rule4
assert
rule4
.
rules
[
1
].
rules
[
0
].
amino_acid
==
"E"
assert
rule4
.
rules
[
1
].
rules
[
1
].
amino_acid
==
"F"
assert
rules_list
[
1
].
rules
[
1
].
rules
[
2
].
amino_acid
==
"G"
# Same as rule4
def
test_create_rules
():
"""Test function 'create_rules(all_rules)'."""
all_rules
=
{}
# Simplest rule
#
Cut
before A
#
cleavage
before A
rule1
=
"(,A)"
all_rules
[
rule1
]
=
True
...
...
@@ -316,7 +316,7 @@ def test_create_rules():
assert
truth1
in
res
# More complex rule
#
Cut
after B or C
#
cleavage
after B or C
rule2
=
"(B or C,)"
all_rules
[
rule2
]
=
True
# Truth for rule2
...
...
@@ -403,40 +403,40 @@ def test_create_rules():
assert
len
(
res
)
==
4
def
test_handle_rule
():
"""Test function 'handle_rule(seq, pos, a_rule, c
ut
)'"""
"""Test function 'handle_rule(seq, pos, a_rule, c
leavage
)'"""
# We c
ut
after E preceeded by D
# We c
leavage
after E preceeded by D
a_rule
=
{}
rule_txt
=
"(D)(E,)"
a_rule
[
rule_txt
]
=
True
all_rules
=
rule
.
create_rules
(
a_rule
)
seq
=
"ABCDEF"
pos
=
4
c
ut
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
ut
)
c
leavage
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
leavage
)
assert
res
is
True
# We c
ut
after E preceeded by D
# We c
leavage
after E preceeded by D
a_rule
=
{}
rule_txt
=
"(D)(E,)"
a_rule
[
rule_txt
]
=
True
all_rules
=
rule
.
create_rules
(
a_rule
)
seq
=
"ABCXEF"
pos
=
4
c
ut
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
ut
)
c
leavage
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
leavage
)
assert
res
is
None
# We c
ut
after E preceeded by D
# We c
leavage
after E preceeded by D
a_rule
=
{}
rule_txt
=
"(D)(E,)"
a_rule
[
rule_txt
]
=
True
all_rules
=
rule
.
create_rules
(
a_rule
)
seq
=
"ABCDEF"
pos
=
3
# Not E
c
ut
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
ut
)
c
leavage
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
leavage
)
assert
res
is
None
# We c
ut
after E NOT preceeded by D
# We c
leavage
after E NOT preceeded by D
a_rule
=
{}
rule_txt
=
"(E,)"
a_rule
[
rule_txt
]
=
True
...
...
@@ -445,11 +445,11 @@ def test_handle_rule():
all_rules
=
rule
.
create_rules
(
a_rule
)
seq
=
"ABCXEF"
pos
=
4
c
ut
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
ut
)
c
leavage
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
leavage
)
assert
res
is
True
# We c
ut
after E NOT preceeded by D
# We c
leavage
after E NOT preceeded by D
a_rule
=
{}
rule_txt
=
"(E,)"
a_rule
[
rule_txt
]
=
True
...
...
@@ -458,6 +458,6 @@ def test_handle_rule():
all_rules
=
rule
.
create_rules
(
a_rule
)
seq
=
"ABCDEF"
pos
=
4
c
ut
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
ut
)
c
leavage
=
None
# Not needed here
res
=
rule
.
handle_rule
(
seq
,
pos
,
all_rules
[
0
],
c
leavage
)
assert
res
is
False
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment