def __init__(self, addressbook_name, addressbook_path, filename=""):
     self.addressbook_name = addressbook_name
     if filename == "":
         # create new vcard
         self.vcard = vobject.vCard()
         choice = string.ascii_uppercase + string.digits
         uid_obj = self.vcard.add('uid')
         uid_obj.value = ''.join([random.choice(choice) for _ in range(36)])
         self.vcard_full_filename = os.path.join(addressbook_path,
                 self.vcard.uid.value + ".vcf")
     else:
         # create vcard from file
         self.vcard_full_filename = filename
         # open .vcf file
         try:
             file = open(filename, "r")
             contents = file.read()
             file.close()
         except IOError as e:
             raise CarddavObject.VCardParseError(e)
         # create vcard object
         try:
             self.vcard = vobject.readOne(contents)
         except vobject.base.ParseError as e:
             # if creation fails, try to repair vcard contents
             try:
                 self.vcard = vobject.readOne(
                         self.filter_invalid_tags(contents))
                 self.write_to_file(overwrite=True)
             except vobject.base.ParseError as e:
                 raise CarddavObject.VCardParseError(e)

    def put(cls, uri, data, content_type, cache=None):
        import vobject
        Party = Pool().get('party.party')

        party_id = cls.vcard(uri)
        if party_id is None:
            vcard = vobject.readOne(data)
            values = Party().vcard2values(vcard)
            try:
                party_id, = Party.create([values])
            except Exception:
                raise DAV_Forbidden
            party = Party(party_id)
            return (Transaction().cursor.database_name + '/Contacts/' +
                    party.uuid + '.vcf')
        if party_id:
            party = Party(party_id)
            vcard = vobject.readOne(data)
            values = party.vcard2values(vcard)
            try:
                Party.write([party], values)
            except Exception:
                raise DAV_Forbidden
            return
        return super(Collection, cls).put(uri, data, content_type,
            cache=cache)

def ical2text(ical_string):
    import vobject
    result = []
    if isinstance(ical_string, unicode):
        parsedCal = vobject.readOne(ical_string)
    else:
        try:
            parsedCal = vobject.readOne(ical_string)
        except:
            parsedCal = vobject.readOne(ical_string.decode('utf-8', 'ignore'))

    for event in parsedCal.getChildren():
        if event.name == 'VEVENT':
            if hasattr(event, 'dtstart'):
                start = event.dtstart.value.strftime('%F %H:%M')
            else:
                start = 'unknown start date'

            if hasattr(event, 'dtend'):
                end = event.dtend.value.strftime('%F %H:%M')
            else:
                end = start

            if start == end:
                date_str = start
            else:
                date_str = '%s -- %s' % (start, end)

            result.append('%s: %s' % (date_str, event.summary.value))

    return '\n'.join(result)

    def __init__(self, address_book, filename = None):
        self.vcard = None
        self.address_book = address_book
        self.filename = filename

        if self.filename is None:
            # create new vcard object
            self.vcard = vobject.vCard()
            # uid
            choice = string.ascii_uppercase + string.digits
            uid_obj = self.vcard.add('uid')
            uid_obj.value = ''.join([random.choice(choice) for _ in range(36)])
            # use uid for vcard filename
            self.filename = os.path.join(address_book.get_path(),
                    self.vcard.uid.value + ".vcf")

        else:
            # create vcard from .vcf file
            try:
                file = open(self.filename, "r")
                contents = file.read()
                file.close()
            except IOError as e:
                raise
            # create vcard object
            try:
                self.vcard = vobject.readOne(contents)
            except vobject.base.ParseError as e:
                # if creation fails, try to repair vcard contents
                try:
                    self.vcard = vobject.readOne(
                            self.filter_invalid_tags(contents))
                    self.write_to_file(overwrite=True)
                except vobject.base.ParseError as e:
                    raise

	def testMatches(self):
		strErik = """BEGIN:VCARD
VERSION:3.0
FN:null
N:;;;;
EMAIL;TYPE=INTERNET:[email protected]
END:VCARD
"""
		erikcard=vCardWithMatches(parsevCard(vobject.readOne(StringIO.StringIO(strErik))))
		strErik2 = """BEGIN:VCARD
VERSION:3.0
FN:Lars Erik Gewalli
N:Gewalli hotml;Lars;Erik;;
EMAIL;TYPE=INTERNET:[email protected]
NOTE:Phone\\:\\nUser 2\\: [email protected]\\n
END:VCARD
"""
		erikcard2=vCardWithMatches(parsevCard(vobject.readOne(StringIO.StringIO(strErik2))))
		self.assertFalse(erikcard2.matches(erikcard))
		strErik3="""BEGIN:VCARD
VERSION:3.0
FN:Erik M
N:Erik;M;;;
END:VCARD"""
		erikcard3=vCardWithMatches(parsevCard(vobject.readOne(StringIO.StringIO(strErik3))))
		#higher similarity is better
		self.assertFalse(erikcard3.matches(erikcard))

		pass

    def __init__(self, address_book, filename = None):
        self.vcard = None
        self.address_book = address_book
        self.filename = filename
        self.old_vobject_version = False

        # at the moment khard must support two different behavior of the vobject module
        # the versions < 0.8.2 are still widely in use and expect unicode strings for non-ascii characters
        # all newer versions use utf-8 encoded strings directly
        # so we must determine, which version is installed
        try:
            # try to compare the version numbers
            if parse_version(get_distribution("vobject").version) < parse_version("0.8.2"):
                self.old_vobject_version = True
        except Exception as e:
            # if something goes wrong during vobject version comparison, try to serialize a
            # minimal vcard object with umlauts
            # if that fails, khard still uses a vobject version < 0.8.2
            v = vobject.vCard()
            o = v.add("fn")
            o.value = "Markus Schröder"
            o = v.add("n")
            o.value = vobject.vcard.Name(family="Schröder", given="Markus")
            try:
                v.serialize()
            except UnicodeDecodeError as e:
                self.old_vobject_version = True

        # load vcard
        if self.filename is None:
            # create new vcard object
            self.vcard = vobject.vCard()
            # uid
            choice = string.ascii_uppercase + string.digits
            uid_obj = self.vcard.add('uid')
            uid_obj.value = ''.join([random.choice(choice) for _ in range(36)])
            # use uid for vcard filename
            self.filename = os.path.join(address_book.get_path(),
                    self.vcard.uid.value + ".vcf")

        else:
            # create vcard from .vcf file
            try:
                file = open(self.filename, "r")
                contents = file.read()
                file.close()
            except IOError as e:
                raise
            # create vcard object
            try:
                self.vcard = vobject.readOne(contents)
            except vobject.base.ParseError as e:
                # if creation fails, try to repair vcard contents
                try:
                    self.vcard = vobject.readOne(
                            self.filter_invalid_tags(contents))
                    self.write_to_file(overwrite=True)
                except vobject.base.ParseError as e:
                    raise

