Bibulous Module¶
-
bibulous.
sentence_case
(s)[source]¶ Reduce the case of the string to lower case, except for the first character in the string, and except if any given character is at nonzero brace level.
Parameters: s : str
The string to be modified.
Returns: t : str
The resulting modified string.
-
bibulous.
stringsplit
(s, sep=' |(?<!\\\\)~')[source]¶ Split a string into tokens, taking care not to allow the separator to act unless at brace level zero.
Parameters: s : str
The string to split.
Returns: tokens : list of str
The list of tokens.
-
bibulous.
namefield_to_namelist
(namefield, key=None, sep='and', disable=None)[source]¶ Parse a name field (“author” or “editor”) of a BibTeX entry into a list of dicts, one for each person.
Parameters: namefield : str
Either the “author” field of a database entry or the “editor” field.
key : str, optional
The bibliography data entry key.
sep : str, optional
The string defining what to use as a name separator.
disable : list of int, optional
The list of warning message numbers to ignore.
Returns: namelist : list
A list of dictionaries, with one dictionary for each name. Each dict has keys “first”, “middle”, “prefix”, “last”, and “suffix”. The “last” key is the only one that is required.
-
bibulous.
namestr_to_namedict
(namestr, disable=None)[source]¶ Take a BibTeX string representing a single person’s name and parse it into its first, middle, last, etc pieces.
- BibTeX allows three different styles of author formats.
- A space-separated list, [firstname middlenames suffix lastname]
- A two-element comma-separated list, [prefix lastname, firstname middlenames]
- a three-element comma-separated list, [prefix lastname, suffix, firstname middlenames].
So, we can separate these three categories by counting the number of commas that appear.
Parameters: namestr : str
The string containing a single person’s name, in BibTeX format
disable : list of int, optional
The list of warning message numbers to ignore.
Returns: namedict : dict
A dictionary with keys “first”, “middle”, “prefix”, “last”, and “suffix”.
-
bibulous.
initialize_name
(name, options=None, debug=False)[source]¶ From an input name element (first, middle, prefix, last, or suffix) , convert it to its initials.
Parameters: name : str
The name element to be converted.
options : dict of bools, optional
‘french_intials’: whether to initialize digraphs with two letters instead of the default of one. For example, if use_french_initials==True, then “Christian” -> “Ch.”, not “C.”. ‘period_after_initial’: whether to include a ‘.’ after the author initial.
Returns: new_name : str
The name element converted to its initials form.
-
bibulous.
get_delim_levels
(s, delims=('{', '}'), operator=None)[source]¶ Generate a list of level numbers for each character in a string.
Parameters: s : str
The string to characterize.
delims : tuple of two strings
The (left-hand-side delimiter, right-hand-side delimiter).
operator : str
The “operator” string that appears to the left of the delimiter. For example, operator=r’ extbf’ allows the code to look for nested structures like {…} and simultaneously for structures like ` extbf{…}`, and be able to keep track of which is which.
Returns: levels : list of ints
A list giving the operator delimiter level (or “brace level” if no operator is given) of each character in the string.
-
bibulous.
show_levels_debug
(s, levels)[source]¶ A debugging tool for showing delimiter levels and the input string next to one another.
Parameters: s : str
The string used to determine the delimiter levels.
levels : list of ints
The list of delimiter levels at each character position in the string.
-
bibulous.
get_quote_levels
(s, disable=None, debug=False)[source]¶ Return a list which gives the “quotation level” of each character in the string.
Parameters: s : str
The string to analyze.
disable : list of ints, optional
The list of warning message numbers to ignore.
Returns: alevels : list of ints
The double-quote-level for (``,’‘) pairs in the string.
blevels : list of ints
The single-quote-level for (`,’) pairs in the string.
clevels : list of ints
The neutral-quote-level for (“,”) pairs in the string.
Notes
When using double-quotes, it is easy to break the parser, so they should be used only sparingly.
-
bibulous.
splitat
(s, ilist)[source]¶ Split a string at locations given by a list of indices.
This can be used more flexibly than Python’s native string split() function, when the character you are splitting on is not always a valid splitting location.
Parameters: s : str
The string to split.
ilist : list
The list of string index locations at which to split the string.
Returns: slist : list of str
The list of split substrings.
-
bibulous.
multisplit
(s, seps)[source]¶ Split a string using more than one separator.
Copied from http://stackoverflow.com/questions/1059559/python-strings-split-with-multiple-separators.
Parameters: s : str
The string to split.
sep : list of str
The list of separators.
Returns: res : list
The list of split substrings.
-
bibulous.
enwrap_nested_string
(s, delims=('{', '}'), odd_operator='\\textbf', even_operator='\\textrm', disable=None)[source]¶ This function will return the input string if it finds there are no nested operators inside (i.e. when the number of delimiters found is < 2).
Parameters: s : str
The string whose nested operators are to be modified.
delims : tuple of two strings
The left and right delimiters for all matches.
odd_operator : str
The nested operator (applied to the left of the delimiter) currently used within string “s”.
even_operator : str
The operator used to replace the currently used one for all even nesting levels.
disable : list of int, optional
The list of warning message numbers to ignore.
Returns: s : str
The modified string.
-
bibulous.
enwrap_nested_quotes
(s, disable=None, debug=False)[source]¶ Find nested quotes within strings and, if necessary, replace them with the proper nesting (i.e. outer quotes use ``
...''
while inner quotes use`...'
).Parameters: s : str
The string to modify.
disable : list of int, optional
The list of warning message numbers to ignore.
Returns: s : str
The new string in which nested quotes have been properly reformatted.
-
bibulous.
purify_string
(s)[source]¶ Remove the LaTeX-based formatting elements from a string so that a sorting function can use alphanumerical sorting on the string.
Parameters: s : str
The string to “purify”.
Returns: p : str
The “purified” string.
-
bibulous.
latex_to_utf8
(s)[source]¶ Translate LaTeX-markup special characters to their Unicode equivalents.
Parameters: s : str
The string to translate.
Returns: s : str
The translated version of the input.
-
bibulous.
search_middlename_for_prefixes
(namedict)[source]¶ From the middle name of a single person, check if any of the names should be placed into the “prefix” and move them there.
Parameters: namedict : dict
The dictionary containing the key “middle”, containing the string with the person’s middle names/initials.
Returns: namedict : dict
The dictionary augmented with the key “prefix” if a prefix is indeed found.
-
bibulous.
get_edition_ordinal
(edition_field, disable=None)[source]¶ Given a bibliography entry’s edition number, format it as an ordinal (i.e. “1st”, “2nd” instead of “1”, “2”) in the way that it will appear on the formatted page.
Parameters: edition_field : str
The string representing the “edition” field in the database entry.
disable : list of int, optional
The list of warning message numbers to ignore.
Returns: edition_ordinal_str : str
The formatted form of the edition, with ordinal attached.
-
bibulous.
export_bibfile
(bibdata, filename, abbrevs=None)[source]¶ Write a bibliography database dictionary into a .bib file.
Parameters: filename : str
The filename of the file to write.
bibdata : dict
The bibliography dictionary to write out.
abbrevs : dict, optional
The dictionary of abbreviations to write to the BIB file.
-
bibulous.
parse_pagerange
(pages_str, citekey=None, disable=None)[source]¶ Given a string containing the “pages” field of a bibliographic entry, figure out the start and end pages.
Parameters: pages_str : str
The string to parse.
citekey : str, optional
The citation key (useful for debugging messages).
disable : list of int, optional
The list of warning message numbers to ignore.
Returns: startpage : str
The starting page.
endpage : str
The ending page. If endpage==startpage, then endpage is set to None.
-
bibulous.
parse_nameabbrev
(abbrevstr)[source]¶ Given a string containing either a single “name” > “abbreviation” pair or a list of such pairs, parse the string into a dictionary of names and abbreviations.
Parameters: abbrevstr : str
The string containing the abbreviation definitions.
Returns: nameabbrev_dict : dict
A dictionary with names for keys and abbreviations for values.
-
bibulous.
filter_script
(line)[source]¶ Remove elements from a Python script which are provide the most egregious security flaws; also replace some identifiers with their correct namespace representation.
Parameters: line : str
The line of source code to filter.
Returns: filtered : str
The filtered line of source code.
-
bibulous.
str_is_integer
(s)[source]¶ Check is an input string represents an integer value. Although a trivial function, it will be useful for user scripts.
Parameters: s : str
The input string to test.
Returns: is_integer : bool
Whether the string represents an integer value.
-
bibulous.
bib_warning
(msg, disable=None)[source]¶ Print a warning message, with the option to disable any given message.
Parameters: msg : str
The warning message to print.
disable : list of int, optional
The list of warning message numbers that the user wishes to disable (i.e. ignore).
-
bibulous.
create_citation_alpha
(entry, options)[source]¶ Create an “alpha” style citation key (typically the first three letters of the author’s last name, followed by the last two numbers of the year).
Parameters: entry : dict
The bibliography entry.
options : dict
The dictionary of keyword options (the only key used is “name_separator”).
Returns: alpha : str
The alpha-style citation key.
-
bibulous.
toplevel_split
(s, splitchar, levels)[source]¶ Split a string, but only if the splitting character is at level 0 or 1 and not higher.
Parameters: s : str
The string to split.
splitchar : str
The character to split with.
levels : list of ints
The operator levels of the characters in the string.
Returns: split_list : list of str
The list of split sections of the string.
-
bibulous.
get_variable_name_elements
(variable)[source]¶ Split the variable name into “name” (left-hand-side part), “iterator” (middle part), and “remainder” (the right- hand-side part).
With these three elements, we will know how to build a template variable inside the implicit loop.
Parameters: variable : str
The variable name to be parsed.
Returns: var_dict : dict
The dictionary containing elements of the variable name, with keys ‘varname’, ‘prefix’, ‘index’, and ‘suffix’. The input variable can be reconstructed with name + ‘.’ + prefix + index + suffix.
-
bibulous.
format_namelist
(namelist, nametype='author', options=None)[source]¶ Format a list of dictionaries (one dict for each person) into a long string, with the format according to the directives in the bibliography style template.
Parameters: namelist : str
The list of dictionaries containing all of the names to be formatted.
nametype : str, {‘author’, ‘editor’}, optional
Whether the names are for authors or editors.
options : dict, optional
The dictionary of keyword-based options.
Returns: namestr : str
The formatted form of the “name string”. This is generally a list of authors or list of editors.
-
bibulous.
namedict_to_formatted_namestr
(namedict, options=None)[source]¶ Convert a name dictionary into a formatted name string.
Parameters: namedict : dict
The name dictionary (contains a required key “last” and optional keys “first”, “middle”, “prefix”, and “suffix”.
options : dict, optional
Dictionary of formatting options.
Returns: namestr : str
The formatted string of the name.
-
bibulous.
argsort
(seq, reverse=False)[source]¶ Return the indices for producing a sorted list.
Parameters: seq : iterable
The iterable object to sort.
reverse : bool
Whether to return a reversed list.
Returns: idx : list of ints
The indices needed for a sorted list.
-
bibulous.
create_alphanum_citelabels
(entrykey, bibdata, citelist)[source]¶ Create an alphanumeric style citation key (the first letter of the author’s last name, followed by a number giving the sort order).
Warning: do not run this function on a large database of citations — it is not optimized for that use and will take quite a while to complete.
Parameters: entry : dict
The bibliography entry.
bibdata : dict
The entire bibliography database.
citelist : list of str
The sorted list of citation keys.
Returns: citelabels : str
The dictionary of citation labels.
-
bibulous.
get_implicit_loop_data
(templatestr)[source]¶ From a template containing an implicit loop (‘…’ notation), build a full-size template without an ellipsis.
Right now, the code only allows one implicit loop in any given template.
Parameters: templatestr : str
The input template string (containing the implicit loop ellipsis notation).
Returns: loop_data : dict
A dictionary containing all of the information needed to build a loop for a template.
-
class
bibulous.
Bibdata
(filename, disable=None, culldata=True, uselocale=None, silent=False, debug=False)[source]¶ Bibdata is a class to hold all data related to a bibliography database, a citation list, and a style template.
To initialize the class, either call it with the filename of the .aux file containing the relevant file locations (for the .bib database files and the .bst template files) or simply call it with a list of all filenames to be used (i.e. database_name.bib, style_template_name.bst and main_filename.aux). The output file (the LaTeX- formatted bibliography) is assumed to have the same filename root as the .aux file, but with .bbl as its extension.
Attributes
abbrevs (dict) The list of abbreviations given in the bibliography database file(s). The dictionary keys are the abbreviations, and the values are their full forms. bibdata (dict) The database of bibliography entries and fields derived from parsing the bibliography database file(s). bstdict (dict) The style template for formatting the bibliography. The dictionary keys are the entrytypes, with the dictionary values their string template. citedict (dict) The dictionary of citation keys, and their corresponding numerical order of citation. debug (bool) Whether to turn on debugging features. filedict (dict) The ditionary of filenames associated with the bibliographic data. The dictionary consists of keys bib, bst, aux, tex, and bbl. The first two are lists of filenames, while the others contain only a single filename. filename (str) (For error messages and debugging) The name of the file currently being parsed. i (int) (For error messages and debugging) The line of the file currently being parsed. options (dict) The dictionary containing the various option settings from the style template (BST) files. specials (dict) The dictionary containing the special templates from the BST file(s). abbrevkey_pattern (compiled regular expression object) The regex used to search for abbreviation keys. anybrace_pattern (compiled regular expression object) The regex used to search for curly braces { or }. anybraceorquote_pattern (compiled regular expression object) The regex used to search for curly braces or for double-quotes, i.e. {, }, or “. endbrace_pattern (compiled regular expression object) The regex used to search for an ending curly brace, i.e. ‘}’. quote_pattern (compiled regular expression object) The regex used to search for a double-quote, i.e. “. startbrace_pattern (compiled regular expression object) The regex used to search for a starting curly brace, {. culldata (bool) Whether to cull the database so that only cited entries are parsed. Setting this to False means that the entire BIB file database will be parsed. When True, the BIB file parser will only parse those entries corresponding to keys in the citedict. Setting this to True provides significant speedups for large databases. parse_only_entrykeys (bool) When comparing a database file against a citation list, all we are initially interested in are the entrykeys and not the data. So, in our first pass through the database, we can use this flag to skip the data and get only the keys themselves. Methods
parse_bibfile
(filename)Parse a “.bib” file to generate a dictionary representing a bibliography database. parse_bibentry
(entrystr, entrytype)Given a string representing the entire contents of the BibTeX-format bibliography entry, parse the contents and place them into the bibliography preamble string, the set of abbreviations, and the bibliography database dictionary. parse_bibfield
(entrystr[, entrykey])For a given string representing the raw contents of a BibTeX-format bibliography entry, parse the contents into a dictionary of key:value pairs corresponding to the field names and field values. parse_auxfile
(filename[, recursive_call, debug])Read in an .aux file and convert the citation{} entries found there into a dictionary of citekeys and citation order number. parse_bstfile
(filename)Convert a Bibulous-type bibliography style template into a dictionary. write_bblfile
([filename, write_preamble, …])Given a bibliography database bibdata, a dictionary containing the citations called out citedict, and a bibliography style template bstdict write the LaTeX-format file for the formatted bibliography. create_citation_list
()Create the list of citation keys, sorted into the proper order. format_bibitem
(citekey[, debug])Create the “ibitem{…}” string to insert into the “.bbl” file. insert_crossref_data
(entrykey[, fieldname])Insert crossref info into a bibliography database dictionary. write_citeextract
(outputfile[, write_abbrevs])Extract a sub-database from a large bibliography database, with the former containing only those entries cited in the .aux file (and any relevant cross-references). write_authorextract
(searchname[, …])Extract a sub-database from a large bibliography database, with the former containing only those entries citing the given author/editor. replace_abbrevs_with_full
(fieldstr, resultstr)Given an input str, locate the abbreviation key within it and replace the abbreviation with its full form. get_bibfilenames
(filename)If the input is a filename ending in .aux, then read through the .aux file and locate the lines ibdata{…} and ibstyle{…} to get the filename(s) for the bibliography database and style template. check_citekeys_in_datakeys
()Check to see if all of the citation keys (from the AUX file) exist within the current set of database entrykeys. add_crossrefs_to_searchkeys
()Add any cross-referenced entrykeys into the searchkeys, the list which is used to cull the database so that only necessary entries are parsed. insert_specials
(entrykey)Insert “special” fields into a database entry. validate_templatestr
(templatestr, key)Validate the template string so that it contains no formatting errors. fillout_implicit_indices
(templatestr, entrykey)From a template containing an implicit loop (‘…’ notation), build a full-size template without an ellipsis. template_substitution
(templatestr, entrykey)Substitute database entry variables into template string. insert_title_into_template
(title_var, …)Insert the title field into a template string. remove_nested_template_options_brackets
(…)Given a template string, go through each options sequence […] and search for undefined variables. remove_template_options_brackets
(…)Given a template string, go through each options sequence […] and search for undefined variables. simplify_template_bracket
(templatestr, …)From an “options train” […|…|…], find the first fully defined block in the sequence. get_variable
(bibentry, variable[, options])Get the variable (i.e. format_operator_arg
(varname)If the operator argument begins with “option.” then return the content of the options variable following the dot. get_indexed_variable
(field, indexer[, …])Get the result of dot-indexing into a field. get_indexed_vars_in_template
(templatestr)Get a list of the indexed variables within a template. -
add_crossrefs_to_searchkeys
()[source]¶ Add any cross-referenced entrykeys into the searchkeys, the list which is used to cull the database so that only necessary entries are parsed.
-
check_citekeys_in_datakeys
()[source]¶ Check to see if all of the citation keys (from the AUX file) exist within the current set of database entrykeys.
Returns: is_complete : bool
True if all citations exist in the database, False otherwise.
-
fillout_implicit_indices
(templatestr, entrykey, templatekey=None)[source]¶ From a template containing an implicit loop (‘…’ notation), build a full-size template without an ellipsis.
Right now, the code only allows one implicit loop in any given template.
Parameters: templatestr : str
The input template string (containing the implicit loop ellipsis notation).
entrykey : str
The key of the bibliography entry to query.
templatekey : str
If this template is for a special variable rather than an entrytype, then this key will tell which special variable is being operated on.
Returns: new_templatestr : str
The new template with the ellipsis replaced with the loop-generated template variables and “glue”.
-
format_bibitem
(citekey, debug=False)[source]¶ Create the “ibitem{…}” string to insert into the “.bbl” file.
This is the workhorse function of Bibulous. For a given citation key, find the resulting entry in the bibliography database. From the entry’s entrytype, lookup the relevant template in bstdict and start replacing template variables with formatted elements of the database entry. Once you’ve replaced all template variables, you’re done formatting that entry. Write the result to the BBL file.
Parameters: citekey : str
The citation key.
Returns: itemstr : str
The string containing the ibitem{} citation key and LaTeX-formatted string for the formatted bibliography. (That is, this string is designed to be inserted directly into the LaTeX document.)
-
format_operator_arg
(varname)[source]¶ If the operator argument begins with “option.” then return the content of the options variable following the dot. If there is not “option.” at the beginning of the argument, then it’s just a regular string.
-
get_bibfilenames
(filename)[source]¶ If the input is a filename ending in .aux, then read through the .aux file and locate the lines ibdata{…} and ibstyle{…} to get the filename(s) for the bibliography database and style template.
Also determine whether to set the culldata flag. If the input is a single AUX filename, then the default is to set culldata=True. If the input is a list of filenames, then assume that this is the complete list of files to use (i.e. ignore the contents of the AUX file except for generating the citedict), and set culldata=False.
Parameters: filename : str
The “auxiliary” file, containing citation info, TOC info, etc.
Returns: filedict : dict
A dictionary with keys aux, bbl, bib, bst, extract, and tex, each entry of which contains a list of filenames.
-
get_indexed_variable
(field, indexer, entrykey='', options={})[source]¶ Get the result of dot-indexing into a field. This can be accessing an element of a list or dictionary, or the result of operating on a string with a function.
Parameters: field : str
The field to operate on.
indexer : str
The dot-delimited indexing operator.
entrykey : str
The entrykey of the bibliography entry being evaluated (useful for error messages).
options : dict
An optional dictionary giving extra info (such as whether to insert dots after initials).
Returns: result : str
The string resulting from the dot-indexing operation on the field. If a valid operation cannot be performed, then return “None”.
-
get_indexed_vars_in_template
(templatestr)[source]¶ Get a list of the indexed variables within a template.
Parameters: templatestr : str
The template to analyze.
Returns: indexed_vars : list of str
The list of variable names that are indexed variables.
-
get_names
(entry, templatestr)[source]¶ Get the list of names associated with a given entry, giving priority to the first namelist present in the “namelists” list.
Parameters: entry : dict
The bibliography data entry.
templatestr : str
The template string – to tell whether to use authors or editors.
Returns: namelist : list of dicts
The list of names found.
-
get_variable
(bibentry, variable, options={})[source]¶ Get the variable (i.e. entry field) from within the current bibliography entry.
Parameters: bibentry : dict
The bibliography entry to search.
variable : str
The dot-indexed template variable to evaluate.
options : dict
An optional dictionary giving extra info (such as whether to insert dots after initials).
Returns: result : str
The field value (if it exists). If no corresponding field is found, return None.
-
insert_crossref_data
(entrykey, fieldname=None)[source]¶ Insert crossref info into a bibliography database dictionary.
Loop through a bibliography database dictionary and, for each entry which has a “crossref” field, locate the crossref entry and insert any missing bibliographic information into the main entry’s fields.
Parameters: entrykey : str
The key of the bibliography entry to query.
fieldname : str, optional
The name of the field to check. If fieldname==None, then check all fields.
Returns: foundit : bool
Whether the function found a crossref for the queried field. If multiple fieldnames were input, then foundit will be True if a crossref is located for any one of them.
-
insert_specials
(entrykey)[source]¶ Insert “special” fields into a database entry.
Parameters: entrykey : str
The key of the entry to which we want to add special fields.
-
insert_title_into_template
(title_var, templatestr, bibentry)[source]¶ Insert the title field into a template string.
This requires more work than simply performing a string replacement, because there can be punctuation conflicts when the title itself ends with punctuation, while the template itself has punctuation immediately following the title.
Parameters: title_var : str
The title variable (which may simply be “<title>”, or may have operators attached to the variable name.
templatestr : str
The template to insert the title into.
bibentry : dict
The bibliography entry to get the title from.
Returns: templatestr : str
The template with the variable replaced with the “title” field, with possible operators applied.
-
parse_auxfile
(filename, recursive_call=False, debug=False)[source]¶ Read in an .aux file and convert the citation{} entries found there into a dictionary of citekeys and citation order number.
Parameters: filename : str
The filename of the .aux file to parse.
recursive_call : bool
Whether this function was called recursively (recursive_call=True), or if it is the top-level call (recursive_call=False). Only in the latter case do we take the keylist and make self.citedict with it.
-
parse_bibentry
(entrystr, entrytype)[source]¶ Given a string representing the entire contents of the BibTeX-format bibliography entry, parse the contents and place them into the bibliography preamble string, the set of abbreviations, and the bibliography database dictionary.
Parameters: entrystr : str
The string containing the entire contents of the bibliography entry.
entrytype : str
The type of entry (article, preamble, etc.).
-
parse_bibfield
(entrystr, entrykey='')[source]¶ For a given string representing the raw contents of a BibTeX-format bibliography entry, parse the contents into a dictionary of key:value pairs corresponding to the field names and field values.
Parameters: entrystr : str
The string containing the entire contents of the bibliography entry.
entrykey : str
The key of the bibliography entry being parsed (useful for error messages).
Returns: fd : dict
The dictionary of “field name” and “field value” pairs.
-
parse_bibfile
(filename)[source]¶ Parse a “.bib” file to generate a dictionary representing a bibliography database.
Parameters: filename : str
The filename of the .bib file to parse.
-
parse_bstfile
(filename)[source]¶ Convert a Bibulous-type bibliography style template into a dictionary.
The resulting dictionary consists of keys which are the various entrytypes, and values which are the template strings. In addition, any formatting options are stored in the “options” key as a dictionary of option_name:option_value pairs.
Parameters: filename : str
The filename of the Bibulous style template to use.
-
remove_nested_template_options_brackets
(templatestr, entry, variables)[source]¶ Given a template string, go through each options sequence […] and search for undefined variables. In each sequence, return only the block of each sequence in which all variables are defined (i.e. with outer braces removed).
Parameters: templatestr : str
The string defining the template to analyze.
entry : dict
The bibliography database entry inside which to look for variables.
variables : list of str
The variables to look for.
-
remove_template_options_brackets
(templatestr, entry, variables)[source]¶ Given a template string, go through each options sequence […] and search for undefined variables. In each sequence, return only the block of each sequence in which all variables are defined.
Parameters: templatestr : str
The string defining the template to analyze.
entry : dict
The bibliography database entry inside which to look for variables.
variables : list of str
The variables to look for.
-
replace_abbrevs_with_full
(fieldstr, resultstr)[source]¶ Given an input str, locate the abbreviation key within it and replace the abbreviation with its full form.
Once the abbreviation key is found, remove it from the “fieldstr” and add the full form to the “resultstr”.
Parameters: fieldstr : str
The string to search for the abbreviation key.
resultstr : str
The thing to hold the abbreviation’s full form. (Note that it might not be empty on input.)
Returns: fieldstr : str
The string to search for the abbreviation key.
resultstr : str
The thing to hold the abbreviation’s full form.
end_of_field : bool
Whether the abbreviation key was at the end of the current field.
-
simplify_template_bracket
(templatestr, bibentry, variables)[source]¶ From an “options train” […|…|…], find the first fully defined block in the sequence.
A style template string contains grammatical features of the form […|…|…], which we can call options sequences. Each “block” in the sequence (divided from the others by a | symbol), contains fields which, if defined, replace the entire options sequence in the returned string.
When the options sequence ends with “|]” (i.e. at least one of the blocks is required to be defined) but we find that none of the blocks have all their variables defined, then we replace the entire block with the “undefstr”.
Parameters: templatestr : str
The string containing a complete entrytype bibliography style template.
variables : list of str
The list of variables defined within the template string.
bibentry : dict
An entry from the bibliography database.
Returns: arg : str
The string giving the entrytype block to replace an options sequence.
-
template_substitution
(templatestr, entrykey, templatekey=None)[source]¶ Substitute database entry variables into template string.
Parameters: templatestr : str
The template string itself.
entrykey : dict
The key of the database entry from which to get fields to substitute into the template.
templatekey : str
If this template is for a special variable rather than an entrytype, then this key will tell which special variable is being operated on.
Returns: templatestr : str
The template string with all variables replaced.
-
validate_templatestr
(templatestr, key)[source]¶ Validate the template string so that it contains no formatting errors.
Parameters: templatestr : str
The template string to be validated.
key : str
The name of the variable that uses this template.
Returns: okay : bool
Whether or not the template is properly formatted.
Extract a sub-database from a large bibliography database, with the former containing only those entries citing the given author/editor.
Parameters: searchname : str or dict
The string or dictionary for the author’s name. This can be, for example, “Bugs E. Bunny” or {‘first’:’Bugs’, ‘last’:’Bunny’, ‘middle’:’E’}.
outputfile : str, optional
The filename of the extracted BIB file to write.
write_abbrevs : bool
Whether or not to write the abbreviations to the BIB file. Since the abbreviations are already inserted into the database entries, they are no longer needed, but may be useful for future editing and adding of entries to the database file.
-
write_auxfile
(filename=None)[source]¶ Given the input database file(s) and style file(s), write out an AUX file containing citations to all unique database entries.
This function is only provided as a utility, and is not actually used except during troubleshooting.
Parameters: filename : str
The filename of the auxfile to write.
-
write_bblfile
(filename=None, write_preamble=True, write_postamble=True, bibsize=None, debug=False)[source]¶ Given a bibliography database bibdata, a dictionary containing the citations called out citedict, and a bibliography style template bstdict write the LaTeX-format file for the formatted bibliography.
Start with the preamble and then loop over the citations one by one, formatting each entry one at a time, and put end{thebibliography} at the end when done.
Parameters: filename : str, optional
The filename of the “.bbl” file to write. (Default is to take the AUX file and change its extension to “.bbl”.)
write_preamble : bool, optional
Whether to write the preamble. (Setting this to False can be useful when writing the bibliography in separate steps, as in the testing suite.)
write_postamble : bool, optional
Whether to write the postamble. (Setting this to False can be useful when writing the bibliography in separate steps, as in the testing suite.)
bibsize : str, optional
A string the length of which is used to determine the label margin for the bibliography.
-
write_citeextract
(outputfile, write_abbrevs=False)[source]¶ Extract a sub-database from a large bibliography database, with the former containing only those entries cited in the .aux file (and any relevant cross-references).
Parameters: filedict : str
The dictionary filenames must have keys “aux”, “bst”, and “bib”.
outputfile : str, optional
The filename to use for writing the extracted BIB file.
write_abbrevs : bool
Whether or not to write the abbreviations to the BIB file. Since the abbreviations are already inserted into the database entries, they are no longer needed, but may be useful for future editing and adding of entries to the database file.
-


T
- the type of objects that may be compared by this comparator@FunctionalInterface public interface Comparator<T>
Collections.sort
or Arrays.sort
) to allow precise control
over the sort order. Comparators can also be used to control the order of
certain data structures (such as sorted sets
or sorted maps
), or to provide an ordering for collections of
objects that don't have a natural ordering
.The ordering imposed by a comparator c on a set of elements S is said to be consistent with equals if and only if c.compare(e1, e2)==0 has the same boolean value as e1.equals(e2) for every e1 and e2 in S.
Caution should be exercised when using a comparator capable of imposing an ordering inconsistent with equals to order a sorted set (or sorted map). Suppose a sorted set (or sorted map) with an explicit comparator c is used with elements (or keys) drawn from a set S. If the ordering imposed by c on S is inconsistent with equals, the sorted set (or sorted map) will behave "strangely." In particular the sorted set (or sorted map) will violate the general contract for set (or map), which is defined in terms of equals.
For example, suppose one adds two elements a
and b
such that
(a.equals(b) && c.compare(a, b) != 0)
to an empty TreeSet
with comparator c
.
The second add
operation will return
true (and the size of the tree set will increase) because a
and
b
are not equivalent from the tree set's perspective, even though
this is contrary to the specification of the
Set.add
method.
Note: It is generally a good idea for comparators to also implement
java.io.Serializable, as they may be used as ordering methods in
serializable data structures (like TreeSet
, TreeMap
). In
order for the data structure to serialize successfully, the comparator (if
provided) must implement Serializable.
For the mathematically inclined, the relation that defines the imposed ordering that a given comparator c imposes on a given set of objects S is:
{(x, y) such that c.compare(x, y) <= 0}.The quotient for this total order is:
{(x, y) such that c.compare(x, y) == 0}.It follows immediately from the contract for compare that the quotient is an equivalence relation on S, and that the imposed ordering is a total order on S. When we say that the ordering imposed by c on S is consistent with equals, we mean that the quotient for the ordering is the equivalence relation defined by the objects'
equals(Object)
method(s):{(x, y) such that x.equals(y)}.
Unlike Comparable
, a comparator may optionally permit
comparison of null arguments, while maintaining the requirements for
an equivalence relation.
This interface is a member of the Java Collections Framework.
Comparable
,
Serializable
| Modifier and Type | Method and Description |
|---|---|
int |
compare(T o1,
T o2)
Compares its two arguments for order.
|
static <T,U extends Comparable<? super U>> |
comparing(Function<? super T,? extends U> keyExtractor)
Accepts a function that extracts a
Comparable sort key from a type T , and returns a Comparator<T> that compares by that sort key. |
static <T,U> Comparator<T> |
comparing(Function<? super T,? extends U> keyExtractor,
Comparator<? super U> keyComparator)
Accepts a function that extracts a sort key from a type
T , and
returns a Comparator<T> that compares by that sort key using
the specified Comparator . |
static <T> Comparator<T> |
comparingDouble(ToDoubleFunction<? super T> keyExtractor)
Accepts a function that extracts a
double sort key from a type
T , and returns a Comparator<T> that compares by that
sort key. |
static <T> Comparator<T> |
comparingInt(ToIntFunction<? super T> keyExtractor)
Accepts a function that extracts an
int sort key from a type
T , and returns a Comparator<T> that compares by that
sort key. |
static <T> Comparator<T> |
comparingLong(ToLongFunction<? super T> keyExtractor)
Accepts a function that extracts a
long sort key from a type
T , and returns a Comparator<T> that compares by that
sort key. |
boolean |
equals(Object obj)
Indicates whether some other object is "equal to" this
comparator.
|
static <T extends Comparable<? super T>> |
naturalOrder()
Returns a comparator that compares
Comparable objects in natural
order. |
static <T> Comparator<T> |
nullsFirst(Comparator<? super T> comparator)
Returns a null-friendly comparator that considers
null to be
less than non-null. |
static <T> Comparator<T> |
nullsLast(Comparator<? super T> comparator)
Returns a null-friendly comparator that considers
null to be
greater than non-null. |
default Comparator<T> |
reversed()
Returns a comparator that imposes the reverse ordering of this
comparator.
|
static <T extends Comparable<? super T>> |
reverseOrder()
Returns a comparator that imposes the reverse of the natural
ordering.
|
default Comparator<T> |
thenComparing(Comparator<? super T> other)
Returns a lexicographic-order comparator with another comparator.
|
default <U extends Comparable<? super U>> |
thenComparing(Function<? super T,? extends U> keyExtractor)
Returns a lexicographic-order comparator with a function that
extracts a
Comparable sort key. |
default <U> Comparator<T> |
thenComparing(Function<? super T,? extends U> keyExtractor,
Comparator<? super U> keyComparator)
Returns a lexicographic-order comparator with a function that
extracts a key to be compared with the given
Comparator . |
default Comparator<T> |
thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)
Returns a lexicographic-order comparator with a function that
extracts a
double sort key. |
default Comparator<T> |
thenComparingInt(ToIntFunction<? super T> keyExtractor)
Returns a lexicographic-order comparator with a function that
extracts a
int sort key. |
default Comparator<T> |
thenComparingLong(ToLongFunction<? super T> keyExtractor)
Returns a lexicographic-order comparator with a function that
extracts a
long sort key. |
int compare(T o1, T o2)
In the foregoing description, the notation sgn(expression) designates the mathematical signum function, which is defined to return one of -1, 0, or 1 according to whether the value of expression is negative, zero or positive.
The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.)
The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.
Finally, the implementor must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z.
It is generally the case, but not strictly required that (compare(x, y)==0) == (x.equals(y)). Generally speaking, any comparator that violates this condition should clearly indicate this fact. The recommended language is "Note: this comparator imposes orderings that are inconsistent with equals."
o1
- the first object to be compared.o2
- the second object to be compared.NullPointerException
- if an argument is null and this
comparator does not permit null argumentsClassCastException
- if the arguments' types prevent them from
being compared by this comparator.boolean equals(Object obj)
Object.equals(Object)
. Additionally, this method can return
true only if the specified object is also a comparator
and it imposes the same ordering as this comparator. Thus,
comp1.equals(comp2)
implies that sgn(comp1.compare(o1,
o2))==sgn(comp2.compare(o1, o2)) for every object reference
o1 and o2.Note that it is always safe not to override Object.equals(Object). However, overriding this method may, in some cases, improve performance by allowing programs to determine that two distinct comparators impose the same order.
equals
in class Object
obj
- the reference object with which to compare.true
only if the specified object is also
a comparator and it imposes the same ordering as this
comparator.Object.equals(Object)
,
Object.hashCode()
default Comparator<T> reversed()
default Comparator<T> thenComparing(Comparator<? super T> other)
Comparator
considers two elements equal, i.e.
compare(a, b) == 0
, other
is used to determine the order.
The returned comparator is serializable if the specified comparator is also serializable.
other
- the other comparator to be used when this comparator
compares two objects that are equal.NullPointerException
- if the argument is null.default <U> Comparator<T> thenComparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)
Comparator
.U
- the type of the sort keykeyExtractor
- the function used to extract the sort keykeyComparator
- the Comparator
used to compare the sort keyNullPointerException
- if either argument is null.comparing(Function, Comparator)
,
thenComparing(Comparator)
default <U extends Comparable<? super U>> Comparator<T> thenComparing(Function<? super T,? extends U> keyExtractor)
Comparable
sort key.U
- the type of the Comparable
sort keykeyExtractor
- the function used to extract the Comparable
sort keyComparable
sort key.NullPointerException
- if the argument is null.comparing(Function)
,
thenComparing(Comparator)
default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor)
int
sort key.keyExtractor
- the function used to extract the integer sort keyint
sort keyNullPointerException
- if the argument is null.comparingInt(ToIntFunction)
,
thenComparing(Comparator)
default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor)
long
sort key.keyExtractor
- the function used to extract the long sort keylong
sort keyNullPointerException
- if the argument is null.comparingLong(ToLongFunction)
,
thenComparing(Comparator)
default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)
double
sort key.keyExtractor
- the function used to extract the double sort keydouble
sort keyNullPointerException
- if the argument is null.comparingDouble(ToDoubleFunction)
,
thenComparing(Comparator)
static <T extends Comparable<? super T>> Comparator<T> reverseOrder()
The returned comparator is serializable and throws NullPointerException
when comparing null
.
T
- the Comparable
type of element to be comparedComparable
objects.Comparable
static <T extends Comparable<? super T>> Comparator<T> naturalOrder()
Comparable
objects in natural
order.
The returned comparator is serializable and throws NullPointerException
when comparing null
.
T
- the Comparable
type of element to be comparedComparable
objects.Comparable
static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator)
null
to be
less than non-null. When both are null
, they are considered
equal. If both are non-null, the specified Comparator
is used
to determine the order. If the specified comparator is null
,
then the returned comparator considers all non-null values to be equal.
The returned comparator is serializable if the specified comparator is serializable.
T
- the type of the elements to be comparedcomparator
- a Comparator
for comparing non-null valuesnull
to be less than
non-null, and compares non-null objects with the supplied
Comparator
.static <T> Comparator<T> nullsLast(Comparator<? super T> comparator)
null
to be
greater than non-null. When both are null
, they are considered
equal. If both are non-null, the specified Comparator
is used
to determine the order. If the specified comparator is null
,
then the returned comparator considers all non-null values to be equal.
The returned comparator is serializable if the specified comparator is serializable.
T
- the type of the elements to be comparedcomparator
- a Comparator
for comparing non-null valuesnull
to be greater than
non-null, and compares non-null objects with the supplied
Comparator
.static <T,U> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)
T
, and
returns a Comparator<T>
that compares by that sort key using
the specified Comparator
.
The returned comparator is serializable if the specified function and comparator are both serializable.
T
- the type of element to be comparedU
- the type of the sort keykeyExtractor
- the function used to extract the sort keykeyComparator
- the Comparator
used to compare the sort keyComparator
NullPointerException
- if either argument is nullstatic <T,U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor)
Comparable
sort key from a type T
, and returns a Comparator<T>
that compares by that sort key.
The returned comparator is serializable if the specified function is also serializable.
T
- the type of element to be comparedU
- the type of the Comparable
sort keykeyExtractor
- the function used to extract the Comparable
sort keyNullPointerException
- if the argument is nullstatic <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor)
int
sort key from a type
T
, and returns a Comparator<T>
that compares by that
sort key.
The returned comparator is serializable if the specified function is also serializable.
T
- the type of element to be comparedkeyExtractor
- the function used to extract the integer sort keyNullPointerException
- if the argument is nullcomparing(Function)
static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor)
long
sort key from a type
T
, and returns a Comparator<T>
that compares by that
sort key.
The returned comparator is serializable if the specified function is also serializable.
T
- the type of element to be comparedkeyExtractor
- the function used to extract the long sort keyNullPointerException
- if the argument is nullcomparing(Function)
static <T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor)
double
sort key from a type
T
, and returns a Comparator<T>
that compares by that
sort key.
The returned comparator is serializable if the specified function is also serializable.
T
- the type of element to be comparedkeyExtractor
- the function used to extract the double sort keyNullPointerException
- if the argument is nullcomparing(Function)
Dracula Javadoc Sample, Made with Allan Im.


