Exemplo n.º 1
0
def get_post():
    registerDateHandler(parse_date)
    feed = parse("http://rus.vrw.ru/feed")
    if feed.status != 200:
        error(u'Error. HTTP is not 200. Quit.')
        quit()
    else:
        return feed
Exemplo n.º 2
0
def get_update_time_from_feed(feed_url):
    feedparser.registerDateHandler(myDateHandler)
    feed = feedparser.parse(feed_url)

    update_time = ''
    if len(feed.entries) > 0:
        one = feed.entries[0]
        if 'published_parsed' in one:
            update_time = time_as_string(feed.entries[0].published_parsed)
        elif 'updated_parsed' in one:
            update_time = time_as_string(feed.entries[0].updated_parsed)
    return update_time
Exemplo n.º 3
0
def get_update_time_from_feed(feed_url):
    feedparser.registerDateHandler(myDateHandler)
    feed = feedparser.parse(feed_url)

    update_time = ''
    if len(feed.entries) > 0:
        one = feed.entries[0]
        if 'published_parsed' in one:
            update_time = time_as_string(feed.entries[0].published_parsed)
        elif 'updated_parsed' in one:
            update_time = time_as_string(feed.entries[0].updated_parsed)
    return update_time
Exemplo n.º 4
0
 def testDate(self):
     def t(dateString):
         t = feedparser._parse_date(dateString)
         return datetimefromparsed(t).isoformat() if t else None
         
         
     self.assertEqual(t("Wed, 17 Aug 2011 12:25:03 +0100"), "2011-08-17T12:25:03")
     self.assertEqual(t("Mon, 18 Apr 2011 17:30:18 GMT -05:00"), "2011-04-18T18:30:18")
     
     self.assertEqual(t("Friday: 1:29:2010: 17:30:18 GMT -05:00"), None)
     feedparser.registerDateHandler(parseTrueNewsDate)
     self.assertEqual(t("Friday: 1:29:2010: 17:30:18 GMT -05:00"), "2010-01-29T17:30:18")
     feedparser._date_handlers.remove(parseTrueNewsDate)
Exemplo n.º 5
0
 def parse_feed(self):
     new_feed = []
     if self.dateHandler:
         feedparser.registerDateHandler(self.dateHandler)
     feed = feedparser.parse(self.feed_url)
     for feedelement in feed.entries:
         for key in feedelement.keys():
             if "_parsed" in key:
                 continue
             if isinstance(feedelement[key], list):
                 if key == "content":
                     feedelement[key] = feedelement[key][0].value
             feedelement[key] = str(feedelement[key])
             feedelement[key] = self.TAG_RE.sub('', feedelement[key])
             feedelement[key] = self.hp.unescape(feedelement[key])
         new_feed.append(feedelement)
     self.deduplicateAndProcess(new_feed)
Exemplo n.º 6
0
import feedparser
def sepTimezone(dateString):
  if dateString[-3] == ':':
    return dateString[:-6], dateString[-6:-3], dateString[-2:]
  else:
    return dateString[:-5], dateString[-5:-2], dateString[-2:]

# http://stackoverflow.com/questions/526406/python-time-to-age-part-2-timezones
def getFuckingPythonToParseNumericTimezones(dateString, format):
  from datetime import timedelta, datetime
  dateString = dateString.strip()
  t, zh, zm = sepTimezone(dateString)
  return datetime.timetuple(datetime.strptime(t, format)
                        + timedelta(hours=int(zh), minutes=int(zm)))

# handle http://www.aaronsw.com/weblog/index.xml
def sillyFormat1(dateString):
  try: return getFuckingPythonToParseNumericTimezones(dateString, "%B %d, %Y")
  except KeyboardInterrupt: raise
  except: traceback.print_exc(file=sys.stdout)
feedparser.registerDateHandler(sillyFormat1)
Exemplo n.º 7
0
_afpy_dates = [
    re.compile(r'(\d{4})/(\d{2})/(\d{2}) (\d{,2}):(\d{2}):(\d{2})'),
    re.compile(r'(\d{4})-(\d{2})-(\d{2}) (\d{,2}):(\d{2}):(\d{2})'),
]


