import codecs

import os

import logging

import pkgutil

import StringIO

import sys

return os.path.getmtime(a) >= os.path.getmtime(b)

def load_packaged_grammar(package, grammar_source):

"""Normally, loads a pickled grammar by doing

pkgutil.get_data(package, pickled_grammar)

where *pickled_grammar* is computed from *grammar_source* by adding the

Python version and using a ``.pickle`` extension.

However, if *grammar_source* is an extant file, load_grammar(grammar_source)

is called instead. This facilities using a packaged grammar file when needed

but preserves load_grammar's automatic regeneration behavior when possible.

"""

if os.path.isfile(grammar_source):

return load_grammar(grammar_source)

pickled_name = _generate_pickle_name(os.path.basename(grammar_source))

data = pkgutil.get_data(package, pickled_name)

g = grammar.Grammar()

g.loads(data)

return g

def main(*args):

"""Main program, when run as a script: produce grammar pickle files.

f.close()

self.__dict__.update(d)

def loads(self, pkl):

"""Load the grammar tables from a pickle bytes object."""

self.__dict__.update(pickle.loads(pkl))

def copy(self):

"""

Copy the grammar.

setattr(self, name, symbol)

python_grammar = driver.load_grammar(_GRAMMAR_FILE)

python_grammar = driver.load_packaged_grammar("lib2to3", _GRAMMAR_FILE)

python_symbols = Symbols(python_grammar)

python_grammar_no_print_statement = python_grammar.copy()

del python_grammar_no_print_statement.keywords["print"]

pattern_grammar = driver.load_grammar(_PATTERN_GRAMMAR_FILE)

pattern_grammar = driver.load_packaged_grammar("lib2to3", _PATTERN_GRAMMAR_FILE)

pattern_symbols = Symbols(pattern_grammar)

from .support import driver, test_dir

# Python imports

import operator

import os

import pickle

import shutil

import subprocess

import sys

import tempfile

import types

import unittest

# Local imports

finally:

shutil.rmtree(tmpdir)

def test_load_packaged_grammar(self):

modname = __name__ + '.load_test'

class MyLoader:

def get_data(self, where):

return pickle.dumps({'elephant': 19})

class MyModule(types.ModuleType):

__file__ = 'parsertestmodule'

__loader__ = MyLoader()

sys.modules[modname] = MyModule(modname)

self.addCleanup(operator.delitem, sys.modules, modname)

g = pgen2_driver.load_packaged_grammar(modname, 'Grammar.txt')

self.assertEqual(g.elephant, 19)

class GrammarTest(support.TestCase):

2to3 and lib2to3 can now read pickled grammar files using pkgutil.get_data()

rather than probing the filesystem. This lets 2to3 and lib2to3 work when run

from a zipfile.