--- title: Class RecordChangedCallback description: RecordChangedCallback navLabel: RecordChangedCallback category: interface body_class: dark ---
Called when the listener is added via Record .subscribe(RecordChangedCallback,boolean)
Will contain the entire record data, regardless of whether triggered by a Patch or Update
recordName
- The name of the record changedata
- The entire data as a JsonElement, can be retrieved via JsonElement .getAsJsonObject ()


Stochastic source example¶
If you want to run the following example on your local machine, you are welcome to download the code here and run it (after having pip-installed the package).
Finally we demonstrate how the PECUZAL method deals with non-deterministic input data. Therefore, we create a simple AR(1)-process:
import numpy as np
import matplotlib.pyplot as plt
def ar_process(u0, alpha, p, N):
'''Generate `N`-sample data from an auto regressive process of order 1 with autocorrelation-parameter
`alpha` and amplitude `p` for an intial condition value `u0`.
'''
x = np.zeros(N+10)
x[0] = u0
for i in range(1,N+10):
x[i] = alpha*x[i-1] + p*np.random.randn()
return x[10:]
u0 = .2
data = ar_process(u0, .9, .2, 2000)
plt.figure()
plt.plot(data)
plt.title('AR(1) process')
plt.xlabel('sample')
plt.grid()
When we now call the PECUZAL algorithm pecuzal_embedding.pecuzal_embedding()
from pecuzal_embedding import pecuzal_embedding
Y_reconstruct, tau_vals, ts_vals, Ls, eps = pecuzal_embedding(data, econ = True)
we’ll get the following note in the console:
Algorithm stopped due to increasing L-values in the first embedding cycle.. Valid embedding NOT achieved.
The algorithm did not obtain any valid embedding, thus, it values the input data as a non-deterministic source.