def afpy_date(dt):
    """parse a UTC date in MM/DD/YYYY HH:MM:SS format"""
    g = None
    for afpy_date in _afpy_dates:
        try:
            g = afpy_date.search(dt).groups()
        except:
            pass
    if g:
        return tuple([int(i) for i in g] + [0, 0, 0])
feedparser.registerDateHandler(afpy_date)


def feed_dispatcher(bot):
    send_tweet = bot.get_plugin(AfpySocial).send_alain_tweet
    call_later = bot.loop.call_later

    def dispatcher(messages):
        for i, (c, m) in enumerate(messages):
            if u'afpy' in m.lower():
                bot.log.info('Sending %r', m)
                # call_later(i + 1, bot.privmsg, c, m)
                call_later(i + 1, send_tweet, m)
    return dispatcher
Exemplo n.º 8
0
import datetime
import re
from urllib import quote, urlencode

from google.appengine.ext import db
from google.appengine.api import memcache
from google.appengine.api import users
from google.appengine.api import urlfetch

from django.utils.html import strip_tags
from django.utils import simplejson
import feedparser

debug = 0

feedparser.registerDateHandler(lambda s:time.strptime(s[:-6], "%a , %d %b %Y %H:%M:%S"))

_query_cache = {}

def gql(cls, clause, *args, **kwds):
    try:
        query_string = 'SELECT * FROM %s %s' % (cls.kind(), clause)
    except AttributeError:
        query_string = 'SELECT * FROM %s %s' % (cls, clause)
    query = _query_cache.get(query_string)
    if query is None:
        logging.info("query_cache: %s -> MISS" % query_string)
        _query_cache[query_string] = query = db.GqlQuery(query_string)
    else:
        logging.info("query_cache: %s  -> HIT" % query_string)
    query.bind(*args, **kwds)
Exemplo n.º 9
0
        "November": 11,
        "December": 12
    }
    # Parse a date sucn as "Sunday, November 25, 2012 - 12:00"
    try:
        # feedparser is supposed to catch the exception on its own,
        # but it doesn't
        month, day, year, hour, minute = _feedburner_date_pattern.search(
            aDateString).groups()
        return (int(year), int(months[month]), int(day), int(hour),
                int(minute), 0, 0, 0, 0)
    except AttributeError:
        return None


feedparser.registerDateHandler(FeedburnerDateHandler)

# The following are some auxiliary functions


def sanitize(data):
    # sanestring = ''.join([x if x.isalnum() else "_" for x in string])
    sanestring = ''.join(x if x.isalnum() else "_"
                         for x in unicodedata.normalize('NFKD', data)
                         if x in string.printable)
    return sanestring


def ensure_dir(dirname):
    try:
        os.makedirs(dirname)
Exemplo n.º 10
0
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""

from pyramid.config import Configurator
from pyramid_zodbconn import get_connection

from .models import appmaker
from .views import listen, publish, subscribe

# for some reason feedparser put this at the end and one of the
# other parsers catches our dates and doesn't consider DST
import feedparser
# re-registering this should put it at the front
feedparser.registerDateHandler(feedparser._parse_date_iso8601)


def root_factory(request):
    conn = get_connection(request)
    return appmaker(conn.root())


def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    config = Configurator(root_factory=root_factory, settings=settings)

    config.add_static_view('static', 'static', cache_max_age=3600)

    config.add_route('publish', '/publish')
Exemplo n.º 11
0
import time
from urllib2 import URLError
from dated import utc_from_string

import feedparser
from procol.console import print_err, print_err_trace

from .result import FeedUnchanged, RssErrorResult, RssResult


def _to_utc(datetime_string):
    utc = utc_from_string(datetime_string)
    return utc.timetuple()


feedparser.registerDateHandler(_to_utc)


