Posts Tagged ‘Python’

Freitag, 30. August 2013

Google Chrome unter die Haube schauen (und JSON lesbar ausgeben)

Hierzu haben die Google-Entwickler folgende URI erdacht:

chrome://net-internals/

Über diese Benutzeroberfläche lassen sich Daten auch im JSON-Format exportieren. Damit diese JSON-Daten auch für Menschen (einigermassen) lesbar werden, nimmt man Python zu Hilfe. Im nachfolgenden Beispiel gehen wir davon aus, dass der JSON-Dump in der Datei dump.json abgelegt ist:

python -mjson.tool < dump.json > dump-pretty.json

Tags: , , , , , , ,
Labels: Web

Keine Kommentare | neuen Kommentar verfassen

Freitag, 30. August 2013

urllib unter Python 3 Debug-Meldungen entlocken

Im Grunde ganz simpel – vorausgesetzt, man weiss wie (angelehnt an how to debug a urllib.urlopen in python!, wo aber noch mit urllib unter Python 2 gearbeitet wird):

import urllib.request
import http.client

http.client.debuglevel = 1
http.client.HTTPConnection.debuglevel = 1

url = 'http://www.eMeidi.com/?action=hack'
headers = {}

Request = urllib.request.Request(url,None,headers)
response = urllib.request.urlopen(Request)	
html = response.read()

Dies produziert Ausgaben in folgender Form:

send: b'GET http://www.eMeidi.com/?action=hack HTTP/1.1\r\nAccept-Encoding: iden
tity\r\nHost: www.eMeidi.com\r\nUser-Agent: Python-urllib/3.3\r\nConnection: clo
se\r\n\r\n'
reply: 'HTTP/1.0 407 Proxy Authentication Required\r\n'
header: Date header: Proxy-Authenticate header: Proxy-Connection header: Content
-Type header: Content-Length

Tags: , ,
Labels: Programmierung

Keine Kommentare | neuen Kommentar verfassen

Mittwoch, 14. August 2013

URLs mit Python dekodieren

War gestern auf der Arbeit sehr handlich, um URL-kodierte GET-Parameter wieder lesbar zu machen:

$ python
>>> import urllib.parse
>>> urllib.parse.unquote('http://domain.tld/index.php?t=12%2F7%2F2013%2011%3A19%3A40%201%20-120&ce=UTF-8')
'http://domain.tld/index.php?t=12/7/2013 11:19:40 1 -120&ce=UTF-8'

Tags: , , , ,
Labels: Programmierung

Keine Kommentare | neuen Kommentar verfassen

Dienstag, 19. Februar 2013

cld zwecks Spracherkennung in Python-Scripts integrieren

CLD ist der Compact Language Detector welcher in Google-Projekten zum Einsatz kommt — primär einmal in Googles Web-Browser Google Chrome. Mit diesem Detektor ist es möglich, die Sprache eines Textes zu erkennen.

Der Code des Detektors ist quelloffen, weshalb findige Entwickler den Code aus dem Google-Projekt herausgelöst haben und als eigenständige Linux-Library bereitstellen:

CLD – Compact Language Detector

Ich habe diesen Detektor in ein Projekt integriert und dabei die PHP-basierte Lösung Package Information: Text_LanguageDetect abgelöst, weil ich dessen Erkennungsgenauigkeit nicht als herausragend empfunden habe.

Download und Kompilation der Library

Zuerst klonte ich den Quellcode auf das Entwicklungssystem:

$ cd /tmp
$ git clone https://github.com/mzsanford/cld.git

Anschliessend versuchte ich die Kompilierung und Installation, doch dies schlug fehl:

$ cd /tmp/cld
$ ./configure
configure: error: cannot find install-sh or install.sh in "." "./.." "./../.."

Zuerst musste ich mir folgende Ubuntu/Debian-Pakete herunterladen:

# apt-get install build-essential libtool autoconf automake pkg-config