Numbers 13:24
The place was called the brook Eshcol, because of the cluster of grapes which the children of Israel cut down from thence.


| Reference | Class List | Member Functions | Typedefs | File List |
Thread pools are a mechanism for asynchronous and parallel processing within the same process. The pool class provides a convenient way for dispatching asynchronous tasks as functions objects. The scheduling of these tasks can be easily controlled by using customized schedulers. A task must not throw an exception.
A pool is DefaultConstructible, CopyConstructible and Assignable. It has reference semantics; all copies of the same pool are equivalent and interchangeable. All operations on a pool except assignment are strongly thread safe or sequentially consistent; that is, the behavior of concurrent calls is as if the calls have been issued sequentially in an unspecified order.
| Task | A function object which implements the operator 'void operator() (void) const'. The operator () is called by the pool to execute the task. Exceptions are ignored. | |
| SchedulingPolicy | A task container which determines how tasks are scheduled. It is guaranteed that this container is accessed only by one thread at a time. The scheduler shall not throw exceptions. |
Scheduling policies: fifo_scheduler, lifo_scheduler, prio_scheduler
Definition at line 73 of file pool.hpp.
Public Types | |
| typedef SchedulingPolicy< task_type > | scheduler_type |
| typedef SizePolicyController< pool_core_type > | size_controller_type |
| typedef SizePolicy< pool_core_type > | size_policy_type |
| typedef Task | task_type |
Public Member Functions | |
| size_t | active () const |
| void | clear () |
| bool | empty () const |
| size_t | pending () const |
| bool | schedule (task_type const &task) |
| size_t | size () const |
| size_controller_type | size_controller () |
| thread_pool (size_t initial_threads=0) | |
| bool | wait (xtime const ×tamp, size_t task_threshold=0) const |
| void | wait (size_t task_threshold=0) const |
|
|
Indicates the scheduler's type.
|
|
|
|
|
|
|
|
|
Indicates the task's type.
|
|
|
Constructor.
|
|
|
Returns the number of tasks which are currently executed.
|
|
|
Removes all pending tasks from the pool's scheduler. |
|
|
Indicates that there are no tasks pending.
|
|
|
Returns the number of tasks which are ready for execution.
|
|
|
Schedules a task for asynchronous execution. The task will be executed once only.
|
|
|
Gets the number of threads in the pool.
|
|
|
Gets the size controller which manages the number of threads in the pool.
|
|
|
The current thread of execution is blocked until the timestamp is met or the sum of all active and pending tasks is equal or less than a given threshold.
|
|
|
The current thread of execution is blocked until the sum of all active and pending tasks is equal or less than a given threshold.
|


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 2
Dietary
Little cooks can make these tasty falafel balls with only a bit of grown-up help.
Before cooking, wash your hands and put an apron on. Weigh or measure all the ingredients. Brush a baking tray generously with vegetable oil. Ask a grown-up to preheat the oven at 200C/400F/Gas 6.
Start by placing the drained beans and the garlic clove in the plastic bag and mashing with the rolling pin then transferring into bowl.
Ask a grown-up to help you use the scissors to cut off the roots and the dark green top of the spring onions – this is called topping and tailing. Finely cut up the rest of the spring onion and add to the beans. Then chop up the fresh coriander finely with the scissors and add it to the bean mash.
Sprinkle over the dried cumin, you can add more if you really like the taste. Sprinkle over the plain flour and mix everything together well. Now squeeze the mixture with your hands until it all starts to stick together.
 Put on the oiled baking sheet and dab the top with a little more oil.