def openics(invitation_file):
    with open(invitation_file) as f:
        try:
            with warnings.catch_warnings(): #vobject uses deprecated Exception stuff
                warnings.simplefilter("ignore")
                invitation = vobject.readOne(f, ignoreUnreadable=True)
        except AttributeError:
            invitation = vobject.readOne(f, ignoreUnreadable=True)
	return invitation

def get_invitation_from_path(path):
    with open(path) as f:
        try:
            # vobject uses deprecated Exceptions
            with warnings.catch_warnings():
                warnings.simplefilter("ignore")
                return vobject.readOne(f, ignoreUnreadable=True)
        except AttributeError:
            return vobject.readOne(f, ignoreUnreadable=True)

def merge(filenames, timezone_file):
    combined_calendar = vobject.iCalendar()

    with codecs.open(timezone_file, encoding='utf-8') as f:
        merge_timezones(combined_calendar, vobject.readOne(f))

    for filename in filenames:
        with codecs.open(filename, 'r', encoding='utf-8') as f:
            merge_events(combined_calendar, vobject.readOne(f))

    return combined_calendar.serialize()

 def setUp(self):
     vcard_data = dict(
         nickname=u'x',
         mobile=u'3333308',
         name=u'NAME SURNAME',
         firstname=u'NAME',
         surname=u'SURNAME',
         email=u'[email protected]')
     self.vcard_data = namedtuple('Contact', vcard_data.keys())(
         **vcard_data)
     self.contact = Contact(alias=self.vcard_data.nickname,
                            mobile=self.vcard_data.mobile,
                            name=self.vcard_data.name)
     vcard_str = """
     BEGIN:VCARD
     VERSION:3.0
     FN:{name}
     N:{surname};{firstname};;;
     NICKNAME:{nickname}
     EMAIL;TYPE=INTERNET:{email}
     TEL;TYPE=CELL:{mobile}
     END:VCARD
     """.format(
         name=self.vcard_data.name,
         firstname=self.vcard_data.firstname,
         surname=self.vcard_data.surname,
         nickname=self.vcard_data.nickname,
         email=self.vcard_data.email,
         mobile=self.vcard_data.mobile)
     self.vcard_str = textwrap.dedent(vcard_str)
     self.vcard = vobject.readOne(self.vcard_str)

	def Sync(self):

		flag = raw_input("Enter '0' to exit program or any other key to continue: ")
		if flag == '0':
			exit()

		vcf_path = os.path.dirname(os.path.abspath(__file__))	
			
		vcf_list = glob.glob(vcf_path + "\*.vcf")
		count = 0

		for people in vcf_list:

			fp = open(people,"r")
			content = fp.read()
			fp.close()

			v = vobject.readOne(content)

			name=v.n.value
			number=v.tel.value

			new_contact = gdata.contacts.data.ContactEntry()
			new_contact.name = gdata.data.Name(full_name=gdata.data.FullName(text=name))
			new_contact.phone_number.append(gdata.data.PhoneNumber(text=number,rel=gdata.data.WORK_REL,primary='true'))

			contact_entry = self.gd_client.CreateContact(new_contact)
			print "Contact's ID: ", contact_entry.id.text
			name =""
			number = ""
			count = count + 1
			print "\nUploaded Contacts: " + str(count)
			time.sleep(1)

    def render_PUT(self, request):
        result = WebdavResource.render_PUT(self, request)
        if result is not None and result.has_key(request.path) and \
        request.env['CONTENT_TYPE'].strip().find('text/calendar') == 0:
            user=request.env.get('user')
            stream = self.storageProvider.get(request.path, user=user)
            try:
                event = vobject.readOne(stream)
                self.calendarProvider.store(request.path, event, user=user)

                # generate the etag data and add it to the document.
                stream.seek(0)
                md5Sum = getMD5(stream)
                md5Sum.update(request.path)
                etag = md5Sum.hexdigest()

                request.setHeader("ETag", "%s" % etag)

                self.storageProvider.setMeta(request.path,
                                        {'{DAV:}getetag': "%s" % etag,
                                         '{DAV:}getcontenttype': 'text/calendar'
                                        },
                                        user=user
                                 )
            except Exception as ex:
                logging.getLogger().warn('Not a calendar object. Got error: %s' % ex)
            finally:
                stream.close()
        return result

 def parse_vcf(self,response):
      v=vobject.readOne(response.body)
      print v
      item=response.meta['item']
      item['first_name']=v.n.value.given.strip()
      item['second_name']=v.n.value.family.strip()
      yield item

    def _clean_private(cls, record, transp):
        '''
        Clean private record
        '''
        summary = cls.raise_user_error(transp, raise_exception=False)
        if 'summary' in record:
            record['summary'] = summary

        vevent = None
        if 'vevent' in record:
            vevent = record['vevent']
            if vevent:
                vevent = vobject.readOne(str(vevent))
                if hasattr(vevent, 'summary'):
                    vevent.summary.value = summary

        for field, value in (
                ('description', ''),
                ('categories', []),
                ('location', None),
                ('status', ''),
                ('organizer', ''),
                ('attendees', []),
                ('alarms', [])):
            if field in record:
                record[field] = value
            if field + '.rec_name' in record:
                record[field + '.rec_name'] = ''
            if vevent:
                if hasattr(vevent, field):
                    delattr(vevent, field)
        if vevent:
            record['vevent'] = vevent.serialize()

	def getWakeUpTimes(self):
		retrive_iCal.retrive()
		self.lastRetrived = datetime.datetime.now()
		if os.path.exists("calender.ical") and \
		   self.lastParsed == os.path.getmtime("calender.ical"):
			return
		else:
			self.lastParsed = os.path.getmtime("calender.ical")

		self.wakeUpTimes = []
		iCalFile = open("calender.ical")
		parsedCal = vobject.readOne(iCalFile)
		for event in parsedCal.vevent_list:
			try:
				event.categories.value
			except:
				continue

			if event.categories.value == [u'WakeUp']:
				tz = event.dtstart.value.tzinfo
				start = event.dtstart.value.utctimetuple()
				end = event.dtend.value.utctimetuple()
				diff = event.dtend.value - event.dtstart.value
				now = datetime.datetime.utcnow().utctimetuple()
				#Reacuring event
				if event.rruleset:
					for date in event.rruleset:
						start = date.utctimetuple()
						end = date + diff
						end = end.utctimetuple()
						if end > now:
							break #alarm found
				#only append if alarm havent allready gone off
				if end > now:
					self.wakeUpTimes.append([start, end])

    def __init__(self, text, name=None):
        """Initialize object from ``text`` and different ``kwargs``."""
        self.component = vobject.readOne(text)
        self._name = name

        if not self.component.name:
            # Header
            self._name = next(self.component.lines()).name.lower()
            return

        # We must synchronize the name in the text and in the object.
        # An item must have a name, determined in order by:
        #
        # - the ``name`` parameter
        # - the ``X-RADICALE-NAME`` iCal property (for Events, Todos, Journals)
        # - the ``UID`` iCal property (for Events, Todos, Journals)
        # - the ``TZID`` iCal property (for Timezones)
        if not self._name:
            for line in self.component.lines():
                if line.name in ("X-RADICALE-NAME", "UID", "TZID"):
                    self._name = line.value
                    if line.name == "X-RADICALE-NAME":
                        break

        if self._name:
            # Leading and ending brackets that may have been put by Outlook.
            # Slashes are mostly unwanted when saving collections on disk.
            self._name = self._name.strip("{}").replace("/", "_")
        else:
            self._name = uuid4().hex

        if not hasattr(self.component, "x_radicale_name"):
            self.component.add("X-RADICALE-NAME")
        self.component.x_radicale_name.value = self._name

 def vcard_added(self, href, etag, vcard):
   self.max_key += 1
   vcard = vobject.readOne(vcard)
   self.card_list_sql[self.max_key] = (href,etag,vcard,0)
   treeiter = self.model.append( (self.max_key, '', '', '', 400, '') )
   self.key_from_href[href] = (self.max_key, treeiter)
   self.update_treeview_values(vcard, treeiter)

	def import_vcard(vin):
		"""Convert a _single_ vcard (text) to a mfdict. 

		Parameters:
		in - a string or a file object
		"""

		vcard = vobject.readOne(vin)
		mfd = uf_mfdict.mfdict()

		for child in vcard.getChildren():
			if type(child.value) not in types.StringTypes:
				child.value = unicode(child.value)

			if child.name == "N":
				d = dict(zip(vobject.vcard.NAME_ORDER, vobject.vcard.splitFields(child.value)))
			elif child.name == "ADR":
				d = dict(zip(vobject.vcard.ADDRESS_ORDER, vobject.vcard.splitFields(child.value)))
			else:
				d = { "" : child.value }

			ctype = child.params.get("TYPE", [])

			for key, value in d.iteritems():
				keys = filter(lambda s: s, [ child.name.lower(), key, ] + ctype)

				if type(value) == types.ListType:
					value = " ".join(value)

				value = clean_space(value)

				mfd.add(keys, value)

		return	mfd