def parse_feed_result(feed_url, etag=None):
    while True:
        try:
            return _parse_feed_result(feed_url, etag)
        except URLError, e:
            print_err(str(e))
            time.sleep(10)
        except ssl.CertificateError:
            raise
        except BaseException, e:
            print_err_trace('Exception: %s : %s' % (type(e), e))
            time.sleep(60)
Exemplo n.º 12
0
class InactiveFeedError(FeedError):
    pass


class EntryError(Exception):
    """
    An error occurred when processing an entry
    """
    pass


def no_timezone_beijing_date_handler(aDateString):
    return feedparser._parse_date_rfc822(aDateString + " +0800")


feedparser.registerDateHandler(no_timezone_beijing_date_handler)

###############################################################################
#                                                               Feed model

class Feed(models.Model):
    """
    A feed definition
    
    The last_updated field is either the updated or published date of the feed,
    or if neither are set, the feed parser's best guess.
    
    Currently ignoring the following feedparser attributes:
        author
        author_detail
        cloud
Exemplo n.º 13
0
Arquivo: greg.py Projeto: TMily/greg
    months = {"January": 1, "February": 2, "March": 3, "April": 4, "May": 5,
              "June": 6, "July": 7, "August": 8, "September": 9, "October": 10,
              "November": 11, "December": 12}
    # Parse a date sucn as "Sunday, November 25, 2012 - 12:00"
    try:
        # feedparser is supposed to catch the exception on its own,
        # but it doesn't
        month, day, year, hour, minute = _feedburner_date_pattern.search(
            aDateString).groups()
        return (
            int(year), int(months[month]), int(
                day), int(hour), int(minute), 0, 0, 0, 0)
    except AttributeError:
        return None

feedparser.registerDateHandler(FeedburnerDateHandler)

# The following are some auxiliary functions


def sanitize(data):
    # sanestring = ''.join([x if x.isalnum() else "_" for x in string])
    sanestring = ''.join(x if x.isalnum() else "_" for x in
                         unicodedata.normalize('NFKD', data)
                         if x in string.printable)
    return sanestring


def ensure_dir(dirname):
    try:
        os.makedirs(dirname)
Exemplo n.º 14
0
    months = {"January": 1, "February": 2, "March": 3, "April": 4, "May": 5,
              "June": 6, "July": 7, "August": 8, "September": 9, "October": 10,
              "November": 11, "December": 12}
    # Parse a date sucn as "Sunday, November 25, 2012 - 12:00"
    try:
        # feedparser is supposed to catch the exception on its own,
        # but it doesn't
        month, day, year, hour, minute = _feedburner_date_pattern.search(
            aDateString).groups()
        return (
            int(year), int(months[month]), int(
                day), int(hour), int(minute), 0, 0, 0, 0)
    except AttributeError:
        return None

feedparser.registerDateHandler(feedburner_date_handler)

# The following are some auxiliary functions


def sanitize(data):
    # sanestring = ''.join([x if x.isalnum() else "_" for x in string])
    sanestring = ''.join(x if x.isalnum() else "_" for x in
                         unicodedata.normalize('NFKD', data)
                         if x in string.printable)
    return sanestring


def ensure_dir(dirname):
    try:
        os.makedirs(dirname)
Exemplo n.º 15
0
#
#    Support functions
#
#    Patch feedparser to support time zone information in RFC2822 time stamps.
#
def RFC2822dateparser(aDateString):
    """parse a RFC2822 date, including time zone: 'Sun, 28 Feb 2010 11:57:48 -0500'"""
    dateinfo = email.utils.parsedate_tz(aDateString)    # parse date
    if dateinfo is None :                               # if none, fail
        return(None)                                    # next parser gets a chance
    utcstamp = email.utils.mktime_tz(dateinfo)          # convert to timestamp format
    utcdate = time.gmtime(utcstamp)                     # convert back to time tuple, but now in UT
    ####print("RFC2822dateparser: in: %s   dateinfo: %s  out: %s" % (repr(aDateString), repr(dateinfo), repr(utcdate))) ## ***TEMP***
    return(utcdate)                                     # feedparser wants UT time

feedparser.registerDateHandler(RFC2822dateparser)       # register above conversion with feedparser
#
kremovenonalpha = re.compile(r'\W')
#
def textsubset(s1, s2) :
    """
    True if s1 is a subset of s2, considering alphanumeric chars only
    """
    return(kremovenonalpha.sub("",s2).startswith(kremovenonalpha.sub("",s1)))
    
#
#    class Newsfeed  --  one news feed
#
class Newsfeed(feedmanager.Feed) :                            

    #    FeedParser's list of acceptable HTML elements.
Exemplo n.º 16
0
        except Exception:
            ex = sys.exc_info()
            error = traceback.format_exc()

    return render_to_response(
        "home.html",
        {
            "feed": feed,
            "feed_xml": prettyxml,
            "feed_link": feed_link,
            "feed_format": output_format,
            "first_url": url,
            "error": error,
        },
    )


def sanitize(request):
    (url, output_format, feed_class, feed_link, ids) = parse_request(request)

    if not url:
        raise "url not specified"
    feed = buildfeed(url, feed_class, feed_link, ids)

    response = HttpResponse(mimetype=feed.mime_type)
    feed.write(response, "utf-8")
    return response


feedparser.registerDateHandler(parseTrueNewsDate)
Exemplo n.º 17
0
            prettyxml = xml.dom.minidom.parseString(
                feedxml.getvalue()).toprettyxml()
        except Exception:
            ex = sys.exc_info()
            error = traceback.format_exc()

    return render_to_response(
        "home.html", {
            "feed": feed,
            "feed_xml": prettyxml,
            "feed_link": feed_link,
            "feed_format": output_format,
            "first_url": url,
            "error": error
        })


def sanitize(request):
    (url, output_format, feed_class, feed_link, ids) = parse_request(request)

    if not url:
        raise "url not specified"
    feed = buildfeed(url, feed_class, feed_link, ids)

    response = HttpResponse(mimetype=feed.mime_type)
    feed.write(response, 'utf-8')
    return response


feedparser.registerDateHandler(parseTrueNewsDate)
Exemplo n.º 18
0
import feedparser
import datetime
import re
date_regex = re.compile(
    "(?P<day>\d{2})/(?P<month>\d{2})/(?P<year>\d{4})\s(?P<hour>\d{2}):(?P<minutes>\d{2}):(?P<seconds>\d{2})"
)


def parse_ambiguous_date(datestring):
    """ Handle dates formatted as 10/04/2014 03:44:14
    If the first value is actually the month, the result will be incorrect.
    """
    result = date_regex.match(datestring)
    if result:
        try:
            d = result.groupdict()
            stamp = datetime.datetime(int(d["year"]), int(d["month"]),
                                      int(d["day"]), int(d["hour"]),
                                      int(d["minutes"]), int(d["seconds"]))
            result = stamp.utctimetuple()
        except (ValueError, TypeError) as e:
            pass
    return result


feedparser.registerDateHandler(parse_ambiguous_date)
Exemplo n.º 19
0
    months = {"January": 1, "February": 2, "March": 3, "April": 4, "May": 5,
              "June": 6, "July": 7, "August": 8, "September": 9, "October": 10,
              "November": 11, "December": 12}
    # Parse a date sucn as "Sunday, November 25, 2012 - 12:00"
    try:
        # feedparser is supposed to catch the exception on its own,
        # but it doesn't
        month, day, year, hour, minute = _feedburner_date_pattern.search(
            aDateString).groups()
        return (
            int(year), int(months[month]), int(
                day), int(hour), int(minute), 0, 0, 0, 0)
    except AttributeError:
        return None

feedparser.registerDateHandler(feedburner_date_handler)

# The following are some auxiliary functions


def sanitize(data):
    # sanestring = ''.join([x if x.isalnum() else "_" for x in string])
    sanestring = ''.join(x if x.isalnum() else "_" for x in
                         unicodedata.normalize('NFKD', data)
                         if x in string.printable)
    return sanestring


def ensure_dir(dirname):
    try:
        os.makedirs(dirname)
Exemplo n.º 20
0
import socket
socket.setdefaulttimeout(10.0)

g_db_file = ''

def dateutilDateHandler(date_string):
	'''
	It seems that feedparser can't correctly parse 
	'Fri, 11 Oct 2013 18:18:00 MSK' and 'Fri, 11 Oct 2013 16:34:00 MSK'
	We need to provide our own date handler
	'''
	return dateutil.parser.parse(date_string).utctimetuple()


feedparser.registerDateHandler(dateutilDateHandler)


class FeedMonitor:
	def __init__(self, db_file):
		self.freshItems = []
		self.dbConnection = sqlite3.connect(db_file, timeout=30)
		self.dbCursor = self.dbConnection.cursor()

	def check(self, url_list):
		map(self._check_url, url_list)

	@contextmanager
	def _url_status(self, url):
		try:
			with self.dbConnection:
Exemplo n.º 21
0
class InactiveFeedError(FeedError):
    pass


class EntryError(Exception):
    """
    An error occurred when processing an entry
    """
    pass


def no_timezone_beijing_date_handler(aDateString):
    return feedparser._parse_date_rfc822(aDateString + " +0800")


feedparser.registerDateHandler(no_timezone_beijing_date_handler)

###############################################################################
#                                                               Feed model

class Feed(models.Model):
    """
    A feed definition
    
    The last_updated field is either the updated or published date of the feed,
    or if neither are set, the feed parser's best guess.
    
    Currently ignoring the following feedparser attributes:
        author
        author_detail
        cloud