Ask a grown-up to put them in the oven for 12-15 minutes. Leave to cool for about five minutes to allow them to set before eating. Serve warm or cold in pitta pockets with salad leaves.


"OX GOAD "mentioned only in Judges 3:31, the weapon with which Shamgar (q.v.) slew six hundred Philistines. “The ploughman still carries his goad, a weapon apparently more fitted for the hand of the soldier than the peaceful husbandman. The one I saw was of the ‘oak of Bashan,’ and measured upwards of ten feet in length. At one end was an iron spear, and at the other a piece of the same metal flattened. One can well understand how a warrior might use such a weapon with effect in the battle-field”(Porter’s Syria, etc.). (See GOAD.)
"OX GOAD "mentioned only in Judges 3:31, the weapon with which Shamgar (q.v.) slew six hundred Philistines. “The ploughman still carries his goad, a weapon apparently more fitted for the hand of the soldier than the peaceful husbandman. The one I saw was of the ‘oak of Bashan,’ and measured upwards of ten feet in length. At one end was an iron spear, and at the other a piece of the same metal flattened. One can well understand how a warrior might use such a weapon with effect in the battle-field”(Porter’s Syria, etc.). (See GOAD.)


 Photography, Mark Irwin. Editing, O.Nicholas Brown. Production design, Carol Winstead Wood. Music, Richard Gibbs. Produced by Andrew Lazar. Cast: Heath Ledger (Patrick Verona), Julia Stiles (Katarina Stratford), Joseph-Gordon Levitt (Cameron James), Larisa Oleynik (Bianca Stratford), David Krumholtz (Michael Eckman), Andrew Keegan (Joey Donner), Susan May Pratt (Mandella), Gabrielle Union (Chastity), Larry Miller (Walter Stratford), Daryl (Chill) Mitchell ( Morgan) and Allison Janney (Ms. Perky). A Touchstone (Disney) release. Pictures. 93 minutes. PG-13.
