| | |
- buffer
-
- tablebuffer
- fragment
-
- ccp4i_info
- program
- keytext
- logfile
- patternmatch
- summary
- table
- table_column
- table_graph
class buffer |
| |
Buffer object for parsing log files.
The buffer object holds lines of text which are added
a line at a time via the 'append' method.
|
| |
Methods defined here:
- __init__(self, maxsize=0)
- Initialise a new buffer object.
If 'maxsize' is greater than zero then it sets the
maximum number of lines that the buffer will hold.
If this number of lines is exceeded by an append
operation, then the 'oldest' line is dropped from
the buffer.
If 'maxsize' is zero or negative then no upper limit
is placed on the number of lines that the buffer will
store.
- all(self)
- Return entire buffer contents as a string.
All lines in the buffer will be concatenated into a single
string with line ends terminated by a newline character.
- append(self, line)
- Append a line of text to the buffer.
The line will have any trailing 'end of line'
characters removed automatically upon storage.
- clear(self)
- Clear the buffer of all content.
Delete all lines currently stored in the buffer.
- contents(self, n, m)
- Return lines 'n' through to 'm' as a string.
Return the specified lines from the buffer concatenated
into a single string with line ends terminated by a newline
character.
- getlines(self, n, m)
- Return lines 'n' through to 'm' as a list.
Return a set of lines starting from line index 'n' up to
but not including line index 'm', as a list.
- len(self)
- Return the number of lines currently stored.
- line(self, n)
- Return the n'th line of text from the buffer.
The line will be returned without end-of-line characters.
- tail(self, n=10)
- Return the 'tail' of the buffer.
This returns the last n lines of text stored in the
buffer, concatenated into a single string with end lines
terminated by a newline character.
If a number of lines is not specified then it defaults
to the last 10 lines of text.
|
class ccp4i_info(fragment) |
| |
Object describing a CCP4i information message in a CCP4 logfile.
The ccp4i_info class has the following attributes:
'message': the text of the CCP4i information message.
|
| |
Methods defined here:
- __init__(self)
- isccp4i_info(self)
- isfragment(self)
Methods inherited from fragment:
- __getattr__(self, key)
- Implements the functionality for value = fragment.key
Wrapper for the get_attribute method.
- __getitem__(self, key)
- Implements the functionality for value = fragment[key]
Wrapper for the get_attribute method.
- __len__(self)
- Implement the __len__ built-in method.
The length of a fragment is the number of lines
of text that it contains.
- __nonzero__(self)
- Implement the __nonzero__ built-in method.
The fragment is considered 'nonzero' once an
attribute, table or keytext has been assigned
to it.
- __setitem__(self, key, value)
- Implements the functionality for program[key] = value
Wrapper for the set_attribute method.
- addkeytext(self, name='', junk_text='', message='')
- Add a new keytext object to the fragment.
Create a new keytext object and add it to the list of
keytexts associated with the fragment.
The values of the parameters 'name', 'junk_text' and
'message' will be used to initialise the new keytext
object (one or more of these can be blank).
This method returns the new keytext object.
- addtable(self, tabletext='')
- Add a new table object to the fragment.
Create a new table object and add it to the list of
tables associated with the fragment.
If 'tabletext' is nonblank then the table object will
be automatically populated from the text, if possible.
This method returns the new table object.
- attributes(self)
- Return a list of all the fragment attributes.
The list contains all the attributes that have been
set for the fragment.
- findtable(self, title_pattern, index=0)
- Fetch a table in the fragment by matching the title.
This method is deprecated; use the 'tables' method
instead.
This method looks up a particular table in a list
of table objects (argument 'table_list'), by finding
the first table in the list which matches the supplied
regular expression 'title_pattern'.
If there is more than one matching table then the 'index'
argument specifies which of the list of matching tables
should be returned. If index is out of range (or there are
no matching tables) then return 'None'.
It calls the 'find_table_by_title' function.
- get_attribute(self, key)
- Return the value of a fragment attribute.
The key is a string specifying a particular fragment
attribute. If the attribute has been read from the file
then its value is returned, otherwise a KeyError
exception is raised.
- get_endline(self)
- Get the end line of the fragment in the source document.
- get_source_file(self)
- Get the source document for the fragment.
- get_startline(self)
- Get the start line of the fragment in the source document.
- has_attribute(self, key)
- Check whether a fragment attribute has been set.
The key is a string specifying a particular fragment
attribute. If the attribute has been set then this
method returns True, otherwise it returns False.
- isprogram(self)
- Return True if this represents a program logfile.
- keytext(self, i)
- Return the i'th keytext object.
For example: program.keytext(i) returns the i'th keytext
object associated with the program object. The methods
of the keytext class can then be used to drill down into
the contents of the message.
Use the nkeytexts method to get the total number of
keytext objects associated with the program/fragment.
- nkeytexts(self)
- Return the number of keytexts found in the logfile fragment.
'Keytexts' are warnings and messages issued by the
ccperror/CCPERR functions within programs; see the
loggraph format documentation for more information, e.g.
http://www.ccp4.ac.uk/dist/html/loggraphformat.html
- ntables(self)
- Return the number of tables found in the fragment.
- retrieve(self)
- Retrieve the text associated with the fragment.
This uses the 'retrieve' method within the module.
- set_attribute(self, key, value)
- Set the value of a fragment attribute.
The key is a string specifying a particular fragment
attribute which will be assigned the given value.
If the attribute doesn't exist then it will be created,
if it does then the current value will be overwritten
by the new one.
- set_attributes_from_dictionary(self, dict)
- Set the values of multiple fragment attributes.
For each key in dictionary 'dict', the value of a
fragment attribute with the same name as the key will
be assigned the same value as that of the key.
- set_endline(self, line_no)
- Set the end line of the fragment in the source document.
- set_source_file(self, source_file)
- Set the source document for the fragment.
The source document is specified as the name of the file that
the fragment is part of.
- set_startline(self, line_no)
- Set the start line of the fragment in the source document.
- table(self, i)
- Return the i'th table object.
This method is deprecated, use 'fragment.tables()[i]'
instead.
fragment.table(i) returns the i'th table object associated
with the fragment object. The methods of the table class
can then be used to drill down into the contents of the
table.
Use the ntables method to get the total number of table
objects associated with the fragment.
- tables(self, select_title='')
- Return a list of tables in the fragment.
If no 'select_title' is specifed then this returns
the list of all the table objects stored in the fragment
object.
If 'select_title' is given then this is compiled as
a regular expression pattern, and the method returns a
list containing only those table objects for which the
title matches the pattern.
In either case if no table objects are found then an
empty list is returned.
This method calls the 'find_tables_by_title' function.
|
class fragment |
| |
Object describing a generic fragment of a logfile.
The fragment object is intended to represent any
'top-level' fragment of a logfile, for example a
program logfile or some output from a script that
appears inbetween program logs.
The fragment class is used as the base class for
the program and ccp4i_info classes.
|
| |
Methods defined here:
- __getattr__(self, key)
- Implements the functionality for value = fragment.key
Wrapper for the get_attribute method.
- __getitem__(self, key)
- Implements the functionality for value = fragment[key]
Wrapper for the get_attribute method.
- __init__(self)
- Initialise a new fragment object.
- __len__(self)
- Implement the __len__ built-in method.
The length of a fragment is the number of lines
of text that it contains.
- __nonzero__(self)
- Implement the __nonzero__ built-in method.
The fragment is considered 'nonzero' once an
attribute, table or keytext has been assigned
to it.
- __setitem__(self, key, value)
- Implements the functionality for program[key] = value
Wrapper for the set_attribute method.
- addkeytext(self, name='', junk_text='', message='')
- Add a new keytext object to the fragment.
Create a new keytext object and add it to the list of
keytexts associated with the fragment.
The values of the parameters 'name', 'junk_text' and
'message' will be used to initialise the new keytext
object (one or more of these can be blank).
This method returns the new keytext object.
- addtable(self, tabletext='')
- Add a new table object to the fragment.
Create a new table object and add it to the list of
tables associated with the fragment.
If 'tabletext' is nonblank then the table object will
be automatically populated from the text, if possible.
This method returns the new table object.
- attributes(self)
- Return a list of all the fragment attributes.
The list contains all the attributes that have been
set for the fragment.
- findtable(self, title_pattern, index=0)
- Fetch a table in the fragment by matching the title.
This method is deprecated; use the 'tables' method
instead.
This method looks up a particular table in a list
of table objects (argument 'table_list'), by finding
the first table in the list which matches the supplied
regular expression 'title_pattern'.
If there is more than one matching table then the 'index'
argument specifies which of the list of matching tables
should be returned. If index is out of range (or there are
no matching tables) then return 'None'.
It calls the 'find_table_by_title' function.
- get_attribute(self, key)
- Return the value of a fragment attribute.
The key is a string specifying a particular fragment
attribute. If the attribute has been read from the file
then its value is returned, otherwise a KeyError
exception is raised.
- get_endline(self)
- Get the end line of the fragment in the source document.
- get_source_file(self)
- Get the source document for the fragment.
- get_startline(self)
- Get the start line of the fragment in the source document.
- has_attribute(self, key)
- Check whether a fragment attribute has been set.
The key is a string specifying a particular fragment
attribute. If the attribute has been set then this
method returns True, otherwise it returns False.
- isccp4i_info(self)
- Return True if this is a CCP4i information fragment.
- isfragment(self)
- Return True if this represents a basic fragment.
- isprogram(self)
- Return True if this represents a program logfile.
- keytext(self, i)
- Return the i'th keytext object.
For example: program.keytext(i) returns the i'th keytext
object associated with the program object. The methods
of the keytext class can then be used to drill down into
the contents of the message.
Use the nkeytexts method to get the total number of
keytext objects associated with the program/fragment.
- nkeytexts(self)
- Return the number of keytexts found in the logfile fragment.
'Keytexts' are warnings and messages issued by the
ccperror/CCPERR functions within programs; see the
loggraph format documentation for more information, e.g.
http://www.ccp4.ac.uk/dist/html/loggraphformat.html
- ntables(self)
- Return the number of tables found in the fragment.
- retrieve(self)
- Retrieve the text associated with the fragment.
This uses the 'retrieve' method within the module.
- set_attribute(self, key, value)
- Set the value of a fragment attribute.
The key is a string specifying a particular fragment
attribute which will be assigned the given value.
If the attribute doesn't exist then it will be created,
if it does then the current value will be overwritten
by the new one.
- set_attributes_from_dictionary(self, dict)
- Set the values of multiple fragment attributes.
For each key in dictionary 'dict', the value of a
fragment attribute with the same name as the key will
be assigned the same value as that of the key.
- set_endline(self, line_no)
- Set the end line of the fragment in the source document.
- set_source_file(self, source_file)
- Set the source document for the fragment.
The source document is specified as the name of the file that
the fragment is part of.
- set_startline(self, line_no)
- Set the start line of the fragment in the source document.
- table(self, i)
- Return the i'th table object.
This method is deprecated, use 'fragment.tables()[i]'
instead.
fragment.table(i) returns the i'th table object associated
with the fragment object. The methods of the table class
can then be used to drill down into the contents of the
table.
Use the ntables method to get the total number of table
objects associated with the fragment.
- tables(self, select_title='')
- Return a list of tables in the fragment.
If no 'select_title' is specifed then this returns
the list of all the table objects stored in the fragment
object.
If 'select_title' is given then this is compiled as
a regular expression pattern, and the method returns a
list containing only those table objects for which the
title matches the pattern.
In either case if no table objects are found then an
empty list is returned.
This method calls the 'find_tables_by_title' function.
|
class logfile |
| |
Object describing a program logfile.
A logfile object is populated and returned by the
parselog() function. This takes a file name as a single
compulsory argument; the optional 'progress' argument
specifies a number of lines at which to report progress
when parsing the file.
A logfile object holds lists of 'programs', 'tables',
'keytext messages' and 'CCP4i information messages',
plus a master list of 'fragments' (which can be any of
the above). There are methods to allow access to each of
these lists.
There is also a list of CCP4 'summaries' that have been
been found in the logfile. These are kept distinct from
the logfile fragments above.
|
| |
Methods defined here:
- __init__(self, filename)
- Initialise the logfile object.
- __nonzero__(self)
- Implement the nonzero built-in method.
The logfile will test as True if at least one
fragment is defined - otherwise it will test as
False.
- addccp4i_info(self)
- Add another ccp4i_info object to the logfile.
Creates a new ccp4i_info object and added to the
list of fragments, and to the list of CCP4i information
messages found in the logfile.
- addfragment(self, fragment)
- Add an existing fragment-like object to the logfile.
- addkeytext(self, thiskeytext=False, name='', junk_text='', message='')
- Add a keytext object to the list of keytexts.
If an existing keytext object is supplied with the
thiskeytext argument this is appended to the list.
Otherwise a new keytext object is created and
populated with the contents of the name, junk_text
and message arguments.
- addprogram(self)
- Add a new program object to the logfile.
- addsummary(self, start_line=-1)
- Add another summary object to the logfile.
A new summary object is created and returned. The
new object is also added to the list of summaries
for the logfile.
- addtable(self, thistable=False, tabletext='')
- Add a table object to the list of tables.
If an existing table object is specified with the
thistable argument then this is appended to the
list. Otherwise a new table object is created. In
that case, if tabletext is supplied then this is
used to populate the table object; otherwise the
new table object is empty.
- append_ccp4i_header(self, line)
- Append a line of text to the CCP4i header.
- append_ccp4i_tail(self, line)
- Append a line of text to the CCP4i tail.
- ccp4i_header(self)
- Return the CCP4i header content.
- ccp4i_info(self, i)
- Return the i'th ccp4i_info object in the logfile.
Note that i counts up starting from zero.
- ccp4i_tail(self)
- Return the CCP4i tail content.
- filename(self)
- Return the filename of the source logfile.
- findtable(self, title_pattern, index=0)
- Fetch a table in the logfile by matching the title.
This method is deprecated; use the 'tables' method
instead.
This method looks up a particular table in a list
of table objects (argument 'table_list'), by finding
the first table in the list which matches the supplied
regular expression 'title_pattern'.
If there is more than one matching table then the 'index'
argument specifies which of the list of matching tables
should be returned. If index is out of range (or there are
no matching tables) then return 'None'.
It calls the 'find_table_by_title' function.
- fragment(self, i)
- Return the i'th fragment in the logfile.
A fragment can be a program, table, CCP4i message or
keytext object.
Note that i counts up from zero.
- fragment_to_program(self, i)
- Convert the i'th fragment to a program.
This method allows a fragment in the logfile to be
recast as a program, and performs all the necessary
book keeping operations such as updating the lists
of fragment and program objects.
On successful conversion the converted program
object is returned. If the fragment is already a
program then no action is taken.
- isccp4i(self)
- Return True if the logfile appears to be from CCP4i.
- keytext(self, i)
- Return the i'th keytext object in the logfile.
Note that i counts up starting from zero.
- nccp4i_info(self)
- Return the number of ccp4i_info messages.
- newfragment(self)
- Generate a new fragement and add to the logfile.
Returns a new fragment object and calls addfragment to
add it to the list of fragments for this logfile.
- nfragments(self)
- Return the number of fragments.
- nkeytexts(self)
- Return the number of keytexts in the logfile.
- nprograms(self)
- Return the number of program objects.
- nsummaries(self)
- Return the number of summaries found in the log.
- ntables(self)
- Return the number of tables in the logfile.
- program(self, i)
- Return the i'th program object in the logfile.
Note that i counts up starting from zero.
- set_fragment_end(self, line_no)
- Set the end line of the most recent fragment.
The most recent fragment is the last fragment object
in the list of fragments for this logfile. 'line_no'
is the current line number in the source file.
The supplied line number is always taken as the last
line number of the fragment. This method will also
check the start line number and will attempt to set
it to a reasonable value if it is not set: either the
first line after the end of the previous fragment,
or the start of the file (if there is no previous
fragment).
- set_fragment_start(self, line_no)
- Set the start line of the most recent fragment.
The most recent fragment is the last fragment object
in the list of fragments for this logfile. 'line_no'
is the current line number in the source file.
If the fragment has an 'nlines' attribute then this
is taken to be the offset from the current line back
to the start of the fragment. If nlines is not
present then the fragment is taken to start after the
end of the previous fragment. If there is no previous
fragment then it is assumed to start from the first
line of the file
- summary(self, i)
- Return the i'th summary object in the logfile.
Note that i counts up starting from zero.
- table(self, i)
- Return the i'th table object in the logfile.
This method is deprecated, use 'logfile.tables()[i]'
instead.
Note that i counts up starting from zero.
- tables(self, select_title='')
- Return a list of tables in the logfile.
If no 'select_title' is specifed then this returns
the list of all the table objects stored in the logfile
object.
If 'select_title' is given then this is compiled as
a regular expression pattern, and the method returns a
list containing only those table objects for which the
title matches the pattern.
In either case if no table objects are found then an
empty list is returned.
This method calls the 'find_tables_by_title' function.
|
class patternmatch |
| |
Object holding regular expressions for logfile features.
The patternmatch object provides a set of methods that can
match various features that might be found in CCP4 logfiles,
and logfiles from other programs. These are:
isccp4banner: check for CCP4 program banner
isccp4termination: check for CCP4 program termination message
isshelxbanner: check for SHELX program banner
isshelxtermination: check for SHELX program termination
isccp4keytext: check for CCP4 keytext messages
isccp4table: check for CCP4 table
isccp4iheader: check for CCP4i logfile header line
isccp4itail: check for CCP4i logfile tail line
isccp4iinformation: check for CCP4i information block
It also provides methods to match single lines:
isdataline: check if line contains CCP4 keyword input
isfileopen: check if line contains CCP4 file opening information
issummary_begin: check if line contains the start of a summary
issummary_end: check if the line contains the end of a summary
In each case, the method returns False if there is no match,
and a dictionary of data items if there is a match. The data
items are dependent on the type of pattern that is matched -
see the information for the relevant method for descriptions.
|
| |
Methods defined here:
- __init__(self)
- compile(self, name, pattern)
- Returns a compiled regular expression from the pattern.
This method returns a compiled regular expression associated
with 'name', based on the supplied 'pattern'. If the name
already has a compiled expression then that is returned,
otherwise the compile method compiles and stores it before
returning it.
- get_pattern(self, name)
- Fetch a compiled regular expression associated with 'name'.
- has_pattern(self, name)
- Returns True if there is a pattern associated 'name'.
- isccp4banner(self, text)
- Regular expression match to CCP4 program banner.
Given a block of text, attempts to match it against
regular expressions for a CCP4 program banner.
Returns False if the match fails, otherwise returns
a dictionary object populated with attributes
derived from the supplied text.
See the isccp4banner_standard and isccp4banner_phaser
functions for descriptions of the attributes that are
extracted.
- isccp4banner_old(self, text)
- Test if text matches an old-style CCP4 program banner.
'Old-style' banners come from versions of CCP4 predating
version 4.1 of the suite.
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
name: the name of the program from the CCP4 banner.
version: the program version; for CCP4 programs, this is the
version found in the program banner. For programs that don't
explicitly give their own version number this will be the same
as the CCP4 library version.
date: the date string found in the CCP4 banner; it is
typically the last date that the source code file was
committed to CVS. (It is not the date that the program was
run on - for that, use 'rundate' and 'runtime').
ccp4version: the CCP4 library version as it appears in the
program banner. Typically this includes only the major and
minor version numbers, but not the patch level.
user: the user id that appears in the CCP4 banner at runtime.
runtime: the time of day that the program run started at as
reported in the program banner.
rundate: the date that the program run started at as
reported in the program banner.
- isccp4banner_phaser(self, text)
- Test if text matches a 'phaser-style' CCP4 program banner.
'Phaser-style' banners look similar to CCP4 banners but
contain some different information. They are also used by
the 'pointless' program.
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
name: the name of the program from the banner.
version: the reported program version.
user: the user id that appears in the banner at runtime.
rundate: the date that the program run started at as
reported in the program banner.
runtime: the time of day that the program run started at as
reported in the program banner.
os: corresponds to the 'os type' as reported in the banner,
for example 'linux'.
date: corresponds to the 'release date' of the program as
reported in the banner.
ccp4version: currently set to '?'.
- isccp4banner_standard(self, text)
- Test if text matches a standard CCP4 program banner.
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
name: the name of the program from the CCP4 banner.
version: the program version; for CCP4 programs, this is the
version found in the program banner. For programs that don't
explicitly give their own version number this will be the same
as the CCP4 library version.
date: the date string found in the CCP4 banner; it is
typically the last date that the source code file was
committed to CVS. (It is not the date that the program was
run on - for that, use 'rundate' and 'runtime').
ccp4version: the CCP4 library version as it appears in the
program banner. Typically this includes only the major and
minor version numbers, but not the patch level.
user: the user id that appears in the CCP4 banner at runtime.
runtime: the time of day that the program run started at as
reported in the program banner.
rundate: the date that the program run started at as
reported in the program banner.
- isccp4i_information(self, text)
- Test if text matches a CCP4i information block.
- isccp4iheader(self, text)
- Test if text matches a CCP4i header line.
- isccp4itail(self, text)
- Test if text matches a CCP4i tail line.
- isccp4keytext(self, text)
- Test if text matches CCP4 keytext message ($TEXT).
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
name: the message 'name' or identifier
junk_text: 'junk' text provided by the program (normally ignored)
message: the message text
nlines: the number of lines of text covered by the entire keytext
message block.
- isccp4table(self, text)
- Test if text matches CCP4 logfile table ($TABLE).
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
rawtable: the exact text of the table as it appeared in the
logfile
title: the title of the table.
type: the table type.
graphs: the text of the $GRAPHS portion of the table text.
columns: the text of the column headers in the table.
text: the 'junk' text after the column headers and before the
actual table data.
data: the text of the table data (i.e. columns and rows of
numbers or other data.
nlines: the number of lines of text covered by the entire table
block.
These data items are themselves relatively unprocessed, so it
is recommended that the text that matches the table should be
fed into a 'table' object which provides a much easier to use
interface to the various bits of data in the table.
a table
- isccp4termination(self, text)
- Regular expression match to CCP4 program termination.
Given a block of text, attempts to match it against
regular expressions for a CCP4 program termination.
Returns False if the match fails, otherwise returns
a dictionary object populated with attributes
derived from the supplied text.
See the isccp4termination_standard and
isccp4termination_phaser functions for descriptions of
the attributes that are extracted.
- isccp4termination_phaser(self, text)
- Test if text matches a 'phaser-style' CCP4 program termination.
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
termination_name: the program name as reported in the
CCP4 termination message at the tail of the program log.
termination_message: the message text displayed in the
CCP4 termination message, e.g. 'SUCCESS'.
systemtime: the value of the 'CPU time' given at
termination.
Note that this is a subset of the attributes collected
for standard CCP4 termination messages.
- isccp4termination_standard(self, text)
- Test if text matches a standard CCP4 program termination.
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
termination_name: the program name as reported in the
CCP4 termination message at the tail of the program log.
termination_message: the message text displayed in the
CCP4 termination message, e.g. 'Normal termination'.
usertime: the value of the 'user time' given at
termination.
systemtime: the value of the 'system time' given at
termination.
elapsedtime: the value of the 'elapsed time' given at
termination.
- isdataline(self, line)
- Test if line matches a CCP4 keyword input line.
This function tries to match the keyword input lines.
If the match fails then return False; if it succeeds then
returns a dictionary with the following keys:
data_line: the keyword data
- isfileopen(self, line)
- Test if line matches a CCP4 file opening report.
This function tries to match the reports of a file opening
event from the CCP4 libraries, which report the logical name
and associated filename.
If the match fails then return False; if it succeeds then
returns a dictionary with the following keys:
logical_name: the logical name
filename: the associated filename
- isshelxbanner(self, text)
- Test if text matches a SHELX program banner.
This function tries to match the banners from SHELXC,
SHELXD and SHELXE.
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
name: the program name.
version: the program version.
runtime: the time of day that the program run started at as
reported in the program banner.
rundate: the date that the program run started at as
reported in the program banner.
- isshelxtermination(self, text)
- Test if text matches a SHELX program termination.
This function tries to match the messages from SHELXC,
SHELXD and SHELXE.
If the match fails then return False; if it succeeds then
return a dictionary with the following keys:
termination_name: the program name as reported in the
SHELX termination message at the tail of the program log.
termination_message: the message text displayed in the
termination message. The content of this text varies
between SHELXC and SHELXD/E so no further processing is
currently attempted.
- issummary_begin(self, line)
- Test if line matches a CCP4 SUMMARY_BEGIN line.
This function tries to match lines that indicate the start
of a CCP4 summary block i.e. lines containing the text
'<!--SUMMARY_BEGIN-->'.
If the match fails then return False; if it succeeds then
return True.
- issummary_end(self, line)
- Test if line matches a CCP4 SUMMARY_END line.
This function tries to match lines that indicate the end
of a CCP4 summary block i.e. lines containing the text
'<!--SUMMARY_END-->'.
If the match fails then return False; if it succeeds then
return True.
- store_pattern(self, name, cpattern)
- Store a compiled regular expression associated with 'name'.
'cpattern' is a compiled regular expression which
will be associated with 'name'. The expression can be
retrieved using the 'get_pattern'.
|
class program(fragment) |
| |
Object describing the log for a single program.
program objects are instantiated and populated by parselog
as part of the parsing process. The program object is
intended to describe a fragment of logfile that corresponds
to the run of a particular program, although in practice
other types of logfile features (for example, 'interstitial'
fragments i.e. bits of output inbetween program logs) are
also assigned to program objects in the current version of
smartie.
A program object holds various attributes describing the
logfile fragment in question, as well as a list of tables
and keytext messages. A program object may also hold CCP4i
information messages, however normally it will not hold this
at the same time as actual program data.
The attributes associated with the program object can be
accessed using either of the syntaxes 'program['attribute']'
or 'program.attribute'.
For programs using the standard CCP4 banners, the following
attributes may be defined:
name: the name of the program from the CCP4 banner, or
equivalent.
version: the program version; for CCP4 programs, this is the
version found in the program banner. For programs that don't
explicitly give their own version number this will be the same
as the CCP4 library version.
date: the date string found in the CCP4 banner; it is
typically the last date that the source code file was
committed to CVS. It is not the date that the program was
run on - for that, see the 'rundate' and 'runtime' attributes.
ccp4version: the CCP4 library version as it appears in the
program banner. Typically this includes only the major and
minor version numbers, but not the patch level.
user: the user id that appears in the CCP4 banner at runtime.
runtime: the time of day that the program run started at as
reported in the program banner.
rundate: the date that the program run started at as
reported in the program banner.
termination_name: the program name as reported in the
CCP4 termination message at the tail of the program log.
termination_message: the message text displayed in the
CCP4 termination message.
usertime: the value of the 'user time' given at
termination.
systemtime: the value of the 'system time' given at
termination.
elapsedtime: the value of the 'elapsed time' given at
termination.
Note that not all these attributes may be defined, for
example if the program fragment is an incomplete CCP4 log
file or if the program is not a CCP4 program. Use the
'attributes' method to get a list of the defined
attributes.
In addition the program object also stores a list of the
keyword input lines; this list can be retrieved directly
using the 'keywords' method.
|
| |
Methods defined here:
- __init__(self)
- Initialise a new program object.
- addkeyword(self, line)
- Append a keyword input line to the program logfile.
This appends a keyword input line (with any leading text
removed) to the list of keyword lines stored in the
program object.
- addlogicalname(self, logical_name, filename)
- Add a logical name/filename reference.
This adds a logical name and the associated filename to
the dictionary of files that were reported as being opened
in the logfile.
If the same logical name is added multiple times then only
the last associated filename is kept.
- isccp4(self)
- Check if the logfile fragment is from a CCP4 program.
This returns True if the fragment of logfile appeared to
be from a CCP4 program, and False otherwise.
- isfragment(self)
- Return True if this represents a raw logfile fragment.
Overrides the 'isfragment' method in the base class.
- isprogram(self)
- Return True if this represents a program logfile.
Overrides the 'isprogram' method in the base class.
- keywords(self)
- Return the list of keyword lines.
This method returns a list of the keyword input lines
that have been stored for the program object. The lines
are otherwise unprocessed. The lines are stored in the
order that they were originally stored, and so should
reflect the order that they appear in the logfile.
- logicalnamefile(self, logical_name)
- Return the filename associated with a logical name.
Given a logical name, return the associated filename.
If the logical name isn't found then a KeyError
exception is raised.
- logicalnames(self)
- Return a list of logical names associated with the program.
The name of the file associated with a logical name can
be retrieved using the 'logicalnamefile' method.
- set_isccp4(self, isccp4)
- Set whether the logfile fragment is from a CCP4 program or not.
This method sets the value of the isccp4 flag to True
if the logfile fragment is determined to be from a CCP4
program, and False if not. Use the 'isccp4' method to
return the value of this flag.
- set_termination(self, termination)
- Set whether the logfile has a termination message.
This sets the value of the 'termination' flag to be
True if a termination message was found, and False if
not. Use the 'termination' method to return the value
of this flag.
- termination(self)
- Check if the logfile fragment ends with a valid termination.
This returns True if the fragment appeared to finish with a
recognised termination message, False otherwise.
Program fragments that do not end with a termination
message may have terminated prematurely due to an error.
Methods inherited from fragment:
- __getattr__(self, key)
- Implements the functionality for value = fragment.key
Wrapper for the get_attribute method.
- __getitem__(self, key)
- Implements the functionality for value = fragment[key]
Wrapper for the get_attribute method.
- __len__(self)
- Implement the __len__ built-in method.
The length of a fragment is the number of lines
of text that it contains.
- __nonzero__(self)
- Implement the __nonzero__ built-in method.
The fragment is considered 'nonzero' once an
attribute, table or keytext has been assigned
to it.
- __setitem__(self, key, value)
- Implements the functionality for program[key] = value
Wrapper for the set_attribute method.
- addkeytext(self, name='', junk_text='', message='')
- Add a new keytext object to the fragment.
Create a new keytext object and add it to the list of
keytexts associated with the fragment.
The values of the parameters 'name', 'junk_text' and
'message' will be used to initialise the new keytext
object (one or more of these can be blank).
This method returns the new keytext object.
- addtable(self, tabletext='')
- Add a new table object to the fragment.
Create a new table object and add it to the list of
tables associated with the fragment.
If 'tabletext' is nonblank then the table object will
be automatically populated from the text, if possible.
This method returns the new table object.
- attributes(self)
- Return a list of all the fragment attributes.
The list contains all the attributes that have been
set for the fragment.
- findtable(self, title_pattern, index=0)
- Fetch a table in the fragment by matching the title.
This method is deprecated; use the 'tables' method
instead.
This method looks up a particular table in a list
of table objects (argument 'table_list'), by finding
the first table in the list which matches the supplied
regular expression 'title_pattern'.
If there is more than one matching table then the 'index'
argument specifies which of the list of matching tables
should be returned. If index is out of range (or there are
no matching tables) then return 'None'.
It calls the 'find_table_by_title' function.
- get_attribute(self, key)
- Return the value of a fragment attribute.
The key is a string specifying a particular fragment
attribute. If the attribute has been read from the file
then its value is returned, otherwise a KeyError
exception is raised.
- get_endline(self)
- Get the end line of the fragment in the source document.
- get_source_file(self)
- Get the source document for the fragment.
- get_startline(self)
- Get the start line of the fragment in the source document.
- has_attribute(self, key)
- Check whether a fragment attribute has been set.
The key is a string specifying a particular fragment
attribute. If the attribute has been set then this
method returns True, otherwise it returns False.
- isccp4i_info(self)
- Return True if this is a CCP4i information fragment.
- keytext(self, i)
- Return the i'th keytext object.
For example: program.keytext(i) returns the i'th keytext
object associated with the program object. The methods
of the keytext class can then be used to drill down into
the contents of the message.
Use the nkeytexts method to get the total number of
keytext objects associated with the program/fragment.
- nkeytexts(self)
- Return the number of keytexts found in the logfile fragment.
'Keytexts' are warnings and messages issued by the
ccperror/CCPERR functions within programs; see the
loggraph format documentation for more information, e.g.
http://www.ccp4.ac.uk/dist/html/loggraphformat.html
- ntables(self)
- Return the number of tables found in the fragment.
- retrieve(self)
- Retrieve the text associated with the fragment.
This uses the 'retrieve' method within the module.
- set_attribute(self, key, value)
- Set the value of a fragment attribute.
The key is a string specifying a particular fragment
attribute which will be assigned the given value.
If the attribute doesn't exist then it will be created,
if it does then the current value will be overwritten
by the new one.
- set_attributes_from_dictionary(self, dict)
- Set the values of multiple fragment attributes.
For each key in dictionary 'dict', the value of a
fragment attribute with the same name as the key will
be assigned the same value as that of the key.
- set_endline(self, line_no)
- Set the end line of the fragment in the source document.
- set_source_file(self, source_file)
- Set the source document for the fragment.
The source document is specified as the name of the file that
the fragment is part of.
- set_startline(self, line_no)
- Set the start line of the fragment in the source document.
- table(self, i)
- Return the i'th table object.
This method is deprecated, use 'fragment.tables()[i]'
instead.
fragment.table(i) returns the i'th table object associated
with the fragment object. The methods of the table class
can then be used to drill down into the contents of the
table.
Use the ntables method to get the total number of table
objects associated with the fragment.
- tables(self, select_title='')
- Return a list of tables in the fragment.
If no 'select_title' is specifed then this returns
the list of all the table objects stored in the fragment
object.
If 'select_title' is given then this is compiled as
a regular expression pattern, and the method returns a
list containing only those table objects for which the
title matches the pattern.
In either case if no table objects are found then an
empty list is returned.
This method calls the 'find_tables_by_title' function.
|
class summary |
| |
Object describing a summary block in a CCP4 logfile.
The summary object holds information about the location
of a block of text in a logfile. Normally this text would
be a summary block from a CCP4 logfile, which is
identified as starting with the text '<!--SUMMARY_BEGIN-->'
and terminating with the text '<!--SUMMARY_END-->'.
In practice, the summary object has three attributes: the
name of a source file, and the start and end line numbers
of the block of text within that file. The actual text is
not stored. It can be fetched using the 'retrieve' method,
in which case it is read directly from the file and
returned.
|
| |
Methods defined here:
- __init__(self, source_file, start_line=-1)
- # Initialise the keytext object
- end(self)
- Return the end line for the summary block.
- iscomplete(self)
- Check whether the summary block is complete.
Returns True if the start and end line numbers
are valid and consistent, and False otherwise.
- retrieve(self)
- Return the text within the summary block.
- set_end(self, end_line)
- Set the end line for the summary block.
- set_start(self, start_line)
- Set the start line for the summary block.
- start(self)
- Return the start line for the summary block.
|
class table |
| |
Object describing a CCP4 logfile table
The table class represents the various components of a table
as output in CCP4 program logfiles. These tables are formatted
in a standard way that enables the data that they contain to
be displayed by the (x|j)loggraph programs.
For a description of the loggraph format see the loggraph
format documentation, e.g.
http://www.ccp4.ac.uk/dist/html/loggraphformat.html
A table consists of a number of columns of data, and a
number of graphs which are defined as being a subset of these
columns. Within smartie the table_column class represents an
individual column, and the table_graph class represents an
individual graph.
A table object can be populated when it is created, by
supplying it with text containing a CCP4-formatted table
(typically, a fragment of logfile text). Alternatively an
'empty' table can be instantiated and then populated using
the methods of the objects.
The contents of the table can be output in the correct
CCP4 format using the 'show' and 'jloggraph' methods.
|
| |
Methods defined here:
- __init__(self, tabletext='')
- Create a new table object.
If tabletext contains the text of an existing
CCP4-formatted table then the table object will
attempt to parse the table and populate itself using
the supplied data.
If 'tabletext' cannot be interpreted as a table
then the table object will be 'empty' and will contain
no data. In this case, if 'tabletext' consists of a
single line with no trailing newline then the table
object title will be set to 'tabletext'
automatically.
- __nonzero__(self)
- Builtin: provides the True/False test.
A table object is nonzero if data has been loaded
into it either at instantiation or subsequently
using any of its methods.
- __str__(self)
- Builtin: return the table title
- add_data(self, rowdata)
- Add a row of values to the table.
'rowdata' is a dictionary which specifies column
names as keys defining the values to be appended. For
example, if the table has columns called 'X', 'Y' and
'Z', then rowdata might be defined as:
rowdata = { 'X': 0.0, 'Y': 0.776, 'Z': 878 }
'Null' values (i.e. '*' character) will be added to
columns not named to keep the table data well-formed.
For example:
rowdata = { 'X': 0.0, 'Z': 878 }
will assign the expected data to the 'X' and 'Z'columns,
while assigning the '*' character to the 'Y' column.
- addcolumn(self, title='')
- Add a new column to the table.
This method adds a new 'table_column' object to
the table, to represent a column of data.
Optionally the name of the column can be supplied
via the 'title' argument. The table_column is
otherwise unpopulated.
The new table_column is returned by this method.
- addgraph(self, title='')
- Add a new graph object to the table.
This method adds a new 'table_graph' object to the
table. Optionally the name of the new graph can be
supplied using the 'title' argument. All other graph
attributes are unset by default.
- col(self, name)
- Return the data in the column identified by 'name'.
This method returns the data in the table column
identified by 'name' (for example, 'Rfree'), as a
list of values. (This is a copy of the list of values
in the table_column object representing the column.)
If the named column isn't found then a LookupError
exception is raised.
- columns(self)
- Return the original column titles text string.
This method returns the 'raw' string that was supplied
via the 'setcolumns' method, i.e. a single string with
whitespace delimited column titles. Of itself this
data is probably not very useful.
- data(self)
- Return the 'raw' data from the table body.
This method returns the 'raw' table body text as
supplied originally via the 'setdata' method. Of
itself this data is probably not very useful.
- definegraph(self, title, columns, scaling='')
- Add a new graph definition to the table.
This provides an interface to adding new graph
definitions to an existing table.
title: title for the graph.
columns: a list of column names. The first column
will the be the X-axis, others will be
the Y-values.
scaling: (optional) the scaling definition.
Possible scaling strings are:
'A': fully automatic (axes limits are automatically
determined when the graph is rendered (this is
the default)
'N': 'nought', axes limits start at zero
'XMIN|XMAXxYMIN|YMAX': limits xmin,xmax and ymin,ymax.
Raises a ValueError if insufficient number of columns
are specified, or if a specified column name doesn't
appear in the table.
- graphs(self)
- Return the graph titles and descriptions.
This method returns the 'raw' string containing the
graph definitions for the table, which were originally
supplied via the 'setgraphs' method. Of itself this
data is probably not very useful.
- html(self, border=2)
- Return the text of a table with HTML formatting.
This method returns the body of the table (column
titles and column data) marked up as a HTML table.
The width of the table can be controlled by setting
the 'border' argument.
Any HTML special characters (<, > and &) in the
column titles or data items are automatically
converted to the correct form for HTML.
- jloggraph(self, codebase='', width=400, height=300)
- Return a jloggraph-formatted table.
This method returns the text for CCP4-formatted table
from this object which includes the HTML tags required
for the jloggraph Java applet.
The codebase argument should specify the full path for
the JLogGraph.class and JLogCanvas.class files required
to run the applet (typically this is $CCP4/bin/).
- list_columns(self)
- Return a list of the column names defined in the graph.
- loggraph(self, pad_columns=True)
- Return a loggraph-formatted table.
The loggraph method generates the text of the table based
on the data stored in the object, with the correct
tags defining the columns and graphs and which should
be viewable in (x)loggraph.
For information on the 'pad_columns' option, see the 'show'
method (the setting here is passed directly to 'show').
To generate jloggraph-formatted tables use the
jloggraph method.
- ncolumns(self)
- Return the number of columns in the table.
This method returns the number of table_column
objects associated with the table.
- ngraphs(self)
- Return the number of graphs defined in the table.
This method returns the number of 'table_graph'
objects associated with the table.
- nrows(self)
- Return the number of complete rows in the table.
Returns the length of the shortest column of data stored
in the table.
- parse_error(self)
- Check if the supplied table was parsed correctly.
If there was a problem parsing the raw table text (for
example if the table was incomplete or misformatted) then
parse_error() will return True, otherwise it will be
False.
- rawtable(self)
- Return the 'raw' table text taken from the logfile.
This returns any original 'raw' text of the table that
was used to populate the table object.
If the table object wasn't populated from a text fragment
then this will return an empty string. The 'loggraph' and
'jloggraph' methods are recommended over the 'rawtable'
method as a way to return the table data formatted with
loggraph tags.
- setcolumns(self, columns)
- Create new columns in the table from the 'raw' data.
Within a CCP4-formatted table, titles of columns are
supplied as a string of white-space delimited 'tokens'
(the tokens are the titles). For example:
Resln_Range 1/resol^2 Nref Nz1 Nz2 Nz3 ...
This string is supplied to the setcolumns method as the
'columns' argument. setcolumns then extracts the
individual column titles and for each makes a new
(empty) table_column object.
If table values have previously been stored in the
table object (via the 'setdata' method) then setcolumns
will also attempt to populate the columns from this
data.
- setdata(self, data)
- Store the raw tabulated data for the table.
The body of a CCP4-formatted table contains tabulated
data items corresponding to columns associated with the
column titles. The table body consists of a sequence
of white-space separated data items (typically numbers
but could be other data).
The table body data is supplied to this method as a
single text string via the 'data' argument, and is
stored as is in the table object.
If table columns have also previously been defined
then this method will further attempt to populate the
columns with the data from the table body.
- setgraphs(self, graphs)
- Store the graph definitions in the table in 'raw' format.
Within a CCP4-formatted table, one or more graphs are
be defined using simple strings. Generally the descriptions
take the form:
:graph1 name:graphtype:column_list:
:graph2 name:graphtype:column_list: ...
(The graph definitions can be separated using whitespace,
not necessarily newlines).
The 'setgraphs' method takes an arbitrary number of graph
definition strings of the above form and extracts from each
the data, namely: the graph name (i.e. title), the type
(normally either GRAPH or SCATTER) and a list of column
numbers in the table.
- setrawtable(self, rawtable)
- Store the 'raw' table text from the original logfile.
The raw table data is the original text (for example, the
fragment of log file text) supplied to the object to
populate itself from.
- settext(self, text)
- Store the arbitrary text from the table.
Within a CCP4-formatted table there is space for a
'arbitrary text' (see the table format documentation
for more details on this). This text is not used when
plotting graphs but is included when the data in the
table is written back out in CCP4 $TABLE format.
- settitle(self, title)
- Store the table title.
The table title is an arbitrary string of text that is
intended to describe briefly the nature of the data
presented in the table.
- settype(self, graphtype)
- Store the table graph type.
This is currently one of two possible loggraph keywords,
either GRAPHS or SCATTER. The keyword is an indication
to plotting software of how the data should be displayed:
GRAPHS: line graphs, with data points joined by lines
SCATTER: scatter plots, with data plotted as points.
Raises a ValueError if the graphtype is not recognised.
- show(self, loggraph=False, html=False, pad_columns=True)
- Return the text of a CCP4-formatted table.
The show method generates the text of the table based
on the data stored in the object. If the 'loggraph'
argument is specified as 'True' then the table includes
the correct tags defining the columns and graphs and
which should be viewable in (x)loggraph. If the 'html'
argument is specified then special HTML characters in
the titles are escaped.
If 'pad_columns' is True then columns will be padded
with spaces in order to make them line up nicely. If
padding is not required then set it to False.
- table_column(self, i)
- Return the i'th column associated with the table.
This returns the i'th table_column object in the
table. Note that i counts from zero.
Generally applications that want to examine the data
stored in a table are better off using the 'col'
method of the table class rather than the
'table_column' method. The 'col' method allows data
to be retrieved by column name, and returns the
column of data as a Python list.
- table_graph(self, i)
- Return the i'th graph object.
This method returns the i'th table_graph object
associated with the table. (Note that i starts from
zero.)
- text(self)
- Return the arbitrary text from the table.
This returns any arbitrary text associated with the
table header that was previously stored using the
'settext' method.
- title(self)
- Return the table title stored in the object.
- type(self)
- Return the table graph type.
See the 'settype' method for the possible values and their
associated meanings for the table graph type.
|
class table_column |
| |
Object describing a column in a CCP4i logfile table
|
| |
Methods defined here:
- __getitem__(self, key)
- Implement table_column[i] to return the i'th data value.
- __init__(self, title='')
- Initialise the table_column object.
- __len__(self)
- Implements len(table_column).
- __nonzero__(self)
- Returns True if the column contains data, False otherwise.
- append(self, item)
- Append a data value to the end of the column.
The value will be stored as integer, float or string as
appropriate.
- data(self)
- Return the list of data values in the column.
- nrows(self)
- Return the number of rows in the column.
- settitle(self, title)
- Set the title of the column.
- title(self)
- Return the title of the column.
|
class table_graph |
| |
Object describing a graph in a CCP4 logfile table.
Tables in logfiles can contain any number of 'graphs',
which are represented within smartie by table_graph
objects.
A graph is defined by a title, a scaling type, and a
collection of table_columns storing columns of data.
|
| |
Methods defined here:
- __init__(self, title='', scaling='', column_list=[])
- Create a new table_graph object.
The 'title' argument is a string containing the title
for the graph.
'scaling' is a string describing how the graph should
be displayed within the (x|j)loggraph program.
'column_list' is a list of integers corresponding to
the columns in the table that holds the graph. The first
column in the list will form the 'x' axis of the graph
when displayed, the others will be displayed on the
'y' axis.
- __nonzero__(self)
- columns(self)
- Return the list of columns associated with the graph.
This is a list of integers corresponding to the columns
in the table.
- graphcols(self)
- Return a list of the column names in the graph.
- scaling(self)
- Return the scaling description.
- set_parent_table(self, table)
- Store a reference to the parent table object.
- setcolumns(self, columns)
- Set the table_columns associated with the graph.
The columns are specified as a string of the form
e.g. '1,2,4,5'. Note that the column numbers are adjusted
downwards by 1 to map onto Python numbering (which starts
at zero).
- setscaling(self, scaling)
- Store the scaling description.
This is a string which should take one of three possible
forms, and which is an instruction to the display
program on how to scale the graph data for display.
'A' is 'fully automatic' scaling (the display program
determines the scaling itself for both axes).
'N' (for 'nought') is automatic y coordinate scaling, where
the lowest limit on the y axis is 0s.
'XMIN|XMAXxYMIN|YMAX' (where XMIN, XMAX and YMIN, YMAX are
numbers) specifies the exact limits of both axes.
- settitle(self, title)
- Store the title of the graph.
- title(self)
- Return the title of the graph.
|
class tablebuffer(buffer) |
| |
Buffer object specialised for dealing with CCP4 tables.
This class extends the 'buffer' class with additional
data and methods specialised for CCP4 tables.
|
| |
Methods defined here:
- __init__(self, maxsize=0)
- Initialise a new tablebuffer object.
- append(self, line)
- Append a line of text to the tablebuffer.
This overrides the append method of the parent class
and performs additional checks on the line being
added, to also identify specific features (such as
'$$' symbols) that are part of a CCP4 table.
- clear(self)
- Clear the tablebuffer of all data.
This overrides the 'clear' method of the parent class
and also resets the flag data that is specific to the
tablebuffer class.
- complete(self)
- Check if the buffer appears to contain a complete table.
Returns 'True' if the buffer contains the following
features, encountered in this order:
1. '$TABLE' token
2. '$GRAPH' or '$SCATTER' token
3. Four '$$' tokens
In this case it is likely that the buffer contains a
complete CCP4 table.
If any of these elements are missing then the method
returns 'False'.
Methods inherited from buffer:
- all(self)
- Return entire buffer contents as a string.
All lines in the buffer will be concatenated into a single
string with line ends terminated by a newline character.
- contents(self, n, m)
- Return lines 'n' through to 'm' as a string.
Return the specified lines from the buffer concatenated
into a single string with line ends terminated by a newline
character.
- getlines(self, n, m)
- Return lines 'n' through to 'm' as a list.
Return a set of lines starting from line index 'n' up to
but not including line index 'm', as a list.
- len(self)
- Return the number of lines currently stored.
- line(self, n)
- Return the n'th line of text from the buffer.
The line will be returned without end-of-line characters.
- tail(self, n=10)
- Return the 'tail' of the buffer.
This returns the last n lines of text stored in the
buffer, concatenated into a single string with end lines
terminated by a newline character.
If a number of lines is not specified then it defaults
to the last 10 lines of text.
| |