Via: run autoreconf -f -i -Wall,no-obsolete to fix install-sh problem

Anschliessend musste ich die Kompilierungsinformationen des Projektes neu generieren:

$ cd /tmp/cld
$ autoreconf -f -i -Wall,no-obsolete

Nach diesem Schritt klappte es auch mit der Kompiliererei:

$ cd /tmp/cld
$ ./configure

Installation der Library

Nun musste die Library noch installiert werden, was mit folgendem Befehl erfolgte:

# cd /tmp/cld
# make install

Installation der Python-Bindings

Noch war ich nicht am Ziel. Nachdem die Shared Library installiert war, fehlten noch die Python-Bindings, mit welchen die Library mittels eines simplen import cld in ein Python-Script importiert werden kann:

# cd /tmp/cld/ports/python
# make install
...
pycldmodule.cc:5:20: Schwerwiegender Fehler: Python.h: Datei oder Verzeichnis nicht gefunden
Kompilierung beendet.

Sorry, aber den Laptop habe nicht ich aufgesetzt — Linux läuft bei mir immer unter der englischen Sprache …

Es fehlte der Python-Quellcode, welchen ich folgendermassen nachrüstete:

# apt-get install python-dev

Anschliessend funktionierte auch der folgende Befehl sauber:

# cd /tmp/cld/ports/python
# make install

Die Originalversion dieses Artikels liess das Paket pkg-config nicht installieren. Ist dieses Paket nicht vorhanden, erscheint bei der Kompilierung folgende Fehlermeldung:

/tmp/cld/ports/python# make
python -u setup.py build
Traceback (most recent call last):
  File "setup.py", line 12, in 
    **pkgconfig('cld'))
TypeError: __init__() keywords must be strings
make: *** [build] Error 1

Nachdem pkg-config nachinstalliert wird, klappt es mit der Installation der Python-Bindings problemlos.

Via: Error when installing python bindings

Integration in Python-Scripts

Leider funktionierte die Integration der Library in ein Python-Script mittels import cld nicht:

Traceback (most recent call last):
File "", line 1, in 
ImportError: libcld.so.0: cannot open shared object file: No such file or directory

Zuerst musste noch die Shell-Variable LD_LIBRARY_PATH mit dem Pfad auf cld angepasst werden (sowohl in .bashrc als auch in .profile, weil ich immer noch nicht begriffen habe, welche Datei bei einem Shell-Login geladen wird — ich sollte wohl mal Shell startup scripts lesen, doch diese Grafik sagt wohl schon alles zum Thema aus):

...
export LD_LIBRARY_PATH="/usr/local/lib:/usr/local/lib/cld"

Via: Language detection with Google’s Compact Language Detector

Alternativ kann das Verzeichnis über die Verzeichnisstruktur /etc/ld.so.conf.d auch systemweit gesetzt werden (Via: How to define LD_LIBRARY_PATH for all applications).

Anschliessend konnte ich mit wenigen Zeilen Python-Code die Spracherkennung für Texte aktivieren:

import cld
...
detectedLangName, detectedLangCode, isReliable, textBytesFound, details = cld.detect(plaintext, pickSummaryLanguage=False, removeWeakMatches=False)

Tags: , , , , , ,
Labels: Programmierung

Keine Kommentare | neuen Kommentar verfassen

Donnerstag, 14. Februar 2013

Data Mining mit Ubuntu, MySQL, PHP und Python

Beruflich setze ich mich derzeit mit der Analyse von Inhalten von Web-Sites auseinander. Nachfolgend habe ich einige Erfahrungen aufgelistet, welche ich dabei gemacht habe.

Wir verarbeiten in diesem Projekt Web-Sites, welche wir mit entsprechenden Tools aus dem Web auf den lokalen Rechner gespiegelt haben. Die Web-Site Assets liegen im Dateisystem. Zur Weiterverarbeitung der Daten wurden die HTML-, JS-, CSS- und XML-Rohdaten in eine MySQL-Tabelle gespitzt (12GB) und anschliessend mit Meta-Daten ergänzt.