The lack of Cold War movies has left a gap --but the teen genres never die, Shakespeare is up, classic English novels are up, and the old repertories of American directors and writers have given way to a bewildering number of new names, both in mainstream and independent film-making.
It was fated that at some point literature and high school would finally meet. They did in 10 Things, but whoa! You don't really expect a high school flick with students studying and learning, do you? No such thing in the Land of the Free.
The way the Bard and the kids get together, as directed by a an experiences TV person inhis first featurem and as written by first-timers, is to take The Taming of the Shrew and deviously transport it to an institution of middle non-education. Well, it's Shakespeare and not Shakespeare, in about the proportions of a mouse to an elephant. But it's a big mouse. Still, those who call this movie an updating or modernizing of the play should have their Bard examined.I wonder why the credits don't say "Based on an idea by Bill Shakespeare"?
There's a general concept of the father and the daughters. Here Padua's Signor Baptista becomes Walter Stratford, his senior daughter Katharina ("Kiss Me Kate") is Kat, and the younger one, Bianca, remains Bianca.
The Stratford girls (get the joke?) go to Padua (sic) High School that ought to get acting credit here. Played by that huge, superbly kitschy Stadium High School in Tacoma, it looks like a cross between some of the palaces the oil-barons built some 100 years ago, the Chateau Frontenac of Quebec City, and other massively wild follies.
Bianca, who's vague and vaguely sweet, is popular. Period. There's nothing vague about Kat. She's clearly a brilliant. But also a young Dragon Lady, though unladylike as she goes around spreading haughtily her misanthropy, militant feminism, disrespect (to put it mildly) of the entire staff and student body whom she insults perpetually for their conformism, stupidity, you name it. Her tongue is caustic and tart, and I don't mean like a Tarte Tatin. Her manners are to match. She even backs up on purpose into the car of Joey Donner, the school's pretty boy (and a professional model) who is full of money and you-know-what. (Well, he had it coming).
The kids, with some exceptions (for audiences who keep up with TV) are not played by familiar faces. They look generic, including Bianca and Kat, no beauties, but then the latter, Julia Stiles, does a beaut of a job with her role.  In uniform, with boots, a couple of German shephers dogs and a thicker waist, she'd be perfect.
Daddy is played with restrained humor by Larry Miller in a secondary but original role. A single parent, an MD . A gynecologist I believe, but then the movie has the habit of leaving matters vague and with loose ends. He's seen too many awful pregnancies, births, abortions and such.  No dates, no fooling around, he has decreed. This may be OK with Kat, whom he knows well. After school he casually asks her "Did you make anybody cry today?" "Sadly, no" she replies "But it's only 4:30." That's what's known as a felicitous repartee.
Bianca is another story.  Eventually, smart Daddy comes up with a pronunciamento. "You can date if Kat does" which he is positive will never happen. And thereby hangs the essence of the story.
To liberate Bianca, Joey tries to set up Kat with someone. No piece of cake, this. The only possible candidate is tough-looking, Australian-born (like the actor who plays him) Patrick Verona (Get the references to Two Gentlemen of Verona?) But Patrick is no gentleman, or so it would seem. "What! He's a CRIMINAL! " exclaims one of the boys who is assisting Joey so that some other pal who's sweet on Bianca can have a chance. He recites a litany of the would-be suitor's horrible record which includes a break from San Quentin (or something of the sort) and facts such as "He sold his own liver for a new pair of speakers!" "He ate a live duck!" Unfazed, Joey bribes Patrick to date Kat, even though the boy from Down Under keeps upping the ante. And that's where the courtship, the taming, the rigueur misunderstandings begin.
It's an odd thing. Up to this approximate point the movie was clever and very entertaining nonsense and way out funny details. But as we reach what should be the core of the story, things go limp. Sure, there were cliches before this, but freshly and imaginatively cooked, along with some original bits.
Now the totally predictable is upon us, with unnecessary diversions, sub-plots and asides that distract, add dead weight, put the breaks on what was until now a fast-moving car. Kat is delighted to get accepted by Sarah Lawrence College (back East) but Daddy is unhappy that she'll be so far. So? Patrick visits a rather dismal femme-club. This adds little to the developments. I expected Maenads to attack this sole male customer, but no.
Pat is too quickly,too obviously transformed, via hairdo and makeup, from the "criminal," sullen type to a nice, neat fellow. Luxury student cars abound. They limit the human interest as they set the film among the Children of the Rich. (At least either Kat or Bianca leaven this later by asking Dad "What's a hot rod?")
Irrelevancies and inconsistencies gather. At a party (deja vu all over again), Kat gets drunk, which is what reveals her true (i.e.nice but hidden) self. Is this promoting liquor among the under-aged as a catalyst of truth? By party-time the film has lost its impetus, has become aimless. It puts in too much padding --which means that there's too little for the movie proper. The inevitable prom, the Golden Fleece of high school movies, doesn't help either.
No question about it, there are nuggets even among the pebbles of Part II : Kat's brazen, sexy invasion of a detention schoolroom; recurring quotations from Shakespeare's other works, aimed, no doubt, at the literati. Even better, in both parts are several scenes with two supporting characters who steal the show again and again. Mr. Morgan is a most likable and non-cliched teacher of English (or writing) who raps deliciously the lines of the Bard and whose familiar give-and-take with his students is sheer pleasure. Equally appealing is Mrs. Perky, the guidance counselor whose own rapport with the kids is a howl, especially as she never stops writing a porno novel on her desk-top computer. Hilarious. And she casually asks both the students and her secretary for synonyms, as for an enlarged male member. Fast-reacting Kat comes up with a winner: "tumescent."
A pity that this picture starts on a strong three-star level but loses steam approximately past the halfway mark. Perhaps one should eventually get a video and save on tape all the scenes with Dr. Stratford, Mr. Morgan and Mrs. Perky.
" Le mauvais gout mene au crime" (Stendhal)
Edwin Jahiel's movie reviews are at http://www.prairienet.org/ejahiel
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


