Exemple #1
0
def create_form(draft, rmap, opts):
    if opts.label not in rmap['forms']:
        raise FormNotFoundError(label=opts.label)

    with open(rmap['forms'][opts.label]) as y:
        spec = yaml_load(y)

    with open_datasource(rmap, spec['source']) as db:
        initial = []
        if 'comments' in spec:
            wrapped = map(comment_yaml, wrap_text(spec['comments'], 78))
            initial.extend(wrapped)
        initial.append("# new values")
        initial.append("# ----------")
        avails = dict(map(lambda x: (x['name'], parse_column_default(x)),
                          spec['columns']))
        initial.extend(yaml_dump(avails).split('\n'))
        try:
            if opts.values:
                reviewed = avails
                reviewed.update(parse_opt_values(opts.values))
            else:
                _, yaml_str = edit(draft, opts, initial="\n".join(initial))
                reviewed = yaml_load(yaml_str)
            db.execute(text(spec['insert']), **reviewed)
            return 0, "Record created successfully!"
        except (YAMLParserError, YAMLScannerError) as e:
            err = EditError('YAML Parsing Error: %s' % str(e))
            err.original_exception = e
            raise err
        except sqlexc.StatementError as e:
            err = EditError('SQL Statement Error: %s' % str(e))
            err.original_exception = e
            raise err
Exemple #2
0
def get_summary(doc: Document, limit: float, wrap: int) -> StringList:
    """Get summary of `doc` as StringList of lines

    Arguments:
        doc {Document} -- document
        limit {float} -- length of summary
        wrap {int} -- column wrap

    Returns:
        StringList -- lines of document
    """
    sentences = doc.summarize(limit)
    text = ' '.join(sentences)

    return [text] if wrap < 1 else wrap_text(text, width=wrap)
def bubble_sort(L):
	'''Sortiert die gegebene Liste L mit Bubble-Sort.'''
	remain = len(L)-1
	done = False
	swap_counter = [ [] for i in range(len(L)) ]
	while not done:
		done = True
		for i in range(remain):
			if L[i] > L[i+1]:
				done = False
				# print("Swapping %s_%s and %s_%s" % (L[i],i,L[i+1],i+1))
				L[i], L[i+1] = L[i+1], L[i]
				swap_counter[i] += [1]
				swap_counter[i+1] += [-1]
				swap_counter[i], swap_counter[i+1] = swap_counter[i+1], swap_counter[i]
		remain -= 1
	total_swaps = sum([ len(swaps) for swaps in swap_counter ])
	wrong_direction_swaps = sum([ abs( abs(sum(swaps))-len(swaps) ) for swaps in swap_counter ])//2
	print(wrap_text( "Von %d Vertauschungen, gingen %d in die falsche Richtung und nochmal soviele wurden gebraucht um diese Rückgängig zu machen. Insgesamt waren also %d%% der Vertauschungen unnötig" % (total_swaps,wrong_direction_swaps,round(2*wrong_direction_swaps/total_swaps*100)) ),"\n")
	return 2*wrong_direction_swaps/total_swaps*100