Ich persönlich bin nicht sicher, ob die Ablage von HTML-Code in der Datenbank die sinnvollste und performanteste Lösung ist, aber dies war nunmal der Stand des Projektes als ich dazu gestossen bin — und daran liess sich nichts mehr rütteln.

Da wir unter anderem auch Volltextsuchen auf die Grunddaten anwenden, hätte ich mir Apache Solr genauer angeschaut und darauf mittels PHP und JSON zugegriffen.

Kommandozeile

Da der Ubuntu-Server aus mir unerfindlichen Gründen mit LAMPP aufgesetzt wurde, befinden sich die Binaries wie php nicht in den Standardpfaden und werden von bash ohne absolute Pfadangabe nicht gefunden. Da man den Interpreter täglich dutzende, wenn nicht gar hunderte Male aufruft, ist es ratsam, das Verzeichnis sofort in die $PATH-Variable des Shells aufzunehmen.

Hier findet man sich in der Shell Startup File Hell wieder. Je nachdem, ob man lokal arbeitet oder sich per SSH einloggt muss der Befehl an einem anderen Ort stehen. Schlussendlich habe ich die nachfolgende Zeile …

...
PATH="$PATH:/opt/lampp/bin"

… ans Ende folgender zwei Dateien angefügt:

  • ~/.profile
  • ~/.bashrc

Datenbank (MySQL)

Cache aktivieren

Wir führen PHP-Scripts über die Linux-Shell aus. Gerade bei der Entwicklung neuer Scripts sind verschiedene Anläufe nötig, bis alle Bugs und nicht beabsichtigten Funktionen ausgemerzt sind. Da wir oftmals an einem Datenset von 60’000+ Seiten arbeiten, ist es unabdingbar, dass wir eine Cacheing-Lösung anwenden, um Datenbankabfragen im Kurzspeicher zwischenzulagern.

Folgende Parameter in my.cnf aktivieren den in MySQL vorhandenen Cache:

...
[mysqld]
...
query_cache_type = 1
query_cache_size = 512M
query_cache_limit = 32M

Der Geschwindigkeitsgewinn ist immens — nachdem ein Script mit SELECT-Statements zum ersten Mal ausgeführt wurde und dafür mehrere Minuten benötigte, rauscht es in den folgenden Malen innert Sekunden durch.

Programmierung (PHP und Python)

Helper-Funktionen und -Klassen

Wie aus der Web-Entwicklung gewohnt sollte man bei jedem der mit der Zeit entstehenden Scripts zu Beginn Klassen, allgemeine Einstellungen und Funktionen einbinden.

In der Funktionsbibliothek setze ich beispielsweise folgende wichtigen Parameter in globaler Form:

...
error_reporting(E_ALL);
date_default_timezone_set('Europe/Zurich');

Auch die Datenbankverbindung wird mittels meiner MySQL-Klasse hier erstellt und an alle Scripts weitergegeben, welche die Library einbinden.

Aufbau der Scripts

Als ich zum Projekt stiess herrschten Spaghetti-Code in teils monolithischen Scripts vor. Ich habe meine eigenen Scripts dann aber so entwickelt, dass sie dem Unix-Gedanken folgend normalerweise nur eine bestimmte Funktion ausführen, diese dafür aber ausgezeichnet und in sich abgeschlossen. So steht im Normalfall in jedem Script, welches Daten manipuliert, zuoberst ein SQL-Query, welches die zu verändernden Datenbankdaten auswählt.

Bei der Entwicklung wählt man hierbei ein Query, das einen oder nur wenige Werte aus der Datenbank ausliest und verarbeitet — in dieser Phase hat man keine Zeit, möglicherweise fehlerhafte Manipulationen an 60’000+ Seiten durchzuführen.