O! Savage & vile & pink & bloated thing!
Curs'd uncanny globule of despair!
Monstrous, too! So pale & shuddering!
Its gleaming talons clawing at my hair!
Hast this being come t’ announce my doom?
Its head is like a chaffinch or a gull.
It has been sent by Doctor Bogenbroom,
Invoked by minstrel-wizards Jethro Tull.


|
FlatBuffers
An open source project by FPL.
|
Helper class to hold data needed in creation of a FlatBuffer. More...
#include <flatbuffers.h>
Helper class to hold data needed in creation of a FlatBuffer.
To serialize data, you typically call one of the Create*()
functions in the generated code, which in turn call a sequence of StartTable
/ PushElement
/AddElement
/EndTable
, or the builtin CreateString
/ CreateVector
functions. Do this is depth-first order to build up a tree to the root. Finish()
wraps up the buffer ready for transport.
Classes | |
| struct | FieldLoc |
| struct | StringOffsetCompare |
Public Member Functions | |
| void | Clear () |
| Reset all the state in this FlatBufferBuilder so it can be reused to construct another buffer. More... | |
| Offset< String > | CreateSharedString (const char *str, size_t len) |
| Store a string in the buffer, which can contain any binary data. More... | |
| Offset< String > | CreateSharedString (const char *str) |
| Store a string in the buffer, which null-terminated. More... | |
| Offset< String > | CreateSharedString (const std::string &str) |
| Store a string in the buffer, which can contain any binary data. More... | |
| Offset< String > | CreateSharedString (const String *str) |
| Store a string in the buffer, which can contain any binary data. More... | |
| Offset< String > | CreateString (const char *str, size_t len) |
| Store a string in the buffer, which can contain any binary data. More... | |
| Offset< String > | CreateString (const char *str) |
| Store a string in the buffer, which is null-terminated. More... | |
| Offset< String > | CreateString (char *str) |
| Store a string in the buffer, which is null-terminated. More... | |
| Offset< String > | CreateString (const std::string &str) |
| Store a string in the buffer, which can contain any binary data. More... | |
| Offset< String > | CreateString (flatbuffers::string_view str) |
| Store a string in the buffer, which can contain any binary data. More... | |
| Offset< String > | CreateString (const String *str) |
| Store a string in the buffer, which can contain any binary data. More... | |
| template<typename T > | |
| Offset< String > | CreateString (const T &str) |
| Store a string in the buffer, which can contain any binary data. More... | |
| template<typename T > | |
| Offset< const T * > | CreateStruct (const T &structobj) |
| Write a struct by itself, typically to be part of a union. | |
| uoffset_t | CreateUninitializedVector (size_t len, size_t elemsize, uint8_t **buf) |
Specialized version of CreateVector for non-copying use cases. More... | |
| template<typename T > | |
| Offset< Vector< T > > | CreateUninitializedVector (size_t len, T **buf) |
Specialized version of CreateVector for non-copying use cases. More... | |
| template<typename T > | |
| Offset< Vector< const T * > > | CreateUninitializedVectorOfStructs (size_t len, T **buf) |
| template<typename T > | |
| Offset< Vector< T > > | CreateVector (const T *v, size_t len) |
Serialize an array into a FlatBuffer vector . More... | |
| template<typename T > | |
| Offset< Vector< Offset< T > > > | CreateVector (const Offset< T > *v, size_t len) |
| template<typename T > | |
| Offset< Vector< T > > | CreateVector (const std::vector< T > &v) |
Serialize a std::vector into a FlatBuffer vector . More... | |
| Offset< Vector< uint8_t > > | CreateVector (const std::vector< bool > &v) |
| template<typename T > | |
| Offset< Vector< T > > | CreateVector (size_t vector_size, const std::function< T(size_t i)> &f) |
Serialize values returned by a function into a FlatBuffer vector . More... | |
| template<typename T , typename F , typename S > | |
| Offset< Vector< T > > | CreateVector (size_t vector_size, F f, S *state) |
Serialize values returned by a function into a FlatBuffer vector . More... | |
| template<typename T , typename S > | |
| Offset< Vector< const T * > > | CreateVectorOfNativeStructs (const S *v, size_t len) |
Serialize an array of native structs into a FlatBuffer vector . More... | |
| template<typename T , typename S > | |
| Offset< Vector< const T * > > | CreateVectorOfNativeStructs (const std::vector< S > &v) |
Serialize a std::vector of native structs into a FlatBuffer vector . More... | |
| template<typename T , typename S > | |
| Offset< Vector< const T * > > | CreateVectorOfSortedNativeStructs (std::vector< S > *v) |
Serialize a std::vector of native structs into a FlatBuffer vector in sorted order. More... | |
| template<typename T , typename S > | |
| Offset< Vector< const T * > > | CreateVectorOfSortedNativeStructs (S *v, size_t len) |
Serialize an array of native structs into a FlatBuffer vector in sorted order. More... | |
| template<typename T > | |
| Offset< Vector< const T * > > | CreateVectorOfSortedStructs (std::vector< T > *v) |
Serialize a std::vector of structs into a FlatBuffer vector in sorted order. More... | |
| template<typename T > | |
| Offset< Vector< const T * > > | CreateVectorOfSortedStructs (T *v, size_t len) |
Serialize an array of structs into a FlatBuffer vector in sorted order. More... | |
| template<typename T > | |
| Offset< Vector< Offset< T > > > | CreateVectorOfSortedTables (Offset< T > *v, size_t len) |
Serialize an array of table offsets as a vector in the buffer in sorted order. More... | |
| template<typename T > | |
| Offset< Vector< Offset< T > > > | CreateVectorOfSortedTables (std::vector< Offset< T >> *v) |
Serialize an array of table offsets as a vector in the buffer in sorted order. More... | |
| Offset< Vector< Offset< String > > > | CreateVectorOfStrings (const std::vector< std::string > &v) |
Serialize a std::vector<std::string> into a FlatBuffer vector . More... | |
| template<typename T > | |
| Offset< Vector< const T * > > | CreateVectorOfStructs (const T *v, size_t len) |
Serialize an array of structs into a FlatBuffer vector . More... | |
| template<typename T > | |
| Offset< Vector< const T * > > | CreateVectorOfStructs (size_t vector_size, const std::function< void(size_t i, T *)> &filler) |
Serialize an array of structs into a FlatBuffer vector . More... | |
| template<typename T , typename F , typename S > | |
| Offset< Vector< const T * > > | CreateVectorOfStructs (size_t vector_size, F f, S *state) |
Serialize an array of structs into a FlatBuffer vector . More... | |
| template<typename T , typename Alloc > | |
| Offset< Vector< const T * > > | CreateVectorOfStructs (const std::vector< T, Alloc > &v) |
Serialize a std::vector of structs into a FlatBuffer vector . More... | |
| void | DedupVtables (bool dedup) |
| By default vtables are deduped in order to save space. More... | |
| template<typename T > | |
| void | Finish (Offset< T > root, const char *file_identifier=nullptr) |
| Finish serializing a buffer by writing the root offset. More... | |
| template<typename T > | |
| void | FinishSizePrefixed (Offset< T > root, const char *file_identifier=nullptr) |
| Finish a buffer with a 32 bit size field pre-fixed (size of the buffer following the size field). More... | |
| FlatBufferBuilder (size_t initial_size=1024, Allocator *allocator=nullptr, bool own_allocator=false, size_t buffer_minalign=AlignOf< largest_scalar_t >()) | |
| Default constructor for FlatBufferBuilder. More... | |
| FlatBufferBuilder (FlatBufferBuilder &&other) | |
| Move constructor for FlatBufferBuilder. | |
| void | ForceDefaults (bool fd) |
| In order to save space, fields that are set to their default value don't get serialized into the buffer. More... | |
| size_t | GetBufferMinAlignment () |
| get the minimum alignment this buffer needs to be accessed properly. More... | |
| uint8_t * | GetBufferPointer () const |
Get the serialized buffer (after you call Finish() ). More... | |
| uint8_t * | GetCurrentBufferPointer () const |
| Get a pointer to an unfinished buffer. More... | |
| uoffset_t | GetSize () const |
| The current size of the serialized buffer, counting from the end. More... | |
| FlatBufferBuilder & | operator= (FlatBufferBuilder &&other) |
| Move assignment operator for FlatBufferBuilder. | |
| DetachedBuffer | Release () |
| Get the released DetachedBuffer. More... | |
| DetachedBuffer | ReleaseBufferPointer () |
| Get the released pointer to the serialized buffer. More... | |
| uint8_t * | ReleaseRaw (size_t &size, size_t &offset) |
| Get the released pointer to the serialized buffer. More... | |
| void | Reset () |
| void | Swap (FlatBufferBuilder &other) |
Static Public Attributes | |
| static const size_t | kFileIdentifierLength = 4 |
| The length of a FlatBuffer file header. | |
Protected Types | |
| typedef std::set< Offset< String >, StringOffsetCompare > | StringOffsetMap |
Protected Member Functions | |
| void | Finish (uoffset_t root, const char *file_identifier, bool size_prefix) |
| FlatBufferBuilder (const FlatBufferBuilder &) | |
| FlatBufferBuilder & | operator= (const FlatBufferBuilder &) |
Protected Attributes | |
| vector_downward | buf_ |
| bool | dedup_vtables_ |
| bool | finished |
| bool | force_defaults_ |
| voffset_t | max_voffset_ |
| size_t | minalign_ |
| bool | nested |
| uoffset_t | num_field_loc |
| StringOffsetMap * | string_pool |
|
inlineexplicit |
Default constructor for FlatBufferBuilder.
| [in] | initial_size | The initial size of the buffer, in bytes. Defaults to 1024 . |
| [in] | allocator | An Allocator to use. If null will use DefaultAllocator . |
| [in] | own_allocator | Whether the builder/vector should own the allocator. Defaults to / false . |
| [in] | buffer_minalign | Force the buffer to be aligned to the given minimum alignment upon reallocation. Only needed if you intend to store types with custom alignment AND you wish to read the buffer in-place directly after creation. |
|
inline |
Reset all the state in this FlatBufferBuilder so it can be reused to construct another buffer.
|
inline |
Store a string in the buffer, which can contain any binary data.
If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string.
| [in] | str | A const char pointer to the data to be stored as a string. |
| [in] | len | The number of bytes that should be stored from str . |
Store a string in the buffer, which null-terminated.
If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string.
| [in] | str | A const char pointer to a C-string to add to the buffer. |
Store a string in the buffer, which can contain any binary data.
If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string.
| [in] | str | A const reference to a std::string to store in the buffer. |
Store a string in the buffer, which can contain any binary data.
If a string with this exact contents has already been serialized before, instead simply returns the offset of the existing string.
| [in] | str | A const pointer to a String struct to add to the buffer. |
Store a string in the buffer, which can contain any binary data.
| [in] | str | A const char pointer to the data to be stored as a string. |
| [in] | len | The number of bytes that should be stored from str . |
Store a string in the buffer, which is null-terminated.
| [in] | str | A const char pointer to a C-string to add to the buffer. |
Store a string in the buffer, which is null-terminated.
| [in] | str | A char pointer to a C-string to add to the buffer. |
Store a string in the buffer, which can contain any binary data.
| [in] | str | A const reference to a std::string to store in the buffer. |
Store a string in the buffer, which can contain any binary data.
| [in] | str | A const string_view to copy in to the buffer. |
Store a string in the buffer, which can contain any binary data.
| [in] | str | A const pointer to a String struct to add to the buffer. |
|
inline |
Store a string in the buffer, which can contain any binary data.
| [in] | str | A const reference to a std::string like type with support of T::c_str() and T::length() to store in the buffer. |
|
inline |
Specialized version of CreateVector
for non-copying use cases.
Write the data any time later to the returned buffer pointer buf
.
| [in] | len | The number of elements to store in the vector . |
| [in] | elemsize | The size of each element in the vector . |
| [out] | buf | A pointer to a uint8_t pointer that can be written to at a later time to serialize the data into a vector in the buffer. |
|
inline |
Specialized version of CreateVector
for non-copying use cases.
Write the data any time later to the returned buffer pointer buf
.
| T | The data type of the data that will be stored in the buffer as a vector . |
| [in] | len | The number of elements to store in the vector . |
| [out] | buf | A pointer to a pointer of type T that can be written to at a later time to serialize the data into a vector in the buffer. |
|
inline |
Serialize an array into a FlatBuffer vector
.
| T | The data type of the array elements. |
| [in] | v | A pointer to the array of type T to serialize into the buffer as a vector . |
| [in] | len | The number of elements to serialize. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize a std::vector
into a FlatBuffer vector
.
| T | The data type of the std::vector elements. |
| v | A const reference to the std::vector to serialize into the buffer as a vector . |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize values returned by a function into a FlatBuffer vector
.
This is a convenience function that takes care of iteration for you.
| T | The data type of the std::vector elements. |
| f | A function that takes the current iteration 0..vector_size-1 and returns any type that you can construct a FlatBuffers vector out of. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize values returned by a function into a FlatBuffer vector
.
This is a convenience function that takes care of iteration for you.
| T | The data type of the std::vector elements. |
| f | A function that takes the current iteration 0..vector_size-1, and the state parameter returning any type that you can construct a FlatBuffers vector out of. |
| state | State passed to f. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize an array of native structs into a FlatBuffer vector
.
| T | The data type of the struct array elements. |
| S | The data type of the native struct array elements. |
| [in] | v | A pointer to the array of type S to serialize into the buffer as a vector . |
| [in] | len | The number of elements to serialize. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize a std::vector
of native structs into a FlatBuffer vector
.
| T | The data type of the std::vector struct elements. |
| S | The data type of the std::vector native struct elements. |
| [in] |
|
inline |
Serialize a std::vector
of native structs into a FlatBuffer vector
in sorted order.
| T | The data type of the std::vector struct elements. |
| S | The data type of the std::vector native struct elements. |
| [in] |
|
inline |
Serialize an array of native structs into a FlatBuffer vector
in sorted order.
| T | The data type of the struct array elements. |
| S | The data type of the native struct array elements. |
| [in] | v | A pointer to the array of type S to serialize into the buffer as a vector . |
| [in] | len | The number of elements to serialize. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize a std::vector
of structs into a FlatBuffer vector
in sorted order.
| T | The data type of the std::vector struct elements. |
| [in] |
|
inline |
Serialize an array of structs into a FlatBuffer vector
in sorted order.
| T | The data type of the struct array elements. |
| [in] | v | A pointer to the array of type T to serialize into the buffer as a vector . |
| [in] | len | The number of elements to serialize. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize an array of table
offsets as a vector
in the buffer in sorted order.
| T | The data type that the offset refers to. |
| [in] | v | An array of type Offset<T> that contains the table offsets to store in the buffer in sorted order. |
| [in] | len | The number of elements to store in the vector . |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize an array of table
offsets as a vector
in the buffer in sorted order.
| T | The data type that the offset refers to. |
| [in] | v | An array of type Offset<T> that contains the table offsets to store in the buffer in sorted order. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize a std::vector<std::string>
into a FlatBuffer vector
.
This is a convenience function for a common case.
| v | A const reference to the std::vector to serialize into the buffer as a vector . |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize an array of structs into a FlatBuffer vector
.
| T | The data type of the struct array elements. |
| [in] | v | A pointer to the array of type T to serialize into the buffer as a vector . |
| [in] | len | The number of elements to serialize. |
Offset
into the serialized data indicating where the vector is stored.
|
inline |
Serialize an array of structs into a FlatBuffer vector
.
| T | The data type of the struct array elements. |
| [in] | f | A function that takes the current iteration 0..vector_size-1 and a pointer to the struct that must be filled. |
Offset
into the serialized data indicating where the vector is stored. This is mostly useful when flatbuffers are generated with mutation accessors.
|
inline |
Serialize an array of structs into a FlatBuffer vector
.
| T | The data type of the struct array elements. |
| [in] | f | A function that takes the current iteration 0..vector_size-1, a pointer to the struct that must be filled and the state argument. |
| [in] | state | Arbitrary state to pass to f. |
Offset
into the serialized data indicating where the vector is stored. This is mostly useful when flatbuffers are generated with mutation accessors.
|
inline |
Serialize a std::vector
of structs into a FlatBuffer vector
.
| T | The data type of the std::vector struct elements. |
| [in] |
|
inline |
By default vtables are deduped in order to save space.
| [in] | bool | dedup When set to true , dedup vtables. |
|
inline |
Finish serializing a buffer by writing the root offset.
| [in] | file_identifier | If a file_identifier is given, the buffer will be prefixed with a standard FlatBuffers file header. |
|
inline |
Finish a buffer with a 32 bit size field pre-fixed (size of the buffer following the size field).
These buffers are NOT compatible with standard buffers created by Finish, i.e. you can't call GetRoot on them, you have to use GetSizePrefixedRoot instead. All >32 bit quantities in this buffer will be aligned when the whole size pre-fixed buffer is aligned. These kinds of buffers are useful for creating a stream of FlatBuffers.
|
inline |
In order to save space, fields that are set to their default value don't get serialized into the buffer.
| [in] | bool | fd When set to true , always serializes default values that are set. Optional fields which are not set explicitly, will still not be serialized. |
|
inline |
get the minimum alignment this buffer needs to be accessed properly.
This is only known once all elements have been written (after you call Finish()). You can use this information if you need to embed a FlatBuffer in some other buffer, such that you can later read it without first having to copy it into its own buffer.
|
inline |
Get the serialized buffer (after you call Finish()
).
uint8_t
pointer to the FlatBuffer data inside the buffer.
|
inline |
Get a pointer to an unfinished buffer.
uint8_t
pointer to the unfinished buffer.
|
inline |
The current size of the serialized buffer, counting from the end.
uoffset_t
with the current size of the buffer.
|
inline |
Get the released DetachedBuffer.
DetachedBuffer
that owns the buffer and its allocator.
|
inline |
Get the released pointer to the serialized buffer.
FlatBuffer
that owns the buffer and its allocator and behaves similar to a unique_ptr
with a deleter. Deprecated: use Release() instead
|
inline |
Get the released pointer to the serialized buffer.
| The | size of the memory block containing the serialized FlatBuffer . |
| The | offset from the released pointer where the finished FlatBuffer starts. |
FlatBuffer
.