Exemplo n.º 22
0
from django.utils.http import urlencode
from .models import News, Stock

YAHOO_DATE = re.compile(r'([A-Za-z]{3}), (\d{,2}) ([A-Za-z]{3}) (\d{4}) (\d{,2}):(\d{2}):(\d{2}) Etc/GMT')

def yahoo_date_parser(date_string):
    '''They like inventing their own funky format, here it is:
    Mon, 21 Jun 2010 17:15:35 Etc/GMT
    '''
    dow, day, month, year, hour, minute, second = \
            YAHOO_DATE.search(date_string).groups()
    cleaned = "%d %s %d %d:%d:%d" % (int(day), month, int(year),
            int(hour), int(minute), int(second))
    t = time.strptime(cleaned, "%d %b %Y %H:%M:%S")
    return t
feedparser.registerDateHandler(yahoo_date_parser)


def validate_credentials(profile, save=True):
    df = DataFetcher(profile)
    try:
        if not profile.ibd_user or not profile.ibd_password:
            success = None
        else:
            try:
                success = df.ibd_login()
                if success:
                    stock = Stock(ticker='GOOG')
                    # if we don't get data back, we failed
                    if not df.ibd_retrieve_stock(stock):
                        success = False
Exemplo n.º 23
0
def ampmDateHandler(date_str):
    """parse a UTC date in MM/DD/YYYY HH:MM:SS PM format"""
    match = _ampm_date_pattern.search(date_str)
    if not match:
        return None

    month, day, year, hour, minute, second, ampm = match.groups()
    if ampm.upper() == 'PM':
        hour = int(hour) + 12
    return (
        int(year), int(month), int(day),
        int(hour), int(minute), int(second),
        0, 0, 0
    )
