josh-gmail-backup 0.104

data/bin/gmail-backup

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+args = ARGV.map { |arg| arg.inspect }.join(" ")
+command = "python -O #{File.dirname(__FILE__)}/../gmail-backup.pyo #{args}"
+puts command
+system(command)

data/bin/gmail-backup-gui

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+args = ARGV.map { |arg| arg.inspect }.join(" ")
+command = "python -O #{File.dirname(__FILE__)}/../gmail-backup-gui.pyo #{args}"
+puts command
+system(command)

data/gmail-backup-gui.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+exec python2.5 -O  gmail-backup-gui.pyo $@

data/gmail-backup.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+  s.name = "gmail-backup"
+  s.version = "0.104"
+  s.date = "2008-10-15"
+  s.summary = "The ultimate one-click solution for doing backups of your GMail account"
+  s.email = "info@gmail-backup.com"
+  s.homepage = "http://www.gmail-backup.com/"
+  s.has_rdoc = false
+  s.authors = ["Jan Švec", "Filip Jurčíček"]
+  s.files = [
+    "gmail-backup-gui.pyo",
+    "gmail-backup-gui.sh",
+    "gmail-backup.gemspec",
+    "gmail-backup.pyo",
+    "gmail-backup.sh",
+    "gmb.gif",
+    "gmb.ico",
+    "gmb.pyo",
+    "svc/__init__.py",
+    "svc/egg.py",
+    "svc/LICENSE.TXT",
+    "svc/map.py",
+    "svc/osutils.py",
+    "svc/registry.py",
+    "svc/retrans.py",
+    "svc/scripting",
+    "svc/scripting/__init__.py",
+    "svc/scripting/conversions.py",
+    "svc/scripting/externals.py",
+    "svc/scripting/extractors.py",
+    "svc/scripting/help.py",
+    "svc/template.py",
+    "svc/utils.py"
+  ]
+  s.executables = ["gmail-backup", "gmail-backup-gui"]
+end

data/gmail-backup.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+exec python2.5 -O gmail-backup.pyo $@

data/svc/LICENSE.TXT