Login to subscribe to events
Get yourself registered to get started..
Email is required
Enter a valid email
Password is required
Enter valid password. Password must be 5 characters long
User Name is required
Enter a valid Zipcode
Password must be atleast 5 characters long


{% extends "base.html" %} {% block title %}About | Pythonexpress{% endblock %} {% block content %}
We are the team of volunteers who wanted to teach python and create awareness about Python programming Language


Admin
Dashboard
Tables
Building Status
Payments
Clients
Add Client
Admin
Logout
Storage Container(s)
Amount Due Monthly
Last Month Paid
Phone Number
Record a Payment
Name
Date
Payment
Method...
Square
Cash
Amount
Sumbit
Update Client
Phone
Email
Add Storage Units
Remove Building
Submit
Ready to Leave?
×
Select "Logout" below if you are ready to end your current session.


{% load staticfiles %} {% load scout_filters %} {% block content %}
No results? Try updating your filters.
Suggestions for improving the results:


I am a techie who likes hiking and backpacking as a hobby and to keep me grounded while working in the
Cloud, hence my slogan. I have a long term unrealized goal of automating and training myself out of a job.
{{ site.data.language.read_more }}
{% include list-posts entries='5' offset='0' %}


I recently graduated from Northwestern University with a major in Industrial Engineering and now work at KPMG as a Cyber Security Services Associate.
I enjoy learning about all types of technology and am currently expanding my knowledge in coding different languages
Feel free to email me at BradHerzog@gmail.com