HTML mit regulären Ausdrücken parsen?

Nein, besonders nicht dann, wenn man konkret an Eigenschaften des SGML-Markup interessiert ist (bspw. Wohin zeigen Links?). Hierzu verwendet man die in PHP standardmässig enthaltene DOMDocument-Bibliothek.

Wichtig ist, dass man bei der Verwendung von E_ALL die loadHTML()-Funktion mittels @ stummschaltet, weil sonst das Terminal mit Warnungen über fehlerhaften HTML-Code (leider an der Tagesordnung) vollgespamt wird:

...
$dom = new DOMDocument();
@$dom->loadHTML($html);
$elements = $dom->getElementsByTagName('a');

HTML manipulieren — und Fallstricke

Für jede HTML-Seite erstellen wir eine Nur-Text-Version. Hierzu verwenden wir html2text.py von Aaron Swartz selig. Bevor das HTML aber umgewandelt wird, säubern wir die HTML-Datei auf eigene Faust. Auch hier kommt DOMDocument zum Zug.

Wir suchen dabei zuerst einmal Elemente jeglicher Art, deren ID oder Klasse den String nav, menu und breadcrumb enthält. Die Navigation interessiert uns nämlich nicht, und noch schlimmer: Sie verfälscht teilweise die Resultate, weil in der Navigation gesuchte Begriffe vorkommen.

Hierzu lade ich den HTML-Code wieder in eine DOMDocument und iteriere danach über alle Elemente auf der Suche nach den besagten IDs und Klassennamen:

function cleanNavMenuElements($html = null) {
		$dom = new DOMDocument();
		@$dom->loadHTML($html);
		
		$changesMade = false;
		
		$elements = $dom->getElementsByTagName('*');
		foreach($elements as $element) {
			if(preg_match('/^(html|body)$/',$element->nodeName)) {
				// Otherwise we might delete the whole DOM!
				continue;
			}
			
	        if($element->hasAttribute('class') && preg_match('/(nav|menu|breadcrumb)/i',$element->getAttribute('class')) > 0) {
				status('Found element with class ' . $element->getAttribute('class'));
				$element->parentNode->removeChild($element);
				
				$changesMade = true;
				
				// Don't go further if we removed this node already
				continue;
			}
			
			if($element->hasAttribute('id') && preg_match('/(nav|menu|breadcrumb)/i',$element->getAttribute('id')) > 0) {
				status('Found element with id ' . $element->getAttribute('id'));
				$element->parentNode->removeChild($element);
				
				$changesMade = true;
			}
	    }
		
		if(!$changesMade) {
			return $html;
		}
		
		return $dom->saveHTML();
	}

Ein Problem manifestiert sich bei der Manipulation aber: Jegliche Anpassungen erfolgen live, was verwirrende Folgen für Schleifen haben kann.

Da die Suche nach obigen ID- und Klassennamen nicht alle Navigationselemente eliminiert, suche ich in einem zweiten Anlauf Tabellen und Listen, deren Elemente ausschliesslich Links enthalten. Dies ist ein guter Indikator, ein Navigationsblock gefunden zu haben.

Hier ist das Problem des sich bei jeder Iteration veränderndem DOM aber sehr ausgeprägt. Wenn ich deshalb durch td-Elemente und li-Elemente iteriere, verwende ich nicht foreach() sondern eine for()-Schleife, deren Counter $i ich immer dann zurücksetze, wenn ich ein Element entferne. Ansonsten wird aus Erfahrung in der Folge eines (oder mehrere Elemente) übersprungen. Damit dies klappt, arbeite ich den DOM Tabellen- respektive Listenweise ab:

$containers = $dom->getElementsByTagName($containerTag);
	
