diff options
Diffstat (limited to 'Master/tlpkg/archive')
| -rw-r--r-- | Master/tlpkg/archive/lib/C/Makefile | 7 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/C/tlp-config.c | 75 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/C/tlp-config.h | 23 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/C/tlp-src.c | 321 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/C/tlp-src.h | 75 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/C/tlp-utils.c | 182 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/C/tlp-utils.h | 73 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/bash/TeXLiveInfra.sh | 261 | ||||
| -rw-r--r-- | Master/tlpkg/archive/lib/python/TeXLive.py | 1744 |
9 files changed, 2761 insertions, 0 deletions
diff --git a/Master/tlpkg/archive/lib/C/Makefile b/Master/tlpkg/archive/lib/C/Makefile new file mode 100644 index 00000000000..396b9744290 --- /dev/null +++ b/Master/tlpkg/archive/lib/C/Makefile @@ -0,0 +1,7 @@ +CFLAGS = -Wall -I. +SO = dylib + +all: libtlp.$(SO) + +libtlp.$(SO): tlp-src.o tlp-config.o tlp-utils.o + $(CC) $^ -dynamiclib -o $@ diff --git a/Master/tlpkg/archive/lib/C/tlp-config.c b/Master/tlpkg/archive/lib/C/tlp-config.c new file mode 100644 index 00000000000..5633db611dd --- /dev/null +++ b/Master/tlpkg/archive/lib/C/tlp-config.c @@ -0,0 +1,75 @@ +/* tlp-config.c - module exporting configuration stuff + * + * Copyright 2007 Jjgod Jiang + * Derived from the Perl implementation by Norbert Preining + * + * This file is licensed under the GNU General Public License version 2 + * or any later version. */ + +#include <tlp-utils.h> +#include <stdlib.h> + +#define TLP_META_CATEGORIES "Collection", "Scheme" +#define TLP_NORMAL_CATEGORIES "Package", "TLCore", "Documentation" +#define TLP_DEFAULT_CATEGORY "Package" + +const char *_tlp_meta_categories[] = { + TLP_META_CATEGORIES, +}; + +const char *_tlp_normal_categories[] = { + TLP_NORMAL_CATEGORIES, +}; + +const char *_tlp_categories[] = { + TLP_META_CATEGORIES, + TLP_NORMAL_CATEGORIES, +}; + +tlp_str_list *tlp_meta_categories; +tlp_str_list *tlp_normal_categories; +tlp_str_list *tlp_categories; +tlp_str tlp_default_category; + +#define ARR_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) + +/* TODO: we might have more complicated implementation later. */ +tlp_result tlp_config_init() +{ + tlp_meta_categories = tlp_str_list_from_array(_tlp_meta_categories); + if (tlp_meta_categories == NULL) + goto failed1; + + tlp_normal_categories = tlp_str_list_from_array(_tlp_normal_categories); + if (tlp_normal_categories == NULL) + goto failed2; + + tlp_categories = tlp_str_list_from_array(_tlp_categories); + if (tlp_categories == NULL) + goto failed3; + + tlp_default_category = tlp_str_from_bytes(TLP_DEFAULT_CATEGORY); + if (tlp_default_category == NULL) + goto failed4; + + return TLP_OK; + +failed4: + tlp_str_list_free(tlp_categories); +failed3: + tlp_str_list_free(tlp_normal_categories); +failed2: + tlp_str_list_free(tlp_meta_categories); +failed1: + return TLP_FAILED; +} + +void tlp_config_free() +{ + tlp_str_list_free(tlp_meta_categories); + tlp_str_list_free(tlp_normal_categories); + tlp_str_list_free(tlp_categories); + + tlp_str_free(tlp_default_category); +} + diff --git a/Master/tlpkg/archive/lib/C/tlp-config.h b/Master/tlpkg/archive/lib/C/tlp-config.h new file mode 100644 index 00000000000..c00e2143c84 --- /dev/null +++ b/Master/tlpkg/archive/lib/C/tlp-config.h @@ -0,0 +1,23 @@ +/* tlp-config.c - header exporting configuration stuff + * + * Copyright 2007 Jjgod Jiang + * Derived from the Perl implementation by Norbert Preining + * + * This file is licensed under the GNU General Public License version 2 + * or any later version. */ + +#ifndef __TLP_CONFIG__ +#define __TLP_CONFIG__ + +/* We use the following pointers to encapsulate the real config module + * implementation: we could use static allocated arrays, or we could + * use dynamic allocated ones, as long as we follow the rule (put a + * NULL pointer at the end of it), internal implementation does not + * matter. */ + +extern tlp_str_list tlp_meta_categories; +extern tlp_str_list tlp_normal_categories; +extern tlp_str_list tlp_categories; + +#endif + diff --git a/Master/tlpkg/archive/lib/C/tlp-src.c b/Master/tlpkg/archive/lib/C/tlp-src.c new file mode 100644 index 00000000000..a67aacbb74f --- /dev/null +++ b/Master/tlpkg/archive/lib/C/tlp-src.c @@ -0,0 +1,321 @@ +/* tlp-src.c - module for using tlpsrc files + * + * Copyright 2007 Jjgod Jiang + * Derived from the Perl implementation by Norbert Preining + * + * This file is licensed under the GNU General Public License version 2 + * or any later version. */ + +#include <tlp-src.h> +#include <stdio.h> + +/* internal function prototypes {{{ */ + +tlp_result tlp_src_process_line(tlp_src *src, tlp_str line, + int *started, int *finished, + const char *file); + +tlp_result tlp_str_get_word(tlp_str str, tlp_str word, int max); + +tlp_result tlp_src_get_name(tlp_str line, + tlp_src *src, + int *started, + const char *file); + +tlp_result tlp_src_get_category(tlp_str line, + tlp_src *src, + int *started, + const char *file); + +/* }}} */ + +/* internal data structures {{{ */ + +struct tlp_src_field { + const char *key; + tlp_result (*func)(tlp_str line, + tlp_src *src, + int *started, + const char *file); +}; + +/* for lines start with "name", we use function tlp_src_get_name() to + * process it, and feed it with the current tlp_src instance. */ + +struct tlp_src_field tlp_src_fields[] = { + { "name", tlp_src_get_name }, + { "category", tlp_src_get_category }, /* + { "shortdesc", tlp_src_get_shortdesc }, + { "longdesc", tlp_src_get_longdesc }, + { "catalogue", tlp_src_get_catalogue }, + + { "runpatterns", tlp_src_get_runpatterns }, + { "srcpatterns", tlp_src_get_srcpatterns }, + { "docpatterns", tlp_src_get_docpatterns }, + { "binpatterns", tlp_src_get_binpatterns }, + + { "execute", tlp_src_get_execute }, + { "depend", tlp_src_get_depend }, */ +}; + +#define TLP_SRC_TOTAL_FIELDS (sizeof(tlp_src_fields) / sizeof(tlp_src_fields[0])) + +/* }}} */ + +/* tlp_src related {{{ */ + +tlp_src *tlp_src_new(tlp_str name, + tlp_str category, + tlp_str shortdesc, + tlp_str longdesc, + tlp_str catalogue, + tlp_pattern *runpatterns, + tlp_pattern *srcpatterns, + tlp_pattern *docpatterns, + tlp_pattern *binpatterns, + tlp_execute *executes, + tlp_depend *depends) +{ + tlp_src *src = tlp_new(tlp_src); + if (! src) + return NULL; + + src->name = tlp_str_copy(name); + src->category = tlp_str_copy(category); + src->shortdesc = tlp_str_copy(shortdesc); + src->longdesc = tlp_str_copy(longdesc); + src->catalogue = tlp_str_copy(catalogue); + + src->runpatterns = runpatterns; + src->srcpatterns = srcpatterns; + src->docpatterns = docpatterns; + src->binpatterns = binpatterns; + + src->executes = executes; + src->depends = depends; + + return src; +} + +void tlp_src_free(tlp_src *src) +{ + if (! src) + return; + + tlp_str_free(src->name); + tlp_str_free(src->category); + tlp_str_free(src->shortdesc); + tlp_str_free(src->longdesc); + tlp_str_free(src->catalogue); + + tlp_patterns_free(src->runpatterns); + tlp_patterns_free(src->srcpatterns); + tlp_patterns_free(src->docpatterns); + tlp_patterns_free(src->binpatterns); + + tlp_executes_free(src->executes); + tlp_depends_free(src->depends); + + free(src); + src = NULL; +} + +tlp_src *tlp_src_from_file(char *file) +{ + FILE *fp; + tlp_src *src; + tlp_char line[TLP_SRC_LINE_MAX]; + int started, finished; + + fp = fopen(file, "r"); + if (! fp) + return NULL; + + src = tlp_new(tlp_src); + + /* TODO: if the argument is not readable as is, try looking + * for it in the hierarchy where we are.*/ + if (! src) + return NULL; + + started = finished = 0; + + while (tlp_fgets(line, TLP_SRC_LINE_MAX, fp)) + { + if (tlp_src_process_line(src, line, + &started, + &finished, + file) != TLP_OK) + goto failed; + } + + fclose(fp); + return src; + +failed: + tlp_src_free(src); + fclose(fp); + return NULL; +} + +tlp_result tlp_src_process_line(tlp_src *src, tlp_str line, + int *started, int *finished, + const char *file) +{ + int i; + + /* skip all leading spaces */ + for (i = 0; tlp_char_is_space(line[i]); i++) + ; + + /* skip comment lines */ + if (line[i] == TLP_CHAR_COMMENT) + return TLP_OK; + + if (tlp_char_is_eol(line[i])) + { + if (! *started || *finished) + return TLP_OK; + + tlp_error_msg("%s: empty line not allowed in tlpsrc\n", file); + return TLP_FAILED; + } + + /* something like " name ..." is not allowed */ + if (line[0] == ' ') + { + tlp_error_msg("%s: continuation line not allowed in tlpsrc: ", file); + tlp_error_str(line); + + return TLP_FAILED; + } + + for (i = 0; i < TLP_SRC_TOTAL_FIELDS; i++) + if (tlp_str_start_with_bytes(line, tlp_src_fields[i].key)) + return tlp_src_fields[i].func(line, src, started, file); + + tlp_error_msg("%s: unknown tlpsrc directive, please fix: %s", + file, line); + return TLP_OK; +} + +tlp_result tlp_src_get_name(tlp_str line, + tlp_src *src, + int *started, + const char *file) +{ + tlp_char name[TLP_SRC_NAME_MAX]; + + if (*started) + { + tlp_error_msg("%s: tlpsrc cannot have two name directives", file); + return TLP_FAILED; + } + + if (tlp_str_get_word(line + tlp_str_len(TLP_STR("name")), + name, TLP_SRC_NAME_MAX) == TLP_OK) + { + src->name = tlp_str_copy(name); + *started = 1; + + return TLP_OK; + } + else + return TLP_FAILED; +} + +tlp_result tlp_src_get_category(tlp_str line, + tlp_src *src, + int *started, + const char *file) +{ + if (! *started) + { + tlp_error_msg("%s: first tlpsrc directive must be 'name'", file); + return TLP_FAILED; + } + + return TLP_OK; +} + +/* }}} */ + +/* tlp_pattern related {{{ */ + +void tlp_pattern_free(tlp_pattern *pat) +{ + if (pat != NULL) + return; + + switch (pat->type) + { + case TLP_PATTERN_T: + tlp_str_list_free(pat->u.t); + break; + + case TLP_PATTERN_F: + tlp_str_free(pat->u.f); + break; + + case TLP_PATTERN_D: + tlp_str_free(pat->u.d); + break; + + case TLP_PATTERN_R: + tlp_str_free(pat->u.r); + break; + } + + free(pat); + pat = NULL; +} + +void tlp_patterns_free(tlp_pattern *pat) +{ + tlp_pattern *node = pat, *temp; + + while (node != NULL) + { + temp = node->next; + tlp_pattern_free(node); + node = temp; + } + + pat = NULL; +} + +/* }}} */ + +/* remaining stuff used in tlp_src processing {{{ */ + +tlp_result tlp_str_get_word(tlp_str str, tlp_str word, int max) +{ + int i, j; + + /* skip all leading spaces */ + for (i = 0; tlp_char_is_space(str[i]); i++) + ; + + j = 0; + for (; ! tlp_char_is_eol(str[i]); i++) + { + if (str[i] != TLP_CHAR('-') && + ! tlp_char_in_word(str[i])) + return TLP_FAILED; + + if (j >= max) + return TLP_FAILED; + + word[j++] = str[i]; + } + + if (j == 0) + return TLP_FAILED; + + word[j] = TLP_CHAR_END; + return TLP_OK; +} + +/* }}} */ + +/* vim:set ts=4 sts=4 sw=4 expandtab foldmethod=marker: */ diff --git a/Master/tlpkg/archive/lib/C/tlp-src.h b/Master/tlpkg/archive/lib/C/tlp-src.h new file mode 100644 index 00000000000..cf04de32dc7 --- /dev/null +++ b/Master/tlpkg/archive/lib/C/tlp-src.h @@ -0,0 +1,75 @@ +/* tlp-src.h - header for using tlpsrc files + * + * Copyright 2007 Jjgod Jiang + * Derived from the Perl implementation by Norbert Preining + * + * This file is licensed under the GNU General Public License version 2 + * or any later version. */ + +#ifndef __TLP_SRC__ +#define __TLP_SRC__ + +#include <tlp-utils.h> + +enum tlp_src_limits { + TLP_SRC_LINE_MAX = 1024, + TLP_SRC_NAME_MAX = 256, +}; + +enum tlp_pattern_type { + TLP_PATTERN_T, TLP_PATTERN_F, + TLP_PATTERN_D, TLP_PATTERN_R +}; + +typedef struct tlp_pattern { + enum tlp_pattern_type type; + + union { + tlp_str_list *t; + tlp_str f; + tlp_str d; + tlp_str r; + } u; + + struct tlp_pattern *next; +} tlp_pattern; + +typedef struct tlp_src { + /* name of the package */ + tlp_str name; + /* Collection Scheme TLCore Package Documentation */ + tlp_str category; + /* short one line desc */ + tlp_str shortdesc; + /* longer multiline dscription */ + tlp_str longdesc; + /* name of the respective Catalogue entry */ + tlp_str catalogue; + + tlp_pattern *runpatterns; + tlp_pattern *srcpatterns; + tlp_pattern *docpatterns; + tlp_pattern *binpatterns; + + tlp_execute *executes; + tlp_depend *depends; +} tlp_src; + +tlp_src *tlp_src_new(tlp_str name, + tlp_str category, + tlp_str shortdesc, + tlp_str longdesc, + tlp_str catalogue, + tlp_pattern *runpatterns, + tlp_pattern *srcpatterns, + tlp_pattern *docpatterns, + tlp_pattern *binpatterns, + tlp_execute *executes, + tlp_depend *depends); + +void tlp_src_free(tlp_src *src); +void tlp_patterns_free(tlp_pattern *pat); +void tlp_pattern_free(tlp_pattern *pat); + +#endif + diff --git a/Master/tlpkg/archive/lib/C/tlp-utils.c b/Master/tlpkg/archive/lib/C/tlp-utils.c new file mode 100644 index 00000000000..864b7a0597c --- /dev/null +++ b/Master/tlpkg/archive/lib/C/tlp-utils.c @@ -0,0 +1,182 @@ +/* tlp-utils.h - module for general tlp utilities + * + * Copyright 2007 Jjgod Jiang + * Derived from the Perl implementation by Norbert Preining + * + * This file is licensed under the GNU General Public License version 2 + * or any later version. */ + +#include <tlp-utils.h> +#include <string.h> +#include <stdio.h> +#include <ctype.h> + +tlp_str tlp_str_from_bytes(const char *bytes) +{ + return (tlp_str) strdup(bytes); +} + +tlp_str tlp_str_copy(tlp_str str) +{ + if (str == NULL) + return NULL; + + return strdup(str); +} + +void tlp_str_free(tlp_str str) +{ + free(str); +} + +tlp_str_list *tlp_str_list_new() +{ + tlp_str_list *list = tlp_new(tlp_str_list); + if (list == NULL) + return NULL; + + list->head = list->tail = NULL; + return list; +} + +tlp_str_list *tlp_str_list_from_array(const char *array[]) +{ + tlp_str_list *list = tlp_str_list_new(); + int i, size; + + if (list == NULL) + return NULL; + + size = sizeof(array) / sizeof(array[0]); + for (i = 0; i < size; i++) + if (tlp_str_list_append_bytes(list, array[i]) != TLP_OK) + { + tlp_str_list_free(list); + return NULL; + } + + return list; +} + +tlp_result tlp_str_list_append(tlp_str_list *list, tlp_str str) +{ + tlp_str_list_node *node = tlp_new(tlp_str_list_node); + + if (node == NULL) + return TLP_FAILED; + + node->str = str; + node->next = NULL; + + if (list->head == NULL) + list->head = node; + + if (list->tail == NULL) + list->tail = node; + + else + { + list->tail->next = node; + list->tail = node; + } + + return TLP_OK; +} + +tlp_result tlp_str_list_append_bytes(tlp_str_list *list, const char *bytes) +{ + tlp_str str = tlp_str_from_bytes(bytes); + if (str == NULL) + return TLP_FAILED; + + return tlp_str_list_append(list, str); +} + +void tlp_str_list_free(tlp_str_list *list) +{ + tlp_str_list_node *node = list->head, *temp; + + while (node != NULL) + { + temp = node->next; + + tlp_str_free(node->str); + free(node); + + node = temp; + } + + free(list); + list = NULL; +} + +tlp_str tlp_fgets(tlp_str s, int n, FILE *fp) +{ + return (tlp_str) fgets((char *) s, n, fp); +} + +void tlp_str_output(FILE *fp, tlp_str str) +{ + fprintf(stderr, "%s", (char *) str); +} + +size_t tlp_str_len(tlp_str str) +{ + return strlen((const char *) str); +} + +int tlp_str_start_with(tlp_str str, tlp_str prefix) +{ + int len = tlp_str_len(prefix); + + if (tlp_str_len(str) < len) + return 0; + + return strncmp((const char *) str, + (const char *) prefix, len); +} + +int tlp_str_start_with_bytes(tlp_str str, const char *prefix) +{ + tlp_str prefix_str; + int ret; + + prefix_str = tlp_str_from_bytes(prefix); + if (prefix_str == NULL) + return 0; + + ret = tlp_str_start_with(str, prefix_str); + + tlp_str_free(prefix_str); + return ret; +} + +int tlp_char_is_space(tlp_char ch) +{ + return isspace((int) ch); +} + +int tlp_char_is_eol(tlp_char ch) +{ + return (ch == '\r' || ch == '\n'); +} + +int tlp_char_in_word(tlp_char ch) +{ + return (isalnum(ch) || ch == '_'); +} + +void tlp_error_msg(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); +} + +void tlp_error_str(tlp_str str) +{ + tlp_str_output(stderr, str); +} + diff --git a/Master/tlpkg/archive/lib/C/tlp-utils.h b/Master/tlpkg/archive/lib/C/tlp-utils.h new file mode 100644 index 00000000000..a2332bf8d4f --- /dev/null +++ b/Master/tlpkg/archive/lib/C/tlp-utils.h @@ -0,0 +1,73 @@ +/* tlp-utils.h - header for general tlp definitions + * + * Copyright 2007 Jjgod Jiang + * Derived from the Perl implementation by Norbert Preining + * + * This file is licensed under the GNU General Public License version 2 + * or any later version. */ + +#ifndef __TLP_UTILS__ +#define __TLP_UTILS__ + +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> + +typedef char tlp_char; +typedef tlp_char *tlp_str; + +#define TLP_CHAR(x) ((tlp_char) x) + +enum tlp_special_chars { + TLP_CHAR_COMMENT = TLP_CHAR('#'), + TLP_CHAR_END = TLP_CHAR('\0'), +}; + +typedef struct tlp_str_list_node { + tlp_str str; + struct tlp_str_list_node *next; +} tlp_str_list_node; + +typedef struct tlp_str_list { + struct tlp_str_list_node *head; + struct tlp_str_list_node *tail; +} tlp_str_list; + +typedef tlp_str_list tlp_execute; +typedef tlp_str_list tlp_depend; + +#define tlp_executes_free(x) tlp_str_list_free(x) +#define tlp_depends_free(x) tlp_str_list_free(x) + +typedef enum tlp_result { + TLP_FAILED = 0, TLP_OK = 1 +} tlp_result; + +#define tlp_new(x) ((x *) malloc(sizeof(x))) + +tlp_str tlp_str_from_bytes(const char *bytes); +tlp_str tlp_str_copy(tlp_str str); +void tlp_str_free(tlp_str str); + + +tlp_str_list *tlp_str_list_new(); +tlp_str_list *tlp_str_list_from_array(const char *array[]); +tlp_result tlp_str_list_append(tlp_str_list *list, tlp_str str); +tlp_result tlp_str_list_append_bytes(tlp_str_list *list, const char *bytes); +void tlp_str_list_free(tlp_str_list *list); + +tlp_str tlp_fgets(tlp_str s, int n, FILE *fp); +size_t tlp_str_len(tlp_str str); +void tlp_str_output(FILE *fp, tlp_str str); +int tlp_str_start_with(tlp_str str, tlp_str prefix); +int tlp_str_start_with_bytes(tlp_str str, const char *prefix); + +int tlp_char_is_space(tlp_char ch); +int tlp_char_is_eol(tlp_char ch); +int tlp_char_in_word(tlp_char ch); + +void tlp_error_msg(const char *fmt, ...); +void tlp_error_str(tlp_str str); + +#endif + diff --git a/Master/tlpkg/archive/lib/bash/TeXLiveInfra.sh b/Master/tlpkg/archive/lib/bash/TeXLiveInfra.sh new file mode 100644 index 00000000000..f3eca766017 --- /dev/null +++ b/Master/tlpkg/archive/lib/bash/TeXLiveInfra.sh @@ -0,0 +1,261 @@ +# $Id$ +# TeXLiveInfra.sh - shell library for the access to TLDB and TLP +# +# Copyright 2007 Norbert Preining +# This file is licensed under the GNU General Public License version 2 +# or any later version. + +die() { + echo $* + exit 1 +} + +test_tlp() { + tlpfile="$1" + if [ ! -r "$tlpfile" ] ; then + die "tlp file not readable: $tlpfile" + fi +} + +# we read the whole tlp again and again +# if we could use some multi-line grepping this could be speed up +# but I guess we would need perl regexp grepping +# BETTER: use an awk program for this, but I am not able to write +# such an awk program. And do we have it available everywhere? +_tlp_get_multi() { + entry="$1" + tlpfile="$2" + arch="$3" + test_tlp "$tlpfile" + ( SAVEDIFS=$IFS ; IFS= ; cat "$tlpfile" | __tlp_get_multi "$entry" "$arch" ) +} +__tlp_get_multi() { + entry="$1" + arch="$2" + if [ "$arch" = "" ] ; then + pat="$entry*" + else + pat="$entry*arch=$arch*" + fi + reading_multi=0 + while read line ; do + case "$line" in + $pat) + reading_multi=1 + ;; + \ *) + if [ $reading_multi = 1 ] ; then + ( IFS=$SAVEDIFS ; echo $line ) + fi + ;; + *) + if [ $reading_multi = 1 ] ; then + # we already have read the interesting part, return now + return + fi + ;; + esac + done +} + +_tlp_get_multi_simple() { + entry="$1" + tlpfile="$2" + test_tlp "$tlpfile" + grep "^$entry" "$tlpfile" | sed -e "s@^$entry[ \t]*@@" +} + +_tlp_get_simple() { + entry="$1" + tlpfile="$2" + field="$3" + prefix="$4" + test_tlp "$tlpfile" + cat "$tlpfile" | __tlp_get_simple $entry $field $prefix +} + +__tlp_get_simple() { + entry="$1" + field="$2" + prefix="$3" + if [ "$field" = "" ] ; then + grep -m 1 "^$entry " | sed -e "s@^$entry[ \t]*@@" | sed -e "s@^$prefix@@" + else + grep -m 1 "^$entry " | awk "{print\$${field}}" | sed -e "s@^$prefix@@" + fi +} + +tlp_get_name() +{ + _tlp_get_simple name "$1" +} +tlp_get_revision() +{ + _tlp_get_simple revision "$1" +} +tlp_get_category () +{ + _tlp_get_simple category "$1" +} +tlp_get_shortdesc () +{ + _tlp_get_simple shortdesc "$1" +} +tlp_get_catalogue () +{ + _tlp_get_simple catalogue "$1" +} +tlp_get_longdesc () +{ + _tlp_get_multi longdesc "$1" +} +tlp_get_depends () +{ + _tlp_get_multi_simple depend "$1" +} +tlp_get_executes () +{ + _tlp_get_multi_simple execute "$1" +} +tlp_get_srcfiles () +{ + _tlp_get_multi srcfiles "$1" +} +tlp_get_docfiles () { + _tlp_get_multi docfiles "$1" +} +tlp_get_runfiles () { + _tlp_get_multi runfiles "$1" +} +tlp_get_srcsize () { + _tlp_get_simple srcfiles "$1" 2 "size=" +} +tlp_get_docsize () +{ + _tlp_get_simple docfiles "$1" 2 "size=" +} +tlp_get_runsize () +{ + _tlp_get_simple runfiles "$1" 2 "size=" +} + +tlp_get_binsize () +{ + tlpfile="$1" + arch="$2" + _tlp_get_simple "binfiles[ \t]*arch=$arch" "$1" 3 "size=" +} +tlp_get_binfiles () +{ + _tlp_get_multi binfile "$1" "$2" +} + +tlp_get_available_arch () +{ + test_tlp "$tlpfile" + grep 'binfiles[ \t]*arch=' "$tlpfile" | awk '{print$2}' | sed -e 's/arch=//' +} + +test_tldb() { + tldbfile="$1" + if [ ! -r "$tldbfile" ] ; then + die "tldb file not readable: $tldbfile" + fi +} + +_tldb_tlp_get_multi() +{ + tldb="$1" + tlp="$2" + entry="$3" + arch="$4" + test_tldb "$tldb" + foundpackage=0 + ( SAVEDIFS=$IFS ; IFS= ; while read line ; do + case "$line" in + name\ $tlp*) + foundpackage=1 + __tlp_get_multi $entry $arch + ;; + *) + if [ $foundpackage = 1 ] ; then + return + fi + ;; + esac + done ) <$tldb +} +_tldb_tlp_get_simple() +{ + tldb="$1" + tlp="$2" + entry="$3" + field="$4" + prefix="$5" + test_tldb "$tldb" + foundpackage=0 + ( SAVEDIFS=$IFS ; IFS= ; while read line ; do + case "$line" in + name\ $tlp*) + foundpackage=1 + __tlp_get_simple $entry $field $prefix + ;; + *) + if [ $foundpackage = 1 ] ; then + return + fi + ;; + esac + done ) <$tldb +} + + +tldb_tlp_get_revision() +{ + _tldb_tlp_get_simple "$1" "$2" revision "$3" "$4" +} +tldb_tlp_get_category () +{ + _tldb_tlp_get_simple "$1" "$2" category "$3" "$4" +} +tldb_tlp_get_shortdesc () +{ + _tldb_tlp_get_simple "$1" "$2" shortdesc "$3" "$4" +} +tldb_tlp_get_catalogue () +{ + _tldb_tlp_get_simple "$1" "$2" catalogue "$3" "$4" +} +tldb_tlp_get_longdesc () +{ + _tldb_tlp_get_multi "$1" "$2" longdesc "$3" +} +tldb_tlp_get_srcfiles () +{ + _tldb_tlp_get_multi "$1" "$2" srcfiles "$3" +} +tldb_tlp_get_docfiles () { + _tldb_tlp_get_multi "$1" "$2" docfiles "$3" +} +tldb_tlp_get_runfiles () { + _tldb_tlp_get_multi "$1" "$2" runfiles "$3" +} +tldb_tlp_get_binfiles () +{ + _tldb_tlp_get_multi "$1" "$2" binfile "$3" +} + +tldb_get_installed_packages () +{ + tldb="$1" + test_tldb "$tldb" + grep ^name "$tldb" | awk '{print$2}' +} + + +### Local Variables: +### perl-indent-level: 4 +### tab-width: 4 +### indent-tabs-mode: t +### End: +# vim:set tabstop=4: # diff --git a/Master/tlpkg/archive/lib/python/TeXLive.py b/Master/tlpkg/archive/lib/python/TeXLive.py new file mode 100644 index 00000000000..fe302acee9b --- /dev/null +++ b/Master/tlpkg/archive/lib/python/TeXLive.py @@ -0,0 +1,1744 @@ +#!/usr/bin/python2.4 -u +# TeXLive.py +# -*- encoding: utf-8 -*- +# Usage: call with argument of --help +# 2007-Aug-05 Jim Hefferon ftpmaint@tug.ctan.org +"""Understand a TeX Live package and the associated dB file. + +TeX Live has a format for metadata located in trunk/Master/tlpkg (for +the 'src' packages and documentation of the format) and +trunk/Master/texlive.tlpdb (see also -withctan ?). This module reads the +two formats, can transform them by adding package documentation from the +ctanWeb database, and can write them back out. + +""" +__version__='1.0.0' +__author__='Jim Hefferon' +__date__='2007-Aug-05' +__notes__=""" +Bugs: +1) Does not expand patterns for the src module, and does not + redo the sizes, etc., for obj files. +2) You can't from the command line change the name of the db files. +3) This version for the TeX Live svn tree has the dB stripped out, so + the option -a doesn't work, and the option -n has no effect. +""" + +import os, os.path, sys +import re +import optparse +import codecs +import tempfile +import time +import pprint +import glob + +## import library +## from util import * +## import dBUtils +## from defaults import DEFAULT_ENCODING, DEFAULT_DATABASE_ENCODING, DEBUG, LOGGING +DEFAULT_ENCODING='UTF-8' + +TLPDB_FILENAME='/home/svn/texlive/trunk/Master/texlive.tlpdb' + +THIS_SCRIPT=sys.argv[0] +DEBUG=True +LOGGING=True +LOGFILE_NAME=os.path.splitext(os.path.basename(THIS_SCRIPT))[0]+'.log' +VERBOSE=True + +# What encoding for the terminal? +import locale +locale_language, locale_output_encoding = locale.getdefaultlocale() +if locale_output_encoding is None: + locale_output_encoding='UTF-8' + + +#---------------------- stuff from util.py +import StringIO # for msg +import traceback # for msg +import logging # for openLog, msg +import locale # for warn messages +import types + +import grp, pwd # get user name and group name + +import pprint # to make nice debugging structures + +termEncoding='UTF-8' + +class utilError(StandardError): + pass + +# Getting the string from the exception is a problem if you want unicode, +# since str() is no good for that, and I can't get err.message to work. +# I need the same functionality for my exceptions as for Python's so +# I wrap a call to err[0] +def errorValue(err): + """Return the string error message from an exception. + err exception instance + Note: I cannot get err.message to work. I sent a note to clp on + Jan 29 2007 with a related query and this is the best that I figured + out. + """ + try: + return str(err) + except: + return err[0] # one of mine, in unicode + +class jhError(StandardError): + """Subclass this to get exceptions that behave correctly when + you do this. + try: + raise subclassOfJhError, 'some error message with unicode chars' + except subclassOfJhError, err + mesg='the message is '+unicode(err) + I don't believe that the built-in exceptions ever pass unicode so you can + use unicode(err) on those also, I think, provided that you don't + raise them yourself. + """ + def __unicode__(self): + return errorValue(self) + +# You can use a string to set the level, or a constant from the logging +# module +_logLevels={'debug':logging.DEBUG, + 'info':logging.INFO, + 'warn':logging.WARN, + 'error':logging.ERROR, + 'critical':logging.CRITICAL, + logging.DEBUG:logging.DEBUG, + logging.INFO:logging.INFO, + logging.WARN:logging.WARN, + logging.WARN:logging.ERROR, + logging.CRITICAL:logging.CRITICAL} + + +# openLog Open a logging instance +def openLog(fn,name=None,purpose=None,format="%(levelname)s\t%(asctime)s: %(message)s",level=logging.DEBUG,announce=False): + """Open an instance of the logging module. Does not append to an old file; + instead it makes a new one. + fn Name of the file. + name=None Name of the logging instance; if None then fn is used + purpose=None Name of calling program; if None then no head line on log + file is written + format='%(levelname)s %(asctime)s: %(message)s' Format for log file + entries + announce=False Announce in log file that logging has started + These are available for the format: + %(name)s Name of the logger (logging channel) + %(levelno)s Numeric logging level for the message (DEBUG, INFO, + WARN, ERROR, CRITICAL) + %(levelname)s Text logging level for the message ("DEBUG", "INFO", + "WARN", "ERROR", "CRITICAL") + %(pathname)s Full pathname of the source file where the logging + call was issued (if available) + %(filename)s Filename portion of pathname + %(module)s Module (name portion of filename) + %(lineno)d Source line number where the logging call was issued + (if available) + %(created)f Time when the LogRecord was created (time.time() + return value) + %(asctime)s Textual time when the LogRecord was created + %(msecs)d Millisecond portion of the creation time + %(relativeCreated)d Time in milliseconds when the LogRecord was created, + relative to the time the logging module was loaded + (typically at application startup time) + %(thread)d Thread ID (if available) + %(message)s The result of record.getMessage(), computed just as + the record is emitted + May raise a utilError. + """ + if not(purpose is None): # write a header on the file, if it is new + if not(os.path.isfile(fn)): + try: + f=open(fn,'w') + f.write("# log file for %s\n" % (purpose,)) + f.close() + except IOError, err: + raise utilError, "Log file %s not present and unable to open and write to a new log file: %s" % (fn,errorValue(err)) + if name is None: + log=logging.getLogger(fn) + else: + log=logging.getLogger(name) + logger_formatter=logging.Formatter(format) + try: + logger_handler=logging.FileHandler(fn) + except Exception, err: + raise utilError, "Unable to associate a log with %s: %s" % (fn,errorValue(err)) + logger_handler.setFormatter(logger_formatter) + log.addHandler(logger_handler) + try: + log.setLevel(_logLevels[level]) + except: + raise utilError, "Unable to set level of the log" + if announce: + try: + log.info("Logging started") + except Exception, err: + raise utilError, "Unable to initially write to the log with file name %s: %s" % (fn,errorValue(err)) + return log + +# msg return a message, for debugging, feedback to the user, etc., and +# optionally log +def msg(m,devel=None,log=None,logLevel='debug',debug=False,**mDct): + """Return a message. Options allow it to be logged, or for a special + debugging flag to be switched to give additional information + m The message returned. Substitutions from the keyword arguments at end + devel=None String that will be used if the DEBUG flag is set for + developer (and used for writing to the log). If devel=None, then m + is used. + log A logging object + logLevel='debug' One of 'debug', 'info', 'warn', 'error', 'critical', + or logging.DEBUG, .. logging.CRITICAL + debug=False Boolean select which message m or mDevel is shown. + **mDct Keyword argument that are substituted into m and mDevel + Note that if an exception is pending then a traceback gets printed to the + log file. + """ + # Indicate log level + try: + level=_logLevels[logLevel] + except: + raise utilError, "Unable to set level of the log to %s" % (repr(logLevel),) + # The main part + if devel is None: + devel_str=m + else: + devel_str=devel + #if log: + # log.debug("in msg: m=<%s>, devel_str=<%s>" % (m,devel_str)) + if log: + (excClass,excObj,excTb)=sys.exc_info() # is there a pending exception? + if excClass: + tbStr=StringIO.StringIO() + traceback.print_exc(None,tbStr) + mDct['tB']=tbStr.getvalue().rstrip() + log.log(level,(devel_str+"\n %(tB)s") % mDct) + else: + log.log(level,devel_str % mDct) + if debug: + m=devel_str + # expect that everybody needs to be encoded; print can't do characters numbered greater than 128 + for (k,v) in mDct.items(): + try: + if not(isinstance(v,UnicodeType)): + mDct[k]=unicode(v,termEncoding,'replace') + except: + try: + mDct[k]=unicode(str(v),termEncoding,'replace') #? has no unicode method, but has a str method? Like StandardError? + except: + mDct[k]="Error in util.msg() -- string conversion to unicode impossible: %s" % (repr(v),) # give a message with some hint of what's gone wrong + return m % mDct + + +DEFAULT_EXCEPTION=utilError +WARNINGS_WANTED=False # sometimes, as for unit testing, nice to turn off +def noteException(m,devel=None,log=None,logLevel='error',exception=DEFAULT_EXCEPTION,debug=None,**mDct): + """ + Raise an exception, and also, optionally, note it in a log file + m string Error message for users; use '%(id)s'-style substitution + devel=None string String for development; sub as in m. + log Instance of logging module + exception An exception + debug Print the error to the stderr? + **mDct Additional keyword arguments; like 'id=7' will be subbed into + m, devel + Uses the msg function; will raise exception. + """ + # print "util.py.noteException: m is: ",m," mDct is",pprint.pformat(mDct) + if sys.exc_info()[0]: # if there is an active exception + extraStr=" (exception is %s)" % (exceptionName(),) + if devel is None: + m+=extraStr + else: + devel+=extraStr + r=msg(m,devel=devel,log=log,logLevel=logLevel,debug=debug,**mDct) + if (debug + and not(log) + and WARNINGS_WANTED): + warn(r,log=None,debug=debug) # print to stderr + raise exception, r + +def warn(s,leader='WARNING: ',log=None,debug=False,**mDct): + """Send a message to stderr and possibly log it + s Message to report + log=None A logging object + debug=False Whether to report debugging information + Warning! You can't use leader, log, or debug as a key + """ + # print >>sys.stderr, leader, msg(s,log=log,logLevel='error',debug=debug,**mDct).encode(locale.getdefaultlocale()[1]) + if not(isinstance(s,types.UnicodeType)): + s=unicode(s,termEncoding,'replace') + # print "in warn(): s=",s," and mDct.keys() is ",repr(mDct.keys()),"<<<<<===" + print >>sys.stderr, leader, msg(s,log=log,logLevel='error',debug=debug,**mDct).encode(termEncoding) + return None + +def ann(s,log=None,debug=False,**mDct): + """Issue a warning-like message without the 'WARNING' message. + s Message to report; may contain %(var)s as long as they are matched + by var=var in the tailing arguments + log=None,debug=False debugging stuff + **mDct variables to substitute in s + """ + return warn(s,leader='',log=log,debug=debug,**mDct) + +def note(s,log,flag=os.environ.has_key('GATEWAY_INTERFACE'),leader="NOTE: "): + """Take the message s and either log it or print it, depending + on the flag. The idea is to debug with note('informational message',log) + and have it do the right thing, in a cgi context or not. + s message to use + log logging instance + flag=os.environ.has_key('GATEWAY_INTERFACE') if True, use log. If + False, use stdout (default is True iff running as a CGI script) + """ + # programming note: + # I've avoided too many options, such as potentially outputting + # to stderr or using another log level; we'll see if simple works. + if flag and log: + log.info(s) + else: + warn(s,leader=leader,log=log) # no debug because no devel string + + +def fail(s,returnCode=1,log=None,debug=False,**mDct): + """Drop out, reporting a return code, and possibly logging a message + s Message to report + returnCode=1 return code + log=None A logging object + debug=False Whether to report debugging information + Warning! You can't use returnCode, leader, log, or debug as a key + """ + warn(s,leader='ERROR: ',log=log,debug=debug,**mDct) + sys.exit(returnCode) + +# exceptionName: get the name of the raised exception +# for use as: +# try: +# .. +# except specificError, err: +# .. +# except Exception, err: +# eN=exceptionName() +# print "exception was",eN +# +def exceptionName(): + """Get the name of the currently raised exception. + """ + fullName=sys.exc_info()[0] # looks like "'exceptions.AttributeError'" + if fullName is None: + return 'No exception' # return rather than None, as I don't expect it to happen, and I don't want the failure if it is None + else: + return str(fullName).split('.')[-1] +#---------------------------------------- + +#-------------------------------stuff from dButils.py +## import psycopg2, psycopg2.extensions + +## DEFAULT_DBCONNECTION_STRING="user=hefferon dbname=ctan password=Gd6eBitK55y" +## DEFAULT_DATABASE_ENCODING='UTF-8' + +## dBConnectionString=DEFAULT_DBCONNECTION_STRING # can be force-changed for debugging + +## class dBUtilsError(StandardError): +## pass + +## def opendB(connectionstring=dBConnectionString,log=None,debug=DEBUG,encoding=DEFAULT_DATABASE_ENCODING,utc=True): +## """ +## Make a connection to the database; return the pair (connection, cursor). +## connectionstring=dBConnectionstring string See doc for psycopg +## log=None logging object +## debug=DEBUG Whether to output extra information +## encoding='UNICODE' What to set the client encoding to (default is utf-8) +## utc=True Set time zone to utc (alternative is local time) +## May raise a dBUtilsError. +## """ +## if encoding.upper()=='UTF-8': +## encoding='UNICODE' # postgres's name for UTF-8 +## if not(encoding in psycopg2.extensions.encodings.keys()): +## mesg=u'Unable to make a database connection' +## noteException(mesg,devel=mesg+" using connection string %(connectionstring)s because the called-for encoding %(encoding)s is not one known to psycopg2",log=log,exception=dBUtilsError,debug=debug,connectionstring=connectionstring,encoding=encoding) +## try: +## dBcnx = psycopg2.connect(connectionstring) +## # dBcnx.set_client_encoding(encoding) # causes a failure JH 05-10-12 +## dBcsr = dBcnx.cursor() +## if utc: +## dBcsr.execute("SET TIME ZONE 'UTC'") +## dBcsr.execute("SET client_encoding TO "+encoding) +## if encoding=='UNICODE': # any way to systematize this code? +## psycopg2.extensions.register_type(psycopg2.extensions.UNICODE) +## elif encoding=='LATIN1': +## psycopg2.extensions.register_type(psycopg2.extensions.LATIN1) +## elif encoding=='SQL_ASCII': +## psycopg2.extensions.register_type(psycopg2.extensions.SQL_ASCII) +## elif encoding=='latin-1': +## psycopg2.extensions.register_type(psycopg2.extensions.LATIN1) +## except psycopg2.DatabaseError, err: +## mesg=u'Unable to connect to the database' +## noteException(mesg,devel=mesg+" using connection string %(connectionstring)s: %(err)s",log=log,exception=dBUtilsError,debug=debug,connectionstring=connectionstring,err=err) +## except Exception, err: +## eN=exceptionName() +## mesg=u'Unable to connect to the database' +## noteException(mesg,devel=mesg+" (exception: %(eN)s) using connection string %(connectionstring)s: %(err)s",log=log,exception=dBUtilsError,debug=debug,eN=eN,connectionstring=connectionstring,err=err) +## return (dBcnx,dBcsr) + +## def getData(sql,dct={},dBcsr=None,selectOne=False,log=None,debug=DEBUG,listtype='list from the database'): +## """ +## Get data out of the database, returning a list of lists +## sql SQL statement; typically a SELECT statement +## dct={} Dictionary of substitutions into SQL statement (unicode strings +## are encoded according to the encoding) +## dBcsr=None database cursor. If None, one will be generated +## log=None Instance of logging object +## selectOne=False With a dB result, issue a fetchone() or a fetchall()? +## debug=DEBUG Whether to include debugging information +## listtype Phrase for use in error messages +## Psycopg2 will handle conversion of unicode strings. +## """ +## if not(dBcsr): # sanity check +## mesg=u'Error getting access to the database' +## noteException(mesg,devel=mesg+": no database cursor, while getting a %(listtype)s",log=log,exception=dBUtilsError,debug=debug,listtype=listtype) +## try: +## dBcsr.execute(sql,dct) +## if selectOne: +## dBres=dBcsr.fetchone() +## if dBres is None: +## lst=[] # an empty list so always yield a sequence +## else: +## lst=dBres # one tuple +## else: +## lst=dBcsr.fetchall() # a list with possibly many tuples +## except psycopg2.DatabaseError, err: +## mesg=u'Database operation error fetching a %(listtype)s' +## noteException(mesg,devel=mesg+" with query "+dBcsr.query+": %(err)s -- "+dBcsr.statusmessage,log=log,exception=dBUtilsError,debug=debug,listtype=listtype,sql=sql,dct=repr(dct),err=err) +## except Exception, err: +## eN=exceptionName() +## noteException("Database error (unknown kind) fetching a %(listtype)s",devel="Database error (exception %(eN)s) fetching a %(listtype)s with sql='%(sql)s' and dct=%(dct)s: %(err)s",log=log,exception=dBUtilsError,debug=debug,listtype=listtype,eN=eN,err=err) +## return lst + +## def putData(sql,dct={},dBcsr=None,log=None,encoding=DEFAULT_DATABASE_ENCODING,debug=DEBUG,listtype='list to the database'): +## """ +## Put data into the database, encoding unicode strings on their way in +## sql SQL statement; should be an INSERT or an UPDATE +## dct={} Dictionary of substitutions into SQL statement (unicode strings +## are encoded according to the encoding) +## dBcsr=None database cursor. If None, one will be generated +## log=None Instance of logging object +## encoding=DEFAULT_DATABASE_ENCODING Unicode encoding to use for the +## database +## debug=DEBUG Whether to include debugging information +## listtype Phrase for use in error messages +## Does *not* do a dBcsr.commit(). +## """ +## if not(dBcsr): # sanity check +## mesg=u'Error accessing the database' +## noteException(mesg,devel=mesg+" while putting a %(listtype)s: no database cursor",log=log,exception=dBUtilsError,debug=debug,listtype=listtype) +## try: +## dBcsr.execute(sql,dct) +## except (psycopg2.DatabaseError,psycopg2.ProgrammingError), err: +## eN=exceptionName() +## mesg=u'Database operation error' +## noteException(mesg,devel=mesg+" (exception %(eN)s) %(err)s while putting a %(listtype)s with query="+dBcsr.query+": %(err)s -- "+dBcsr.statusmessage,log=log,exception=dBUtilsError,debug=debug,listtype=listtype,eN=eN,err=err) +## except Exception, err: +## eN=exceptionName() +## mesg=u'Database operation error' +## noteException(mesg,devel=mesg+" (exception %(eN)s) %(err)s while putting a %(listtype)s",log=log,exception=dBUtilsError,debug=debug,eN=eN,err=str(err),listtype=listtype) +## return None + +#------------------------------------------------- + +class tlError(jhError): + pass + +tlobjKeys=set(['name','category','catalogue','shortdesc','longdesc','depend','execute','revision','srcsize','srcfiles','docsize','docfiles','runsize','runfiles','binsize','binfiles','cataloguedata','srcpattern','runpattern','docpattern','binpattern']) + +class tlp(object): + """Give information based on a TeXLive object file + """ + def __init__(self,verbose=False,log=None,debug=False): + """Initialize an object. + """ + self.verbose=verbose + self.log=log + self.debug=debug + self.name=None # string id of package + self.category=None # string category into which package falls + self.catalogue=None # string id of associated Catalogue package + self.shortdesc=None # string one-liner + self.longdesc=None # string may have newlines + self.depend=None # list of the form Category/Name + self.execute=None # list free-form strings + return None + + def __unicode__(self): + r=[] + r.append("name: %s" % (pprint.pformat(self.name),)) + r.append(" category: %s" % (pprint.pformat(self.category),)) + r.append(" catalogue: %s" % (pprint.pformat(self.catalogue),)) + r.append(" shortdesc: %s" % (pprint.pformat(self.shortdesc),)) + r.append(" longdesc: %s" % (pprint.pformat(self.longdesc),)) + r.append(" depend: %s" % (pprint.pformat(self.depend),)) + r.append(" execute: %s" % (pprint.pformat(self.execute),)) + return "\n".join(r) + + def writeout(self,fn=None): + """Write a textual representation + fn=None file name; if None use sys.stdout + """ + if fn is None: + f=sys.stdout + if f.encoding!=DEFAULT_ENCODING: + warn('using STDOUT but the encoding is %(fEncoding)s and not the expected %(defaultEncoding)s',log=self.log,debug=self.debug,fEncoding=repr(f.encoding),defaultEncoding=repr(DEFAULT_ENCODING)) + else: + if self.debug: + errors='strict' + else: + errors='replace' + try: + f=codecs.open(fn,'w',DEFAULT_ENCODING,errors) + except Exception, err: + mesg='unable to open the file for writing' + noteException(mesg,devel=mesg+' %(fn)s: %(err)s',exception=tlError,log=log,debug=self.debug,fn=repr(fn),err=unicode(err)) + self.writeout_fh(f) + f.close() + return None + + def _stringToWriteout(self): + """String that will be written out during writeout_fh + """ + r=[] + r.append("name %s" % (self.name,)) + if self.category: + r.append("category %s" % (self.category,)) + if self.shortdesc: + r.append("shortdesc %s" % (self.shortdesc,)) + if self.longdesc: + for line in self.longdesc.split("\n"): + r.append("longdesc %s" % (line,)) + if self.depend: + for line in self.depend: + r.append("depend %s" % (line,)) + if self.execute: + for line in self.execute: + r.append("execute %s" % (line,)) + return "\n".join(r) + + def writeout_fh(self,f): + """Write a string representation of the user variables to the + filehandle. + f filehandle + """ + s=self._stringToWriteout() + f.write(s) + return None + + def get_associated_cat_ids(self,dBcsr,log=None,debug=False): + """Return the matching catalogue ids + """ + sql="""SELECT pkg_id FROM tl_cat + WHERE tl_id=%(tlId)s + AND pkg_id IS NOT NULL""" + dct={'tlId':self.name} + try: + dBres=dBUtils.getData(sql,dct=dct,dBcsr=dBcsr,log=log,debug=debug,listtype='get catalogue package ids related to this TeX Live package id') + except dBUtils.dBUtilsError, err: + mesg=u'unable to get texlive-catalogue packages record' + noteException(mesg,devel=mesg+' for TeX Live package %(tlId)s: %(err)s',exception=tlError,log=log,debug=debug,tlId=repr(tlId),err=errorValue(err)) + return [catId for (catId,) in dBres] + + def add_cat_desc(self,dBcsr,catId=None,log=None,debug=False): + """If there is not now a description, and there is a matching + Catalogue package, add its descriptions. (Also sets the catalogue + variable) + dBcsr database cursor + catId=None string or None if present, the name of the Catalogue + package whose descriptions will be added. + log=None,debug=False debugging + """ + if not(catId): + catIds=self.get_associated_cat_ids(dBcsr,log=log,debug=debug) + if len(catIds)==1: + catId=catIds[0] + if not(catId): + return False + sql="""SELECT caption, description FROM pkg_text + WHERE id=%(catId)s + AND iso_code='en'""" + dct={'catId':catId} + try: + dBres=dBUtils.getData(sql,dct=dct,dBcsr=dBcsr,log=log,debug=debug,listtype='get catalogue descriptions related to this TeX Live package id') + except dBUtils.dBUtilsError, err: + mesg=u'unable to get catalogue package descriptions for this TeX Live package' + noteException(mesg,devel=mesg+' for TeX Live package %(tlId)s and catalogue id %(catId)s: %(err)s',exception=tlError,log=log,debug=debug,tlId=repr(tlId),catId=repr(catId),err=errorValue(err)) + res=dBres[0] + if res: + (catCaption,catDesc)=dBres[0] + if (not(self.shortdesc) + and not(self.longdesc)): + self.catalogue=catId + self.shortdesc=catCaption + self.longdesc=catDesc + return True + + def from_file(self,fn=None,multi=False): + """Read a tlp object from a file. + fn=None string file name or None, which means sys.stdin + multi=False boolean whether to allow multiple pkgs in a file + """ + if fn is None: + f=sys.stdin + if f.encoding!=DEFAULT_ENCODING: + warn('using STDIN but the encoding is %(fEncoding)s and not the expected %(defaultEncoding)s',log=self.log,debug=self.debug,fEncoding=repr(f.encoding),defaultEncoding=repr(DEFAULT_ENCODING)) + else: + try: + if self.debug: + errors='strict' + else: + errors='replace' + f=codecs.open(fn,'rU',DEFAULT_ENCODING,errors) + except Exception, err: + mesg='unable to open file for reading' + noteException(mesg,devel=mesg+' %(fn)s: %(err)s',exception=tlError,log=log,debug=self.debug,fn=repr(fn),err=unicode(err)) + r=self.from_fh(f,multi=multi,lineNo=0) + return None + + initialState='init' + keyValueStates=tlobjKeys # line of form "key value" + filePathStates=set(['srcfiles_file','runfiles_file','docfiles_file','binfiles_file']) # line contains file path indented by space + nextStates={initialState:tlobjKeys, + 'name':keyValueStates-set(['name']), + 'category':keyValueStates-set(['category']), + 'catalogue':keyValueStates-set(['catalogue']), + 'shortdesc':keyValueStates-set(['shortdesc']), + 'longdesc':keyValueStates, + 'depend':keyValueStates, + 'execute':keyValueStates} + def from_fh(self,f,multi=None,lineNo=0): + """Read tlp information from a file handle. Returns None if EOF is + read before anything is found. Note that files have been opened + with codecs.open() (except for stdin) + f an opened file + multi=None If not None then multiple tplobj's in the file are + treated as an error + lineNo=0 debugging + May raise tlError. + """ + # Implementation note: I am putting the full parsing routine in + # this base class, except for some "handle" routines, to allow + # me to have the handle routines report error messages in the + # tplobj and tplsrc classes. + state=self.initialState + # Look for blank lines that are delimeters between tlp parts + anyNonblankLinesRead=False + while True: + line=f.readline() + if not(line): # EOF? + return False + lineNo+=1 + if self.debug and self.verbose: + note('line is '+repr(line),self.log) + line=line.rstrip() + if not(anyNonblankLinesRead): + if (not(line) + or line[0]=='#'): # toss initial blank lines or comments + continue + else: + anyNonblankLinesRead=True + elif not(line): + if multi is None: + mesg=u'unexpected multiple tpl objects' + noteException(mesg,devel=mesg+'; trailing blank line found at line %(lineNo)s',exception=tlError,log=self.log,debug=self.debug,lineNo=repr(lineNo)) + else: + return self + # Get the next state (the key) and the part of the line after key. + # The "srcfiles", etc., states need special handling as they + # put the reader in a position where the first thing on the line + # is not the next state. + restOfLine="" + if line[0]==' ': + if (state=='srcfiles' + or state=='srcfiles_file'): + newState='srcfiles_file' + restOfLine=line[1:] + elif (state=='runfiles' + or state=='runfiles_file'): + newState='runfiles_file' + restOfLine=line[1:] + elif (state=='docfiles' + or state=='docfiles_file'): + newState='docfiles_file' + restOfLine=line[1:] + elif (state=='binfiles' + or state=='binfiles_file'): + newState='binfiles_file' + restOfLine=line[1:] + else: + try: + fields=line.split() + newState=fields[0].lower() + restOfLine=line[len(newState):] # can't lstrip() if it is longdesc + except: + mesg=u'no key in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; while in state %(state)s unable to get the new state for line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),state=repr(state)) + # Reject illegal newState's + if not(newState=='binfiles_file'): + self.currentArch=None + if not(newState in self.nextStates[state]): + # print"newState",repr(newState),"state",repr(state),'self.nextStates[state]=',repr(self.nextStates[state])," type",repr(type(self.nextStates[state])) + mesg=u'unable to transition to the next state in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; while in state %(state)s the next state %(newState)s is not legal in line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),state=repr(state),newState=repr(newState)) + # Main part of routine: handle the line depending on the newState. + # if self.debug: + # print "newState is ",repr(newState)," line is ",repr(line) + if newState==self.initialState: + mesg=u'unexpected initial state in line=%(lineNo)s' + noteException(mesg,devel=mesg+'; while in state %(state)s now in initial state reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),state=repr(state)) + if newState=='name': + try: + fields=restOfLine.strip().split() + self.name=fields[0] + if self.debug: + note("package name is "+repr(self.name),self.log) + except Exception, err: + mesg=u'no "value" text in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s: %(err)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState),err=errorValue(err)) + elif newState=='category': + try: + fields=restOfLine.strip().split() + self.category=fields[0] + except: + mesg=u'no "value" text in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + elif newState=='catalogue': + try: + fields=restOfLine.strip().split() + self.catalogue=fields[0] + except: + mesg=u'no "value" text in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + elif newState=='shortdesc': + try: + # I'll allow multiline shortdesc's, although I'll regret it + if self.shortdesc is None: + self.shortdesc="" + if self.shortdesc: + self.shortdesc+=' ' + self.shortdesc+=restOfLine + except: + mesg=u'no value in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + elif newState=='longdesc': + try: + if self.longdesc is None: + self.longdesc="" + if self.longdesc: + self.longdesc+="\n" + self.longdesc+=restOfLine + except Exception, err: + mesg=u'no value in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s: %(err)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState),err=errorValuse(err)) + elif newState=='depend': + fields=restOfLine.strip().split() + if len(fields)>0: + if self.depend is None: + self.depend=[] + self.depend.append(restOfLine.strip()) + else: + mesg=u'no value in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + elif newState=='execute': + fields=restOfLine.strip().split() + if len(fields)>0: + if self.execute is None: + self.execute=[] + self.execute.append(restOfLine.strip()) + else: + mesg=u'no value in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + elif newState=='revision': + self.handleRevision(newState,restOfLine,line,lineNo) + elif newState=='srcfiles': + self.handleSrcfiles(newState,restOfLine,line,lineNo) + elif newState=='srcfiles_file': + self.handleSrcfilesFile(newState,restOfLine,line,lineNo) + elif newState=='docfiles': + self.handleDocfiles(newState,restOfLine,line,lineNo) + elif newState=='docfiles_file': + self.handleDocfilesFile(newState,restOfLine,line,lineNo) + elif newState=='runfiles': + self.handleRunfiles(newState,restOfLine,line,lineNo) + elif newState=='runfiles_file': + self.handleRunfilesFile(newState,restOfLine,line,lineNo) + elif newState=='binfiles': + self.handleBinfiles(newState,restOfLine,line,lineNo) + elif newState=='binfiles_file': + self.handleBinfilesFile(newState,restOfLine,line,lineNo) + elif newState=='srcpattern': + self.handleSrcpattern(newState,restOfLine,line,lineNo) + elif newState=='runpattern': + self.handleRunpattern(newState,restOfLine,line,lineNo) + elif newState=='docpattern': + self.handleDocpattern(newState,restOfLine,line,lineNo) + elif newState=='binpattern': + self.handleBinpattern(newState,restOfLine,line,lineNo) + elif newState.startswith('cataloguedata-'): + self.handleCataloguedata(newState,restOfLine,line,lineNo) + else: + mesg=u'unknown key in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; key is %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=repr(lineNo),line=repr(line),newState=repr(newState)) + # Cycle back to read next line + state=newState + return True + + def handleRevision(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'revision' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleSrcfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'srcfiles' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleSrcfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'srcfiles_file' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleDocfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'docfiles' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleDocfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'docfiles_file' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleRunfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'runfiles' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleRunfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'runfiles_file' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleBinfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'binfiles' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleBinfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'binfiles_file' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleSrcpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'srcpattern' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleRunpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'runpattern' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleDocpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'docpattern' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleBinpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'binpattern' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + def handleCataloguedata(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'cataloguedata-xxx' + """ + mesg=u'the new state is not allowed here, line number=%(lineNo)s' + noteException(mesg,devel=mesg+"; this object %(objName) cannot be in the state %(newState)s: line=%(line)s",exception=tlError,log=self.log,debug=self.debug,objName=repr(self.__class__.__name__),newState=repr(newState),lineNo=repr(lineNo),line=repr(line)) + return None + + +class tlp_db(object): + """Give information based on a tl file database. This class exists + for tlpobj_db and tlpsrc_db to inherit from + """ + def __init__(self,verbose=False,log=None,debug=False): + """Initialize an instance. + """ + self.verbose=verbose + self.log=log + self.debug=debug + self.value={} # map name --> tl pkg + return None + + def __unicode__(self): + names=self.value.keys() + names.sort() + return u" ".join(names) + + def get_package(self,name): + try: + return self.value[name] + except: + return None + + def _makeSingle(self): + """Helper fcn to make one of whatever self.value is holding multiple + of. Used in from_file. + """ + return tlp(log=self.log,debug=self.debug) + + def from_file(self,fn=None,multi=True): + """Read a tlp db file. Set self.value. + """ + if fn is None: + f=sys.stdin + if f.encoding!=DEFAULT_ENCODING: + warn('using STDIN but the encoding is %(fEncoding)s and not the expected %(defaultEncoding)s',log=self.log,debug=self.debug,fEncoding=repr(f.encoding),defaultEncoding=repr(DEFAULT_ENCODING)) + else: + if self.debug: + errors='strict' + else: + errors='replace' + try: + f=codecs.open(fn,'rU',DEFAULT_ENCODING,errors) + except Exception, err: + mesg='unable to open tlpobj file' + noteException(mesg,devel=mesg+' %(fn)s: %(err)s',exception=tlError,log=log,debug=self.debug,fn=repr(fn),err=unicode(err)) + r=self._makeSingle() + retVal=r.from_fh(f,multi=multi,lineNo=0) + self.value[r.name]=r + while retVal: + r=self._makeSingle() + retVal=r.from_fh(f,multi=multi,lineNo=0) + self.value[r.name]=r + return None + + def write_file(self,fn=None): + if fn is None: + f=sys.stdout + if f.encoding!=DEFAULT_ENCODING: + warn('using STDOUT but the encoding is %(fEncoding)s and not the expected %(defaultEncoding)s',log=self.log,debug=self.debug,fEncoding=repr(f.encoding),defaultEncoding=repr(DEFAULT_ENCODING)) + else: + if self.debug: + errors='strict' + else: + errors='replace' + try: + f=codecs.open(fn,'w',DEFAULT_ENCODING,errors) + except Exception, err: + mesg=u'unable to write because unable to open the file' + noteException(mesg,devel=mesg+': %(err)s',exception=tlError,log=self.log,debug=self.debug,err=errorValue(err)) + pkgNames=self.value.keys() + pkgNames.sort() + pkgNo=1 + for k in pkgNames: + v=self.value[k] + v.writeout_fh(f) + f.write("\n") + if pkgNo<len(pkgNames): # keep off extra \n after end + f.write("\n") + pkgNo+=1 + f.close() + return None + + def add_cat_descs(self,dBcsr): + """Add catalogue descriptions to all matching TL packages that do not + already have a description. + """ + pkgNames=self.value.keys() + pkgNames.sort() + for k in pkgNames: + self.value[k].add_cat_desc(dBcsr,log=self.log,debug=self.debug) + return None + + + +class tlpobj(tlp): + """Give information based on a TeXLive object file + """ + def __init__(self,verbose=False,log=None,debug=False): + """Initialize an object. + """ + super(tlpobj,self).__init__(verbose=verbose,log=log,debug=debug) + self.revision=None # integer + self.srcfiles=None # list of files + self.runfiles=None # list of files + self.docfiles=None # dct fileName--> (dct tagkey --> tagval) + self.binfiles=None # arch --> list of files + self.srcsize=None # int (or None) + self.runsize=None # int (or None) + self.docsize=None # int (or None) + self.binsize=None # arch --> size (or None) + self.cataloguedata=None # cataloguekey --> value + return None + + def __unicode__(self): + r=[] + r.append(super(tlpobj,self).__unicode__()) + r.append(" revision: %s" % (pprint.pformat(self.revision),)) + r.append(" srcsize: %s" % (pprint.pformat(self.srcsize),)) + r.append(" srcfiles: %s" % (pprint.pformat(self.srcfiles),)) + r.append(" docsize: %s" % (pprint.pformat(self.docsize),)) + r.append(" docfiles: %s" % (pprint.pformat(self.docfiles),)) + r.append(" runsize: %s" % (pprint.pformat(self.runsize),)) + r.append(" runfiles: %s" % (pprint.pformat(self.runfiles),)) + r.append(" binsize: %s" % (pprint.pformat(self.binsize),)) + r.append(" binfiles: %s" % (pprint.pformat(self.binfiles),)) + r.append(" cataloguedata: %s" % (pprint.pformat(self.cataloguedata),)) + return "\n".join(r) + + def _stringToWriteout(self): + """String that will be written out during writeout_fh + """ + r=[] + r.append(super(tlpobj,self)._stringToWriteout()) + if self.revision: + r.append("revision %s" % (self.revision,)) + if self.docfiles: + if self.docsize is None: + mesg='docsize is not there but there are docfiles' + noteException(mesg,devel=mesg,exception=tlError,log=self.log,debug=self.debug) + r.append("docfiles size=%s" % (self.docsize,)) + dFiles=self.docfiles.keys() + dFiles.sort() + for line in dFiles: + s=[] + for (k,v) in self.docfiles[line].items(): + s.append("%s=%s" % (k,v)) + dLine=" "+line + if s: + dLine+=" "+(" ".join(s)) + r.append(dLine) + if self.srcfiles: + if self.srcsize is None: + mesg='srcsize is not there but there are srcfiles' + noteException(mesg,devel=mesg,exception=tlError,log=self.log,debug=self.debug) + r.append("srcfiles size=%s" % (self.srcsize,)) + self.srcfiles.sort() + for line in self.srcfiles: + r.append(" "+line) + if self.runfiles: + if self.runsize is None: + mesg='runsize is not there but there are runfiles' + noteException(mesg,devel=mesg,exception=tlError,log=self.log,debug=self.debug) + r.append("runfiles size=%s" % (self.runsize,)) + self.runfiles.sort() + for line in self.runfiles: + r.append(" "+line) + if self.binfiles: + arches=self.binfiles.keys() + arches.sort() + for arch in arches: + if self.binsize[arch] is None: + mesg='binsize is not there but there are binfiles' + noteException(mesg,devel=mesg+" for %(arch)s",exception=tlError,log=self.log,debug=self.debug,arch=repr(arch)) + r.append("binfiles arch=%s size=%s" % (arch,self.binsize[arch],)) + sBinfiles=self.binfiles[arch] + sBinfiles.sort() + for line in sBinfiles: + r.append(" "+line) + if self.cataloguedata: + cdKeys=self.cataloguedata.keys() + for k in cdKeys: + r.append("catalogue-%s %s" % (k,self.cataloguedata[k])) + return "\n".join(r) + +## def to_db(self,dBcsr,dBcnx,careful=True,associatedCatPkgs=None,verbose=False): +## """Put the yyy-file information to a database +## dBcsr, dBcnx database cursor and connection +## careful=True raise exception on error? +## associatedCatPkgs=None list of catalogue package id's that either +## are part of this texlive package of of which this texlive package +## is a part (None is the same as using what is now in the dB) +## verbose=False Give warnings +## """ +## tlId=self.name +## # Drop the file records if they are there +## sql="DELETE FROM tds_files WHERE tl_id=%(tlId)s" +## dct={'tlId':tlId} +## try: +## dBUtils.putData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='drop old texlive files record') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to drop existing tds files record' +## noteException(mesg,devel=mesg+' for package %(pkgId)s: %(err)s',log=self.log,debug=self.debug,pkgId=repr(pkgId),err=errorValue(err)) +## # Do the tl_cat records; see which ones to do +## if associatedCatPkgs is None: +## sql="SELECT pkg_id FROM tl_cat WHERE tl_id=%(tlId)s" +## dct['tlId']=tlId +## try: +## dBres=dBUtils.getData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='get list of catalogue packages for this texlive package') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to get list of catalogue packages for this texlive packages ' +## noteException(mesg,devel=mesg+'%(tlId)s: %(err)s',log=self.log,debug=self.debug,tlId=repr(tlId),err=errorValue(err)) +## associatedCatPkgs=[a for (a,) in dBres] +## if not(associatedCatPkgs): # try tlId +## possiblePkgId=tlId.lower() +## sql="SELECT id FROM package WHERE id=%(pkgId)s" +## dct['pkgId']=possiblePkgId +## try: +## dBres=dBUtils.getData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='check for existence of a catalogue id') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to check for existence of a catalogue id' +## noteException(mesg,devel=mesg+'%(pkgId)s: %(err)s',log=self.log,debug=self.debug,pkgId=repr(possiblePkgId),err=errorValue(err)) +## if dBres: +## associatedCatPkgs.append(possiblePkgId) +## # drop any that are there now +## sql="DELETE FROM tl_cat WHERE tl_id=%(tlId)s" +## dct={'tlId':tlId} +## try: +## dBUtils.putData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='drop old texlive package-catalogue package association') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to drop existing texlive package record' +## noteException(mesg,devel=mesg+' for package %(tlId)s: %(err)s',log=self.log,debug=self.debug,tlId=repr(tlId),err=errorValue(err)) +## # Drop the tl records if they are there +## sql="DELETE FROM tl WHERE tl_id=%(tlId)s" +## dct={'tlId':tlId} +## try: +## dBUtils.putData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='drop old texlive package record') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to drop existing texlive package record' +## noteException(mesg,devel=mesg+' for package %(tlId)s: %(err)s',log=self.log,debug=self.debug,tlId=repr(tlId),err=errorValue(err)) +## # Insert new tl record +## sql="INSERT INTO tl (tl_id,shortdesc,longdesc) VALUES (%(tlId)s,%(shortdesc)s,%(longdesc)s)" +## dct['shortdesc']=self.shortdesc +## dct['longdesc']=self.longdesc +## try: +## dBUtils.putData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='insert new texlive package record') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to insert new texlive package record' +## noteException(mesg,devel=mesg+' for package %(tlId)s: %(err)s',log=self.log,debug=self.debug,tlId=repr(tlId),err=errorValue(err)) +## # insert new tl_cat records +## if not(tlId.startswith('bin-') +## or tlId.startswith('collection-') +## or tlId.startswith('hyphen-') +## or tlId.startswith('lib-') +## or tlId.startswith('scheme-') +## or tlId.startswith('texlive-')): +## if (not(associatedCatPkgs) +## and careful +## and verbose): +## mesg=u'there are no catalogue packages associated with the TeX Live package %(tlId)s' +## warn(mesg,log=self.log,debug=self.debug,tlId=repr(tlId)) +## for pkgId in associatedCatPkgs: +## sql="INSERT INTO tl_cat (tl_id,pkg_id) VALUES (%(tlId)s,%(pkgId)s)" +## dct['pkgId']=pkgId +## try: +## dBUtils.putData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='insert new tl_cat package record') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to insert new association between a texlive package and a catalogue package' +## noteException(mesg,devel=mesg+' for texlive package %(tlId)s and catalgoue package %(pkgId)s: %(err)s',log=self.log,debug=self.debug,tlId=repr(tlId),pkgId=repr(pkgId),err=errorValue(err)) +## # Insert the file records +## # First build a list of pairs: (fileName,fileType) +## fileList=[] +## if self.srcfiles: +## for fn in self.srcfiles: +## fileList.append((fn,'src')) +## if self.runfiles: +## for fn in self.runfiles: +## fileList.append((fn,'run')) +## if self.docfiles: +## for fn in self.docfiles.keys(): +## fileList.append((fn,'doc')) +## if self.binfiles: +## for arch in self.binfiles.keys(): +## for fn in self.binfiles[arch]: +## fileList.append((fn,'bin')) +## # .. then put the info in the dB +## dct={'tlId':tlId} +## for (fn,fileType) in fileList: +## pathDir,pathBase=os.path.split(fn) +## sql="INSERT INTO tds_files (tl_id,type,path_dir,path_base) VALUES (%(tlId)s,%(fileType)s,%(pathDir)s,%(pathBase)s)" +## dct['fileType']=fileType +## dct['pathDir']=pathDir +## dct['pathBase']=pathBase +## try: +## dBUtils.putData(sql,dct=dct,dBcsr=dBcsr,log=self.log,debug=self.debug,listtype='insert new texlive files record') +## except dBUtils.dBUtilsError, err: +## mesg=u'unable to insert new tds files record' +## noteException(mesg,devel=mesg+' for package %(tlId)s with type=%(fileType)s, pathDir=%(pathDir)s, pathBase=%(pathBase)s: %(err)s',log=self.log,debug=self.debug,tlId=repr(tlId),fileType=repr(fileType),pathDir=repr(pathDir),pathBase=repr(pathBase),err=errorValue(err)) +## # Commit +## try: +## dBcnx.commit() +## except Exception, err: +## mesg=u'unable to commit the insert of the new tds files record' +## noteException(mesg,devel=mesg+' for package %(pkgId)s: %(err)s',log=self.log,debug=self.debug,tlId=repr(tlId),err=errorValue(err)) +## return None + + initialState=tlp.initialState + nextStates=tlp.nextStates + nextStates['revision']=tlp.keyValueStates-set(['revision']) + nextStates['srcfiles']=tlp.keyValueStates | set(['srcfiles_file'])-set(['srcfiles']) + nextStates['srcfiles_file']=tlp.keyValueStates | set(['srcfiles_file']) + nextStates['runfiles']=tlp.keyValueStates | set(['runfiles_file'])-set(['runfiles']) + nextStates['runfiles_file']=tlp.keyValueStates | set(['runfiles_file']) + nextStates['docfiles']=tlp.keyValueStates | set(['docfiles_file'])-set(['docfiles']) + nextStates['docfiles_file']=tlp.keyValueStates | set(['docfiles_file'])-set(['docfiles']) + nextStates['binfiles']=tlp.keyValueStates | set(['binfiles_file']) + nextStates['binfiles_file']=tlp.keyValueStates | set(['binfiles_file']) + nextStates['cataloguedata']=tlp.keyValueStates + + def handleRevision(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'revision' + """ + try: + fields=restOfLine.strip().split() + self.revision=int(fields[0]) + except: + mesg=u'no "value" integer in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + return None + + def handleSrcfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'srcfiles' + """ + try: + fields=restOfLine.strip().split() + sizeString=fields[0] + except: + mesg=u'no value in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + try: + sizeFields=sizeString.split('=') + if sizeFields[0].lower()!='size': + raise tlError + size=int(sizeFields[1]) + if self.srcsize is None: + self.srcsize=0 + self.srcsize+=size + except: + mesg=u'expected a value of size=NNNNNN in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + if self.srcfiles is None: + self.srcfiles=[] + return None + + def handleSrcfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'srcfiles_file' + """ + try: + fields=restOfLine.strip().split() # recall that restOfLine=line[1:] + self.srcfiles.append(fields[0]) + except: + mesg=u'unable to understand source file name in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + return None + + def handleDocfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'docfiles' + """ + try: + fields=restOfLine.strip().split() + sizeString=fields[0] + except: + mesg=u'no value in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + try: + sizeFields=sizeString.split('=',1) + if sizeFields[0].lower()!='size': + raise tlError + size=int(sizeFields[1]) + if self.docsize is None: + self.docsize=0 + self.docsize+=size + except: + mesg=u'expected a value of size=NNNNNN in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + if self.docfiles is None: + self.docfiles={} + return None + + def handleDocfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'docfiles_file' + """ + fields=restOfLine.strip().split() # recall that restOfLine=line[1:] + kvDct={} + kvString=None + try: + for kvString in fields[1:]: + if kvString: + k,v=kvString.split("=",1) + kvDct[k]=v + except: + mesg=u'unable to understand doc file description in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s; key-value description string=%(kvString)s; reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState),kvString=repr(kvString)) + try: + self.docfiles[fields[0].strip()]=kvDct + except Exception, err: + mesg=u'unable to understand doc file name in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s: %(err)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState),err=errorValue(err)) + return None + + def handleRunfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'runfiles' + """ + try: + fields=restOfLine.strip().split() + sizeString=fields[0] + except: + mesg=u'no value in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + try: + sizeFields=sizeString.split('=',1) + if sizeFields[0].lower()!='size': + raise tlError + size=int(sizeFields[1]) + if self.runsize is None: + self.runsize=0 + self.runsize+=size + except: + mesg=u'expected a value of size=NNNNNN in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + if self.runfiles is None: + self.runfiles=[] + return None + + def handleRunfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'runfiles_file' + """ + try: + fields=restOfLine.strip().split() # recall that restOfLine=line[1:] + self.runfiles.append(fields[0].strip()) + except: + mesg=u'unable to understand run file name in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + return None + + def handleBinfiles(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'binfiles' + """ + try: + fields=restOfLine.strip().split() + firstString,secondString=fields[0],fields[1] + except: + mesg=u'expected an arch=XXXX size=NNNNNN in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + try: + firstStringFields=firstString.split('=',1) + secondStringFields=secondString.split('=',1) + if firstStringFields[0].lower()=='arch': + archFields=firstStringFields + sizeFields=secondStringFields + else: + archFields=secondStringFields + sizeFields=firstStringFields + if (archFields[0].lower()!='arch' + or sizeFields[0].lower()!='size'): + raise tlError + self.currentArch=archFields[1] + except: + mesg=u'expected two values of the form x=y in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + try: + if self.binsize is None: + self.binsize={} + self.binsize[self.currentArch]=int(sizeFields[1]) + except: + mesg=u'expected size to be an integer in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + if self.binfiles is None: + self.binfiles={} + self.binfiles[self.currentArch]=[] + return None + + def handleBinfilesFile(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'binfiles_file' + """ + if self.currentArch is None: + mesg=u'do not know the right architecture in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + try: + fields=restOfLine.strip().split() # recall that restOfLine=line[1:] + self.binfiles[self.currentArch].append(fields[0].strip()) + except: + mesg=u'unable to understand bin file path in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s with architecture %(currentArch)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState),currentArch=repr(currentArch)) + return None + + def is_arch_dependent(self): + """Returns True if there are binfiles. + """ + if self.binfiles: + return True + else: + return False + + def total_size(self,*archs): + """Returns the sum of the sizes of srcfiles, docfiles, runfiles, + and binfiles any architectures given. + """ + if self.srcsize is None: + srcsize=0 + else: + srcsize=self.srcsize + if self.docsize is None: + docsize=0 + else: + docsize=self.docsize + if self.runsize is None: + runsize=0 + else: + runsize=self.runsize + s=srcsize+docsize+runsize + try: + for arch in archs: + s+=self.binsize[arch] + except: + mesg=u'unable to recognize an architecture' + noteException(mesg,devel=mesg+': %(arch)s',exception=tlError,log=self.log,debug=self.debug,arch=repr(arch)) + return s + + def _subtractList(self,l1,l2): + """From l1 remove any elements of l2, as many times as they occur. + """ + for f in l2: + while True: # more than one f in l1? + try: + l1.remove(f) + except: + break + return l1 + def add_srcfiles(self,fileList): + self.srcfiles+=fileList + def remove_srcfiles(self,fileList): + self.srcfiles=self._subtractList(self.srcfiles,fileList) + def add_docfiles(self,fileList): + self.docfiles+=fileList + def remove_docfiles(self,fileList): + self.docfiles=self._subtractList(self.docfiles,fileList) + def add_runfiles(self,fileList): + self.runfiles+=fileList + def remove_runfiles(self,fileList): + self.runfiles=self._subtractList(self.runfiles,fileList) + def add_binfiles(self,arch,fileList): + self.binfiles[arch]+=fileList + def remove_binfiles(self,arch,fileList): + self.binfiles[arch]=self._subtractList(self.binfiles[arch],fileList) + def add_files(self,t,fileList): + if t=='src': + self.add_srcfiles(fileList) + elif t=='doc': + self.add_docfiles(fileList) + elif t=='run': + self.add_runfiles(fileList) + else: + mesg=u'file type not known' + noteException(mesg,devel=mesg+': %(t)s',exception=tlError,log=self.log,debug=self.debug,t=repr(t)) + def remove_files(self,t,fileList): + if t=='src': + self.remove_srcfiles(fileList) + elif t=='doc': + self.remove_docfiles(fileList) + elif t=='run': + self.remove_runfiles(fileList) + else: + mesg=u'file type not known' + noteException(mesg,devel=mesg+': %(t)s',exception=tlError,log=self.log,debug=self.debug,t=repr(t)) + + def list_files(self): + """Return a string of lines with file names for all files + """ + r=[] + if self.srcfiles: + r+=self.srcfiles + if self.runfiles: + r+=self.runfiles + if self.docfiles: + r+=self.docfiles.keys() + if self.binfiles: + for arch in self.binfiles.keys(): + r+=self.binfiles[arch] + r.sort() + return "\n".join(r) + + +class tlpobj_db(tlp_db): + """Give information based on a TeXLive object file database + """ + def _makeSingle(self): + """Helper fcn to make one of whatever self.value is holding multiple + of + f file handle + """ + return tlpobj(log=self.log,debug=self.debug) + +## def to_db(self,dBcsr,dBcnx,verbose=False): +## """Write all records to the database +## dBcsr,dBcnx database cursor and connection +## """ +## pkgNames=self.value.keys() +## pkgNames.sort() +## for k in pkgNames: +## v=self.value[k] +## v.to_db(dBcsr,dBcnx,verbose=verbose) +## return None + + +class tlpsrc(tlp): + """Give information based on a TeXLive source file + """ + def __init__(self,verbose=False,log=None,debug=False): + """Initialize an object. + """ + super(tlpsrc,self).__init__(verbose=verbose,log=log,debug=debug) + self.srcpattern=None # list of strings (or None) + self.runpattern=None # list of strings (or None) + self.docpattern=None # list of strings (or None) + self.binpattern=None # list of strings (or None) + return None + + def __unicode__(self): + r=[] + r.append(super(tlpsrc,self).__unicode__()) + r.append(" srcpattern: %s" % (pprint.pformat(self.srcpattern),)) + r.append(" runpattern: %s" % (pprint.pformat(self.runpattern),)) + r.append(" docpattern: %s" % (pprint.pformat(self.docpattern),)) + r.append(" binpattern: %s" % (pprint.pformat(self.binpattern),)) + return "\n".join(r) + + def _stringToWriteout(self): + """String that will be written out during writeout_fh + """ + r=[] + r.append(super(tlpsrc,self)._stringToWriteout()) + if self.srcpattern: + for line in self.srcpattern: + r.append("srcpattern %s" % (line,)) + if self.runpattern: + for line in self.runpattern: + r.append("runpattern %s" % (line,)) + if self.docpattern: + for line in self.docpattern: + r.append("docpattern %s" % (line,)) + if self.binpattern: + for line in self.binpattern: + r.append("binpattern %s" % (line,)) + return "\n".join(r) + + initialState=tlp.initialState + nextStates=tlp.nextStates + nextStates['srcpattern']=tlp.keyValueStates + nextStates['runpattern']=tlp.keyValueStates + nextStates['docpattern']=tlp.keyValueStates + nextStates['binpattern']=tlp.keyValueStates + + def handleSrcpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'srcpattern' + """ + try: + if self.srcpattern is None: + self.srcpattern=[] + self.srcpattern.append(restOfLine.rstrip()) + except: + mesg=u'no "value" text in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + return None + + def handleRunpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'runpattern' + """ + try: + if self.runpattern is None: + self.runpattern=[] + self.runpattern.append(restOfLine.rstrip()) + except: + mesg=u'no "value" text in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + return None + + def handleDocpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'docpattern' + """ + try: + if self.docpattern is None: + self.docpattern=[] + self.docpattern.append(restOfLine.rstrip()) + except: + mesg=u'no "value" text in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + return None + + def handleBinpattern(self,newState,restOfLine,line,lineNo): + """What to do if the newState is 'binpattern' + """ + try: + if self.binpattern is None: + self.binpattern=[] + self.binpattern.append(restOfLine.rstrip()) + except: + mesg=u'no "value" text in line number=%(lineNo)s' + noteException(mesg,devel=mesg+'; now in state %(newState)s reading line=%(line)s',exception=tlError,log=self.log,debug=self.debug,lineNo=lineNo,line=repr(line),newState=repr(newState)) + return None + + +class tlpsrc_db(tlp_db): + """Give information based on a TeXLive src file list + """ + def from_dir(self,dn=None): + """Read a set of tlpsrc files. Set self.value. + dn=None directory name. If None, use the canonical name. + """ + if dn is None: + dn=os.path.join(os.path.dirname(TLPDB_FILENAME),'tlpkg/tlpsrc') + globPattern=os.path.join(dn,'*.tlpsrc') + for fn in glob.glob(globPattern): + self.from_file(fn=fn) + return None + + def _makeSingle(self): + """Helper fcn to make one of whatever self.value is holding multiple + of. + """ + return tlpsrc(log=self.log,debug=self.debug) + + def to_dir(self,dn=None): + """Write a set of tlpsrc files. + dn=None directory name. If None, use the canonical name. + """ + if dn is None: + dn=os.path.join(os.path.basename(TLPDB_FILENAME),'tlpsrc') + if not(os.path.exists(dn)): + os.makedirs(dn) + pkgNames=self.value.keys() + for k in pkgNames: + v=self.value[k] + fn=os.path.join(dn,v.name+'.tlpsrc') + v.writeout(fn=fn) + return None + + +def getRelatedCatPkg(tlId,dBcsr,log=None,debug=False): + """Get the list of catalogue packages that are related to the given + TeX Live package (does not return None values). + tlId string + dBcsr database cursor + log=None,debug=False debugging + """ + sql="""SELECT pkg_id FROM tl_cat + WHERE tl_id=%(tlId)s + AND pkg_id IS NOT NULL""" + dct={'tlId':tlId} + try: + dBres=dBUtils.getData(sql,dct=dct,dBcsr=dBcsr,log=log,debug=debug,listtype='get catalogue package ids related to this TeX Live package id') + except dBUtils.dBUtilsError, err: + mesg=u'unable to get texlive-catalogue packages record' + noteException(mesg,devel=mesg+' for TeX Live package %(tlId)s: %(err)s',log=log,debug=debug,tlId=repr(tlId),err=errorValue(err)) + return set([catId for (catId,) in dBres]) + +def getRelatedTlPkg(pkgId,dBcsr,log=None,debug=False): + """Get the list of TeX Live packages that are related to the given + Catalogue package. + pkgId string + dBcsr database cursor + log=None,debug=False debugging + """ + sql="""SELECT tl_id FROM tl_cat + WHERE pkg_id=%(pkgId)s""" + dct={'pkgId':pkgId} + try: + dBres=dBUtils.getData(sql,dct=dct,dBcsr=dBcsr,log=log,debug=debug,listtype='get TeX Live package ids related to this catalogue package id') + except dBUtils.dBUtilsError, err: + mesg=u'unable to get catalogue-texlive packages record' + noteException(mesg,devel=mesg+' for catalogue package %(pkgId)s: %(err)s',log=log,debug=debug,pkgId=repr(pkgId),err=errorValue(err)) + return set([tlId for (tlId,) in dBres]) + + +#...................................................................... +def main(argv=None,log=None,debug=DEBUG): + """The main logic if called from the command line + argv The arguments to the routine + log=None, debug=DEBUG Debugging stuff + """ + if argv is None: + argv=sys.argv + # Parse the arguments + usage="""%prog: read a TeX Live tlp src or obj file; typically write the obj filelists to the dB + %prog [options]""" + oP=optparse.OptionParser(usage=usage,version=__version__) + oP.add_option('--output','-o',action='store_true',default=False,dest='output',help='show all package records') + oP.add_option('--no-database','-n',action='store_true',default=False,dest='noDb',help='do not put all package records to the database') + oP.add_option('--source-read','-s',action='store_true',default=False,dest='srcDir',help='read the source files') + oP.add_option('--add-catalogue-information','-a',action='store_true',default=False,dest='catInfo',help='add catalogue information to the source or object information') + oP.add_option('--debug','-D',action='store_true',default=DEBUG,dest='debug',help='output debugging information') + oP.add_option('--verbose','-V',action='store_true',default=VERBOSE,dest='verbose',help='talk a lot') + opts, args=oP.parse_args(argv[1:]) + # Handle the options + # Handle positional arguments + if args[1:]: + tlpdbFilename=args[1] + else: + tlpdbFilename=TLPDB_FILENAME + # Handle the various command line switches +## try: +## (dBcnx,dBcsr)=dBUtils.opendB() +## except dBUtils.dBUtilsError, err: +## fail("Unable to connect to the database: %(err)s",returnCode=10,log=log,debug=opts.debug,err=errorValue(err)) + if opts.srcDir: + try: + t=tlpsrc_db(log=log,debug=opts.debug) + t.from_dir(dn=None) + if opts.catInfo: + t.add_cat_descs(dBcsr) + t.to_dir(dn='tmpTexlive') + except Exception, err: + mesg="trouble reading the object file and writing: "+errorValue(err) + fail(mesg,returnCode=10,log=log,debug=opts.debug) + return None + if opts.output: + try: + t=tlpobj_db(log=log,debug=opts.debug) + t.from_file(tlpdbFilename) + if opts.catInfo: + t.add_cat_descs(dBcsr) + t.write_file() + except Exception, err: + mesg="trouble reading the object file and writing: "+errorValue(err) + fail(mesg,returnCode=10,log=log,debug=opts.debug) + return None +## if not(opts.noDb): +## try: +## t=tlpobj_db(log=log,debug=opts.debug) +## t.from_file(tlpdbFilename) +## t.to_db(dBcsr,dBcnx,verbose=opts.verbose) +## except Exception, err: +## mesg="trouble reading the object file and sending the results to the database: "+errorValue(err) +## fail(mesg,returnCode=10,log=log,debug=opts.debug) + return None + + +# ............... script start ....................... +if __name__=='__main__': + log=None + if LOGGING: + log=openLog(LOGFILE_NAME,purpose=THIS_SCRIPT) + if DEBUG and __notes__.strip(): + note(__notes__,log,leader="NOTES FOR %s:" % (THIS_SCRIPT,),) + try: + main(argv=sys.argv,log=log,debug=DEBUG) + except KeyboardInterrupt: + mesg=u"Keyboard interrupt" + fail(mesg,returnCode=1,log=log,debug=DEBUG) + except StandardError, err: + mesg=u"General programming error: "+errorValue(err) + fail(mesg,returnCode=2,log=log,debug=DEBUG) + except SystemExit, err: # fail() inside a subroutine + pass + sys.exit(0) |