Exemple #4
0
def edit_form(draft, rmap, opts):
    if opts.label not in rmap['forms']:
        raise FormNotFoundError(label=opts.label)

    with open(rmap['forms'][opts.label]) as y:
        spec = yaml_load(y)

    can_edits = map(lambda x: x['name'],
                    filter(lambda x: 'noedit' not in x.get('perms', []),
                           spec['columns']))

    defaults = dict(map(lambda x: (x['name'], parse_column_default(x)),
                        filter(lambda x: 'noedit' not in x.get('perms', []),
                               spec['columns'])))

    with open_datasource(rmap, spec['source']) as db:
        row = db.execute(text(spec['detail']), dict(pk=opts.pk)).fetchone()
        if not row:
            raise RecordNotFoundError()
        initial = []
        if 'comments' in spec:
            wrapped = map(comment_yaml, wrap_text(spec['comments'], 78))
            initial.extend(wrapped)
        can_shows = map(lambda x: x['name'],
                        filter(lambda x: 'noshow' not in x.get('perms', []),
                               spec['columns']))
        original_data = dict(filter(lambda x: x[0] in can_shows,
                                    dict(row).iteritems()))
        original = yaml_dump(original_data).split('\n')
        initial.append("")
        initial.append("# originial values")
        initial.append("# ----------------")
        initial.extend(map(comment_yaml, original))
        initial.append("# new values")
        initial.append("# ----------")
        edit_form = defaults
        edit_form.update(dict((filter(lambda x: x[0] in can_edits,
                                      dict(row).items()))))
        initial.extend(yaml_dump(edit_form).split('\n'))

        try:
            if opts.values:
                reviewed = edit_form
                update_nested_dict(reviewed, parse_opt_values(opts.values))
            else:
                _, yaml_str = edit(draft, opts, initial="\n".join(initial))
                reviewed = yaml_load(yaml_str)
            for (k, v) in reviewed.iteritems():
                if isinstance(v, dict):
                    reviewed[k].update(dict(map(
                        lambda x: (x[0], unicode(x[1])), v.iteritems())))
            db.execute(text(spec['update']), pk=opts.pk, **reviewed)
            return 0, "Record updated successfully!"
        except (YAMLParserError, YAMLScannerError) as e:
            err = EditError('YAML Parsing Error: %s' % str(e))
            err.original_exception = e
            raise err
        except sqlexc.StatementError as e:
            err = EditError('SQL Statement Error: %s' % str(e))
            err.original_exception = e
            raise err
	'''Sortiert die gegebene Liste von ganzen Zahlen mit in-place Counting-Sort.'''
	C = [0 for i in range(max(L)+1)]
	for i in range(len(L)):
		C[L[i]] += 1
	l_i = 0
	for c_i in range(len(C)):
		while C[c_i] != 0:
			L[l_i] = c_i
			l_i += 1
			C[c_i] -= 1

# Tests
from random import randint
for i in range(10):
	L = [ randint(0,9) for i in range(20) ]
	counting_sort(L)
	print(L)
print()

# Aufgabenteil c)
from textwrap import fill as wrap_text
print(wrap_text("Der Algorythmus besteht aus zwei Teilen. Zunächst werden alle Elemente von L aufgerufen und in C summiert. Dabei ist die Laufzeit T1=c1*n wobei n=len(L). Danach werden alle addierten einsen aus C n=sum(C)=len(L) wieder in L abgespeichert T2=c2*n. Allerdings muss in diesem Schritt auch noch mindestens m=len(C)=max(L) mal verglichen werden, ob das Element von C bereits 0 ist. Damit ergibt sich T3=c3*m. Insgesamt haben wir damit eine Laufzeit von T=(c1+c2)*n+c3*m=O(n+m)."))
print()
print(wrap_text("Der Speicheraufwand ist durch die Länge von C, also den Betrag des größten Elements von L, m=len(C)=max(L) gegeben S(m)=c1*m=O(m)."))
print()

# Aufgabenteil b)
print(wrap_text("Der in-place Counting-Sort Algorythmus ist nicht zum sortieren nach Geburtstagen geeignet. Es treten zwei Probleme auf:"))
print(wrap_text("1. kann der Algorythmus nur Listen aus ganzen Zahlen sortieren, da die gegebene Liste mit den in C gespeicherten Plätzen überschrieben wird. C speichert aber nur Positionen von ganzen Zahlen und keine Daten. Dies lässt sich nur lösen, wenn die in-place Eigenschaft aufgegeben wird."))
print(wrap_text("2. Außerdem ist der Algorythmus noch nicht einmal zur Sortierung von Geburtsdaten an sich geeignet. Geburtstage sind 8-stellige Zahlen (YYYMMDD), somit bräuchte man eine über 20-millionen-stellige Hilfsliste C und selbst, wenn man den Algorythmus so verändern würde, dass C nicht bei 0 losläuft sondern einen Startwert akzeptiert, so hätte man immernoch 1 Million Stellen in C für die letzten hundert Jahre und proportionale Laufzeit und Speicherverbrauch. Die Lösung wäre eine Radix-Sort-Variante, welche nacheinander Tage, Monate und Jahre sortiert. Diese lässt sich mit diesem Algorythmus aber wegen der fehlenden Stabilität nich implementieren. "))