foreach($containers as $container) {
	$items = $container->getElementsByTagName($itemTag);
	
	for($i = 0; $i < $items->length; $i++) {
		$item = $items->item($i);
		
		if($item === null) {
			continue;
		}
		
		$otherTagsPresent = false;
		foreach($item->childNodes as $child) {
			$tag = $child->nodeName;

			if($tag == '#text') {
				$text = trim($child->nodeValue);
				$len = strlen($text);
				if($len < 1) {
					//#text is empty, thus not relevant
					continue;
				}
			}

			if($tag != 'a') {
				$otherTagsPresent = true;
				continue;
			}
		}

		if(!$otherTagsPresent) {
			$item->parentNode->removeChild($item);
			$i = $i-1;
		}
	}

Weiterverarbeitung der Daten durch Nicht-IT-Profis

Zur Weiterverarbeitung der Auswertungen durch andere, in IT nicht versierte Mitarbeiter habe ich eine Funktion geschrieben, welche eine Pfadangabe sowie CSV-Daten als Argumente übertragen erhält. Die Datei wird geschrieben und gleich anschliessend mittels eines kleinen Python-Scripts (Stichwort: openpyxl) in das bei uns hauptsächlich verwendete XLSX-Format konvertiert.

Tags: , , , , , , , , ,
Labels: Programmierung

Keine Kommentare | neuen Kommentar verfassen

Samstag, 17. November 2012

Bilddateien unter Mac OS X mit Rechtsklick auf Flickr laden (Python und Automator)

Rückblickend — wie so vieles — eine ganz simple Aufgabe.

WICHTIG: Das neueste, überarbeitete Script findet sich auf Github unter emeidi/flickrUpload

flickrUploaderLean.py

#!/usr/bin/env python

import os
import sys
import re
import flickrapi

api_key = ''
api_secret = ''

flickr = flickrapi.FlickrAPI(api_key, api_secret)

(token, frob) = flickr.get_token_part_one(perms='write')
if not token:
    raw_input("Press ENTER after you authorized this program")
flickr.get_token_part_two((token, frob))

numArgs = len(sys.argv)
if(numArgs < 1):
	sys.exit("Usage:" + sys.argv[0] + " ")

photo_path = sys.argv[1]

if(os.path.isfile(photo_path) == False):
	sys.exit("File not found: " + photo_path)

res = flickr.upload(filename=photo_path, is_public=u'1')

t = res[0]
if t.tag == 'photoid':
	print 'http://www.flickr.com/photos/upload/edit/?ids=' + t.text
else:
	print 'http://www.flickr.com/upload+failed'

sys.exit(0)

Anschliessend erstellt man mittels Apple Automator einen Service, welcher nach dem Abspeichern mittels eines Rechtsklick auf eine Datei im Untermenu „Services“ aufgeführt wird:

image-5276

Konkret:

  • Service receives selected files or folders in Finder.app
  • Run Shell Script
    • Shell: /bin/bash
    • Pass Input: as arguments
    • (Textfeld): /Users/mario/Scripts/flickrUploadLean.py „$@“
  • Display Webpages

Tags: , , , , , ,
Labels: IT

Keine Kommentare | neuen Kommentar verfassen

Donnerstag, 9. Februar 2012

SAP Spreadsheet-Exporte parsen

… ist leider nicht so einfach.

SAP bietet die Möglichkeit, Reports zu exportieren. Zur Auswahl steht unter anderem auch ein „Spreadsheet“-Format, für welches die Endung .xls vorgeschlagen wird. Dabei handelt es sich aber nicht etwa um das Excel-Binärformat, welches heute durch OOXML abgelöst wurde, sondern um das ältere XLL-Format, was auch immer das genau sein soll. Betrachtet man die aus SAP generierte Datei in einem Text-Editor, ist offensichtlich, dass es sich hierbei nicht um ein Binär- sondern um ein Plaintext-Format mit Tabulator getrennten Spalten handelt.

Wenn diese Datei aber mit Python eingelesen wird und verarbeitet werden soll, ergeben sich Probleme. Die Zeichen sind auf der cygwin-Kommandozeile von einem Leerzeichen getrennt. Es handelt sich also nicht um eine ASCII-Ausgabe.

Ein Blick mit Notepad++ auf die Datei zeigt, dass die Encodierung der Datei UCS-2 Little Endian sein soll. Auf Stackoverflow ist erwähnt, dass diese Encodierung in Python wie UTF-16 behandelt werden kann, und zwar folgendermassen:

file = codecs.open(filenameInput,'Ur',encoding='utf-16be')

Leider führt das aber nicht zum Erfolg, was nachfolgende Fehlermeldung einem schmerzlich vor Augen führt:

Traceback (most recent call last):
  File "./<script>.py", line 140, in 
    data = file.read()
  File "C:\Python27\lib\codecs.py", line 671, in read
    return self.reader.read(size)
  File "C:\Python27\lib\codecs.py", line 477, in read
    newchars, decodedbytes = self.decode(data, self.errors)
UnicodeDecodeError: 'utf16' codec can't decode bytes in position 1082-1083: illegal encoding

Tags: , ,
Labels: Allgemein

Keine Kommentare | neuen Kommentar verfassen

Donnerstag, 9. Februar 2012

Mit openpyxl .xlsx-Dateien ausgeben

Mit dem Python-Modul openpyxl ist es möglich, Excel-Dateien im Microsoft OOXML-Format (.xlsx) zu lesen und zu schreiben.

Da das Erstellen einer solchen Datei im Netz verständlich erklärt ist und hier nicht näher beleuchtet werden soll, ist das Styling von Tabellenzeilen leider kaum dokumentiert.

Hier einige Ansatzpunkte in Form von Code-Schnipseln aus einem meiner Python-Scripts:

from openpyxl.reader.excel import load_workbook
from openpyxl.writer.excel import ExcelWriter

from openpyxl.workbook import Workbook
from openpyxl.worksheet import ColumnDimension
from openpyxl.cell import get_column_letter, column_index_from_string
from openpyxl.style import Color, Fill

# Eigenschaften von Zelle in Reihe 4 und Spalte 3
cellCoord = get_column_letter(3) + "4"

# Fettschrift
sheetResult.cell(cellCoord).style.font.bold = True

# Textausrichtung
sheetResult.cell(cellCoord).style.alignment.horizontal = 'left'
sheetResult.cell(cellCoord).style.alignment.vertical = 'top'

# Textumbruch
sheetResult.cell(cellCoord).style.alignment.wrap_text = True

# Zellfüllung
sheetResult.cell(cellCoord).style.fill.fill_type = Fill.FILL_SOLID 
sheetResult.cell(cellCoord).style.fill.start_color.index = Color.GREEN

# Für Zellfüllung verfügbare Farben
BLACK = 'FF000000'
WHITE = 'FFFFFFFF'
RED = 'FFFF0000'
DARKRED = 'FF800000'
BLUE = 'FF0000FF'
DARKBLUE = 'FF000080'
GREEN = 'FF00FF00'
DARKGREEN = 'FF008000'
YELLOW = 'FFFFFF00'
DARKYELLOW = 'FF808000'

Tags: ,
Labels: Allgemein

Keine Kommentare | neuen Kommentar verfassen

Donnerstag, 9. Februar 2012

Python-Scripts unter Windows in ausführbare .exe-Dateien umwandeln

Mit Python-Scripts kann man auch in einer Grossfirma wie meinem Arbeitgeber Arbeitsabläufe automatisieren, so beispielsweise das parsen einer Excel-Datei mit dem Modul openpyxl. Ich suche in der Excel-Datei in einer bestimmten Spalte nach Parametern und in derselben Zeile dann nach den auf dem produktiven System eingestellten Werten.

Doch was macht man nun mit dem Python-Script, wenn es als stabil empfunden und zur Distribution unter den Arbeitskollegen freigegeben wurde? Man kann nicht erwarten, dass nur ein einziger Mitarbeiter Python auf seinem Windows-Rechner installiert hat und das Script so ausführen kann.

Zum Glück gibt es eine einfache Möglichkeit, um Python-Scripts in eine .exe-Datei umzuwandeln, welche ausschliesslich aus dieser Datei bestehen und deshalb problemlos herumgereicht werden können.

Hierfür benötigt man den pyinstaller (kompatibel mit Python 2.7), welchen man folgendermassen aufruft:

python C:\Source\pyinstaller-1.5.1\pyinstaller.py C:\Source\emeidi\<script>.py -F

Der Switch -F sagt pyinstaller, dass er das Script in eine einzige, grosse .exe-Datei umwandeln und auf den sonst ebenfalls nötigen .dll-Plunder verzichtet.

Anschliessend findet sich die .exe-Datei unter C:\Source\pyinstaller-1.5.1\<script>\dist\<script>.exe, welche man beispielsweise auf den Desktop kopieren und von dort ausführen kann.

Tags: , , ,
Labels: Allgemein

1 Kommentar | neuen Kommentar verfassen

Mittwoch, 31. August 2011

Word HTML-Säuberer wordoff.py lokal ausführbar machen

Kürzlich stand ich auf der Arbeit vor der schmerzlichen Vorgabe, ein dutzendes Seiten umfassendes Word-Dokumenten nach Excel zu kopieren (das Dokument enthielt unzählige Tabellen im immer gleichen Aufbau). Anstelle jede Zelle mühsam einzeln nach Excel zu kopieren – was meine gesamte bisherige Ausbildung in Frage gestellt hätte – entschied ich mich dafür, das Word-Dokument als HTML abzuspeichern, den HTML-Code anzupassen und danach in Word zu importieren.

Bekanntermassen ist der von Word produzierte HTML-Code ungefähr so das schrecklichste, was ein Web-Entwickler jemals zu Gesicht bekommen wird. Zum Glück gibt es Web-Dienste wie WordOff, welche über ein Web-Form Word-HTML entgegennehmen, säubern und zum Download anbieten.

Da das Word-Dokument in meinem Falle aber die Bemerkung „Strictly Confidential“ enthielt, empfand ich dies dann doch eher als gewagter Stunt, der mir im schlimmsten Falle den Job hätte kosten können.

Ich entschied mich deshalb, den Python-Code für das Projekt von git herunterzuladen, anzupassen und danach lokal über das HTML-File laufen zu lassen.

Folgende Anpassung war in wordoff.py nötig:

...
def superClean(str):
    clean = stripAttributes(str)
    cleaner = stripSpans(clean)
    cleaner = stripDivs(cleaner)
    #cleaner = xenophobia(cleaner)
    cleaner = stripEmptyElements(cleaner)
    cleaner = stripEmptyElements(cleaner)
    cleaner = stripEmptyElements(cleaner)
    cleaner = reduceLineBreaks(cleaner)
    return cleaner

# Changes added by Mario Aeby, eMeidi.com
# Allows to execute the script locally on a command line
def main():
	file = open("word-to-excel.htm");
	str = file.read()
	
	print superClean(str)
	
if __name__ == "__main__":
    main()

Dies erlaubt, das Script folgendermassen auf der Kommandozeile aufzurufen (die Quelldatei muss derzeit leider in den Sourceode hardkodiert werden):

$ ./wordoff.py > word-to-excel-clean.html

Nicht schlecht. Wer weiss, vielleicht lässt der Entwickler diese Anpassung ja auch ins Projekt einfliessen, damit man es künftig sowohl unter dem Django-Framework als auch lokal in einer Shell ausführen kann.

Tags: , , , ,
Labels: IT, Web

1 Kommentar | neuen Kommentar verfassen