Metamagical Themas : Questing for the Essence of Mind and Pattern; Douglas R. Hofstadter; Paperback; $20.70;
Le Ton Beau De Marot : The Spark and Sparkle of Creative Translation; Douglas R. Hofstadter, Clement a Une Damoyselle Malade Marot; Hardcover; $27.00 ;
The Tumult of Inner Voices or What Is the Meaning of the Word 'I'?; Douglas R. Hofstadter; Hardcover; $10.35
Fluid Concepts & Creative Analogies : Computer Models of the Fundamental Mechanisms of Thought; Douglas Hofstadter; Hardcover (Hard to Find)
The Mind's I : Fantasies and Reflections on Self and Soul; Douglas R., Hofstadter; Hardcover (Hard to Find)
This page is maintained by Alexander Chislenko


| 600 | (A) | thay wanne vpe fułł wyghtly the walles to kepe |
| 603 | (C) | They wenten vp wyȝtly . þe walles to kepe |
| 597 | (D) | They went vp wightly þe wallis to kepe |
| 589 | (E) | ¶ Thei wentyn vp whiȝtly . þe walles to keepe |
| (Ex) | ---- no text ---- | |
| 618 | (L) | þei wynnen vp whyȝtly þe walles to kepe |
| 558 | (P) | þai wan vp lightely þe walles to kepe |
| 597 | (U) | Thei wenten vp wightly / the walles to kepe |
| (V) | ---- no text ---- |


Radio buttons are a special kind of field, since they come in groups, sharing the same name but having different values.
Luga Validator validates a set of radios with the same name as a unique entity. So, inside a set of radios, you can define the validation attributes only once (if you specify attributes with conflicting values, the last one wins):
<input name="drink" type="radio" class="boxes" value="Nicole" data-lugavalidator-required="true"/>
<input name="drink" type="radio" class="boxes" value="Kate"/>


Spilhuset is a magical place located in the heart of Copenhagen. Historically home to some of the nations best game developers, Spilhuset is the perfect environment for game and tech startups to meet, think, build and celebrate. Since the mid 2000s, talented and ambitious startups have contributed to our community’s culture, making it Denmark’s biggest cluster of game companies.
With the spirit of the community, we’re opening a cozy 620 m2 apartment-style coworking space. This new space offers the perfect compromise between intimate working space and tech community. From private space (desk or room) to conference rooms and common areas, we provide everything startups need to succeed.
As a company or individual in Spilhuset you get access to a fully furnished office environment in lovely surroundings. Height adjustable tables and great office chairs. High speed internet access, regularly cleaned spaces and optional lunch arrangements. Everyone has access to both small and large meeting rooms, our big dining hall and several cozy nooks for co-working or relaxing. In other words, it’s the perfect place to work on your dream project.
Watch the residents talk about SpilhusetCommon rooms and flexible desks
1100 DKK/mo
Starting price
Get in touch Learn more
A flexible membership is for you who want a fantastic workplace a few times a week
You don't need to think about all the practical stuff because we take care of internet, cleaning, alarmsystems, printer, tea-kitchen, a fully equipped kitchen, meeting room and a postal address. It’s ideal for freelancers and small teams working flexible schedules
We've got brand new office chairs and height adjustable tables
You can join our optional catered lunches (at a fee)
A flexible membership is exactly that, flexible. There is no interminability and you can cancel your subscription at any time
Establishment fee: 399,-
All Prices are excl. VAT
Your own desk
2.900 DKK/mo
Starting price
Get in touch Learn more
A full-time membership is for you who want your own personal desk in Spilhuset
You only need to focus on your work because we take care of internet, cleaning, alarmsystems, printer, tea-kitchen, a fully equipped kitchen, several meeting rooms, a cool lobby and a postal address
We've got brand new office chairs and height adjustable tables
You can join our optional catered lunches (at a fee)
Your desk can be in an open environment or in a lockable joint room with your own key for an additional price of 299,-/mo.
Access 24/7
Deposit: 3 months rent
Establishment fee: 399,-
All Prices are excl. VAT
A private office
Custom
Get in touch Learn more
We offer private appartment style offices with your own key. Here your team can work in a safe and cozy environment while we take care of all the practical things.
Your team will have access to a tea-kitchen, a fully equipped kitchen, several meeting rooms, a cool lobby, a big dininghall for events and obviously your own postal adress
We've got brand new office chairs and height adjustable tables but if you already have furniture we can also work that out
You can join our optional catered lunches (at a fee).
Access 24/7
Contact us for a custom solution
All Prices are excl. VAT
A flexible membership is for you who want a fantastic workplace a few times a week
You don't need to think about all the practical stuff because we take care of internet, cleaning, alarmsystems, printer, tea-kitchen, a fully equipped kitchen, meeting room and a postal address. It’s ideal for freelancers and small teams working flexible schedules
We've got brand new office chairs and height adjustable tables
You can join our optional catered lunches (at a fee)
A flexible membership is exactly that, flexible. There is no interminability and you can cancel your subscription at any time
Access 24/7
Establishment fee: 399,-
All Prices are excl. VAT
A full-time membership is for you who want your own personal desk in Spilhuset
You only need to focus on your work because we take care of internet, cleaning, alarmsystems, printer, tea-kitchen, a fully equipped kitchen, several meeting rooms, a cool lobby and a postal address
We've got brand new office chairs and height adjustable tables
You can join our optional catered lunches (at a fee)
Your desk can be in an open environment or in a lockable joint room with your own key for an additional price of 299,-/mo.
Access 24/7
Deposit: 3 months rent
All Prices are excl. VAT
We offer private appartment style offices with your own key. Here your team can work in a safe and cozy environment while we take care of all the practical things.
Your team will have access to a tea-kitchen, a fully equipped kitchen, several meeting rooms, a cool lobby, a big dininghall for events and obviously your own postal adress
We've got brand new office chairs and height adjustable tables but if you already have furniture we can also work that out
You can join our optional catered lunches (at a fee).
Access 24/7
Contact us for a custom solution
All Prices are excl. VAT


Your Name: Your Company: Phone Number: Email Address: Job Description/Comments:
Download FREE EllipsisDesign wallpaper! download instructions or, want to Leave us a comment...
design of the week or Choose from the Gallery


Struct Request
Structure Request provides configuration, connection pooling, cookie persistance. You can consider it as 'Session'.
struct Request
;
Fields
| Name | Type | Description |
|---|---|---|
_authenticator
|
Auth | Auth provider |
_bind
|
string | bind outgoing connections to this addr (name or ip) |
_bufferSize
|
ulong | io buffer size |
_cm
|
std | connection cache |
_contentType
|
string | content type for POST/PUT requests |
_cookie
|
std | cookie storage |
_headers
|
string[string] | user-provided headers(use addHeader to add) |
_interceptors
|
Interceptor[] | user-provided interceptors |
_keepAlive
|
bool | use keepalive requests |
_maxContentLength
|
ulong | maximum content length |
_maxHeadersLength
|
ulong | maximum headers length |
_maxRedirects
|
uint | limit redirect number |
_method
|
string | method (GET, POST, ...) |
_multipartForm
|
MultipartForm | multipart form (for multipart POST requests) |
_params
|
std | request parameters |
_permanent_redirects
|
string[requests | permanent redirect cache |
_postData
|
requests | unified interface for post data |
_proxy
|
string | http/https proxy |
_socketFactory
|
requests | user-provided socket factory |
_sslOptions
|
requests | |
_sslSetVerifyPeer
|
bool | verify peer when using ssl |
_timeout
|
core | timeout for connect/send/receive |
_uri
|
requests | uri for the request |
_userHeaders
|
_UH | |
_useStreaming
|
bool | use streaming when receive response |
_verbosity
|
uint | logging verbosity |
Properties
| Name | Type | Description |
|---|---|---|
authenticator [get]
|
inout(Auth) | |
authenticator [set]
|
Auth | |
bind [get]
|
inout(string) | |
bind [set]
|
string | |
bufferSize [get]
|
inout(ulong) | |
bufferSize [set]
|
ulong | |
cm [get]
|
std | |
contentType [get]
|
inout(string) | |
cookie [get]
|
inout(std | |
cookie [set]
|
std | |
hasMultipartForm [get]
|
bool | helper |
headers [get]
|
inout(string[string]) | |
headers [set]
|
string[string] | |
keepAlive [get]
|
inout(bool) | |
keepAlive [set]
|
bool | |
maxContentLength [get]
|
inout(ulong) | |
maxContentLength [set]
|
ulong | |
maxHeadersLength [get]
|
inout(ulong) | |
maxHeadersLength [set]
|
ulong | |
maxRedirects [get]
|
inout(uint) | |
maxRedirects [set]
|
uint | |
method [get]
|
inout(string) | |
method [set]
|
string | |
multipartForm [get]
|
inout(MultipartForm) | |
params [get]
|
inout(std | |
path [get, set]
|
string | Set/Get path for next request. |
permanent_redirects [get]
|
inout(string[requests | |
postData [get]
|
inout(requests | |
proxy [get]
|
inout(string) | |
proxy [set]
|
string | |
socketFactory [get]
|
requests | |
socketFactory [set]
|
requests | |
sslOptions [get]
|
inout(requests | |
sslSetCaCert [set]
|
string | Set path to certificate authority file. |
sslSetCertFile [set]
|
string | Set path and format for ssl certificate file. |
sslSetKeyFile [set]
|
string | Set path and format for ssl key file. |
sslSetVerifyPeer [set]
|
bool | Enable/disable ssl peer verification.. |
timeout [get]
|
inout(core | |
timeout [set]
|
core | |
uri [get]
|
inout(requests | |
uri [set]
|
string | Set and Get uri for next request. |
useStreaming [get]
|
inout(bool) | |
useStreaming [set]
|
bool | |
verbosity [get]
|
inout(uint) | |
verbosity [set]
|
uint | |
userHeaders [get]
|
_UH |
Methods
| Name | Description |
|---|---|
addHeaders
|
Add headers to request |
addInterceptor
|
Add interceptor to request. |
clearHeaders
|
Remove any previously added headers. |
deleteRequest
|
|
deleteRequest
|
|
exec
|
Execute GET for http and retrieve file for FTP. You have to provide at least uri. All other arguments should conform to HTTPRequest.get or FTPRequest.get depending on the URI scheme. When arguments do not conform scheme (for example you try to call get("ftp://somehost.net/pub/README", {"a":"b"}) which doesn't make sense) you will receive Exception("Operation not supported for ftp") |
exec
|
|
execute
|
|
execute
|
|
execute
|
|
format
|
|
get
|
|
get
|
|
patch
|
|
patch
|
|
patch
|
|
post
|
|
post
|
|
post
|
|
post
|
|
put
|
|
put
|
|
put
|
|
toString
|
Inner classes
| Name | Description |
|---|---|
LastInterceptor
|
Aliases
| Name | Description |
|---|---|
__xdtor
|
|
__xpostblit
|