@@ -0,0 +1,12 @@
+Copyright (C) 2008 Jan Svec and Filip Jurcicek
+
+YOU USE THIS TOOL ON YOUR OWN RISK!
+
+email: info@gmail-backup.com
+
+
+Disclaimer of Warranty
+----------------------
+
+Unless required by applicable law or agreed to in writing, licensor provides this tool (and each contributor provides its contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using this work and assume any risks associated with your exercise of permissions under this license. 
+

data/svc/egg.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2008 Jan Svec and Filip Jurcicek
+# 
+# YOU USE THIS TOOL ON YOUR OWN RISK!
+# 
+# email: info@gmail-backup.com
+# 
+# 
+# Disclaimer of Warranty
+# ----------------------
+# 
+# Unless required by applicable law or agreed to in writing, licensor provides
+# this tool (and each contributor provides its contributions) on an "AS IS"
+# BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied, including, without limitation, any warranties or conditions of
+# TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
+# PURPOSE. You are solely responsible for determining the appropriateness of
+# using this work and assume any risks associated with your exercise of
+# permissions under this license. 
+
+"""PythonEgg class module
+"""
+import inspect
+
+from svc.utils import sym
+
+class MetaEgg(type):
+    """PythonEgg metaclass
+    """
+    accessors = {
+        'get': ('getter', 0),
+        'is': ('getter', 0),
+        'set': ('setter', 1),
+        'del': ('deller', 0),
+    }
+
+    def __init__(cls, name, bases, dict):
+        cls.createProperties(dict)
+        super(MetaEgg, cls).__init__(name, bases, dict)
+
+    def createProperties(cls, dict):
+        props = {}
+        for name, object in dict.iteritems():
+            type, prop_name = cls.getPropertyDesc(name, object)
+            if type is None:
+                # No property
+                continue
+            item = props.setdefault(prop_name,  {})
+            if type in item:
+                raise ValueError('More than one access method (%r) for property %r' \
+                                 % (item[type], prop_name))
+            item[type] = name
+        for prop_name in props:
+            d = cls.getAccessors(prop_name)
+            getter = d['getter']
+            setter = d['setter']
+            deller = d['deller']
+            setattr(cls, prop_name, property(getter, setter, deller))
+
+    @classmethod
+    def getPropertyDesc(cls, name, object):
+        NO_PROPERTY = None, None
+        if not inspect.isfunction(object):
+            return NO_PROPERTY
+
+        protected = False
+        if name[0] == '_':
+            protected = True
+            name = name[1:]
+
+        for prefix, (type, argcount) in cls.accessors.iteritems():
+            obj_argcount = object.func_code.co_argcount - 1  # Minus one for 'self'
+            if name.startswith(prefix) and obj_argcount == argcount:
+                name = name[len(prefix):]
+                if not name:
+                    # Skip empty property name
+                    continue
+                break
+        else:
+            return NO_PROPERTY
+
+        name = cls._suffixToProperty(name)
+
+        if protected:
+            name = '_' + name
+
+        return type, name
+
+    @classmethod
+    def _suffixToProperty(cls, suffix):
+        """Converts suffix of attribute into property name
+
+        Examples:
+            getValue(),     suffix 'Value', property 'value'
+            getSomeValue()         'SomeValue'       'someValue'
+            getASR()               'ASR'             'ASR'
+            getX()                 'X'               'x'
+        """
+        if len(suffix) == 1:
+            # One-char property name
+            return suffix.lower()
+        elif suffix[0].isupper() and suffix[1].islower():
+            # Word property like SomeProperty --> someProperty
+            return suffix[0].lower() + suffix[1:]
+        else:
+            # Word property like ASR --> ASR
+            return suffix
+
+    @classmethod
+    def _propertyToSuffix(cls, pname):
+        """Inversion to _suffixToProperty()
+        """
+        return pname[0].upper() + pname[1:]
+
+    def getAccessors(cls, name):
+        if name[0] == '_':
+            name = name[1:]
+            prefix = '_'
+        else:
+            prefix = ''
+        pname = cls._propertyToSuffix(name)
+        ret = {}
+        for method, (type, argcount) in cls.accessors.iteritems():
+            accessor = getattr(cls, '%s%s%s' % (prefix, method, pname), None)
+            ret[type] = accessor
+        return ret
+
+class PythonEgg(object):
+    """PythonEgg class
+
+    Main features:
+        - auto-creation of properties
+    """
+
+    __metaclass__ = MetaEgg
+
+    def __init__(self, *args, **kwargs):
+        self._createMetaAttributes()
+        super(PythonEgg, self).__init__(*args, **kwargs)
+
+    def _createMetaAttributes(self):
+        for name, value in self.__class__.__dict__.iteritems():
+            if self._isMetaAttribute(name, value):
+                setattr(self, name, value(self))
+
+    def _isMetaAttribute(self, name, attr_value):
+        if isinstance(attr_value, MetaAttribute):
+            return True
+        if  inspect.isclass(attr_value) \
+        and issubclass(attr_value, AttributeClass):
+            return True
+
+class MetaAttribute(PythonEgg):
+    def __init__(self, creator, *args, **kwargs):
+        super(MetaAttribute, self).__init__()
+        self._creator = creator
+        self._args = args
+        self._kwargs = kwargs
+
+    def __call__(self, owner):
+        return self._creator(owner, *self._args, **self._kwargs)
+
+class AttributeClass(PythonEgg):
+    def __init__(self, owner):
+        self.owner = owner
+        super(AttributeClass, self).__init__()

data/svc/map.py

@@ -0,0 +1,123 @@
+# Copyright (C) 2008 Jan Svec and Filip Jurcicek
+# 
+# YOU USE THIS TOOL ON YOUR OWN RISK!
+# 
+# email: info@gmail-backup.com
+# 
+# 
+# Disclaimer of Warranty
+# ----------------------
+# 
+# Unless required by applicable law or agreed to in writing, licensor provides
+# this tool (and each contributor provides its contributions) on an "AS IS"
+# BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied, including, without limitation, any warranties or conditions of
+# TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
+# PURPOSE. You are solely responsible for determining the appropriateness of
+# using this work and assume any risks associated with your exercise of
+# permissions under this license. 
+
+import codecs
+from svc.egg import PythonEgg
+
+class HalfMap(PythonEgg, dict):
+    def __init__(self, *args, **kwargs):
+        super(HalfMap, self).__init__(*args, **kwargs)
+        self.setindex(0)
+
+    def newindex(self):
+        v = set(self.itervalues())
+        while self._index in v:
+            self._index += 1
+        return self._index
+
+    def setindex(self, value):
+        self._index = value
+
+    def add(self, key):
+        if key not in self:
+            value = self.newindex()
+            self[key] = value
+            return value
+        else:
+            return self[key]
+
+    @classmethod
+    def readFromFile(cls, fn, encoding='utf-8', format=(unicode, int)):
+        fr = codecs.open(fn, 'r', encoding)
+        try:
+            ret = cls()
+            for line in fr:
+                split = line.split()
+                if len(split) == 0:
+                    continue
+                elif len(split) != 2:
+                    raise ValueError("Bad line in file %r: %r" % (fn, line))
+                key, value = split
+                key = format[0](key)
+                value = format[1](value)
+                ret[key] = value
+            return ret
+        finally:
+            fr.close()
+
+    def writeToFile(self, fn, encoding='utf-8'):
+        fw = codecs.open(fn, 'w', encoding)
+        try:
+            for k, v in sorted(self.items()):
+                fw.write('%s\t%s\n' % (k, v))
+        finally:
+            fw.close()
+
+_unique_value = ['unique_value']
+
+class SymMap(HalfMap):
+    def __init__(self, source=None, _inv=None):
+        super(SymMap, self).__init__()
+        if _inv is None:
+            self.inverse = self.__class__(_inv=self)
+        else:
+            self.inverse = _inv
+        if source is not None:
+            i = 0
+            for key, value in dict(source).iteritems():
+                self[key] = value
+                i += 1
+            self.setindex(i)
+
+    def clear(self, _inv=False):
+        super(SymMap, self).clear()
+        if not _inv:
+            self.inverse.clear(_inv=True)
+
+    def pop(self, *args):
+        ret = super(SymMap, self).pop(*args)
+        self.inverse.__delitem__(ret, _inv=True)
+        return ret
+
+    def popitem(self):
+        key, value = super(SymMap, self).popitem()
+        self.inverse.__delitem__(value, _inv=True)
+        return key, value
+
+    def setdefault(self, key, value=None):
+        raise NotImplementedError("Method SymMap.setdefault() is not implemented")
+
+    def __setitem__(self, key, value, _inv=False):
+        # FIXME:
+        #   x = SymMap([(1, 2), (2, 3), (3, 4), (4, 1)])
+        #   x[1] = 3
+        #   x == {1: 3, 3: 4, 4: 1}    ## Missing key 2
+        if key in self:
+            old_value = self[key]
+            self.inverse.__delitem__(old_value, _inv=True)
+        super(SymMap, self).__setitem__(key, value)
+        if not _inv:
+            self.inverse.__setitem__(value, key, _inv=True)
+
+    def __delitem__(self, key, _inv=False):
+        value = self[key]
+        super(SymMap, self).__delitem__(key)
+        if not _inv:
+            self.inverse.__delitem__(value, _inv=True)
+

data/svc/osutils.py

@@ -0,0 +1,67 @@
+# Copyright (C) 2008 Jan Svec and Filip Jurcicek
+# 
+# YOU USE THIS TOOL ON YOUR OWN RISK!
+# 
+# email: info@gmail-backup.com
+# 
+# 
+# Disclaimer of Warranty
+# ----------------------
+# 
+# Unless required by applicable law or agreed to in writing, licensor provides
+# this tool (and each contributor provides its contributions) on an "AS IS"
+# BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied, including, without limitation, any warranties or conditions of
+# TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
+# PURPOSE. You are solely responsible for determining the appropriateness of
+# using this work and assume any risks associated with your exercise of
+# permissions under this license. 
+
+import os
+
+def fsplit(path):
+    """Recursive call of `os.path.split`
+
+    It splits `path` by recursive calling of `os.path.split` and returns lists
+    of path elements.
+
+    :RType: list
+    """
+    ret = []
+    while path not in ['', '/']:
+        path, last = os.path.split(path)
+        ret.insert(0, last)
+    if path:
+        ret.insert(0, path)
+    return ret
+
+def fjoin(path):
+    """Recursive call of `os.path.join`
+
+    It joins path elements given by list `path` into single string using
+    `os.path.join`.
+
+    :RType: str
+    """
+    ret = path[0]
+    for i in range(1, len(path)):
+        ret = os.path.join(ret, path[i])
+    return ret
+
+def mkdirp(path):
+    """Make directory `path` possibly creating its parents
+
+    If some of parent paths exists, nothing will happen. But if this path is
+    not a directory, OSError will be raised.
+    """
+    path = fsplit(path)
+    full = ''
+    for elm in path:
+        full = os.path.join(full, elm)
+        if os.path.exists(full):
+            if not os.path.isdir(full):
+                raise OSError("Path %r is not directory" % full)
+        else:
+            os.mkdir(full)
+
+

data/svc/registry.py

@@ -0,0 +1,171 @@
+# Copyright (C) 2008 Jan Svec and Filip Jurcicek
+# 
+# YOU USE THIS TOOL ON YOUR OWN RISK!
+# 
+# email: info@gmail-backup.com
+# 
+# 
+# Disclaimer of Warranty
+# ----------------------
+# 
+# Unless required by applicable law or agreed to in writing, licensor provides
+# this tool (and each contributor provides its contributions) on an "AS IS"
+# BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied, including, without limitation, any warranties or conditions of
+# TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
+# PURPOSE. You are solely responsible for determining the appropriateness of
+# using this work and assume any risks associated with your exercise of
+# permissions under this license. 
+
+class AbstractRegistry(object):
+	def __init__(self):
+		super(AbstractRegistry, self).__init__()
+		self._children = set()
+		self._setParent(None)
+		self.setName(None)
+	
+	def getPath(self):
+		ret = [self]
+		while True:
+			parent = ret[0].getParent()
+			if parent is None:
+				break
+			else:
+				ret.insert(0, parent)
+		return ret
+	
+	def getParent(self):
+		return self.__dict__['_parent']
+
+	def _setParent(self, parent):
+		self.__dict__['_parent'] = parent
+	
+	def getName(self):
+		return self._name
+
+	def setName(self, name):
+		parent = self.getParent()
+		if parent is not None:
+			raise ValueError("setName() requires that parent == None")
+		self._name = name
+	
+	def getFullName(self):
+		def mapper(obj):
+			name = obj.getName()
+			if name is None: return '<anon>'
+			else:            return name
+		return '.'.join(mapper(obj) for obj in self.getPath())
+	
+	def addChild(self, child):
+		my_path = self.getPath()
+		if child in my_path:
+			raise ValueError("You cannot create cycles, child %r is parent of %r" % (child, self))
+		old_parent = child.getParent()
+		if old_parent is not None:
+			old_parent.delChild(child)
+		child._setParent(self)
+		self._children.add(child)
+	
+	def delChild(self, child):
+		child._setParent(None)
+		self._children.remove(child)
+	
+	def getChildren(self):
+		return self._children
+	
+	def __setattr__(self, name, obj):
+		if hasattr(obj, '_setParent'):
+			if hasattr(obj, 'setName'):
+				obj.setName(name)
+			self.addChild(obj)
+		self.__dict__[name] = obj
+	
+	def __delattr__(self, name):
+		obj = getattr(self, name)
+		if obj in self.getChildren():
+			self.delChild(obj)
+			if hasattr(obj, 'setName'):
+				obj.setName(None)
+		del self.__dict__[name]
+
+	def _createMethod(self, name, pre_func=None, post_func=None):
+		def method(*args, **kwargs):
+			objects = iter(self)
+			if pre_func is not None:
+				objects = pre_func(objects)
+			retvals = (obj(*args, **kwargs) for obj in objects)
+			if post_func is not None:
+				return post_func(retvals)
+			else:
+				return list(retvals)
+		method.__name__ = name
+		setattr(self, name, method)
+	
+	def createSequent(self, name, reduce=None, obs_name=None):
+		if obs_name is None:
+			obs_name = name
+		def pre_func(objects):
+			return (getattr(o, obs_name) for o in objects)
+		self._createMethod(name, pre_func=pre_func, post_func=reduce)
+	
+	def createDirectSequent(self, name, reduce=None):
+		self._createMethod(name, post_func=reduce)
+	
+	def createQuery(self, name, obs_name=None):
+		if obs_name is None:
+			obs_name = name
+		def pre_func(objects):
+			return (getattr(o, obs_name) for o in objects)
+		def post_func(retvals):
+			for o in retvals:
+				if o is not None:
+					return o
+		self._createMethod(name, pre_func=pre_func, post_func=post_func)
+
+	def createDirectQuery(self, name):
+		def post_func(retvals):
+			for o in retvals:
+				if o is not None:
+					return o
+		self._createMethod(name, post_func=post_func)
+
+	def createChain(self, name, obs_name=None):
+		if obs_name is None:
+			obs_name = name
+		def method(args):
+			for o in self:
+				func = getattr(o, obs_name)
+				args = func(args)
+			return args
+		method.__name__ = name
+		setattr(self, name, method)
+			
+	def createDirectChain(self, name):
+		def method(args):
+			for o in self:
+				args = o(args)
+			return args
+		method.__name__ = name
+		setattr(self, name, method)
+
+	
+class Registry(AbstractRegistry, list):
+	def __repr__(self):
+		return "<registry %s: [%s]>" % (self.getFullName(), ', '.join(repr(obj) for obj in self))
+
+	def __eq__(self, other):
+		if isinstance(other, Registry):
+			return self is other
+		else:
+			return super(Registry, self).__eq__(other)
+
+	def __hash__(self):
+		return id(self)
+
+
+def register(registry):
+	def decorator(func):
+		registry.append(func)
+		return func
+	return decorator
+