feedparser.registerDateHandler(ampmDateHandler)


def parsed_to_datetime(parsed):
    """converts a time 9-tuple to a naive UTC datetime object"""
    return datetime.utcfromtimestamp(timegm(parsed))


class Fetcher:
    """requests a feed, parses it for entries, and updated the data store"""

    def __init__(self, session=None):
        self.session = model.session if not session else session
        self.logger = logger

    def bind_session(self, session):
Exemplo n.º 24
0
import time
from urllib2 import URLError
from dated import utc_from_string

import feedparser
from procol.console import print_err, print_err_trace

from .result import FeedUnchanged, RssErrorResult, RssResult


def _to_utc(datetime_string):
    utc = utc_from_string(datetime_string)
    return utc.timetuple()


feedparser.registerDateHandler(_to_utc)


def parse_feed_result(feed_url, etag=None):
    while True:
        try:
            return _parse_feed_result(feed_url, etag)
        except URLError, e:
            print_err(str(e))
            time.sleep(10)
        except ssl.CertificateError:
            raise
        except BaseException, e:
            print_err_trace('Exception: %s : %s' % (type(e), e))
            time.sleep(60)
Exemplo n.º 25
0
    basefeed_pre_save,
)

LOGGER = logging.getLogger(__name__)

__all__ = [
    'RssAtomFeed',
    'create_feeds_from_url',
    'prepare_feed_url',
    'parse_feeds_urls',
    'discover_feeds_urls',
]

