¿Qué es un buen analizador de Python para una consulta de búsqueda tipo google?

Question

Para algunos códigos basados ​​en búsquedas (en Python), necesito escribir un analizador de sintaxis de consulta que analice una sintaxis de consulta simple de Google. Por ejemplo:

todas estas palabras "con esta frase" O eso, o este sitio: within.site filetype: ps a partir de: lastweek

Como la búsqueda se vuelve más una más popular, me se espera que pueda encontrar fácilmente una biblioteca de Python para hacer esto y así evitar tener que reinventar la rueda. Lamentablemente, las búsquedas en google no rinden mucho.

¿Qué recomendarías como una biblioteca de análisis de Python para esta sencilla tarea?

Answer 1

Mientras que ply es un enfoque más clásico (una variante pitonica de lexx + yacc) y por lo tanto puede ser más fácil comenzar si ya estás familiarizado con tales herramientas tradicionales, pyparsing es altamente pitónico y sería mi principal recomendación , especialmente para tareas tan simples (que en realidad son más parecidas a las de un análisis "completo" ... al menos hasta que quieras permitir paréntesis posiblemente anidados, pero los pymes no se verán afectados por eso ;-).

Answer 2

PLY es genial. Se basa en el idioma Lex/Yacc y, por lo tanto, puede que ya esté familiarizado. Le permite crear lexers y analizadores arbitrarios complejos para cualquier tarea, incluida la que necesita.

Usar una poderosa herramienta como PLY en lugar de un simple juguete es una buena idea, porque sus necesidades pueden volverse más complejas con el tiempo y le gustaría quedarse con la misma herramienta.

Answer 3

SORRY - Lepl ya no se desarrolla.

También hay LEPL - http://www.acooke.org/lepl

he aquí una solución rápida que escribí durante el desayuno:

 
pl6 src: python3              
Python 3.1 (r31:73572, Oct 24 2009, 05:39:09)       
[GCC 4.4.1 [gcc-4_4-branch revision 150839]] on linux2     
Type "help", "copyright", "credits" or "license" for more information. 
>>> from lepl import *             
>>>                 
>>> class Alternatives(Node):           
...  pass               
... 
>>> class Query(Node): 
...  pass 
... 
>>> class Text(Node): 
...  pass 
... 
>>> def compile(): 
...  qualifier  = Word() & Drop(':')   > 'qualifier' 
...  word   = ~Lookahead('OR') & Word() 
...  phrase   = String() 
...  text   = phrase | word 
...  word_or_phrase = (Optional(qualifier) & text) > Text 
...  space   = Drop(Space()[1:]) 
...  query   = word_or_phrase[1:, space] > Query 
...  separator  = Drop(space & 'OR' & space) 
...  alternatives = query[:, separator]   > Alternatives 
...  return alternatives.string_parser() 
... 
>>> parser = compile() 
>>> 
>>> alternatives = parser('all of these words "with this phrase" ' 
...      'OR that OR this site:within.site ' 
...      'filetype:ps from:lastweek')[0] 
>>> 
>>> print(str(alternatives)) 
Alternatives 
+- Query 
| +- Text 
| | `- 'all' 
| +- Text 
| | `- 'of' 
| +- Text 
| | `- 'these' 
| +- Text 
| | `- 'words' 
| `- Text 
|  `- 'with this phrase' 
+- Query 
| `- Text 
|  `- 'that' 
`- Query 
    +- Text 
    | `- 'this' 
    +- Text 
    | +- qualifier 'site' 
    | `- 'within.site' 
    +- Text 
    | +- qualifier 'filetype' 
    | `- 'ps' 
    `- Text 
     +- qualifier 'from' 
     `- 'lastweek' 
>>> 

yo diría que LEPL no es un "juguete" - aunque es descendente recursivo, que incluye memorización y trampolín, que ayudan a evitar algunas de las limitaciones de ese enfoque.

Sin embargo, es Python puro, así que no es súper rápido, y está en desarrollo activo (una nueva versión, 4.0, con un buen número de correcciones y mejoras, está llegando relativamente breve).

Answer 4

Whoosh tiene un módulo de análisis de consulta de búsqueda integral whoosh.qparser y la clase QueryParser que debe ser razonablemente fácil de adaptar a su caso de uso.

Ver http://pythonhosted.org/Whoosh/parsing.html y https://bitbucket.org/mchaput/whoosh/src/55f9c484047a8306101c8eaa59e9a110f960a1c2/src/whoosh/qparser

Answer 5

Algunas buenas opciones:

• Whoosh: el único problema es que tienen pocos ejemplos de análisis ya que el analizador puede que no sea su principal característica/enfoque, pero es sin duda una buena opción

• modgrammar: yo no lo probamos, pero parece bastante flexible y sencilla

• capa

• pyparsing: muy recomendable. hay algunos buenos ejemplos de análisis en línea

Si terminaste con el proyecto, ¿qué terminaste eligiendo?

Answer 6

Sé que esta es una vieja pregunta, pero para referencia futura acabo de subir mi paquete searchstringparser al PyPi. Que implementa una maquinaria de análisis de consultas decente basada en ply. Emite una cadena adecuada para la función PostgreSQL tsquery. Puede ver las clases lexer y analizador para ver si se ajustan a sus necesidades o modificar en consecuencia.

Comentarios bienvenidos!

Answer 7

PyParsing sería la opción correcta, aunque es bastante tedioso, por eso he desarrollado un analizador de consultas inspirado en la sintaxis de lucene y gmail. La única dependencia es PyParsing, y la hemos usado en varios proyectos. Es totalmente personalizable y extensible, además de que lo abstrae de los problemas de pyparsing. Puede verificarlo aquí:

http://www.github.com/sebastiandev/plyse

Su bastante bien documentado por lo que encontrará documentos sobre cómo hacer la consulta, configuraciones, etc.