def update_document(data):
	remote = urllib2.urlopen(config.get(CONFIG_KEY, 'url'), timeout=config.getint(CONFIG_KEY, 'timeout'))

	current_date = datetime.datetime.now()

	if not data.get('events'):
		data['events'] = []

	components = vobject.readOne(remote)

	for event in components.contents['vevent']:
		# could be datetime or just date
		e_date = event.dtstart.value

		if type(e_date) is datetime.date:
			e_date = datetime.datetime.combine(e_date, datetime.time(0, 0))
		else:
			e_date = e_date.replace(tzinfo=None)

		# compare with timezone data removed
		if e_date < current_date:
			continue

		data['events'].append({
			'name': event.summary.value,
			'type': 'calendarevent',
			'timestamp': int(time.mktime((event.dtstart.value.timetuple()))),
			'extra': event.description.value,
		})

	return data

    def fProcess_ics(self, file):
        """ Read an ics (ical) file and append it to the reminders file. """
        try:
            src = open(self.get_inputdir() + '/' + file)
            dst = open(self.get_outputfile(),"a")
            try:
                tzinput = timezone('Etc/UTC') # ics files from http://www.mysportscal.com
                datefmt = '%b %d %Y'
                timefmt = '%H:%M'
                remfmt = 'REM %s AT %s +30 DURATION %s MSG %s'

                cal = vobject.readOne(src)

                for event in cal.vevent_list:
                    text = event.summary.value

                    dtstart = event.dtstart.value.astimezone(tzinput).astimezone(self.get_tzlocal())
                    dtend = event.dtend.value.astimezone(tzinput).astimezone(self.get_tzlocal())
                    duration = str(dtend - dtstart)[:-3]

                    now = self.get_tzlocal().localize(datetime.now())
                    #if dtstart >= now:
                    print >>dst, remfmt % (
                        dtstart.strftime(datefmt),
                        dtstart.strftime(timefmt),
                        duration, text
                    )
            finally:
                src.close()
        except IOError as (errno, strerror):
            print "Error {0}: {1} input:{2} output:{3}.".format(errno, strerror, self.get_inputdir() + '/' + file, self.get_outputfile())