# —————————————————————————————————————————————— External modules configuration

feedparser.registerDateHandler(datetime_extended_parser)
feedparser.USER_AGENT = settings.DEFAULT_USER_AGENT


def check_feedparser_error(parsed_feed, feed=None):
    """ Check for harmless or harmfull feedparser errors. """

    if parsed_feed.get('bozo', None) is None:
        return

    error = parsed_feed.get('bozo_exception', None)

    if error is None:
        return

    # Charset declaration problems are harmless (until they are not).
Exemplo n.º 26
0

def dateparser_handler(date_string):
    """
    Allows feedparser to use the dateparser module for identifying dates.
    """
    dp_settings = {"PREFER_DAY_OF_MONTH": "first", "DATE_ORDER": "YMD"}

    try:
        return dateparser.parse(date_string,
                                settings=dp_settings).utctimetuple()
    except AttributeError:
        pass


parser.registerDateHandler(dateparser_handler)


def _customize_sanitizer(feedparser):

    bad_attributes = ["align", "valign", "hspace", "class", "width", "height"]

    for item in bad_attributes:
        try:
            if item in feedparser._HTMLSanitizer.acceptable_attributes:
                feedparser._HTMLSanitizer.acceptable_attributes.remove(item)
        except Exception:
            logging.debug("Could not remove {item}", item=item)


def get_agent(source_feed):
Exemplo n.º 27
0
# -*- coding: utf-8 -*-
'''
Created on 2010-7-9

@author: ֣郑仁启
'''
import feedparser
import re
import fetchpage

fetch_page = fetchpage.fetch_page
fetch_content = fetchpage.fetch_content
def _parse_date_wsj(dateString):
  wsj_date_format_re = re.compile(u'(\d{4})/(\d{,2})/(\d{,2})[\s{0,2}|T](\d{,2}):(\d{,2}):(\d{,2})\s{,2}(\+|-)(\d{,2})(\d{2})')
  m = wsj_date_format_re.match(dateString)
  if not m: return
  w3dtfdate = '%(year)s-%(month)s-%(day)sT%(hour)s:%(minute)s:%(second)s%(zone0)s%(zone1)s:%(zone2)s' % \
              {'year': m.group(1), 'month': m.group(2), 'day': m.group(3), \
               'hour': m.group(4), 'minute': m.group(5), 'second': m.group(6), \
               'zone0': m.group(7), 'zone1': m.group(8), 'zone2': m.group(9)}
  return feedparser._parse_date_w3dtf(w3dtfdate)
  pass
feedparser.registerDateHandler(_parse_date_wsj)
Exemplo n.º 28
0
)

LOGGER = logging.getLogger(__name__)

__all__ = [
    'RssAtomFeed',
    'create_feeds_from_url',
    'prepare_feed_url',
    'parse_feeds_urls',
    'discover_feeds_urls',
]

# —————————————————————————————————————————————— External modules configuration


feedparser.registerDateHandler(datetime_extended_parser)
feedparser.USER_AGENT = settings.DEFAULT_USER_AGENT


def check_feedparser_error(parsed_feed, feed=None):
    """ Check for harmless or harmfull feedparser errors. """

    if parsed_feed.get('bozo', None) is None:
        return

    error = parsed_feed.get('bozo_exception', None)

    if error is None:
        return

    # Charset declaration problems are harmless (until they are not).
Exemplo n.º 29
0
import dateutil.parser

import feedparser
from requests import RequestException

from flexget import plugin
from flexget.config_schema import one_or_more
from flexget.entry import Entry
from flexget.event import event
from flexget.utils.cached_input import cached
from flexget.utils.tools import decode_html
from flexget.utils.pathscrub import pathscrub

log = logging.getLogger('rss')
feedparser.registerDateHandler(
    lambda date_string: dateutil.parser.parse(date_string).timetuple())


def fp_field_name(name):
    """Translates literal field name to the sanitized one feedparser will use."""
    return name.replace(':', '_').lower()


class InputRSS(object):
    """
    Parses RSS feed.

    Hazzlefree configuration for public rss feeds::

      rss: <url>
Exemplo n.º 30
0
    return strptime(aDateString, tf1)

def myDateHandler2(aDateString):
    return strptime(aDateString, tf2)

def myDateHandler3(aDateString):
    match = pattern1.search(aDateString)
    if match:
        wday, day, month, year, hour, minute, second, nm = \
            match.groups()
        new_string = wday+' '+day+' '+month+' '+year+' '+hour + minute + second
        return myDateHandler1(new_string)
    else:
        return aDateString

feedparser.registerDateHandler(myDateHandler1)
feedparser.registerDateHandler(myDateHandler2)
feedparser.registerDateHandler(myDateHandler3)
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@endpoints.api( name='reader',
                version='v1',
                allowed_client_ids=[WEB_CLIENT_ID, API_EXPLORER_CLIENT_ID],
                scopes=[EMAIL_SCOPE])
class ReaderApi(remote.Service):
    """Reader API v0.1"""
    @endpoints.method(message_types.VoidMessage, Greeting,
                      path='authed', http_method='POST',
                      name='authed')
    def greeting_authed(self, request):
        """Greeting logged in user"""
        user = endpoints.get_current_user()
Exemplo n.º 31
0
import dateutil.parser

import feedparser
from requests import RequestException

from flexget import plugin
from flexget.config_schema import one_or_more
from flexget.entry import Entry
from flexget.event import event
from flexget.utils.cached_input import cached
from flexget.utils.tools import decode_html
from flexget.utils.pathscrub import pathscrub

log = logging.getLogger('rss')
feedparser.registerDateHandler(lambda date_string: dateutil.parser.parse(date_string).timetuple())


def fp_field_name(name):
    """Translates literal field name to the sanitized one feedparser will use."""
    return name.replace(':', '_').lower()


class InputRSS(object):
    """
    Parses RSS feed.

    Hazzlefree configuration for public rss feeds::

      rss: <url>
Exemplo n.º 32
0
Arquivo: temporal.py Projeto: dpla/zen
            return datetime.datetime(int(d[0:4]), int(d[4:6]), int(d[6:8]), int(d[8:10]), int(d[10:12]), int(d[12:]), 0, UTC).timetuple() #.utctimetuple()
        except ValueError:
            return None
    return None

#
def plain_year(d):
    if len(d) == 4:
        try:
            #FIXME: converting via tuple to datetime, then back to tuple.  Wasteful.
            return datetime.datetime(int(d[0:4]), 1, 1).timetuple()
        except ValueError:
            return None
    return None

feedparser.registerDateHandler(mods_convention_date)
feedparser.registerDateHandler(plain_year)

def smart_parse_date(date):
    '''
    Accepts a string or unicode date to be parsed and returns a datetime.datetime result
    
    A very restrictive list of dates that can be parsed (i.e. some date formats not
    listed here should work):

    W3C dates, documented here:

    http://www.w3.org/TR/NOTE-datetime

    A subset of undelimited ISO-8601 dates work (as prevalent in LC MODS).