Comment: | commit 1 |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | trunk | commit1 |
Files: | files | file ages | folders |
SHA3-256: |
2fd7dc4dd557072b74bf5828ec33a392 |
User & Date: | olr on 2017-04-25 11:51:19 |
Other Links: | manifest | tags |
2017-04-25
| ||
12:09 | Python v3.6 check-in: 1b348abe60 user: olr tags: trunk | |
11:51 | commit 1 check-in: 2fd7dc4dd5 user: olr tags: trunk, commit1 | |
11:44 | initial empty check-in check-in: c902aec434 user: Z9 tags: trunk | |
Added LICENSE.fr.txt version [6c800bc372].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 | LICENCE PUBLIQUE GÉNÉRALE GNU Version 3, du 29 juin 2007. Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> Chacun est autorisé à copier et distribuer des copies conformes de ce document de licence, mais toute modification en est proscrite. Traduction française par Philippe Verdy <verdy_p (à) wanadoo (point) fr>, le 30 juin 2007. _______________________________________________________________________ Avertissement important au sujet de cette traduction française. _______________________________________________________________________ Ceci est une traduction en français de la licence “GNU General Public License” (GPL). Cette traduction est fournie ici dans l’espoir qu’elle facilitera sa compréhension, mais elle ne constitue pas une traduction officielle ou approuvée d’un point de vue juridique. La Free Software Foundation (FSF) ne publie pas cette traduction et ne l’a pas approuvée en tant que substitut valide au plan légal pour la licence authentique “GNU General Public Licence”. Cette traduction n’a pas encore été passée en revue attentivement par un juriste et donc le traducteur ne peut garantir avec certitude qu’elle représente avec exactitude la signification légale des termes de la licence authentique “GNU General Public License” publiée en anglais. Cette traduction n’établit donc légalement aucun des termes et conditions d’utilisation d’un logiciel sous licence GNU GPL — seul le texte original en anglais le fait. Si vous souhaitez être sûr que les activités que vous projetez seront autorisées par la GNU General Public License, veuillez vous référer à sa seule version anglaise authentique. La FSF vous recommande fermement de ne pas utiliser cette traduction en tant que termes officiels pour vos propres programmes ; veuillez plutôt utiliser la version anglaise authentique telle que publiée par la FSF. Si vous choisissez d’acheminer cette traduction en même temps qu’un Programme sous licence GNU GPL, cela ne vous dispense pas de l’obligation d’acheminer en même temps une copie de la licence authentique en anglais, et de conserver dans la traduction cet avertissement important en français et son équivalent en anglais ci-dessous. _______________________________________________________________________ Important Warning About This French Translation. _______________________________________________________________________ This is a translation of the GNU General Public License (GPL) into French. This translation is distributed in the hope that it will facilitate understanding, but it is not an official or legally approved translation. The Free Software Foundation (FSF) is not the publisher of this translation and has not approved it as a legal substitute for the authentic GNU General Public License. The translation has not been reviewed carefully by lawyers, and therefore the translator cannot be sure that it exactly represents the legal meaning of the authentic GNU General Public License published in English. This translation does not legally state the terms and conditions of use of any Program licenced under GNU GPL — only the original English text of the GNU LGPL does that. If you wish to be sure whether your planned activities are permitted by the GNU General Public License, please refer to its sole authentic English version. The FSF strongly urges you not to use this translation as the official distribution terms for your programs; instead, please use the authentic English version published by the FSF. If you choose to convey this translation along with a Program covered by the GPL Licence, this does not remove your obligation to convey at the same time a copy of the authentic GNU GPL License in English, and you must keep in this translation this important warning in English and its equivalent in French above. _______________________________________________________________________ Préambule La Licence Publique Générale GNU (“GNU General Public License”) est une licence libre, en “copyleft”, destinée aux œuvres logicielles et d’autres types de travaux. Les licences de la plupart des œuvres logicielles et autres travaux de pratique sont conçues pour ôter votre liberté de partager et modifier ces travaux. En contraste, la Licence Publique Générale GNU a pour but de garantir votre liberté de partager et changer toutes les versions d’un programme — afin d’assurer qu’il restera libre pour tous les utilisateurs. Nous, la Free Software Foundation, utilisons la Licence Publique Générale GNU pour la plupart de nos logiciels ; cela s’applique aussi à tout autre travail édité de cette façon par ses auteurs. Vous pouvez, vous aussi, l’appliquer à vos propres programmes. Quand nous parlons de logiciel libre (“free”), nous nous référons à la liberté (“freedom”), pas au prix. Nos Licences Publiques Générales sont conçues pour assurer que vous ayez la liberté de distribuer des copies de logiciel libre (et le facturer si vous le souhaitez), que vous receviez le code source ou pouviez l’obtenir si vous le voulez, que vous pouviez modifier le logiciel ou en utiliser toute partie dans de nouveaux logiciels libres, et que vous sachiez que vous avez le droit de faire tout ceci. Pour protéger vos droits, nous avons besoin d’empêcher que d’autres vous restreignent ces droits ou vous demande de leur abandonner ces droits. En conséquence, vous avez certaines responsabilités si vous distribuez des copies d’un tel programme ou si vous le modifiez : les responsabilités de respecter la liberté des autres. Par exemple, si vous distribuez des copies d’un tel programme, que ce soit gratuit ou contre un paiement, vous devez accorder aux Destinataires les mêmes libertés que vous avez reçues. Vous devez aussi vous assurer qu’eux aussi reçoivent ou peuvent recevoir son code source. Et vous devez leur montrer les termes de cette licence afin qu’ils connaissent leurs droits. Les développeurs qui utilisent la GPL GNU protègent vos droits en deux étapes : (1) ils affirment leur droits d’auteur (“copyright”) sur le logiciel, et (2) vous accordent cette Licence qui vous donne la permission légale de le copier, le distribuer et/ou le modifier. Pour la protection des développeurs et auteurs, la GPL stipule clairement qu’il n’y a pas de garantie pour ce logiciel libre. Aux fins à la fois des utilisateurs et auteurs, la GPL requière que les versions modifiées soient marquées comme changées, afin que leurs problèmes ne soient pas attribués de façon erronée aux auteurs des versions précédentes. Certains dispositifs sont conçus pour empêcher l’accès des utilisateurs à l’installation ou l’exécution de versions modifiées du logiciel à l’intérieur de ces dispositifs, alors que les fabricants le peuvent. Ceci est fondamentalement incompatible avec le but de protéger la liberté des utilisateurs de modifier le logiciel. L’aspect systématique de tels abus se produit dans le secteur des produits destinés aux utilisateurs individuels, ce qui est précidément ce qui est le plus inacceptable. Aussi, nous avons conçu cette version de la GPL pour prohiber cette pratique pour ces produits. Si de tels problèmes surviennent dans d’autres domaines, nous nous tenons prêt à étendre cette restriction à ces domaines dans de futures versions de la GPL, autant qu’il sera nécessaire pour protéger la liberté des utilisateurs. Finalement, chaque programme est constamment menacé par les brevets logiciels. Les États ne devraient pas autoriser de tels brevets à restreindre le développement et l’utilisation de logiciels libres sur des ordinateurs d’usage général ; mais dans ceux qui le font, nous voulons spécialement éviter le danger que les brevets appliqués à un programme libre puisse le rendre effectivement propriétaire. Pour empêcher ceci, la GPL assure que les brevets ne peuvent être utilisés pour rendre le programme non-libre. Les termes précis et conditions concernant la copie, la distribution et la modification suivent. TERMES ET CONDITIONS Article 0. Définitions. « Cette Licence » se réfère à la version 3 de la “GNU General Public License” (le texte original en anglais). « Droit d’Auteur » signifie aussi les droits du “copyright” ou voisins qui s’appliquent à d’autres types de travaux, tels que ceux sur les masques de semi-conducteurs. « Le Programme » se réfère à tout travail qui peut être sujet au Droit d’Auteur (“copyright”) et dont les droits d’utilisation sont concédés en vertu de cette Licence. Chacun des Licenciés, à qui cette Licence est concédée, est désigné par « vous. » Les « Licenciés » et les « Destinataires » peuvent être des personnes physiques ou morales (individus ou organisations). « Modifier » un travail signifie en obtenir une copie et adapter tout ou partie du travail d’une façon nécessitant une autorisation d’un titulaire de Droit d’Auteur, autre que celle permettant d’en produire une copie conforme. Le travail résultant est appelé une « version modifiée » du précédent travail, ou un travail « basé sur » le précédent travail. Un « Travail Couvert » signifie soit le Programme non modifié soit un travail basé sur le Programme. « Propager » un travail signifie faire quoi que ce soit avec lui qui, sans permission, vous rendrait directement ou indirectement responsable d’un délit de contrefaçon suivant les lois relatives au Droit d’Auteur, à l’exception de son exécution sur un ordinateur ou de la modification d’une copie privée. La propagation inclue la copie, la distribution (avec ou sans modification), la mise à disposition envers le public, et aussi d'autres activités dans certains pays. « Acheminer » un travail signifie tout moyen de propagation de celui-ci qui permet à d’autres parties de réaliser ou recevoir des copies. La simple interaction d’un utilisateur à travers un réseau informatique, sans transfert effectif d’une copie, ne constitue pas un acheminement. Une interface utilisateur interactive affiche des « Notices Légales Appropriées » quand elle comprend un dispositif convenable, bien visible et évident qui (1) affiche une notice appropriée sur les droits d’auteur et (2) informe l’utilisateur qu’il n’y a pas de garantie pour le travail (sauf si des garanties ont été fournies hors du cadre de cette Licence), que les licenciés peuvent acheminer le travail sous cette Licence, et comment voir une copie de cette Licence. Si l’interface présente une liste de commandes utilisateur ou d’options, tel qu’un menu, un élément évident dans la liste présentée remplit ce critère. Article 1. Code source. Le « code source » d’un travail signifie la forme préférée du travail permettant ou facilitant les modifications de celui-ci. Le « code objet » d’un travail signifie toute forme du travail qui n’en est pas le code source. Une « Interface Standard » signifie une interface qui est soit celle d’une norme officielle définie par un organisme de normalisation reconnu ou, dans le cas des interfaces spécifiées pour un langage de programmation particulier, une interface largement utilisée parmi les développeurs travaillant dans ce langage. Les « Bibliothèques Système » d’un travail exécutable incluent tout ce qui, en dehors du travail dans son ensemble, (a) est inclus dans la forme usuelle de paquetage d’un Composant Majeur mais ne fait pas partie de ce Composant Majeur et (b) sert seulement à permettre l’utilisation du travail avec ce Composant Majeur ou à implémenter une Interface Standard pour laquelle une implémentation est disponible au public sous forme de code source ; un « Composant Majeur » signifie, dans ce contexte, un composant majeur essentiel (noyau, système de fenêtrage, etc.) du système d’exploitation (le cas échéant) d’un système sur lequel le travail exécutable fonctionne, ou bien un compilateur utilisé pour produire le code objet du travail, ou un interprète de code objet utilisé pour exécuter celui-ci. Le « Source Correspondant » d’un travail sous forme de code objet signifie l’ensemble des codes sources nécessaires pour générer, installer et (dans le cas d’un travail exécutable) exécuter le code objet et modifier le travail, y compris les scripts pour contrôler ces activités. Cependant, cela n’inclue pas les Bibliothèques Système du travail, ni les outils d’usage général ou les programmes libres généralement disponibles qui peuvent être utilisés sans modification pour achever ces activités mais ne sont pas partie de ce travail. Par exemple le Source Correspondant inclut les fichiers de définition d’interfaces associés aux fichiers sources du travail, et le code source des bibliothèques partagées et des sous-routines liées dynamiquement, pour lesquelles le travail est spécifiquement conçu pour les requérir via, par exemple, des communications de données ou contrôles de flux internes entre ces sous-programmes et d’autres parties du travail. Le Source Correspondant n’a pas besoin d’inclure tout ce que les utilisateurs peuvent regénérer automatiquement à partir d’autres parties du Source Correspondant. Le Source Correspondant pour un travail sous forme de code source est ce même travail. Article 2. Permissions de base. Tous les droits accordés suivant cette Licence le sont jusqu’au terme des Droits d’Auteur (“copyright”) sur le Programme, et sont irrévocables pourvu que les conditions établies soient remplies. Cette Licence affirme explicitement votre permission illimitée d’exécuter le Programme non modifié. La sortie produite par l’exécution d’un Travail Couvert n’est couverte par cette Licence que si cette sortie, étant donné leur contenu, constitue un Travail Couvert. Cette Licence reconnait vos propres droits d’usage raisonnable (“fair use” en législation des États-Unis d’Amérique) ou autres équivalents, tels qu’ils sont pourvus par la loi applicable sur le Droit d’Auteur (“copyright”). Vous pouvez créer, exécuter et propager sans condition des Travaux Couverts que vous n’acheminez pas, aussi longtemps que votre licence demeure en vigueur. Vous pouvez acheminer des Travaux Couverts à d’autres personnes dans le seul but de leur faire réaliser des modifications à votre usage exclusif, ou pour qu’ils vous fournissent des facilités vous permettant d’exécuter ces travaux, pourvu que vous vous conformiez aux termes de cette Licence lors de l’acheminement de tout matériel dont vous ne contrôlez pas le Droit d’Auteur (“copyright”). Ceux qui, dès lors, réalisent ou exécutent pour vous les Travaux Couverts ne doivent alors le faire qu’exclusivement pour votre propre compte, sous votre direction et votre contrôle, suivant des termes qui leur interdisent de réaliser, en dehors de leurs relations avec vous, toute copie de votre matériel soumis au Droit d’Auteur. L’acheminement dans toutes les autres circonstances n’est permis que selon les conditions établies ci-dessous. La concession de sous-licences n’est pas autorisé ; l’article 10 rend cet usage non nécessaire. Article 3. Protection des droits légaux des utilisateurs envers les lois anti-contournement. Aucun Travail Couvert ne doit être vu comme faisant partie d’une mesure technologique effective selon toute loi applicable remplissant les obligations prévues à l’article 11 du traité international sur le droit d’auteur adopté à l’OMPI le 20 décembre 1996, ou toutes lois similaires qui prohibent ou restreignent le contournement de telles mesures. Si vous acheminez un Travail Couvert, vous renoncez à tout pouvoir légal d’interdire le contournement des mesures technologiques dans tous les cas où un tel contournement serait effectué en exerçant les droits prévus dans cette Licence pour ce Travail Couvert, et vous déclarez rejeter toute intention de limiter l’opération ou la modification du Travail, en tant que moyens de renforcer, à l’encontre des utilisateurs de ce Travail, vos droits légaux ou ceux de tierces parties d’interdire le contournement des mesures technologiques. Article 4. Acheminement des copies conformes. Vous pouvez acheminer des copies conformes du code source du Programme tel que vous l’avez reçu, sur n’importe quel support, pourvu que vous publiiez scrupuleusement et de façon appropriée sur chaque copie une notice de Droit d’Auteur appropriée ; gardez intactes toutes les notices établissant que cette Licence et tous les termes additionnels non permissifs ajoutés en accord avec l’article 7 s’appliquent à ce code ; et donnez à chacun des Destinataires une copie de cette Licence en même temps que le Programme. Vous pouvez facturer à un prix quelconque, y compris gratuit, chacune des copies que vous acheminez, et vous pouvez offrir une protection additionnelle de support ou de garantie en échange d’un paiement. Article 5. Acheminement des versions sources modifiées. Vous pouvez acheminer un travail basé sur le Programme, ou bien les modifications pour le produire à partir du Programme, sous la forme de code source suivant les termes de l’article 4, pourvu que vous satisfassiez aussi à chacune des conditions requises suivantes : a) Le travail doit comporter des notices évidentes établissant que vous l’avez modifié et donnant la date correspondante. b) Le travail doit comporter des notices évidentes établissant qu’il est édité selon cette Licence et les conditions ajoutées d’après l’article 7. Cette obligation vient modifier l’obligation de l’article 4 de « garder intactes toutes les notices. » c) Vous devez licencier le travail entier, comme un tout, suivant cette Licence à quiconque entre en possession d’une copie. Cette Licence s’appliquera en conséquence, avec les termes additionnels applicables prévus par l’article 7, à la totalité du travail et chacune de ses parties, indépendamment de la façon dont ils sont empaquetés. Cette licence ne donne aucune permission de licencier le travail d’une autre façon, mais elle n’invalide pas une telle permission si vous l’avez reçue séparément. d) Si le travail a des interfaces utilisateurs interactives, chacune doit afficher les Notices Légales Appropriées ; cependant si le Programme a des interfaces qui n’affichent pas les Notices Légales Appropriées, votre travail n’a pas à les modifier pour qu’elles les affichent. Une compilation d’un Travail Couvert avec d’autres travaux séparés et indépendants, qui ne sont pas par leur nature des extensions du Travail Couvert, et qui ne sont pas combinés avec lui de façon à former un programme plus large, dans ou sur un volume de stockage ou un support de distribution, est appelé un « aggrégat » si la compilation et son Droit d’Auteur résultant ne sont pas utilisés pour limiter l’accès ou les droits légaux des utilisateurs de la compilation en deça de ce que permettent les travaux individuels. L’inclusion d’un Travail Couvert dans un aggrégat ne cause pas l’application de cette Licence aux autres parties de l’aggrégat. Article 6. Acheminement des formes non sources. Vous pouvez acheminer sous forme de code objet un Travail Couvert suivant les termes des articles 4 et 5, pourvu que vous acheminiez également suivant les termes de cette Licence le Source Correspondant lisible par une machine, d’une des façons suivantes : a) Acheminer le code objet sur, ou inclus dans, un produit physique (y compris un support de distribution physique), accompagné par le Source Correspondant fixé sur un support physique durable habituellement utilisé pour les échanges de logiciels. b) Acheminer le code objet sur, ou inclus dans, un produit physique (y compris un support de distribution physique), accompagné d’une offre écrite, valide pour au moins trois années et valide pour aussi longtemps que vous fournissez des pièces de rechange ou un support client pour ce modèle de produit, afin de donner à quiconque possède le code objet soit (1) une copie du Source Correspondant à tout logiciel dans ce produit qui est couvert par cette Licence, sur un support physique durable habituellement utilisé pour les échanges de logiciels, pour un prix non supérieur au coût raisonnable de la réalisation physique de l’acheminement de la source, ou soit (2) un accès permettant de copier le Source Correspondant depuis un serveur réseau sans frais. c) Acheminer des copies individuelles du code objet avec une copie de l’offre écrite de fournir le Source Correspondant. Cette alternative est permise seulement occasionellement et non commercialement, et seulement si vous avez reçu le code objet avec une telle offre, en accord avec l’article 6 alinéa b. d) Acheminer le code objet en offrant un accès depuis un emplacement désigné (gratuit ou contre facturation) et offrir un accès équivalent au Source Correspondant de la même façon via le même emplacement et sans facturation supplémentaire. Vous n’avez pas besoin d’obliger les Destinataires à copier le Source Correspondant en même temps que le code objet. Si l’emplacement pour copier le code objet est un serveur réseau, le Source Correspondant peut être sur un serveur différent (opéré par vous ou par un tiers) qui supporte des facilités équivalentes de copie, pourvu que vous mainteniez des directions claires à proximité du code objet indiquant où trouver le Source Correspondant. Indépendamment de quel serveur héberge le Source Correspondant, vous restez obligé de vous assurer qu’il reste disponible aussi longtemps que nécessaire pour satisfaire à ces obligations. e) Acheminer le code objet en utilisant une transmission d’égal-à-égal, pourvu que vous informiez les autres participants sur où le code objet et le Source Correspondant du travail sont offerts sans frais au public général suivant l’article 6 alinéa d. Une portion séparable du code objet, dont le code source est exclu du Source Correspondant en tant que Bibliothèque Système, n’a pas besoin d’être inclu dans l’acheminement du travail sous forme de code objet. Un « Produit Utilisateur » est soit (1) un « Produit de Consommation, » ce qui signifie toute propriété personnelle tangible normalement utilisée à des fins personnelles, familiales ou relatives au foyer, soit (2) toute chose conçue ou vendue pour l’incorporation dans un lieu d’habitation. Pour déterminer si un produit constitue un Produit de Consommation, les cas ambigus sont résolus en fonction de la couverture. Pour un produit particulier reçu par un utilisateur particulier, l’expression « normalement utilisée » ci-avant se réfère à une utilisation typique ou l’usage commun de produits de même catégorie, indépendamment du statut de cet utilisateur particulier ou de la façon spécifique dont cet utilisateur particulier utilise effectivement ou s’attend lui-même ou est attendu à utiliser ce produit. Un produit est un Produit de Consommation indépendamment du fait que ce produit a ou n’a pas d’utilisations substantielles commerciales, industrielles ou hors Consommation, à moins que de telles utilisations représentent le seul mode significatif d’utilisation du produit. Les « Informations d’Installation » d’un Produit Utilisateur signifient toutes les méthodes, procédures, clés d’autorisation ou autres informations requises pour installer et exécuter des versions modifiées d’un Travail Couvert dans ce Produit Utilisateur à partir d’une version modifiée de son Source Correspondant. Les informations qui suffisent à assurer la continuité de fonctionnement du code objet modifié ne doivent en aucun cas être empêchées ou interférées du seul fait qu’une modification a été effectuée. Si vous acheminez le code objet d’un Travail Couvert dans, ou avec, ou spécifiquement pour l’utilisation dans, un Produit Utilisateur et l’acheminement se produit en tant qu’élément d’une transaction dans laquelle le droit de possession et d’utilisation du Produit Utilisateur est transféré au Destinataire définitivement ou pour un terme fixé (indépendamment de la façon dont la transaction est caractérisée), le Source Correspondant acheminé selon cet article-ci doit être accompagné des Informations d’Installation. Mais cette obligation ne s’applique pas si ni vous ni aucune tierce partie ne détient la possibilité d’intaller un code objet modifié sur le Produit Utilisateur (par exemple, le travail a été installé en mémoire morte). L’obligation de fournir les Informations d’Installation n’inclue pas celle de continuer à fournir un service de support, une garantie ou des mises à jour pour un travail qui a été modifié ou installé par le Destinataire, ou pour le Produit Utilisateur dans lequel il a été modifié ou installé. L’accès à un réseau peut être rejeté quand la modification elle-même affecte matériellement et défavorablement les opérations du réseau ou viole les règles et protocoles de communication au travers du réseau. Le Source Correspondant acheminé et les Informations d’Installation fournies, en accord avec cet article, doivent être dans un format publiquement documenté (et dont une implémentation est disponible auprès du public sous forme de code source) et ne doit nécessiter aucune clé ou mot de passe spécial pour le dépaquetage, la lecture ou la copie. Article 7. Termes additionnels. Les « permissions additionelles » désignent les termes qui supplémentent ceux de cette Licence en émettant des exceptions à l’une ou plusieurs de ses conditions. Les permissions additionnelles qui sont applicables au Programme entier doivent être traitées comme si elles étaient incluent dans cette Licence, dans les limites de leur validité suivant la loi applicable. Si des permissions additionnelles s’appliquent seulement à une partie du Programme, cette partie peut être utilisée séparément suivant ces permissions, mais le Programme tout entier reste gouverné par cette Licence sans regard aux permissions additionelles. Quand vous acheminez une copie d’un Travail Couvert, vous pouvez à votre convenance ôter toute permission additionelle de cette copie, ou de n’importe quelle partie de celui-ci. (Des permissions additionnelles peuvent être rédigées de façon à requérir leur propre suppression dans certains cas où vous modifiez le travail.) Vous pouvez placer les permissions additionnelles sur le matériel acheminé, ajoutées par vous à un Travail Couvert pour lequel vous avez ou pouvez donner les permissions de Droit d’Auteur (“copyright”) appropriées. Nonobstant toute autre clause de cette Licence, pour tout constituant que vous ajoutez à un Travail Couvert, vous pouvez (si autorisé par les titulaires de Droit d’Auteur pour ce constituant) supplémenter les termes de cette Licence avec des termes : a) qui rejettent la garantie ou limitent la responsabilité de façon différente des termes des articles 15 et 16 de cette Licence ; ou b) qui requièrent la préservation de notices légales raisonnables spécifiées ou les attributions d’auteur dans ce constituant ou dans les Notices Légales Appropriées affichées par les travaux qui le contiennent ; ou c) qui prohibent la représentation incorrecte de l’origine de ce constituant, ou qui requièrent que les versions modifiées d’un tel constituant soit marquées par des moyens raisonnables comme différentes de la version originale ; ou d) qui limitent l’usage à but publicitaire des noms des concédants de licence et des auteurs du constituant ; ou e) qui refusent à accorder des droits selon la législation relative aux marques commerciales, pour l’utilisation dans des noms commerciaux, marques commerciales ou marques de services ; ou f) qui requièrent l’indemnisation des concédants de licences et auteurs du constituant par quiconque achemine ce constituant (ou des versions modifiées de celui-ci) en assumant contractuellement la responsabilité envers le Destinataire, pour toute responsabilité que ces engagements contractuels imposent directement à ces octroyants de licences et auteurs. Tous les autres termes additionnels non permissifs sont considérés comme des « restrictions avancées » dans le sens de l’article 10. Si le Programme tel que vous l’avez reçu, ou toute partie de celui-ci, contient une notice établissant qu’il est gouverné par cette Licence en même temps qu’un terme qui est une restriction avancée, vous pouvez ôter ce terme. Si un document de licence contient une restriction avancée mais permet la reconcession de licence ou l’acheminement suivant cette Licence, vous pouvez ajouter un Travail Couvert constituant gouverné par les termes de ce document de licence, pourvu que la restriction avancée ne survit pas à un telle cession de licence ou acheminement. Si vous ajoutez des termes à un Travail Couvert en accord avec cet article, vous devez placer, dans les fichiers sources appropriés, une déclaration des termes additionnels qui s’appliquent à ces fichiers, ou une notice indiquant où trouver les termes applicables. Les termes additionnels, qu’ils soient permissifs ou non permissifs, peuvent être établis sous la forme d’une licence écrite séparément, ou établis comme des exceptions ; les obligations ci-dessus s’appliquent dans chacun de ces cas. Article 8. Terminaison. Vous ne pouvez ni propager ni modifier un Travail Couvert autrement que suivant les termes de cette Licence. Toute autre tentative de le propager ou le modifier est nulle et terminera automatiquement vos droits selon cette Licence (y compris toute licence de brevet accordée selon le troisième paragraphe de l’article 11). Cependant, si vous cessez toute violation de cette Licence, alors votre licence depuis un titulaire de Droit d’Auteur (“copyright”) est réinstaurée (a) à titre provisoire à moins que et jusqu’à ce que le titulaire de Droit d’Auteur termine finalement et explicitement votre licence, et (b) de façon permanente si le titulaire de Droit d’Auteur ne parvient pas à vous notifier de la violation par quelque moyen raisonnable dans les soixante (60) jours après la cessation. De plus, votre licence depuis un titulaire particulier de Droit d’Auteur est réinstaurée de façon permanente si ce titulaire vous notifie de la violation par quelque moyen raisonnable, c’est la première fois que vous avez reçu une notification deviolation de cette Licence (pour un travail quelconque) depuis ce titulaire de Droit d’Auteur, et vous résolvez la violation dans les trente (30) jours qui suivent votre réception de la notification. La terminaison de vos droits suivant cette section ne terminera pas les licences des parties qui ont reçu des copies ou droits de votre part suivant cette Licence. Si vos droits ont été terminés et non réinstaurés de façon permanente, vous n’êtes plus qualifié à recevoir de nouvelles licences pour les mêmes constituants selon l’article 10. Article 9. Acceptation non requise pour obtenir des copies. Vous n’êtes pas obligé d’accepter cette licence afin de recevoir ou exécuter une copie du Programme. La propagation asservie d’un Travail Couvert qui se produit simplement en conséquence d’une transmission d’égal-à-égal pour recevoir une copie ne nécessite pas l’acceptation. Cependant, rien d’autre que cette Licence ne vous accorde la permission de propager ou modifier un quelconque Travail Couvert. Ces actions enfreignent le Droit d’Auteur si vous n’acceptez pas cette Licence. Par conséquent, en modifiant ou propageant un Travail Couvert, vous indiquez votre acceptation de cette Licence pour agir ainsi. Article 10. Cession automatique de Licence aux Destinataires et intermédiaires. Chaque fois que vous acheminez un Travail Couvert, le Destinataire reçoit automatiquement une licence depuis les concédants originaux, pour exécuter, modifier et propager ce travail, suivant les termes de cette Licence. Vous n’êtes pas responsable du renforcement de la conformation des tierces parties avec cette Licence. Une « transaction d’entité » désigne une transaction qui transfère le contrôle d’une organisation, ou de substantiellement tous ses actifs, ou la subdivision d’une organisation, ou la fusion de plusieurs organisations. Si la propagation d’un Travail Couvert résulte d’une transaction d’entité, chaque partie à cette transaction qui reçoit une copie du travail reçoit aussi les licences pour le travail que le prédécesseur intéressé à cette partie avait ou pourrait donner selon le paragraphe précédent, plus un droit de possession du Source Correspondant de ce travail depuis le prédécesseur intéressé si ce prédécesseur en dispose ou peut l’obtenir par des efforts raisonnables. Vous ne pouvez imposer aucune restriction avancée dans l’exercice des droits accordés ou affirmés selon cette Licence. Par exemple, vous ne pouvez imposer aucun paiement pour la licence, aucune royaltie, ni aucune autre charge pour l’exercice des droits accordés selon cette Licence ; et vous ne pouvez amorcer aucun litige judiciaire (y compris une réclamation croisée ou contre-réclamation dans un procès) sur l’allégation qu’une revendication de brevet est enfreinte par la réalisation, l’utilisation, la vente, l’offre de vente, ou l’importation du Programme ou d’une quelconque portion de celui-ci. Article 11. Brevets. Un « contributeur » est un titulaire de Droit d’Auteur (“copyright”) qui autorise l’utilisation selon cette Licence du Programme ou du travail sur lequel le Programme est basé. Le travail ainsi soumis à licence est appelé la « version contributive » de ce contributeur. Les « revendications de brevet essentielles » sont toutes les revendications de brevets détenues ou contrôlées par le contributeur, qu’elles soient déjà acquises par lui ou acquises subséquemment, qui pourraient être enfreintes de quelque manière, permises par cette Licence, sur la réalisation, l’utilisation ou la vente de la version contributive de celui-ci. Aux fins de cette définition, le « contrôle » inclue le droit de concéder des sous-licences de brevets d’une manière consistante, nécessaire et suffisante, avec les obligations de cette Licence. Chaque contributeur vous accorde une licence de brevet non exclusive, mondiale et libre de toute royaltie, selon les revendications de brevet essentielles, pour réaliser, utiliser, vendre, offrir à la vente, importer et autrement exécuter, modifier et propager les contenus de sa version contributive. Dans les trois paragraphes suivants, une « licence de brevet » désigne tous les accords ou engagements exprimés, quel que soit le nom que vous lui donnez, de ne pas mettre en vigueur un brevet (telle qu’une permission explicite pour mettre en pratique un brevet, ou un accord pour ne pas poursuivre un Destinataire pour cause de violation de brevet). « Accorder » une telle licence de brevet à une partie signifie conclure un tel accord ou engagement à ne pas faire appliquer le brevet à cette partie. Si vous acheminez un Travail Couvert, dépendant en connaissance d’une licence de brevet, et si le Source Correspondant du travail n’est pas disponible à quiconque copie, sans frais et suivant les termes de cette Licence, à travers un serveur réseau publiquement acessible ou tout autre moyen immédiatement accessible, alors vous devez soit (1) rendre la Source Correspondante ainsi disponible, soit (2) vous engager à vous priver pour vous-même du bénéfice de la licence de brevet pour ce travail particulier, soit (3) vous engager, d’une façon consistante avec les obligations de cette Licence, à étendre la licence de brevet aux Destinataires de ce travail. « Dépendant en connaissance » signifie que vous avez effectivement connaissance que, selon la licence de brevet, votre acheminement du Travail Couvert dans un pays, ou l’utilisation du Travail Couvert par votre Destinataire dans un pays, infreindrait un ou plusieurs brevets identifiables dans ce pays où vous avez des raisons de penser qu’ils sont valides. Si, conformément à ou en liaison avec une même transaction ou un même arrangement, vous acheminez, ou propagez en procurant un acheminement de, un Travail Couvert et accordez une licence de brevet à l’une des parties recevant le Travail Couvert pour lui permettre d’utiliser, propager, modifier ou acheminer une copie spécifique du Travail Couvert, alors votre accord est automatiquement étendu à tous les Destinataires du Travail Couvert et des travaux basés sur celui-ci. Une licence de brevet est « discriminatoire » si, dans le champ de sa couverture, elle n’inclut pas un ou plusieurs des droits qui sont spécifiquement accordés selon cette Licence, ou en prohibe l’exercice, ou est conditionnée par le non-exercice d’un ou plusieurs de ces droits. Vous ne pouvez pas acheminer un Travail Couvert si vous êtes partie à un arrangement selon lequel une partie tierce exerçant son activité dans la distribution de logiciels et à laquelle vous effectuez un paiement fondé sur l’étendue de votre activité d’acheminement du travail, et selon lequel la partie tierce accorde, à une quelconque partie qui recevrait depuis vous le Travail Couvert, une licence de brevet discriminatoire (a) en relation avec les copies du Travail Couvert acheminées par vous (ou les copies réalisées à partir de ces copies), ou (b) avant tout destinée et en relation avec des produits spécifiques ou compilations contenant le Travail Couvert, à moins que vous ayez conclu cet arrangement ou que la licence de brevet ait été accordée avant le 28 mars 2007. Rien dans cette Licence ne devrait être interprété comme devant exclure ou limiter toute licence implicite ou d’autres moyens de défense à une infraction qui vous seraient autrement disponible selon la loi applicable relative aux brevets. Article 12. Non abandon de la liberté des autres. Si des conditions vous sont imposées (que ce soit par décision judiciaire, par un accord ou autrement) qui contredisent les conditions de cette Licence, elles ne vous excusent pas des conditions de cette Licence. Si vous ne pouvez pas acheminer un Travail Couvert de façon à satisfaire simulténément vos obligations suivant cette Licence et toutes autres obligations pertinentes, alors en conséquence vous ne pouvez pas du tout l’acheminer. Par exemple, si vous avez un accord sur des termes qui vous obligent à collecter pour le réacheminement des royalties depuis ceux à qui vous acheminez le Programme, la seule façon qui puisse vous permettre de satisfaire à la fois à ces termes et ceux de cette Licence sera de vous abstenir entièrement d’acheminer le Programme. Article 13. Utilisation avec la Licence Générale Publique Affero GNU. Nonobstant toute autre clause de cette Licence, vous avez la permission de lier ou combiner tout Travail Couvert avec un travail placé sous la version 3 de la Licence Générale Publique GNU Affero (“GNU Affero General Public License”) en un seul travail combiné, et d’acheminer le travail résultant. Les termes de cette Licence continueront à s’appliquer à la partie formant un Travail Couvert, mais les obligations spéciales de la Licence Générale Publique GNU Affero, article 13, concernant l’interaction à travers un réseau s’appliqueront à la combinaison en tant que telle. Article 14. Versions révisées de cette License. La Free Software Foundation peut publier des versions révisées et/ou nouvelles de la Licence Publique Générale GNU (“GNU General Public License”) de temps en temps. De telles version nouvelles resteront similaires dans l’esprit avec la présente version, mais peuvent différer dans le détail afin de traiter de nouveaux problèmes ou préoccupations. Chaque version reçoit un numéro de version distinctif. Si le Programme indique qu’une version spécifique de la Licence Publique Générale GNU « ou toute version ultérieure » (“or any later version”) s’applique à celui-ci, vous avez le choix de suivre soit les termes et conditions de cette version numérotée, soit ceux de n’importe quelle version publiée ultérieurement par la Free Software Foundation. Si le Programme n’indique pas une version spécifique de la Licence Publique Générale GNU, vous pouvez choisir l’une quelconque des versions qui ont été publiées par la Free Software Foundation. Si le Programme spécifie qu’un intermédiaire peut décider quelles versions futures de la Licence Générale Publique GNU peut être utilisée, la déclaration publique d’acceptation d’une version par cet intermédiaire vous autorise à choisir cette version pour le Programme. Des versions ultérieures de la licence peuvent vous donner des permissions additionelles ou différentes. Cependant aucune obligation additionelle n’est imposée à l’un des auteurs ou titulaires de Droit d’Auteur du fait de votre choix de suivre une version ultérieure. Article 15. Déclaration d’absence de garantie. IL N’Y A AUCUNE GARANTIE POUR LE PROGRAMME, DANS LES LIMITES PERMISES PAR LA LOI APPLICABLE. À MOINS QUE CELA NE SOIT ÉTABLI DIFFÉREMMENT PAR ÉCRIT, LES PROPRIÉTAIRES DE DROITS ET/OU LES AUTRES PARTIES FOURNISSENT LE PROGRAMME « EN L’ÉTAT » SANS GARANTIE D’AUCUNE SORTE, QU’ELLE SOIT EXPRIMÉE OU IMPLICITE, CECI COMPRENANT, SANS SE LIMITER À CELLES-CI, LES GARANTIES IMPLICITES DE COMMERCIALISABILITÉ ET D’ADÉQUATION À UN OBJECTIF PARTICULIER. VOUS ASSUMEZ LE RISQUE ENTIER CONCERNANT LA QUALITÉ ET LES PERFORMANCES DU PROGRAMME. DANS L’ÉVENTUALITÉ OÙ LE PROGRAMME S’AVÉRERAIT DÉFECTUEUX, VOUS ASSUMEZ LES COÛTS DE TOUS LES SERVICES, RÉPARATIONS OU CORRECTIONS NÉCESSAIRES. Article 16. Limitation de responsabilité. EN AUCUNE AUTRE CIRCONSTANCE QUE CELLES REQUISES PAR LA LOI APPLICABLE OU ACCORDÉES PAR ÉCRIT, UN TITULAIRE DE DROITS SUR LE PROGRAMME, OU TOUT AUTRE PARTIE QUI MODIFIE OU ACHEMINE LE PROGRAMME COMME PERMIS CI-DESSUS, NE PEUT ÊTRE TENU POUR RESPONSABLE ENVERS VOUS POUR LES DOMMAGES, INCLUANT TOUT DOMMAGE GÉNÉRAL, SPÉCIAL, ACCIDENTEL OU INDUIT SURVENANT PAR SUITE DE L’UTILISATION OU DE L’INCAPACITÉ D’UTILISER LE PROGRAMME (Y COMPRIS, SANS SE LIMITER À CELLES-CI, LA PERTE DE DONNÉES OU L’INEXACTITUDE DES DONNÉES RETOURNÉES OU LES PERTES SUBIES PAR VOUS OU DES PARTIES TIERCES OU L’INCAPACITÉ DU PROGRAMME À FONCTIONNER AVEC TOUT AUTRE PROGRAMME), MÊME SI UN TEL TITULAIRE OU TOUTE AUTRE PARTIE A ÉTÉ AVISÉ DE LA POSSIBILITÉ DE TELS DOMMAGES. Article 17. Interprétation des sections 15 et 16. Si la déclaration d’absence de garantie et la limitation de responsabilité fournies ci-dessus ne peuvent prendre effet localement selon leurs termes, les cours de justice qui les examinent doivent appliquer la législation locale qui approche au plus près possible une levée absolue de toute responsabilité civile liée au Programme, à moins qu’une garantie ou assumation de responsabilité accompagne une copie du Programme en échange d’un paiement. FIN DES TERMES ET CONDITIONS. _______________________________________________________________________ Comment appliquer ces termes à vos nouveaux programmes Si vous développez un nouveau programme et voulez qu’il soit le plus possible utilisable par le public, la meilleure façon d’y parvenir et d’en faire un logiciel libre que chacun peut redistribuer et changer suivant ces termes-ci. Pour appliquer ces termes, attachez les notices suivantes au programme. Il est plus sûr de les attacher au début de chacun des fichiers sources afin de transporter de façon la plus effective possible l’exclusion de garantie ; et chaque fichier devrait comporter au moins la ligne de réservation de droit (“copyright”) et une indication permettant de savoir où la notice complète peut être trouvée : <une ligne donnant le nom du programme et une brève idée de ce qu’il fait.> Copyright (C) <année> <nom de l’auteur> — Tous droits réservés. Ce programme est un logiciel libre ; vous pouvez le redistribuer ou le modifier suivant les termes de la “GNU General Public License” telle que publiée par la Free Software Foundation : soit la version 3 de cette licence, soit (à votre gré) toute version ultérieure. Ce programme est distribué dans l’espoir qu’il vous sera utile, mais SANS AUCUNE GARANTIE : sans même la garantie implicite de COMMERCIALISABILITÉ ni d’ADÉQUATION À UN OBJECTIF PARTICULIER. Consultez la Licence Générale Publique GNU pour plus de détails. Vous devriez avoir reçu une copie de la Licence Générale Publique GNU avec ce programme ; si ce n’est pas le cas, consultez : <http://www.gnu.org/licenses/>. Ajoutez également les informations permettant de vous contacter par courrier électronique ou postal. Si le programme produit une interaction sur un terminal, faites lui afficher une courte notice comme celle-ci lors de son démarrage en mode interactif : <programme> Copyright (C) <année> <nom de l’auteur> Ce programme vient SANS ABSOLUMENT AUCUNE GARANTIE ; taper “affiche g” pour les détails. Ceci est un logiciel libre et vous êtes invité à le redistribuer suivant certaines conditions ; taper “affiche c” pour les détails. Les commandes hypothétiques “affiche g” and “affiche c” devrait afficher les parties appropriées de la Licence Générale Publique. Bien sûr, les commandes de votre programme peuvent être différentes ; pour une interface graphique, vous pourriez utiliser une « boîte À propos. » Vous devriez également obtenir de votre employeur (si vous travaillez en tant que programmeur) ou de votre école un « renoncement aux droits de propriété » pour ce programme, si nécessaire. Pour plus d’informations à ce sujet, et comment appliquer la GPL GNU, consultez <http://www.gnu.org/licenses/>. La Licence Générale Publique GNU ne permet pas d’incorporer votre programme dans des programmes propriétaires. Si votre programme est une bibliothèque de sous-routines, vous pourriez considérer qu’il serait plus utile de permettre de lier des applications propriétaires avec la bibliothèque. Si c’est ce que vous voulez faire, utilisez la Licence Générale Publique Limitée GNU au lieu de cette Licence ; mais d’abord, veuillez lire <http://www.gnu.org/philosophy/why-not-lgpl.html>. _______________________________________________________________________ |
Added LICENSE.txt version [040444d592].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 | GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year> <name of author> This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: <program> Copyright (C) <year> <name of author> This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <http://www.gnu.org/licenses/>. The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read <http://www.gnu.org/philosophy/why-not-lgpl.html>. |
Added README.txt version [43cb1be5f3].
> > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | = GRAMMALECTE = Grammar checker By Olivier R. Website: http://grammalecte.net License: GPL 3 -- http://www.gnu.org/copyleft/gpl.html Grammalecte is a fork of Lightproof from László Németh (nemeth /at/ numbertext /dot/ org) http://cgit.freedesktop.org/libreoffice/lightproof/ Required : Python 3.3 |
Added bottle.py version [edaaf360b0].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 | #!/usr/bin/env python # -*- coding: utf-8 -*- """ Bottle is a fast and simple micro-framework for small web applications. It offers request dispatching (Routes) with url parameter support, templates, a built-in HTTP Server and adapters for many third party WSGI/HTTP-server and template engines - all in a single file and with no dependencies other than the Python Standard Library. Homepage and documentation: http://bottlepy.org/ Copyright (c) 2013, Marcel Hellkamp. License: MIT (see LICENSE for details) """ from __future__ import with_statement __author__ = 'Marcel Hellkamp' __version__ = '0.12.9' __license__ = 'MIT' # The gevent server adapter needs to patch some modules before they are imported # This is why we parse the commandline parameters here but handle them later if __name__ == '__main__': from optparse import OptionParser _cmd_parser = OptionParser(usage="usage: %prog [options] package.module:app") _opt = _cmd_parser.add_option _opt("--version", action="store_true", help="show version number.") _opt("-b", "--bind", metavar="ADDRESS", help="bind socket to ADDRESS.") _opt("-s", "--server", default='wsgiref', help="use SERVER as backend.") _opt("-p", "--plugin", action="append", help="install additional plugin/s.") _opt("--debug", action="store_true", help="start server in debug mode.") _opt("--reload", action="store_true", help="auto-reload on file changes.") _cmd_options, _cmd_args = _cmd_parser.parse_args() if _cmd_options.server and _cmd_options.server.startswith('gevent'): import gevent.monkey; gevent.monkey.patch_all() import base64, cgi, email.utils, functools, hmac, imp, itertools, mimetypes,\ os, re, subprocess, sys, tempfile, threading, time, warnings from datetime import date as datedate, datetime, timedelta from tempfile import TemporaryFile from traceback import format_exc, print_exc from inspect import getargspec from unicodedata import normalize try: from simplejson import dumps as json_dumps, loads as json_lds except ImportError: # pragma: no cover try: from json import dumps as json_dumps, loads as json_lds except ImportError: try: from django.utils.simplejson import dumps as json_dumps, loads as json_lds except ImportError: def json_dumps(data): raise ImportError("JSON support requires Python 2.6 or simplejson.") json_lds = json_dumps # We now try to fix 2.5/2.6/3.1/3.2 incompatibilities. # It ain't pretty but it works... Sorry for the mess. py = sys.version_info py3k = py >= (3, 0, 0) py25 = py < (2, 6, 0) py31 = (3, 1, 0) <= py < (3, 2, 0) # Workaround for the missing "as" keyword in py3k. def _e(): return sys.exc_info()[1] # Workaround for the "print is a keyword/function" Python 2/3 dilemma # and a fallback for mod_wsgi (resticts stdout/err attribute access) try: _stdout, _stderr = sys.stdout.write, sys.stderr.write except IOError: _stdout = lambda x: sys.stdout.write(x) _stderr = lambda x: sys.stderr.write(x) # Lots of stdlib and builtin differences. if py3k: import http.client as httplib import _thread as thread from urllib.parse import urljoin, SplitResult as UrlSplitResult from urllib.parse import urlencode, quote as urlquote, unquote as urlunquote urlunquote = functools.partial(urlunquote, encoding='latin1') from http.cookies import SimpleCookie from collections import MutableMapping as DictMixin import pickle from io import BytesIO from configparser import ConfigParser basestring = str unicode = str json_loads = lambda s: json_lds(touni(s)) callable = lambda x: hasattr(x, '__call__') imap = map def _raise(*a): raise a[0](a[1]).with_traceback(a[2]) else: # 2.x import httplib import thread from urlparse import urljoin, SplitResult as UrlSplitResult from urllib import urlencode, quote as urlquote, unquote as urlunquote from Cookie import SimpleCookie from itertools import imap import cPickle as pickle from StringIO import StringIO as BytesIO from ConfigParser import SafeConfigParser as ConfigParser if py25: msg = "Python 2.5 support may be dropped in future versions of Bottle." warnings.warn(msg, DeprecationWarning) from UserDict import DictMixin def next(it): return it.next() bytes = str else: # 2.6, 2.7 from collections import MutableMapping as DictMixin unicode = unicode json_loads = json_lds eval(compile('def _raise(*a): raise a[0], a[1], a[2]', '<py3fix>', 'exec')) # Some helpers for string/byte handling def tob(s, enc='utf8'): return s.encode(enc) if isinstance(s, unicode) else bytes(s) def touni(s, enc='utf8', err='strict'): return s.decode(enc, err) if isinstance(s, bytes) else unicode(s) tonat = touni if py3k else tob # 3.2 fixes cgi.FieldStorage to accept bytes (which makes a lot of sense). # 3.1 needs a workaround. if py31: from io import TextIOWrapper class NCTextIOWrapper(TextIOWrapper): def close(self): pass # Keep wrapped buffer open. # A bug in functools causes it to break if the wrapper is an instance method def update_wrapper(wrapper, wrapped, *a, **ka): try: functools.update_wrapper(wrapper, wrapped, *a, **ka) except AttributeError: pass # These helpers are used at module level and need to be defined first. # And yes, I know PEP-8, but sometimes a lower-case classname makes more sense. def depr(message, hard=False): warnings.warn(message, DeprecationWarning, stacklevel=3) def makelist(data): # This is just to handy if isinstance(data, (tuple, list, set, dict)): return list(data) elif data: return [data] else: return [] class DictProperty(object): ''' Property that maps to a key in a local dict-like attribute. ''' def __init__(self, attr, key=None, read_only=False): self.attr, self.key, self.read_only = attr, key, read_only def __call__(self, func): functools.update_wrapper(self, func, updated=[]) self.getter, self.key = func, self.key or func.__name__ return self def __get__(self, obj, cls): if obj is None: return self key, storage = self.key, getattr(obj, self.attr) if key not in storage: storage[key] = self.getter(obj) return storage[key] def __set__(self, obj, value): if self.read_only: raise AttributeError("Read-Only property.") getattr(obj, self.attr)[self.key] = value def __delete__(self, obj): if self.read_only: raise AttributeError("Read-Only property.") del getattr(obj, self.attr)[self.key] class cached_property(object): ''' A property that is only computed once per instance and then replaces itself with an ordinary attribute. Deleting the attribute resets the property. ''' def __init__(self, func): self.__doc__ = getattr(func, '__doc__') self.func = func def __get__(self, obj, cls): if obj is None: return self value = obj.__dict__[self.func.__name__] = self.func(obj) return value class lazy_attribute(object): ''' A property that caches itself to the class object. ''' def __init__(self, func): functools.update_wrapper(self, func, updated=[]) self.getter = func def __get__(self, obj, cls): value = self.getter(cls) setattr(cls, self.__name__, value) return value ############################################################################### # Exceptions and Events ######################################################## ############################################################################### class BottleException(Exception): """ A base class for exceptions used by bottle. """ pass ############################################################################### # Routing ###################################################################### ############################################################################### class RouteError(BottleException): """ This is a base class for all routing related exceptions """ class RouteReset(BottleException): """ If raised by a plugin or request handler, the route is reset and all plugins are re-applied. """ class RouterUnknownModeError(RouteError): pass class RouteSyntaxError(RouteError): """ The route parser found something not supported by this router. """ class RouteBuildError(RouteError): """ The route could not be built. """ def _re_flatten(p): ''' Turn all capturing groups in a regular expression pattern into non-capturing groups. ''' if '(' not in p: return p return re.sub(r'(\\*)(\(\?P<[^>]+>|\((?!\?))', lambda m: m.group(0) if len(m.group(1)) % 2 else m.group(1) + '(?:', p) class Router(object): ''' A Router is an ordered collection of route->target pairs. It is used to efficiently match WSGI requests against a number of routes and return the first target that satisfies the request. The target may be anything, usually a string, ID or callable object. A route consists of a path-rule and a HTTP method. The path-rule is either a static path (e.g. `/contact`) or a dynamic path that contains wildcards (e.g. `/wiki/<page>`). The wildcard syntax and details on the matching order are described in docs:`routing`. ''' default_pattern = '[^/]+' default_filter = 're' #: The current CPython regexp implementation does not allow more #: than 99 matching groups per regular expression. _MAX_GROUPS_PER_PATTERN = 99 def __init__(self, strict=False): self.rules = [] # All rules in order self._groups = {} # index of regexes to find them in dyna_routes self.builder = {} # Data structure for the url builder self.static = {} # Search structure for static routes self.dyna_routes = {} self.dyna_regexes = {} # Search structure for dynamic routes #: If true, static routes are no longer checked first. self.strict_order = strict self.filters = { 're': lambda conf: (_re_flatten(conf or self.default_pattern), None, None), 'int': lambda conf: (r'-?\d+', int, lambda x: str(int(x))), 'float': lambda conf: (r'-?[\d.]+', float, lambda x: str(float(x))), 'path': lambda conf: (r'.+?', None, None)} def add_filter(self, name, func): ''' Add a filter. The provided function is called with the configuration string as parameter and must return a (regexp, to_python, to_url) tuple. The first element is a string, the last two are callables or None. ''' self.filters[name] = func rule_syntax = re.compile('(\\\\*)'\ '(?:(?::([a-zA-Z_][a-zA-Z_0-9]*)?()(?:#(.*?)#)?)'\ '|(?:<([a-zA-Z_][a-zA-Z_0-9]*)?(?::([a-zA-Z_]*)'\ '(?::((?:\\\\.|[^\\\\>]+)+)?)?)?>))') def _itertokens(self, rule): offset, prefix = 0, '' for match in self.rule_syntax.finditer(rule): prefix += rule[offset:match.start()] g = match.groups() if len(g[0])%2: # Escaped wildcard prefix += match.group(0)[len(g[0]):] offset = match.end() continue if prefix: yield prefix, None, None name, filtr, conf = g[4:7] if g[2] is None else g[1:4] yield name, filtr or 'default', conf or None offset, prefix = match.end(), '' if offset <= len(rule) or prefix: yield prefix+rule[offset:], None, None def add(self, rule, method, target, name=None): ''' Add a new rule or replace the target for an existing rule. ''' anons = 0 # Number of anonymous wildcards found keys = [] # Names of keys pattern = '' # Regular expression pattern with named groups filters = [] # Lists of wildcard input filters builder = [] # Data structure for the URL builder is_static = True for key, mode, conf in self._itertokens(rule): if mode: is_static = False if mode == 'default': mode = self.default_filter mask, in_filter, out_filter = self.filters[mode](conf) if not key: pattern += '(?:%s)' % mask key = 'anon%d' % anons anons += 1 else: pattern += '(?P<%s>%s)' % (key, mask) keys.append(key) if in_filter: filters.append((key, in_filter)) builder.append((key, out_filter or str)) elif key: pattern += re.escape(key) builder.append((None, key)) self.builder[rule] = builder if name: self.builder[name] = builder if is_static and not self.strict_order: self.static.setdefault(method, {}) self.static[method][self.build(rule)] = (target, None) return try: re_pattern = re.compile('^(%s)$' % pattern) re_match = re_pattern.match except re.error: raise RouteSyntaxError("Could not add Route: %s (%s)" % (rule, _e())) if filters: def getargs(path): url_args = re_match(path).groupdict() for name, wildcard_filter in filters: try: url_args[name] = wildcard_filter(url_args[name]) except ValueError: raise HTTPError(400, 'Path has wrong format.') return url_args elif re_pattern.groupindex: def getargs(path): return re_match(path).groupdict() else: getargs = None flatpat = _re_flatten(pattern) whole_rule = (rule, flatpat, target, getargs) if (flatpat, method) in self._groups: if DEBUG: msg = 'Route <%s %s> overwrites a previously defined route' warnings.warn(msg % (method, rule), RuntimeWarning) self.dyna_routes[method][self._groups[flatpat, method]] = whole_rule else: self.dyna_routes.setdefault(method, []).append(whole_rule) self._groups[flatpat, method] = len(self.dyna_routes[method]) - 1 self._compile(method) def _compile(self, method): all_rules = self.dyna_routes[method] comborules = self.dyna_regexes[method] = [] maxgroups = self._MAX_GROUPS_PER_PATTERN for x in range(0, len(all_rules), maxgroups): some = all_rules[x:x+maxgroups] combined = (flatpat for (_, flatpat, _, _) in some) combined = '|'.join('(^%s$)' % flatpat for flatpat in combined) combined = re.compile(combined).match rules = [(target, getargs) for (_, _, target, getargs) in some] comborules.append((combined, rules)) def build(self, _name, *anons, **query): ''' Build an URL by filling the wildcards in a rule. ''' builder = self.builder.get(_name) if not builder: raise RouteBuildError("No route with that name.", _name) try: for i, value in enumerate(anons): query['anon%d'%i] = value url = ''.join([f(query.pop(n)) if n else f for (n,f) in builder]) return url if not query else url+'?'+urlencode(query) except KeyError: raise RouteBuildError('Missing URL argument: %r' % _e().args[0]) def match(self, environ): ''' Return a (target, url_agrs) tuple or raise HTTPError(400/404/405). ''' verb = environ['REQUEST_METHOD'].upper() path = environ['PATH_INFO'] or '/' target = None if verb == 'HEAD': methods = ['PROXY', verb, 'GET', 'ANY'] else: methods = ['PROXY', verb, 'ANY'] for method in methods: if method in self.static and path in self.static[method]: target, getargs = self.static[method][path] return target, getargs(path) if getargs else {} elif method in self.dyna_regexes: for combined, rules in self.dyna_regexes[method]: match = combined(path) if match: target, getargs = rules[match.lastindex - 1] return target, getargs(path) if getargs else {} # No matching route found. Collect alternative methods for 405 response allowed = set([]) nocheck = set(methods) for method in set(self.static) - nocheck: if path in self.static[method]: allowed.add(verb) for method in set(self.dyna_regexes) - allowed - nocheck: for combined, rules in self.dyna_regexes[method]: match = combined(path) if match: allowed.add(method) if allowed: allow_header = ",".join(sorted(allowed)) raise HTTPError(405, "Method not allowed.", Allow=allow_header) # No matching route and no alternative method found. We give up raise HTTPError(404, "Not found: " + repr(path)) class Route(object): ''' This class wraps a route callback along with route specific metadata and configuration and applies Plugins on demand. It is also responsible for turing an URL path rule into a regular expression usable by the Router. ''' def __init__(self, app, rule, method, callback, name=None, plugins=None, skiplist=None, **config): #: The application this route is installed to. self.app = app #: The path-rule string (e.g. ``/wiki/:page``). self.rule = rule #: The HTTP method as a string (e.g. ``GET``). self.method = method #: The original callback with no plugins applied. Useful for introspection. self.callback = callback #: The name of the route (if specified) or ``None``. self.name = name or None #: A list of route-specific plugins (see :meth:`Bottle.route`). self.plugins = plugins or [] #: A list of plugins to not apply to this route (see :meth:`Bottle.route`). self.skiplist = skiplist or [] #: Additional keyword arguments passed to the :meth:`Bottle.route` #: decorator are stored in this dictionary. Used for route-specific #: plugin configuration and meta-data. self.config = ConfigDict().load_dict(config, make_namespaces=True) def __call__(self, *a, **ka): depr("Some APIs changed to return Route() instances instead of"\ " callables. Make sure to use the Route.call method and not to"\ " call Route instances directly.") #0.12 return self.call(*a, **ka) @cached_property def call(self): ''' The route callback with all plugins applied. This property is created on demand and then cached to speed up subsequent requests.''' return self._make_callback() def reset(self): ''' Forget any cached values. The next time :attr:`call` is accessed, all plugins are re-applied. ''' self.__dict__.pop('call', None) def prepare(self): ''' Do all on-demand work immediately (useful for debugging).''' self.call @property def _context(self): depr('Switch to Plugin API v2 and access the Route object directly.') #0.12 return dict(rule=self.rule, method=self.method, callback=self.callback, name=self.name, app=self.app, config=self.config, apply=self.plugins, skip=self.skiplist) def all_plugins(self): ''' Yield all Plugins affecting this route. ''' unique = set() for p in reversed(self.app.plugins + self.plugins): if True in self.skiplist: break name = getattr(p, 'name', False) if name and (name in self.skiplist or name in unique): continue if p in self.skiplist or type(p) in self.skiplist: continue if name: unique.add(name) yield p def _make_callback(self): callback = self.callback for plugin in self.all_plugins(): try: if hasattr(plugin, 'apply'): api = getattr(plugin, 'api', 1) context = self if api > 1 else self._context callback = plugin.apply(callback, context) else: callback = plugin(callback) except RouteReset: # Try again with changed configuration. return self._make_callback() if not callback is self.callback: update_wrapper(callback, self.callback) return callback def get_undecorated_callback(self): ''' Return the callback. If the callback is a decorated function, try to recover the original function. ''' func = self.callback func = getattr(func, '__func__' if py3k else 'im_func', func) closure_attr = '__closure__' if py3k else 'func_closure' while hasattr(func, closure_attr) and getattr(func, closure_attr): func = getattr(func, closure_attr)[0].cell_contents return func def get_callback_args(self): ''' Return a list of argument names the callback (most likely) accepts as keyword arguments. If the callback is a decorated function, try to recover the original function before inspection. ''' return getargspec(self.get_undecorated_callback())[0] def get_config(self, key, default=None): ''' Lookup a config field and return its value, first checking the route.config, then route.app.config.''' for conf in (self.config, self.app.conifg): if key in conf: return conf[key] return default def __repr__(self): cb = self.get_undecorated_callback() return '<%s %r %r>' % (self.method, self.rule, cb) ############################################################################### # Application Object ########################################################### ############################################################################### class Bottle(object): """ Each Bottle object represents a single, distinct web application and consists of routes, callbacks, plugins, resources and configuration. Instances are callable WSGI applications. :param catchall: If true (default), handle all exceptions. Turn off to let debugging middleware handle exceptions. """ def __init__(self, catchall=True, autojson=True): #: A :class:`ConfigDict` for app specific configuration. self.config = ConfigDict() self.config._on_change = functools.partial(self.trigger_hook, 'config') self.config.meta_set('autojson', 'validate', bool) self.config.meta_set('catchall', 'validate', bool) self.config['catchall'] = catchall self.config['autojson'] = autojson #: A :class:`ResourceManager` for application files self.resources = ResourceManager() self.routes = [] # List of installed :class:`Route` instances. self.router = Router() # Maps requests to :class:`Route` instances. self.error_handler = {} # Core plugins self.plugins = [] # List of installed plugins. if self.config['autojson']: self.install(JSONPlugin()) self.install(TemplatePlugin()) #: If true, most exceptions are caught and returned as :exc:`HTTPError` catchall = DictProperty('config', 'catchall') __hook_names = 'before_request', 'after_request', 'app_reset', 'config' __hook_reversed = 'after_request' @cached_property def _hooks(self): return dict((name, []) for name in self.__hook_names) def add_hook(self, name, func): ''' Attach a callback to a hook. Three hooks are currently implemented: before_request Executed once before each request. The request context is available, but no routing has happened yet. after_request Executed once after each request regardless of its outcome. app_reset Called whenever :meth:`Bottle.reset` is called. ''' if name in self.__hook_reversed: self._hooks[name].insert(0, func) else: self._hooks[name].append(func) def remove_hook(self, name, func): ''' Remove a callback from a hook. ''' if name in self._hooks and func in self._hooks[name]: self._hooks[name].remove(func) return True def trigger_hook(self, __name, *args, **kwargs): ''' Trigger a hook and return a list of results. ''' return [hook(*args, **kwargs) for hook in self._hooks[__name][:]] def hook(self, name): """ Return a decorator that attaches a callback to a hook. See :meth:`add_hook` for details.""" def decorator(func): self.add_hook(name, func) return func return decorator def mount(self, prefix, app, **options): ''' Mount an application (:class:`Bottle` or plain WSGI) to a specific URL prefix. Example:: root_app.mount('/admin/', admin_app) :param prefix: path prefix or `mount-point`. If it ends in a slash, that slash is mandatory. :param app: an instance of :class:`Bottle` or a WSGI application. All other parameters are passed to the underlying :meth:`route` call. ''' if isinstance(app, basestring): depr('Parameter order of Bottle.mount() changed.', True) # 0.10 segments = [p for p in prefix.split('/') if p] if not segments: raise ValueError('Empty path prefix.') path_depth = len(segments) def mountpoint_wrapper(): try: request.path_shift(path_depth) rs = HTTPResponse([]) def start_response(status, headerlist, exc_info=None): if exc_info: try: _raise(*exc_info) finally: exc_info = None rs.status = status for name, value in headerlist: rs.add_header(name, value) return rs.body.append body = app(request.environ, start_response) if body and rs.body: body = itertools.chain(rs.body, body) rs.body = body or rs.body return rs finally: request.path_shift(-path_depth) options.setdefault('skip', True) options.setdefault('method', 'PROXY') options.setdefault('mountpoint', {'prefix': prefix, 'target': app}) options['callback'] = mountpoint_wrapper self.route('/%s/<:re:.*>' % '/'.join(segments), **options) if not prefix.endswith('/'): self.route('/' + '/'.join(segments), **options) def merge(self, routes): ''' Merge the routes of another :class:`Bottle` application or a list of :class:`Route` objects into this application. The routes keep their 'owner', meaning that the :data:`Route.app` attribute is not changed. ''' if isinstance(routes, Bottle): routes = routes.routes for route in routes: self.add_route(route) def install(self, plugin): ''' Add a plugin to the list of plugins and prepare it for being applied to all routes of this application. A plugin may be a simple decorator or an object that implements the :class:`Plugin` API. ''' if hasattr(plugin, 'setup'): plugin.setup(self) if not callable(plugin) and not hasattr(plugin, 'apply'): raise TypeError("Plugins must be callable or implement .apply()") self.plugins.append(plugin) self.reset() return plugin def uninstall(self, plugin): ''' Uninstall plugins. Pass an instance to remove a specific plugin, a type object to remove all plugins that match that type, a string to remove all plugins with a matching ``name`` attribute or ``True`` to remove all plugins. Return the list of removed plugins. ''' removed, remove = [], plugin for i, plugin in list(enumerate(self.plugins))[::-1]: if remove is True or remove is plugin or remove is type(plugin) \ or getattr(plugin, 'name', True) == remove: removed.append(plugin) del self.plugins[i] if hasattr(plugin, 'close'): plugin.close() if removed: self.reset() return removed def reset(self, route=None): ''' Reset all routes (force plugins to be re-applied) and clear all caches. If an ID or route object is given, only that specific route is affected. ''' if route is None: routes = self.routes elif isinstance(route, Route): routes = [route] else: routes = [self.routes[route]] for route in routes: route.reset() if DEBUG: for route in routes: route.prepare() self.trigger_hook('app_reset') def close(self): ''' Close the application and all installed plugins. ''' for plugin in self.plugins: if hasattr(plugin, 'close'): plugin.close() self.stopped = True def run(self, **kwargs): ''' Calls :func:`run` with the same parameters. ''' run(self, **kwargs) def match(self, environ): """ Search for a matching route and return a (:class:`Route` , urlargs) tuple. The second value is a dictionary with parameters extracted from the URL. Raise :exc:`HTTPError` (404/405) on a non-match.""" return self.router.match(environ) def get_url(self, routename, **kargs): """ Return a string that matches a named route """ scriptname = request.environ.get('SCRIPT_NAME', '').strip('/') + '/' location = self.router.build(routename, **kargs).lstrip('/') return urljoin(urljoin('/', scriptname), location) def add_route(self, route): ''' Add a route object, but do not change the :data:`Route.app` attribute.''' self.routes.append(route) self.router.add(route.rule, route.method, route, name=route.name) if DEBUG: route.prepare() def route(self, path=None, method='GET', callback=None, name=None, apply=None, skip=None, **config): """ A decorator to bind a function to a request URL. Example:: @app.route('/hello/:name') def hello(name): return 'Hello %s' % name The ``:name`` part is a wildcard. See :class:`Router` for syntax details. :param path: Request path or a list of paths to listen to. If no path is specified, it is automatically generated from the signature of the function. :param method: HTTP method (`GET`, `POST`, `PUT`, ...) or a list of methods to listen to. (default: `GET`) :param callback: An optional shortcut to avoid the decorator syntax. ``route(..., callback=func)`` equals ``route(...)(func)`` :param name: The name for this route. (default: None) :param apply: A decorator or plugin or a list of plugins. These are applied to the route callback in addition to installed plugins. :param skip: A list of plugins, plugin classes or names. Matching plugins are not installed to this route. ``True`` skips all. Any additional keyword arguments are stored as route-specific configuration and passed to plugins (see :meth:`Plugin.apply`). """ if callable(path): path, callback = None, path plugins = makelist(apply) skiplist = makelist(skip) def decorator(callback): # TODO: Documentation and tests if isinstance(callback, basestring): callback = load(callback) for rule in makelist(path) or yieldroutes(callback): for verb in makelist(method): verb = verb.upper() route = Route(self, rule, verb, callback, name=name, plugins=plugins, skiplist=skiplist, **config) self.add_route(route) return callback return decorator(callback) if callback else decorator def get(self, path=None, method='GET', **options): """ Equals :meth:`route`. """ return self.route(path, method, **options) def post(self, path=None, method='POST', **options): """ Equals :meth:`route` with a ``POST`` method parameter. """ return self.route(path, method, **options) def put(self, path=None, method='PUT', **options): """ Equals :meth:`route` with a ``PUT`` method parameter. """ return self.route(path, method, **options) def delete(self, path=None, method='DELETE', **options): """ Equals :meth:`route` with a ``DELETE`` method parameter. """ return self.route(path, method, **options) def error(self, code=500): """ Decorator: Register an output handler for a HTTP error code""" def wrapper(handler): self.error_handler[int(code)] = handler return handler return wrapper def default_error_handler(self, res): return tob(template(ERROR_PAGE_TEMPLATE, e=res)) def _handle(self, environ): path = environ['bottle.raw_path'] = environ['PATH_INFO'] if py3k: try: environ['PATH_INFO'] = path.encode('latin1').decode('utf8') except UnicodeError: return HTTPError(400, 'Invalid path string. Expected UTF-8') try: environ['bottle.app'] = self request.bind(environ) response.bind() try: self.trigger_hook('before_request') route, args = self.router.match(environ) environ['route.handle'] = route environ['bottle.route'] = route environ['route.url_args'] = args return route.call(**args) finally: self.trigger_hook('after_request') except HTTPResponse: return _e() except RouteReset: route.reset() return self._handle(environ) except (KeyboardInterrupt, SystemExit, MemoryError): raise except Exception: if not self.catchall: raise stacktrace = format_exc() environ['wsgi.errors'].write(stacktrace) return HTTPError(500, "Internal Server Error", _e(), stacktrace) def _cast(self, out, peek=None): """ Try to convert the parameter into something WSGI compatible and set correct HTTP headers when possible. Support: False, str, unicode, dict, HTTPResponse, HTTPError, file-like, iterable of strings and iterable of unicodes """ # Empty output is done here if not out: if 'Content-Length' not in response: response['Content-Length'] = 0 return [] # Join lists of byte or unicode strings. Mixed lists are NOT supported if isinstance(out, (tuple, list))\ and isinstance(out[0], (bytes, unicode)): out = out[0][0:0].join(out) # b'abc'[0:0] -> b'' # Encode unicode strings if isinstance(out, unicode): out = out.encode(response.charset) # Byte Strings are just returned if isinstance(out, bytes): if 'Content-Length' not in response: response['Content-Length'] = len(out) return [out] # HTTPError or HTTPException (recursive, because they may wrap anything) # TODO: Handle these explicitly in handle() or make them iterable. if isinstance(out, HTTPError): out.apply(response) out = self.error_handler.get(out.status_code, self.default_error_handler)(out) return self._cast(out) if isinstance(out, HTTPResponse): out.apply(response) return self._cast(out.body) # File-like objects. if hasattr(out, 'read'): if 'wsgi.file_wrapper' in request.environ: return request.environ['wsgi.file_wrapper'](out) elif hasattr(out, 'close') or not hasattr(out, '__iter__'): return WSGIFileWrapper(out) # Handle Iterables. We peek into them to detect their inner type. try: iout = iter(out) first = next(iout) while not first: first = next(iout) except StopIteration: return self._cast('') except HTTPResponse: first = _e() except (KeyboardInterrupt, SystemExit, MemoryError): raise except Exception: if not self.catchall: raise first = HTTPError(500, 'Unhandled exception', _e(), format_exc()) # These are the inner types allowed in iterator or generator objects. if isinstance(first, HTTPResponse): return self._cast(first) elif isinstance(first, bytes): new_iter = itertools.chain([first], iout) elif isinstance(first, unicode): encoder = lambda x: x.encode(response.charset) new_iter = imap(encoder, itertools.chain([first], iout)) else: msg = 'Unsupported response type: %s' % type(first) return self._cast(HTTPError(500, msg)) if hasattr(out, 'close'): new_iter = _closeiter(new_iter, out.close) return new_iter def wsgi(self, environ, start_response): """ The bottle WSGI-interface. """ try: out = self._cast(self._handle(environ)) # rfc2616 section 4.3 if response._status_code in (100, 101, 204, 304)\ or environ['REQUEST_METHOD'] == 'HEAD': if hasattr(out, 'close'): out.close() out = [] start_response(response._status_line, response.headerlist) return out except (KeyboardInterrupt, SystemExit, MemoryError): raise except Exception: if not self.catchall: raise err = '<h1>Critical error while processing request: %s</h1>' \ % html_escape(environ.get('PATH_INFO', '/')) if DEBUG: err += '<h2>Error:</h2>\n<pre>\n%s\n</pre>\n' \ '<h2>Traceback:</h2>\n<pre>\n%s\n</pre>\n' \ % (html_escape(repr(_e())), html_escape(format_exc())) environ['wsgi.errors'].write(err) headers = [('Content-Type', 'text/html; charset=UTF-8')] start_response('500 INTERNAL SERVER ERROR', headers, sys.exc_info()) return [tob(err)] def __call__(self, environ, start_response): ''' Each instance of :class:'Bottle' is a WSGI application. ''' return self.wsgi(environ, start_response) ############################################################################### # HTTP and WSGI Tools ########################################################## ############################################################################### class BaseRequest(object): """ A wrapper for WSGI environment dictionaries that adds a lot of convenient access methods and properties. Most of them are read-only. Adding new attributes to a request actually adds them to the environ dictionary (as 'bottle.request.ext.<name>'). This is the recommended way to store and access request-specific data. """ __slots__ = ('environ') #: Maximum size of memory buffer for :attr:`body` in bytes. MEMFILE_MAX = 102400 def __init__(self, environ=None): """ Wrap a WSGI environ dictionary. """ #: The wrapped WSGI environ dictionary. This is the only real attribute. #: All other attributes actually are read-only properties. self.environ = {} if environ is None else environ self.environ['bottle.request'] = self @DictProperty('environ', 'bottle.app', read_only=True) def app(self): ''' Bottle application handling this request. ''' raise RuntimeError('This request is not connected to an application.') @DictProperty('environ', 'bottle.route', read_only=True) def route(self): """ The bottle :class:`Route` object that matches this request. """ raise RuntimeError('This request is not connected to a route.') @DictProperty('environ', 'route.url_args', read_only=True) def url_args(self): """ The arguments extracted from the URL. """ raise RuntimeError('This request is not connected to a route.') @property def path(self): ''' The value of ``PATH_INFO`` with exactly one prefixed slash (to fix broken clients and avoid the "empty path" edge case). ''' return '/' + self.environ.get('PATH_INFO','').lstrip('/') @property def method(self): ''' The ``REQUEST_METHOD`` value as an uppercase string. ''' return self.environ.get('REQUEST_METHOD', 'GET').upper() @DictProperty('environ', 'bottle.request.headers', read_only=True) def headers(self): ''' A :class:`WSGIHeaderDict` that provides case-insensitive access to HTTP request headers. ''' return WSGIHeaderDict(self.environ) def get_header(self, name, default=None): ''' Return the value of a request header, or a given default value. ''' return self.headers.get(name, default) @DictProperty('environ', 'bottle.request.cookies', read_only=True) def cookies(self): """ Cookies parsed into a :class:`FormsDict`. Signed cookies are NOT decoded. Use :meth:`get_cookie` if you expect signed cookies. """ cookies = SimpleCookie(self.environ.get('HTTP_COOKIE','')).values() return FormsDict((c.key, c.value) for c in cookies) def get_cookie(self, key, default=None, secret=None): """ Return the content of a cookie. To read a `Signed Cookie`, the `secret` must match the one used to create the cookie (see :meth:`BaseResponse.set_cookie`). If anything goes wrong (missing cookie or wrong signature), return a default value. """ value = self.cookies.get(key) if secret and value: dec = cookie_decode(value, secret) # (key, value) tuple or None return dec[1] if dec and dec[0] == key else default return value or default @DictProperty('environ', 'bottle.request.query', read_only=True) def query(self): ''' The :attr:`query_string` parsed into a :class:`FormsDict`. These values are sometimes called "URL arguments" or "GET parameters", but not to be confused with "URL wildcards" as they are provided by the :class:`Router`. ''' get = self.environ['bottle.get'] = FormsDict() pairs = _parse_qsl(self.environ.get('QUERY_STRING', '')) for key, value in pairs: get[key] = value return get @DictProperty('environ', 'bottle.request.forms', read_only=True) def forms(self): """ Form values parsed from an `url-encoded` or `multipart/form-data` encoded POST or PUT request body. The result is returned as a :class:`FormsDict`. All keys and values are strings. File uploads are stored separately in :attr:`files`. """ forms = FormsDict() for name, item in self.POST.allitems(): if not isinstance(item, FileUpload): forms[name] = item return forms @DictProperty('environ', 'bottle.request.params', read_only=True) def params(self): """ A :class:`FormsDict` with the combined values of :attr:`query` and :attr:`forms`. File uploads are stored in :attr:`files`. """ params = FormsDict() for key, value in self.query.allitems(): params[key] = value for key, value in self.forms.allitems(): params[key] = value return params @DictProperty('environ', 'bottle.request.files', read_only=True) def files(self): """ File uploads parsed from `multipart/form-data` encoded POST or PUT request body. The values are instances of :class:`FileUpload`. """ files = FormsDict() for name, item in self.POST.allitems(): if isinstance(item, FileUpload): files[name] = item return files @DictProperty('environ', 'bottle.request.json', read_only=True) def json(self): ''' If the ``Content-Type`` header is ``application/json``, this property holds the parsed content of the request body. Only requests smaller than :attr:`MEMFILE_MAX` are processed to avoid memory exhaustion. ''' ctype = self.environ.get('CONTENT_TYPE', '').lower().split(';')[0] if ctype == 'application/json': b = self._get_body_string() if not b: return None return json_loads(b) return None def _iter_body(self, read, bufsize): maxread = max(0, self.content_length) while maxread: part = read(min(maxread, bufsize)) if not part: break yield part maxread -= len(part) def _iter_chunked(self, read, bufsize): err = HTTPError(400, 'Error while parsing chunked transfer body.') rn, sem, bs = tob('\r\n'), tob(';'), tob('') while True: header = read(1) while header[-2:] != rn: c = read(1) header += c if not c: raise err if len(header) > bufsize: raise err size, _, _ = header.partition(sem) try: maxread = int(tonat(size.strip()), 16) except ValueError: raise err if maxread == 0: break buff = bs while maxread > 0: if not buff: buff = read(min(maxread, bufsize)) part, buff = buff[:maxread], buff[maxread:] if not part: raise err yield part maxread -= len(part) if read(2) != rn: raise err @DictProperty('environ', 'bottle.request.body', read_only=True) def _body(self): body_iter = self._iter_chunked if self.chunked else self._iter_body read_func = self.environ['wsgi.input'].read body, body_size, is_temp_file = BytesIO(), 0, False for part in body_iter(read_func, self.MEMFILE_MAX): body.write(part) body_size += len(part) if not is_temp_file and body_size > self.MEMFILE_MAX: body, tmp = TemporaryFile(mode='w+b'), body body.write(tmp.getvalue()) del tmp is_temp_file = True self.environ['wsgi.input'] = body body.seek(0) return body def _get_body_string(self): ''' read body until content-length or MEMFILE_MAX into a string. Raise HTTPError(413) on requests that are to large. ''' clen = self.content_length if clen > self.MEMFILE_MAX: raise HTTPError(413, 'Request to large') if clen < 0: clen = self.MEMFILE_MAX + 1 data = self.body.read(clen) if len(data) > self.MEMFILE_MAX: # Fail fast raise HTTPError(413, 'Request to large') return data @property def body(self): """ The HTTP request body as a seek-able file-like object. Depending on :attr:`MEMFILE_MAX`, this is either a temporary file or a :class:`io.BytesIO` instance. Accessing this property for the first time reads and replaces the ``wsgi.input`` environ variable. Subsequent accesses just do a `seek(0)` on the file object. """ self._body.seek(0) return self._body @property def chunked(self): ''' True if Chunked transfer encoding was. ''' return 'chunked' in self.environ.get('HTTP_TRANSFER_ENCODING', '').lower() #: An alias for :attr:`query`. GET = query @DictProperty('environ', 'bottle.request.post', read_only=True) def POST(self): """ The values of :attr:`forms` and :attr:`files` combined into a single :class:`FormsDict`. Values are either strings (form values) or instances of :class:`cgi.FieldStorage` (file uploads). """ post = FormsDict() # We default to application/x-www-form-urlencoded for everything that # is not multipart and take the fast path (also: 3.1 workaround) if not self.content_type.startswith('multipart/'): pairs = _parse_qsl(tonat(self._get_body_string(), 'latin1')) for key, value in pairs: post[key] = value return post safe_env = {'QUERY_STRING':''} # Build a safe environment for cgi for key in ('REQUEST_METHOD', 'CONTENT_TYPE', 'CONTENT_LENGTH'): if key in self.environ: safe_env[key] = self.environ[key] args = dict(fp=self.body, environ=safe_env, keep_blank_values=True) if py31: args['fp'] = NCTextIOWrapper(args['fp'], encoding='utf8', newline='\n') elif py3k: args['encoding'] = 'utf8' data = cgi.FieldStorage(**args) self['_cgi.FieldStorage'] = data #http://bugs.python.org/issue18394#msg207958 data = data.list or [] for item in data: if item.filename: post[item.name] = FileUpload(item.file, item.name, item.filename, item.headers) else: post[item.name] = item.value return post @property def url(self): """ The full request URI including hostname and scheme. If your app lives behind a reverse proxy or load balancer and you get confusing results, make sure that the ``X-Forwarded-Host`` header is set correctly. """ return self.urlparts.geturl() @DictProperty('environ', 'bottle.request.urlparts', read_only=True) def urlparts(self): ''' The :attr:`url` string as an :class:`urlparse.SplitResult` tuple. The tuple contains (scheme, host, path, query_string and fragment), but the fragment is always empty because it is not visible to the server. ''' env = self.environ http = env.get('HTTP_X_FORWARDED_PROTO') or env.get('wsgi.url_scheme', 'http') host = env.get('HTTP_X_FORWARDED_HOST') or env.get('HTTP_HOST') if not host: # HTTP 1.1 requires a Host-header. This is for HTTP/1.0 clients. host = env.get('SERVER_NAME', '127.0.0.1') port = env.get('SERVER_PORT') if port and port != ('80' if http == 'http' else '443'): host += ':' + port path = urlquote(self.fullpath) return UrlSplitResult(http, host, path, env.get('QUERY_STRING'), '') @property def fullpath(self): """ Request path including :attr:`script_name` (if present). """ return urljoin(self.script_name, self.path.lstrip('/')) @property def query_string(self): """ The raw :attr:`query` part of the URL (everything in between ``?`` and ``#``) as a string. """ return self.environ.get('QUERY_STRING', '') @property def script_name(self): ''' The initial portion of the URL's `path` that was removed by a higher level (server or routing middleware) before the application was called. This script path is returned with leading and tailing slashes. ''' script_name = self.environ.get('SCRIPT_NAME', '').strip('/') return '/' + script_name + '/' if script_name else '/' def path_shift(self, shift=1): ''' Shift path segments from :attr:`path` to :attr:`script_name` and vice versa. :param shift: The number of path segments to shift. May be negative to change the shift direction. (default: 1) ''' script = self.environ.get('SCRIPT_NAME','/') self['SCRIPT_NAME'], self['PATH_INFO'] = path_shift(script, self.path, shift) @property def content_length(self): ''' The request body length as an integer. The client is responsible to set this header. Otherwise, the real length of the body is unknown and -1 is returned. In this case, :attr:`body` will be empty. ''' return int(self.environ.get('CONTENT_LENGTH') or -1) @property def content_type(self): ''' The Content-Type header as a lowercase-string (default: empty). ''' return self.environ.get('CONTENT_TYPE', '').lower() @property def is_xhr(self): ''' True if the request was triggered by a XMLHttpRequest. This only works with JavaScript libraries that support the `X-Requested-With` header (most of the popular libraries do). ''' requested_with = self.environ.get('HTTP_X_REQUESTED_WITH','') return requested_with.lower() == 'xmlhttprequest' @property def is_ajax(self): ''' Alias for :attr:`is_xhr`. "Ajax" is not the right term. ''' return self.is_xhr @property def auth(self): """ HTTP authentication data as a (user, password) tuple. This implementation currently supports basic (not digest) authentication only. If the authentication happened at a higher level (e.g. in the front web-server or a middleware), the password field is None, but the user field is looked up from the ``REMOTE_USER`` environ variable. On any errors, None is returned. """ basic = parse_auth(self.environ.get('HTTP_AUTHORIZATION','')) if basic: return basic ruser = self.environ.get('REMOTE_USER') if ruser: return (ruser, None) return None @property def remote_route(self): """ A list of all IPs that were involved in this request, starting with the client IP and followed by zero or more proxies. This does only work if all proxies support the ```X-Forwarded-For`` header. Note that this information can be forged by malicious clients. """ proxy = self.environ.get('HTTP_X_FORWARDED_FOR') if proxy: return [ip.strip() for ip in proxy.split(',')] remote = self.environ.get('REMOTE_ADDR') return [remote] if remote else [] @property def remote_addr(self): """ The client IP as a string. Note that this information can be forged by malicious clients. """ route = self.remote_route return route[0] if route else None def copy(self): """ Return a new :class:`Request` with a shallow :attr:`environ` copy. """ return Request(self.environ.copy()) def get(self, value, default=None): return self.environ.get(value, default) def __getitem__(self, key): return self.environ[key] def __delitem__(self, key): self[key] = ""; del(self.environ[key]) def __iter__(self): return iter(self.environ) def __len__(self): return len(self.environ) def keys(self): return self.environ.keys() def __setitem__(self, key, value): """ Change an environ value and clear all caches that depend on it. """ if self.environ.get('bottle.request.readonly'): raise KeyError('The environ dictionary is read-only.') self.environ[key] = value todelete = () if key == 'wsgi.input': todelete = ('body', 'forms', 'files', 'params', 'post', 'json') elif key == 'QUERY_STRING': todelete = ('query', 'params') elif key.startswith('HTTP_'): todelete = ('headers', 'cookies') for key in todelete: self.environ.pop('bottle.request.'+key, None) def __repr__(self): return '<%s: %s %s>' % (self.__class__.__name__, self.method, self.url) def __getattr__(self, name): ''' Search in self.environ for additional user defined attributes. ''' try: var = self.environ['bottle.request.ext.%s'%name] return var.__get__(self) if hasattr(var, '__get__') else var except KeyError: raise AttributeError('Attribute %r not defined.' % name) def __setattr__(self, name, value): if name == 'environ': return object.__setattr__(self, name, value) self.environ['bottle.request.ext.%s'%name] = value def _hkey(s): return s.title().replace('_','-') class HeaderProperty(object): def __init__(self, name, reader=None, writer=str, default=''): self.name, self.default = name, default self.reader, self.writer = reader, writer self.__doc__ = 'Current value of the %r header.' % name.title() def __get__(self, obj, cls): if obj is None: return self value = obj.headers.get(self.name, self.default) return self.reader(value) if self.reader else value def __set__(self, obj, value): obj.headers[self.name] = self.writer(value) def __delete__(self, obj): del obj.headers[self.name] class BaseResponse(object): """ Storage class for a response body as well as headers and cookies. This class does support dict-like case-insensitive item-access to headers, but is NOT a dict. Most notably, iterating over a response yields parts of the body and not the headers. :param body: The response body as one of the supported types. :param status: Either an HTTP status code (e.g. 200) or a status line including the reason phrase (e.g. '200 OK'). :param headers: A dictionary or a list of name-value pairs. Additional keyword arguments are added to the list of headers. Underscores in the header name are replaced with dashes. """ default_status = 200 default_content_type = 'text/html; charset=UTF-8' # Header blacklist for specific response codes # (rfc2616 section 10.2.3 and 10.3.5) bad_headers = { 204: set(('Content-Type',)), 304: set(('Allow', 'Content-Encoding', 'Content-Language', 'Content-Length', 'Content-Range', 'Content-Type', 'Content-Md5', 'Last-Modified'))} def __init__(self, body='', status=None, headers=None, **more_headers): self._cookies = None self._headers = {} self.body = body self.status = status or self.default_status if headers: if isinstance(headers, dict): headers = headers.items() for name, value in headers: self.add_header(name, value) if more_headers: for name, value in more_headers.items(): self.add_header(name, value) def copy(self, cls=None): ''' Returns a copy of self. ''' cls = cls or BaseResponse assert issubclass(cls, BaseResponse) copy = cls() copy.status = self.status copy._headers = dict((k, v[:]) for (k, v) in self._headers.items()) if self._cookies: copy._cookies = SimpleCookie() copy._cookies.load(self._cookies.output(header='')) return copy def __iter__(self): return iter(self.body) def close(self): if hasattr(self.body, 'close'): self.body.close() @property def status_line(self): ''' The HTTP status line as a string (e.g. ``404 Not Found``).''' return self._status_line @property def status_code(self): ''' The HTTP status code as an integer (e.g. 404).''' return self._status_code def _set_status(self, status): if isinstance(status, int): code, status = status, _HTTP_STATUS_LINES.get(status) elif ' ' in status: status = status.strip() code = int(status.split()[0]) else: raise ValueError('String status line without a reason phrase.') if not 100 <= code <= 999: raise ValueError('Status code out of range.') self._status_code = code self._status_line = str(status or ('%d Unknown' % code)) def _get_status(self): return self._status_line status = property(_get_status, _set_status, None, ''' A writeable property to change the HTTP response status. It accepts either a numeric code (100-999) or a string with a custom reason phrase (e.g. "404 Brain not found"). Both :data:`status_line` and :data:`status_code` are updated accordingly. The return value is always a status string. ''') del _get_status, _set_status @property def headers(self): ''' An instance of :class:`HeaderDict`, a case-insensitive dict-like view on the response headers. ''' hdict = HeaderDict() hdict.dict = self._headers return hdict def __contains__(self, name): return _hkey(name) in self._headers def __delitem__(self, name): del self._headers[_hkey(name)] def __getitem__(self, name): return self._headers[_hkey(name)][-1] def __setitem__(self, name, value): self._headers[_hkey(name)] = [str(value)] def get_header(self, name, default=None): ''' Return the value of a previously defined header. If there is no header with that name, return a default value. ''' return self._headers.get(_hkey(name), [default])[-1] def set_header(self, name, value): ''' Create a new response header, replacing any previously defined headers with the same name. ''' self._headers[_hkey(name)] = [str(value)] def add_header(self, name, value): ''' Add an additional response header, not removing duplicates. ''' self._headers.setdefault(_hkey(name), []).append(str(value)) def iter_headers(self): ''' Yield (header, value) tuples, skipping headers that are not allowed with the current response status code. ''' return self.headerlist @property def headerlist(self): ''' WSGI conform list of (header, value) tuples. ''' out = [] headers = list(self._headers.items()) if 'Content-Type' not in self._headers: headers.append(('Content-Type', [self.default_content_type])) if self._status_code in self.bad_headers: bad_headers = self.bad_headers[self._status_code] headers = [h for h in headers if h[0] not in bad_headers] out += [(name, val) for name, vals in headers for val in vals] if self._cookies: for c in self._cookies.values(): out.append(('Set-Cookie', c.OutputString())) return out content_type = HeaderProperty('Content-Type') content_length = HeaderProperty('Content-Length', reader=int) expires = HeaderProperty('Expires', reader=lambda x: datetime.utcfromtimestamp(parse_date(x)), writer=lambda x: http_date(x)) @property def charset(self, default='UTF-8'): """ Return the charset specified in the content-type header (default: utf8). """ if 'charset=' in self.content_type: return self.content_type.split('charset=')[-1].split(';')[0].strip() return default def set_cookie(self, name, value, secret=None, **options): ''' Create a new cookie or replace an old one. If the `secret` parameter is set, create a `Signed Cookie` (described below). :param name: the name of the cookie. :param value: the value of the cookie. :param secret: a signature key required for signed cookies. Additionally, this method accepts all RFC 2109 attributes that are supported by :class:`cookie.Morsel`, including: :param max_age: maximum age in seconds. (default: None) :param expires: a datetime object or UNIX timestamp. (default: None) :param domain: the domain that is allowed to read the cookie. (default: current domain) :param path: limits the cookie to a given path (default: current path) :param secure: limit the cookie to HTTPS connections (default: off). :param httponly: prevents client-side javascript to read this cookie (default: off, requires Python 2.6 or newer). If neither `expires` nor `max_age` is set (default), the cookie will expire at the end of the browser session (as soon as the browser window is closed). Signed cookies may store any pickle-able object and are cryptographically signed to prevent manipulation. Keep in mind that cookies are limited to 4kb in most browsers. Warning: Signed cookies are not encrypted (the client can still see the content) and not copy-protected (the client can restore an old cookie). The main intention is to make pickling and unpickling save, not to store secret information at client side. ''' if not self._cookies: self._cookies = SimpleCookie() if secret: value = touni(cookie_encode((name, value), secret)) elif not isinstance(value, basestring): raise TypeError('Secret key missing for non-string Cookie.') if len(value) > 4096: raise ValueError('Cookie value to long.') self._cookies[name] = value for key, value in options.items(): if key == 'max_age': if isinstance(value, timedelta): value = value.seconds + value.days * 24 * 3600 if key == 'expires': if isinstance(value, (datedate, datetime)): value = value.timetuple() elif isinstance(value, (int, float)): value = time.gmtime(value) value = time.strftime("%a, %d %b %Y %H:%M:%S GMT", value) self._cookies[name][key.replace('_', '-')] = value def delete_cookie(self, key, **kwargs): ''' Delete a cookie. Be sure to use the same `domain` and `path` settings as used to create the cookie. ''' kwargs['max_age'] = -1 kwargs['expires'] = 0 self.set_cookie(key, '', **kwargs) def __repr__(self): out = '' for name, value in self.headerlist: out += '%s: %s\n' % (name.title(), value.strip()) return out def local_property(name=None): if name: depr('local_property() is deprecated and will be removed.') #0.12 ls = threading.local() def fget(self): try: return ls.var except AttributeError: raise RuntimeError("Request context not initialized.") def fset(self, value): ls.var = value def fdel(self): del ls.var return property(fget, fset, fdel, 'Thread-local property') class LocalRequest(BaseRequest): ''' A thread-local subclass of :class:`BaseRequest` with a different set of attributes for each thread. There is usually only one global instance of this class (:data:`request`). If accessed during a request/response cycle, this instance always refers to the *current* request (even on a multithreaded server). ''' bind = BaseRequest.__init__ environ = local_property() class LocalResponse(BaseResponse): ''' A thread-local subclass of :class:`BaseResponse` with a different set of attributes for each thread. There is usually only one global instance of this class (:data:`response`). Its attributes are used to build the HTTP response at the end of the request/response cycle. ''' bind = BaseResponse.__init__ _status_line = local_property() _status_code = local_property() _cookies = local_property() _headers = local_property() body = local_property() Request = BaseRequest Response = BaseResponse class HTTPResponse(Response, BottleException): def __init__(self, body='', status=None, headers=None, **more_headers): super(HTTPResponse, self).__init__(body, status, headers, **more_headers) def apply(self, response): response._status_code = self._status_code response._status_line = self._status_line response._headers = self._headers response._cookies = self._cookies response.body = self.body class HTTPError(HTTPResponse): default_status = 500 def __init__(self, status=None, body=None, exception=None, traceback=None, **options): self.exception = exception self.traceback = traceback super(HTTPError, self).__init__(body, status, **options) ############################################################################### # Plugins ###################################################################### ############################################################################### class PluginError(BottleException): pass class JSONPlugin(object): name = 'json' api = 2 def __init__(self, json_dumps=json_dumps): self.json_dumps = json_dumps def apply(self, callback, route): dumps = self.json_dumps if not dumps: return callback def wrapper(*a, **ka): try: rv = callback(*a, **ka) except HTTPError: rv = _e() if isinstance(rv, dict): #Attempt to serialize, raises exception on failure json_response = dumps(rv) #Set content type only if serialization succesful response.content_type = 'application/json' return json_response elif isinstance(rv, HTTPResponse) and isinstance(rv.body, dict): rv.body = dumps(rv.body) rv.content_type = 'application/json' return rv return wrapper class TemplatePlugin(object): ''' This plugin applies the :func:`view` decorator to all routes with a `template` config parameter. If the parameter is a tuple, the second element must be a dict with additional options (e.g. `template_engine`) or default variables for the template. ''' name = 'template' api = 2 def apply(self, callback, route): conf = route.config.get('template') if isinstance(conf, (tuple, list)) and len(conf) == 2: return view(conf[0], **conf[1])(callback) elif isinstance(conf, str): return view(conf)(callback) else: return callback #: Not a plugin, but part of the plugin API. TODO: Find a better place. class _ImportRedirect(object): def __init__(self, name, impmask): ''' Create a virtual package that redirects imports (see PEP 302). ''' self.name = name self.impmask = impmask self.module = sys.modules.setdefault(name, imp.new_module(name)) self.module.__dict__.update({'__file__': __file__, '__path__': [], '__all__': [], '__loader__': self}) sys.meta_path.append(self) def find_module(self, fullname, path=None): if '.' not in fullname: return packname = fullname.rsplit('.', 1)[0] if packname != self.name: return return self def load_module(self, fullname): if fullname in sys.modules: return sys.modules[fullname] modname = fullname.rsplit('.', 1)[1] realname = self.impmask % modname __import__(realname) module = sys.modules[fullname] = sys.modules[realname] setattr(self.module, modname, module) module.__loader__ = self return module ############################################################################### # Common Utilities ############################################################# ############################################################################### class MultiDict(DictMixin): """ This dict stores multiple values per key, but behaves exactly like a normal dict in that it returns only the newest value for any given key. There are special methods available to access the full list of values. """ def __init__(self, *a, **k): self.dict = dict((k, [v]) for (k, v) in dict(*a, **k).items()) def __len__(self): return len(self.dict) def __iter__(self): return iter(self.dict) def __contains__(self, key): return key in self.dict def __delitem__(self, key): del self.dict[key] def __getitem__(self, key): return self.dict[key][-1] def __setitem__(self, key, value): self.append(key, value) def keys(self): return self.dict.keys() if py3k: def values(self): return (v[-1] for v in self.dict.values()) def items(self): return ((k, v[-1]) for k, v in self.dict.items()) def allitems(self): return ((k, v) for k, vl in self.dict.items() for v in vl) iterkeys = keys itervalues = values iteritems = items iterallitems = allitems else: def values(self): return [v[-1] for v in self.dict.values()] def items(self): return [(k, v[-1]) for k, v in self.dict.items()] def iterkeys(self): return self.dict.iterkeys() def itervalues(self): return (v[-1] for v in self.dict.itervalues()) def iteritems(self): return ((k, v[-1]) for k, v in self.dict.iteritems()) def iterallitems(self): return ((k, v) for k, vl in self.dict.iteritems() for v in vl) def allitems(self): return [(k, v) for k, vl in self.dict.iteritems() for v in vl] def get(self, key, default=None, index=-1, type=None): ''' Return the most recent value for a key. :param default: The default value to be returned if the key is not present or the type conversion fails. :param index: An index for the list of available values. :param type: If defined, this callable is used to cast the value into a specific type. Exception are suppressed and result in the default value to be returned. ''' try: val = self.dict[key][index] return type(val) if type else val except Exception: pass return default def append(self, key, value): ''' Add a new value to the list of values for this key. ''' self.dict.setdefault(key, []).append(value) def replace(self, key, value): ''' Replace the list of values with a single value. ''' self.dict[key] = [value] def getall(self, key): ''' Return a (possibly empty) list of values for a key. ''' return self.dict.get(key) or [] #: Aliases for WTForms to mimic other multi-dict APIs (Django) getone = get getlist = getall class FormsDict(MultiDict): ''' This :class:`MultiDict` subclass is used to store request form data. Additionally to the normal dict-like item access methods (which return unmodified data as native strings), this container also supports attribute-like access to its values. Attributes are automatically de- or recoded to match :attr:`input_encoding` (default: 'utf8'). Missing attributes default to an empty string. ''' #: Encoding used for attribute values. input_encoding = 'utf8' #: If true (default), unicode strings are first encoded with `latin1` #: and then decoded to match :attr:`input_encoding`. recode_unicode = True def _fix(self, s, encoding=None): if isinstance(s, unicode) and self.recode_unicode: # Python 3 WSGI return s.encode('latin1').decode(encoding or self.input_encoding) elif isinstance(s, bytes): # Python 2 WSGI return s.decode(encoding or self.input_encoding) else: return s def decode(self, encoding=None): ''' Returns a copy with all keys and values de- or recoded to match :attr:`input_encoding`. Some libraries (e.g. WTForms) want a unicode dictionary. ''' copy = FormsDict() enc = copy.input_encoding = encoding or self.input_encoding copy.recode_unicode = False for key, value in self.allitems(): copy.append(self._fix(key, enc), self._fix(value, enc)) return copy def getunicode(self, name, default=None, encoding=None): ''' Return the value as a unicode string, or the default. ''' try: return self._fix(self[name], encoding) except (UnicodeError, KeyError): return default def __getattr__(self, name, default=unicode()): # Without this guard, pickle generates a cryptic TypeError: if name.startswith('__') and name.endswith('__'): return super(FormsDict, self).__getattr__(name) return self.getunicode(name, default=default) class HeaderDict(MultiDict): """ A case-insensitive version of :class:`MultiDict` that defaults to replace the old value instead of appending it. """ def __init__(self, *a, **ka): self.dict = {} if a or ka: self.update(*a, **ka) def __contains__(self, key): return _hkey(key) in self.dict def __delitem__(self, key): del self.dict[_hkey(key)] def __getitem__(self, key): return self.dict[_hkey(key)][-1] def __setitem__(self, key, value): self.dict[_hkey(key)] = [str(value)] def append(self, key, value): self.dict.setdefault(_hkey(key), []).append(str(value)) def replace(self, key, value): self.dict[_hkey(key)] = [str(value)] def getall(self, key): return self.dict.get(_hkey(key)) or [] def get(self, key, default=None, index=-1): return MultiDict.get(self, _hkey(key), default, index) def filter(self, names): for name in [_hkey(n) for n in names]: if name in self.dict: del self.dict[name] class WSGIHeaderDict(DictMixin): ''' This dict-like class wraps a WSGI environ dict and provides convenient access to HTTP_* fields. Keys and values are native strings (2.x bytes or 3.x unicode) and keys are case-insensitive. If the WSGI environment contains non-native string values, these are de- or encoded using a lossless 'latin1' character set. The API will remain stable even on changes to the relevant PEPs. Currently PEP 333, 444 and 3333 are supported. (PEP 444 is the only one that uses non-native strings.) ''' #: List of keys that do not have a ``HTTP_`` prefix. cgikeys = ('CONTENT_TYPE', 'CONTENT_LENGTH') def __init__(self, environ): self.environ = environ def _ekey(self, key): ''' Translate header field name to CGI/WSGI environ key. ''' key = key.replace('-','_').upper() if key in self.cgikeys: return key return 'HTTP_' + key def raw(self, key, default=None): ''' Return the header value as is (may be bytes or unicode). ''' return self.environ.get(self._ekey(key), default) def __getitem__(self, key): return tonat(self.environ[self._ekey(key)], 'latin1') def __setitem__(self, key, value): raise TypeError("%s is read-only." % self.__class__) def __delitem__(self, key): raise TypeError("%s is read-only." % self.__class__) def __iter__(self): for key in self.environ: if key[:5] == 'HTTP_': yield key[5:].replace('_', '-').title() elif key in self.cgikeys: yield key.replace('_', '-').title() def keys(self): return [x for x in self] def __len__(self): return len(self.keys()) def __contains__(self, key): return self._ekey(key) in self.environ class ConfigDict(dict): ''' A dict-like configuration storage with additional support for namespaces, validators, meta-data, on_change listeners and more. This storage is optimized for fast read access. Retrieving a key or using non-altering dict methods (e.g. `dict.get()`) has no overhead compared to a native dict. ''' __slots__ = ('_meta', '_on_change') class Namespace(DictMixin): def __init__(self, config, namespace): self._config = config self._prefix = namespace def __getitem__(self, key): depr('Accessing namespaces as dicts is discouraged. ' 'Only use flat item access: ' 'cfg["names"]["pace"]["key"] -> cfg["name.space.key"]') #0.12 return self._config[self._prefix + '.' + key] def __setitem__(self, key, value): self._config[self._prefix + '.' + key] = value def __delitem__(self, key): del self._config[self._prefix + '.' + key] def __iter__(self): ns_prefix = self._prefix + '.' for key in self._config: ns, dot, name = key.rpartition('.') if ns == self._prefix and name: yield name def keys(self): return [x for x in self] def __len__(self): return len(self.keys()) def __contains__(self, key): return self._prefix + '.' + key in self._config def __repr__(self): return '<Config.Namespace %s.*>' % self._prefix def __str__(self): return '<Config.Namespace %s.*>' % self._prefix # Deprecated ConfigDict features def __getattr__(self, key): depr('Attribute access is deprecated.') #0.12 if key not in self and key[0].isupper(): self[key] = ConfigDict.Namespace(self._config, self._prefix + '.' + key) if key not in self and key.startswith('__'): raise AttributeError(key) return self.get(key) def __setattr__(self, key, value): if key in ('_config', '_prefix'): self.__dict__[key] = value return depr('Attribute assignment is deprecated.') #0.12 if hasattr(DictMixin, key): raise AttributeError('Read-only attribute.') if key in self and self[key] and isinstance(self[key], self.__class__): raise AttributeError('Non-empty namespace attribute.') self[key] = value def __delattr__(self, key): if key in self: val = self.pop(key) if isinstance(val, self.__class__): prefix = key + '.' for key in self: if key.startswith(prefix): del self[prefix+key] def __call__(self, *a, **ka): depr('Calling ConfDict is deprecated. Use the update() method.') #0.12 self.update(*a, **ka) return self def __init__(self, *a, **ka): self._meta = {} self._on_change = lambda name, value: None if a or ka: depr('Constructor does no longer accept parameters.') #0.12 self.update(*a, **ka) def load_config(self, filename): ''' Load values from an *.ini style config file. If the config file contains sections, their names are used as namespaces for the values within. The two special sections ``DEFAULT`` and ``bottle`` refer to the root namespace (no prefix). ''' conf = ConfigParser() conf.read(filename) for section in conf.sections(): for key, value in conf.items(section): if section not in ('DEFAULT', 'bottle'): key = section + '.' + key self[key] = value return self def load_dict(self, source, namespace='', make_namespaces=False): ''' Import values from a dictionary structure. Nesting can be used to represent namespaces. >>> ConfigDict().load_dict({'name': {'space': {'key': 'value'}}}) {'name.space.key': 'value'} ''' stack = [(namespace, source)] while stack: prefix, source = stack.pop() if not isinstance(source, dict): raise TypeError('Source is not a dict (r)' % type(key)) for key, value in source.items(): if not isinstance(key, basestring): raise TypeError('Key is not a string (%r)' % type(key)) full_key = prefix + '.' + key if prefix else key if isinstance(value, dict): stack.append((full_key, value)) if make_namespaces: self[full_key] = self.Namespace(self, full_key) else: self[full_key] = value return self def update(self, *a, **ka): ''' If the first parameter is a string, all keys are prefixed with this namespace. Apart from that it works just as the usual dict.update(). Example: ``update('some.namespace', key='value')`` ''' prefix = '' if a and isinstance(a[0], basestring): prefix = a[0].strip('.') + '.' a = a[1:] for key, value in dict(*a, **ka).items(): self[prefix+key] = value def setdefault(self, key, value): if key not in self: self[key] = value return self[key] def __setitem__(self, key, value): if not isinstance(key, basestring): raise TypeError('Key has type %r (not a string)' % type(key)) value = self.meta_get(key, 'filter', lambda x: x)(value) if key in self and self[key] is value: return self._on_change(key, value) dict.__setitem__(self, key, value) def __delitem__(self, key): dict.__delitem__(self, key) def clear(self): for key in self: del self[key] def meta_get(self, key, metafield, default=None): ''' Return the value of a meta field for a key. ''' return self._meta.get(key, {}).get(metafield, default) def meta_set(self, key, metafield, value): ''' Set the meta field for a key to a new value. This triggers the on-change handler for existing keys. ''' self._meta.setdefault(key, {})[metafield] = value if key in self: self[key] = self[key] def meta_list(self, key): ''' Return an iterable of meta field names defined for a key. ''' return self._meta.get(key, {}).keys() # Deprecated ConfigDict features def __getattr__(self, key): depr('Attribute access is deprecated.') #0.12 if key not in self and key[0].isupper(): self[key] = self.Namespace(self, key) if key not in self and key.startswith('__'): raise AttributeError(key) return self.get(key) def __setattr__(self, key, value): if key in self.__slots__: return dict.__setattr__(self, key, value) depr('Attribute assignment is deprecated.') #0.12 if hasattr(dict, key): raise AttributeError('Read-only attribute.') if key in self and self[key] and isinstance(self[key], self.Namespace): raise AttributeError('Non-empty namespace attribute.') self[key] = value def __delattr__(self, key): if key in self: val = self.pop(key) if isinstance(val, self.Namespace): prefix = key + '.' for key in self: if key.startswith(prefix): del self[prefix+key] def __call__(self, *a, **ka): depr('Calling ConfDict is deprecated. Use the update() method.') #0.12 self.update(*a, **ka) return self class AppStack(list): """ A stack-like list. Calling it returns the head of the stack. """ def __call__(self): """ Return the current default application. """ return self[-1] def push(self, value=None): """ Add a new :class:`Bottle` instance to the stack """ if not isinstance(value, Bottle): value = Bottle() self.append(value) return value class WSGIFileWrapper(object): def __init__(self, fp, buffer_size=1024*64): self.fp, self.buffer_size = fp, buffer_size for attr in ('fileno', 'close', 'read', 'readlines', 'tell', 'seek'): if hasattr(fp, attr): setattr(self, attr, getattr(fp, attr)) def __iter__(self): buff, read = self.buffer_size, self.read while True: part = read(buff) if not part: return yield part class _closeiter(object): ''' This only exists to be able to attach a .close method to iterators that do not support attribute assignment (most of itertools). ''' def __init__(self, iterator, close=None): self.iterator = iterator self.close_callbacks = makelist(close) def __iter__(self): return iter(self.iterator) def close(self): for func in self.close_callbacks: func() class ResourceManager(object): ''' This class manages a list of search paths and helps to find and open application-bound resources (files). :param base: default value for :meth:`add_path` calls. :param opener: callable used to open resources. :param cachemode: controls which lookups are cached. One of 'all', 'found' or 'none'. ''' def __init__(self, base='./', opener=open, cachemode='all'): self.opener = open self.base = base self.cachemode = cachemode #: A list of search paths. See :meth:`add_path` for details. self.path = [] #: A cache for resolved paths. ``res.cache.clear()`` clears the cache. self.cache = {} def add_path(self, path, base=None, index=None, create=False): ''' Add a new path to the list of search paths. Return False if the path does not exist. :param path: The new search path. Relative paths are turned into an absolute and normalized form. If the path looks like a file (not ending in `/`), the filename is stripped off. :param base: Path used to absolutize relative search paths. Defaults to :attr:`base` which defaults to ``os.getcwd()``. :param index: Position within the list of search paths. Defaults to last index (appends to the list). The `base` parameter makes it easy to reference files installed along with a python module or package:: res.add_path('./resources/', __file__) ''' base = os.path.abspath(os.path.dirname(base or self.base)) path = os.path.abspath(os.path.join(base, os.path.dirname(path))) path += os.sep if path in self.path: self.path.remove(path) if create and not os.path.isdir(path): os.makedirs(path) if index is None: self.path.append(path) else: self.path.insert(index, path) self.cache.clear() return os.path.exists(path) def __iter__(self): ''' Iterate over all existing files in all registered paths. ''' search = self.path[:] while search: path = search.pop() if not os.path.isdir(path): continue for name in os.listdir(path): full = os.path.join(path, name) if os.path.isdir(full): search.append(full) else: yield full def lookup(self, name): ''' Search for a resource and return an absolute file path, or `None`. The :attr:`path` list is searched in order. The first match is returend. Symlinks are followed. The result is cached to speed up future lookups. ''' if name not in self.cache or DEBUG: for path in self.path: fpath = os.path.join(path, name) if os.path.isfile(fpath): if self.cachemode in ('all', 'found'): self.cache[name] = fpath return fpath if self.cachemode == 'all': self.cache[name] = None return self.cache[name] def open(self, name, mode='r', *args, **kwargs): ''' Find a resource and return a file object, or raise IOError. ''' fname = self.lookup(name) if not fname: raise IOError("Resource %r not found." % name) return self.opener(fname, mode=mode, *args, **kwargs) class FileUpload(object): def __init__(self, fileobj, name, filename, headers=None): ''' Wrapper for file uploads. ''' #: Open file(-like) object (BytesIO buffer or temporary file) self.file = fileobj #: Name of the upload form field self.name = name #: Raw filename as sent by the client (may contain unsafe characters) self.raw_filename = filename #: A :class:`HeaderDict` with additional headers (e.g. content-type) self.headers = HeaderDict(headers) if headers else HeaderDict() content_type = HeaderProperty('Content-Type') content_length = HeaderProperty('Content-Length', reader=int, default=-1) @cached_property def filename(self): ''' Name of the file on the client file system, but normalized to ensure file system compatibility. An empty filename is returned as 'empty'. Only ASCII letters, digits, dashes, underscores and dots are allowed in the final filename. Accents are removed, if possible. Whitespace is replaced by a single dash. Leading or tailing dots or dashes are removed. The filename is limited to 255 characters. ''' fname = self.raw_filename if not isinstance(fname, unicode): fname = fname.decode('utf8', 'ignore') fname = normalize('NFKD', fname).encode('ASCII', 'ignore').decode('ASCII') fname = os.path.basename(fname.replace('\\', os.path.sep)) fname = re.sub(r'[^a-zA-Z0-9-_.\s]', '', fname).strip() fname = re.sub(r'[-\s]+', '-', fname).strip('.-') return fname[:255] or 'empty' def _copy_file(self, fp, chunk_size=2**16): read, write, offset = self.file.read, fp.write, self.file.tell() while 1: buf = read(chunk_size) if not buf: break write(buf) self.file.seek(offset) def save(self, destination, overwrite=False, chunk_size=2**16): ''' Save file to disk or copy its content to an open file(-like) object. If *destination* is a directory, :attr:`filename` is added to the path. Existing files are not overwritten by default (IOError). :param destination: File path, directory or file(-like) object. :param overwrite: If True, replace existing files. (default: False) :param chunk_size: Bytes to read at a time. (default: 64kb) ''' if isinstance(destination, basestring): # Except file-likes here if os.path.isdir(destination): destination = os.path.join(destination, self.filename) if not overwrite and os.path.exists(destination): raise IOError('File exists.') with open(destination, 'wb') as fp: self._copy_file(fp, chunk_size) else: self._copy_file(destination, chunk_size) ############################################################################### # Application Helper ########################################################### ############################################################################### def abort(code=500, text='Unknown Error.'): """ Aborts execution and causes a HTTP error. """ raise HTTPError(code, text) def redirect(url, code=None): """ Aborts execution and causes a 303 or 302 redirect, depending on the HTTP protocol version. """ if not code: code = 303 if request.get('SERVER_PROTOCOL') == "HTTP/1.1" else 302 res = response.copy(cls=HTTPResponse) res.status = code res.body = "" res.set_header('Location', urljoin(request.url, url)) raise res def _file_iter_range(fp, offset, bytes, maxread=1024*1024): ''' Yield chunks from a range in a file. No chunk is bigger than maxread.''' fp.seek(offset) while bytes > 0: part = fp.read(min(bytes, maxread)) if not part: break bytes -= len(part) yield part def static_file(filename, root, mimetype='auto', download=False, charset='UTF-8'): """ Open a file in a safe way and return :exc:`HTTPResponse` with status code 200, 305, 403 or 404. The ``Content-Type``, ``Content-Encoding``, ``Content-Length`` and ``Last-Modified`` headers are set if possible. Special support for ``If-Modified-Since``, ``Range`` and ``HEAD`` requests. :param filename: Name or path of the file to send. :param root: Root path for file lookups. Should be an absolute directory path. :param mimetype: Defines the content-type header (default: guess from file extension) :param download: If True, ask the browser to open a `Save as...` dialog instead of opening the file with the associated program. You can specify a custom filename as a string. If not specified, the original filename is used (default: False). :param charset: The charset to use for files with a ``text/*`` mime-type. (default: UTF-8) """ root = os.path.abspath(root) + os.sep filename = os.path.abspath(os.path.join(root, filename.strip('/\\'))) headers = dict() if not filename.startswith(root): return HTTPError(403, "Access denied.") if not os.path.exists(filename) or not os.path.isfile(filename): return HTTPError(404, "File does not exist.") if not os.access(filename, os.R_OK): return HTTPError(403, "You do not have permission to access this file.") if mimetype == 'auto': mimetype, encoding = mimetypes.guess_type(filename) if encoding: headers['Content-Encoding'] = encoding if mimetype: if mimetype[:5] == 'text/' and charset and 'charset' not in mimetype: mimetype += '; charset=%s' % charset headers['Content-Type'] = mimetype if download: download = os.path.basename(filename if download == True else download) headers['Content-Disposition'] = 'attachment; filename="%s"' % download stats = os.stat(filename) headers['Content-Length'] = clen = stats.st_size lm = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime(stats.st_mtime)) headers['Last-Modified'] = lm ims = request.environ.get('HTTP_IF_MODIFIED_SINCE') if ims: ims = parse_date(ims.split(";")[0].strip()) if ims is not None and ims >= int(stats.st_mtime): headers['Date'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime()) return HTTPResponse(status=304, **headers) body = '' if request.method == 'HEAD' else open(filename, 'rb') headers["Accept-Ranges"] = "bytes" ranges = request.environ.get('HTTP_RANGE') if 'HTTP_RANGE' in request.environ: ranges = list(parse_range_header(request.environ['HTTP_RANGE'], clen)) if not ranges: return HTTPError(416, "Requested Range Not Satisfiable") offset, end = ranges[0] headers["Content-Range"] = "bytes %d-%d/%d" % (offset, end-1, clen) headers["Content-Length"] = str(end-offset) if body: body = _file_iter_range(body, offset, end-offset) return HTTPResponse(body, status=206, **headers) return HTTPResponse(body, **headers) ############################################################################### # HTTP Utilities and MISC (TODO) ############################################### ############################################################################### def debug(mode=True): """ Change the debug level. There is only one debug level supported at the moment.""" global DEBUG if mode: warnings.simplefilter('default') DEBUG = bool(mode) def http_date(value): if isinstance(value, (datedate, datetime)): value = value.utctimetuple() elif isinstance(value, (int, float)): value = time.gmtime(value) if not isinstance(value, basestring): value = time.strftime("%a, %d %b %Y %H:%M:%S GMT", value) return value def parse_date(ims): """ Parse rfc1123, rfc850 and asctime timestamps and return UTC epoch. """ try: ts = email.utils.parsedate_tz(ims) return time.mktime(ts[:8] + (0,)) - (ts[9] or 0) - time.timezone except (TypeError, ValueError, IndexError, OverflowError): return None def parse_auth(header): """ Parse rfc2617 HTTP authentication header string (basic) and return (user,pass) tuple or None""" try: method, data = header.split(None, 1) if method.lower() == 'basic': user, pwd = touni(base64.b64decode(tob(data))).split(':',1) return user, pwd except (KeyError, ValueError): return None def parse_range_header(header, maxlen=0): ''' Yield (start, end) ranges parsed from a HTTP Range header. Skip unsatisfiable ranges. The end index is non-inclusive.''' if not header or header[:6] != 'bytes=': return ranges = [r.split('-', 1) for r in header[6:].split(',') if '-' in r] for start, end in ranges: try: if not start: # bytes=-100 -> last 100 bytes start, end = max(0, maxlen-int(end)), maxlen elif not end: # bytes=100- -> all but the first 99 bytes start, end = int(start), maxlen else: # bytes=100-200 -> bytes 100-200 (inclusive) start, end = int(start), min(int(end)+1, maxlen) if 0 <= start < end <= maxlen: yield start, end except ValueError: pass def _parse_qsl(qs): r = [] for pair in qs.replace(';','&').split('&'): if not pair: continue nv = pair.split('=', 1) if len(nv) != 2: nv.append('') key = urlunquote(nv[0].replace('+', ' ')) value = urlunquote(nv[1].replace('+', ' ')) r.append((key, value)) return r def _lscmp(a, b): ''' Compares two strings in a cryptographically safe way: Runtime is not affected by length of common prefix. ''' return not sum(0 if x==y else 1 for x, y in zip(a, b)) and len(a) == len(b) def cookie_encode(data, key): ''' Encode and sign a pickle-able object. Return a (byte) string ''' msg = base64.b64encode(pickle.dumps(data, -1)) sig = base64.b64encode(hmac.new(tob(key), msg).digest()) return tob('!') + sig + tob('?') + msg def cookie_decode(data, key): ''' Verify and decode an encoded string. Return an object or None.''' data = tob(data) if cookie_is_encoded(data): sig, msg = data.split(tob('?'), 1) if _lscmp(sig[1:], base64.b64encode(hmac.new(tob(key), msg).digest())): return pickle.loads(base64.b64decode(msg)) return None def cookie_is_encoded(data): ''' Return True if the argument looks like a encoded cookie.''' return bool(data.startswith(tob('!')) and tob('?') in data) def html_escape(string): ''' Escape HTML special characters ``&<>`` and quotes ``'"``. ''' return string.replace('&','&').replace('<','<').replace('>','>')\ .replace('"','"').replace("'",''') def html_quote(string): ''' Escape and quote a string to be used as an HTTP attribute.''' return '"%s"' % html_escape(string).replace('\n',' ')\ .replace('\r',' ').replace('\t','	') def yieldroutes(func): """ Return a generator for routes that match the signature (name, args) of the func parameter. This may yield more than one route if the function takes optional keyword arguments. The output is best described by example:: a() -> '/a' b(x, y) -> '/b/<x>/<y>' c(x, y=5) -> '/c/<x>' and '/c/<x>/<y>' d(x=5, y=6) -> '/d' and '/d/<x>' and '/d/<x>/<y>' """ path = '/' + func.__name__.replace('__','/').lstrip('/') spec = getargspec(func) argc = len(spec[0]) - len(spec[3] or []) path += ('/<%s>' * argc) % tuple(spec[0][:argc]) yield path for arg in spec[0][argc:]: path += '/<%s>' % arg yield path def path_shift(script_name, path_info, shift=1): ''' Shift path fragments from PATH_INFO to SCRIPT_NAME and vice versa. :return: The modified paths. :param script_name: The SCRIPT_NAME path. :param script_name: The PATH_INFO path. :param shift: The number of path fragments to shift. May be negative to change the shift direction. (default: 1) ''' if shift == 0: return script_name, path_info pathlist = path_info.strip('/').split('/') scriptlist = script_name.strip('/').split('/') if pathlist and pathlist[0] == '': pathlist = [] if scriptlist and scriptlist[0] == '': scriptlist = [] if shift > 0 and shift <= len(pathlist): moved = pathlist[:shift] scriptlist = scriptlist + moved pathlist = pathlist[shift:] elif shift < 0 and shift >= -len(scriptlist): moved = scriptlist[shift:] pathlist = moved + pathlist scriptlist = scriptlist[:shift] else: empty = 'SCRIPT_NAME' if shift < 0 else 'PATH_INFO' raise AssertionError("Cannot shift. Nothing left from %s" % empty) new_script_name = '/' + '/'.join(scriptlist) new_path_info = '/' + '/'.join(pathlist) if path_info.endswith('/') and pathlist: new_path_info += '/' return new_script_name, new_path_info def auth_basic(check, realm="private", text="Access denied"): ''' Callback decorator to require HTTP auth (basic). TODO: Add route(check_auth=...) parameter. ''' def decorator(func): def wrapper(*a, **ka): user, password = request.auth or (None, None) if user is None or not check(user, password): err = HTTPError(401, text) err.add_header('WWW-Authenticate', 'Basic realm="%s"' % realm) return err return func(*a, **ka) return wrapper return decorator # Shortcuts for common Bottle methods. # They all refer to the current default application. def make_default_app_wrapper(name): ''' Return a callable that relays calls to the current default app. ''' @functools.wraps(getattr(Bottle, name)) def wrapper(*a, **ka): return getattr(app(), name)(*a, **ka) return wrapper route = make_default_app_wrapper('route') get = make_default_app_wrapper('get') post = make_default_app_wrapper('post') put = make_default_app_wrapper('put') delete = make_default_app_wrapper('delete') error = make_default_app_wrapper('error') mount = make_default_app_wrapper('mount') hook = make_default_app_wrapper('hook') install = make_default_app_wrapper('install') uninstall = make_default_app_wrapper('uninstall') url = make_default_app_wrapper('get_url') ############################################################################### # Server Adapter ############################################################### ############################################################################### class ServerAdapter(object): quiet = False def __init__(self, host='127.0.0.1', port=8080, **options): self.options = options self.host = host self.port = int(port) def run(self, handler): # pragma: no cover pass def __repr__(self): args = ', '.join(['%s=%s'%(k,repr(v)) for k, v in self.options.items()]) return "%s(%s)" % (self.__class__.__name__, args) class CGIServer(ServerAdapter): quiet = True def run(self, handler): # pragma: no cover from wsgiref.handlers import CGIHandler def fixed_environ(environ, start_response): environ.setdefault('PATH_INFO', '') return handler(environ, start_response) CGIHandler().run(fixed_environ) class FlupFCGIServer(ServerAdapter): def run(self, handler): # pragma: no cover import flup.server.fcgi self.options.setdefault('bindAddress', (self.host, self.port)) flup.server.fcgi.WSGIServer(handler, **self.options).run() class WSGIRefServer(ServerAdapter): def run(self, app): # pragma: no cover from wsgiref.simple_server import WSGIRequestHandler, WSGIServer from wsgiref.simple_server import make_server import socket class FixedHandler(WSGIRequestHandler): def address_string(self): # Prevent reverse DNS lookups please. return self.client_address[0] def log_request(*args, **kw): if not self.quiet: return WSGIRequestHandler.log_request(*args, **kw) handler_cls = self.options.get('handler_class', FixedHandler) server_cls = self.options.get('server_class', WSGIServer) if ':' in self.host: # Fix wsgiref for IPv6 addresses. if getattr(server_cls, 'address_family') == socket.AF_INET: class server_cls(server_cls): address_family = socket.AF_INET6 srv = make_server(self.host, self.port, app, server_cls, handler_cls) srv.serve_forever() class CherryPyServer(ServerAdapter): def run(self, handler): # pragma: no cover from cherrypy import wsgiserver self.options['bind_addr'] = (self.host, self.port) self.options['wsgi_app'] = handler certfile = self.options.get('certfile') if certfile: del self.options['certfile'] keyfile = self.options.get('keyfile') if keyfile: del self.options['keyfile'] server = wsgiserver.CherryPyWSGIServer(**self.options) if certfile: server.ssl_certificate = certfile if keyfile: server.ssl_private_key = keyfile try: server.start() finally: server.stop() class WaitressServer(ServerAdapter): def run(self, handler): from waitress import serve serve(handler, host=self.host, port=self.port) class PasteServer(ServerAdapter): def run(self, handler): # pragma: no cover from paste import httpserver from paste.translogger import TransLogger handler = TransLogger(handler, setup_console_handler=(not self.quiet)) httpserver.serve(handler, host=self.host, port=str(self.port), **self.options) class MeinheldServer(ServerAdapter): def run(self, handler): from meinheld import server server.listen((self.host, self.port)) server.run(handler) class FapwsServer(ServerAdapter): """ Extremely fast webserver using libev. See http://www.fapws.org/ """ def run(self, handler): # pragma: no cover import fapws._evwsgi as evwsgi from fapws import base, config port = self.port if float(config.SERVER_IDENT[-2:]) > 0.4: # fapws3 silently changed its API in 0.5 port = str(port) evwsgi.start(self.host, port) # fapws3 never releases the GIL. Complain upstream. I tried. No luck. if 'BOTTLE_CHILD' in os.environ and not self.quiet: _stderr("WARNING: Auto-reloading does not work with Fapws3.\n") _stderr(" (Fapws3 breaks python thread support)\n") evwsgi.set_base_module(base) def app(environ, start_response): environ['wsgi.multiprocess'] = False return handler(environ, start_response) evwsgi.wsgi_cb(('', app)) evwsgi.run() class TornadoServer(ServerAdapter): """ The super hyped asynchronous server by facebook. Untested. """ def run(self, handler): # pragma: no cover import tornado.wsgi, tornado.httpserver, tornado.ioloop container = tornado.wsgi.WSGIContainer(handler) server = tornado.httpserver.HTTPServer(container) server.listen(port=self.port,address=self.host) tornado.ioloop.IOLoop.instance().start() class AppEngineServer(ServerAdapter): """ Adapter for Google App Engine. """ quiet = True def run(self, handler): from google.appengine.ext.webapp import util # A main() function in the handler script enables 'App Caching'. # Lets makes sure it is there. This _really_ improves performance. module = sys.modules.get('__main__') if module and not hasattr(module, 'main'): module.main = lambda: util.run_wsgi_app(handler) util.run_wsgi_app(handler) class TwistedServer(ServerAdapter): """ Untested. """ def run(self, handler): from twisted.web import server, wsgi from twisted.python.threadpool import ThreadPool from twisted.internet import reactor thread_pool = ThreadPool() thread_pool.start() reactor.addSystemEventTrigger('after', 'shutdown', thread_pool.stop) factory = server.Site(wsgi.WSGIResource(reactor, thread_pool, handler)) reactor.listenTCP(self.port, factory, interface=self.host) reactor.run() class DieselServer(ServerAdapter): """ Untested. """ def run(self, handler): from diesel.protocols.wsgi import WSGIApplication app = WSGIApplication(handler, port=self.port) app.run() class GeventServer(ServerAdapter): """ Untested. Options: * `fast` (default: False) uses libevent's http server, but has some issues: No streaming, no pipelining, no SSL. * See gevent.wsgi.WSGIServer() documentation for more options. """ def run(self, handler): from gevent import wsgi, pywsgi, local if not isinstance(threading.local(), local.local): msg = "Bottle requires gevent.monkey.patch_all() (before import)" raise RuntimeError(msg) if not self.options.pop('fast', None): wsgi = pywsgi self.options['log'] = None if self.quiet else 'default' address = (self.host, self.port) server = wsgi.WSGIServer(address, handler, **self.options) if 'BOTTLE_CHILD' in os.environ: import signal signal.signal(signal.SIGINT, lambda s, f: server.stop()) server.serve_forever() class GeventSocketIOServer(ServerAdapter): def run(self,handler): from socketio import server address = (self.host, self.port) server.SocketIOServer(address, handler, **self.options).serve_forever() class GunicornServer(ServerAdapter): """ Untested. See http://gunicorn.org/configure.html for options. """ def run(self, handler): from gunicorn.app.base import Application config = {'bind': "%s:%d" % (self.host, int(self.port))} config.update(self.options) class GunicornApplication(Application): def init(self, parser, opts, args): return config def load(self): return handler GunicornApplication().run() class EventletServer(ServerAdapter): """ Untested """ def run(self, handler): from eventlet import wsgi, listen try: wsgi.server(listen((self.host, self.port)), handler, log_output=(not self.quiet)) except TypeError: # Fallback, if we have old version of eventlet wsgi.server(listen((self.host, self.port)), handler) class RocketServer(ServerAdapter): """ Untested. """ def run(self, handler): from rocket import Rocket server = Rocket((self.host, self.port), 'wsgi', { 'wsgi_app' : handler }) server.start() class BjoernServer(ServerAdapter): """ Fast server written in C: https://github.com/jonashaag/bjoern """ def run(self, handler): from bjoern import run run(handler, self.host, self.port) class AutoServer(ServerAdapter): """ Untested. """ adapters = [WaitressServer, PasteServer, TwistedServer, CherryPyServer, WSGIRefServer] def run(self, handler): for sa in self.adapters: try: return sa(self.host, self.port, **self.options).run(handler) except ImportError: pass server_names = { 'cgi': CGIServer, 'flup': FlupFCGIServer, 'wsgiref': WSGIRefServer, 'waitress': WaitressServer, 'cherrypy': CherryPyServer, 'paste': PasteServer, 'fapws3': FapwsServer, 'tornado': TornadoServer, 'gae': AppEngineServer, 'twisted': TwistedServer, 'diesel': DieselServer, 'meinheld': MeinheldServer, 'gunicorn': GunicornServer, 'eventlet': EventletServer, 'gevent': GeventServer, 'geventSocketIO':GeventSocketIOServer, 'rocket': RocketServer, 'bjoern' : BjoernServer, 'auto': AutoServer, } ############################################################################### # Application Control ########################################################## ############################################################################### def load(target, **namespace): """ Import a module or fetch an object from a module. * ``package.module`` returns `module` as a module object. * ``pack.mod:name`` returns the module variable `name` from `pack.mod`. * ``pack.mod:func()`` calls `pack.mod.func()` and returns the result. The last form accepts not only function calls, but any type of expression. Keyword arguments passed to this function are available as local variables. Example: ``import_string('re:compile(x)', x='[a-z]')`` """ module, target = target.split(":", 1) if ':' in target else (target, None) if module not in sys.modules: __import__(module) if not target: return sys.modules[module] if target.isalnum(): return getattr(sys.modules[module], target) package_name = module.split('.')[0] namespace[package_name] = sys.modules[package_name] return eval('%s.%s' % (module, target), namespace) def load_app(target): """ Load a bottle application from a module and make sure that the import does not affect the current default application, but returns a separate application object. See :func:`load` for the target parameter. """ global NORUN; NORUN, nr_old = True, NORUN try: tmp = default_app.push() # Create a new "default application" rv = load(target) # Import the target module return rv if callable(rv) else tmp finally: default_app.remove(tmp) # Remove the temporary added default application NORUN = nr_old _debug = debug def run(app=None, server='wsgiref', host='127.0.0.1', port=8080, interval=1, reloader=False, quiet=False, plugins=None, debug=None, **kargs): """ Start a server instance. This method blocks until the server terminates. :param app: WSGI application or target string supported by :func:`load_app`. (default: :func:`default_app`) :param server: Server adapter to use. See :data:`server_names` keys for valid names or pass a :class:`ServerAdapter` subclass. (default: `wsgiref`) :param host: Server address to bind to. Pass ``0.0.0.0`` to listens on all interfaces including the external one. (default: 127.0.0.1) :param port: Server port to bind to. Values below 1024 require root privileges. (default: 8080) :param reloader: Start auto-reloading server? (default: False) :param interval: Auto-reloader interval in seconds (default: 1) :param quiet: Suppress output to stdout and stderr? (default: False) :param options: Options passed to the server adapter. """ if NORUN: return if reloader and not os.environ.get('BOTTLE_CHILD'): try: lockfile = None fd, lockfile = tempfile.mkstemp(prefix='bottle.', suffix='.lock') os.close(fd) # We only need this file to exist. We never write to it while os.path.exists(lockfile): args = [sys.executable] + sys.argv environ = os.environ.copy() environ['BOTTLE_CHILD'] = 'true' environ['BOTTLE_LOCKFILE'] = lockfile p = subprocess.Popen(args, env=environ) while p.poll() is None: # Busy wait... os.utime(lockfile, None) # I am alive! time.sleep(interval) if p.poll() != 3: if os.path.exists(lockfile): os.unlink(lockfile) sys.exit(p.poll()) except KeyboardInterrupt: pass finally: if os.path.exists(lockfile): os.unlink(lockfile) return try: if debug is not None: _debug(debug) app = app or default_app() if isinstance(app, basestring): app = load_app(app) if not callable(app): raise ValueError("Application is not callable: %r" % app) for plugin in plugins or []: app.install(plugin) if server in server_names: server = server_names.get(server) if isinstance(server, basestring): server = load(server) if isinstance(server, type): server = server(host=host, port=port, **kargs) if not isinstance(server, ServerAdapter): raise ValueError("Unknown or unsupported server: %r" % server) server.quiet = server.quiet or quiet if not server.quiet: _stderr("Bottle v%s server starting up (using %s)...\n" % (__version__, repr(server))) _stderr("Listening on http://%s:%d/\n" % (server.host, server.port)) _stderr("Hit Ctrl-C to quit.\n\n") if reloader: lockfile = os.environ.get('BOTTLE_LOCKFILE') bgcheck = FileCheckerThread(lockfile, interval) with bgcheck: server.run(app) if bgcheck.status == 'reload': sys.exit(3) else: server.run(app) except KeyboardInterrupt: pass except (SystemExit, MemoryError): raise except: if not reloader: raise if not getattr(server, 'quiet', quiet): print_exc() time.sleep(interval) sys.exit(3) class FileCheckerThread(threading.Thread): ''' Interrupt main-thread as soon as a changed module file is detected, the lockfile gets deleted or gets to old. ''' def __init__(self, lockfile, interval): threading.Thread.__init__(self) self.lockfile, self.interval = lockfile, interval #: Is one of 'reload', 'error' or 'exit' self.status = None def run(self): exists = os.path.exists mtime = lambda path: os.stat(path).st_mtime files = dict() for module in list(sys.modules.values()): path = getattr(module, '__file__', '') if path[-4:] in ('.pyo', '.pyc'): path = path[:-1] if path and exists(path): files[path] = mtime(path) while not self.status: if not exists(self.lockfile)\ or mtime(self.lockfile) < time.time() - self.interval - 5: self.status = 'error' thread.interrupt_main() for path, lmtime in list(files.items()): if not exists(path) or mtime(path) > lmtime: self.status = 'reload' thread.interrupt_main() break time.sleep(self.interval) def __enter__(self): self.start() def __exit__(self, exc_type, exc_val, exc_tb): if not self.status: self.status = 'exit' # silent exit self.join() return exc_type is not None and issubclass(exc_type, KeyboardInterrupt) ############################################################################### # Template Adapters ############################################################ ############################################################################### class TemplateError(HTTPError): def __init__(self, message): HTTPError.__init__(self, 500, message) class BaseTemplate(object): """ Base class and minimal API for template adapters """ extensions = ['tpl','html','thtml','stpl'] settings = {} #used in prepare() defaults = {} #used in render() def __init__(self, source=None, name=None, lookup=[], encoding='utf8', **settings): """ Create a new template. If the source parameter (str or buffer) is missing, the name argument is used to guess a template filename. Subclasses can assume that self.source and/or self.filename are set. Both are strings. The lookup, encoding and settings parameters are stored as instance variables. The lookup parameter stores a list containing directory paths. The encoding parameter should be used to decode byte strings or files. The settings parameter contains a dict for engine-specific settings. """ self.name = name self.source = source.read() if hasattr(source, 'read') else source self.filename = source.filename if hasattr(source, 'filename') else None self.lookup = [os.path.abspath(x) for x in lookup] self.encoding = encoding self.settings = self.settings.copy() # Copy from class variable self.settings.update(settings) # Apply if not self.source and self.name: self.filename = self.search(self.name, self.lookup) if not self.filename: raise TemplateError('Template %s not found.' % repr(name)) if not self.source and not self.filename: raise TemplateError('No template specified.') self.prepare(**self.settings) @classmethod def search(cls, name, lookup=[]): """ Search name in all directories specified in lookup. First without, then with common extensions. Return first hit. """ if not lookup: depr('The template lookup path list should not be empty.') #0.12 lookup = ['.'] if os.path.isabs(name) and os.path.isfile(name): depr('Absolute template path names are deprecated.') #0.12 return os.path.abspath(name) for spath in lookup: spath = os.path.abspath(spath) + os.sep fname = os.path.abspath(os.path.join(spath, name)) if not fname.startswith(spath): continue if os.path.isfile(fname): return fname for ext in cls.extensions: if os.path.isfile('%s.%s' % (fname, ext)): return '%s.%s' % (fname, ext) @classmethod def global_config(cls, key, *args): ''' This reads or sets the global settings stored in class.settings. ''' if args: cls.settings = cls.settings.copy() # Make settings local to class cls.settings[key] = args[0] else: return cls.settings[key] def prepare(self, **options): """ Run preparations (parsing, caching, ...). It should be possible to call this again to refresh a template or to update settings. """ raise NotImplementedError def render(self, *args, **kwargs): """ Render the template with the specified local variables and return a single byte or unicode string. If it is a byte string, the encoding must match self.encoding. This method must be thread-safe! Local variables may be provided in dictionaries (args) or directly, as keywords (kwargs). """ raise NotImplementedError class MakoTemplate(BaseTemplate): def prepare(self, **options): from mako.template import Template from mako.lookup import TemplateLookup options.update({'input_encoding':self.encoding}) options.setdefault('format_exceptions', bool(DEBUG)) lookup = TemplateLookup(directories=self.lookup, **options) if self.source: self.tpl = Template(self.source, lookup=lookup, **options) else: self.tpl = Template(uri=self.name, filename=self.filename, lookup=lookup, **options) def render(self, *args, **kwargs): for dictarg in args: kwargs.update(dictarg) _defaults = self.defaults.copy() _defaults.update(kwargs) return self.tpl.render(**_defaults) class CheetahTemplate(BaseTemplate): def prepare(self, **options): from Cheetah.Template import Template self.context = threading.local() self.context.vars = {} options['searchList'] = [self.context.vars] if self.source: self.tpl = Template(source=self.source, **options) else: self.tpl = Template(file=self.filename, **options) def render(self, *args, **kwargs): for dictarg in args: kwargs.update(dictarg) self.context.vars.update(self.defaults) self.context.vars.update(kwargs) out = str(self.tpl) self.context.vars.clear() return out class Jinja2Template(BaseTemplate): def prepare(self, filters=None, tests=None, globals={}, **kwargs): from jinja2 import Environment, FunctionLoader if 'prefix' in kwargs: # TODO: to be removed after a while raise RuntimeError('The keyword argument `prefix` has been removed. ' 'Use the full jinja2 environment name line_statement_prefix instead.') self.env = Environment(loader=FunctionLoader(self.loader), **kwargs) if filters: self.env.filters.update(filters) if tests: self.env.tests.update(tests) if globals: self.env.globals.update(globals) if self.source: self.tpl = self.env.from_string(self.source) else: self.tpl = self.env.get_template(self.filename) def render(self, *args, **kwargs): for dictarg in args: kwargs.update(dictarg) _defaults = self.defaults.copy() _defaults.update(kwargs) return self.tpl.render(**_defaults) def loader(self, name): fname = self.search(name, self.lookup) if not fname: return with open(fname, "rb") as f: return f.read().decode(self.encoding) class SimpleTemplate(BaseTemplate): def prepare(self, escape_func=html_escape, noescape=False, syntax=None, **ka): self.cache = {} enc = self.encoding self._str = lambda x: touni(x, enc) self._escape = lambda x: escape_func(touni(x, enc)) self.syntax = syntax if noescape: self._str, self._escape = self._escape, self._str @cached_property def co(self): return compile(self.code, self.filename or '<string>', 'exec') @cached_property def code(self): source = self.source if not source: with open(self.filename, 'rb') as f: source = f.read() try: source, encoding = touni(source), 'utf8' except UnicodeError: depr('Template encodings other than utf8 are no longer supported.') #0.11 source, encoding = touni(source, 'latin1'), 'latin1' parser = StplParser(source, encoding=encoding, syntax=self.syntax) code = parser.translate() self.encoding = parser.encoding return code def _rebase(self, _env, _name=None, **kwargs): if _name is None: depr('Rebase function called without arguments.' ' You were probably looking for {{base}}?', True) #0.12 _env['_rebase'] = (_name, kwargs) def _include(self, _env, _name=None, **kwargs): if _name is None: depr('Rebase function called without arguments.' ' You were probably looking for {{base}}?', True) #0.12 env = _env.copy() env.update(kwargs) if _name not in self.cache: self.cache[_name] = self.__class__(name=_name, lookup=self.lookup) return self.cache[_name].execute(env['_stdout'], env) def execute(self, _stdout, kwargs): env = self.defaults.copy() env.update(kwargs) env.update({'_stdout': _stdout, '_printlist': _stdout.extend, 'include': functools.partial(self._include, env), 'rebase': functools.partial(self._rebase, env), '_rebase': None, '_str': self._str, '_escape': self._escape, 'get': env.get, 'setdefault': env.setdefault, 'defined': env.__contains__ }) eval(self.co, env) if env.get('_rebase'): subtpl, rargs = env.pop('_rebase') rargs['base'] = ''.join(_stdout) #copy stdout del _stdout[:] # clear stdout return self._include(env, subtpl, **rargs) return env def render(self, *args, **kwargs): """ Render the template using keyword arguments as local variables. """ env = {}; stdout = [] for dictarg in args: env.update(dictarg) env.update(kwargs) self.execute(stdout, env) return ''.join(stdout) class StplSyntaxError(TemplateError): pass class StplParser(object): ''' Parser for stpl templates. ''' _re_cache = {} #: Cache for compiled re patterns # This huge pile of voodoo magic splits python code into 8 different tokens. # 1: All kinds of python strings (trust me, it works) _re_tok = '((?m)[urbURB]?(?:\'\'(?!\')|""(?!")|\'{6}|"{6}' \ '|\'(?:[^\\\\\']|\\\\.)+?\'|"(?:[^\\\\"]|\\\\.)+?"' \ '|\'{3}(?:[^\\\\]|\\\\.|\\n)+?\'{3}' \ '|"{3}(?:[^\\\\]|\\\\.|\\n)+?"{3}))' _re_inl = _re_tok.replace('|\\n','') # We re-use this string pattern later # 2: Comments (until end of line, but not the newline itself) _re_tok += '|(#.*)' # 3,4: Open and close grouping tokens _re_tok += '|([\[\{\(])' _re_tok += '|([\]\}\)])' # 5,6: Keywords that start or continue a python block (only start of line) _re_tok += '|^([ \\t]*(?:if|for|while|with|try|def|class)\\b)' \ '|^([ \\t]*(?:elif|else|except|finally)\\b)' # 7: Our special 'end' keyword (but only if it stands alone) _re_tok += '|((?:^|;)[ \\t]*end[ \\t]*(?=(?:%(block_close)s[ \\t]*)?\\r?$|;|#))' # 8: A customizable end-of-code-block template token (only end of line) _re_tok += '|(%(block_close)s[ \\t]*(?=$))' # 9: And finally, a single newline. The 10th token is 'everything else' _re_tok += '|(\\r?\\n)' # Match the start tokens of code areas in a template _re_split = '(?m)^[ \t]*(\\\\?)((%(line_start)s)|(%(block_start)s))(%%?)' # Match inline statements (may contain python strings) _re_inl = '%%(inline_start)s((?:%s|[^\'"\n]*?)+)%%(inline_end)s' % _re_inl default_syntax = '<% %> % {{ }}' def __init__(self, source, syntax=None, encoding='utf8'): self.source, self.encoding = touni(source, encoding), encoding self.set_syntax(syntax or self.default_syntax) self.code_buffer, self.text_buffer = [], [] self.lineno, self.offset = 1, 0 self.indent, self.indent_mod = 0, 0 self.paren_depth = 0 def get_syntax(self): ''' Tokens as a space separated string (default: <% %> % {{ }}) ''' return self._syntax def set_syntax(self, syntax): self._syntax = syntax self._tokens = syntax.split() if not syntax in self._re_cache: names = 'block_start block_close line_start inline_start inline_end' etokens = map(re.escape, self._tokens) pattern_vars = dict(zip(names.split(), etokens)) patterns = (self._re_split, self._re_tok, self._re_inl) patterns = [re.compile(p%pattern_vars) for p in patterns] self._re_cache[syntax] = patterns self.re_split, self.re_tok, self.re_inl = self._re_cache[syntax] syntax = property(get_syntax, set_syntax) def translate(self): if self.offset: raise RuntimeError('Parser is a one time instance.') while True: m = self.re_split.search(self.source[self.offset:]) if m: text = self.source[self.offset:self.offset+m.start()] self.text_buffer.append(text) self.offset += m.end() if m.group(1): # New escape syntax line, sep, _ = self.source[self.offset:].partition('\n') self.text_buffer.append(m.group(2)+m.group(5)+line+sep) self.offset += len(line+sep)+1 continue elif m.group(5): # Old escape syntax depr('Escape code lines with a backslash.') #0.12 line, sep, _ = self.source[self.offset:].partition('\n') self.text_buffer.append(m.group(2)+line+sep) self.offset += len(line+sep)+1 continue self.flush_text() self.read_code(multiline=bool(m.group(4))) else: break self.text_buffer.append(self.source[self.offset:]) self.flush_text() return ''.join(self.code_buffer) def read_code(self, multiline): code_line, comment = '', '' while True: m = self.re_tok.search(self.source[self.offset:]) if not m: code_line += self.source[self.offset:] self.offset = len(self.source) self.write_code(code_line.strip(), comment) return code_line += self.source[self.offset:self.offset+m.start()] self.offset += m.end() _str, _com, _po, _pc, _blk1, _blk2, _end, _cend, _nl = m.groups() if (code_line or self.paren_depth > 0) and (_blk1 or _blk2): # a if b else c code_line += _blk1 or _blk2 continue if _str: # Python string code_line += _str elif _com: # Python comment (up to EOL) comment = _com if multiline and _com.strip().endswith(self._tokens[1]): multiline = False # Allow end-of-block in comments elif _po: # open parenthesis self.paren_depth += 1 code_line += _po elif _pc: # close parenthesis if self.paren_depth > 0: # we could check for matching parentheses here, but it's # easier to leave that to python - just check counts self.paren_depth -= 1 code_line += _pc elif _blk1: # Start-block keyword (if/for/while/def/try/...) code_line, self.indent_mod = _blk1, -1 self.indent += 1 elif _blk2: # Continue-block keyword (else/elif/except/...) code_line, self.indent_mod = _blk2, -1 elif _end: # The non-standard 'end'-keyword (ends a block) self.indent -= 1 elif _cend: # The end-code-block template token (usually '%>') if multiline: multiline = False else: code_line += _cend else: # \n self.write_code(code_line.strip(), comment) self.lineno += 1 code_line, comment, self.indent_mod = '', '', 0 if not multiline: break def flush_text(self): text = ''.join(self.text_buffer) del self.text_buffer[:] if not text: return parts, pos, nl = [], 0, '\\\n'+' '*self.indent for m in self.re_inl.finditer(text): prefix, pos = text[pos:m.start()], m.end() if prefix: parts.append(nl.join(map(repr, prefix.splitlines(True)))) if prefix.endswith('\n'): parts[-1] += nl parts.append(self.process_inline(m.group(1).strip())) if pos < len(text): prefix = text[pos:] lines = prefix.splitlines(True) if lines[-1].endswith('\\\\\n'): lines[-1] = lines[-1][:-3] elif lines[-1].endswith('\\\\\r\n'): lines[-1] = lines[-1][:-4] parts.append(nl.join(map(repr, lines))) code = '_printlist((%s,))' % ', '.join(parts) self.lineno += code.count('\n')+1 self.write_code(code) def process_inline(self, chunk): if chunk[0] == '!': return '_str(%s)' % chunk[1:] return '_escape(%s)' % chunk def write_code(self, line, comment=''): line, comment = self.fix_backward_compatibility(line, comment) code = ' ' * (self.indent+self.indent_mod) code += line.lstrip() + comment + '\n' self.code_buffer.append(code) def fix_backward_compatibility(self, line, comment): parts = line.strip().split(None, 2) if parts and parts[0] in ('include', 'rebase'): depr('The include and rebase keywords are functions now.') #0.12 if len(parts) == 1: return "_printlist([base])", comment elif len(parts) == 2: return "_=%s(%r)" % tuple(parts), comment else: return "_=%s(%r, %s)" % tuple(parts), comment if self.lineno <= 2 and not line.strip() and 'coding' in comment: m = re.match(r"#.*coding[:=]\s*([-\w.]+)", comment) if m: depr('PEP263 encoding strings in templates are deprecated.') #0.12 enc = m.group(1) self.source = self.source.encode(self.encoding).decode(enc) self.encoding = enc return line, comment.replace('coding','coding*') return line, comment def template(*args, **kwargs): ''' Get a rendered template as a string iterator. You can use a name, a filename or a template string as first parameter. Template rendering arguments can be passed as dictionaries or directly (as keyword arguments). ''' tpl = args[0] if args else None adapter = kwargs.pop('template_adapter', SimpleTemplate) lookup = kwargs.pop('template_lookup', TEMPLATE_PATH) tplid = (id(lookup), tpl) if tplid not in TEMPLATES or DEBUG: settings = kwargs.pop('template_settings', {}) if isinstance(tpl, adapter): TEMPLATES[tplid] = tpl if settings: TEMPLATES[tplid].prepare(**settings) elif "\n" in tpl or "{" in tpl or "%" in tpl or '$' in tpl: TEMPLATES[tplid] = adapter(source=tpl, lookup=lookup, **settings) else: TEMPLATES[tplid] = adapter(name=tpl, lookup=lookup, **settings) if not TEMPLATES[tplid]: abort(500, 'Template (%s) not found' % tpl) for dictarg in args[1:]: kwargs.update(dictarg) return TEMPLATES[tplid].render(kwargs) mako_template = functools.partial(template, template_adapter=MakoTemplate) cheetah_template = functools.partial(template, template_adapter=CheetahTemplate) jinja2_template = functools.partial(template, template_adapter=Jinja2Template) def view(tpl_name, **defaults): ''' Decorator: renders a template for a handler. The handler can control its behavior like that: - return a dict of template vars to fill out the template - return something other than a dict and the view decorator will not process the template, but return the handler result as is. This includes returning a HTTPResponse(dict) to get, for instance, JSON with autojson or other castfilters. ''' def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): result = func(*args, **kwargs) if isinstance(result, (dict, DictMixin)): tplvars = defaults.copy() tplvars.update(result) return template(tpl_name, **tplvars) elif result is None: return template(tpl_name, defaults) return result return wrapper return decorator mako_view = functools.partial(view, template_adapter=MakoTemplate) cheetah_view = functools.partial(view, template_adapter=CheetahTemplate) jinja2_view = functools.partial(view, template_adapter=Jinja2Template) ############################################################################### # Constants and Globals ######################################################## ############################################################################### TEMPLATE_PATH = ['./', './views/'] TEMPLATES = {} DEBUG = False NORUN = False # If set, run() does nothing. Used by load_app() #: A dict to map HTTP status codes (e.g. 404) to phrases (e.g. 'Not Found') HTTP_CODES = httplib.responses HTTP_CODES[418] = "I'm a teapot" # RFC 2324 HTTP_CODES[422] = "Unprocessable Entity" # RFC 4918 HTTP_CODES[428] = "Precondition Required" HTTP_CODES[429] = "Too Many Requests" HTTP_CODES[431] = "Request Header Fields Too Large" HTTP_CODES[511] = "Network Authentication Required" _HTTP_STATUS_LINES = dict((k, '%d %s'%(k,v)) for (k,v) in HTTP_CODES.items()) #: The default template used for error pages. Override with @error() ERROR_PAGE_TEMPLATE = """ %%try: %%from %s import DEBUG, HTTP_CODES, request, touni <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN"> <html> <head> <title>Error: {{e.status}}</title> <style type="text/css"> html {background-color: #eee; font-family: sans;} body {background-color: #fff; border: 1px solid #ddd; padding: 15px; margin: 15px;} pre {background-color: #eee; border: 1px solid #ddd; padding: 5px;} </style> </head> <body> <h1>Error: {{e.status}}</h1> <p>Sorry, the requested URL <tt>{{repr(request.url)}}</tt> caused an error:</p> <pre>{{e.body}}</pre> %%if DEBUG and e.exception: <h2>Exception:</h2> <pre>{{repr(e.exception)}}</pre> %%end %%if DEBUG and e.traceback: <h2>Traceback:</h2> <pre>{{e.traceback}}</pre> %%end </body> </html> %%except ImportError: <b>ImportError:</b> Could not generate the error page. Please add bottle to the import path. %%end """ % __name__ #: A thread-safe instance of :class:`LocalRequest`. If accessed from within a #: request callback, this instance always refers to the *current* request #: (even on a multithreaded server). request = LocalRequest() #: A thread-safe instance of :class:`LocalResponse`. It is used to change the #: HTTP response for the *current* request. response = LocalResponse() #: A thread-safe namespace. Not used by Bottle. local = threading.local() # Initialize app stack (create first empty Bottle app) # BC: 0.6.4 and needed for run() app = default_app = AppStack() app.push() #: A virtual package that redirects import statements. #: Example: ``import bottle.ext.sqlite`` actually imports `bottle_sqlite`. ext = _ImportRedirect('bottle.ext' if __name__ == '__main__' else __name__+".ext", 'bottle_%s').module if __name__ == '__main__': opt, args, parser = _cmd_options, _cmd_args, _cmd_parser if opt.version: _stdout('Bottle %s\n'%__version__) sys.exit(0) if not args: parser.print_help() _stderr('\nError: No application specified.\n') sys.exit(1) sys.path.insert(0, '.') sys.modules.setdefault('bottle', sys.modules['__main__']) host, port = (opt.bind or 'localhost'), 8080 if ':' in host and host.rfind(']') < host.rfind(':'): host, port = host.rsplit(':', 1) host = host.strip('[]') run(args[0], host=host, port=int(port), server=opt.server, reloader=opt.reload, plugins=opt.plugin, debug=opt.debug) # THE END |
Added changelog.txt version [b2b4236d65].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | # CHANGELOG OF GRAMMALECTE ## 0.0 Alpha version, similar to Lightproof (a grammar checker for LibreOffice) ## 0.1 Lexical analysis commands with disambiguation by pattern exclusion Optional suggestions Back reference groups within error messages ## 0.2 Bi-passes engine Pass 1: paragraph by paragraph Pass 2: sentence by sentence Text preprocessor between the two passes Error positioning (by group selection) ## 0.3 Multi-passes engine Dictionary switcher Text formatter Lexicographer French Conjugueur ## 0.4 Suggestion mechanisms Simplier user options writing Application Launcher Author field edition ## 0.5 Grammalecte is an autonomous package, free from Hunspell and LibreOffice Indexable binary dictionary (DAWG-FSA) generator Disambiguator Multi-actions rules (bi-passes engine again) Simplier options for word boundaries Unit tests |
Added cli.py version [844acbe744].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 | #!python3 import sys import os.path import argparse import json import grammalecte.fr as gce import grammalecte.fr.lexicographe as lxg import grammalecte.fr.textformatter as tf import grammalecte.text as txt import grammalecte.tokenizer as tkz from grammalecte.echo import echo _EXAMPLE = "Quoi ? Racontes ! Racontes-moi ! Bon sangg, parles ! Oui. Il y a des menteur partout. " \ "Je suit sidéré par la brutales arrogance de cette homme-là. Quelle salopard ! Un escrocs de la pire espece. " \ "Quant sera t’il châtiés pour ses mensonge ? Merde ! J’en aie marre." _HELP = """ /help /h show this text ?word1 [word2] ... words analysis /lopt /lo list options /+ option1 [option2] ... activate grammar checking options /- option1 [option2] ... deactivate grammar checking options /lrules [pattern] /lr list rules /--rule1 [rule2] ... deactivate grammar checking rule /++rule1 [rule2] ... reactivate grammar checking rule /quit /q exit """ def _getText (sInputText): sText = input(sInputText) if sText == "*": return _EXAMPLE if sys.platform == "win32": # Apparently, the console transforms «’» in «'». # So we reverse it to avoid many useless warnings. sText = sText.replace("'", "’") return sText def _getErrors (sText, oTokenizer, oDict, bContext=False, bDebug=False): "returns a tuple: (grammar errors, spelling errors)" aGrammErrs = gce.parse(sText, "FR", bDebug=bDebug, bContext=bContext) aSpellErrs = [] for dToken in oTokenizer.genTokens(sText): if dToken['sType'] == "WORD" and not oDict.isValidToken(dToken['sValue']): aSpellErrs.append(dToken) return aGrammErrs, aSpellErrs def generateText (sText, oTokenizer, oDict, bDebug=False, bEmptyIfNoErrors=False, nWidth=100): aGrammErrs, aSpellErrs = _getErrors(sText, oTokenizer, oDict, False, bDebug) if bEmptyIfNoErrors and not aGrammErrs and not aSpellErrs: return "" return txt.generateParagraph(sText, aGrammErrs, aSpellErrs, nWidth) def generateJSON (iIndex, sText, oTokenizer, oDict, bContext=False, bDebug=False, bEmptyIfNoErrors=False, lLineSet=None, bReturnText=False): aGrammErrs, aSpellErrs = _getErrors(sText, oTokenizer, oDict, bContext, bDebug) aGrammErrs = list(aGrammErrs) if bEmptyIfNoErrors and not aGrammErrs and not aSpellErrs: return "" if lLineSet: aGrammErrs, aSpellErrs = txt.convertToXY(aGrammErrs, aSpellErrs, lLineSet) return json.dumps({ "lGrammarErrors": aGrammErrs, "lSpellingErrors": aSpellErrs }, ensure_ascii=False) if bReturnText: return json.dumps({ "iParagraph": iIndex, "sText": sText, "lGrammarErrors": aGrammErrs, "lSpellingErrors": aSpellErrs }, ensure_ascii=False) return json.dumps({ "iParagraph": iIndex, "lGrammarErrors": aGrammErrs, "lSpellingErrors": aSpellErrs }, ensure_ascii=False) def readfile (spf): "generator: returns file line by line" if os.path.isfile(spf): with open(spf, "r", encoding="utf-8") as hSrc: for sLine in hSrc: yield sLine else: print("# Error: file not found.") def readfileAndConcatLines (spf): "generator: returns text by list of lines not separated by an empty line" lLine = [] for i, sLine in enumerate(readfile(spf), 1): if sLine.strip(): lLine.append((i, sLine)) elif lLine: yield lLine lLine = [] if lLine: yield lLine def output (sText, hDst=None): if not hDst: echo(sText, end="") else: hDst.write(sText) def main (): xParser = argparse.ArgumentParser() xParser.add_argument("-f", "--file", help="parse file (UTF-8 required!) [on Windows, -f is similar to -ff]", type=str) xParser.add_argument("-ff", "--file_to_file", help="parse file (UTF-8 required!) and create a result file (*.res.txt)", type=str) xParser.add_argument("-owe", "--only_when_errors", help="display results only when there are errors", action="store_true") xParser.add_argument("-j", "--json", help="generate list of errors in JSON (only with option --file or --file_to_file)", action="store_true") xParser.add_argument("-cl", "--concat_lines", help="concatenate lines not separated by an empty paragraph (only with option --file or --file_to_file)", action="store_true") xParser.add_argument("-tf", "--textformatter", help="auto-format text according to typographical rules (unavailable with option --concat_lines)", action="store_true") xParser.add_argument("-tfo", "--textformatteronly", help="auto-format text and disable grammar checking (only with option --file or --file_to_file)", action="store_true") xParser.add_argument("-ctx", "--context", help="return errors with context (only with option --json)", action="store_true") xParser.add_argument("-w", "--width", help="width in characters (40 < width < 200; default: 100)", type=int, choices=range(40,201,10), default=100) xParser.add_argument("-lo", "--list_options", help="list options", action="store_true") xParser.add_argument("-lr", "--list_rules", nargs="?", help="list rules [regex pattern as filter]", const="*") xParser.add_argument("-on", "--opt_on", nargs="+", help="activate options") xParser.add_argument("-off", "--opt_off", nargs="+", help="deactivate options") xParser.add_argument("-roff", "--rule_off", nargs="+", help="deactivate rules") xParser.add_argument("-d", "--debug", help="debugging mode (only in interactive mode)", action="store_true") xArgs = xParser.parse_args() gce.load() if not xArgs.json: echo("Grammalecte v{}".format(gce.version)) oDict = gce.getDictionary() oTokenizer = tkz.Tokenizer("fr") oLexGraphe = lxg.Lexicographe(oDict) if xArgs.textformatter or xArgs.textformatteronly: oTF = tf.TextFormatter() if xArgs.list_options or xArgs.list_rules: if xArgs.list_options: gce.displayOptions("fr") if xArgs.list_rules: gce.displayRules(None if xArgs.list_rules == "*" else xArgs.list_rules) exit() if not xArgs.json: xArgs.context = False gce.setOptions({"html": True, "latex": True}) if xArgs.opt_on: gce.setOptions({ opt:True for opt in xArgs.opt_on if opt in gce.getOptions() }) if xArgs.opt_off: gce.setOptions({ opt:False for opt in xArgs.opt_off if opt in gce.getOptions() }) if xArgs.rule_off: for sRule in xArgs.rule_off: gce.ignoreRule(sRule) sFile = xArgs.file or xArgs.file_to_file if sFile: # file processing hDst = open(sFile[:sFile.rfind(".")]+".res.txt", "w", encoding="utf-8", newline="\n") if xArgs.file_to_file or sys.platform == "win32" else None bComma = False if xArgs.json: output('{ "grammalecte": "'+gce.version+'", "lang": "'+gce.lang+'", "data" : [\n', hDst) if not xArgs.concat_lines: # pas de concaténation des lignes for i, sText in enumerate(readfile(sFile), 1): if xArgs.textformatter or xArgs.textformatteronly: sText = oTF.formatText(sText) if xArgs.textformatteronly: output(sText, hDst) else: if xArgs.json: sText = generateJSON(i, sText, oTokenizer, oDict, bContext=xArgs.context, bDebug=False, bEmptyIfNoErrors=xArgs.only_when_errors, bReturnText=xArgs.textformatter) else: sText = generateText(sText, oTokenizer, oDict, bDebug=False, bEmptyIfNoErrors=xArgs.only_when_errors, nWidth=xArgs.width) if sText: if xArgs.json and bComma: output(",\n", hDst) output(sText, hDst) bComma = True if hDst: echo("§ %d\r" % i, end="", flush=True) else: # concaténation des lignes non séparées par une ligne vide for i, lLine in enumerate(readfileAndConcatLines(sFile), 1): sText, lLineSet = txt.createParagraphWithLines(lLine) if xArgs.json: sText = generateJSON(i, sText, oTokenizer, oDict, bContext=xArgs.context, bDebug=False, bEmptyIfNoErrors=xArgs.only_when_errors, lLineSet=lLineSet) else: sText = generateText(sText, oTokenizer, oDict, bDebug=False, bEmptyIfNoErrors=xArgs.only_when_errors, nWidth=xArgs.width) if sText: if xArgs.json and bComma: output(",\n", hDst) output(sText, hDst) bComma = True if hDst: echo("§ %d\r" % i, end="", flush=True) if xArgs.json: output("\n]}\n", hDst) else: # pseudo-console sInputText = "\n~==========~ Enter your text [/h /q] ~==========~\n" sText = _getText(sInputText) while True: if sText.startswith("?"): for sWord in sText[1:].strip().split(): if sWord: echo("* {}".format(sWord)) for sMorph in oDict.getMorph(sWord): echo(" {:<32} {}".format(sMorph, oLexGraphe.formatTags(sMorph))) elif sText.startswith("/+ "): gce.setOptions({ opt:True for opt in sText[3:].strip().split() if opt in gce.getOptions() }) echo("done") elif sText.startswith("/- "): gce.setOptions({ opt:False for opt in sText[3:].strip().split() if opt in gce.getOptions() }) echo("done") elif sText.startswith("/-- "): for sRule in sText[3:].strip().split(): gce.ignoreRule(sRule) echo("done") elif sText.startswith("/++ "): for sRule in sText[3:].strip().split(): gce.reactivateRule(sRule) echo("done") elif sText == "/debug" or sText == "/d": xArgs.debug = not(xArgs.debug) echo("debug mode on" if xArgs.debug else "debug mode off") elif sText == "/textformatter" or sText == "/tf": xArgs.textformatter = not(xArgs.textformatter) echo("textformatter on" if xArgs.debug else "textformatter off") elif sText == "/help" or sText == "/h": echo(_HELP) elif sText == "/lopt" or sText == "/l": gce.displayOptions("fr") elif sText.startswith("/lr"): sText = sText.strip() sFilter = sText[sText.find(" "):].strip() if sText != "/lr" and sText != "/rules" else None gce.displayRules(sFilter) elif sText == "/quit" or sText == "/q": break elif sText.startswith("/rl"): # reload (todo) pass else: for sParagraph in txt.getParagraph(sText): if xArgs.textformatter: sText = oTF.formatText(sText) sRes = generateText(sText, oTokenizer, oDict, bDebug=xArgs.debug, bEmptyIfNoErrors=xArgs.only_when_errors, nWidth=xArgs.width) if sRes: echo("\n" + sRes) else: echo("\nNo error found.") sText = _getText(sInputText) if __name__ == '__main__': main() |
Added compile_rules.py version [7ac4ebe558].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 | import re import sys import traceback import copy import json from distutils import file_util DEF = {} FUNCTIONS = [] JSREGEXES = {} WORDLIMITLEFT = r"(?<![\w.,–-])" # r"(?<![-.,—])\b" seems slower WORDLIMITRIGHT = r"(?![\w–-])" # r"\b(?!-—)" seems slower def prepareFunction (s): s = s.replace("__also__", "bCondMemo") s = s.replace("__else__", "not bCondMemo") s = re.sub(r"(select|exclude)[(][\\](\d+)", '\\1(dDA, m.start(\\2), m.group(\\2)', s) s = re.sub(r"define[(][\\](\d+)", 'define(dDA, m.start(\\1)', s) s = re.sub(r"(morph|morphex|displayInfo)[(][\\](\d+)", '\\1((m.start(\\2), m.group(\\2))', s) s = re.sub(r"(morph|morphex|displayInfo)[(]", '\\1(dDA, ', s) s = re.sub(r"(sugg\w+|switch\w+)\(@", '\\1(m.group(i[4])', s) s = re.sub(r"word\(\s*1\b", 'nextword1(s, m.end()', s) # word(1) s = re.sub(r"word\(\s*-1\b", 'prevword1(s, m.start()', s) # word(-1) s = re.sub(r"word\(\s*(\d)", 'nextword(s, m.end(), \\1', s) # word(n) s = re.sub(r"word\(\s*-(\d)", 'prevword(s, m.start(), \\1', s) # word(-n) s = re.sub(r"before\(\s*", 'look(s[:m.start()], ', s) # before(s) s = re.sub(r"after\(\s*", 'look(s[m.end():], ', s) # after(s) s = re.sub(r"textarea\(\s*", 'look(s, ', s) # textarea(s) s = re.sub(r"before_chk1\(\s*", 'look_chk1(dDA, s[:m.start()], 0, ', s) # before_chk1(s) s = re.sub(r"after_chk1\(\s*", 'look_chk1(dDA, s[m.end():], m.end(), ', s) # after_chk1(s) s = re.sub(r"textarea_chk1\(\s*", 'look_chk1(dDA, s, 0, ', s) # textarea_chk1(s) s = re.sub(r"/0", 'sx[m.start():m.end()]', s) # /0 s = re.sub(r"before0\(\s*", 'look(sx[:m.start()], ', s) # before0(s) s = re.sub(r"after0\(\s*", 'look(sx[m.end():], ', s) # after0(s) s = re.sub(r"textarea0\(\s*", 'look(sx, ', s) # textarea0(s) s = re.sub(r"before0_chk1\(\s*", 'look_chk1(dDA, sx[:m.start()], 0, ', s) # before0_chk1(s) s = re.sub(r"after0_chk1\(\s*", 'look_chk1(dDA, sx[m.end():], m.end(), ', s) # after0_chk1(s) s = re.sub(r"textarea0_chk1\(\s*", 'look_chk1(dDA, sx, 0, ', s) # textarea0_chk1(s) s = re.sub(r"isEndOfNG\(\s*\)", 'isEndOfNG(dDA, s[m.end():], m.end())', s) # isEndOfNG(s) s = re.sub(r"isNextNotCOD\(\s*\)", 'isNextNotCOD(dDA, s[m.end():], m.end())', s) # isNextNotCOD(s) s = re.sub(r"isNextVerb\(\s*\)", 'isNextVerb(dDA, s[m.end():], m.end())', s) # isNextVerb(s) s = re.sub(r"\bspell *[(]", '_oDict.isValid(', s) s = re.sub(r"[\\](\d+)", 'm.group(\\1)', s) return s def py2js (sCode): "convert Python code to JavaScript code" # Python 2.x unicode strings sCode = re.sub('\\b[ur]"', '"', sCode) sCode = re.sub("\\b[ur]'", "'", sCode) # operators sCode = sCode.replace(" and ", " && ") sCode = sCode.replace(" or ", " || ") sCode = re.sub("\\bnot\\b", "!", sCode) sCode = re.sub("(.+) if (.+) else (.+)", "(\\2) ? \\1 : \\3", sCode) # boolean sCode = sCode.replace("False", "false") sCode = sCode.replace("True", "true") sCode = sCode.replace("bool", "Boolean") # methods sCode = sCode.replace(".__len__()", ".length") sCode = sCode.replace(".endswith", ".endsWith") sCode = sCode.replace(".find", ".indexOf") sCode = sCode.replace(".startswith", ".startsWith") sCode = sCode.replace(".lower", ".toLowerCase") sCode = sCode.replace(".upper", ".toUpperCase") sCode = sCode.replace(".isdigit", "._isDigit") sCode = sCode.replace(".isupper", "._isUpperCase") sCode = sCode.replace(".islower", "._isLowerCase") sCode = sCode.replace(".istitle", "._isTitle") sCode = sCode.replace(".capitalize", "._toCapitalize") sCode = sCode.replace(".strip", "._trim") sCode = sCode.replace(".lstrip", "._trimLeft") sCode = sCode.replace(".rstrip", "._trimRight") sCode = sCode.replace('.replace("."', ".replace(/\./g") sCode = sCode.replace('.replace("..."', ".replace(/\.\.\./g") sCode = re.sub('.replace\("([^"]+)" ?,', ".replace(/\\1/g,", sCode) # regex sCode = re.sub('re.search\("([^"]+)", *(m.group\(\\d\))\)', "(\\2.search(/\\1/) >= 0)", sCode) sCode = re.sub(".search\\(/\\(\\?i\\)([^/]+)/\\) >= 0\\)", ".search(/\\1/i) >= 0)", sCode) sCode = re.sub('(look\\(sx?[][.a-z:()]*), "\\(\\?i\\)([^"]+)"', "\\1, /\\2/i", sCode) sCode = re.sub('(look\\(sx?[][.a-z:()]*), "([^"]+)"', "\\1, /\\2/", sCode) sCode = re.sub('(look_chk1\\(dDA, sx?[][.a-z:()]*, [0-9a-z.()]+), "\\(\\?i\\)([^"]+)"', "\\1, /\\2/i", sCode) sCode = re.sub('(look_chk1\\(dDA, sx?[][.a-z:()]*, [0-9a-z.()]+), "([^"]+)"', "\\1, /\\2/i", sCode) sCode = sCode.replace("(?<!-)", "") # todo # slices sCode = sCode.replace("[:m.start()]", ".slice(0,m.index)") sCode = sCode.replace("[m.end():]", ".slice(m.end[0])") sCode = sCode.replace("[m.start():m.end()]", ".slice(m.index, m.end[0])") sCode = re.sub("\\[(-?\\d+):(-?\\d+)\\]", ".slice(\\1,\\2)", sCode) sCode = re.sub("\\[(-?\\d+):\\]", ".slice(\\1)", sCode) sCode = re.sub("\\[:(-?\\d+)\\]", ".slice(0,\\1)", sCode) # regex matches sCode = sCode.replace(".end()", ".end[0]") sCode = sCode.replace(".start()", ".index") sCode = sCode.replace("m.group()", "m[0]") sCode = re.sub("\\.start\\((\\d+)\\)", ".start[\\1]", sCode) sCode = re.sub("m\\.group\\((\\d+)\\)", "m[\\1]", sCode) # tuples -> lists sCode = re.sub("\((m\.start\[\\d+\], m\[\\d+\])\)", "[\\1]", sCode) # regex sCode = sCode.replace("\w[\w-]+", "[a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯfi-st][a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯfi-st-]+") sCode = sCode.replace(r"/\w/", "/[a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯfi-st]/") sCode = sCode.replace(r"[\w-]", "[a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯfi-st-]") sCode = sCode.replace(r"[\w,]", "[a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯfi-st,]") return sCode def uppercase (s, sLang): "(flag i is not enough): converts regex to uppercase regex: 'foo' becomes '[Ff][Oo][Oo]', but 'Bar' becomes 'B[Aa][Rr]'." sUp = "" nState = 0 for i in range(0, len(s)): c = s[i] if c == "[": nState = 1 if nState == 1 and c == "]": nState = 0 if c == "<" and i > 3 and s[i-3:i] == "(?P": nState = 2 if nState == 2 and c == ">": nState = 0 if c == "?" and i > 0 and s[i-1:i] == "(" and s[i+1:i+2] != ":": nState = 5 if nState == 5 and c == ")": nState = 0 if c.isalpha() and c.islower() and nState == 0: if c == "i" and (sLang == "tr" or sLang == "az"): sUp += "[İ" + c + "]" else: sUp += "[" + c.upper() + c + "]" elif c.isalpha() and c.islower() and nState == 1 and s[i+1:i+2] != "-": if s[i-1:i] == "-" and s[i-2:i-1].islower(): # [a-z] -> [a-zA-Z] sUp += c + s[i-2:i-1].upper() + "-" + c.upper() elif c == "i" and (sLang == "tr" or sLang == "az"): sUp += "İ" + c else: sUp += c.upper() + c else: sUp += c if c == "\\": nState = 4 elif nState == 4: nState = 0 return sUp def countGroupInRegex (sRegex): try: return re.compile(sRegex).groups except: traceback.print_exc() print(sRegex) return 0 def createRule (s, nIdLine, sLang, bParagraph, dOptPriority): "returns rule as list [option name, regex, bCaseInsensitive, identifier, list of actions]" global JSREGEXES #### OPTIONS sLineId = str(nIdLine) + ("p" if bParagraph else "s") sRuleId = sLineId sOption = False # False or [a-z0-9]+ name nPriority = 4 # Default is 4, value must be between 0 and 9 tGroups = None # code for groups positioning (only useful for JavaScript) cCaseMode = 'i' # i: case insensitive, s: case sensitive, u: uppercasing allowed cWordLimitLeft = '[' # [: word limit, <: no specific limit cWordLimitRight = ']' # ]: word limit, >: no specific limit m = re.match("^__([[<]\\w[]>])(/[a-zA-Z0-9]+|)(\\(\\w+\\)|)(![0-9]|)__ *", s) if m: cWordLimitLeft = m.group(1)[0] cCaseMode = m.group(1)[1] cWordLimitRight = m.group(1)[2] sOption = m.group(2)[1:] if m.group(2) else False if m.group(3): sRuleId = m.group(3)[1:-1] nPriority = dOptPriority.get(sOption, 4) if m.group(4): nPriority = int(m.group(4)[1:]) s = s[m.end(0):] else: print("Warning. No option defined at line: " + sLineId) #### REGEX TRIGGER i = s.find(" <<-") if i == -1: print("# Error: no condition at line " + sLineId) return None sRegex = s[:i].strip() s = s[i+4:] # JS groups positioning codes m = re.search("@@\\S+", sRegex) if m: tGroups = groupsPositioningCodeToList(sRegex[m.start()+2:]) sRegex = sRegex[:m.start()].strip() # JS regex m = re.search("<js>.+</js>i?", sRegex) if m: JSREGEXES[sLineId] = m.group(0) sRegex = sRegex[:m.start()].strip() if "<js>" in sRegex or "</js>" in sRegex: print("# Error: JavaScript regex not delimited at line " + sLineId) return None # quotes ? if sRegex.startswith('"') and sRegex.endswith('"'): sRegex = sRegex[1:-1] ## definitions for sDef, sRepl in DEF.items(): sRegex = sRegex.replace(sDef, sRepl) ## count number of groups (must be done before modifying the regex) nGroup = countGroupInRegex(sRegex) if nGroup > 0: if not tGroups: print("# warning: groups positioning code for JavaScript should be defined at line " + sLineId) else: if nGroup != len(tGroups): print("# error: groups positioning code irrelevant at line " + sLineId) ## word limit if cWordLimitLeft == '[' and not sRegex.startswith(("^", '’', "'", ",")): sRegex = WORDLIMITLEFT + sRegex if cWordLimitRight == ']' and not sRegex.endswith(("$", '’', "'", ",")): sRegex = sRegex + WORDLIMITRIGHT ## casing mode if cCaseMode == "i": bCaseInsensitive = True if not sRegex.startswith("(?i)"): sRegex = "(?i)" + sRegex elif cCaseMode == "s": bCaseInsensitive = False sRegex = sRegex.replace("(?i)", "") elif cCaseMode == "u": bCaseInsensitive = False sRegex = sRegex.replace("(?i)", "") sRegex = uppercase(sRegex, sLang) else: print("# Unknown case mode [" + cCaseMode + "] at line " + sLineId) ## check regex try: z = re.compile(sRegex) except: print("# Regex error at line ", nIdLine) print(sRegex) traceback.print_exc() return None ## groups in non grouping parenthesis for x in re.finditer("\(\?:[^)]*\([[\w -]", sRegex): print("# Warning: groups inside non grouping parenthesis in regex at line " + sLineId) #### PARSE ACTIONS lActions = [] nAction = 1 for sAction in s.split(" <<- "): t = createAction(sLineId + "_" + str(nAction), sAction, nGroup) nAction += 1 if t: lActions.append(t) if not lActions: return None return [sOption, sRegex, bCaseInsensitive, sLineId, sRuleId, nPriority, lActions, tGroups] def createAction (sIdAction, sAction, nGroup): "returns an action to perform as a tuple (condition, action type, action[, iGroup [, message, URL ]])" global FUNCTIONS m = re.search(r"([-~=>])(\d*|)>>", sAction) if not m: print("# No action at line " + sIdAction) return None #### CONDITION sCondition = sAction[:m.start()].strip() if sCondition: sCondition = prepareFunction(sCondition) FUNCTIONS.append(("c"+sIdAction, sCondition)) for x in re.finditer("[.](?:group|start|end)[(](\d+)[)]", sCondition): if int(x.group(1)) > nGroup: print("# Error in groups in condition at line " + sIdAction + " ("+str(nGroup)+" groups only)") if ".match" in sCondition: print("# Error. JS compatibility. Don't use .match() in condition, use .search()") sCondition = "c"+sIdAction else: sCondition = None #### iGroup / positioning iGroup = int(m.group(2)) if m.group(2) else 0 if iGroup > nGroup: print("# Selected group > group number in regex at line " + sIdAction) #### ACTION sAction = sAction[m.end():].strip() cAction = m.group(1) if cAction == "-": ## error iMsg = sAction.find(" # ") sMsg = sAction[iMsg+3:].strip() sAction = sAction[:iMsg].strip() sURL = "" mURL = re.search("[|] *(https?://.*)", sMsg) if mURL: sURL = mURL.group(1).strip() sMsg = sMsg[:mURL.start(0)].strip() if sMsg[0:1] == "=": sMsg = prepareFunction(sMsg[1:]) FUNCTIONS.append(("m"+sIdAction, sMsg)) for x in re.finditer("group[(](\d+)[)]", sMsg): if int(x.group(1)) > nGroup: print("# error in groups in message at line " + sIdAction + " ("+str(nGroup)+" groups only)") sMsg = "=m"+sIdAction else: for x in re.finditer(r"\\(\d+)", sMsg): if int(x.group(1)) > nGroup: print("# error in groups in message at line " + sIdAction + " ("+str(nGroup)+" groups only)") if re.search("[.]\\w+[(]", sMsg): print("# error in message at line " + sIdAction + ": This message looks like code. Line should begin with =") if sAction[0:1] == "=" or cAction == "=": if "define" in sAction and not re.search(r"define\(\\\d+ *, *\[.*\] *\)", sAction): print("# error in action at line " + sIdAction + ": second argument for define must be a list of strings") sAction = prepareFunction(sAction) sAction = sAction.replace("m.group(i[4])", "m.group("+str(iGroup)+")") for x in re.finditer("group[(](\d+)[)]", sAction): if int(x.group(1)) > nGroup: print("# error in groups in replacement at line " + sIdAction + " ("+str(nGroup)+" groups only)") else: for x in re.finditer(r"\\(\d+)", sAction): if int(x.group(1)) > nGroup: print("# error in groups in replacement at line " + sIdAction + " ("+str(nGroup)+" groups only)") if re.search("[.]\\w+[(]", sAction): print("# error in action at line " + sIdAction + ": This action looks like code. Line should begin with =") if cAction == "-": ## error detected if not sAction: print("# error in action at line " + sIdAction + ": This action is empty.") if sAction[0:1] == "=": FUNCTIONS.append(("s"+sIdAction, sAction[1:])) sAction = "=s"+sIdAction elif sAction.startswith('"') and sAction.endswith('"'): sAction = sAction[1:-1] if not sMsg: print("# error in action at line " + sIdAction + ": the message is empty.") return [sCondition, cAction, sAction, iGroup, sMsg, sURL] elif cAction == "~": ## text preprocessor if not sAction: print("# error in action at line " + sIdAction + ": This action is empty.") if sAction[0:1] == "=": FUNCTIONS.append(("p"+sIdAction, sAction[1:])) sAction = "=p"+sIdAction elif sAction.startswith('"') and sAction.endswith('"'): sAction = sAction[1:-1] return [sCondition, cAction, sAction, iGroup] elif cAction == "=": ## disambiguator if sAction[0:1] == "=": sAction = sAction[1:] if not sAction: print("# error in action at line " + sIdAction + ": This action is empty.") FUNCTIONS.append(("d"+sIdAction, sAction)) sAction = "d"+sIdAction return [sCondition, cAction, sAction] elif cAction == ">": ## no action, break loop if condition is False return [sCondition, cAction, ""] else: print("# Unknown action at line " + sIdAction) return None def regex2js (sRegex): "converts Python regex to JS regex and returns JS regex and list of negative lookbefore assertions" # Latin letters: http://unicode-table.com/fr/ # 0-9 and _ # A-Z # a-z # À-Ö 00C0-00D6 (upper case) # Ø-ß 00D8-00DF (upper case) # à-ö 00E0-00F6 (lower case) # ø-ÿ 00F8-00FF (lower case) # Ā-ʯ 0100-02AF (mixed) # -> a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯ bCaseInsensitive = False if "(?i)" in sRegex: sRegex = sRegex.replace("(?i)", "") bCaseInsensitive = True lNegLookBeforeRegex = [] if WORDLIMITLEFT in sRegex: sRegex = sRegex.replace(WORDLIMITLEFT, "") lNegLookBeforeRegex = ["[a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯ.,–-]$"] sRegex = sRegex.replace("[\\w", "[a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯ") sRegex = sRegex.replace("\\w", "[a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯ]") sRegex = sRegex.replace("[.]", r"\.") if not sRegex.startswith("<js>"): sRegex = sRegex.replace("/", r"\/") m = re.search(r"\(\?<!([^()]+)\)", sRegex) # Negative lookbefore assertion should always be at the beginning of regex if m: lNegLookBeforeRegex.append(m.group(1)+"$") sRegex = sRegex.replace(m.group(0), "") if "(?<" in sRegex: print("# Warning. Lookbefore assertion not changed in:\n ") print(sRegex) if sRegex.startswith("<js>"): sRegex = sRegex.replace('<js>', '/').replace('</js>i', '/ig').replace('</js>', '/g') else: sRegex = "/" + sRegex + "/g" if bCaseInsensitive and not sRegex.endswith("/ig"): sRegex = sRegex + "i" if not lNegLookBeforeRegex: lNegLookBeforeRegex = None return (sRegex, lNegLookBeforeRegex) def pyRuleToJS (lRule): lRuleJS = copy.deepcopy(lRule) del lRule[-1] # tGroups positioning codes are useless for Python # error messages for aAction in lRuleJS[6]: if aAction[1] == "-": aAction[4] = aAction[4].replace("« ", "« ").replace(" »", " »") # js regexes lRuleJS[1], lNegLookBehindRegex = regex2js( JSREGEXES.get(lRuleJS[3], lRuleJS[1]) ) lRuleJS.append(lNegLookBehindRegex) return lRuleJS def writeRulesToJSArray (lRules): sArray = "[\n" for sOption, aRuleGroup in lRules: sArray += ' ["' + sOption + '", [\n' if sOption else " [false, [\n" for sRegex, bCaseInsensitive, sLineId, sRuleId, nPriority, lActions, aGroups, aNegLookBehindRegex in aRuleGroup: sArray += ' [' + sRegex + ", " sArray += "true, " if bCaseInsensitive else "false, " sArray += '"' + sLineId + '", ' sArray += '"' + sRuleId + '", ' sArray += str(nPriority) + ", " sArray += json.dumps(lActions, ensure_ascii=False) + ", " sArray += json.dumps(aGroups, ensure_ascii=False) + ", " sArray += json.dumps(aNegLookBehindRegex, ensure_ascii=False) + "],\n" sArray += " ]],\n" sArray += "]" return sArray def groupsPositioningCodeToList (sGroupsPositioningCode): if not sGroupsPositioningCode: return None return [ int(sCode) if sCode.isdigit() or (sCode[0:1] == "-" and sCode[1:].isdigit()) else sCode \ for sCode in sGroupsPositioningCode.split(",") ] def _calcRulesStats (lRules): d = {'=':0, '~': 0, '-': 0, '>': 0} for aRule in lRules: for aAction in aRule[6]: d[aAction[1]] = d[aAction[1]] + 1 return (d, len(lRules)) def displayStats (lParagraphRules, lSentenceRules): print(" {:>18} {:>18} {:>18} {:>18}".format("DISAMBIGUATOR", "TEXT PROCESSOR", "GRAMMAR CHECKING", "REGEX")) d, nRule = _calcRulesStats(lParagraphRules) print("§ {:>10} actions {:>10} actions {:>10} actions in {:>8} rules".format(d['='], d['~'], d['-'], nRule)) d, nRule = _calcRulesStats(lSentenceRules) print("s {:>10} actions {:>10} actions {:>10} actions in {:>8} rules".format(d['='], d['~'], d['-'], nRule)) def mergeRulesByOption (lRules): "returns a list of tuples [option, list of rules] keeping the rules order" lFinal = [] lTemp = [] sOption = None for aRule in lRules: if aRule[0] != sOption: if sOption != None: lFinal.append([sOption, lTemp]) # new tuple sOption = aRule[0] lTemp = [] lTemp.append(aRule[1:]) lFinal.append([sOption, lTemp]) return lFinal def prepareOptions (lOptionLines): "returns a dictionary with data about options" sLang = "" lStructOpt = [] lOpt = [] dOptLabel = {} dOptPriority = {} for sLine in lOptionLines: sLine = sLine.strip() if sLine.startswith("OPTGROUP/"): m = re.match("OPTGROUP/([a-z0-9]+):(.+)$", sLine) lStructOpt.append( (m.group(1), list(map(str.split, m.group(2).split(",")))) ) elif sLine.startswith("OPTSOFTWARE:"): lOpt = [ [s, {}] for s in sLine[12:].strip().split() ] # don’t use tuples (s, {}), because unknown to JS elif sLine.startswith("OPT/"): m = re.match("OPT/([a-z0-9]+):(.+)$", sLine) for i, sOpt in enumerate(m.group(2).split()): lOpt[i][1][m.group(1)] = eval(sOpt) elif sLine.startswith("OPTPRIORITY/"): m = re.match("OPTPRIORITY/([a-z0-9]+): *([0-9])$", sLine) dOptPriority[m.group(1)] = int(m.group(2)) elif sLine.startswith("OPTLANG/"): m = re.match("OPTLANG/([a-z][a-z](?:_[A-Z][A-Z]|)):(.+)$", sLine) sLang = m.group(1)[:2] dOptLabel[sLang] = { "__optiontitle__": m.group(2).strip() } elif sLine.startswith("OPTLABEL/"): m = re.match("OPTLABEL/([a-z0-9]+):(.+)$", sLine) dOptLabel[sLang][m.group(1)] = list(map(str.strip, m.group(2).split("|"))) if "|" in m.group(2) else [m.group(2).strip(), ""] else: print("# Error. Wrong option line in:\n ") print(sLine) print(" options defined for: " + ", ".join([ t[0] for t in lOpt ])) dOptions = { "lStructOpt": lStructOpt, "dOptLabel": dOptLabel } dOptions.update({ "dOpt"+k: v for k, v in lOpt }) return dOptions, dOptPriority def make (lRules, sLang, bJavaScript): "compile rules" # removing comments, zeroing empty lines, creating definitions, storing tests, merging rule lines print(" parsing rules...") global DEF lLine = [] lRuleLine = [] lTest = [] lOpt = [] for i, sLine in enumerate(lRules, 1): if sLine.startswith('#END'): break elif sLine.startswith("#"): pass elif sLine.startswith("DEF:"): m = re.match("DEF: +([a-zA-Z_][a-zA-Z_0-9]*) +(.+)$", sLine.strip()) if m: DEF["{"+m.group(1)+"}"] = m.group(2) else: print("Error in definition: ", end="") print(sLine.strip()) elif sLine.startswith("TEST:"): lTest.append("{:<8}".format(i) + " " + sLine[5:].lstrip()) elif sLine.startswith("TODO:"): pass elif sLine.startswith(("OPTGROUP/", "OPTSOFTWARE:", "OPT/", "OPTLANG/", "OPTLABEL/", "OPTPRIORITY/")): lOpt.append(sLine) elif re.match("[ \t]*$", sLine): pass elif sLine.startswith((" ", "\t")): lRuleLine[len(lRuleLine)-1][1] += " " + sLine.strip() else: lRuleLine.append([i, sLine.strip()]) # generating options files print(" parsing options...") try: dOptions, dOptPriority = prepareOptions(lOpt) except: traceback.print_exc() exit() # generating test files print(" generating test files...") with open("tests/"+sLang+"/gc_test.txt", "w", encoding="utf-8", newline="\n") as hDstPy, \ open("gc_lang/"+sLang+"/modules-js/tests_data.json", "w", encoding="utf-8", newline="\n") as hDstJS: hDstPy.write("# TESTS FOR LANG ["+sLang+"]\n\n") for sLine in lTest: hDstPy.write(sLine) hDstJS.write('{ "aData": ' + json.dumps(lTest, ensure_ascii=False) + " }\n") # processing print(" preparing rules...") bParagraph = True lParagraphRules = [] lSentenceRules = [] lParagraphRulesJS = [] lSentenceRulesJS = [] for nLine, sLine in lRuleLine: if sLine: if sLine == "[++]": bParagraph = False else: aRule = createRule(sLine, nLine, sLang, bParagraph, dOptPriority) if aRule: if bParagraph: lParagraphRules.append(aRule) lParagraphRulesJS.append(pyRuleToJS(aRule)) else: lSentenceRules.append(aRule) lSentenceRulesJS.append(pyRuleToJS(aRule)) # creating file with all functions callable by rules print(" creating callables...") sPyCallables = "# generated code, do not edit\n" sJSCallables = "// generated code, do not edit\nconst oEvalFunc = {\n" for sFuncName, sReturn in FUNCTIONS: cType = sFuncName[0:1] if cType == "c": # condition sParams = "s, sx, m, dDA, sCountry, bCondMemo" elif cType == "m": # message sParams = "s, m" elif cType == "s": # suggestion sParams = "s, m" elif cType == "p": # preprocessor sParams = "s, m" elif cType == "d": # disambiguator sParams = "s, m, dDA" else: print("# Unknown function type in [" + sFuncName + "]") continue sPyCallables += "def {} ({}):\n".format(sFuncName, sParams) sPyCallables += " return " + sReturn + "\n" sJSCallables += " {}: function ({})".format(sFuncName, sParams) + " {\n" sJSCallables += " return " + py2js(sReturn) + ";\n" sJSCallables += " },\n" sJSCallables += "}\n" displayStats(lParagraphRules, lSentenceRules) d = { "callables": sPyCallables, "callablesJS": sJSCallables, "paragraph_rules": mergeRulesByOption(lParagraphRules), "sentence_rules": mergeRulesByOption(lSentenceRules), "paragraph_rules_JS": writeRulesToJSArray(mergeRulesByOption(lParagraphRulesJS)), "sentence_rules_JS": writeRulesToJSArray(mergeRulesByOption(lSentenceRulesJS)) } d.update(dOptions) return d |
Added dialog_bundled.py version [00d8c7ccc2].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 | # -*- encoding: UTF-8 -*- import sys import re import os comment = re.compile(r"[\n#]") ids = re.compile(r"\w+:\s*\*?\w+(,\s*\*?\w+)*") langu = re.compile(r"\[.+=.+\]\s*") titl = re.compile(r"\w+\s*=\s*") helptexts = [] # XDL file xdl_header = """<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE dlg:window PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "dialog.dtd"> <dlg:window xmlns:dlg="http://openoffice.org/2000/dialog" xmlns:script="http://openoffice.org/2000/script" dlg:id="%s" dlg:left="101" dlg:top="52" dlg:width="196" dlg:height="72" dlg:closeable="true" dlg:moveable="true" dlg:withtitlebar="false"> <dlg:bulletinboard> """ xdl_footer = """</dlg:bulletinboard> </dlg:window> """ xdl_group = '<dlg:fixedline dlg:id="%s" dlg:tab-index="%d" dlg:left="5" dlg:top="%d" dlg:width="240" dlg:height="10" dlg:value="&%s"/>\n' xdl_item = '<dlg:checkbox dlg:id="%s" dlg:tab-index="%d" dlg:left="%d" dlg:top="%d" dlg:width="%d" dlg:height="10" dlg:value="&%s" dlg:checked="%s" %s/>\n' # XCS file xcs_header = """<?xml version="1.0" encoding="UTF-8"?> <oor:component-schema xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" oor:name="%s" oor:package="org.openoffice" xml:lang="en-US"> <info> <desc>Contains the options data used for the test extensions.</desc> </info> <templates> """ xcs_leaf_header = """ <group oor:name="%s"> <info> <desc>The data for one leaf.</desc> </info> """ xcs_leaf = """<prop oor:name="%s" oor:type="xs:string"> <value></value> </prop> """ xcs_leaf_footer = """ </group> """ xcs_component_header = """ </templates> <component> <group oor:name="Leaves"> """ xcs_component = """ <node-ref oor:name="%s" oor:node-type="%s"/> """ xcs_footer = """ </group> </component> </oor:component-schema> """ # XCU file xcu_header = u"""<?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE oor:component-data SYSTEM "../../../../component-update.dtd"> <oor:component-data oor:name="OptionsDialog" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <node oor:name="Nodes"> <!--<node oor:name="org.openoffice.lightproof" oor:op="fuse"> <prop oor:name="Label"> <value xml:lang="en">Dictionaries</value> <value xml:lang="hu">Szótárak</value> </prop>--> <node oor:name="LanguageSettings" oor:op="fuse"> <prop oor:name="Label"> <value xml:lang="en-US">Language Settings</value> <value xml:lang="fr-FR">Paramètres linguistiques</value> </prop> <node oor:name="Leaves"> """ xcu_node_header = """ <node oor:name="org.openoffice.lightproof.%s" oor:op="fuse"> <prop oor:name="Id"> <!--<value>org.openoffice.comp.pyuno.lightproof.oxt.%s</value>--> <value>French.linguistic.resources.from.Dicollecte.by.OlivierR</value> </prop> <prop oor:name="Label"> """ xcu_node = """ <value xml:lang="%s">%s</value> """ xcu_node_footer = """ </prop> <prop oor:name="OptionsPage"> <value>%%origin%%/%s.xdl</value> </prop> <prop oor:name="EventHandlerService"> <value>org.openoffice.comp.pyuno.LightproofOptionsEventHandler.%s</value> </prop> </node> """ xcu_footer = """ </node> </node> </node> </oor:component-data> """ indexes = {} indexes_def = {} modules = {} def create_xdl (pkg, lLineOptions, hZip, lang): global indexes global indexes_def global modules indexes[lang] = [] indexes_def[lang] = [] modules[lang] = [] f2 = "" state = 0 f2n = "dialog/" + lang + ".xdl" f2 = f2 + xdl_header%lang k = 0 k2 = 0 lin = 0 ok = False for i in lLineOptions: i = i.strip() if "=" in i and r"\n" in i: helptexts.append(i.split("=")[0]) for i in lLineOptions: i = i.strip().replace(r"\n", "@#@") + "\n" lin = lin + 1 if not comment.match(i): if state == 0: ok = True if ids.match(i.strip()): j = i.strip().split(":") f2 = f2 + xdl_group%(j[0].strip(), k, k2 * 10 + 5, j[0].strip()) for l in j[1].split(","): k = k + 1 k2 = k2 + 1 l = l.strip() la = l.split(" ") l3 = 0 itemlen = int(240 / len(la)) for l2 in la: if l2 != "-": checked = "false" if l2[0] == '*': checked = "true" l2 = l2[1:] indexes_def[lang] += [l2] indexes[lang] += [l2] helptext = "" if l2 in helptexts: helptext = "dlg:help-text=\"&hlp_" + l2 + "\"" f2 = f2 + xdl_item%(l2, k, 10 + itemlen * l3, k2 * 10 + 5, itemlen, l2, checked, helptext) l3 = l3 + 1 k = k + 1 k2 = k2 + 1 k = k + 1 else: ok = False if langu.match(i.strip()): if "xdl" in f2n: f2 = f2 + xdl_footer hZip.writestr(f2n, f2) f2 = "" i = i.strip() langname = i[1:i.find("=")] modules[lang] += [langname[:langname.find("_")], i[i.find("=")+1:-1]] f2n = "dialog/" + lang + "_" + langname + ".properties" state = state + 1 if state == 1: hZip.writestr("dialog/" + lang + "_" + langname + ".default", "") elif titl.match(i.strip()): hlp = i.encode("unicode-escape").decode('ascii').replace(r"\n","\n").replace(r"\t","\t").replace(r"\x","\\u00").split("@#@", 1) if len(hlp) > 1: helptexts.append(hlp[0].split("=")[0]) f2 = f2 + "hlp_" + hlp[0].split("=")[0] + "=" + hlp[1] hlp[0] = hlp[0] + "\n" f2 = f2 + hlp[0] elif not ok: print ("Syntax error in line %d: %s" %(lin, i)) if "xdl" in f2n: f2 = f2 + xdl_footer hZip.writestr(f2n, f2) def c (sImplname, lLineOptions, hZip, sLang): # create xdl dialog data files create_xdl(sImplname, lLineOptions, hZip, sLang) #print(indexes) # create xcs file s = xcs_header% ("Lightproof_" + sImplname) for i in indexes: s = s + xcs_leaf_header%i + \ xcs_leaf*len(indexes[i])%tuple(indexes[i]) + xcs_leaf_footer s = s + xcs_component_header for i in indexes: s = s + xcs_component%(i,i) hZip.writestr("dialog/OptionsDialog.xcs", s + xcs_footer) # create xcu (bundled dialog in LO options) s = "" for i in indexes: s = s + xcu_node_header%(sImplname, sImplname) + \ xcu_node*(len(modules[i])//2)%tuple(modules[i]) + \ xcu_node_footer%(i, sImplname) hZip.writestr("dialog/OptionsDialog.xcu", (xcu_header + s + xcu_footer).encode("utf-8")) # python resource file s = "lopts = {}\nlopts_default = {}\n" for i in indexes: s = s + "lopts['" + i + "'] = " + str(indexes[i]) + "\n" for i in indexes: s = s + "lopts_default['" + i + "'] = " + str(indexes_def[i]) + "\n" hZip.writestr("pythonpath/lightproof_opts_%s.py"%sImplname, s) |
Added doc/API.txt version [74d38805d7].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | = Grammalecte API = Sorry, PEP8. CamelCase here. Writer legacy & JavaScript. == grammalecte.ibdawg == .IBDAWG .__init__(dic_name) Loads the dictionary dic_name from the folder _dictionaries. .lookup(word) Returns True if word is in the dictionary else False. .isValid(word) Returns True if word is in the dictionary else False. Several casing tried. .isValidToken(token) Returns True if token (combination of words) is valid. Several casing tried. .getMorph(word) Returns the list of morphologies of word. == grammalecte.fr == Grammar checker for French language .load() Initialize the grammar checker. .parse(paragraph) Returns a list of errors found in the paragraph. .setOptions(dict_options) Change the grammar checking options. .getDictionary() Returns the dictionary (IBDAWG) == grammalecte.fr.conj == .isVerb(word) Returns True is word exists in the list of verb (infinite form) .getConj(verb, tense, who) Returns conjugation of verb with subject who at tense (can be an empty string) tense has to be: :Y infinitif :PQ participes passés et présent :Ip indicatif présent :Iq imparfait :Is passé simple :If futur :K conditionnel :Sp subjonctif présent :Sq subjonctif imparfait :E impératif who has to be: :P participe présent :Q1 participe passé masculin singulier ou invariable :Q2 participe passé masculin pluriel :Q3 participe passé féminin singulier :Q4 participe passé féminin pluriel :1s première personne au singulier (1ś pour une éventuelle forme interrogative spécifique) :2s deuxième personne au singulier :3s troisième personne au singulier :1p première personne au pluriel :2p deuxième personne au pluriel :3p troisième personne au pluriel Exception ValueError is raised if failed to retrieve information. .hasConj(verb, tense, who) Returns False if no conjugation with subject who at tense else True. Exception ValueError is raised if failed to retrieve information. .Verb .__init__(verb) .dConj Attribute. Dictionary of all conjugations. .sInfo Attribute. Readable informations about the verb. .infinitif(bPro, bNeg, bTpsCo, bInt, bFem) .participePasse(sWho) .participePresent(bPro, bNeg, bTpsCo, bInt, bFem) .conjugue(sTemps, sWho, bPro, bNeg, bTpsCo, bInt, bFem) .imperatif(sWho, bPro, bNeg, bTpsCo, bFem) |
Added doc/build.txt version [a7ffc6f8bf].
Added doc/options.txt version [dc0618d03e].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | # 1. Copy this template to the data folder. # # 2. Define your group ids and option ids and the localized title # texts (see later for the syntax). # # Syntax of the dialog data file: # # Options and title texts for the Settings and conditional rules # # Format of the dialog definition: # # GroupID: OptionID [OptionsInTheSameLines_or_hyphen_placeholder], OptionID ... # Group2ID: OptionID, OptionID ... # ... # [Language_code=title of the window] # GroupID=title of the group # OptionID=title of the option [\n tooltip] # Option2ID=title of the option [\n tooltip] # # The first language is the default language for the other locales # (use en_US or the common language of your country) # # The OptionIDs are used in the rules, too. For example: # # foo <<- option("style") ->> bar # bar is far better # # or # # __[i]/style__ foo <<- ->> bar # bar is far better # # these rule depends from the state of the "style" option. # options spelling: comma, hyphen proofreading: style, moregrammar # titles [en_US=Hungarian grammar checking] spelling=Spelling comma=Comma usage hyphen=Check compound words with hyphen proofreading=Proofreading style=Style checking moregrammar=Use grammar rules with ambiguous word analysis [yourlocale=yourtitle] spelling=... wordpart=... ... |
Added doc/syntax.txt version [ee9590ca86].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 | WRITING RULES FOR GRAMMALECTE = Principles = Grammalecte is a multi-passes grammar checker engine. On the first pass, the engine checks the text paragraph by paragraph. On the next passes, the engine check the text sentence by sentence. The command to add a new pass is: [++] You shoudn’t need more than two passes, but you can create as many passes as you wish. In each pass, you can write as many rules as you need. A rule is defined by: - a regex pattern trigger - a list of actions (can’t be empty) - [optional] flags “LCR” for the regex word boundaries and case sensitiveness - [optional] user option name for activating/disactivating the rule There is no limit to the number of actions and the type of actions a rule can launch. Each action has its own condition to be triggered. There are three kind of actions: - Error warning, with a message and optionaly suggestions and optionally an URL - Text transformation, modifying internally the checked text - Disambigation action, setting tags on a position The rules file for your language must be named “rules.grx”. The options file must be named “option.txt”. The settings file must be named “config.ini”. All these files are simple utf-8 text file. UTF-8 is mandatory. = Rule syntax = __LCR__ pattern <<- condition ->> error_suggestions # message_error|http://awebsite.net... <<- condition ~>> text_rewriting <<- condition =>> commands_for_disambigation ... Patterns are written with the Python syntax for regular expressions: http://docs.python.org/library/re.html There can be one or several actions for each rule, executed the order they are written. Conditions are optional, i.e.: <<- ~>> replacement LCR flags means: - Left boundary for the regex - Case sensitiveness - Right boundary for the regex Left boundary: [ word boundary or < no word boundary right boundary: ] word boundary or > no word boundary Case sensitiveness: i: case insensitive s: case sensitive u: uppercase allowed for lowercased characters i.e.: "Word" becomes "W[oO][rR][dD]" Examples: __[i]__ pattern __<s]__ pattern __[u>__ pattern __<s>__ pattern ... User option activating/disactivating is possible with an option name placed just after the LCR flags, i.e.: __[i]/useroption1__ pattern __[u]/useroption2__ pattern __[s>/useroption1__ pattern __<u>/useroption3__ pattern __<i>/useroption3__ pattern ... The LCR flags are also optional. If you don’t set these flags, the default LCR flags will be: __[i]__ Example. Report “foo” in the text and suggest "bar": foo <<- ->> bar # Use bar instead of foo. Example. Recognize and suggest missing hyphen and rewrite internally the text with the hyphen: __[s]__ foo bar <<- ->> foo-bar # Missing hyphen. <<- ~>> foo-bar == Simple-line or multi-line rules == Rules can be break to multiple lines by leading tabulators or spaces. You should use 4 spaces. Examples: __<s>__ pattern <<- condition ->> replacement # message <<- condition ->> suggestion # message <<- condition ~>> text_rewriting <<- =>> disambiguation __<s>__ pattern <<- condition ->> replacement # message == Comments == Lines beginning with # are comments. Example. No action done. # pattern <<- ->> foo bar # message == End of file == With the command: #END the compiler won’t go further. Whatever is written after will be considered as comments. == Whitespaces at the border of patterns or suggestions == Example. Recognize double or more spaces and suggests a single space: __<s>__ " +" <<- ->> " " # Extra space(s). ASCII " characters protect spaces in the pattern and in the replacement text. == Pattern groups and back references == It is usually useful to retrieve parts of the matched pattern. We simply use parenthesis in pattern to get groups with back references. Example. Suggest a word with correct quotation marks: \"(\w+)\" <<- ->> “\1” # Correct quotation marks. Example. Suggest the missing space after the !, ? or . signs: __<i]__ \b([?!.])([A-Z]+) <<- ->> \1 \2 # Missing space? Example. Back reference in messages. (fooo) bar <<- ->> foo bar # “\1” should be: == Name definitions == Grammalecte supports name definitions to simplify the description of the complex rules. Example. DEF: name pattern Usage in the rules: ({name}) (\w+) ->> "\1-\2" # Missing hyphen? == Multiple suggestions == Use | in the replacement text to add multiple suggestions: Example 7. Foo, FOO, Bar and BAR suggestions for the input word "foo". foo <<- ->> Foo|FOO|Bar|BAR # Did you mean: == No suggestion == You can display message without making suggestions. For this purpose, use a single character _ in the suggestion field. Example. No suggestion. foobar <<- ->> _ # Message == Positioning == Positioning is valid only for error creation and text rewriting. By default, the full pattern will be underlined with blue. You can shorten the underlined text area by specifying a back reference group of the pattern. Instead of writing ->>, write -n>> n being the number of a back reference group. Actually, ->> is similar to -0>> Example. (ying) and yang <<- -1>> yin # Did you mean: __[s]__ (Mr.) [A-Z]\w+ <<- ~1>> Mr === Comparison === Rule A: ying and yang <<- ->> yin and yang # Did you mean: Rule B: (ying) and yang <<- -1>> yin # Did you mean: With the rule A, the full pattern is underlined: ying and yang ^^^^^^^^^^^^^ With the rule B, only the first group is underlined: ying and yang ^^^^ == Longer explanations with URLs == Warning messages can contain optional URL for longer explanations separated by "|": (your|her|our|their)['’]s <<- ->> \1s # Possessive pronoun:|http://en.wikipedia.org/wiki/Possessive_pronoun = Text rewriting = Example. Replacing a string by another Mr. [A-Z]\w+ <<- ~>> Mister WARNING: The replacing text must be shorter than the replaced text or have the same length. Breaking this rule will misplace following error reports. You have to ensure yourself the rules comply with this constraint, Grammalecte won’t do it for you. Specific commands for text rewriting ~>> * replace by whitespaces ~>> @ replace by arobases, useful mostly at firt pass, where it is advised to check usage of punctuations and whitespaces. @ are automatically removed at the beginning of the second pass. You can use positioning with text rewriting actions. Mr(. [A-Z]\w+) <<- ~1>> * You can also call Python expressions. __[s]__ Mr. ([a-z]\w+) <<- ~1>> =\1.upper() = Disambiguation = When Grammalecte analyses a word with morph or morphex, before requesting the POS tags to the dictionary, it checks if there is a stored marker for the position where the word is. If there is a marker, Grammalecte uses the stored data and don’t make request to the dictionary. The disambigation commands store POS tags at the position of a word. There is 3 commands for disambigation. - select(n, pattern) stores at position n only the POS tags of the word matching the pattern. - exclude(n, pattern) stores at position n the POS tags of the word, except those matching the pattern. - define(n, definition) stores at position n the POS tags in definition. Examples. =>> select(\1, "po:noun is:pl") =>> exclude(\1, "po:verb") =>> define(\1, "po:adv") =>> exclude(\1, "po:verb") and define(\2, "po:adv") and select(\3, "po:adv") Note: select, exclude and define ALWAYS return True. If select and exclude generate an empty list, no marker is set. With define, you can set a list of POS tags. Example: define(\1, "po:nom is:plur|po:adj is:sing|po:adv") This will store a list of tags at the position of the first group: ["po:nom is:plur", "po:adj is:sing", "po:adv"] = Conditions = Conditions are Python expressions, they must return a value, which will be evaluated as boolean. You can use the usual Python syntax and libraries. You can call pattern subgroups via \0, \1, \2… Example: these (\w+) <<- \1 == "man" -1>> men # Man is a singular noun. Use the plural form: You can also apply functions to subgroups like: \1.startswith("a") \3.islower() re.match("pattern", \2) … == Standard functions == word(n) catches the nth next word after the pattern (separated only by white spaces). returns None if no word catched word(-n) catches the nth next word before the pattern (separated only by white spaces). returns None if no word catched after(regex[, neg_regex]) checks if the text after the pattern matches the regex. before(regex[, neg_regex]) checks if the text before the pattern matches the regex. textarea(regex[, neg_regex]) checks if the full text of the checked area (paragraph or sentence) matches the regex. morph(n, regex[, strict=True][, noword=False]) checks if all tags of the word in group n match the regex. if strict = False, returns True only if one of tags matches the regex. if there is no word at position n, returns the value of noword. morphex(n, regex, neg_regex[, noword=False]) checks if one of the tags of the word in group n match the regex and if no tags matches the neg_regex. if there is no word at position n, returns the value of noword. option(option_name) returns True if option_name is activated else False Note: the analysis is done on the preprocessed text. == Default variables == sCountry It contains the current country locale of the checked paragraph. colour <<- sCountry == "US" ->> color # Use American English spelling. = Expressions in the suggestions = Suggestions (and warning messages) started by an equal sign are Python string expressions extended with possible back references and named definitions: Example: foo\w+ ->> = '"' + \0.upper() + '"' # With uppercase letters and quoation marks All words beginning with "foo" will be recognized, and the suggestion is the uppercase form of the string with ASCII quoation marks: eg. foom ->> "FOOM". //////////////////////////////// OLD /////////////////////////////////////// = Text preprocessing and multi-passes checking = On each pass, Lightproof uses rules written in the text preprocessor to modify internally the text before checking the text. The text preprocessor is useful to simplify texts and write simplier checking rules. For example, sentences with the same grammar mistake: These “cats” are blacks. These cats are “blacks”. These cats are absolutely blacks. These stupid “cats” are all blacks. These unknown cats are as per usual blacks. Instead of writting complex rules or several rules to find mistakes for all possible cases, you can use the text preprocessor to simplify the text. To remove the chars “”, write: [“”] ->> * The * means: replace text by whitespaces. as per usual ->> * Similarly to grammar rules, you can add conditions: \w+ly <<- morph(\0, "adverb") ->> * You can also remove a group reference: these (\w+) (\w+) <<- morph(\1, "adjective") and morph(\2, "noun") -1>> * (am|are|is|were|was) (all) -2>> * With these rules, you get the following sentences: These cats are blacks. These cats are blacks . These cats are blacks. These cats are blacks. These cats are blacks. These grammar mistakes can be detected with one simple rule: these +(\w+) +are +(\w+s) <<- morph(\1, "noun") and morph(\2, "plural") -2>> _ # Adjectives are invariable. Instead of replacing text with whitespaces, you can replace text with @. https?://\S+ ->> @ This is useful if at first pass you write rules to check successive whitespaces. @ are automatically removed at the second pass. You can also replace any text as you wish. Mister ->> Mr (Mrs?)[.] ->> \1 With the multi-passes checking and the text preprocessor, it is advised to remove or simplify the text which has been checked on the previous pass. = Typical problems = == Pattern matching == Repeating pattern matching of a single rule continues after the previous matching, so instead of general multiword patterns, like (\w+) (\w+) <<- some_check(\1, \2) ->> \1, \2 # foo use (\w+) <<- some_check(\1, word(1)) ->> \1, # foo |
Added gc_core/js/README.txt version [05ae253824].
> > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 | = GRAMMALECTE = Grammar checker By Olivier R. Website: http://grammalecte.net License: GPL 3 -- http://www.gnu.org/copyleft/gpl.html |
Added gc_core/js/helpers.js version [6c4ecd114f].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | // HELPERS "use strict"; // In Firefox, there is no console.log in PromiseWorker, but there is worker.log. // In Thunderbird, you can’t access to console directly. So it’s required to pass a log function. let funcOutput = null; function setLogOutput (func) { funcOutput = func; } function echo (obj) { if (funcOutput !== null) { funcOutput(obj); } else { console.log(obj); } return true; } function logerror (e, bStack=false) { let sMsg = "\n" + e.fileName + "\n" + e.name + "\nline: " + e.lineNumber + "\n" + e.message; if (bStack) { sMsg += "\n--- Stack ---\n" + e.stack; } if (funcOutput !== null) { funcOutput(sMsg); } else { console.error(sMsg); } } // load ressources in workers (suggested by Mozilla extensions reviewers) // for more options have a look here: https://gist.github.com/Noitidart/ec1e6b9a593ec7e3efed // if not in workers, use sdk/data.load() instead function loadFile (spf) { try { let xRequest; if (typeof XMLHttpRequest !== "undefined") { xRequest = new XMLHttpRequest(); } else { // JS bullshit again… necessary for Thunderbird let { Cc, Ci } = require("chrome"); xRequest = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(); xRequest.QueryInterface(Ci.nsIXMLHttpRequest); } xRequest.open('GET', spf, false); // 3rd arg is false for synchronous, sync is acceptable in workers xRequest.send(); return xRequest.responseText; } catch (e) { logerror(e); return null } } // conversions function objectToMap (obj) { let m = new Map(); for (let param in obj) { //console.log(param + " " + obj[param]); m.set(param, obj[param]); } return m; } function mapToObject (m) { let obj = {}; for (let [k, v] of m) { obj[k] = v; } return obj; } exports.echo = echo; exports.logerror = logerror; exports.objectToMap = objectToMap; exports.mapToObject = mapToObject; exports.setLogOutput = setLogOutput; exports.loadFile = loadFile; |
Added gc_core/js/ibdawg.js version [2d42754063].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 | //// IBDAWG "use strict"; const st = require("resource://grammalecte/str_transform.js"); const helpers = require("resource://grammalecte/helpers.js"); // String // Don’t remove. Necessary in TB. ${string} class IBDAWG { // INDEXABLE BINARY DIRECT ACYCLIC WORD GRAPH constructor (sDicName) { try { const dict = JSON.parse(helpers.loadFile("resource://grammalecte/_dictionaries/"+sDicName)); Object.assign(this, dict); //const dict = require("resource://grammalecte/"+sLang+"/dictionary.js"); //Object.assign(this, dict.dictionary); } catch (e) { throw Error("# Error. File not found or not loadable.\n" + e.message + "\n"); } /* Properties: sName, nVersion, sHeader, lArcVal, nArcVal, byDic, sLang, nChar, nBytesArc, nBytesNodeAddress, nEntries, nNode, nArc, nAff, cStemming, nTag, dChar, _arcMask, _finalNodeMask, _lastArcMask, _addrBitMask, nBytesOffset, */ if (!this.sHeader.startsWith("/pyfsa/")) { throw TypeError("# Error. Not a pyfsa binary dictionary. Header: " + this.sHeader); } if (!(this.nVersion == "1" || this.nVersion == "2" || this.nVersion == "3")) { throw RangeError("# Error. Unknown dictionary version: " + this.nVersion); } this.dChar = helpers.objectToMap(this.dChar); //this.byDic = new Uint8Array(this.byDic); // not quicker, even slower if (this.cStemming == "S") { this.funcStemming = st.getStemFromSuffixCode; } else if (this.cStemming == "A") { this.funcStemming = st.getStemFromAffixCode; } else { this.funcStemming = st.noStemming; } // Configuring DAWG functions according to nVersion switch (this.nVersion) { case 1: this.morph = this._morph1; this.stem = this._stem1; this._lookupArcNode = this._lookupArcNode1; this._writeNodes = this._writeNodes1; break; case 2: this.morph = this._morph2; this.stem = this._stem2; this._lookupArcNode = this._lookupArcNode2; this._writeNodes = this._writeNodes2; break; case 3: this.morph = this._morph3; this.stem = this._stem3; this._lookupArcNode = this._lookupArcNode3; this._writeNodes = this._writeNodes3; break; default: throw ValueError("# Error: unknown code: " + this.nVersion); } //console.log(this.getInfo()); this.bOptNumSigle = true; this.bOptNumAtLast = false; }; getInfo () { return ` Language: ${this.sLang} Version: ${this.nVersion} Stemming: ${this.cStemming}FX\n` + ` Arcs values: ${this.nArcVal} = ${this.nChar} characters, ${this.nAff} affixes, ${this.nTag} tags\n` + ` Dictionary: ${this.nEntries} entries, ${this.nNode} nodes, ${this.nArc} arcs\n` + ` Address size: ${this.nBytesNodeAddress} bytes, Arc size: ${this.nBytesArc} bytes\n`; }; isValidToken (sToken) { // checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked) if (this.isValid(sToken)) { return true; } if (sToken.includes("-")) { if (sToken._count("-") > 4) { return true; } return sToken.split("-").every(sWord => this.isValid(sWord)); } return false; }; isValid (sWord) { // checks if sWord is valid (different casing tested if the first letter is a capital) if (!sWord) { return null; } if (sWord.includes("’")) { // ugly hack sWord = sWord.replace("’", "'"); } if (this.lookup(sWord)) { return true; } if (sWord.charAt(0)._isUpperCase()) { if (sWord.length > 1) { if (sWord._isTitle()) { return !!this.lookup(sWord.toLowerCase()); } if (sWord._isUpperCase()) { if (this.bOptNumSigle) { return true; } return !!(this.lookup(sWord.toLowerCase()) || this.lookup(sWord._toCapitalize())); } return !!this.lookup(sWord.slice(0, 1).toLowerCase() + sWord.slice(1)); } else { return !!this.lookup(sWord.toLowerCase()); } } return false; }; _convBytesToInteger (aBytes) { // Byte order = Big Endian (bigger first) let nVal = 0; let nWeight = (aBytes.length - 1) * 8; for (let n of aBytes) { nVal += n << nWeight; nWeight = nWeight - 8; } return nVal; }; lookup (sWord) { // returns true if sWord in dictionary (strict verification) let iAddr = 0; for (let c of sWord) { if (!this.dChar.has(c)) { return false; } iAddr = this._lookupArcNode(this.dChar.get(c), iAddr); if (iAddr === null) { return false; } } return Boolean(this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask); }; getMorph (sWord) { // retrieves morphologies list, different casing allowed let l = this.morph(sWord); if (sWord[0]._isUpperCase()) { l = l.concat(this.morph(sWord.toLowerCase())); if (sWord._isUpperCase() && sWord.length > 1) { l = l.concat(this.morph(sWord._toCapitalize())); } } return l; }; // morph (sWord) { // is defined in constructor // }; // VERSION 1 _morph1 (sWord) { // returns morphologies of sWord let iAddr = 0; for (let c of sWord) { if (!this.dChar.has(c)) { return []; } iAddr = this._lookupArcNode(this.dChar.get(c), iAddr); if (iAddr === null) { return []; } } if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) { let l = []; let nRawArc = 0; while (!(nRawArc & this._lastArcMask)) { var iEndArcAddr = iAddr + this.nBytesArc; nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr)); var nArc = nRawArc & this._arcMask; if (nArc >= this.nChar) { // This value is not a char, this is a stemming code var sStem = ">" + this.funcStemming(sWord, this.lArcVal[nArc]); // Now , we go to the next node and retrieve all following arcs values, all of them are tags var iAddr2 = this._convBytesToInteger(this.byDic.slice(iEndArcAddr, iEndArcAddr+this.nBytesNodeAddress)); var nRawArc2 = 0; while (!(nRawArc2 & this._lastArcMask)) { var iEndArcAddr2 = iAddr2 + this.nBytesArc; nRawArc2 = this._convBytesToInteger(this.byDic.slice(iAddr2, iEndArcAddr2)); l.push(sStem + " " + this.lArcVal[nRawArc2 & this._arcMask]); iAddr2 = iEndArcAddr2+this.nBytesNodeAddress; } } iAddr = iEndArcAddr + this.nBytesNodeAddress; } return l; } return []; }; _stem1 (sWord) { // returns stems list of sWord let iAddr = 0; for (let c of sWord) { if (!this.dChar.has(c)) { return []; } iAddr = this._lookupArcNode(this.dChar.get(c), iAddr); if (iAddr === null) { return []; } } if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) { let l = []; let nRawArc = 0; while (!(nRawArc & this._lastArcMask)) { var iEndArcAddr = iAddr + this.nBytesArc; nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr)); var nArc = nRawArc & this._arcMask; if (nArc >= this.nChar) { // This value is not a char, this is a stemming code l.push(this.funcStemming(sWord, this.lArcVal[nArc])); } iAddr = iEndArcAddr + this.nBytesNodeAddress; } return l; } return []; }; _lookupArcNode1 (nVal, iAddr) { // looks if nVal is an arc at the node at iAddr, if yes, returns address of next node else None while (true) { let iEndArcAddr = iAddr+this.nBytesArc; let nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr)); if (nVal == (nRawArc & this._arcMask)) { // the value we are looking for // we return the address of the next node return this._convBytesToInteger(this.byDic.slice(iEndArcAddr, iEndArcAddr+this.nBytesNodeAddress)); } else { // value not found if (nRawArc & this._lastArcMask) { return null; } iAddr = iEndArcAddr + this.nBytesNodeAddress; } } }; // VERSION 2 _morph2 (sWord) { // to do }; _stem2 (sWord) { // to do }; _lookupArcNode2 (nVal, iAddr) { // to do }; // VERSION 3 _morph3 (sWord) { // to do }; _stem3 (sWord) { // to do }; _lookupArcNode3 (nVal, iAddr) { // to do }; } exports.IBDAWG = IBDAWG; |
Added gc_core/js/jsex_map.js version [975706110f].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | // Map Map.prototype._shallowCopy = function () { let oNewMap = new Map(); for (let [key, val] of this.entries()) { oNewMap.set(key, val); } return oNewMap; } Map.prototype._get = function (key, defaultValue) { let res = this.get(key); if (res !== undefined) { return res; } return defaultValue; } Map.prototype._toString = function () { // Default .toString() gives nothing useful let sRes = "{ "; for (let [k, v] of this.entries()) { sRes += (typeof k === "string") ? '"' + k + '": ' : k.toString() + ": "; sRes += (typeof v === "string") ? '"' + v + '", ' : v.toString() + ", "; } sRes = sRes.slice(0, -2) + " }" return sRes; } Map.prototype._update = function (dDict) { for (let [k, v] of dDict.entries()) { this.set(k, v); } } Map.prototype._updateOnlyExistingKeys = function (dDict) { for (let [k, v] of dDict.entries()) { if (this.has(k)){ this.set(k, v); } } } |
Added gc_core/js/jsex_regex.js version [35ff67872c].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | // regex RegExp.prototype._exec2 = function (sText, aGroupsPos, aNegLookBefore=null) { let m; while ((m = this.exec(sText)) !== null) { // we have to iterate over sText here too // because first match doesn’t imply it’s a valid match according to negative lookbefore assertions, // and even if first match is finally invalid, it doesn’t mean the following eligible matchs would be invalid too. if (aNegLookBefore !== null) { // check negative look before assertions if ( !aNegLookBefore.some(sRegEx => (RegExp.leftContext.search(sRegEx) >= 0)) ) { break; } } else { break; } } if (m === null) { return null; } let codePos; let iPos = 0; m.start = [m.index]; m.end = [this.lastIndex]; if (m.length > 1) { // there is subgroup(s) if (aGroupsPos !== null) { // aGroupsPos is defined for (let i = 1; i <= m.length-1; i++) { codePos = aGroupsPos[i-1]; if (typeof codePos === "number") { // position as a number m.start.push(m.index + codePos); m.end.push(m.index + codePos + m[i].length); } else if (codePos === "$") { // at the end of the pattern m.start.push(this.lastIndex - m[i].length); m.end.push(this.lastIndex); } else if (codePos === "w") { // word in the middle of the pattern iPos = m[0].search("[ ~’,()«»“”]"+m[i]+"[ ,’~()«»“”]") + 1 + m.index m.start.push(iPos); m.end.push(iPos + m[i].length) } else if (codePos === "*") { // anywhere iPos = m[0].indexOf(m[i]) + m.index; m.start.push(iPos); m.end.push(iPos + m[i].length) } else if (codePos === "**") { // anywhere after previous group iPos = m[0].indexOf(m[i], m.end[i-1]-m.index) + m.index; m.start.push(iPos); m.end.push(iPos + m[i].length) } else if (codePos.startsWith(">")) { // >x:_ // todo: look in substring x iPos = m[0].indexOf(m[i]) + m.index; m.start.push(iPos); m.end.push(iPos + m[i].length); } else { console.error("# Error: unknown positioning code in regex [" + this.source + "], for group[" + i.toString() +"], code: [" + codePos + "]"); } } } else { // no aGroupsPos for (let subm of m.slice(1)) { iPos = m[0].indexOf(subm) + m.index; m.start.push(iPos); m.end.push(iPos + subm.length); } } } return m; } |
Added gc_core/js/jsex_string.js version [c771aa921e].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | // String String.prototype._count = function (sSearch, bOverlapping) { // http://jsperf.com/string-ocurrence-split-vs-match/8 if (sSearch.length <= 0) { return this.length + 1; } let nOccur = 0; let iPos = 0; let nStep = (bOverlapping) ? 1 : sSearch.length; while ((iPos = this.indexOf(sSearch, iPos)) >= 0) { nOccur++; iPos += nStep; } return nOccur; } String.prototype._isDigit = function () { return (this.search(/^[0-9⁰¹²³⁴⁵⁶⁷⁸⁹]+$/) !== -1); } String.prototype._isLowerCase = function () { return (this.search(/^[a-zà-öø-ÿ0-9-]+$/) !== -1); } String.prototype._isUpperCase = function () { return (this.search(/^[A-ZÀ-ÖØ-ߌ0-9-]+$/) !== -1); } String.prototype._isTitle = function () { return (this.search(/^[A-ZÀ-ÖØ-ߌ][a-zà-öø-ÿ'’-]+$/) !== -1); } String.prototype._toCapitalize = function () { return this.slice(0,1).toUpperCase() + this.slice(1).toLowerCase(); } String.prototype._expand = function (oMatch) { let sNew = this; for (let i = 0; i < oMatch.length ; i++) { let z = new RegExp("\\\\"+parseInt(i), "g"); sNew = sNew.replace(z, oMatch[i]); } return sNew; } String.prototype._trimRight = function (sChars) { let z = new RegExp("["+sChars+"]+$"); return this.replace(z, ""); } String.prototype._trimLeft = function (sChars) { let z = new RegExp("^["+sChars+"]+"); return this.replace(z, ""); } String.prototype._trim = function (sChars) { let z1 = new RegExp("^["+sChars+"]+"); let z2 = new RegExp("["+sChars+"]+$"); return this.replace(z1, "").replace(z2, ""); } |
Added gc_core/js/lang_core/gc_engine.js version [b4d754f9e9].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 | // Grammar checker engine ${string} ${regex} ${map} function capitalizeArray (aArray) { // can’t map on user defined function?? let aNew = []; for (let i = 0; i < aArray.length; i = i + 1) { aNew[i] = aArray[i]._toCapitalize(); } return aNew; } const ibdawg = require("resource://grammalecte/ibdawg.js"); const helpers = require("resource://grammalecte/helpers.js"); const gc_options = require("resource://grammalecte/${lang}/gc_options.js"); const cr = require("resource://grammalecte/${lang}/cregex.js"); const text = require("resource://grammalecte/text.js"); const echo = require("resource://grammalecte/helpers.js").echo; const lang = "${lang}"; const locales = ${loc}; const pkg = "${implname}"; const name = "${name}"; const version = "${version}"; const author = "${author}"; // commons regexes const _zEndOfSentence = new RegExp ('([.?!:;…][ .?!… »”")]*|.$)', "g"); const _zBeginOfParagraph = new RegExp ("^[- –—.,;?!…]*", "ig"); const _zEndOfParagraph = new RegExp ("[- .,;?!…–—]*$", "ig"); // grammar rules and dictionary //const _rules = require("./gc_rules.js"); const _rules = require("resource://grammalecte/${lang}/gc_rules.js"); let _dOptions = gc_options.dOpt._shallowCopy(); // duplication necessary, to be able to reset to default let _aIgnoredRules = new Set(); let _oDict = null; let _dAnalyses = new Map(); // cache for data from dictionary ///// Parsing function parse (sText, sCountry="${country_default}", bDebug=false, bContext=false) { // analyses the paragraph sText and returns list of errors let dErrors; let errs; let sAlt = sText; let dDA = new Map(); // Disamnbiguator let dPriority = new Map(); // Key = position; value = priority let sNew = ""; // parse paragraph try { [sNew, dErrors] = _proofread(sText, sAlt, 0, true, dDA, dPriority, sCountry, bDebug, bContext); if (sNew) { sText = sNew; } } catch (e) { helpers.logerror(e); } // cleanup if (sText.includes(" ")) { sText = sText.replace(/ /g, ' '); // nbsp } if (sText.includes(" ")) { sText = sText.replace(/ /g, ' '); // snbsp } if (sText.includes("'")) { sText = sText.replace(/'/g, "’"); } if (sText.includes("‑")) { sText = sText.replace(/‑/g, "-"); // nobreakdash } // parse sentence for (let [iStart, iEnd] of _getSentenceBoundaries(sText)) { if (4 < (iEnd - iStart) < 2000) { dDA.clear(); //echo(sText.slice(iStart, iEnd)); try { [_, errs] = _proofread(sText.slice(iStart, iEnd), sAlt.slice(iStart, iEnd), iStart, false, dDA, dPriority, sCountry, bDebug, bContext); dErrors._update(errs); } catch (e) { helpers.logerror(e); } } } return Array.from(dErrors.values()); } function* _getSentenceBoundaries (sText) { let mBeginOfSentence = _zBeginOfParagraph.exec(sText) let iStart = _zBeginOfParagraph.lastIndex; let m; while ((m = _zEndOfSentence.exec(sText)) !== null) { yield [iStart, _zEndOfSentence.lastIndex]; iStart = _zEndOfSentence.lastIndex; } } function _proofread (s, sx, nOffset, bParagraph, dDA, dPriority, sCountry, bDebug, bContext) { let dErrs = new Map(); let bChange = false; let bIdRule = option('idrule'); let m; let bCondMemo; let nErrorStart; for (let [sOption, lRuleGroup] of _getRules(bParagraph)) { if (!sOption || option(sOption)) { for (let [zRegex, bUppercase, sLineId, sRuleId, nPriority, lActions, lGroups, lNegLookBefore] of lRuleGroup) { if (!_aIgnoredRules.has(sRuleId)) { while ((m = zRegex._exec2(s, lGroups, lNegLookBefore)) !== null) { bCondMemo = null; /*if (bDebug) { echo(">>>> Rule # " + sLineId + " - Text: " + s + " opt: "+ sOption); }*/ for (let [sFuncCond, cActionType, sWhat, ...eAct] of lActions) { // action in lActions: [ condition, action type, replacement/suggestion/action[, iGroup[, message, URL]] ] try { //echo(oEvalFunc[sFuncCond]); bCondMemo = (!sFuncCond || oEvalFunc[sFuncCond](s, sx, m, dDA, sCountry, bCondMemo)) if (bCondMemo) { switch (cActionType) { case "-": // grammar error //echo("-> error detected in " + sLineId + "\nzRegex: " + zRegex.source); nErrorStart = nOffset + m.start[eAct[0]]; if (!dErrs.has(nErrorStart) || nPriority > dPriority.get(nErrorStart)) { dErrs.set(nErrorStart, _createError(s, sx, sWhat, nOffset, m, eAct[0], sLineId, sRuleId, bUppercase, eAct[1], eAct[2], bIdRule, sOption, bContext)); dPriority.set(nErrorStart, nPriority); } break; case "~": // text processor //echo("-> text processor by " + sLineId + "\nzRegex: " + zRegex.source); s = _rewrite(s, sWhat, eAct[0], m, bUppercase); bChange = true; if (bDebug) { echo("~ " + s + " -- " + m[eAct[0]] + " # " + sLineId); } break; case "=": // disambiguation //echo("-> disambiguation by " + sLineId + "\nzRegex: " + zRegex.source); oEvalFunc[sWhat](s, m, dDA); if (bDebug) { echo("= " + m[0] + " # " + sLineId + "\nDA: " + dDA._toString()); } break; case ">": // we do nothing, this test is just a condition to apply all following actions break; default: echo("# error: unknown action at " + sLineId); } } else { if (cActionType == ">") { break; } } } catch (e) { echo(s); echo("# id-rule:" + sLineId); helpers.logerror(e); } } } } } } } if (bChange) { return [s, dErrs]; } return [false, dErrs]; } function _createError (s, sx, sRepl, nOffset, m, iGroup, sLineId, sRuleId, bUppercase, sMsg, sURL, bIdRule, sOption, bContext) { let oErr = {}; oErr["nStart"] = nOffset + m.start[iGroup]; oErr["nEnd"] = nOffset + m.end[iGroup]; oErr["sLineId"] = sLineId; oErr["sRuleId"] = sRuleId; oErr["sType"] = (sOption) ? sOption : "notype"; // suggestions if (sRepl[0] === "=") { let sugg = oEvalFunc[sRepl.slice(1)](s, m); if (sugg) { if (bUppercase && m[iGroup].slice(0,1)._isUpperCase()) { oErr["aSuggestions"] = capitalizeArray(sugg.split("|")); } else { oErr["aSuggestions"] = sugg.split("|"); } } else { oErr["aSuggestions"] = []; } } else if (sRepl == "_") { oErr["aSuggestions"] = []; } else { if (bUppercase && m[iGroup].slice(0,1)._isUpperCase()) { oErr["aSuggestions"] = capitalizeArray(sRepl._expand(m).split("|")); } else { oErr["aSuggestions"] = sRepl._expand(m).split("|"); } } // Message if (sMsg[0] === "=") { sMessage = oEvalFunc[sMsg.slice(1)](s, m) } else { sMessage = sMsg._expand(m); } if (bIdRule) { sMessage += " #" + sLineId + " #" + sRuleId; } oErr["sMessage"] = sMessage; // URL oErr["URL"] = sURL || ""; // Context if (bContext) { oErr["sUnderlined"] = sx.slice(m.start[iGroup], m.end[iGroup]); oErr["sBefore"] = sx.slice(Math.max(0, m.start[iGroup]-80), m.start[iGroup]); oErr["sAfter"] = sx.slice(m.end[iGroup], m.end[iGroup]+80); } return oErr; } function _rewrite (s, sRepl, iGroup, m, bUppercase) { // text processor: write sRepl in s at iGroup position" let ln = m.end[iGroup] - m.start[iGroup]; let sNew = ""; if (sRepl === "*") { sNew = " ".repeat(ln); } else if (sRepl === ">" || sRepl === "_" || sRepl === "~") { sNew = sRepl + " ".repeat(ln-1); } else if (sRepl === "@") { sNew = "@".repeat(ln); } else if (sRepl.slice(0,1) === "=") { sNew = oEvalFunc[sRepl.slice(1)](s, m); sNew = sNew + " ".repeat(ln-sNew.length); if (bUppercase && m[iGroup].slice(0,1)._isUpperCase()) { sNew = sNew._toCapitalize(); } } else { sNew = sRepl._expand(m); sNew = sNew + " ".repeat(ln-sNew.length); } //echo("\n"+s+"\nstart: "+m.start[iGroup]+" end:"+m.end[iGroup]) return s.slice(0, m.start[iGroup]) + sNew + s.slice(m.end[iGroup]); } function ignoreRule (sRuleId) { _aIgnoredRules.add(sRuleId); } function resetIgnoreRules () { _aIgnoredRules.clear(); } function reactivateRule (sRuleId) { _aIgnoredRules.delete(sRuleId); } function listRules (sFilter=null) { // generator: returns tuple (sOption, sLineId, sRuleId) try { for ([sOption, lRuleGroup] of _getRules(true)) { for ([_, _, sLineId, sRuleId, _, _] of lRuleGroup) { if (!sFilter || sRuleId.test(sFilter)) { yield [sOption, sLineId, sRuleId]; } } } for ([sOption, lRuleGroup] of _getRules(false)) { for ([_, _, sLineId, sRuleId, _, _] of lRuleGroup) { if (!sFilter || sRuleId.test(sFilter)) { yield [sOption, sLineId, sRuleId]; } } } } catch (e) { helpers.logerror(e); } } //////// init function load () { try { _oDict = new ibdawg.IBDAWG("${js_binary_dic}"); } catch (e) { helpers.logerror(e); } } function setOption (sOpt, bVal) { if (_dOptions.has(sOpt)) { _dOptions.set(sOpt, bVal); } } function setOptions (dOpt) { _dOptions._updateOnlyExistingKeys(dOpt); } function getOptions () { return _dOptions; } function getDefaultOptions () { return gc_options.dOpt._shallowCopy(); } function resetOptions () { _dOptions = gc_options.dOpt._shallowCopy(); } function getDictionary () { return _oDict; } function _getRules (bParagraph) { if (!bParagraph) { return _rules.lSentenceRules; } return _rules.lParagraphRules; } //////// common functions function option (sOpt) { // return true if option sOpt is active return _dOptions.get(sOpt); } function displayInfo (dDA, aWord) { // for debugging: info of word if (!aWord) { echo("> nothing to find"); return true; } if (!_dAnalyses.has(aWord[1]) && !_storeMorphFromFSA(aWord[1])) { echo("> not in FSA"); return true; } if (dDA.has(aWord[0])) { echo("DA: " + dDA.get(aWord[0])); } echo("FSA: " + _dAnalyses.get(aWord[1])); return true; } function _storeMorphFromFSA (sWord) { // retrieves morphologies list from _oDict -> _dAnalyses //echo("register: "+sWord + " " + _oDict.getMorph(sWord).toString()) _dAnalyses.set(sWord, _oDict.getMorph(sWord)); return !!_dAnalyses.get(sWord); } function morph (dDA, aWord, sPattern, bStrict=true, bNoWord=false) { // analyse a tuple (position, word), return true if sPattern in morphologies (disambiguation on) if (!aWord) { //echo("morph: noword, returns " + bNoWord); return bNoWord; } //echo("aWord: "+aWord.toString()); if (!_dAnalyses.has(aWord[1]) && !_storeMorphFromFSA(aWord[1])) { return false; } let lMorph = dDA.has(aWord[0]) ? dDA.get(aWord[0]) : _dAnalyses.get(aWord[1]); //echo("lMorph: "+lMorph.toString()); if (lMorph.length === 0) { return false; } //echo("***"); if (bStrict) { return lMorph.every(s => (s.search(sPattern) !== -1)); } return lMorph.some(s => (s.search(sPattern) !== -1)); } function morphex (dDA, aWord, sPattern, sNegPattern, bNoWord=false) { // analyse a tuple (position, word), returns true if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation on) if (!aWord) { //echo("morph: noword, returns " + bNoWord); return bNoWord; } //echo("aWord: "+aWord.toString()); if (!_dAnalyses.has(aWord[1]) && !_storeMorphFromFSA(aWord[1])) { return false; } let lMorph = dDA.has(aWord[0]) ? dDA.get(aWord[0]) : _dAnalyses.get(aWord[1]); //echo("lMorph: "+lMorph.toString()); if (lMorph.length === 0) { return false; } //echo("***"); // check negative condition if (lMorph.some(s => (s.search(sNegPattern) !== -1))) { return false; } // search sPattern return lMorph.some(s => (s.search(sPattern) !== -1)); } function analyse (sWord, sPattern, bStrict=true) { // analyse a word, return true if sPattern in morphologies (disambiguation off) if (!_dAnalyses.has(sWord) && !_storeMorphFromFSA(sWord)) { return false; } if (bStrict) { return _dAnalyses.get(sWord).every(s => (s.search(sPattern) !== -1)); } return _dAnalyses.get(sWord).some(s => (s.search(sPattern) !== -1)); } function analysex (sWord, sPattern, sNegPattern) { // analyse a word, returns True if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation off) if (!_dAnalyses.has(sWord) && !_storeMorphFromFSA(sWord)) { return false; } // check negative condition if (_dAnalyses.get(sWord).some(s => (s.search(sNegPattern) !== -1))) { return false; } // search sPattern return _dAnalyses.get(sWord).some(s => (s.search(sPattern) !== -1)); } function stem (sWord) { // returns a list of sWord's stems if (!sWord) { return []; } if (!_dAnalyses.has(sWord) && !_storeMorphFromFSA(sWord)) { return []; } return [ for (s of _dAnalyses.get(sWord)) s.slice(1, s.indexOf(" ")) ]; } //// functions to get text outside pattern scope // warning: check compile_rules.py to understand how it works function nextword (s, iStart, n) { // get the nth word of the input string or empty string let z = new RegExp("^( +[a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st%_-]+){" + (n-1).toString() + "} +([a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st%_-]+)", "i"); let m = z.exec(s.slice(iStart)); if (!m) { return null; } return [iStart + RegExp.lastIndex - m[2].length, m[2]]; } function prevword (s, iEnd, n) { // get the (-)nth word of the input string or empty string let z = new RegExp("([a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st%_-]+) +([a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st%_-]+ +){" + (n-1).toString() + "}$", "i"); let m = z.exec(s.slice(0, iEnd)); if (!m) { return null; } return [m.index, m[1]]; } const _zNextWord = new RegExp ("^ +([a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st_][a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st_-]*)", "i"); const _zPrevWord = new RegExp ("([a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st_][a-zà-öA-Zø-ÿÀ-Ö0-9Ø-ßĀ-ʯfi-st_-]*) +$", "i"); function nextword1 (s, iStart) { // get next word (optimization) let m = _zNextWord.exec(s.slice(iStart)); if (!m) { return null; } return [iStart + RegExp.lastIndex - m[1].length, m[1]]; } function prevword1 (s, iEnd) { // get previous word (optimization) //echo("prev1, s:"+s); //echo("prev1, s.slice(0, iEnd):"+s.slice(0, iEnd)); let m = _zPrevWord.exec(s.slice(0, iEnd)); //echo("prev1, m:"+m); if (!m) { return null; } //echo("prev1: " + m.index + " " + m[1]); return [m.index, m[1]]; } function look (s, zPattern, zNegPattern=null) { // seek zPattern in s (before/after/fulltext), if antipattern zNegPattern not in s try { if (zNegPattern && zNegPattern.test(s)) { return false; } return zPattern.test(s); } catch (e) { helpers.logerror(e); } return false; } function look_chk1 (dDA, s, nOffset, zPattern, sPatternGroup1, sNegPatternGroup1=null) { // returns True if s has pattern zPattern and m.group(1) has pattern sPatternGroup1 let m = zPattern._exec2(s, null); if (!m) { return false; } try { let sWord = m[1]; let nPos = m.start[1] + nOffset; if (sNegPatternGroup1) { return morphex(dDA, [nPos, sWord], sPatternGroup1, sNegPatternGroup1); } return morph(dDA, [nPos, sWord], sPatternGroup1, false); } catch (e) { helpers.logerror(e); return false; } } //////// Disambiguator function select (dDA, nPos, sWord, sPattern, lDefault=null) { if (!sWord) { return true; } if (dDA.has(nPos)) { return true; } if (!_dAnalyses.has(sWord) && !_storeMorphFromFSA(sWord)) { return true; } //echo("morph: "+_dAnalyses.get(sWord).toString()); if (_dAnalyses.get(sWord).length === 1) { return true; } let lSelect = [ for (sMorph of _dAnalyses.get(sWord)) if (sMorph.search(sPattern) !== -1) sMorph ]; //echo("lSelect: "+lSelect.toString()); if (lSelect.length > 0) { if (lSelect.length != _dAnalyses.get(sWord).length) { dDA.set(nPos, lSelect); } } else if (lDefault) { dDA.set(nPos, lDefaul); } return true; } function exclude (dDA, nPos, sWord, sPattern, lDefault=null) { if (!sWord) { return true; } if (dDA.has(nPos)) { return true; } if (!_dAnalyses.has(sWord) && !_storeMorphFromFSA(sWord)) { return true; } if (_dAnalyses.get(sWord).length === 1) { return true; } let lSelect = [ for (sMorph of _dAnalyses.get(sWord)) if (sMorph.search(sPattern) === -1) sMorph ]; //echo("lSelect: "+lSelect.toString()); if (lSelect.length > 0) { if (lSelect.length != _dAnalyses.get(sWord).length) { dDA.set(nPos, lSelect); } } else if (lDefault) { dDA.set(nPos, lDefault); } return true; } function define (dDA, nPos, lMorph) { dDA.set(nPos, lMorph); return true; } //////// GRAMMAR CHECKER PLUGINS ${pluginsJS} ${callablesJS} exports.load = load; exports.parse = parse; exports.lang = lang; exports.version = version; exports.getDictionary = getDictionary; exports.setOption = setOption; exports.setOptions = setOptions; exports.getOptions = getOptions; exports.getDefaultOptions = getDefaultOptions; exports.resetOptions = resetOptions; exports.ignoreRule = ignoreRule; exports.reactivateRule = reactivateRule; exports.resetIgnoreRules = resetIgnoreRules; exports.listRules = listRules; |
Added gc_core/js/lang_core/gc_options.js version [3105c2862f].
> > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 | // Options for Grammalecte ${map} const lStructOpt = ${lStructOpt}; const dOpt = new Map (${dOptJavaScript}); const dOptLabel = ${dOptLabel}; exports.lStructOpt = lStructOpt; exports.dOpt = dOpt; exports.dOptLabel = dOptLabel; |
Added gc_core/js/lang_core/gc_rules.js version [c85bd666a1].
> > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 | // Grammar checker rules "use strict"; ${string} ${regex} const lParagraphRules = ${paragraph_rules_JS}; const lSentenceRules = ${sentence_rules_JS}; exports.lParagraphRules = lParagraphRules; exports.lSentenceRules = lSentenceRules; |
Added gc_core/js/str_transform.js version [572c35f46a].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 | //// STRING TRANSFORMATION var dSimilarChars = new Map ([ ["a", "aàâáä"], ["à", "aàâáä"], ["â", "aàâáä"], ["á", "aàâáä"], ["ä", "aàâáä"], ["c", "cç"], ["ç", "cç"], ["e", "eéêèë"], ["é", "eéêèë"], ["ê", "eéêèë"], ["è", "eéêèë"], ["ë", "eéêèë"], ["i", "iîïíì"], ["î", "iîïíì"], ["ï", "iîïíì"], ["í", "iîïíì"], ["ì", "iîïíì"], ["o", "oôóòö"], ["ô", "oôóòö"], ["ó", "oôóòö"], ["ò", "oôóòö"], ["ö", "oôóòö"], ["u", "uûùüú"], ["û", "uûùüú"], ["ù", "uûùüú"], ["ü", "uûùüú"], ["ú", "uûùüú"] ]); // Note: 48 is the ASCII code for "0" // Suffix only function getStemFromSuffixCode (sFlex, sSfxCode) { if (sSfxCode == "0") { return sFlex; } return sSfxCode[0] == '0' ? sFlex + sSfxCode.slice(1) : sFlex.slice(0, -(sSfxCode.charCodeAt(0)-48)) + sSfxCode.slice(1); } // Prefix and suffix function getStemFromAffixCode (sFlex, sAffCode) { if (sAffCode == "0") { return sFlex; } if (!sAffCode.includes("/")) { return "# error #"; } var [sPfxCode, sSfxCode] = sAffCode.split('/'); sFlex = sPfxCode.slice(1) + sFlex.slice(sPfxCode.charCodeAt(0)-48); return sSfxCode[0] == '0' ? sFlex + sSfxCode.slice(1) : sFlex.slice(0, -(sSfxCode.charCodeAt(0)-48)) + sSfxCode.slice(1); } exports.getStemFromSuffixCode = getStemFromSuffixCode; exports.getStemFromAffixCode = getStemFromAffixCode; |
Added gc_core/js/tests.js version [1893d7a17d].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 | // JavaScript "use strict"; const helpers = require("resource://grammalecte/helpers.js"); class TestGrammarChecking { constructor (gce) { this.gce = gce; this._aRuleTested = new Set(); }; * testParse (bDebug=false) { const t0 = Date.now(); const aData = JSON.parse(helpers.loadFile("resource://grammalecte/"+this.gce.lang+"/tests_data.json")).aData; //const aData = require("resource://grammalecte/"+this.gce.lang+"/tests_data.js").aData; let nInvalid = 0 let nTotal = 0 let sErrorText; let sSugg; let sExpectedErrors; let sTextToCheck; let sFoundErrors; let sListErr; let sLineNum; let i = 1; let sUntestedRules = ""; let bShowUntested = false; let zOption = /^__([a-zA-Z0-9]+)__ /; let sOption; let m; yield "Tests [" + this.gce.lang + "]: " + aData.length.toString(); try { for (let sLine of aData) { sLineNum = sLine.slice(0,10).trim(); sLine = sLine.slice(10).trim(); if (sLine.length > 0 && !sLine.startsWith("#")) { sOption = false; m = zOption.exec(sLine); if (m) { sLine = sLine.slice(sLine.indexOf(" ")+1); sOption = m[1]; } if (sLine.includes("->>")) { [sErrorText, sSugg] = sLine.split("->>"); sErrorText = sErrorText.trim(); sSugg = sSugg.trim(); } else { sErrorText = sLine.trim(); } sExpectedErrors = this._getExpectedErrors(sErrorText); sTextToCheck = sErrorText.replace(/\{\{/g, "").replace(/\}\}/g, ""); [sFoundErrors, sListErr] = this._getFoundErrors(sTextToCheck, bDebug, sOption); if (sExpectedErrors !== sFoundErrors) { yield "\n" + i.toString() + "\n# Line num: " + sLineNum + "\n> to check: " + sTextToCheck + "\n expected: " + sExpectedErrors + "\n found: " + sFoundErrors + "\n errors: \n" + sListErr; nInvalid = nInvalid + 1 } nTotal = nTotal + 1; } i = i + 1; if (i % 100 === 0) { yield i.toString(); } } bShowUntested = true; } catch (e) { helpers.logerror(e); } if (bShowUntested) { i = 0; for (let [sOpt, sLineId, sRuleId] of gce.listRules()) { if (!this._aRuleTested.has(sLineId) && !/^[0-9]+[sp]$/.test(sRuleId)) { sUntestedRules += sRuleId + ", "; i += 1; } } if (i > 0) { yield sUntestedRules + "\n[" + i.toString() + " untested rules]"; } } const t1 = Date.now(); yield "Tests parse finished in " + ((t1-t0)/1000).toString() + " s\nTotal errors: " + nInvalid.toString() + " / " + nTotal.toString(); }; _getExpectedErrors (sLine) { try { let sRes = " ".repeat(sLine.length); let z = /\{\{.+?\}\}/g; let m; let i = 0; while ((m = z.exec(sLine)) !== null) { let nStart = m.index - (4 * i); let nEnd = m.index + m[0].length - (4 * (i+1)); sRes = sRes.slice(0, nStart) + "~".repeat(nEnd - nStart) + sRes.slice(nEnd, -4); i = i + 1; // Warning! JS sucks: infinite loop if writing directly /\{\{.+?\}\}/g.exec(sLine) // lines below to remove when I know why. if (i > 10) { console.log("\ninfinite loop?\nline:"+sLine+"\nm: "+ m.toString()); break; } } return sRes; } catch (e) { helpers.logerror(e); } return " ".repeat(sLine.length); }; _getFoundErrors (sLine, bDebug, sOption) { try { let aErrs = []; if (sOption) { gce.setOption(sOption, true); aErrs = this.gce.parse(sLine, "FR", bDebug); gce.setOption(sOption, false); } else { aErrs = this.gce.parse(sLine, "FR", bDebug); } let sRes = " ".repeat(sLine.length); let sListErr = ""; for (let dErr of aErrs) { sRes = sRes.slice(0, dErr["nStart"]) + "~".repeat(dErr["nEnd"] - dErr["nStart"]) + sRes.slice(dErr["nEnd"]); sListErr += " * {" + dErr['sLineId'] + " / " + dErr['sRuleId'] + "} at " + dErr['nStart'] + ":" + dErr['nEnd'] + "\n"; this._aRuleTested.add(dErr["sLineId"]); } return [sRes, sListErr]; } catch (e) { helpers.logerror(e); } return [" ".repeat(sLine.length), ""]; }; } exports.TestGrammarChecking = TestGrammarChecking; |
Added gc_core/js/text.js version [0a62428d8c].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | // JavaScript "use strict"; const helpers = require("resource://grammalecte/helpers.js"); function* getParagraph (sText) { // generator: returns paragraphs of text let iStart = 0; let iEnd = 0; sText = sText.replace("\r", ""); while ((iEnd = sText.indexOf("\n", iStart)) !== -1) { yield sText.slice(iStart, iEnd); iStart = iEnd + 1; } yield sText.slice(iStart); } function* wrap (sText, nWidth=80) { // generator: returns text line by line while (sText) { if (sText.length >= nWidth) { let nEnd = sText.lastIndexOf(" ", nWidth) + 1; if (nEnd > 0) { yield sText.slice(0, nEnd); sText = sText.slice(nEnd); } else { yield sText.slice(0, nWidth); sText = sText.slice(nWidth); } } else { break; } } yield sText; } function getReadableError (oErr) { // Returns an error oErr as a readable error try { let s = "\n* " + oErr['nStart'] + ":" + oErr['nEnd'] + " # " + oErr['sRuleId']+" : "; s += oErr["sMessage"]; if (oErr["aSuggestions"].length > 0) { s += "\n > Suggestions : " + oErr["aSuggestions"].join(" | "); } if (oErr["URL"] !== "") { s += "\n > URL: " + oErr["URL"]; } return s; } catch (e) { helpers.logerror(e); return "\n# Error. Data: " + oErr.toString(); } } function addHtmlEntities (sParagraph) { if (sParagraph.includes("&")) { sParagraph = sParagraph.replace(/&/g, "&"); } if (sParagraph.includes("<")) { sParagraph = sParagraph.replace(/</g, "<").replace(/>/g, ">"); } return sParagraph; } function createHTMLBlock (sParagraph, iParagraph) { let sClassName = (sParagraph.includes('<u id="err')) ? " softred" : ""; return '<p id="paragr'+iParagraph.toString()+'" class="paragraph' + sClassName + '" lang="fr" spellcheck="false">' + sParagraph + '</p>\n' + '<div class="actions"><div id="end'+iParagraph.toString()+'" class="button red">×</div>' + '<div id="edit'+iParagraph.toString()+'" class="button">Éditer</div>' + '<div id="check'+iParagraph.toString()+'" class="button green">Réanalyser</div> </div>\n'; } function tagParagraph (sParagraph, iParagraph, aGrammErr, aSpellErr, bDebug=false) { // Returns a text with with underlined errors and messages in tooltip try { if (aGrammErr.length === 0 && aSpellErr.length === 0) { return sParagraph; } aGrammErr.push(...aSpellErr); aGrammErr.sort(function (a, b) { if (a["nStart"] < b["nStart"]) return 1; if (a["nStart"] > b["nStart"]) return -1; return 0; }); let nErr = aGrammErr.length - 1; // we count errors to give them an identifier let nStartLastErr = sParagraph.length; for (let oErr of aGrammErr) { let sErrId = iParagraph.toString() + "_" + nErr.toString(); let nStart = oErr["nStart"]; let nEnd = oErr["nEnd"]; if (nEnd <= nStartLastErr) { oErr["sId"] = sErrId; if (oErr['sType'] !== 'WORD') { // Grammar Error sParagraph = sParagraph.slice(0, nStart) + '<u id="err' + sErrId + '" class="error '+oErr['sType']+'" href="#" onclick="return false;">' + sParagraph.slice(nStart, nEnd) + '<span id="tooltip' + sErrId + '" class="tooltip" contenteditable="false">' + getGrammarErrorHTML(oErr, bDebug) + '</span>' + "</u><!-- err_end -->" + sParagraph.slice(nEnd); } else { // Spelling error sParagraph = sParagraph.slice(0, nStart) + '<u id="err' + sErrId + '" class="error spell" href="#" onclick="return false;">' + sParagraph.slice(nStart, nEnd) + '<span id="tooltip' + sErrId + '" class="tooltip" contenteditable="false">' + getSpellingErrorHTML(oErr) + '</span>' + "</u><!-- err_end -->" + sParagraph.slice(nEnd); } nStartLastErr = nStart; } nErr -= 1; } return sParagraph; } catch (e) { helpers.logerror(e); return "# Error."; } } function getGrammarErrorHTML (oErr, bDebug=false) { // Returns an error oErr as a readable error in HTML try { let sErr = ''; if (bDebug) { sErr += '<em class="debug">' + '<i id="data'+oErr['sId']+'" class="data" hidden>' + oErr['nStart'] + ":" + oErr['nEnd'] + ' · #' + oErr['sRuleId'] + " </i>+</em>"; } sErr += oErr["sMessage"]; sErr += ' <a id="ignore'+oErr['sId']+'" class="ignore" href="#" onclick="return false;">IGNORER</a>'; if (oErr["URL"] !== "") { sErr += ' <a href="' + oErr["URL"] + '" onclick="return false;">Infos…</a>'; } if (oErr["aSuggestions"].length > 0) { sErr += '<br/><s>Suggestions :</s><br/>'; let iSugg = 0; for (let sSugg of oErr["aSuggestions"]) { sErr += '<a id="sugg' + oErr['sId'] + "-" + iSugg + '" class="sugg" href="#" onclick="return false;">' + sSugg + '</a> '; iSugg += 1; } } return sErr; } catch (e) { helpers.logerror(e); return '# Error. Data: ' + oErr.toString(); } } function getSpellingErrorHTML (oErr) { // Returns an error oErr as a readable error in HTML try { let sErr = 'Mot inconnu du dictionnaire.'; sErr += ' <a id="ignore' + oErr['sId'] + '" class="ignore" href="#" onclick="return false;">IGNORER</a>'; sErr += '<br/><s>Suggestions :</s><br/>'; return sErr; } catch (e) { helpers.logerror(e); return '# Error. Data: ' + oErr.toString(); } } exports.getParagraph = getParagraph; exports.addHtmlEntities = addHtmlEntities; exports.createHTMLBlock = createHTMLBlock; exports.tagParagraph = tagParagraph; exports.getReadableError = getReadableError; |
Added gc_core/js/tokenizer.js version [d06151ccd7].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 | // JavaScript // Very simple tokenizer "use strict"; const helpers = require("resource://grammalecte/helpers.js"); const aPatterns = { // All regexps must start with ^. "default": [ [/^[ \t]+/, 'SPACE'], [/^[,.;:!?…«»“”"()/·]+/, 'SEPARATOR'], [/^(?:https?:\/\/|www[.]|[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_]+[@.][a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_]+[@.])[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_.\/?&!%=+*"'@$#-]+/, 'LINK'], [/^[#@][a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_-]+/, 'TAG'], [/^<[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+.*?>|<\/[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+ *>/, 'HTML'], [/^\[\/?[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+\]/, 'PSEUDOHTML'], [/^&\w+;(?:\w+;|)/, 'HTMLENTITY'], [/^\d\d?h\d\d\b/, 'HOUR'], [/^-?\d+(?:[.,]\d+|)/, 'NUM'], [/^[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+(?:[’'`-][a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+)*/, 'WORD'] ], "fr": [ [/^[ \t]+/, 'SPACE'], [/^[,.;:!?…«»“”"()/·]+/, 'SEPARATOR'], [/^(?:https?:\/\/|www[.]|[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_]+[@.][a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_]+[@.])[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_.\/?&!%=+*"'@$#-]+/, 'LINK'], [/^[#@][a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st_-]+/, 'TAG'], [/^<[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+.*?>|<\/[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+ *>/, 'HTML'], [/^\[\/?[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+\]/, 'PSEUDOHTML'], [/^&\w+;(?:\w+;|)/, 'HTMLENTITY'], [/^(?:l|d|n|m|t|s|j|c|ç|lorsqu|puisqu|jusqu|quoiqu|qu)['’`]/i, 'ELPFX'], [/^\d\d?[hm]\d\d\b/, 'HOUR'], [/^\d+(?:er|nd|e|de|ième|ème|eme)\b/, 'ORDINAL'], [/^-?\d+(?:[.,]\d+|)/, 'NUM'], [/^[a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+(?:[’'`-][a-zA-Zà-öÀ-Ö0-9ø-ÿØ-ßĀ-ʯfi-st]+)*/, 'WORD'] ] } class Tokenizer { constructor (sLang) { this.sLang = sLang; if (!aPatterns.hasOwnProperty(sLang)) { this.sLang = "default"; } this.aRules = aPatterns[sLang]; }; * genTokens (sText) { let m; let i = 0; while (sText) { let nCut = 1; for (let [zRegex, sType] of this.aRules) { try { if ((m = zRegex.exec(sText)) !== null) { yield { "sType": sType, "sValue": m[0], "nStart": i, "nEnd": i + m[0].length } nCut = m[0].length; break; } } catch (e) { helpers.logerror(e); } } i += nCut; sText = sText.slice(nCut); } } } exports.Tokenizer = Tokenizer; |
Added gc_core/py/README.txt version [ffaeafbfd2].
> > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | = GRAMMALECTE = Grammar checker By Olivier R. Website: http://grammalecte.net License: GPL 3 -- http://www.gnu.org/copyleft/gpl.html Grammalecte is a fork of Lightproof from László Németh (nemeth /at/ numbertext /dot/ org) http://cgit.freedesktop.org/libreoffice/lightproof/ Required : Python 3.3 |
Added gc_core/py/__init__.py version [a7ffc6f8bf].
Added gc_core/py/dawg.py version [a9c487538f].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 | #!python3 # FSA DICTIONARY BUILDER # # by Olivier R. # License: MPL 2 # # This tool encodes lexicon into an indexable binary dictionary # Input files MUST be encoded in UTF-8. import sys import os import collections from . import str_transform as st from .progressbar import ProgressBar class DAWG: """DIRECT ACYCLIC WORD GRAPH""" # This code is inspired from Steve Hanov’s DAWG, 2011. (http://stevehanov.ca/blog/index.php?id=115) # We store suffix/affix codes and tags within the graph after the “real” word. # A word is a list of numbers [ c1, c2, c3 . . . cN, iAffix, iTags] # Each arc is an index in self.lArcVal, where are stored characters, suffix/affix codes for stemming and tags. # Important: As usual, the last node (after ‘iTags’) is tagged final, AND the node after ‘cN’ is ALSO tagged final. def __init__ (self, spfSrc, sLangName, cStemming): print("===== Direct Acyclic Word Graph - Minimal Acyclic Finite State Automaton =====") cStemming = cStemming.upper() if cStemming == "A": funcStemmingGen = st.defineAffixCode elif cStemming == "S": funcStemmingGen = st.defineSuffixCode elif cStemming == "N": funcStemmingGen = st.noStemming else: print("# Error code: {}".format(cStemming)) exit() lEntry = [] lChar = ['']; dChar = {}; nChar = 1; dCharOccur = {} lAff = []; dAff = {}; nAff = 0; dAffOccur = {} lTag = []; dTag = {}; nTag = 0; dTagOccur = {} nErr = 0 # read lexicon with open(spfSrc, 'r', encoding='utf-8') as hSrc: print(" > Reading lexicon: " + spfSrc + " ...") for line in hSrc: line = line.strip() if not (line.startswith('#') or line == ''): try: flex, stem, tag = line.split("\t") except: nErr += 1 continue # chars for c in flex: if c not in dChar: dChar[c] = nChar lChar.append(c) nChar += 1 dCharOccur[c] = dCharOccur.get(c, 0) + 1 # affixes to find stem from flexion aff = funcStemmingGen(flex, stem) if aff not in dAff: dAff[aff] = nAff lAff.append(aff) nAff += 1 dAffOccur[aff] = dCharOccur.get(aff, 0) + 1 # tags if tag not in dTag: dTag[tag] = nTag lTag.append(tag) nTag += 1 dTagOccur[tag] = dTagOccur.get(tag, 0) + 1 lEntry.append((flex, dAff[aff], dTag[tag])) hSrc.close() if nErr: print(" # Lines ignored: {:>10}".format(nErr)) if not(lEntry): print(" # Empty lexicon") exit() # Preparing DAWG print(" > Preparing list of words") lVal = lChar + lAff + lTag lWord = [ [dChar[c] for c in sFlex] + [iAff+nChar] + [iTag+nChar+nAff] for sFlex, iAff, iTag in lEntry ] lEntry = None # Dictionary of arc values occurrency, to sort arcs of each node dValOccur = dict( [ (dChar[c], dCharOccur[c]) for c in dChar ] \ + [ (dAff[aff]+nChar, dAffOccur[aff]) for aff in dAff ] \ + [ (dTag[tag]+nChar+nAff, dTagOccur[tag]) for tag in dTag ] ) #with open(spfSrc[:-8]+".valuesfreq.txt", 'w', encoding='utf-8') as hFreqDst: # DEBUG # for iKey, nOcc in sorted(dValOccur.items(), key=lambda t: t[1], reverse=True): # hFreqDst.write("{}: {}\n".format(lVal[iKey], nOcc)) # hFreqDst.close() self.sFile = spfSrc self.sLang = sLangName self.nEntry = len(lWord) self.previousWord = [] DawgNode.resetNextId() self.root = DawgNode() self.uncheckedNodes = [] # list of nodes that have not been checked for duplication. self.minimizedNodes = {} # list of unique nodes that have been checked for duplication. self.sortedNodes = [] # version 2 and 3 self.nNode = 0 self.nArc = 0 self.dChar = dChar self.nChar = len(dChar) self.nAff = nAff self.lArcVal = lVal self.nArcVal = len(lVal) self.nTag = self.nArcVal - self.nChar - nAff self.cStemming = cStemming.upper() if cStemming == "A": self.funcStemming = st.getStemFromAffixCode elif cStemming == "S": self.funcStemming = st.getStemFromSuffixCode else: self.funcStemming = st.noStemming # build lWord.sort() oProgBar = ProgressBar(0, len(lWord)) for word in lWord: self.insert(word) oProgBar.increment(1) oProgBar.done() self.finish() self.countNodes() self.countArcs() self.sortNodes() self.sortNodeArcs(dValOccur) self.displayInfo() # BUILD DAWG def insert (self, word): if word < self.previousWord: sys.exit("# Error: Words must be inserted in alphabetical order.") # find common prefix between word and previous word commonPrefix = 0 for i in range(min(len(word), len(self.previousWord))): if word[i] != self.previousWord[i]: break commonPrefix += 1 # Check the uncheckedNodes for redundant nodes, proceeding from last # one down to the common prefix size. Then truncate the list at that point. self._minimize(commonPrefix) # add the suffix, starting from the correct node mid-way through the graph if len(self.uncheckedNodes) == 0: oNode = self.root else: oNode = self.uncheckedNodes[-1][2] iChar = commonPrefix for c in word[commonPrefix:]: oNextNode = DawgNode() oNode.arcs[c] = oNextNode self.uncheckedNodes.append((oNode, c, oNextNode)) if iChar == (len(word) - 2): oNode.final = True iChar += 1 oNode = oNextNode oNode.final = True self.previousWord = word def finish (self): "minimize unchecked nodes" self._minimize(0) def _minimize (self, downTo): # proceed from the leaf up to a certain point for i in range( len(self.uncheckedNodes)-1, downTo-1, -1 ): (parent, char, child) = self.uncheckedNodes[i] if child in self.minimizedNodes: # replace the child with the previously encountered one parent.arcs[char] = self.minimizedNodes[child] else: # add the state to the minimized nodes. self.minimizedNodes[child] = child self.uncheckedNodes.pop() def countNodes (self): self.nNode = len(self.minimizedNodes) def countArcs (self): self.nArc = 0 for node in self.minimizedNodes: self.nArc += len(node.arcs) def sortNodeArcs (self, dValOccur): print(" > Sort node arcs") self.root.sortArcs(dValOccur) for oNode in self.minimizedNodes: oNode.sortArcs(dValOccur) def sortNodes (self): print(" > Sort nodes") for oNode in self.root.arcs.values(): self._parseNodes(oNode) def _parseNodes (self, oNode): # Warning: recursive method if oNode.pos > 0: return oNode.setPos() self.sortedNodes.append(oNode) for oNextNode in oNode.arcs.values(): self._parseNodes(oNextNode) def lookup (self, sWord): oNode = self.root for c in sWord: if self.dChar.get(c, '') not in oNode.arcs: return False oNode = oNode.arcs[self.dChar[c]] return oNode.final def morph (self, sWord): oNode = self.root for c in sWord: if self.dChar.get(c, '') not in oNode.arcs: return '' oNode = oNode.arcs[self.dChar[c]] if oNode.final: s = "* " for arc in oNode.arcs: if arc >= self.nChar: s += " [" + self.funcStemming(sWord, self.lArcVal[arc]) oNode2 = oNode.arcs[arc] for arc2 in oNode2.arcs: s += " / " + self.lArcVal[arc2] s += "]" return s return '' def displayInfo (self): print(" * {:<12} {:>16,}".format("Entries:", self.nEntry)) print(" * {:<12} {:>16,}".format("Characters:", self.nChar)) print(" * {:<12} {:>16,}".format("Affixes:", self.nAff)) print(" * {:<12} {:>16,}".format("Tags:", self.nTag)) print(" * {:<12} {:>16,}".format("Arc values:", self.nArcVal)) print(" * {:<12} {:>16,}".format("Nodes:", self.nNode)) print(" * {:<12} {:>16,}".format("Arcs:", self.nArc)) print(" * {:<12} {:>16}".format("Stemming:", self.cStemming + "FX")) def getArcStats (self): d = {} for oNode in self.minimizedNodes: n = len(oNode.arcs) d[n] = d.get(n, 0) + 1 s = " * Nodes:\n" for n in d: s = s + " {:>9} nodes have {:>3} arcs\n".format(d[n], n) return s def writeInfo (self, sPathFile): print(" > Write informations") with open(sPathFile, 'w', encoding='utf-8', newline="\n") as hDst: hDst.write(self.getArcStats()) hDst.write("\n * Values:\n") for i, s in enumerate(self.lArcVal): hDst.write(" {:>6}. {}\n".format(i, s)) hDst.close() # BINARY CONVERSION def createBinary (self, sPathFile, nMethod, bDebug=False): print(" > Write DAWG as an indexable binary dictionary [method: %d]" % nMethod) if nMethod == 1: self.nBytesArc = ( ( (self.nArcVal).bit_length() + 2 ) // 8 ) + 1 # We add 2 bits. See DawgNode.convToBytes1() self._calcNumBytesNodeAddress() self._calcNodesAddress1() elif nMethod == 2: self.nBytesArc = ( ( (self.nArcVal).bit_length() + 3 ) // 8 ) + 1 # We add 3 bits. See DawgNode.convToBytes2() self._calcNumBytesNodeAddress() self._calcNodesAddress2() elif nMethod == 3: self.nBytesArc = ( ( (self.nArcVal).bit_length() + 3 ) // 8 ) + 1 # We add 3 bits. See DawgNode.convToBytes3() self.nBytesOffset = 1 self.nMaxOffset = (2 ** (self.nBytesOffset * 8)) - 1 self._calcNumBytesNodeAddress() self._calcNodesAddress3() else: print(" # Error: unknown compression method") print(" Arc values (chars, affixes and tags): {} -> {} bytes".format( self.nArcVal, len("\t".join(self.lArcVal).encode("utf-8")) )) print(" Arc size: {} bytes, Address size: {} bytes -> {} * {} = {} bytes".format( self.nBytesArc, self.nBytesNodeAddress, \ self.nBytesArc+self.nBytesNodeAddress, self.nArc, \ (self.nBytesArc+self.nBytesNodeAddress)*self.nArc )) self._writeBinary(sPathFile, nMethod) if bDebug: self._writeNodes(sPathFile, nMethod) def _calcNumBytesNodeAddress (self): "how many bytes needed to store all nodes/arcs in the binary dictionary" self.nBytesNodeAddress = 1 while ((self.nBytesArc + self.nBytesNodeAddress) * self.nArc) > (2 ** (self.nBytesNodeAddress * 8)): self.nBytesNodeAddress += 1 def _calcNodesAddress1 (self): nBytesNode = self.nBytesArc + self.nBytesNodeAddress iAddr = len(self.root.arcs) * nBytesNode for oNode in self.minimizedNodes: oNode.addr = iAddr iAddr += max(len(oNode.arcs), 1) * nBytesNode def _calcNodesAddress2 (self): nBytesNode = self.nBytesArc + self.nBytesNodeAddress iAddr = len(self.root.arcs) * nBytesNode for oNode in self.sortedNodes: oNode.addr = iAddr iAddr += max(len(oNode.arcs), 1) * nBytesNode for oNextNode in oNode.arcs.values(): if (oNode.pos + 1) == oNextNode.pos: iAddr -= self.nBytesNodeAddress #break def _calcNodesAddress3 (self): nBytesNode = self.nBytesArc + self.nBytesNodeAddress # theorical nodes size if only addresses and no offset self.root.size = len(self.root.arcs) * nBytesNode for oNode in self.sortedNodes: oNode.size = max(len(oNode.arcs), 1) * nBytesNode # rewind and calculate dropdown from the end, several times nDiff = self.nBytesNodeAddress - self.nBytesOffset bEnd = False while not bEnd: bEnd = True # recalculate addresses iAddr = self.root.size for oNode in self.sortedNodes: oNode.addr = iAddr iAddr += oNode.size # rewind and calculate dropdown from the end, several times for i in range(self.nNode-1, -1, -1): nSize = max(len(self.sortedNodes[i].arcs), 1) * nBytesNode for oNextNode in self.sortedNodes[i].arcs.values(): if 1 < (oNextNode.addr - self.sortedNodes[i].addr) < self.nMaxOffset: nSize -= nDiff if self.sortedNodes[i].size != nSize: self.sortedNodes[i].size = nSize bEnd = False def _writeBinary (self, sPathFile, nMethod): """ Format of the binary indexable dictionary: Each section is separated with 4 bytes of \0 - Section Header: /pyfsa/[version] * version is an ASCII string - Section Informations: /[tag_lang] /[number of chars] /[number of bytes for each arc] /[number of bytes for each address node] /[number of entries] /[number of nodes] /[number of arcs] /[number of affixes] * each field is a ASCII string /[stemming code] * "S" means stems are generated by /suffix_code/, "A" means they are generated by /affix_code/ See defineSuffixCode() and defineAffixCode() for details. "N" means no stemming - Section Values: * a list of strings encoded in binary from utf-8, each value separated with a tabulation - Section Word Graph (nodes / arcs) * A list of nodes which are a list of arcs with an address of the next node. See DawgNode.convToBytes() for details. """ if not sPathFile.endswith(".bdic"): sPathFile += "."+str(nMethod)+".bdic" with open(sPathFile, 'wb') as hDst: # header hDst.write("/pyfsa/{}/".format(nMethod).encode("utf-8")) hDst.write(b"\0\0\0\0") # infos hDst.write("{}/{}/{}/{}/{}/{}/{}/{}/{}".format(self.sLang, self.nChar, self.nBytesArc, self.nBytesNodeAddress, \ self.nEntry, self.nNode, self.nArc, self.nAff, self.cStemming).encode("utf-8")) hDst.write(b"\0\0\0\0") # lArcVal hDst.write("\t".join(self.lArcVal).encode("utf-8")) hDst.write(b"\0\0\0\0") # DAWG: nodes / arcs if nMethod == 1: hDst.write(self.root.convToBytes1(self.nBytesArc, self.nBytesNodeAddress)) for oNode in self.minimizedNodes: hDst.write(oNode.convToBytes1(self.nBytesArc, self.nBytesNodeAddress)) elif nMethod == 2: hDst.write(self.root.convToBytes2(self.nBytesArc, self.nBytesNodeAddress)) for oNode in self.sortedNodes: hDst.write(oNode.convToBytes2(self.nBytesArc, self.nBytesNodeAddress)) elif nMethod == 3: hDst.write(self.root.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset)) for oNode in self.sortedNodes: hDst.write(oNode.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset)) hDst.close() def _writeNodes (self, sPathFile, nMethod): "for debugging only" print(" > Write nodes") with open(sPathFile+".nodes."+str(nMethod)+".txt", 'w', encoding='utf-8', newline="\n") as hDst: if nMethod == 1: hDst.write(self.root.getTxtRepr1(self.nBytesArc, self.nBytesNodeAddress, self.lArcVal)+"\n") #hDst.write( ''.join( [ "%02X " % z for z in self.root.convToBytes1(self.nBytesArc, self.nBytesNodeAddress) ] ).strip() ) for oNode in self.minimizedNodes: hDst.write(oNode.getTxtRepr1(self.nBytesArc, self.nBytesNodeAddress, self.lArcVal)+"\n") if nMethod == 2: hDst.write(self.root.getTxtRepr2(self.nBytesArc, self.nBytesNodeAddress, self.lArcVal)+"\n") for oNode in self.sortedNodes: hDst.write(oNode.getTxtRepr2(self.nBytesArc, self.nBytesNodeAddress, self.lArcVal)+"\n") if nMethod == 3: hDst.write(self.root.getTxtRepr3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset, self.lArcVal)+"\n") #hDst.write( ''.join( [ "%02X " % z for z in self.root.convToBytes3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset) ] ).strip() ) for oNode in self.sortedNodes: hDst.write(oNode.getTxtRepr3(self.nBytesArc, self.nBytesNodeAddress, self.nBytesOffset, self.lArcVal)+"\n") hDst.close() def writeResults (self, sPathFile): bFileExits = os.path.isfile("_lexicons.res.txt") with open("_lexicons.res.txt", "a", encoding='utf-8', newline="\n") as hDst: sFormat1 = "{:<12} {:>12} {:>5} {:>8} {:>8} {:>6} {:>8} {:>9} {:>9} {:>15} {:>12} {:>12}\n" sFormat2 = "{:<12} {:>12,} {:>5,} {:>8,} {:>8} {:>6,} {:>8,} {:>9,} {:>9,} {:>15,} {:>12,} {:>12,}\n" if not bFileExits: hDst.write(sFormat1.format("Lexicon", "Entries", "Chars", "Affixes", "Stemming", "Tags", "Values", "Nodes", "Arcs", "Lexicon (Kb)", "Dict (Kb)", "LT Dict (Kb)")) hDst.write(sFormat2.format(self.sLang, self.nEntry, self.nChar, self.nAff, self.cStemming + "FX", self.nTag, self.nArcVal, \ self.nNode, self.nArc, os.path.getsize(self.sFile), os.path.getsize(sPathFile), \ os.path.getsize("cfsa/dict/{}.dict".format(self.sLang)) if os.path.isfile("cfsa/dict/{}.dict".format(self.sLang)) else 0)) hDst.close() class DawgNode: NextId = 0 NextPos = 1 # (version 2) def __init__ (self): self.i = DawgNode.NextId DawgNode.NextId += 1 self.final = False self.arcs = {} # key: arc value; value: a node self.addr = 0 # address in the binary dictionary self.pos = 0 # position in the binary dictionary (version 2) self.size = 0 # size of node in bytes (version 3) @classmethod def resetNextId (cls): cls.NextId = 0 def setPos (self): # version 2 self.pos = DawgNode.NextPos DawgNode.NextPos += 1 def __str__ (self): # Caution! this function is used for hashing and comparison! l = [] if self.final: l.append("1") else: l.append("0") for (key, node) in self.arcs.items(): l.append(str(key)) l.append(str(node.i)) return "_".join(l) def __hash__ (self): # Used as a key in a python dictionary. return self.__str__().__hash__() def __eq__ (self, other): # Used as a key in a python dictionary. # Nodes are equivalent if they have identical arcs, and each identical arc leads to identical states. return self.__str__() == other.__str__() def sortArcs (self, dValOccur): self.arcs = collections.OrderedDict(sorted(self.arcs.items(), key=lambda t: dValOccur[t[0]], reverse=True)) # VERSION 1 ===================================================================================================== def convToBytes1 (self, nBytesArc, nBytesNodeAddress): """ Node scheme: - Arc length is defined by nBytesArc - Address length is defined by nBytesNodeAddress | Arc | Address of next node | | | | /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ [...] /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ ^ ^ | | | | | \___ if 1, last arc of this node \_____ if 1, this node is final (only on the first arc) """ nArc = len(self.arcs) nFinalNodeMask = 1 << ((nBytesArc*8)-1) nFinalArcMask = 1 << ((nBytesArc*8)-2) if len(self.arcs) == 0: val = nFinalNodeMask | nFinalArcMask by = val.to_bytes(nBytesArc, byteorder='big') by += (0).to_bytes(nBytesNodeAddress, byteorder='big') return by by = b"" for i, arc in enumerate(self.arcs, 1): val = arc if i == 1 and self.final: val = val | nFinalNodeMask if i == nArc: val = val | nFinalArcMask by += val.to_bytes(nBytesArc, byteorder='big') by += self.arcs[arc].addr.to_bytes(nBytesNodeAddress, byteorder='big') return by def getTxtRepr1 (self, nBytesArc, nBytesNodeAddress, lVal): nArc = len(self.arcs) nFinalNodeMask = 1 << ((nBytesArc*8)-1) nFinalArcMask = 1 << ((nBytesArc*8)-2) s = "i{:_>10} -- #{:_>10}\n".format(self.i, self.addr) if len(self.arcs) == 0: s += " {:<20} {:0>16} i{:_>10} #{:_>10}\n".format("", bin(nFinalNodeMask | nFinalArcMask)[2:], "0", "0") return s for i, arc in enumerate(self.arcs, 1): val = arc if i == 1 and self.final: val = val | nFinalNodeMask if i == nArc: val = val | nFinalArcMask s += " {:<20} {:0>16} i{:_>10} #{:_>10}\n".format(lVal[arc], bin(val)[2:], self.arcs[arc].i, self.arcs[arc].addr) return s # VERSION 2 ===================================================================================================== def convToBytes2 (self, nBytesArc, nBytesNodeAddress): """ Node scheme: - Arc length is defined by nBytesArc - Address length is defined by nBytesNodeAddress | Arc | Address of next node | | | | /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ [...] /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ ^ ^ ^ | | | | | \_ if 1, caution, no address: next node is the following node | \___ if 1, last arc of this node \_____ if 1, this node is final (only on the first arc) """ nArc = len(self.arcs) nFinalNodeMask = 1 << ((nBytesArc*8)-1) nFinalArcMask = 1 << ((nBytesArc*8)-2) nNextNodeMask = 1 << ((nBytesArc*8)-3) if len(self.arcs) == 0: val = nFinalNodeMask | nFinalArcMask by = val.to_bytes(nBytesArc, byteorder='big') by += (0).to_bytes(nBytesNodeAddress, byteorder='big') return by by = b"" for i, arc in enumerate(self.arcs, 1): val = arc if i == 1 and self.final: val = val | nFinalNodeMask if i == nArc: val = val | nFinalArcMask if (self.pos + 1) == self.arcs[arc].pos and self.i != 0: val = val | nNextNodeMask by += val.to_bytes(nBytesArc, byteorder='big') else: by += val.to_bytes(nBytesArc, byteorder='big') by += self.arcs[arc].addr.to_bytes(nBytesNodeAddress, byteorder='big') return by def getTxtRepr2 (self, nBytesArc, nBytesNodeAddress, lVal): nArc = len(self.arcs) nFinalNodeMask = 1 << ((nBytesArc*8)-1) nFinalArcMask = 1 << ((nBytesArc*8)-2) nNextNodeMask = 1 << ((nBytesArc*8)-3) s = "i{:_>10} -- #{:_>10}\n".format(self.i, self.addr) if nArc == 0: s += " {:<20} {:0>16} i{:_>10} #{:_>10}\n".format("", bin(nFinalNodeMask | nFinalArcMask)[2:], "0", "0") return s for i, arc in enumerate(self.arcs, 1): val = arc if i == 1 and self.final: val = val | nFinalNodeMask if i == nArc: val = val | nFinalArcMask if (self.pos + 1) == self.arcs[arc].pos and self.i != 0: val = val | nNextNodeMask s += " {:<20} {:0>16}\n".format(lVal[arc], bin(val)[2:], "") else: s += " {:<20} {:0>16} i{:_>10} #{:_>10}\n".format(lVal[arc], bin(val)[2:], self.arcs[arc].i, self.arcs[arc].addr) return s # VERSION 3 ===================================================================================================== def convToBytes3 (self, nBytesArc, nBytesNodeAddress, nBytesOffset): """ Node scheme: - Arc length is defined by nBytesArc - Address length is defined by nBytesNodeAddress - Offset length is defined by nBytesOffset | Arc | Address of next node or offset to next node | | | | /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ |1|0|0| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ [...] /---------------\ /---------------\ /---------------\ |0|0|1| | | | | | | | | | | | | | | | | | | | | | | | Offsets are shorter than addresses \---------------/ \---------------/ \---------------/ /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ /---------------\ |0|1|0| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ \---------------/ ^ ^ ^ | | | | | \_ if 1, offset instead of address of next node | \___ if 1, last arc of this node \_____ if 1, this node is final (only on the first arc) """ nArc = len(self.arcs) nFinalNodeMask = 1 << ((nBytesArc*8)-1) nFinalArcMask = 1 << ((nBytesArc*8)-2) nNextNodeMask = 1 << ((nBytesArc*8)-3) nMaxOffset = (2 ** (nBytesOffset * 8)) - 1 if nArc == 0: val = nFinalNodeMask | nFinalArcMask by = val.to_bytes(nBytesArc, byteorder='big') by += (0).to_bytes(nBytesNodeAddress, byteorder='big') return by by = b"" for i, arc in enumerate(self.arcs, 1): val = arc if i == 1 and self.final: val = val | nFinalNodeMask if i == nArc: val = val | nFinalArcMask if 1 < (self.arcs[arc].addr - self.addr) < nMaxOffset and self.i != 0: val = val | nNextNodeMask by += val.to_bytes(nBytesArc, byteorder='big') by += (self.arcs[arc].addr-self.addr).to_bytes(nBytesOffset, byteorder='big') else: by += val.to_bytes(nBytesArc, byteorder='big') by += self.arcs[arc].addr.to_bytes(nBytesNodeAddress, byteorder='big') return by def getTxtRepr3 (self, nBytesArc, nBytesNodeAddress, nBytesOffset, lVal): nArc = len(self.arcs) nFinalNodeMask = 1 << ((nBytesArc*8)-1) nFinalArcMask = 1 << ((nBytesArc*8)-2) nNextNodeMask = 1 << ((nBytesArc*8)-3) nMaxOffset = (2 ** (nBytesOffset * 8)) - 1 s = "i{:_>10} -- #{:_>10} ({})\n".format(self.i, self.addr, self.size) if nArc == 0: s += " {:<20} {:0>16} i{:_>10} #{:_>10}\n".format("", bin(nFinalNodeMask | nFinalArcMask)[2:], "0", "0") return s for i, arc in enumerate(self.arcs, 1): val = arc if i == 1 and self.final: val = val | nFinalNodeMask if i == nArc: val = val | nFinalArcMask if 1 < (self.arcs[arc].addr - self.addr) < nMaxOffset and self.i != 0: val = val | nNextNodeMask s += " {:<20} {:0>16} i{:_>10} +{:_>10}\n".format(lVal[arc], bin(val)[2:], self.arcs[arc].i, self.arcs[arc].addr - self.addr) else: s += " {:<20} {:0>16} i{:_>10} #{:_>10}\n".format(lVal[arc], bin(val)[2:], self.arcs[arc].i, self.arcs[arc].addr) return s |
Added gc_core/py/echo.py version [6d11a5dda8].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | #!python3 # The most boring yet indispensable function: print! import sys _CHARMAP = str.maketrans({ 'œ': 'ö', 'Œ': 'Ö', 'ʳ': "r", 'ᵉ': "e", '…': "_", \ '“': '"', '”': '"', '„': '"', '‘': "'", '’': "'", \ 'ā': 'â', 'Ā': 'Â', 'ē': 'ê', 'Ē': 'Ê', 'ī': 'î', 'Ī': 'Î', \ 'ō': 'ô', 'Ō': 'Ô', 'ū': 'û', 'Ū': 'Û', 'Ÿ': 'Y', \ 'ś': 's', 'ŝ': 's', \ '—': '-', '–': '-' }) def echo (obj, sep=' ', end='\n', file=sys.stdout, flush=False): """ Print for Windows to avoid Python crashes. Encoding depends on Windows locale. No useful standard. Always returns True (useful for debugging).""" if sys.platform != "win32": print(obj, sep=sep, end=end, file=file, flush=flush) return True try: print(str(obj).translate(_CHARMAP), sep=sep, end=end, file=file, flush=flush) except: print(str(obj).encode('ascii', 'replace').decode('ascii', 'replace'), sep=sep, end=end, file=file, flush=flush) return True |
Added gc_core/py/ibdawg.py version [9ce1ce821d].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 | #!python3 # -*- coding: UTF-8 -*- import os import traceback import pkgutil from . import str_transform as st from .echo import echo class IBDAWG: """INDEXABLE BINARY DIRECT ACYCLIC WORD GRAPH""" def __init__ (self, sDicName): self.by = pkgutil.get_data(__package__, "_dictionaries/" + sDicName) if not self.by: raise OSError("# Error. File not found or not loadable: "+sDicName) if self.by[0:7] != b"/pyfsa/": raise TypeError("# Error. Not a pyfsa binary dictionary. Header: {}".format(self.by[0:9])) if not(self.by[7:8] == b"1" or self.by[7:8] == b"2" or self.by[7:8] == b"3"): raise ValueError("# Error. Unknown dictionary version: {}".format(self.by[7:8])) try: header, info, values, bdic = self.by.split(b"\0\0\0\0", 3) except Exception: raise Exception self.sName = sDicName self.nVersion = int(self.by[7:8].decode("utf-8")) self.sHeader = header.decode("utf-8") self.lArcVal = values.decode("utf-8").split("\t") self.nArcVal = len(self.lArcVal) self.byDic = bdic l = info.decode("utf-8").split("/") self.sLang = l[0] self.nChar = int(l[1]) self.nBytesArc = int(l[2]) self.nBytesNodeAddress = int(l[3]) self.nEntries = int(l[4]) self.nNode = int(l[5]) self.nArc = int(l[6]) self.nAff = int(l[7]) self.cStemming = l[8] if self.cStemming == "S": self.funcStemming = st.getStemFromSuffixCode elif self.cStemming == "A": self.funcStemming = st.getStemFromAffixCode else: self.funcStemming = st.noStemming self.nTag = self.nArcVal - self.nChar - self.nAff self.dChar = {} for i in range(1, self.nChar): self.dChar[self.lArcVal[i]] = i self._arcMask = (2 ** ((self.nBytesArc * 8) - 3)) - 1 self._finalNodeMask = 1 << ((self.nBytesArc * 8) - 1) self._lastArcMask = 1 << ((self.nBytesArc * 8) - 2) self._addrBitMask = 1 << ((self.nBytesArc * 8) - 3) # version 2 self.nBytesOffset = 1 # version 3 # Configuring DAWG functions according to nVersion if self.nVersion == 1: self.morph = self._morph1 self.stem = self._stem1 self._lookupArcNode = self._lookupArcNode1 self._writeNodes = self._writeNodes1 elif self.nVersion == 2: self.morph = self._morph2 self.stem = self._stem2 self._lookupArcNode = self._lookupArcNode2 self._writeNodes = self._writeNodes2 elif self.nVersion == 3: self.morph = self._morph3 self.stem = self._stem3 self._lookupArcNode = self._lookupArcNode3 self._writeNodes = self._writeNodes3 else: raise ValueError(" # Error: unknown code: {}".format(self.nVersion)) self.bOptNumSigle = False self.bOptNumAtLast = False def getInfo (self): return " Language: {0.sLang:>10} Version: {0.nVersion:>2} Stemming: {0.cStemming}FX\n" \ " Arcs values: {0.nArcVal:>10,} = {0.nChar:>5,} characters, {0.nAff:>6,} affixes, {0.nTag:>6,} tags\n" \ " Dictionary: {0.nEntries:>12,} entries, {0.nNode:>11,} nodes, {0.nArc:>11,} arcs\n" \ " Address size: {0.nBytesNodeAddress:>1} bytes, Arc size: {0.nBytesArc:>1} bytes\n".format(self) def writeAsJSObject (self, spfDest, bInJSModule=False): "write IBDAWG as a JavaScript object in a JavaScript module" import json with open(spfDest, "w", encoding="utf-8", newline="\n") as hDst: if bInJSModule: hDst.write('// JavaScript\n// Generated data (do not edit)\n\n"use strict";\n\nconst dictionary = ') hDst.write(json.dumps({ "sName": self.sName, "nVersion": self.nVersion, "sHeader": self.sHeader, "lArcVal": self.lArcVal, "nArcVal": self.nArcVal, "byDic": [ e for e in self.byDic ], "sLang": self.sLang, "nChar": self.nChar, "nBytesArc": self.nBytesArc, "nBytesNodeAddress": self.nBytesNodeAddress, "nEntries": self.nEntries, "nNode": self.nNode, "nArc": self.nArc, "nAff": self.nAff, "cStemming": self.cStemming, "nTag": self.nTag, "dChar": self.dChar, "_arcMask": self._arcMask, "_finalNodeMask": self._finalNodeMask, "_lastArcMask": self._lastArcMask, "_addrBitMask": self._addrBitMask, "nBytesOffset": self.nBytesOffset }, ensure_ascii=False)) if bInJSModule: hDst.write(";\n\nexports.dictionary = dictionary;\n") def isValidToken (self, sToken): "checks if sToken is valid (if there is hyphens in sToken, sToken is split, each part is checked)" if self.isValid(sToken): return True if "-" in sToken: if sToken.count("-") > 4: return True return all(self.isValid(sWord) for sWord in sToken.split("-")) return False def isValid (self, sWord): "checks if sWord is valid (different casing tested if the first letter is a capital)" if not sWord: return None if "’" in sWord: # ugly hack sWord = sWord.replace("’", "'") if self.lookup(sWord): return True if sWord[0:1].isupper(): if len(sWord) > 1: if sWord.istitle(): return bool(self.lookup(sWord.lower())) if sWord.isupper(): if self.bOptNumSigle: return True return bool(self.lookup(sWord.lower()) or self.lookup(sWord.capitalize())) return bool(self.lookup(sWord[:1].lower() + sWord[1:])) else: return bool(self.lookup(sWord.lower())) return False def lookup (self, sWord): "returns True if sWord in dictionary (strict verification)" iAddr = 0 for c in sWord: if c not in self.dChar: return False iAddr = self._lookupArcNode(self.dChar[c], iAddr) if iAddr == None: return False return int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask def getSugg (self, sWord, iAddr=0, sNewWord=""): "not finished" # RECURSIVE FUNCTION if not sWord: if int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask: return [sNewWord] return [] lSugg = [] lArc = self._getSimilarArcs(sWord[0:1], iAddr) if lArc: for t in lArc: lSugg.extend(self._lookupAndSuggest(sWord[1:], t[1], sNewWord+t[0])) else: pass return lSugg def _getSimilarArcs (self, cChar, iAddr): lArc = [] for c in st.dSimilarChars.get(cChar, cChar): jAddr = self._lookupArcNode(self.dChar[c], iAddr) if jAddr: lArc.append((c, iAddr)) return lArc def getMorph (self, sWord): "retrieves morphologies list, different casing allowed" l = self.morph(sWord) if sWord[0:1].isupper(): l.extend(self.morph(sWord.lower())) if sWord.isupper() and len(sWord) > 1: l.extend(self.morph(sWord.capitalize())) return l # def morph (self, sWord): # is defined in __init__ # VERSION 1 def _morph1 (self, sWord): "returns morphologies of sWord" iAddr = 0 for c in sWord: if c not in self.dChar: return [] iAddr = self._lookupArcNode(self.dChar[c], iAddr) if iAddr == None: return [] if (int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask): l = [] nRawArc = 0 while not (nRawArc & self._lastArcMask): iEndArcAddr = iAddr + self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if nArc >= self.nChar: # This value is not a char, this is a stemming code sStem = ">" + self.funcStemming(sWord, self.lArcVal[nArc]) # Now , we go to the next node and retrieve all following arcs values, all of them are tags iAddr2 = int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') nRawArc2 = 0 while not (nRawArc2 & self._lastArcMask): iEndArcAddr2 = iAddr2 + self.nBytesArc nRawArc2 = int.from_bytes(self.byDic[iAddr2:iEndArcAddr2], byteorder='big') l.append(sStem + " " + self.lArcVal[nRawArc2 & self._arcMask]) iAddr2 = iEndArcAddr2+self.nBytesNodeAddress iAddr = iEndArcAddr+self.nBytesNodeAddress return l return [] def _stem1 (self, sWord): "returns stems list of sWord" iAddr = 0 for c in sWord: if c not in self.dChar: return [] iAddr = self._lookupArcNode(self.dChar[c], iAddr) if iAddr == None: return [] if (int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask): l = [] nRawArc = 0 while not (nRawArc & self._lastArcMask): iEndArcAddr = iAddr + self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if nArc >= self.nChar: # This value is not a char, this is a stemming code l.append(self.funcStemming(sWord, self.lArcVal[nArc])) iAddr = iEndArcAddr+self.nBytesNodeAddress return l return [] def _lookupArcNode1 (self, nVal, iAddr): "looks if nVal is an arc at the node at iAddr, if yes, returns address of next node else None" while True: iEndArcAddr = iAddr+self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') if nVal == (nRawArc & self._arcMask): # the value we are looking for # we return the address of the next node return int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') else: # value not found if (nRawArc & self._lastArcMask): return None iAddr = iEndArcAddr+self.nBytesNodeAddress def _writeNodes1 (self, spfDest): "for debugging only" print(" > Write binary nodes") with codecs.open(spfDest, 'w', 'utf-8', newline="\n") as hDst: iAddr = 0 hDst.write("i{:_>10} -- #{:_>10}\n".format("0", iAddr)) while iAddr < len(self.byDic): iEndArcAddr = iAddr+self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask hDst.write(" {:<20} {:0>16} i{:>10} #{:_>10}\n".format(self.lArcVal[nArc], bin(nRawArc)[2:], "?", \ int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], \ byteorder='big'))) iAddr = iEndArcAddr+self.nBytesNodeAddress if (nRawArc & self._lastArcMask) and iAddr < len(self.byDic): hDst.write("\ni{:_>10} -- #{:_>10}\n".format("?", iAddr)) hDst.close() # VERSION 2 def _morph2 (self, sWord): "returns morphologies of sWord" iAddr = 0 for c in sWord: if c not in self.dChar: return [] iAddr = self._lookupArcNode(self.dChar[c], iAddr) if iAddr == None: return [] if (int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask): l = [] nRawArc = 0 while not (nRawArc & self._lastArcMask): iEndArcAddr = iAddr + self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if nArc >= self.nChar: # This value is not a char, this is a stemming code sStem = ">" + self.funcStemming(sWord, self.lArcVal[nArc]) # Now , we go to the next node and retrieve all following arcs values, all of them are tags if not (nRawArc & self._addrBitMask): iAddr2 = int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') else: # we go to the end of the node iAddr2 = iEndArcAddr while not (nRawArc & self._lastArcMask): nRawArc = int.from_bytes(self.byDic[iAddr2:iAddr2+self.nBytesArc], byteorder='big') iAddr2 += self.nBytesArc + self.nBytesNodeAddress nRawArc2 = 0 while not (nRawArc2 & self._lastArcMask): iEndArcAddr2 = iAddr2 + self.nBytesArc nRawArc2 = int.from_bytes(self.byDic[iAddr2:iEndArcAddr2], byteorder='big') l.append(sStem + " " + self.lArcVal[nRawArc2 & self._arcMask]) iAddr2 = iEndArcAddr2+self.nBytesNodeAddress if not (nRawArc2 & self._addrBitMask) else iEndArcAddr2 iAddr = iEndArcAddr+self.nBytesNodeAddress if not (nRawArc & self._addrBitMask) else iEndArcAddr return l return [] def _stem2 (self, sWord): "returns stems list of sWord" iAddr = 0 for c in sWord: if c not in self.dChar: return [] iAddr = self._lookupArcNode(self.dChar[c], iAddr) if iAddr == None: return [] if (int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask): l = [] nRawArc = 0 while not (nRawArc & self._lastArcMask): iEndArcAddr = iAddr + self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if nArc >= self.nChar: # This value is not a char, this is a stemming code l.append(self.funcStemming(sWord, self.lArcVal[nArc])) # Now , we go to the next node if not (nRawArc & self._addrBitMask): iAddr2 = int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') else: # we go to the end of the node iAddr2 = iEndArcAddr while not (nRawArc & self._lastArcMask): nRawArc = int.from_bytes(self.byDic[iAddr2:iAddr2+self.nBytesArc], byteorder='big') iAddr2 += self.nBytesArc + self.nBytesNodeAddress iAddr = iEndArcAddr+self.nBytesNodeAddress if not (nRawArc & self._addrBitMask) else iEndArcAddr return l return [] def _lookupArcNode2 (self, nVal, iAddr): "looks if nVal is an arc at the node at iAddr, if yes, returns address of next node else None" while True: iEndArcAddr = iAddr+self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') if nVal == (nRawArc & self._arcMask): # the value we are looking for if not (nRawArc & self._addrBitMask): # we return the address of the next node return int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') else: # we go to the end of the node iAddr = iEndArcAddr while not (nRawArc & self._lastArcMask): nRawArc = int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') iAddr += self.nBytesArc + self.nBytesNodeAddress if not (nRawArc & self._addrBitMask) else self.nBytesArc return iAddr else: # value not found if (nRawArc & self._lastArcMask): return None iAddr = iEndArcAddr+self.nBytesNodeAddress if not (nRawArc & self._addrBitMask) else iEndArcAddr def _writeNodes2 (self, spfDest): "for debugging only" print(" > Write binary nodes") with codecs.open(spfDest, 'w', 'utf-8', newline="\n") as hDst: iAddr = 0 hDst.write("i{:_>10} -- #{:_>10}\n".format("0", iAddr)) while iAddr < len(self.byDic): iEndArcAddr = iAddr+self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if not (nRawArc & self._addrBitMask): iNextNodeAddr = int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') hDst.write(" {:<20} {:0>16} i{:>10} #{:_>10}\n".format(self.lArcVal[nArc], bin(nRawArc)[2:], "?", iNextNodeAddr)) iAddr = iEndArcAddr+self.nBytesNodeAddress else: hDst.write(" {:<20} {:0>16}\n".format(self.lArcVal[nArc], bin(nRawArc)[2:])) iAddr = iEndArcAddr if (nRawArc & self._lastArcMask): hDst.write("\ni{:_>10} -- #{:_>10}\n".format("?", iAddr)) hDst.close() # VERSION 3 def _morph3 (self, sWord): "returns morphologies of sWord" iAddr = 0 for c in sWord: if c not in self.dChar: return [] iAddr = self._lookupArcNode(self.dChar[c], iAddr) if iAddr == None: return [] if (int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask): l = [] nRawArc = 0 iAddrNode = iAddr while not (nRawArc & self._lastArcMask): iEndArcAddr = iAddr + self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if nArc >= self.nChar: # This value is not a char, this is a stemming code sStem = ">" + self.funcStemming(sWord, self.lArcVal[nArc]) # Now , we go to the next node and retrieve all following arcs values, all of them are tags if not (nRawArc & self._addrBitMask): iAddr2 = int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') else: iAddr2 = iAddrNode + int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesOffset], byteorder='big') nRawArc2 = 0 while not (nRawArc2 & self._lastArcMask): iEndArcAddr2 = iAddr2 + self.nBytesArc nRawArc2 = int.from_bytes(self.byDic[iAddr2:iEndArcAddr2], byteorder='big') l.append(sStem + " " + self.lArcVal[nRawArc2 & self._arcMask]) iAddr2 = iEndArcAddr2+self.nBytesNodeAddress if not (nRawArc2 & self._addrBitMask) else iEndArcAddr2+self.nBytesOffset iAddr = iEndArcAddr+self.nBytesNodeAddress if not (nRawArc & self._addrBitMask) else iEndArcAddr+self.nBytesOffset return l return [] def _stem3 (self, sWord): "returns stems list of sWord" iAddr = 0 for c in sWord: if c not in self.dChar: return [] iAddr = self._lookupArcNode(self.dChar[c], iAddr) if iAddr == None: return [] if (int.from_bytes(self.byDic[iAddr:iAddr+self.nBytesArc], byteorder='big') & self._finalNodeMask): l = [] nRawArc = 0 iAddrNode = iAddr while not (nRawArc & self._lastArcMask): iEndArcAddr = iAddr + self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if nArc >= self.nChar: # This value is not a char, this is a stemming code l.append(self.funcStemming(sWord, self.lArcVal[nArc])) iAddr = iEndArcAddr+self.nBytesNodeAddress if not (nRawArc & self._addrBitMask) else iEndArcAddr+self.nBytesOffset return l return [] def _lookupArcNode3 (self, nVal, iAddr): "looks if nVal is an arc at the node at iAddr, if yes, returns address of next node else None" iAddrNode = iAddr while True: iEndArcAddr = iAddr+self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') if nVal == (nRawArc & self._arcMask): # the value we are looking for if not (nRawArc & self._addrBitMask): return int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') else: return iAddrNode + int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesOffset], byteorder='big') else: # value not found if (nRawArc & self._lastArcMask): return None iAddr = iEndArcAddr+self.nBytesNodeAddress if not (nRawArc & self._addrBitMask) else iEndArcAddr+self.nBytesOffset def _writeNodes3 (self, spfDest): "for debugging only" print(" > Write binary nodes") with codecs.open(spfDest, 'w', 'utf-8', newline="\n") as hDst: iAddr = 0 hDst.write("i{:_>10} -- #{:_>10}\n".format("0", iAddr)) while iAddr < len(self.byDic): iEndArcAddr = iAddr+self.nBytesArc nRawArc = int.from_bytes(self.byDic[iAddr:iEndArcAddr], byteorder='big') nArc = nRawArc & self._arcMask if not (nRawArc & self._addrBitMask): iNextNodeAddr = int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesNodeAddress], byteorder='big') hDst.write(" {:<20} {:0>16} i{:>10} #{:_>10}\n".format(self.lArcVal[nArc], bin(nRawArc)[2:], "?", iNextNodeAddr)) iAddr = iEndArcAddr+self.nBytesNodeAddress else: iNextNodeAddr = int.from_bytes(self.byDic[iEndArcAddr:iEndArcAddr+self.nBytesOffset], byteorder='big') hDst.write(" {:<20} {:0>16} i{:>10} +{:_>10}\n".format(self.lArcVal[nArc], bin(nRawArc)[2:], "?", iNextNodeAddr)) iAddr = iEndArcAddr+self.nBytesOffset if (nRawArc & self._lastArcMask): hDst.write("\ni{:_>10} -- #{:_>10}\n".format("?", iAddr)) hDst.close() |
Added gc_core/py/lang_core/__init__.py version [0ee899897d].
> > | 1 2 | from .gc_engine import * |
Added gc_core/py/lang_core/gc_engine.py version [e65591d48d].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 | # Grammalecte # Grammar checker engine import re import sys import os import traceback #import unicodedata from itertools import chain from ..ibdawg import IBDAWG from ..echo import echo from . import gc_options __all__ = [ "lang", "locales", "pkg", "name", "version", "author", \ "load", "parse", "getDictionary", \ "setOption", "setOptions", "getOptions", "getDefaultOptions", "getOptionsLabels", "resetOptions", "displayOptions", \ "ignoreRule", "resetIgnoreRules", "reactivateRule", "listRules", "displayRules" ] __version__ = "${version}" lang = "${lang}" locales = ${loc} pkg = "${implname}" name = "${name}" version = "${version}" author = "${author}" # grammar rules and dictionary _rules = None _dOptions = dict(gc_options.dOpt) # duplication necessary, to be able to reset to default _aIgnoredRules = set() _oDict = None _dAnalyses = {} # cache for data from dictionary #### Parsing def parse (sText, sCountry="${country_default}", bDebug=False, dOptions=None, bContext=False): "analyses the paragraph sText and returns list of errors" #sText = unicodedata.normalize("NFC", sText) aErrors = None sAlt = sText dDA = {} # Disambiguisator. Key = position; value = list of morphologies dPriority = {} # Key = position; value = priority dOpt = _dOptions if not dOptions else dOptions # parse paragraph try: sNew, aErrors = _proofread(sText, sAlt, 0, True, dDA, dPriority, sCountry, dOpt, bDebug, bContext) if sNew: sText = sNew except: raise # cleanup if " " in sText: sText = sText.replace(" ", ' ') # nbsp if " " in sText: sText = sText.replace(" ", ' ') # nnbsp if "'" in sText: sText = sText.replace("'", "’") if "‑" in sText: sText = sText.replace("‑", "-") # nobreakdash # parse sentences for iStart, iEnd in _getSentenceBoundaries(sText): if 4 < (iEnd - iStart) < 2000: dDA.clear() try: _, errs = _proofread(sText[iStart:iEnd], sAlt[iStart:iEnd], iStart, False, dDA, dPriority, sCountry, dOpt, bDebug, bContext) aErrors.update(errs) except: raise return aErrors.values() # this is a view (iterable) def _getSentenceBoundaries (sText): iStart = _zBeginOfParagraph.match(sText).end() for m in _zEndOfSentence.finditer(sText): yield (iStart, m.end()) iStart = m.end() def _proofread (s, sx, nOffset, bParagraph, dDA, dPriority, sCountry, dOptions, bDebug, bContext): dErrs = {} bChange = False bIdRule = option('idrule') for sOption, lRuleGroup in _getRules(bParagraph): if not sOption or dOptions.get(sOption, False): for zRegex, bUppercase, sLineId, sRuleId, nPriority, lActions in lRuleGroup: if sRuleId not in _aIgnoredRules: for m in zRegex.finditer(s): bCondMemo = None for sFuncCond, cActionType, sWhat, *eAct in lActions: # action in lActions: [ condition, action type, replacement/suggestion/action[, iGroup[, message, URL]] ] try: bCondMemo = not sFuncCond or globals()[sFuncCond](s, sx, m, dDA, sCountry, bCondMemo) if bCondMemo: if cActionType == "-": # grammar error nErrorStart = nOffset + m.start(eAct[0]) if nErrorStart not in dErrs or nPriority > dPriority[nErrorStart]: dErrs[nErrorStart] = _createError(s, sx, sWhat, nOffset, m, eAct[0], sLineId, sRuleId, bUppercase, eAct[1], eAct[2], bIdRule, sOption, bContext) dPriority[nErrorStart] = nPriority elif cActionType == "~": # text processor s = _rewrite(s, sWhat, eAct[0], m, bUppercase) bChange = True if bDebug: echo("~ " + s + " -- " + m.group(eAct[0]) + " # " + sLineId) elif cActionType == "=": # disambiguation globals()[sWhat](s, m, dDA) if bDebug: echo("= " + m.group(0) + " # " + sLineId + "\nDA: " + str(dDA)) elif cActionType == ">": # we do nothing, this test is just a condition to apply all following actions pass else: echo("# error: unknown action at " + sLineId) elif cActionType == ">": break except Exception as e: raise Exception(str(e), sLineId) if bChange: return (s, dErrs) return (False, dErrs) def _createWriterError (s, sx, sRepl, nOffset, m, iGroup, sLineId, sRuleId, bUppercase, sMsg, sURL, bIdRule, sOption, bContext): "error for Writer (LO/OO)" xErr = SingleProofreadingError() #xErr = uno.createUnoStruct( "com.sun.star.linguistic2.SingleProofreadingError" ) xErr.nErrorStart = nOffset + m.start(iGroup) xErr.nErrorLength = m.end(iGroup) - m.start(iGroup) xErr.nErrorType = PROOFREADING xErr.aRuleIdentifier = sRuleId # suggestions if sRepl[0:1] == "=": sugg = globals()[sRepl[1:]](s, m) if sugg: if bUppercase and m.group(iGroup)[0:1].isupper(): xErr.aSuggestions = tuple(map(str.capitalize, sugg.split("|"))) else: xErr.aSuggestions = tuple(sugg.split("|")) else: xErr.aSuggestions = () elif sRepl == "_": xErr.aSuggestions = () else: if bUppercase and m.group(iGroup)[0:1].isupper(): xErr.aSuggestions = tuple(map(str.capitalize, m.expand(sRepl).split("|"))) else: xErr.aSuggestions = tuple(m.expand(sRepl).split("|")) # Message if sMsg[0:1] == "=": sMessage = globals()[sMsg[1:]](s, m) else: sMessage = m.expand(sMsg) xErr.aShortComment = sMessage # sMessage.split("|")[0] # in context menu xErr.aFullComment = sMessage # sMessage.split("|")[-1] # in dialog if bIdRule: xErr.aShortComment += " # " + sLineId + " # " + sRuleId # URL if sURL: p = PropertyValue() p.Name = "FullCommentURL" p.Value = sURL xErr.aProperties = (p,) else: xErr.aProperties = () return xErr def _createDictError (s, sx, sRepl, nOffset, m, iGroup, sLineId, sRuleId, bUppercase, sMsg, sURL, bIdRule, sOption, bContext): "error as a dictionary" dErr = {} dErr["nStart"] = nOffset + m.start(iGroup) dErr["nEnd"] = nOffset + m.end(iGroup) dErr["sLineId"] = sLineId dErr["sRuleId"] = sRuleId dErr["sType"] = sOption if sOption else "notype" # suggestions if sRepl[0:1] == "=": sugg = globals()[sRepl[1:]](s, m) if sugg: if bUppercase and m.group(iGroup)[0:1].isupper(): dErr["aSuggestions"] = list(map(str.capitalize, sugg.split("|"))) else: dErr["aSuggestions"] = sugg.split("|") else: dErr["aSuggestions"] = () elif sRepl == "_": dErr["aSuggestions"] = () else: if bUppercase and m.group(iGroup)[0:1].isupper(): dErr["aSuggestions"] = list(map(str.capitalize, m.expand(sRepl).split("|"))) else: dErr["aSuggestions"] = m.expand(sRepl).split("|") # Message if sMsg[0:1] == "=": sMessage = globals()[sMsg[1:]](s, m) else: sMessage = m.expand(sMsg) dErr["sMessage"] = sMessage if bIdRule: dErr["sMessage"] += " # " + sLineId + " # " + sRuleId # URL dErr["URL"] = sURL if sURL else "" # Context if bContext: dErr['sUnderlined'] = sx[m.start(iGroup):m.end(iGroup)] dErr['sBefore'] = sx[max(0,m.start(iGroup)-80):m.start(iGroup)] dErr['sAfter'] = sx[m.end(iGroup):m.end(iGroup)+80] return dErr def _rewrite (s, sRepl, iGroup, m, bUppercase): "text processor: write sRepl in s at iGroup position" nLen = m.end(iGroup) - m.start(iGroup) if sRepl == "*": sNew = " " * nLen elif sRepl == ">" or sRepl == "_" or sRepl == "~": sNew = sRepl + " " * (nLen-1) elif sRepl == "@": sNew = "@" * nLen elif sRepl[0:1] == "=": sNew = globals()[sRepl[1:]](s, m) sNew = sNew + " " * (nLen-len(sNew)) if bUppercase and m.group(iGroup)[0:1].isupper(): sNew = sNew.capitalize() else: sNew = m.expand(sRepl) sNew = sNew + " " * (nLen-len(sNew)) return s[0:m.start(iGroup)] + sNew + s[m.end(iGroup):] def ignoreRule (sRuleId): _aIgnoredRules.add(sRuleId) def resetIgnoreRules (): _aIgnoredRules.clear() def reactivateRule (sRuleId): _aIgnoredRules.discard(sRuleId) def listRules (sFilter=None): "generator: returns typle (sOption, sLineId, sRuleId)" if sFilter: try: zFilter = re.compile(sFilter) except: echo("# Error. List rules: wrong regex.") sFilter = None for sOption, lRuleGroup in chain(_getRules(True), _getRules(False)): for _, _, sLineId, sRuleId, _, _ in lRuleGroup: if not sFilter or zFilter.search(sRuleId): yield (sOption, sLineId, sRuleId) def displayRules (sFilter=None): echo("List of rules. Filter: << " + str(sFilter) + " >>") for sOption, sLineId, sRuleId in listRules(sFilter): echo("{:<10} {:<10} {}".format(sOption, sLineId, sRuleId)) #### init try: # LibreOffice / OpenOffice from com.sun.star.linguistic2 import SingleProofreadingError from com.sun.star.text.TextMarkupType import PROOFREADING from com.sun.star.beans import PropertyValue #import lightproof_handler_${implname} as opt _createError = _createWriterError except ImportError: _createError = _createDictError def load (): global _oDict try: _oDict = IBDAWG("${py_binary_dic}") except: traceback.print_exc() def setOption (sOpt, bVal): if sOpt in _dOptions: _dOptions[sOpt] = bVal def setOptions (dOpt): for sKey, bVal in dOpt.items(): if sKey in _dOptions: _dOptions[sKey] = bVal def getOptions (): return _dOptions def getDefaultOptions (): return dict(gc_options.dOpt) def getOptionsLabels (sLang): return gc_options.getUI(sLang) def displayOptions (sLang): echo("List of options") echo("\n".join( [ k+":\t"+str(v)+"\t"+gc_options.getUI(sLang).get(k, ("?", ""))[0] for k, v in sorted(_dOptions.items()) ] )) echo("") def resetOptions (): global _dOptions _dOptions = dict(gc_options.dOpt) def getDictionary (): return _oDict def _getRules (bParagraph): try: if not bParagraph: return _rules.lSentenceRules return _rules.lParagraphRules except: _loadRules() if not bParagraph: return _rules.lSentenceRules return _rules.lParagraphRules def _loadRules (): from . import gc_rules global _rules _rules = gc_rules # compile rules regex for lRuleGroup in chain(_rules.lParagraphRules, _rules.lSentenceRules): for rule in lRuleGroup[1]: try: rule[0] = re.compile(rule[0]) except: echo("Bad regular expression in # " + str(rule[2])) rule[0] = "(?i)<Grammalecte>" def _getPath (): return os.path.join(os.path.dirname(sys.modules[__name__].__file__), __name__ + ".py") #### common functions # common regexes _zEndOfSentence = re.compile('([.?!:;…][ .?!… »”")]*|.$)') _zBeginOfParagraph = re.compile("^\W*") _zEndOfParagraph = re.compile("\W*$") _zNextWord = re.compile(" +(\w[\w-]*)") _zPrevWord = re.compile("(\w[\w-]*) +$") def option (sOpt): "return True if option sOpt is active" return _dOptions.get(sOpt, False) def displayInfo (dDA, tWord): "for debugging: retrieve info of word" if not tWord: echo("> nothing to find") return True if tWord[1] not in _dAnalyses and not _storeMorphFromFSA(tWord[1]): echo("> not in FSA") return True if tWord[0] in dDA: echo("DA: " + str(dDA[tWord[0]])) echo("FSA: " + str(_dAnalyses[tWord[1]])) return True def _storeMorphFromFSA (sWord): "retrieves morphologies list from _oDict -> _dAnalyses" global _dAnalyses _dAnalyses[sWord] = _oDict.getMorph(sWord) return True if _dAnalyses[sWord] else False def morph (dDA, tWord, sPattern, bStrict=True, bNoWord=False): "analyse a tuple (position, word), return True if sPattern in morphologies (disambiguation on)" if not tWord: return bNoWord if tWord[1] not in _dAnalyses and not _storeMorphFromFSA(tWord[1]): return False lMorph = dDA[tWord[0]] if tWord[0] in dDA else _dAnalyses[tWord[1]] if not lMorph: return False p = re.compile(sPattern) if bStrict: return all(p.search(s) for s in lMorph) return any(p.search(s) for s in lMorph) def morphex (dDA, tWord, sPattern, sNegPattern, bNoWord=False): "analyse a tuple (position, word), returns True if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation on)" if not tWord: return bNoWord if tWord[1] not in _dAnalyses and not _storeMorphFromFSA(tWord[1]): return False lMorph = dDA[tWord[0]] if tWord[0] in dDA else _dAnalyses[tWord[1]] # check negative condition np = re.compile(sNegPattern) if any(np.search(s) for s in lMorph): return False # search sPattern p = re.compile(sPattern) return any(p.search(s) for s in lMorph) def analyse (sWord, sPattern, bStrict=True): "analyse a word, return True if sPattern in morphologies (disambiguation off)" if sWord not in _dAnalyses and not _storeMorphFromFSA(sWord): return False if not _dAnalyses[sWord]: return False p = re.compile(sPattern) if bStrict: return all(p.search(s) for s in _dAnalyses[sWord]) return any(p.search(s) for s in _dAnalyses[sWord]) def analysex (sWord, sPattern, sNegPattern): "analyse a word, returns True if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation off)" if sWord not in _dAnalyses and not _storeMorphFromFSA(sWord): return False # check negative condition np = re.compile(sNegPattern) if any(np.search(s) for s in _dAnalyses[sWord]): return False # search sPattern p = re.compile(sPattern) return any(p.search(s) for s in _dAnalyses[sWord]) def stem (sWord): "returns a list of sWord's stems" if not sWord: return [] if sWord not in _dAnalyses and not _storeMorphFromFSA(sWord): return [] return [ s[1:s.find(" ")] for s in _dAnalyses[sWord] ] ## functions to get text outside pattern scope # warning: check compile_rules.py to understand how it works def nextword (s, iStart, n): "get the nth word of the input string or empty string" m = re.match("( +[\\w%-]+){" + str(n-1) + "} +([\\w%-]+)", s[iStart:]) if not m: return None return (iStart+m.start(2), m.group(2)) def prevword (s, iEnd, n): "get the (-)nth word of the input string or empty string" m = re.search("([\\w%-]+) +([\\w%-]+ +){" + str(n-1) + "}$", s[:iEnd]) if not m: return None return (m.start(1), m.group(1)) def nextword1 (s, iStart): "get next word (optimization)" m = _zNextWord.match(s[iStart:]) if not m: return None return (iStart+m.start(1), m.group(1)) def prevword1 (s, iEnd): "get previous word (optimization)" m = _zPrevWord.search(s[:iEnd]) if not m: return None return (m.start(1), m.group(1)) def look (s, sPattern, sNegPattern=None): "seek sPattern in s (before/after/fulltext), if sNegPattern not in s" if sNegPattern and re.search(sNegPattern, s): return False if re.search(sPattern, s): return True return False def look_chk1 (dDA, s, nOffset, sPattern, sPatternGroup1, sNegPatternGroup1=None): "returns True if s has pattern sPattern and m.group(1) has pattern sPatternGroup1" m = re.search(sPattern, s) if not m: return False try: sWord = m.group(1) nPos = m.start(1) + nOffset except: return False if sNegPatternGroup1: return morphex(dDA, (nPos, sWord), sPatternGroup1, sNegPatternGroup1) return morph(dDA, (nPos, sWord), sPatternGroup1, False) #### Disambiguator def select (dDA, nPos, sWord, sPattern, lDefault=None): if not sWord: return True if nPos in dDA: return True if sWord not in _dAnalyses and not _storeMorphFromFSA(sWord): return True if len(_dAnalyses[sWord]) == 1: return True lSelect = [ sMorph for sMorph in _dAnalyses[sWord] if re.search(sPattern, sMorph) ] if lSelect: if len(lSelect) != len(_dAnalyses[sWord]): dDA[nPos] = lSelect #echo("= "+sWord+" "+str(dDA.get(nPos, "null"))) elif lDefault: dDA[nPos] = lDefault #echo("= "+sWord+" "+str(dDA.get(nPos, "null"))) return True def exclude (dDA, nPos, sWord, sPattern, lDefault=None): if not sWord: return True if nPos in dDA: return True if sWord not in _dAnalyses and not _storeMorphFromFSA(sWord): return True if len(_dAnalyses[sWord]) == 1: return True lSelect = [ sMorph for sMorph in _dAnalyses[sWord] if not re.search(sPattern, sMorph) ] if lSelect: if len(lSelect) != len(_dAnalyses[sWord]): dDA[nPos] = lSelect #echo("= "+sWord+" "+str(dDA.get(nPos, "null"))) elif lDefault: dDA[nPos] = lDefault #echo("= "+sWord+" "+str(dDA.get(nPos, "null"))) return True def define (dDA, nPos, lMorph): dDA[nPos] = lMorph #echo("= "+str(nPos)+" "+str(dDA[nPos])) return True #### GRAMMAR CHECKER PLUGINS ${plugins} ${callables} |
Added gc_core/py/lang_core/gc_options.py version [383a99acb3].
> > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 | # generated code, do not edit def getUI (sLang): if sLang in _dOptLabel: return _dOptLabel[sLang] return _dOptLabel["fr"] lStructOpt = ${lStructOpt} dOpt = ${dOptPython} _dOptLabel = ${dOptLabel} |
Added gc_core/py/lang_core/gc_rules.py version [3cf95f4a21].
> > > > > | 1 2 3 4 5 | # generated code, do not edit lParagraphRules = ${paragraph_rules} lSentenceRules = ${sentence_rules} |
Added gc_core/py/oxt/Grammalecte.py version [f962117745].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | # -*- encoding: UTF-8 -*- # Grammalecte for Writer # License: MPL 2 # A derivative work of Lightproof from László Németh (http://cgit.freedesktop.org/libreoffice/lightproof/) import uno import unohelper import sys import traceback from collections import deque from com.sun.star.linguistic2 import XProofreader, XSupportedLocales from com.sun.star.linguistic2 import ProofreadingResult from com.sun.star.lang import XServiceInfo, XServiceName, XServiceDisplayName from com.sun.star.lang import Locale import grammalecte.${lang} as gce #import lightproof_handler_${implname} as opt_handler import Options class Grammalecte (unohelper.Base, XProofreader, XServiceInfo, XServiceName, XServiceDisplayName, XSupportedLocales): def __init__ (self, ctx, *args): self.ctx = ctx self.ServiceName = "com.sun.star.linguistic2.Proofreader" self.ImplementationName = "org.openoffice.comp.pyuno.Lightproof." + gce.pkg self.SupportedServiceNames = (self.ServiceName, ) self.locales = [] for i in gce.locales: l = gce.locales[i] self.locales.append(Locale(l[0], l[1], l[2])) self.locales = tuple(self.locales) xCurCtx = uno.getComponentContext() # init gce.load() # GC options # opt_handler.load(xCurCtx) dOpt = Options.load(xCurCtx) gce.setOptions(dOpt) # store for results of big paragraphs self.dResult = {} self.nMaxRes = 1500 self.lLastRes = deque(maxlen=self.nMaxRes) self.nRes = 0 # XServiceName method implementations def getServiceName (self): return self.ImplementationName # XServiceInfo method implementations def getImplementationName (self): return self.ImplementationName def supportsService (self, ServiceName): return (ServiceName in self.SupportedServiceNames) def getSupportedServiceNames (self): return self.SupportedServiceNames # XSupportedLocales def hasLocale (self, aLocale): if aLocale in self.locales: return True for i in self.locales: if (i.Country == aLocale.Country or i.Country == "") and aLocale.Language == i.Language: return True return False def getLocales (self): return self.locales # XProofreader def isSpellChecker (self): return False def doProofreading (self, nDocId, rText, rLocale, nStartOfSentencePos, nSuggestedSentenceEndPos, rProperties): xRes = ProofreadingResult() #xRes = uno.createUnoStruct("com.sun.star.linguistic2.ProofreadingResult") xRes.aDocumentIdentifier = nDocId xRes.aText = rText xRes.aLocale = rLocale xRes.nStartOfSentencePosition = nStartOfSentencePos xRes.nStartOfNextSentencePosition = nSuggestedSentenceEndPos xRes.aProperties = () xRes.xProofreader = self xRes.aErrors = () # PATCH FOR LO 4 # Fix for http://nabble.documentfoundation.org/Grammar-checker-Undocumented-change-in-the-API-for-LO-4-td4030639.html if nStartOfSentencePos != 0: return xRes xRes.nStartOfNextSentencePosition = len(rText) # END OF PATCH # WORKAROUND FOR AVOIDING REPEATED ACTIONS ON HEAVY PARAGRAPHS if xRes.nStartOfNextSentencePosition > 3000: nHashedVal = hash(rText) if nHashedVal in self.dResult: return self.dResult[nHashedVal] # WORKAROUND ->>> xRes.nBehindEndOfSentencePosition = xRes.nStartOfNextSentencePosition try: xRes.aErrors = tuple(gce.parse(rText, rLocale.Country)) # ->>> WORKAROUND if xRes.nStartOfNextSentencePosition > 3000: self.dResult[nHashedVal] = xRes self.nRes += 1 if self.nRes > self.nMaxRes: del self.dResult[self.lLastRes.popleft()] self.nRes = self.nMaxRes self.lLastRes.append(nHashedVal) # END OF WORKAROUND except Exception as e: if sys.version_info.major == 3: traceback.print_exc() return xRes def ignoreRule (self, rid, aLocale): gce.ignoreRule(rid) def resetIgnoreRules (self): gce.resetIgnoreRules() # XServiceDisplayName def getServiceDisplayName (self, aLocale): return gce.name # Grammalecte def getDictionary (self): return gce.getDictionary() g_ImplementationHelper = unohelper.ImplementationHelper() g_ImplementationHelper.addImplementation(Grammalecte, "org.openoffice.comp.pyuno.Lightproof."+gce.pkg, ("com.sun.star.linguistic2.Proofreader",),) # g_ImplementationHelper.addImplementation( opt_handler.LightproofOptionsEventHandler, \ # "org.openoffice.comp.pyuno.LightproofOptionsEventHandler." + gce.pkg, ("com.sun.star.awt.XContainerWindowEventHandler",),) |
Added gc_core/py/oxt/Linguistic.xcu version [ff91c8d07f].
> > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | <?xml version="1.0" encoding="UTF-8"?> <oor:component-data oor:name="Linguistic" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema"> <node oor:name="ServiceManager"> <node oor:name="GrammarCheckers"> <node oor:name="org.openoffice.comp.pyuno.Lightproof.${implname}" oor:op="fuse"> <prop oor:name="Locales" oor:type="oor:string-list"> <value>${locales}</value> </prop> </node> </node> </node> </oor:component-data> |
Added gc_core/py/oxt/Options.py version [f3a8765730].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | # -*- coding: utf8 -*- # Options Dialog # by Olivier R. # License: MPL 2 import unohelper import uno import traceback from com.sun.star.awt import XActionListener from com.sun.star.beans import PropertyValue import helpers import op_strings try: import grammalecte.${lang} as gce except: traceback.print_exc() options = {} def load (ctx): try: oGCO = GC_Options(ctx) oGCO.load("${lang}") except: print("# Error. Unable to load options of language: ${lang}") return options class GC_Options (unohelper.Base, XActionListener): def __init__ (self, ctx): self.ctx = ctx self.xSvMgr = self.ctx.ServiceManager self.xContainer = None #self.xNode = helpers.getConfigSetting("/org.openoffice.Lightproof_%s/Leaves"%pkg, True) self.xNode = helpers.getConfigSetting("/org.openoffice.Lightproof_grammalecte/Leaves", True) self.nSecret = 0 def _addWidget (self, name, wtype, x, y, w, h, **kwargs): xWidget = self.xDialog.createInstance('com.sun.star.awt.UnoControl%sModel' % wtype) xWidget.Name = name xWidget.PositionX = x xWidget.PositionY = y xWidget.Width = w xWidget.Height = h for k, w in kwargs.items(): setattr(xWidget, k, w) self.xDialog.insertByName(name, xWidget) return xWidget def run (self, sUI): try: dUI = op_strings.getUI(sUI) dUI2 = gce.gc_options.getUI(sUI) # fonts xFDTitle = uno.createUnoStruct("com.sun.star.awt.FontDescriptor") xFDTitle.Height = 9 xFDTitle.Weight = uno.getConstantByName("com.sun.star.awt.FontWeight.BOLD") xFDTitle.Name = "Verdana" xFDBut = uno.createUnoStruct("com.sun.star.awt.FontDescriptor") xFDBut.Height = 10 xFDBut.Weight = uno.getConstantByName("com.sun.star.awt.FontWeight.BOLD") xFDBut.Name = "Verdana" # dialog self.xDialog = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlDialogModel', self.ctx) self.xDialog.Width = 300 self.xDialog.Height = 400 self.xDialog.Title = dUI.get('title', "#err") # build y = 0 nWidth = self.xDialog.Width - 20 nHeight = 10 self.lxOptions = [] for t in gce.gc_options.lStructOpt: x = 10 y += 10 self._addWidget(t[0], 'FixedLine', x, y, nWidth, nHeight, Label = dUI2.get(t[0], "#err")[0], FontDescriptor= xFDTitle) y += 3 for lOptLine in t[1]: x = 15 y += 10 n = len(lOptLine) for sOpt in lOptLine: w = self._addWidget(sOpt, 'CheckBox', x, y, nWidth/n, nHeight, State = options.get(sOpt, False), \ Label = dUI2.get(sOpt, "#err")[0], HelpText = dUI2.get(sOpt, "#err")[1]) self.lxOptions.append(w) x += nWidth / n self.xDialog.Height = y + 40 xWindowSize = helpers.getWindowSize() self.xDialog.PositionX = int((xWindowSize.Width / 2) - (self.xDialog.Width / 2)) self.xDialog.PositionY = int((xWindowSize.Height / 2) - (self.xDialog.Height / 2)) but0 = self._addWidget('default', 'Button', 10, self.xDialog.Height-20, 50, 14, \ Label = dUI.get('default', "#err"), FontDescriptor = xFDBut, TextColor = 0x000044) but1 = self._addWidget('apply', 'Button', self.xDialog.Width-115, self.xDialog.Height-20, 50, 14, \ Label = dUI.get('apply', "#err"), FontDescriptor = xFDBut, TextColor = 0x004400) but2 = self._addWidget('cancel', 'Button', self.xDialog.Width-60, self.xDialog.Height-20, 50, 14, Label = dUI.get('cancel', "#err"), FontDescriptor = xFDBut, TextColor = 0x440000) # container self.xContainer = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlDialog', self.ctx) self.xContainer.setModel(self.xDialog) self.xContainer.getControl('default').addActionListener(self) self.xContainer.getControl('default').setActionCommand('Default') self.xContainer.getControl('apply').addActionListener(self) self.xContainer.getControl('apply').setActionCommand('Apply') self.xContainer.getControl('cancel').addActionListener(self) self.xContainer.getControl('cancel').setActionCommand('Cancel') self.xContainer.setVisible(False) xToolkit = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.ExtToolkit', self.ctx) self.xContainer.createPeer(xToolkit, None) self.xContainer.execute() except: traceback.print_exc() # XActionListener def actionPerformed (self, xActionEvent): try: if xActionEvent.ActionCommand == 'Default': self._setDefault() elif xActionEvent.ActionCommand == 'Apply': self._save("fr") self.xContainer.endExecute() elif xActionEvent.ActionCommand == 'Cancel': self.xContainer.endExecute() else: print("Wrong command: " + xActionEvent.ActionCommand) except: traceback.print_exc() def _setDefault (self): for w in self.lxOptions: w.State = gce.gc_options.dOpt.get(w.Name, False) def load (self, sLang): try: xChild = self.xNode.getByName(sLang) for sKey in gce.gc_options.dOpt: sValue = xChild.getPropertyValue(sKey) if sValue == '': if gce.gc_options.dOpt[sKey]: sValue = 1 else: sValue = 0 options[sKey] = bool(int(sValue)) except: traceback.print_exc() def _save (self, sLang): try: xChild = self.xNode.getByName(sLang) for w in self.lxOptions: sKey = w.Name bValue = w.State xChild.setPropertyValue(sKey, str(bValue)) options[sKey] = bValue gce.setOptions(options) self.xNode.commitChanges() except: traceback.print_exc() |
Added gc_core/py/oxt/OptionsDialog.xcs version [bfbbfee5a6].
> > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | <?xml version="1.0" encoding="UTF-8"?> <oor:component-schema oor:name="Lightproof_${implname}" oor:package="org.openoffice" xml:lang="en-US" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <info> <desc>Contains the options data used for the extension.</desc> </info> <templates> <group oor:name="${lang}"> <info> <desc>The data for one leaf.</desc> </info> ${xcs_options} </group> </templates> <component> <group oor:name="Leaves"> <node-ref oor:name="${lang}" oor:node-type="${lang}" /> </group> </component> </oor:component-schema> |
Added gc_core/py/oxt/OptionsDialog.xcu version [91cca1fa1e].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | <?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE oor:component-data SYSTEM "../../../../component-update.dtd"> <oor:component-data oor:name="OptionsDialog" oor:package="org.openoffice.Office" xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <node oor:name="Nodes"> <!--<node oor:name="org.openoffice.lightproof" oor:op="fuse"> <prop oor:name="Label"> <value xml:lang="en">Dictionaries</value> <value xml:lang="hu">Szótárak</value> </prop>--> <node oor:name="LanguageSettings" oor:op="fuse"> <prop oor:name="Label"> <value xml:lang="en-US">Language Settings</value> <value xml:lang="fr-FR">Paramètres linguistiques</value> </prop> <node oor:name="Leaves"> <node oor:name="org.openoffice.lightproof.${implname}" oor:op="fuse"> <prop oor:name="Id"> <!--<value>org.openoffice.comp.pyuno.lightproof.oxt.${implname}</value>--> <value>${oxt_identifier}</value> </prop> <prop oor:name="Label"> ${xcu_label_values} </prop> <prop oor:name="OptionsPage"> <value>%origin%/options_page.xdl</value> </prop> <prop oor:name="EventHandlerService"> <value>org.openoffice.comp.pyuno.LightproofOptionsEventHandler.${implname}</value> </prop> </node> </node> </node> </node> </oor:component-data> |
Added gc_core/py/oxt/description.xml version [53ef60ca5d].
> > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | <?xml version="1.0" encoding="UTF-8"?> <description xmlns="http://openoffice.org/extensions/description/2006" xmlns:d="http://openoffice.org/extensions/description/2006" xmlns:l="http://libreoffice.org/extensions/description/2011" xmlns:xlink="http://www.w3.org/1999/xlink"> <!--<identifier value="org.openoffice.comp.pyuno.lightproof.oxt.${implname}" />--> <identifier value="${oxt_identifier}" /> <display-name> <name lang="en-US">${name} (pack)</name> </display-name> <version value="${oxt_version}" /> <publisher> <name lang="en" xlink:href="${link}">${provider}</name> </publisher> <icon> <default xlink:href="${logo}" /> </icon> <dependencies> <l:LibreOffice-minimal-version value="4.2" l:name="LibreOffice 4.2" /> <!--<d:OpenOffice.org-minimal-version value="4.0" d:name="OpenOffice.org 4.0" />--> </dependencies> <!--<update-information> <src xlink:href="http://www.dicollecte.org/grammalecte/oxt/grammalecte.update03.xml" /> </update-information>--> </description> |
Added gc_core/py/oxt/lightproof_handler_grammalecte.py version [f322664f2e].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | import uno import unohelper import lightproof_opts_${implname} as lp_opt from gc_engine_${implname} import pkg from com.sun.star.lang import XServiceInfo from com.sun.star.awt import XContainerWindowEventHandler options = {} def load (context): try: l = LightproofOptionsEventHandler(context) for sLang in lp_opt.lopts: l.load(sLang) except: pass class LightproofOptionsEventHandler (unohelper.Base, XServiceInfo, XContainerWindowEventHandler): def __init__ (self, ctx): p = uno.createUnoStruct("com.sun.star.beans.PropertyValue") p.Name = "nodepath" p.Value = "/org.openoffice.Lightproof_%s/Leaves"%pkg self.xConfig = ctx.ServiceManager.createInstance('com.sun.star.configuration.ConfigurationProvider') self.node = self.xConfig.createInstanceWithArguments('com.sun.star.configuration.ConfigurationUpdateAccess', (p, )) self.service = "org.openoffice.comp.pyuno.LightproofOptionsEventHandler." + pkg self.ImplementationName = self.service self.services = (self.service, ) # XContainerWindowEventHandler def callHandlerMethod (self, aWindow, aEventObject, sMethod): if sMethod == "external_event": return self._handleExternalEvent(aWindow, aEventObject) def getSupportedMethodNames (self): return ("external_event", ) def _handleExternalEvent (self, aWindow, aEventObject): #aEventObject = str(aEventObject) # unnecessary in Python if aEventObject == "ok": self._saveData(aWindow) elif aEventObject == "back" or aEventObject == "initialize": self._loadData(aWindow) return True def load (self, sWindowName): child = self.getChild(sWindowName) for i in lp_opt.lopts[sWindowName]: sValue = child.getPropertyValue(i) if sValue == '': if i in lp_opt.lopts_default[sWindowName]: sValue = 1 else: sValue = 0 options[i] = bool(int(sValue)) def _loadData (self, aWindow): sWindowName = self.getWindowName(aWindow) if (sWindowName == None): return child = self.getChild(sWindowName) for i in lp_opt.lopts[sWindowName]: sValue = child.getPropertyValue(i) if sValue == '': if i in lp_opt.lopts_default[sWindowName]: sValue = 1 else: sValue = 0 xControl = aWindow.getControl(i) xControl.State = sValue options[i] = bool(int(sValue)) def _saveData (self, aWindow): sWindowName = self.getWindowName(aWindow) if (sWindowName == None): return child = self.getChild(sWindowName) for i in lp_opt.lopts[sWindowName]: xControl = aWindow.getControl(i) sValue = xControl.State child.setPropertyValue(i, str(sValue)) options[i] = bool(int(sValue)) self.commitChanges() def getWindowName (self, aWindow): sName = aWindow.getModel().Name if sName in lp_opt.lopts: return sName return None # XServiceInfo def getImplementationName (self): return self.ImplementationName def supportsService (self, ServiceName): return (ServiceName in self.services) def getSupportedServiceNames (self): return self.services def getChild (self, name): return self.node.getByName(name) def commitChanges (self): self.node.commitChanges() return True |
Added gc_core/py/oxt/manifest.xml version [a65b8c3dc8].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | <?xml version="1.0" encoding="UTF-8"?> <manifest:manifest> <!-- Dictionaries --> <manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data" manifest:full-path="dictionaries.xcu"/> <!-- Grammalecte --> <manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-schema" manifest:full-path="dialog/OptionsDialog.xcs"/> <!--<manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data" manifest:full-path="dialog/OptionsDialog.xcu"/>--> <manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Python" manifest:full-path="Grammalecte.py"/> <manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data" manifest:full-path="Linguistic.xcu"/> <manifest:file-entry manifest:media-type="application/vnd.sun.star.package-bundle-description" manifest:full-path="package-description.txt"/> <!-- Application laucher --> <manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Python" manifest:full-path="AppLauncher.py"/> <!-- Context Menu --> <manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Python" manifest:full-path="ContextMenu.py"/> <manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data" manifest:full-path="config/jobs.xcu"/> <!-- common --> <manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data" manifest:full-path="addons.xcu"/> </manifest:manifest> |
Added gc_core/py/oxt/op_strings.py version [7b0a214eba].
> > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | # -*- encoding: UTF-8 -*- def getUI (sLang): if sLang in dStrings: return dStrings[sLang] return dStrings["fr"] dStrings = { "fr": { "title": u"Grammalecte · Options du contrôle grammatical", "default": u"Par ~défaut", "apply": u"~OK", "cancel": u"~Annuler" }, "en": { "title": u"Grammalecte · Grammar checking options", "default": u"~Default", "apply": u"~OK", "cancel": u"~Cancel" } } |
Added gc_core/py/oxt/options_page.xdl version [b5343d8dd9].
> > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 | <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE dlg:window PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "dialog.dtd"> <dlg:window xmlns:dlg="http://openoffice.org/2000/dialog" xmlns:script="http://openoffice.org/2000/script" dlg:id="${lang}" dlg:left="101" dlg:top="52" dlg:width="196" dlg:height="72" dlg:closeable="true" dlg:moveable="true" dlg:withtitlebar="false"> <dlg:bulletinboard> ${xdl_dialog_options} </dlg:bulletinboard> </dlg:window> |
Added gc_core/py/progressbar.py version [5def72a6ce].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | # Textual progressbar # by Olivier R. # License: MPL 2 import time class ProgressBar: "Textual progressbar" def __init__ (self, nMin=0, nMax=100, nWidth=78): "initiate with minimum nMin to maximum nMax" self.nMin = nMin self.nMax = nMax self.nSpan = nMax - nMin self.nWidth = nWidth-9 self.nAdvance = -1 self.nCurVal = nMin self.startTime = time.time() self._update() def _update (self): fDone = ((self.nCurVal - self.nMin) / self.nSpan) nAdvance = int(fDone * self.nWidth) if (nAdvance > self.nAdvance): self.nAdvance = nAdvance print("\r[ {}{} {}% ] ".format('>'*nAdvance, ' '*(self.nWidth-nAdvance), round(fDone*100)), end="") def increment (self, n=1): "increment value by n (1 by default)" self.nCurVal += n self._update() def done (self): "to call when it’s finished" print("\r[ task done in {:.1f} s ] ".format(time.time() - self.startTime)) |
Added gc_core/py/str_transform.py version [e86906e5ce].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | #!python3 # -*- coding: UTF-8 -*- dSimilarChars = { "a": "aàâáä", "à": "aàâáä", "â": "aàâáä", "á": "aàâáä", "ä": "aàâáä", "c": "cç", "ç": "cç", "e": "eéêèë", "é": "eéêèë", "ê": "eéêèë", "è": "eéêèë", "ë": "eéêèë", "i": "iîïíì", "î": "iîïíì", "ï": "iîïíì", "í": "iîïíì", "ì": "iîïíì", "o": "oôóòö", "ô": "oôóòö", "ó": "oôóòö", "ò": "oôóòö", "ö": "oôóòö", "u": "uûùüú", "û": "uûùüú", "ù": "uûùüú", "ü": "uûùüú", "ú": "uûùüú", } ## No stemming def noStemming (sFlex, sStem): return sStem def rebuildWord (sFlex, cmd1, cmd2): if cmd1 == "_": return sFlex n, c = cmd1.split(":") s = s[:n] + c + s[n:] if cmd2 == "_": return s n, c = cmd2.split(":") return s[:n] + c + s[n:] ## Define affixes for stemming # Note: 48 is the ASCII code for "0" # Suffix only def defineSuffixCode (sFlex, sStem): """ Returns a string defining how to get stem from flexion "n(sfx)" with n: a char with numeric meaning, "0" = 0, "1" = 1, ... ":" = 10, etc. (See ASCII table.) Says how many letters to strip from flexion. sfx [optional]: string to add on flexion Examples: "0": strips nothing, adds nothing "1er": strips 1 letter, adds "er" "2": strips 2 letters, adds nothing """ if sFlex == sStem: return "0" jSfx = 0 for i in range(min(len(sFlex), len(sStem))): if sFlex[i] != sStem[i]: break jSfx += 1 return chr(len(sFlex)-jSfx+48) + sStem[jSfx:] def getStemFromSuffixCode (sFlex, sSfxCode): if sSfxCode == "0": return sFlex return sFlex[:-(ord(sSfxCode[0])-48)] + sSfxCode[1:] if sSfxCode[0] != '0' else sFlex + sSfxCode[1:] # Prefix and suffix def defineAffixCode (sFlex, sStem): """ Returns a string defining how to get stem from flexion. Examples: "0" if stem = flexion "stem" if no common substring "n(pfx)/m(sfx)" with n and m: chars with numeric meaning, "0" = 0, "1" = 1, ... ":" = 10, etc. (See ASCII table.) Says how many letters to strip from flexion. pfx [optional]: string to add before the flexion sfx [optional]: string to add after the flexion """ if sFlex == sStem: return "0" # is stem a substring of flexion? n = sFlex.find(sStem) if n >= 0: return "{}/{}".format(chr(n+48), chr(len(sFlex)-(len(sStem)+n)+48)) # no, so we are looking for common substring sSubs = longestCommonSubstring(sFlex, sStem) if len(sSubs) > 1: iPos = sStem.find(sSubs) sPfx = sStem[:iPos] sSfx = sStem[iPos+len(sSubs):] n = sFlex.find(sSubs) m = len(sFlex) - (len(sSubs)+n) sAff = "{}/".format(chr(n+48)) if not sPfx else "{}{}/".format(chr(n+48), sPfx) sAff += chr(m+48) if not sSfx else "{}{}".format(chr(m+48), sSfx) return sAff return sStem def longestCommonSubstring (s1, s2): # http://en.wikipedia.org/wiki/Longest_common_substring_problem # http://en.wikibooks.org/wiki/Algorithm_implementation/Strings/Longest_common_substring M = [ [0]*(1+len(s2)) for i in range(1+len(s1)) ] longest, x_longest = 0, 0 for x in range(1, 1+len(s1)): for y in range(1, 1+len(s2)): if s1[x-1] == s2[y-1]: M[x][y] = M[x-1][y-1] + 1 if M[x][y] > longest: longest = M[x][y] x_longest = x else: M[x][y] = 0 return s1[x_longest-longest : x_longest] def getStemFromAffixCode (sFlex, sAffCode): if sAffCode == "0": return sFlex if '/' not in sAffCode: return "# error #" sPfxCode, sSfxCode = sAffCode.split('/') sFlex = sPfxCode[1:] + sFlex[(ord(sPfxCode[0])-48):] return sFlex[:-(ord(sSfxCode[0])-48)] + sSfxCode[1:] if sSfxCode[0] != '0' else sFlex + sSfxCode[1:] |
Added gc_core/py/text.py version [af72c36707].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | #!python3 import textwrap from itertools import chain def getParagraph (sText): "generator: returns paragraphs of text" iStart = 0 iEnd = sText.find("\n", iStart) while iEnd != -1: yield sText[iStart:iEnd] iStart = iEnd + 1 iEnd = sText.find("\n", iStart) yield sText[iStart:] def wrap (sText, nWidth=80): "generator: returns text line by line" sText = sText.rstrip("\r\n") while sText: if len(sText) > nWidth: nEnd = sText.rfind(" ", 0, nWidth) + 1 if nEnd > 0: yield sText[0:nEnd] sText = sText[nEnd:] else: yield sText[0:nWidth] sText = sText[nWidth:] else: break yield sText def generateParagraph (sParagraph, aGrammErrs, aSpellErrs, nWidth=100): "Returns a text with readable errors" if not sParagraph: return "" lGrammErrs = sorted(aGrammErrs, key=lambda d: d["nStart"]) lSpellErrs = sorted(aSpellErrs, key=lambda d: d['nStart']) sText = "" nOffset = 0 for sLine in wrap(sParagraph, nWidth): # textwrap.wrap(sParagraph, nWidth, drop_whitespace=False) sText += sLine + "\n" ln = len(sLine) sErrLine = "" nLenErrLine = 0 nGrammErr = 0 nSpellErr = 0 for dErr in lGrammErrs: nStart = dErr["nStart"] - nOffset if nStart < ln: nGrammErr += 1 if nStart >= nLenErrLine: sErrLine += " " * (nStart - nLenErrLine) + "^" * (dErr["nEnd"] - dErr["nStart"]) nLenErrLine = len(sErrLine) else: break for dErr in lSpellErrs: nStart = dErr['nStart'] - nOffset if nStart < ln: nSpellErr += 1 nEnd = dErr['nEnd'] - nOffset if nEnd > len(sErrLine): sErrLine += " " * (nEnd - len(sErrLine)) sErrLine = sErrLine[:nStart] + "°" * (nEnd - nStart) + sErrLine[nEnd:] else: break if sErrLine: sText += sErrLine + "\n" if nGrammErr: for dErr in lGrammErrs[:nGrammErr]: sMsg, *others = getReadableError(dErr).split("\n") sText += "\n".join(textwrap.wrap(sMsg, nWidth, subsequent_indent=" ")) + "\n" for arg in others: sText += "\n".join(textwrap.wrap(arg, nWidth, subsequent_indent=" ")) + "\n" sText += "\n" del lGrammErrs[0:nGrammErr] if nSpellErr: del lSpellErrs[0:nSpellErr] nOffset += ln return sText def getReadableError (dErr): "Returns an error dErr as a readable error" try: s = u"* {nStart}:{nEnd} # {sLineId} / {sRuleId} : ".format(**dErr) s += dErr.get("sMessage", "# error : message not found") if dErr.get("aSuggestions", None): s += "\n > Suggestions : " + " | ".join(dErr.get("aSuggestions", "# error : suggestions not found")) if dErr.get("URL", None): s += "\n > URL: " + dErr["URL"] return s except KeyError: return u"* Non-compliant error: {}".format(dErr) def createParagraphWithLines (lLine): "Returns a text as merged lines and a set of data about lines (line_number_y, start_x, end_x)" sText = "" lLineSet = [] nLine = 1 n = 0 for iLineNumber, sLine in lLine: sLine = sLine.rstrip("\r\n") if nLine < len(lLine) and not sLine.endswith((" ", " ", "-", "–", "—")): sLine += " " lLineSet.append((iLineNumber, n, n + len(sLine))) n += len(sLine) sText += sLine nLine += 1 return sText, lLineSet def convertToXY (aGrammErrs, aSpellErrs, lLineSet): """Converts errors position as an y and x position in a text (y is line number, x is row number). lLineSet is a list of sets (line_number_y, start_x, end_x) describing how the paragraph is divided.""" for dErr in chain(aGrammErrs, aSpellErrs): for i, elem in enumerate(lLineSet, 1): if dErr['nEnd'] <= elem[2]: dErr['nEndY'] = elem[0] dErr['nEndX'] = dErr['nEnd'] - elem[1] break for elem in reversed(lLineSet[:i]): if dErr['nStart'] >= elem[1]: dErr['nStartY'] = elem[0] dErr['nStartX'] = dErr['nStart'] - elem[1] break del dErr['nStart'] del dErr['nEnd'] return aGrammErrs, aSpellErrs |
Added gc_core/py/tokenizer.py version [27b6fefad2].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | # Very simple tokenizer import re _PATTERNS = { "default": ( r'(?P<PUNC>[.,?!:;…«»“”"()/·]+)', r'(?P<LINK>(?:https?://|www[.]|\w+[@.]\w+[@.])[\w./?&!%=+*"\'@$#-]+)', r'(?P<HASHTAG>[#@][\w-]+)', r'(?P<HTML><\w+.*?>|</\w+ *>)', r'(?P<PSEUDOHTML>\[/?\w+\])', r'(?P<HOUR>\d\d?h\d\d\b)', r'(?P<NUM>-?\d+(?:[.,]\d+))', r"(?P<WORD>\w+(?:[’'`-]\w+)*)" ), "fr": ( r'(?P<PUNC>[.,?!:;…«»“”"()/·]+)', r'(?P<LINK>(?:https?://|www[.]|\w+[@.]\w+[@.])[\w./?&!%=+*"\'@$#-]+)', r'(?P<HASHTAG>[#@][\w-]+)', r'(?P<HTML><\w+.*?>|</\w+ *>)', r'(?P<PSEUDOHTML>\[/?\w+\])', r"(?P<ELPFX>(?:l|d|n|m|t|s|j|c|ç|lorsqu|puisqu|jusqu|quoiqu|qu)['’`])", r'(?P<ORDINAL>\d+(?:er|nd|e|de|ième|ème|eme)\b)', r'(?P<HOUR>\d\d?h\d\d\b)', r'(?P<NUM>-?\d+(?:[.,]\d+|))', r"(?P<WORD>\w+(?:[’'`-]\w+)*)" ) } class Tokenizer: def __init__ (self, sLang): self.sLang = sLang if sLang not in _PATTERNS: self.sLang = "default" self.zToken = re.compile( "(?i)" + '|'.join(sRegex for sRegex in _PATTERNS[sLang]) ) def genTokens (self, sText): for m in self.zToken.finditer(sText): yield { "sType": m.lastgroup, "sValue": m.group(), "nStart": m.start(), "nEnd": m.end() } |
Added gc_lang/fr/README_fr.txt version [459df4560b].
> > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | GRAMMALECTE Correcteur grammatical pour le français version ${version} _______________________________________________________________________________ Basé sur Lightproof de László Németh http://numbertext.org/lightproof/ Modifications de Lightproof et règles grammaticales : Olivier R. - olivier<at>grammalecte<dot>net Dicollecte : http://www.dicollecte.org/ Certaines des règles grammaticales sont reprises du correcteur LanguageTool, notamment celles de Dominique Pellé. Licence : GPL : GNU General Public License version 3 ou supérieure -- http://www.gnu.org/licenses/gpl-3.0.html Ce correcteur emploie le dictionnaire Hunspell créé par Dicollecte : http://www.dicollecte.org/home.php?prj=fr |
Added gc_lang/fr/build_data.py version [5eaa962f47].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 | #!python3 # FRENCH DATA BUILDER # # by Olivier R. # License: MPL 2 import json import os import grammalecte.ibdawg as ibdawg from grammalecte.echo import echo from grammalecte.str_transform import defineSuffixCode class cd: """Context manager for changing the current working directory""" def __init__ (self, newPath): self.newPath = os.path.expanduser(newPath) def __enter__ (self): self.savedPath = os.getcwd() os.chdir(self.newPath) def __exit__ (self, etype, value, traceback): os.chdir(self.savedPath) def makeDictionaries (sp, sVersion): with cd(sp+"/dictionnaire"): os.system("genfrdic.py -s -v "+sVersion) def makeConj (sp, bJS=False): print("> Conjugaisons ", end="") print("(Python et JavaScript)" if bJS else "(Python seulement)") dVerb = {} lVtyp = []; dVtyp = {}; nVtyp = 0 lTags = []; dTags = {}; nTags = 0 dPatternList = { ":PQ": [], ":Ip": [], ":Iq": [], ":Is": [], ":If": [], ":K": [], ":Sp": [], ":Sq": [], ":E": [] } dTrad = { "infi": ":Y", "ppre": ":PQ", "ppas": ":PQ", "ipre": ":Ip", "iimp": ":Iq", "ipsi": ":Is", "ifut": ":If", "spre": ":Sp", "simp": ":Sq", "cond": ":K", "impe": ":E", "1sg": ":1s", "2sg": ":2s", "3sg": ":3s", "1pl": ":1p", "2pl": ":2p", "3pl": ":3p", "1isg": ":1ś", "mas sg": ":Q1", "mas pl": ":Q2", "mas inv": ":Q1", "fem sg": ":Q3", "fem pl": ":Q4", "epi inv": ":Q1" } # read lexicon with open(sp+"/data/dictConj.txt", 'r', encoding='utf-8') as hSrc: nStop = 0 for n, line in enumerate(hSrc.readlines()): line = line.strip() nTab = line.count("\t") if nTab == 1: # new entry sLemma, sVtyp = line.split("\t") dConj = { ":PQ": { ":P": "", ":Q1": "", ":Q2": "", ":Q3": "", ":Q4": ""}, ":Ip": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "", ":1ś": "" }, ":Iq": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" }, ":Is": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" }, ":If": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" }, ":K": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "" }, ":Sp": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "", ":1ś": "" }, ":Sq": { ":1s": "", ":2s": "", ":3s": "", ":1p": "", ":2p": "", ":3p": "", ":1ś": "" }, ":E": { ":2s": "", ":1p": "", ":2p": "" } } if sVtyp not in lVtyp: dVtyp[sVtyp] = nVtyp lVtyp.append(sVtyp) nVtyp += 1 elif nTab == 2: # flexion _, sTag, sFlex = line.split("\t") if sTag.count(" ") == 0: if sTag == "ppre": dConj[":PQ"][":P"] = defineSuffixCode(sLemma, sFlex) else: mode, g = sTag.split(maxsplit=1) try: mode = dTrad[mode] g = dTrad[g] if dConj[mode][g] == "": dConj[mode][g] = defineSuffixCode(sLemma, sFlex) else: # comment gérer les autres graphies ? pass except: print(sLemma.encode("utf-8").decode("ascii"), " - non géré: ", mode, " / ", g) elif line == "$": # we store the dictionary of rules for this lemma if dConj[":Ip"][":1ś"] == "2è": dConj[":Ip"][":1ś"] = "2é" elif sLemma == "pouvoir": dConj[":Ip"][":1ś"] = "6uis" lConjTags = [] for key in [":PQ", ":Ip", ":Iq", ":Is", ":If", ":K", ":Sp", ":Sq", ":E"]: bFound = False for i, d in enumerate(dPatternList[key]): if dConj[key] == d: bFound = True lConjTags.append(i) break if not bFound: lConjTags.append(len(dPatternList[key])) dPatternList[key].append(dConj[key]) tConjTags = tuple(lConjTags) if tConjTags not in lTags: dTags[tConjTags] = nTags lTags.append(tConjTags) nTags += 1 dVerb[sLemma] = (dVtyp[sVtyp], dTags[tConjTags]) else: print("# Error - unknown line #", n) # convert tuples to bytes string # si ça merde, toute la partie conversion peut être supprimée # lBytesTags = [] # for t in lTags: # b = b"" # for n in t: # if n > 255: # print("Erreur : l'indice ne peut être supérieur à 256 pour utiliser des chaînes d'octets (bytes strings)") # exit() # b += n.to_bytes(1, byteorder="big") # lBytesTags.append(b) # lTags = lBytesTags # for key in dVerb.keys(): # b = b"" # for n in dVerb[key]: # if n > 255: # print("Erreur : l'indice ne peut être supérieur à 256 pour utiliser des chaînes d'octets (bytes strings)") # exit() # b += n.to_bytes(1, byteorder="big") # dVerb[key] = b # end conversion ## write file for Python sCode = "## generated data (do not edit)\n\n" + \ "# Informations about verbs\n" + \ "lVtyp = " + str(lVtyp) + "\n\n" + \ "# indexes of tenses in _dPatternConj\n" + \ "lTags = " + str(lTags) + "\n\n" + \ "# lists of affix codes to generate inflected forms\n" + \ "dPatternConj = " + str(dPatternList) + "\n\n" + \ "# dictionary of verbs : (index of Vtyp, index of Tags)\n" + \ "dVerb = " + str(dVerb) + "\n" open(sp+"/modules/conj_data.py", "w", encoding="utf-8", newline="\n").write(sCode) if bJS: ## write file for JavaScript with open(sp+"/modules-js/conj_data.json", "w", encoding="utf-8", newline="\n") as hDst: hDst.write("{\n") hDst.write(' "lVtyp": ' + json.dumps(lVtyp, ensure_ascii=False) + ",\n") hDst.write(' "lTags": ' + json.dumps(lTags, ensure_ascii=False) + ",\n") hDst.write(' "dPatternConj": ' + json.dumps(dPatternList, ensure_ascii=False) + ",\n") hDst.write(' "dVerb": ' + json.dumps(dVerb, ensure_ascii=False) + "\n") hDst.write("}\n") def makeMfsp (sp, bJS=False): print("> Pluriel/singulier/masculin/féminin ", end="") print("(Python et JavaScript)" if bJS else "(Python seulement)") aPlurS = set() dTag = {} lTagMasForm = [] lTagMiscPlur = [] dMiscPlur = {} dMasForm = {} # read lexicon with open(sp+"/data/dictDecl.txt", 'r', encoding='utf-8') as hSrc: lTag = [] lTagMasPl = [] for n, line in enumerate(hSrc.readlines()): line = line.strip() nTab = line.count("\t") if nTab == 1: # new entry lTag.clear() lTagMasPl.clear() sLemma, sFlags = line.split("\t") if sFlags.startswith("S"): cType = "s" elif sFlags.startswith("X"): cType = "p" elif sFlags.startswith("A"): cType = "p" elif sFlags.startswith("I"): cType = "p" elif sFlags.startswith("F"): cType = "m" elif sFlags.startswith("W"): cType = "m" else: cType = "?" print(" > inconnu : " + sFlags) elif nTab == 2: if cType == "s": continue _, sFlexTags, sFlex = line.split("\t") if cType == "p": if sFlexTags.endswith("pl"): lTag.append(defineSuffixCode(sLemma, sFlex)) elif cType == "m": if sFlexTags.endswith("mas sg") or sFlexTags.endswith("mas inv"): lTag.append(defineSuffixCode(sLemma, sFlex)) if sFlexTags.endswith("mas pl"): lTagMasPl.append(defineSuffixCode(sLemma, sFlex)) else: print("erreur: " + cType) elif line == "$": if cType == "s": aPlurS.add(sLemma) elif cType == "p": sTag = "|".join(lTag) if sTag not in dTag: dTag[sTag] = len(lTagMiscPlur) lTagMiscPlur.append(sTag) dMiscPlur[sLemma] = dTag[sTag] elif cType == "m": sTag = "|".join(lTag) if lTagMasPl: sTag += "/" + "|".join(lTagMasPl) if sTag not in dTag: dTag[sTag] = len(lTagMasForm) lTagMasForm.append(sTag) dMasForm[sLemma] = dTag[sTag] else: print("unknown tag: " + ctype) else: print("# Error - unknown line #", n) ## write file for Python sCode = "# generated data (do not edit)\n\n" + \ "# list of affix codes\n" + \ "lTagMiscPlur = " + str(lTagMiscPlur) + "\n" + \ "lTagMasForm = " + str(lTagMasForm) + "\n\n" + \ "# dictionary of words with uncommon plurals (-x, -ux, english, latin and italian plurals) and tags to generate them\n" + \ "dMiscPlur = " + str(dMiscPlur) + "\n\n" + \ "# dictionary of feminine forms and tags to generate masculine forms (singular and plural)\n" + \ "dMasForm = " + str(dMasForm) + "\n" open(sp+"/modules/mfsp_data.py", "w", encoding="utf-8", newline="\n").write(sCode) if bJS: ## write file for JavaScript sCode = '{\n' + \ ' "lTagMiscPlur": ' + json.dumps(lTagMiscPlur, ensure_ascii=False) + ",\n" + \ ' "lTagMasForm": ' + json.dumps(lTagMasForm, ensure_ascii=False) + ",\n" + \ ' "dMiscPlur": ' + json.dumps(dMiscPlur, ensure_ascii=False) + ",\n" + \ ' "dMasForm": ' + json.dumps(dMasForm, ensure_ascii=False) + "\n}" open(sp+"/modules-js/mfsp_data.json", "w", encoding="utf-8", newline="\n").write(sCode) def makePhonetTable (sp, bJS=False): print("> Correspondances phonétiques ", end="") print("(Python et JavaScript)" if bJS else "(Python seulement)") try: oDict = ibdawg.IBDAWG("French.bdic") except: traceback.print_exc() return with open(sp+"/data/phonet_simil.txt", 'r', encoding='utf-8') as hSrc: # set of homophonic words lSet = [] for sLine in hSrc.readlines(): if not sLine.startswith("#") and sLine.strip(): lSet.append(sorted(sLine.strip().split())) # dictionary of words dWord = {} for i, aSet in enumerate(lSet): for sWord in aSet: if oDict.lookup(sWord): dWord[sWord] = i # warning, what if word in several sets? else: echo("Mot inconnu : " + sWord) # dictionary of morphologies dMorph = {} for sWord in dWord: dMorph[sWord] = oDict.getMorph(sWord) # write file for Python sCode = "# generated data (do not edit)\n\n" + \ "dWord = " + str(dWord) + "\n\n" + \ "lSet = " + str(lSet) + "\n\n" + \ "dMorph = " + str(dMorph) + "\n" open(sp+"/modules/phonet_data.py", "w", encoding="utf-8", newline="\n").write(sCode) if bJS: ## write file for JavaScript sCode = "{\n" + \ ' "dWord": ' + json.dumps(dWord, ensure_ascii=False) + ",\n" + \ ' "lSet": ' + json.dumps(lSet, ensure_ascii=False) + ",\n" + \ ' "dMorph": ' + json.dumps(dMorph, ensure_ascii=False) + "\n}" open(sp+"/modules-js/phonet_data.json", "w", encoding="utf-8", newline="\n").write(sCode) def before (spLaunch, dVars, bJS=False): print("========== Build Hunspell dictionaries ==========") makeDictionaries(spLaunch, dVars['oxt_version']) def after (spLaunch, dVars, bJS=False): print("========== Build French data ==========") makeMfsp(spLaunch, bJS) makeConj(spLaunch, bJS) makePhonetTable(spLaunch, bJS) |
Added gc_lang/fr/config.ini version [af08a98257].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 | [args] lang = fr lang_name = French locales = fr_FR fr_BE fr_CA fr_CH fr_LU fr_MC fr_BF fr_CI fr_SN fr_ML fr_NE fr_TG fr_BJ country_default = FR name = Grammalecte implname = grammalecte version = 0.5.16 author = Olivier R. provider = Dicollecte link = http://grammalecte.net description = Correcteur grammatical pour le français. extras = README_fr.txt logo = logo.png # lexicon source lexicon_src = lexicons/French.lex # binary dictionary name py_binary_dic = French.bdic js_binary_dic = French.json # Finite state automaton compression: 1, 2 (experimental) or 3 (experimental) fsa_method = 1 # stemming method: S for suffixes only, A for prefixes and suffixes stemming_method = S # LibreOffice unopkg = C:/Program Files/LibreOffice 5/program/unopkg.com oxt_version = 6.0.3 oxt_identifier = French.linguistic.resources.from.Dicollecte.by.OlivierR # Firefox fx_identifier = French-GC@grammalecte.net fx_name = Grammalecte [fr] # Thunderbird tb_identifier = French-GC-TB@grammalecte.net tb_name = Grammalecte [fr] tb_debug_extension_path = _build/tb-debug.profile/extensions/French-GC-TB@grammalecte.net # Set Thunderbird folder in your PATH variable # Create a local profile: # thunderbird -CreateProfile "debug _build\tb-debug.profile" # Or you can use the GUI with: # thunderbird -P # To launch Thunderbird with the profile debug, type: # thunderbird -P debug # Then, install the extension (.xpi) the first time. # Then, you can build Grammalecte and launch Thunderbird automatically with `make.py [lang] -js -tb` [oxt] # the following files must be in your project folder, files will be copied into the zip archive rules.grx = fr-rules.txt oxt/addons.xcu = addons.xcu oxt/package-description.txt = package-description.txt # images oxt/_img/logo100.png = img/logo100.png oxt/_img/LaMouette_small.png = img/LaMouette_small.png oxt/_img/grammalecte_16.bmp = img/grammalecte_16.bmp oxt/_img/french_flag_16.bmp = img/french_flag_16.bmp # AppLauncher oxt/AppLauncher.py = AppLauncher.py oxt/helpers.py = pythonpath/helpers.py # About oxt/About/About.py = pythonpath/About.py oxt/About/ab_strings.py = pythonpath/ab_strings.py # Dictionaries oxt/Dictionnaires/dictionaries = dictionaries oxt/Dictionnaires/dictionaries.xcu = dictionaries.xcu oxt/Dictionnaires/DictionarySwitcher.py = pythonpath/DictionarySwitcher.py oxt/Dictionnaires/ds_strings.py = pythonpath/ds_strings.py # ContextMenu oxt/ContextMenu/ContextMenu.py = ContextMenu.py oxt/ContextMenu/jobs.xcu = config/jobs.xcu # TextFormatter oxt/TextFormatter/TextFormatter.py = pythonpath/TextFormatter.py oxt/TextFormatter/tf_strings.py = pythonpath/tf_strings.py oxt/TextFormatter/tf_options.py = pythonpath/tf_options.py # Conjugueur oxt/Conjugueur/Conjugueur.py = pythonpath/Conjugueur.py # Modify author oxt/ChangeAuthor/Author.py = pythonpath/Author.py oxt/ChangeAuthor/ca_strings.py = pythonpath/ca_strings.py |
Added gc_lang/fr/data/dictConj.txt version [72c1a37e0e].
more than 10,000 changes
Added gc_lang/fr/data/dictDecl.txt version [b83c3ed7ca].
more than 10,000 changes
Added gc_lang/fr/data/phonet_simil.txt version [316dba4c75].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 | # Homophonies a as à ha ah abaisse abaisses abaissent abbesse abbesses abord abord abhorre abhorres abhorrent accueil accueils accueille accueilles accueillent acre acres âcre âcres adhérant adhérent adhérents ai ait aie aies aient ais hé eh es haie haies hais est et air airs aire aires ère ères hère hères erre erres errent ers haire haires ail aille ailles aillent aïe aile ailes elle elles aller allers allée allées allé allés allez allais allait allaient amen amène amènes amènent an ans en antre antres entre entres entrent appareil appareils appareille appareilles appareillent appel appels appelle appelles appellent appui appuis appuie appuies appuient archée archées archer archers archet archets arête arêtes arrête arrêtes arrêtent assassinat assassinats assassina assassinas assassinât assignat assignats assigna assignas assignât assimilat assimilats assimila assimilas assimilât atèle atèles attelle attelles attellent attentat attentats attenta attentas attentât attribut attributs attribue attribues attribuent au aux ô eau eaux haut hauts auteur auteurs auteure auteures hauteur hauteurs avait avais avaient avez avé aval avals avale avales avalent bail baille bailles baillent bâille bâilles bâillent bâillent baye bayes bayent bâillon bâillons baillons bayons bal bals balle balles balai balais balaie balaies balaient ballet ballets bar bars barre barres barrent bard bards bas bât bâts bah bassinet bassinets bassiner bassinais bassinait bassinaient bassinez basilic basilics basilique basiliques beau beaux baux beur beurs beurre beurre beurrent bit bits bite bites bitent bitte bittes bittent bloc blocs bloque bloques bloquent bois boit boîte boîtes boite boite boitent boss bosse bosses bossent bourg bourgs bourre bourres bourrent bous boue boues bout bouts box boxe boxes boxent bric brick bricks brique briques briquent bure bures burent but buts bute butes butent butte buttes buttent bûtes cal cals cale cales calent calcul calculs calcule calcules calculent camouflet camouflets camoufler camouflais camouflaient camouflez camp camps quand quant khan khans cap caps cape capes cache caches cachent cash cachet cachets cacher cachais cachait cachaient cachez cadran cadrans cadrant caret carets carré carrés carrais carrait carraient carrez ce se céleri céleris sellerie selleries celle celles sel sels selle selles sellent cèle cèles cèlent scelle scelles scellent cendre cendres sandre sandres cène saine saines scène scènes senne sennes sen Seine centon centons santon santons sentons cerf cerfs serre serres serrent sers sert serf serfs ces ses sais sait cet cette sept set sets chant chants champ champs chaud chauds chaux show shows chaut chic chics chique chiques chiquent choc chocs choque choques choquent choix choie choies choient choral chorals chorale chorales corral corrals ci si scie scies scient six sis cilice cilices silice silices cire cires cirent sire sires cirre cirres cirrhe cirrhes cite cites citent site sites scythe scythes clair clairs claire claires clerc clercs clic clics clique cliques cliquent cliquet cliquets cliquer cliquais cliquait cliquaient cliquez coffret coffrets coffrer coffrais coffrait coffraient coffrez coïncidant coïncident coïncidents col cols colle colles collent khôl khôls collet collets coller collais collait collaient collez combinat combinats combina combinas combinât communicant communicants communiquant complet complets complais complait complaît connexion connexions connections conseil conseils conseille conseilles conseillent conseiller conseillers conseiller conseillais conseillait conseillaient conseillez consonne consonnes consone consones consonent contact contacts contacte contactes contactent conte contes content compte comptes comptent comte comtes continu continus continue continues continuent convaincant convaincants convainquant convergeant convergent convergents convoi convois convoie convoies convoient cool cools coule coules coulent coq coqs coque coques coke cokes cote cotes cotent côte côtes cotte cottes coter coté cotais cotait cotaient côté côtés cou cous coût coûts coup coups coud couds couplet couplets coupler couplais couplait couplaient couplez cour cours court courts coure coures courent courre crachat crachats cracha crachas crachât crack cracks craque craques craquent krak kraks crac créer créé créés créée créées crée crées créent créais créait créaient créez crème crèmes chrême chrêmes creuset creusets creuser creusais creusait creusaient creusez cri cris crie cries crient crois croit croient croîs croît croix cuir cuirs cuire cumul cumuls cumule cumules cumulent cumulet cumulets cumuler cumulais cumulait cumulaient cumulez cygne cygnes signe signes signent dans dent dents danse danses dansent dense denses dé dés dès dais des deal deals deale deales dealent défi défis défie défies défient dégel dégels dégèle dégèles dégèlent délégant délégants déléguant dépens dépends dépend desceller déceler desseller désir désirs désire désires désirent détail détails détaille détailles détaillent diagnostic diagnostics diagnostique diagnostiques diagnostiquent différant différent différents dîne dînes dînent dyne dynes dis dit dît dix divergeant divergent divergents doigt doigts dois doit don dons dont doublet doublets doubler doublais doublait doublaient doublez du dû dus due dues dialysat dialysats dialysa dialysas dialysât éclair éclairs éclaire éclaires éclairent égal égale égales éjaculat éjaculats éjacula éjaculas éjaculât élisais élisait élisaient élisez Élysée Élysées emploi emplois emploie emploies emploient empreinte empreintes emprunte empruntes empruntent ennui ennuis ennuie ennuies ennuient entretien entretiens entretient entrée entrées entrer entrais entrait entrez entraient envoi envois envoie envoies envoient envol envols envole envoles envolent épais épée épées équivalant équivalent équivalents essai essais essaie essaies essaient essaye essayes essayent étai étais était étaient été étés étain étains éteint éteins étal étals étale étales étalent étang étangs étant étends étend être êtres hêtre hêtres eusse eusses eussent us éveil éveils éveille éveilles éveillent excellant excellent excellents exsudat exsudats exsuda exsudas exsudât extravagant extravagants extravaguant fabriquant fabricant fabricants face faces fasse fasses fassent fasce fasces faire fer fers ferre ferres ferrent faisan faisans faisant fait faits fée fées far fard fards phare phares fatigant fatigants fatiguant fausse fausses faussent fosses fosses fausset faussets fossé fossés fausser faussais faussait faussaient faussez faux faut faîte faîtes fait faits faite faites fête fêtes fêtent fèces fesse fesses fessent feuillet feuillets feuillée feuillées fi fis fit fît fief fiefs fieffe fieffes fieffent fil fils file files filent filet filets filer filais filait filaient filez film films filme filmes filment filtrat filtrats filtra filtras filtrât fin fins faim faims feins feint flan flan flanc flancs flic flics flique fliques fliquent flou flous floue floues flouent foi fois foie foies font fonts fond fonds forçat forçats força forças forçât foret forets forer forais forait foraient forêt forêts format formats forma formas formât fort forts for fore fores forent fors fou fous fout four fours fourre fourres fourrent fumée fumées fumet fumets fumer fumais fumait fumaient fumez fus fut fût gal gals gale gales galle galles gang gangs gangue gangues garantie garanties garantis garantit gaule gaules goal goals gaz gaze gazes gazent gel gels gèle gèles gèlent gène gènes gêne gênes gênent golf golfs golfe golfes golfent gosse gosses gausse gausses gaussent gauss Gauss goulet goulets goulée goulées gré grès guère guerre guerres hâle hâles halle halles hall halls haltère haltères altère altères altèrent harde hardes arde ardes ardent hausse hausses haussent os haute hautes hôte hôtes hotte hotte ôte ôtes ôtent héro héros héraut hérauts heur heure heures heurt heurts hochet hochets hocher hochais hochait hochaient hochez homme hommes ohm ohms heaume heaumes hydrolysat hydrolysats hydrolysa hydrolysas hydrolysât hyène hyènes yen yens i y il ils île îles incarnat incarnats incarna incarnas incarnât indic indics indique indiques indiquent infiltrat infiltrats infiltra infiltras infiltrât institut instituts institue institues instituent internat internats interna internas internât intriguant intrigant intrigants jar jars jard jards jarre jarres jardinet jardinets jardiner jardinais jardinait jardinaient jardinez jet jets jette jettes jettent jeune jeunes jeûne jeûnes jeûnent joue joues jouent joug jougs jouer jouais jouait jouaient jouet jouets jouez kermès kermesse kermesses la là las lac lacs laque laques laquent lacet lacets lacer laçais laçait laçaient lacez lasser lassais lassait lassaient lassez legs lègue lègues lèguent les laid laids lait laits laie laies lai levée levées lever levers levais levait levaient levez lieu lieux lieue lieues lice lices lisse lisses lissent lys lis lit lits lie lies lient lire lires lyre lyres livret livrets livrer livrais livrait livraient livrez loch lochs loque loques loir loirs Loir Loire loup loups loue loues louent luth luths luttes luttes luttent lut lute lutes lutent lyophilisat lyophilisats lyophilisa lyophilisas lyophilisât ma mas mât mâts macro macros maquereau maquereaux magazine magazines magasine magasines magasinent mai mais mes met mets main mains maint maints maintien maintiens maintient maire maires mer mers mère mères maison maisons méson mésons maître maîtres mètre mètres mettre mal mâle mâles malle malles mante mantes mente mentes mentent menthe menthes marais marée marées marrais marrait marraient marché marchés marcher marchais marchait marchez marchaient mare mares marre marres marrent marc marcs mark marks marque marques marquent mec mecs Mecque mél mêle mêles mêlent mess messe messes meurs meurt mœurs mi mie mies mis mit mît mir mirs mire mires myrrhe myrrhes mite mites mythe mythes mol mols mole moles molle molles môle môles mon mont monts monitorat monitorats monitora monitoras monitorât mort morts mors mords mord maure maures mot mots maux moi mois mou mous moult moût moûts mouds moud moue moues mur murs mûr mûrs mûre mûres mure mures murent muret murets murer murais murait muraient murez mu mus mû mue mues muent nais nait nez navigant navigants naviguant négligeant négligent négligents ni nid nids nie nies nient noix noie noies noient notre nôtre nôtres nous noue noues nouent nui nuis nuit nuits octroi octrois octroie octroies octroient on ont or ors hors ou où houx houe houes hou oubli oublis oublie oublies oublient pain pains pin pins peins peint pair pairs paire paires père pères perds perd pers paix pet pets paie paies paient pal pals pale pales pâle pâles palier paliers pallier palliais palliait palliez palliaient pan pans pend pends panse panses pansent pense penses pensent pansé pansés pansée pansées pensé pensés pensée pensées penser pensais pensait pensaient pensez pansais pensez pansait pansaient par part parts par pare pares parent pars parait paraît parais parer parez parant parent parents parc parcs parque parques parquent Parque Parques parquet parquets parquer parquais parquait parquaient parquez pari paris parie paries parient Paris parquet parquets parquer parquais parquait parquaient parquez parti partis partit partie parties pause pauses pose poses posent peau peaux pot pots Po Pau pêche pêches pèche pèches pèchent péché péchés pêcher pêchers péchais péchait péchaient pêchais pêchait pêchaient peine peines peinent penne pennes pêne pênes pèle pèles pèlent pelle pelles pellent pellet pellets peler pelait pelais pelaient peller pellait pellais pellaient pensionnat pensionnats pensionna pensionnas pensionnât peu peux peut pic pics pique piques piquent pinson pinsons pinçons piquer piquais piquait piquaient piqué piqués piquée piquées piquet piquets pissat pissats pissa pissas pissât plagiat plagiats plagia plagias plagiât plaid plaids plaide plaides plaident plain plains plaint plaints plein pleins plais plaît plaie plaies plan plans plant plants pli plis plie plies plient police polices policent polisse polisses polissent poêle poêles poil poils poignée poignées poignet poignets poids pois poix pouah point points poing poings polissoir polissoirs polissoire polissoires porc porcs port ports pore pores pool pools poule poules post poste postes postent pou poux pouls pouf poufs pouffe pouffes pouffent pouce pouces pousse pousses poussent précédant précédent précédents prêt prêts près pré prés primat primats prima primas primât prix pris prit prît prie pries prient profil profils profile profiles profilent pronostic pronostics pronostique pronostiques pronostiquent provoc provocs provoque provoques provoquent provocant provocants provoquant pu pue pues pus put puce puces pucent pusse pusses pussent puis puits quadruplet quadruplets quadrupler quadruplais quadruplait quadruplaient quadruplez quintuplet quintuplets quintupler quintuplais quintuplait quintuplaient quintuplez rappel rappels rappelle rappelles rappellent racket rackets raquette raquettes rackette rackettes rackettent raffinat raffinats raffina raffinas raffinât rauque rauques roc rocs roque roques roquent recel recels recèle recèles recèlent recueil recueils recueille recueilles recueillent recul reculs recule recules reculent régal régals régale régale régalent reine reines renne rennes rêne rênes relai relais relaye relayes relayent remblai remblais remblaie remblaies remblaient renvoi renvois renvoie renvoies renvoient ressenti ressentis ressentit restaurant restaurants restaurent résultat résultats résulta résultât réveil réveils réveille réveilles réveillent ris rit rient rie ries riz roue roues rouent roux sac sacs saque saques saquent sachet sachets sachez sacret sacrets sacré sacrés sacrée sacrées sacrer sacrais sacrait sacraient sacrez salariat salariats salaria salarias salariât sale sales salent salles salles salut saluts salue salues saluent sang sangs sans cent cents sens sent cens saoul saouls saoule saoules saoulent soûl soûls soûle soûles soûlent soul souls soule soules soulent saké sakés saquer saquais saquait saquaient saquez satire satires satyre satyres saut sauts sot sots sceau sceaux seau seaux saute sautes sautent sotte sottes savon savons sein seins saint saints sain sains ceins ceint ceints ses ces sais sait shoot shoots shoote shootes shootent sifflet sifflets siffler sifflais sifflait sifflaient sifflez signal signale signales signalent signet signets signer signais signait signaient signez soi soie soies soit sois soient sol sols sole soles saule saules somme sommes somment sommeil sommeils sommeille sommeilles sommeillent sommet sommets sommer sommais sommait sommaient sommez son sons sont sonnet sonnets sonner sonnais sonnait sonnaient sonnez sors sort sorts sortie sorties sortis sortit souci soucis soucie soucies soucient soutien soutiens soutient soufflet soufflets soufflé soufflés souffler soufflais soufflait soufflaient soufflez soufre soufres souffre souffres souffrent stress stresse stresses stressent substitut substituts substitue substitues substituent sui suis suit suie suies survie survies survis survit survol survols survole survoles survolent ta tas taie taies tes thé thés tain teint teints thym thyms tin tins tint teins tant temps tends tend tante tantes tente tentes tentent tapis tapit tapît tare tares tard teinte teintes teintent tinte tintes tintent test tests teste testes testent tête têtes tète tètes tètent tic tics tique tiques tiquent tir tirs tire tires tirent tien tiens tient toc toque toques toquent toi toit toits ton tons thon thons tond tonds tort torts tore tores taure taures tord tords tors tournoi tournois tournoie tournoies tournoient tout toux tous tousse tousses toussent trafic trafics trafique trafiques trafiquent tram trams trame trames trament travail travaille travailles travaillent treuil treuils treuille treuilles treuillent tri tris trie tries trient triplet triplets tripler triplais triplait triplaient triplez troc trocs troque troques troquent troquet troquets troquer troquais troquait troquaient troquez troll trolls trolle trolles trollent troller trolley trolleys trollais trollait trollaient trollez trou trous troue troues trouent truc trucs truque truques truquent tu tus tue tues tuent tutorat tutorats tutora tutoras tutorât usa usas USA vacant vacants vaquant vais vé vés vain vains vin vins vint vingt vaincs vainc val vals valent valet valets valais valait valaient valez vallée vallées vaux vaut vau veau veaux vos vent vents vend vends van vans ver vers verre verres vert verts vair verrat verrats verra verras verset versets verser versais versait versaient versez veule veules veulent veux veut vœu vœux vil vils vile viles ville villes vie vies vis vit vis vice vices visse visses vissent viol viols viole violes violent violant violent violents violat violats viola violas violât violet violets violer violais violait violaient violez violé violés violée violées voix voie voies voient vois voit voir voire vol vols vole voles volent volet volets voler volais volait volaient volez vomi vomis vomit vous voue voues vouent zigzagant zigzagants zigzaguant |
Added gc_lang/fr/dictionnaire/_templates/moz-snapshot.png version [8dc8870d7e].
cannot compute difference between binary files
Added gc_lang/fr/dictionnaire/_templates/moz/install.rdf version [349100bbce].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | <?xml version="1.0"?> <RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <Description about="urn:mozilla:install-manifest"> <!-- https://developer.mozilla.org/en-US/docs/Install_Manifests --> <em:id>${mozId}@dictionaries.addons.mozilla.org</em:id> <em:version>${version}</em:version> <em:unpack>true</em:unpack> <em:type>64</em:type> <!-- dictionary --> <!-- Front End MetaData --> <em:name>Dictionnaire français</em:name> <em:description>${description}</em:description> <em:creator>Olivier R.</em:creator> <em:contributor>Olivier R.</em:contributor> <em:contributor>Sylvain P.</em:contributor> <em:contributor>Jean-Luc T.</em:contributor> <em:contributor>Laurent Dubois</em:contributor> <em:contributor>Dominique Pellé</em:contributor> <em:contributor>Pierre Poisson</em:contributor> <em:contributor>Pierre-Yves</em:contributor> <em:contributor>Renouvo</em:contributor> <em:homepageURL>http://www.dicollecte.org/</em:homepageURL> <em:targetApplication> <Description> <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> <!-- Firefox --> <em:minVersion>14.0</em:minVersion> <em:maxVersion>*</em:maxVersion> </Description> </em:targetApplication> <em:targetApplication> <Description> <em:id>{3550f703-e582-4d05-9a08-453d09bdfdc6}</em:id> <!-- Thunderbird --> <em:minVersion>14.0</em:minVersion> <em:maxVersion>53.*</em:maxVersion> </Description> </em:targetApplication> <em:targetApplication> <Description> <em:id>{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}</em:id> <!-- SeaMonkey --> <em:minVersion>2.12</em:minVersion> <em:maxVersion>*</em:maxVersion> </Description> </em:targetApplication> </Description> </RDF> |
Added gc_lang/fr/dictionnaire/_templates/ooo/DictionarySwitcher.py version [9680ccdc4b].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 | # -*- coding: utf8 -*- # French Dictionary Switcher # by Olivier R. # License: MPL 2 import unohelper import uno import re import traceback import ds_strings from com.sun.star.task import XJobExecutor from com.sun.star.awt import XActionListener from com.sun.star.beans import PropertyValue def getWindowSize (): "return main window size" xCurCtx = uno.getComponentContext() xDesktop = xCurCtx.getServiceManager().createInstanceWithContext('com.sun.star.frame.Desktop', xCurCtx) xContainerWindow = xDesktop.getCurrentComponent().CurrentController.Frame.ContainerWindow xWindowSize = xContainerWindow.convertSizeToLogic(xContainerWindow.Size, uno.getConstantByName("com.sun.star.util.MeasureUnit.POINT")) #print(xContainerWindow.Size.Width, ">", xWindowSize.Width) #print(xContainerWindow.Size.Height, ">", xWindowSize.Height) xWindowSize.Width = xWindowSize.Width * 0.666 xWindowSize.Height = xWindowSize.Height * 0.666 return xWindowSize class FrenchDictionarySwitcher (unohelper.Base, XActionListener, XJobExecutor): def __init__ (self, ctx): self.ctx = ctx self.xSvMgr = self.ctx.ServiceManager self.xContainer = None self.dialog = None self.xRB_m = None self.xRB_c = None self.xRB_r = None self.xRB_f = None self.sCurrentDic = '' self.sSelectedDic = '' # In this extension, French is default language. # It is assumed that those who need to use the French dictionaries understand French and may not understand English. xSettings = getConfigSetting("/org.openoffice.Setup/L10N", False) sLocale = xSettings.getByName("ooLocale") # Note: look at ooSetupSystemLocale value ? if sLocale[0:2] in ds_strings.dStrings: self.dUI = ds_strings.dStrings[sLocale[0:2]] else: self.dUI = ds_strings.dStrings["fr"] def addWidget (self, name, wtype, x, y, w, h, **kwargs): xWidget = self.dialog.createInstance('com.sun.star.awt.UnoControl%sModel' % wtype) xWidget.Name = name xWidget.PositionX = x xWidget.PositionY = y xWidget.Width = w xWidget.Height = h for k, w in kwargs.items(): setattr(xWidget, k, w) self.dialog.insertByName(name, xWidget) return xWidget def run (self): # what is the current dictionary xSettings = getConfigSetting("/org.openoffice.Office.Linguistic/ServiceManager/Dictionaries/HunSpellDic_fr", False) xLocations = xSettings.getByName("Locations") m = re.search(r"fr-(\w*)\.(?:dic|aff)", xLocations[0]) self.sCurrentDic = m.group(1) # dialog self.dialog = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlDialogModel', self.ctx) self.dialog.Width = 200 self.dialog.Height = 290 self.dialog.Title = self.dUI.get('title', "#title#") xWindowSize = getWindowSize() self.dialog.PositionX = int((xWindowSize.Width / 2) - (self.dialog.Width / 2)) self.dialog.PositionY = int((xWindowSize.Height / 2) - (self.dialog.Height / 2)) # xWidgets padding = 10 hspace = 60 posY1 = 20; posY2 = posY1 + hspace; posY3 = posY2 + hspace; posY4 = posY3 + hspace; posY5 = posY4 + hspace + 10; nLblWidth = 170 nLblHeight = 20 nDescWidth = 170 nDescHeight = 40 xFD1 = uno.createUnoStruct("com.sun.star.awt.FontDescriptor") xFD1.Height = 12 xFD1.Name = "Verdana" xFD2 = uno.createUnoStruct("com.sun.star.awt.FontDescriptor") xFD2.Height = 11 xFD2.Name = "Verdana" xFD3 = uno.createUnoStruct("com.sun.star.awt.FontDescriptor") xFD3.Height = 10 xFD3.Weight = uno.getConstantByName("com.sun.star.awt.FontWeight.BOLD") xFD3.Name = "Verdana" gbm = self.addWidget('groupbox', 'GroupBox', 5, 5, 190, 260, Label = self.dUI.get('choose', "#choose#"), FontDescriptor = xFD1, FontRelief = 1, TextColor = 0xAA2200) # Note: the only way to group RadioButtons is to create them successively rbm_m = self.addWidget('rb-moderne', 'RadioButton', padding, posY1, nLblWidth, nLblHeight, Label = self.dUI.get('moderne', "#moderne#"), FontDescriptor = xFD2, FontRelief = 1, TextColor = 0x0022AA) self.xRB_m = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_m.setModel(rbm_m) rbm_c = self.addWidget('rb-classique', 'RadioButton', padding, posY2, nLblWidth, nLblHeight, Label = self.dUI.get('classique', "#classique#"), FontDescriptor = xFD2, FontRelief = 1, TextColor = 0x0022AA) self.xRB_c = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_c.setModel(rbm_c) rbm_r = self.addWidget('rb-reforme1990', 'RadioButton', padding, posY3, nLblWidth, nLblHeight, Label = self.dUI.get('reforme1990', "#reforme1990#"), FontDescriptor = xFD2, FontRelief = 1, TextColor = 0x0022AA) self.xRB_r = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_r.setModel(rbm_r) rbm_t = self.addWidget('rb-toutesvariantes', 'RadioButton', padding, posY4, nLblWidth, nLblHeight, Label = self.dUI.get('toutesvariantes', "#toutesvariantes#"), FontDescriptor = xFD2, FontRelief = 1, TextColor = 0x0022AA) self.xRB_t = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_t.setModel(rbm_t) label_m = self.addWidget('label_m', 'FixedText', 20, posY1+10, nDescWidth, nDescHeight, Label = self.dUI.get('descModern', "#descModern#"), MultiLine = True) label_c = self.addWidget('label_c', 'FixedText', 20, posY2+10, nDescWidth, nDescHeight, Label = self.dUI.get('descClassic', "#descClassic#"), MultiLine = True) label_r = self.addWidget('label_r', 'FixedText', 20, posY3+10, nDescWidth, nDescHeight, Label = self.dUI.get('descReform', "#descReform#"), MultiLine = True) label_t = self.addWidget('label_t', 'FixedText', 20, posY4+10, nDescWidth, nDescHeight, Label = self.dUI.get('descAllvar', "#descAllvar#"), MultiLine = True) if self.sCurrentDic: self.setRadioButton(self.sCurrentDic) sMsgLabel = self.dUI.get('restart', "#restart#") bButtonActive = True else: sMsgLabel = self.dUI.get('error', "#error#") bButtonActive = False label_info = self.addWidget('label_info', 'FixedText', 10, posY4+50, 180, 10, Label = sMsgLabel, TextColor = 0xAA2200, MultiLine = True) button = self.addWidget('select', 'Button', padding+40, posY5, 100, 14, Label = self.dUI.get('select', "#select#"), FontDescriptor = xFD3, TextColor = 0x004400, Enabled = bButtonActive) # container self.xContainer = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlDialog', self.ctx) self.xContainer.setModel(self.dialog) self.xContainer.getControl('select').addActionListener(self) self.xContainer.setVisible(False) toolkit = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.ExtToolkit', self.ctx) self.xContainer.createPeer(toolkit, None) self.xContainer.execute() def setRadioButton (self, sDic): if sDic == 'moderne': self.xRB_m.setState(True) elif sDic == 'classique': self.xRB_c.setState(True) elif sDic == 'reforme1990': self.xRB_r.setState(True) elif sDic == 'toutesvariantes': self.xRB_t.setState(True) else: pass def actionPerformed (self, actionEvent): try: if self.xRB_m.getState(): self.sSelectedDic = 'moderne' elif self.xRB_c.getState(): self.sSelectedDic = 'classique' elif self.xRB_r.getState(): self.sSelectedDic = 'reforme1990' elif self.xRB_t.getState(): self.sSelectedDic = 'toutesvariantes' else: # no dictionary selected pass self.xContainer.endExecute() except: traceback.print_exc() def trigger (self, args): try: dialog = FrenchDictionarySwitcher(self.ctx) dialog.run() if dialog.sSelectedDic and dialog.sSelectedDic != dialog.sCurrentDic : # Modify the registry xSettings = getConfigSetting("/org.openoffice.Office.Linguistic/ServiceManager/Dictionaries/HunSpellDic_fr", True) xLocations = xSettings.getByName("Locations") v1 = xLocations[0].replace(dialog.sCurrentDic, dialog.sSelectedDic) v2 = xLocations[1].replace(dialog.sCurrentDic, dialog.sSelectedDic) #xSettings.replaceByName("Locations", xLocations) # doesn't work, see line below uno.invoke(xSettings, "replaceByName", ("Locations", uno.Any("[]string", (v1, v2)))) xSettings.commitChanges() except: traceback.print_exc() def getConfigSetting (sNodeConfig, bUpdate): # get a configuration node # example: aSettings = getConfigSetting( "/org.openoffice.Office.Common/Path/Current", false) xSvMgr = uno.getComponentContext().ServiceManager xConfigProvider = xSvMgr.createInstanceWithContext("com.sun.star.configuration.ConfigurationProvider", uno.getComponentContext()) xPropertyValue = PropertyValue() xPropertyValue.Name = "nodepath" xPropertyValue.Value = sNodeConfig if bUpdate: sService = "com.sun.star.configuration.ConfigurationUpdateAccess" else: sService = "com.sun.star.configuration.ConfigurationAccess" xSettings = xConfigProvider.createInstanceWithArguments(sService, (xPropertyValue,)) return xSettings g_ImplementationHelper = unohelper.ImplementationHelper() g_ImplementationHelper.addImplementation(FrenchDictionarySwitcher, 'dicollecte.FrenchDictionarySwitcher', ('com.sun.star.task.Job',)) |
Added gc_lang/fr/dictionnaire/_templates/ooo/DictionarySwitcher.save.py version [8b30bb88f9].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 | # -*- coding: utf8 -*- # French Dictionary Switcher # by Olivier R. # License: MPL 2 import unohelper import uno import sys import re #import os.path from com.sun.star.task import XJobExecutor from com.sun.star.awt import XActionListener from com.sun.star.awt import WindowDescriptor from com.sun.star.awt.WindowClass import MODALTOP from com.sun.star.awt.VclWindowPeerAttribute import OK, OK_CANCEL, YES_NO, YES_NO_CANCEL, RETRY_CANCEL, DEF_OK, DEF_CANCEL, DEF_RETRY, DEF_YES, DEF_NO from com.sun.star.beans import PropertyValue # XRay - API explorer from com.sun.star.uno import RuntimeException as _rtex def xray(myObject): try: sm = uno.getComponentContext().ServiceManager mspf = sm.createInstanceWithContext("com.sun.star.script.provider.MasterScriptProviderFactory", uno.getComponentContext()) scriptPro = mspf.createScriptProvider("") xScript = scriptPro.getScript("vnd.sun.star.script:XrayTool._Main.Xray?language=Basic&location=application") xScript.invoke((myObject,), (), ()) return except: raise _rtex("\nBasic library Xray is not installed", uno.getComponentContext()) # END Xray DEBUG = False if DEBUG and sys.platform.startswith('win'): import codecs sys.stdout = codecs.open("C:\_multidict_stdout.txt", "w", "utf-8") def handleException (ctx=None): import traceback '''Display exception in a message dialog''' s = '\n'.join(traceback.format_exception(sys.exc_type, sys.exc_value, sys.exc_traceback)) if not sys.platform.startswith('win'): # also print trace on stdout/stderr on non-Windows platform traceback.print_exc() else: # no default stdout/stderr on Windows print(s) if not ctx: return xSvMgr = ctx.ServiceManager xDesktop = xSvMgr.createInstanceWithContext('com.sun.star.frame.Desktop', ctx) xDoc = xDesktop.getCurrentComponent() xWindow = xDoc.CurrentController.Frame.ContainerWindow MessageBox(xWindow, s, 'Exception', 'errorbox') def MessageBox (xParentWin, sMsg, sTitle, sBoxType="messbox", MsgButtons=OK): if sBoxType not in ("messbox", "infobox", "errorbox", "warningbox", "querybox"): sBoxType = "messbox" # window properties aDescriptor = WindowDescriptor() aDescriptor.Type = MODALTOP aDescriptor.WindowServiceName = sBoxType aDescriptor.ParentIndex = -1 aDescriptor.Parent = xParentWin #aDescriptor.Bounds = Rectangle() aDescriptor.WindowAttributes = MsgButtons xTK = xParentWin.getToolkit() msgbox = xTK.createWindow(aDescriptor) msgbox.setMessageText(sMsg) msgbox.setCaptionText(sTitle) return msgbox.execute() LABELDICT = { "moderne": u"Moderne", "classique": u"Classique", "reforme1990": u"Réforme 1990", "toutesvariantes": u"Toutes variantes" } class FrenchDictionarySwitcher (unohelper.Base, XActionListener, XJobExecutor): def __init__ (self, ctx): self.ctx = ctx self.xSvMgr = self.ctx.ServiceManager self.container = None self.dialog = None self.xRB_m = None self.xRB_c = None self.xRB_r = None self.xRB_f = None self.sCurrentDic = '' self.sSelectedDic = '' def addWidget (self, name, wtype, x, y, w, h, **kwargs): widget = self.dialog.createInstance('com.sun.star.awt.UnoControl%sModel' % wtype) widget.Name = name widget.PositionX = x widget.PositionY = y widget.Width = w widget.Height = h for k, w in kwargs.items(): setattr(widget, k, w) self.dialog.insertByName(name, widget) return widget def run (self): # what is the current dictionary xSettings = getConfigSetting("/org.openoffice.Office.Linguistic/ServiceManager/Dictionaries/HunSpellDic_fr", True) xLocations = xSettings.getByName("Locations") m = re.search(r"fr-(\w*)\.(?:dic|aff)", xLocations[0]) self.sCurrentDic = m.group(1) # dialog self.dialog = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlDialogModel', self.ctx) self.dialog.Width = 200 self.dialog.Height = 280 self.dialog.Title = u"Orthographe française" # blabla sSubTitle = u"Choisissez un dictionnaire" sDicLabel_m = u"“Moderne”" sDicDescr_m = u"Ce dictionnaire propose l’orthographe telle qu’elle est écrite aujourd’hui le plus couramment. C’est le dictionnaire recommandé si le français n’est pas votre langue maternelle ou si vous ne désirez qu’une seule graphie correcte par mot." sDicLabel_c = u"“Classique” (recommandé)" sDicDescr_c = u"Il s’agit du dictionnaire “Moderne”, avec des graphies classiques en sus, certaines encore communément utilisées, d’autres désuètes. C’est le dictionnaire recommandé si le français est votre langue maternelle." sDicLabel_r = u"“Réforme 1990”" sDicDescr_r = u"Avec ce dictionnaire, seule l’orthographe réformée est reconnue. Attendu que bon nombre de graphies réformées sont considérées comme erronées par beaucoup, ce dictionnaire est déconseillé. Les graphies passées dans l’usage sont déjà incluses dans le dictionnaire “Moderne”." sDicLabel_t = u"“Toutes variantes”" sDicDescr_t = u"Ce dictionnaire contient les variantes graphiques, classiques, réformées, ainsi que d’autres plus rares encore. Ce dictionnaire est déconseillé à ceux qui ne connaissent pas très bien la langue française." # widgets padding = 10 hspace = 60 posY1 = 20; posY2 = posY1 + hspace; posY3 = posY2 + hspace; posY4 = posY3 + hspace; posY5 = posY4 + hspace; wwidth = 170 wheight = 20 wwidthdescr = 170 wheightdescr = 40 xFD1 = uno.createUnoStruct("com.sun.star.awt.FontDescriptor") xFD1.Height = 12 xFD1.Name = "Verdana" xFD2 = uno.createUnoStruct("com.sun.star.awt.FontDescriptor") xFD2.Height = 11 xFD2.Name = "Verdana" gbm = self.addWidget('groupbox', 'GroupBox', 5, 5, 190, 250, Label = sSubTitle, FontDescriptor = xFD1) # Note: the only way to group RadioButtons is to create them successively rbm_m = self.addWidget('rb-moderne', 'RadioButton', padding, posY1, wwidth, wheight, Label = sDicLabel_m, FontDescriptor = xFD2) self.xRB_m = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_m.setModel(rbm_m) rbm_c = self.addWidget('rb-classique', 'RadioButton', padding, posY2, wwidth, wheight, Label = sDicLabel_c, FontDescriptor = xFD2) self.xRB_c = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_c.setModel(rbm_c) rbm_r = self.addWidget('rb-reforme1990', 'RadioButton', padding, posY3, wwidth, wheight, Label = sDicLabel_r, FontDescriptor = xFD2) self.xRB_r = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_r.setModel(rbm_r) rbm_t = self.addWidget('rb-toutesvariantes', 'RadioButton', padding, posY4, wwidth, wheight, Label = sDicLabel_t, FontDescriptor = xFD2) self.xRB_t = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlRadioButton', self.ctx) self.xRB_t.setModel(rbm_t) label_m = self.addWidget('label_m', 'FixedText', 20, posY1+10, wwidthdescr, wheightdescr, Label = sDicDescr_m, MultiLine = True) label_c = self.addWidget('label_c', 'FixedText', 20, posY2+10, wwidthdescr, wheightdescr, Label = sDicDescr_c, MultiLine = True) label_r = self.addWidget('label_r', 'FixedText', 20, posY3+10, wwidthdescr, wheightdescr, Label = sDicDescr_r, MultiLine = True) label_t = self.addWidget('label_t', 'FixedText', 20, posY4+10, wwidthdescr, wheightdescr, Label = sDicDescr_t, MultiLine = True) self.setRadioButton(self.sCurrentDic) button = self.addWidget('select', 'Button', padding+50, posY5, 80, 14, Label = 'Utiliser ce dictionnaire') # container self.container = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.UnoControlDialog', self.ctx) self.container.setModel(self.dialog) self.container.getControl('select').addActionListener(self) # if self.sCurrentDic != "moderne": # self.container.getControl('rb-moderne').addActionListener(self) # if self.sCurrentDic != "classique": # self.container.getControl('rb-classique').addActionListener(self) # if self.sCurrentDic != "reforme1990": # self.container.getControl('rb-reforme1990').addActionListener(self) # if self.sCurrentDic != "toutesvariantes": # self.container.getControl('rb-toutesvariantes').addActionListener(self) self.container.setVisible(False) toolkit = self.xSvMgr.createInstanceWithContext('com.sun.star.awt.ExtToolkit', self.ctx) self.container.createPeer(toolkit, None) self.container.execute() def setRadioButton (self, sDic): if sDic == 'moderne': self.xRB_m.setState(True) elif sDic == 'classique': self.xRB_c.setState(True) elif sDic == 'reforme1990': self.xRB_r.setState(True) elif sDic == 'toutesvariantes': self.xRB_t.setState(True) else: pass def actionPerformed (self, actionEvent): try: if self.xRB_m.getState(): self.sSelectedDic = 'moderne' elif self.xRB_c.getState(): self.sSelectedDic = 'classique' elif self.xRB_r.getState(): self.sSelectedDic = 'reforme1990' elif self.xRB_t.getState(): self.sSelectedDic = 'toutesvariantes' else: # no dictionary selected pass self.container.endExecute() except: handleException(self.ctx) def trigger (self, args): try: dialog = FrenchDictionarySwitcher(self.ctx) dialog.run() if dialog.sSelectedDic and dialog.sCurrentDic != dialog.sSelectedDic: xSvMgr = uno.getComponentContext().ServiceManager xDesktop = xSvMgr.createInstanceWithContext('com.sun.star.frame.Desktop', self.ctx) xDoc = xDesktop.getCurrentComponent() xWindow = xDoc.CurrentController.Frame.ContainerWindow if dialog.sCurrentDic: # Modify the registry xSettings = getConfigSetting("/org.openoffice.Office.Linguistic/ServiceManager/Dictionaries/HunSpellDic_fr", True) xLocations = xSettings.getByName("Locations") v1 = xLocations[0].replace(dialog.sCurrentDic, dialog.sSelectedDic) v2 = xLocations[1].replace(dialog.sCurrentDic, dialog.sSelectedDic) #xSettings.replaceByName("Locations", xLocations) # ERROR, see line below uno.invoke(xSettings, "replaceByName", ("Locations", uno.Any("[]string", (v1, v2)))) xSettings.commitChanges() # message box sMsg = u"Vous avez choisi un nouveau dictionnaire\northographique pour la langue française.\n\n“%s” ⇒ “%s”\n\nFermez le logiciel (y compris le démarrage rapide)\net relancez-le." % (LABELDICT[dialog.sCurrentDic], LABELDICT[dialog.sSelectedDic]) MessageBox(xWindow, sMsg, u"Sélection d’un nouveau dictionnaire", "infobox") # # get package location (URL of this extension) # xCompCtx = uno.getComponentContext() # xPackageInformationProvider = xCompCtx.getByName("/singletons/com.sun.star.deployment.PackageInformationProvider") # sURL = xPackageInformationProvider.getPackageLocation("French.linguistic.resources.from.Dicollecte.by.OlivierR") # sDstFile = sURL + '/dictionaries.xcu' # sDstFile = sDstFile.replace('file:///', '').replace('%20', ' ') # sDstFile = os.path.normpath(sDstFile) # sTplFile = sDstFile + '.tpl.xml' # # # rewrite dictionaries.xcu # if os.path.isfile(sTplFile) and os.path.isfile(sDstFile): # with open(sTplFile, 'r') as hFile: # content = hFile.read() # hFile.close() # content = content.replace('{{dictionaryName}}', dialog.sSelectedDic) # with open(sDstFile, 'w') as hFile: # hFile.write(content) # hFile.close() # else: # sErrMsg = "" # if not os.path.isfile(sTplFile): # sErrMsg += u"File not found: %s\n" % sTplFile # if not os.path.isfile(sDstFile): # sErrMsg += u"File not found: %s\n" % sDstFile # if sErrMsg: # MessageBox(xWindow, sErrMsg, "ERROR", "error") else: MessageBox(xWindow, u"Couldn’t retrieve informations\nabout the current dictionary.", "ERROR", "errorbox") # xSpellChecker = xSvMgr.createInstanceWithContext('com.sun.star.linguistic2.SpellChecker', self.ctx) # xLocale = uno.createUnoStruct('com.sun.star.lang.Locale') # xLocale.Language = "fr" # xLocale.Country = "FR" # l = xSpellChecker.getSupportedServiceNames() # MessageBox(xWindow, " ".join(l), "DEBUG", "infobox") except: handleException(self.ctx) def getConfigSetting (sNodeConfig, bForUpdate): if bForUpdate: sService = "com.sun.star.configuration.ConfigurationUpdateAccess" else: sService = "com.sun.star.configuration.ConfigurationAccess" xConfigProvider = createUnoService("com.sun.star.configuration.ConfigurationProvider") xPropertyValue = PropertyValue() xPropertyValue.Name = "nodepath" xPropertyValue.Value = sNodeConfig xSettings = xConfigProvider.createInstanceWithArguments(sService, (xPropertyValue,)) return xSettings def createUnoService (serviceName): xSvMgr = uno.getComponentContext().ServiceManager return xSvMgr.createInstanceWithContext(serviceName, uno.getComponentContext()) g_ImplementationHelper = unohelper.ImplementationHelper() g_ImplementationHelper.addImplementation(FrenchDictionarySwitcher, 'dicollecte.FrenchDictionarySwitcher', ('com.sun.star.task.Job',)) |
Added gc_lang/fr/dictionnaire/_templates/ooo/README_fr.txt version [74069c5cbf].
> > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | _______________________________________________________________________________ RESSOURCES LINGUISTIQUES POUR LE FRANÇAIS version ${version} Olivier R. - dicollecte<at>free<dot>fr Dicollecte : http://www.dicollecte.org/ _______________________________________________________________________________ Cette extension contient plusieurs dictionnaires : - des dictionnaires orthographiques, - un thésaurus (dictionnaire des synonymes), - une table des règles de division des mots. Ces dictionnaires sont fournis sous des licences différentes. Lisez les différents fichiers README dans le répertoire /dictionaries pour en prendre connaissance. Pour participer à l’amélioration des dictionnaires, allez sur : http://www.dicollecte.org/home.php?prj=fr _______________________________________________________________________________ |
Added gc_lang/fr/dictionnaire/_templates/ooo/addons.xcu version [c46cc36987].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 | <?xml version="1.0" encoding="UTF-8"?> <oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:package="org.openoffice.Office" oor:name="Addons"> <node oor:name="AddonUI"> <node oor:name="OfficeMenuBarMerging"> <node oor:name="org.openoffice.Office.addon.FrenchDictionarySwitcher" oor:op="replace"> <node oor:name="S1" oor:op="replace"> <prop oor:name="MergePoint"> <value>.uno:ToolsMenu\.uno:LanguageMenu\.uno:Hyphenate</value> </prop> <prop oor:name="MergeCommand"> <value>AddAfter</value> </prop> <prop oor:name="MergeFallback"> <value>AddPath</value> </prop> <node oor:name="MenuItems"> <node oor:name="M1" oor:op="replace"> <prop oor:name="Context" oor:type="xs:string"> <value>com.sun.star.text.TextDocument</value> </prop> <prop oor:name="Title" oor:type="xs:string"> <value/> <value xml:lang="en-US">French spelling dictionaries…</value> <value xml:lang="fr">Dictionnaires orthographiques français…</value> <value xml:lang="ar">قواميس الهجاء الفرنسية</value> <value xml:lang="be">Французскія слоўнікі правапісу…</value> <value xml:lang="cs">Francouzské hláskování slovníky…</value> <value xml:lang="de">Französisch Rechtschreibwörterbücher…</value> <value xml:lang="eo">Franca ortografio vortaroj…</value> <value xml:lang="es">Diccionarios ortográfico francés…</value> <value xml:lang="da">Franske stavemåde ordbøger…</value> <value xml:lang="el">Γαλλικά λεξικά ορθογραφίας…</value> <value xml:lang="et">Prantsuse keele sõnastikud…</value> <value xml:lang="fi">Ranskan oikeinkirjoitus sanakirjoja…</value> <value xml:lang="he">מילוני איות צרפתים</value> <value xml:lang="hi">फ्रांसीसी वर्तनी शब्दकोशों</value> <value xml:lang="hu">French helyesírási szótárak…</value> <value xml:lang="id">Perancis ejaan kamus…</value> <value xml:lang="is">Franska orðabækur stafsetningu…</value> <value xml:lang="it">Dizionari ortografici francesi…</value> <value xml:lang="ko">프랑스어 맞춤법 사전</value> <value xml:lang="lv">Franču pareizrakstības vārdnīcas…</value> <value xml:lang="lt">Prancūzijos rašybos žodynai…</value> <value xml:lang="ja">フランス語のスペルチェック辞書</value> <value xml:lang="ms">Ejaan kamus Perancis…</value> <value xml:lang="nl">Franse spellingwoordenboeken…</value> <value xml:lang="no">Franske stavemåten ordbøker…</value> <value xml:lang="pl">Francuskie słowniki ortograficzne…</value> <value xml:lang="pt">Franceses dicionários de ortografia…</value> <value xml:lang="ro">Dicționare de ortografie franceză…</value> <value xml:lang="ru">Французские словари правописания…</value> <value xml:lang="sr">Француски правопис речници…</value> <value xml:lang="sv">Franska stavningsordlistor…</value> <value xml:lang="sw">Kifaransa spelling kamusi…</value> <value xml:lang="ta">பிரஞ்சு எழுத்துப்பிழை அகராதிகள்</value> <value xml:lang="th">พจนานุกรมการสะกดภาษาฝรั่งเศส</value> <value xml:lang="tr">Fransızca yazım denetimi sözlükleri…</value> <value xml:lang="uk">Французькі словники правопису…</value> <value xml:lang="vi">Pháp chính tả từ điển…</value> <value xml:lang="zh">法语拼写字典</value> </prop> <prop oor:name="URL" oor:type="xs:string"> <value>service:dicollecte.FrenchDictionarySwitcher</value> </prop> <prop oor:name="Target" oor:type="xs:string"> <value>_self</value> </prop> <prop oor:name="ImageIdentifier" oor:type="xs:string"> <value>%origin%/ui/french_flag_16.bmp</value> </prop> </node> </node> </node> </node> </node> </node> </oor:component-data> |
Added gc_lang/fr/dictionnaire/_templates/ooo/description.xml version [3615b9d98b].
> > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | <?xml version="1.0" encoding="UTF-8"?> <description xmlns="http://openoffice.org/extensions/description/2006" xmlns:d="http://openoffice.org/extensions/description/2006" xmlns:xlink="http://www.w3.org/1999/xlink"> <!-- http://wiki.services.openoffice.org/wiki/Extension_Dictionaries --> <!--<registration> <simple-license accept-by="admin" suppress-on-update="false" > <license-text xlink:href="dictionaries/README_fr.txt" lang="fr" /> </simple-license> </registration>--> <version value="${version}" /> <identifier value="French.linguistic.resources.from.Dicollecte.by.OlivierR" /> <display-name> <name lang="fr">Dictionnaires français.</name> </display-name> <platform value="all" /> <dependencies> <OpenOffice.org-minimal-version value="3.2" d:name="OpenOffice.org 3.2" /> </dependencies> <icon> <default xlink:href="french_flag.png" /> </icon> <publisher> <name xlink:href="http://www.dicollecte.org/" lang="fr">Dicollecte</name> </publisher> <!--<update-information> <src xlink:href="http://www.dicollecte.org/grammalecte/oxt/dictionaries.update.xml" /> </update-information>--> </description> |
Added gc_lang/fr/dictionnaire/_templates/ooo/dictionaries.xcu version [fb466201bf].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | <?xml version="1.0" encoding="UTF-8"?> <oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:name="Linguistic" oor:package="org.openoffice.Office"> <node oor:name="ServiceManager"> <node oor:name="Dictionaries"> <node oor:name="HunSpellDic_fr" oor:op="fuse"> <prop oor:name="Locations" oor:type="oor:string-list"> <value>%origin%/dictionaries/fr-classique.aff %origin%/dictionaries/fr-classique.dic</value> </prop> <prop oor:name="Format" oor:type="xs:string"> <value>DICT_SPELL</value> </prop> <prop oor:name="Locales" oor:type="oor:string-list"> <value>fr-FR fr-BE fr-CA fr-CH fr-LU fr-MC fr-BF fr-CI fr-SN fr-ML fr-NE fr-TG fr-BJ</value> <!-- France, Belgique, Canada, Suisse, Luxembourg, Monaco --> <!-- Burkina Faso, Côte d’Ivoire, Sénégal, Mali, Niger, Togo, Benin --> </prop> </node> <node oor:name="HyphDic_fr" oor:op="fuse"> <prop oor:name="Locations" oor:type="oor:string-list"> <value>%origin%/dictionaries/hyph_fr.dic</value> </prop> <prop oor:name="Format" oor:type="xs:string"> <value>DICT_HYPH</value> </prop> <prop oor:name="Locales" oor:type="oor:string-list"> <value>fr-FR fr-BE fr-CA fr-CH fr-LU fr-MC fr-BF fr-CI fr-SN fr-ML fr-NE fr-TG fr-BJ</value> </prop> </node> <node oor:name="ThesDic_fr" oor:op="fuse"> <prop oor:name="Locations" oor:type="oor:string-list"> <value>%origin%/dictionaries/thes_fr.dat %origin%/dictionaries/thes_fr.idx</value> </prop> <prop oor:name="Format" oor:type="xs:string"> <value>DICT_THES</value> </prop> <prop oor:name="Locales" oor:type="oor:string-list"> <value>fr-FR fr-BE fr-CA fr-CH fr-LU fr-MC fr-BF fr-CI fr-SN fr-ML fr-NE fr-TG fr-BJ</value> </prop> </node> </node> </node> </oor:component-data> |
Added gc_lang/fr/dictionnaire/_templates/ooo/dictionaries.xcu.tpl.xml version [240ddc48f8].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | <?xml version="1.0" encoding="UTF-8"?> <oor:component-data xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" oor:name="Linguistic" oor:package="org.openoffice.Office"> <node oor:name="ServiceManager"> <node oor:name="Dictionaries"> <node oor:name="HunSpellDic_fr-multidict" oor:op="fuse"> <prop oor:name="Locations" oor:type="oor:string-list"> <value>%origin%/dictionaries/fr-{{dictionaryName}}.aff %origin%/dictionaries/fr-{{dictionaryName}}.dic</value> </prop> <prop oor:name="Format" oor:type="xs:string"> <value>DICT_SPELL</value> </prop> <prop oor:name="Locales" oor:type="oor:string-list"> <value>fr-FR fr-BE fr-CA fr-CH fr-LU fr-MC fr-BF fr-CI fr-SN fr-ML fr-NE fr-TG fr-BJ</value> <!-- France, Belgique, Canada, Suisse, Luxembourg, Monaco --> <!-- Burkina Faso, Côte d’Ivoire, Sénégal, Mali, Niger, Togo, Benin --> </prop> </node> <node oor:name="HyphDic_fr" oor:op="fuse"> <prop oor:name="Locations" oor:type="oor:string-list"> <value>%origin%/dictionaries/hyph_fr.dic</value> </prop> <prop oor:name="Format" oor:type="xs:string"> <value>DICT_HYPH</value> </prop> <prop oor:name="Locales" oor:type="oor:string-list"> <value>fr-FR fr-BE fr-CA fr-CH fr-LU fr-MC fr-BF fr-CI fr-SN fr-ML fr-NE fr-TG fr-BJ</value> </prop> </node> <node oor:name="ThesDic_fr" oor:op="fuse"> <prop oor:name="Locations" oor:type="oor:string-list"> <value>%origin%/dictionaries/thes_fr.dat %origin%/dictionaries/thes_fr.idx</value> </prop> <prop oor:name="Format" oor:type="xs:string"> <value>DICT_THES</value> </prop> <prop oor:name="Locales" oor:type="oor:string-list"> <value>fr-FR fr-BE fr-CA fr-CH fr-LU fr-MC fr-BF fr-CI fr-SN fr-ML fr-NE fr-TG fr-BJ</value> </prop> </node> </node> </node> </oor:component-data> |
Added gc_lang/fr/dictionnaire/_templates/ooo/ds_strings.py version [b148ee2b72].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 | # -*- encoding: UTF-8 -*- dStrings = { "fr": { "title": u"Orthographe française", "choose": u"Choisissez un dictionnaire", "select": u"Utiliser ce dictionnaire", "moderne": u"“Moderne”", "classique": u"“Classique” (recommandé)", "reforme1990": u"“Réforme 1990”", "toutesvariantes": u"“Toutes variantes”", "descModern": u"Ce dictionnaire propose l’orthographe telle qu’elle est écrite aujourd’hui le plus couramment. C’est le dictionnaire recommandé si le français n’est pas votre langue maternelle ou si vous ne désirez qu’une seule graphie correcte par mot.", "descClassic": u"Il s’agit du dictionnaire “Moderne”, avec des graphies classiques en sus, certaines encore communément utilisées, d’autres désuètes. C’est le dictionnaire recommandé si le français est votre langue maternelle.", "descReform": u"Avec ce dictionnaire, seule l’orthographe réformée est reconnue. Attendu que bon nombre de graphies réformées sont considérées comme erronées par beaucoup, ce dictionnaire est déconseillé. Les graphies passées dans l’usage sont déjà incluses dans le dictionnaire “Moderne”.", "descAllvar": u"Ce dictionnaire contient les variantes graphiques, classiques, réformées, ainsi que d’autres plus rares encore. Ce dictionnaire est déconseillé à ceux qui ne connaissent pas très bien la langue française.", "restart": u"Le changement ne sera effectif qu’après le redémarrage du logiciel.", "error": u"Erreur : impossible de savoir quel dictionnaire est actif." }, "en": { "title": u"French spelling", "choose": u"Choose a dictionary", "select": u"Use this dictionary", "moderne": u"“Modern”", "classique": u"“Classic” (recommended)", "reforme1990": u"“Reform 1990”", "toutesvariantes": u"“All variants”", "descModern": u"This dictionary offers the French spelling as it is written nowadays most often. This is the recommended dictionary if French is not your mother tongue or if you want only one correct spelling per word.", "descClassic": u"This is the “Modern” dictionary plus classical spellings, some of them still widely used, others obsolete. This is the recommended dictionary if French is your native language.", "descReform": u"With this dictionary, only the reformed spelling is recognized. As many of reformed spellings are considered erronous for many people, this dictionary is unadvised. Reformed spellings commonly used are already included in the “Modern” dictionary.", "descAllvar": u"This dictionary contains all spelling variants, classical and reformed, and some others even rarer. This dictionary is unadvised for those who doesn’t know very well the French language.", "restart": u"The modification will be effective only after restarting the software.", "error": u"Error: enable to retrieve information about the current dictionary." } } |
Added gc_lang/fr/dictionnaire/_templates/ooo/french_flag.png version [960f4814b1].
cannot compute difference between binary files
Added gc_lang/fr/dictionnaire/_templates/ooo/french_flag_16.bmp version [f86cbbe4c8].
cannot compute difference between binary files
Added gc_lang/fr/dictionnaire/_templates/ooo/french_flag_16.png version [d1c910d71d].
cannot compute difference between binary files
Added gc_lang/fr/dictionnaire/_templates/ooo/manifest.xml version [d52a9a2be4].
> > > > > > > > | 1 2 3 4 5 6 7 8 | <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE manifest:manifest PUBLIC "-//OpenOffice.org//DTD Manifest 1.0//EN" "Manifest.dtd"> <manifest:manifest xmlns:manifest="http://openoffice.org/2001/manifest"> <manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data" manifest:full-path="dictionaries.xcu"/> <manifest:file-entry manifest:media-type="application/vnd.sun.star.package-bundle-description" manifest:full-path="package-description.txt"/> <manifest:file-entry manifest:media-type="application/vnd.sun.star.configuration-data" manifest:full-path="ui/addons.xcu"/> <manifest:file-entry manifest:media-type="application/vnd.sun.star.uno-component;type=Python" manifest:full-path="DictionarySwitcher.py"/> </manifest:manifest> |
Added gc_lang/fr/dictionnaire/_templates/ooo/package-description.txt version [00d0e64611].
> > > | 1 2 3 | Dictionnaires ${version} • Synonymes 2.3 • Césures 3.0 Quatre dictionnaires orthographiques existent : “Moderne”, “Classique”, “Réforme 1990”, “Toutes variantes”. Pour changer de dictionnaire, allez dans le menu Outils > Langue > Dictionnaires français. |
Added gc_lang/fr/dictionnaire/césures/README_hyph_fr-2.9.txt version [ffc9ffe80a].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | _____________________________________________________________________________ Motifs de division des mots pour le français (fr) Version 2.9 Licence : GNU LGPL. Origine : Basé sur les motifs de division de TeX *hyph-fr.tex*, version renommée (juin 2008) du fichier *frhyph.tex* (V2.12, 2002/12/11) pour la cohérence avec d'autres fichiers de motifs de division de la collection hyph-utf8. Voir http://tug.org/tex-hyphen pour plus d'informations. Les motifs de division de TeX sont publiés sous la licence LaTeX Project Public License (LPPL) -- http://www.latex-project.org/lppl.txt Licence : Les adaptations pour OpenOffice.org sont publiées sous la licence GNU Lesser General Public License (LGPL) version 2.1 ou supérieure -- http://www.gnu.org/licenses/ Auteurs : 2.9 Marc Lodewijck <mlodewijck@gmail.com> 2.0 Paul Pichaureau <paul.pichaureau@alcandre.net> 1.0 Blaise Drayer <blaise@drayer.ch> Journal : 2.9 Nouvelle version révisée et augmentée : + Traitement des noms composés à trait d'union + Redressement de motifs altérés 2.0 Traitement des mots avec apostrophe 1.0 Première conversion Ce dictionnaire devrait être conforme à toutes les variantes régionales du français. _____________________________________________________________________ French word hyphenation patterns Version 2.9 Language: French (fr). License: GNU LGPL. Origin: Based on the TeX hyphenation tables *hyph-fr.tex*, renamed (June 2008) from *frhyph.tex* (V2.12, 2002/12/11) for consistency with other files with hyphenation patterns in hyph-utf8 package. See http://tug.org/tex-hyphen for more details. The TeX hyphenation tables are released under the LaTeX Project Public License (LPPL) -- http://www.latex-project.org/lppl.txt License: OpenOffice.org adaptions of this package are licensed under the GNU Lesser General Public License (LGPL) version 2.1 or higher -- http://www.gnu.org/licenses/ Authors: 2.9 Marc Lodewijck <mlodewijck@gmail.com> 2.0 Paul Pichaureau <paul.pichaureau@alcandre.net> 1.0 Blaise Drayer <blaise@drayer.ch> Log: 2.9 New revised and expanded version: + Processing of hyphenated compounds + Correction of altered patterns 2.0 Fix for words with apostrophe 1.0 First conversion This dictionary is based on syllable matching patterns and therefore should be usable under other variations of French. |
Added gc_lang/fr/dictionnaire/césures/README_hyph_fr-3.0.txt version [b9b9e15d66].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 | _____________________________________________________________________________ Motifs de division des mots pour le français (fr) Version 3.0.1 Licence : GNU LGPL. Origine : Basé sur les motifs de division de TeX *hyph-fr.tex*, version renommée (juin 2008) du fichier *frhyph.tex* (V2.12, 2002/12/11) pour la cohérence avec d'autres fichiers de motifs de division de la collection hyph-utf8. Voir http://tug.org/tex-hyphen pour plus d'informations. Les motifs de division de TeX sont publiés sous la licence LaTeX Project Public License (LPPL) -- http://www.latex-project.org/lppl.txt Licence : Les adaptations pour OpenOffice.org sont publiées sous la licence GNU Lesser General Public License (LGPL) version 2.1 ou supérieure -- http://www.gnu.org/licenses/ Auteurs : 3.0 Marc Lodewijck <mlodewijck@gmail.com> 2.0 Paul Pichaureau <paul.pichaureau@alcandre.net> 1.0 Blaise Drayer <blaise@drayer.ch> Journal : 3.0.1 Correction d’un bug: COUMPOUNDLEFTHYPHENMIN -> COMPOUNDLEFTHYPHENMIN 3.0 Nouvelle version révisée et augmentée : + Conversion au format de codage Unicode UTF-8 + Traitement des noms composés à trait d'union + Redressement de motifs altérés 2.0 Traitement des mots avec apostrophe 1.0 Première conversion Ce dictionnaire devrait être conforme à toutes les variantes régionales du français. _____________________________________________________________________ French word hyphenation patterns Version 3.0 Language: French (fr). License: GNU LGPL. Origin: Based on the TeX hyphenation tables *hyph-fr.tex*, renamed (June 2008) from *frhyph.tex* (V2.12, 2002/12/11) for consistency with other files with hyphenation patterns in hyph-utf8 package. See http://tug.org/tex-hyphen for more details. The TeX hyphenation tables are released under the LaTeX Project Public License (LPPL) -- http://www.latex-project.org/lppl.txt License: OpenOffice.org adaptions of this package are licensed under the GNU Lesser General Public License (LGPL) version 2.1 or higher -- http://www.gnu.org/licenses/ Authors: 3.0 Marc Lodewijck <mlodewijck@gmail.com> 2.0 Paul Pichaureau <paul.pichaureau@alcandre.net> 1.0 Blaise Drayer <blaise@drayer.ch> Log: 3.0.1 Bug fix: COUMPOUNDLEFTHYPHENMIN -> COMPOUNDLEFTHYPHENMIN 3.0 New revised and expanded version: + Conversion to UTF-8 Unicode encoding + Processing of hyphenated compounds + Correction of altered patterns 2.0 Fix for words with apostrophe 1.0 First conversion This dictionary is based on syllable matching patterns and therefore should be usable under other variations of French. |
Added gc_lang/fr/dictionnaire/césures/frhyph.tex version [c1857b37d2].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 | % frhyph.tex % French hyphenation patterns %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % This file is available for free and can used and redistributed % asis for free. Modified versions should have another name. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \message{frhyph.tex - French hyphenation patterns (V2.12) <2002/12/11>} % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % *BEFORE* using this file *PLEASE* run checksum on it: % % checksum -v frhyph.tex % % to make sure that it hasn't been damaged. % % Then if you notice anything wrong in french hyphenation please report to % % R. Bastian, D. Flipo, B. Gaulle at the email address: % % cesure-l@gutenberg.eu.org % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% checksum = "37208 1458 3078 34821" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%% The most famous good guys who worked hard to obtain something usable. % Jacques Desarmenien, Universite de Strasbourg : % - << how to run TeX in a French environment: hyphenation, fonts, % typography. >> in Tugboat, 5 (1984) 91-102. and TeX85 conference % - << La division par ordinateur des mots francais : % application a TeX >> in TSI vol. 5 No 4, 1986 (C) AFCET- % Gauthier-Villars % Norman Buckle, UQAH (nb; many additions) % Michael Ferguson, INRS-Telecommunications (mjf) June 1988 % Justin Bur, Universite de Montreal (jbb; checked against original list) % all patterns including apostrophe missing from nb list % after that, GUTenberg and specially Daniel Flipo and Bernard Gaulle % did their best effort to improve the list of patterns. % % ----------------------------------------------------------------- % % Adaption of these patterns for % - TeX Version 3.x and MLTeX 3.x (2.x) % and % - all fonts in T1/`Cork' and/or CM/OT1 encoding % by Bernd Raichle 1996/08/28 (using ideas from `ghyph31.tex' % as of 1994-02-13 maintained by Bernd Raichle). % (An adaption for the old MLTeX 2.x exists but can not be % tested in lack of an executable.) % % ----------------------------------------------------------------- % % The LaTeX2e identification of this file is done with the % \ProvidesFile declaration. The group and \expandafter % constructions keep \ProvidesFile undefined if this file % is not used with LaTeX2e. % \begingroup \expandafter\expandafter\expandafter\endgroup \expandafter\ifx\csname ProvidesFile\endcsname\relax \else % unfortnately Babel 3.6 destroys standard LaTeX \ProvidesFile command % thus i check if it's still the good one. --bg 97/04/08 \def\PFnormaldef#1{% \begingroup \catcode`\ 10 % \@makeother\/% \@ifnextchar[{\@providesfile{#1}}{\@providesfile{#1}[]}} \ifx\PFnormaldef\ProvidesFile \ProvidesFile{frhyph.tex}[2002/12/11 % French hyphenation patterns v2.12] \fi \fi % % Next we define some commands which are used inside the patterns. % To keep them local, we enclose the rest of the file in a group % (The \patterns command globally changes the hyphenation trie!). % \begingroup % % Make sure that neither quote nor doublequote are active: \catcode`\'=12 \catcode`\"=12 % % % Because ^^e4 is used in the following macros which is read by % TeX 2.x as ^^e or %, the comment character of TeX, some trick % has to be found to avoid this problem. The same is true for % the normally illegal character ^^? in the TeX 2.x code. % Therefore in the code the exclamationmark ! is used instead of % the circumflex ^ and its \catcode is set appropriately % (normally \catcode`\!=12, in the code \catcode`\!=7). % % The following \catcode, \lccode assignments and macro definitions % are defined in such a way that the following \pattern{...} list % can be used for both, (ML)TeX 2.x and (ML)TeX 3.x. % To implement this, distinguish version 2.x and 3.x of TeX: % \ifnum`\@=`\^^40 % true => TeX 3.x % % Assign appropriate \catcode and \lccode values for all % accented characters used in the patterns: \catcode"E0=11 \lccode"E0="E0 % \`a \catcode"E2=11 \lccode"E2="E2 % \^a \catcode"E7=11 \lccode"E7="E7 % \c{c} \catcode"E8=11 \lccode"E8="E8 % \`e \catcode"E9=11 \lccode"E9="E9 % \'e \catcode"EA=11 \lccode"EA="EA % \^e \catcode"EB=11 \lccode"EB="EB % \"e (*unused*) \catcode"EE=11 \lccode"EE="EE % \^{\i} \catcode"EF=11 \lccode"EF="EF % \"{\i} \catcode"F4=11 \lccode"F4="F4 % \^o \catcode"F7=11 \lccode"F7="F7 % \oe{} \catcode"F9=11 \lccode"F9="F9 % \`u (*unused*) \catcode"FB=11 \lccode"FB="FB % \^u \catcode"FC=11 \lccode"FC="FC % \"u (*unused*) \catcode"B8=11 \lccode"B8="B8 % \"y (*unused*) % \catcode`\!=7 % use !!xy instead of ^^xy % % Define the accent macros in such a way that they % expand to single letters in font encoding T1. \def\E{\errmessage{Hyphenation pattern file corrupted}} \def\`#1{\ifx#1a!!e0\else \ifx#1e!!e8\else \E \fi\fi} \def\'#1{\ifx#1e!!e9\else \E \fi} \def\^#1{\ifx#1a!!e2\else \ifx#1e!!ea% \else \ifx#1i!!ee\else \ifx#1o!!f4% \else \ifx#1u!!fb\else \E \fi\fi\fi\fi\fi} \def\"#1{\ifx#1i!!ef\else \ifx#1e!!eb% \else \ifx#1o!!f6\else \E \fi\fi\fi} \def\c#1{\ifx#1c!!e7\else \E \fi} \def\oe{!!f7}% T1 encoded \oe % For \oe which exists in T1 _and_ OT1 encoded fonts but with % different glyph codes, patterns for both glyphs are included. % Thus you can use either T1 encoded fonts, or OT1 encoded fonts % and MLTeX's character substitution definition. \def\n#1{#1} \catcode'33=11 \lccode'33='33 % \oe \def\oeOT{!![}% OT1 encoded \oe %{]} brace hack % \catcode`\!=12 % \else % TeX 2 % \expandafter\ifx\csname starthyph\endcsname\relax % MLTeX 2.x? \message{This is TeX version 2.x without the MLTeX extensions.} \message{I'm sorry, you cannot use these hyphenation patterns.} \message{To process the french hyphenation patterns you need either} \message{TeX version 3.x, MLTeX 3.x, or MLTeX based on TeX 2.x.} \errmessage{I will ignore the hyphenation patterns.} \endgroup \csname fi\endcsname\csname fi\endcsname\endinput \fi % % Untested macros for MLTeX v2.x replaced by the following message: \message{This is MLTeX based on TeX version 2.x. To use these} \message{patterns please get in contact with the maintainers} \message{mentioned in the comment at the top of this file.} \errmessage{I will ignore the hyphenation patterns.} \endgroup \csname fi\endcsname\endinput % \fi % \lccode`\'=`\' % \patterns{ %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%* 2'2 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%a .a4 'a4 .\^a4 '\^a4 ab2h % df-bg 1998/02/07 for abhorrer .ab3r\'ea 'ab3r\'ea ad2h % df-bg 1998/02/07 for adh\`esion & co a1\`e2dre .ae3s4ch 'ae3s4ch 1alcool a2l1algi .amino1a2c 'amino1a2c .ana3s4tr 'ana3s4tr 1a2nesth\'esi .anti1a2 'anti1a2 .anti1e2 'anti1e2 .anti1\'e2 .anti2enne 'anti2enne 'anti1\'e2 .anti1s2 'anti1s2 .apo2s3ta 'apo2s3ta apo2s3tr archi1\'e2pis .as2ta 'as2ta a2s3tro %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%b 1ba 1b\^a .bai2se3main % hyphen disappeared from french 5/2/94 1be 1b\'e 1b\`e 1b\^e 4be. 4bes. 2bent. % mute syllable: tombent (df) 22/02/94 1bi 1b\^i .bi1a2c .bi1a2t % like .tri1a2t for tri-athlon bg 12/27/93 .bi1au .bio1a2 .bi2s1a2 .bi1u2 1b2l 4ble. 4bles. 2blent. % mute syllable: troublent (df) 28/02/94 1bo 1b\^o 1b2r 4bre. 4bres. 2brent. % mute syllable: palabrent (df) 28/02/94 1bu 1b\^u 1by %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%c 1\c{c} 1ca 1c\^a ca3ou3t2 % for caoutchou... added 3/1/94 df-bg 1ce 1c\'e 1c\`e 1c\^e 4ce. 4ces. % words ending with -cent (df) 22/02/94 2cent. ja3cent. ac3cent. \'e3cent. munifi3cent. r\'eti3cent. privatdo3cent. inno3cent. es3cent. acquies4cent. is3cent. immis4cent. % .ch4 1c2h 4ch. 2chb 4che. 4ches. 2chent. % mute syllable: touchent (df) 22/02/94 .ch\`e2vre3feuille % hyphen disappeared from french 5/2/94 2chg ch2l 4chle. 4chles. chlo2r3a2c chlo2r3\'e2t 2chm 2chn 2chp ch2r 4chre. 4chres. 2chs 2cht 2chw 1ci 1c\^i .ci2s1alp 1c2k 4ck. 2ckb 4cke. 4ckes. 2ckent. % mute syllable: stockent (df) 22/02/94 2ckf 2ckg 2ck3h 2ckp 2cks 2ckt 1c2l 4cle. 4cles. 2clent. % mute syllable: encerclent (df) 28/02/94 1co 1c\^o co1acc co1acq co1a2d co1ap co1ar co1assoc co1assur co1au co1ax 1c\oe0 % final zero essential to terminate cs \n{1c\oeOT} % for \oe in OT1 _and_ T1 font encoding co1\'e2 co1ef co1en co1ex .con4 % missing from nb list .cons4 % missing from nb list .contre1s2c .contre3ma\^itre % hyphen disappeared from french 5/2/94 co2nurb .co1o2 .co2o3lie 1c2r 4cre. 4cres. 2crent. % mute syllable: massacrent (df) 28/02/94 1cu 1c\^u 1cy .cul4 % -- as .con4 .cons4 (march 92) %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%d 1d' 1da 1d\^a .dacryo1a2 d1d2h 1de 1d\'e 1d\`e 1d\^e 4de. 4des. % words ending with -dent (df) 22/02/94 2dent. d\'eca3dent. \'e3dent. cci3dent. inci3dent. confi3dent. tri3dent. dissi3dent. chien3dent. .ar3dent. impu3dent. pru3dent. % .d\'e1a2 .d\'e1io .d\'e1o2 .d\'e2s % originaly in JD file %.d\'e2s1a2 removed 09/17/92 because wrong for the % original JD 500 words test .d\'e3s2a3cr .d\'es2a3m % .d\'es2a2mi introduced 09/17/92 bec. i % can't see why d\'esamidonner ran in JD. % Moved to .d\'es2a3m df 12/27/93. .d\'e3s2a3tell .d\'e3s2astr .d\'e3s2c % 1 moved 3 due to .d\'e2s 09/17/92 %.d\'e2s1e2 removed 09/17/92 because wrong for the % original JD 500 words test .d\'e2s1\'e2 .d\'e3s2\'e3gr .d\'e3s2ensib .d\'e3s2ert .d\'e3s2exu %.d\'e2s3h removed 09/17/92 because wrong for the % original JD 500 words test .d\'e2s1i2 .d\'e3s2i3d .d\'e3s2i3gn .d\'e3s2i3li .d\'e3s2i3nen .d\'e3s2invo .d\'e3s2i3r .d\'e3s2ist %.d\'e2s1o2 removed 09/17/92 because wrong for the % original JD 500 words test .d\'e3s2o3d\'e .d\'e2s1\oe0 % final zero essential to terminate cs \n{.d\'e2s1\oeOT} % for \oe in OT1 _and_ T1 font encoding .d\'e3s2o3l .d\'e3s2o3pil .d\'e3s2orm .d\'e3s2orp .d\'e3s2oufr .d\'e3s2p % 1 moved 3 due to .d\'e2s 09/17/92 .d\'e3s2t % 1 moved 3 due to .d\'e2s 09/17/92 .d\'e2s1u2n 3d2hal 3d2houd 1di 1d\^i di2s3cop .di1a2c\'e .di1a2cid .di1ald .di1a2mi .di1a2tom .di1e2n .di2s3h 2dlent. % mute syllable: jodlent (df) 28/02/94 1do 1d\^o 1d2r 4dre. 4dres. 2drent. % mute syllable: engendrent (df) 28/02/94 d1s2 1du 1d\^u 1dy .dy2s3 .dy2s1a2 .dy2s1i2 .dy2s1o2 % missing from nb list .dy2s1u2 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%e .e4 'e4 .\^e4 '\^e4 .\'e4 '\'e4 .\`e4 '\`e4 \'ed2hi % df-bg 1998/02/07 for r\'edhibitoire 1\'e2drie 1\'e2drique 1\'e2lectr 1\'e2l\'ement .en1a2 'en1a2 1\'e2nerg e2n1i2vr .en1o2 'en1o2 \'epi2s3cop \'epi3s4cope e2s3cop .eu2r1a2 'eu2r1a2 eu1s2tat extra1 extra2c extra2i %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%f 1fa 1f\^a 1fe 1f\'e 1f\`e 1f\^e 4fe. 4fes. 2fent. % mute syllable: agrafent chauffent (df) 22/02/94 % 1fi 1f\^i 1f2l 4fle. 4fles. 2flent. % mute syllable: gonflent (df) 28/02/94 1fo 1f\^o 1f2r 4fre. 4fres. 2frent. % mute syllable: balafrent (df) 28/02/94 f1s2 1fu 1f\^u 1fy %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%g 1ga 1g\^a 1ge 1g\'e 1g\`e 1g\^e 4ge. 4ges. % words ending with -gent (df) 22/02/94 2gent. r\'e3gent. entre3gent. indi3gent. dili3gent. intelli3gent. indul3gent. tan3gent. rin3gent. contin3gent. .ar3gent. 'ar3gent. ser3gent. ter3gent. r\'esur3gent. % 1g2ha 1g2he 1g2hi 1g2ho 1g2hy 1gi 1g\^i 1g2l 4gle. 4gles. 2glent. % mute syllable: meuglent (df) 28/02/94 1g2n 'a2g3nat % (df) 16/01/02 .a2g3nat % (df) 16/01/02 a2g3nos % (df) 16/01/02 (pattern dia2g3n deleted) co2g3niti % (df) 16/01/02 'i2g3n\'e % (df) 16/01/02 .i2g3n\'e % (df) 16/01/02 'i2g3ni % (df) 16/01/02 .i2g3ni % (df) 16/01/02 .ma2g3nicide % (df) 16/01/02 .ma2g3nificat % (df) 16/01/02 .ma2g3num % (df) 16/01/02 o2g3nomoni % (df) 16/01/02 o2g3nosi % (df) 16/01/02 .pro2g3nath % (df) 16/01/02 pu2g3nable % (df) 16/01/02 pu2g3nac % (df) 16/01/02 .sta2g3n .syn2g3nath % (df) 16/01/02 wa2g3n 4gne. 4gnes. 2gnent. % mute syllable: accompagnent (df) 28/02/94 1go 1g\^o 1g2r 4gre. 4gres. 2grent. % mute syllable: immigrent (df) 28/02/94 1gu 1g\^u g1s2 4gue. 4gues. % words ending with -guent (df) 22/02/94 2guent. .on3guent. 'on3guent. % 1gy %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%h 1ha 1h\^a 1he 1h\'e 1h\`e 1h\^e h\'emi1\'e h\'emo1p2t 4he. 4hes. 1hi 1h\^i 1ho 1h\^o 1hu 1h\^u 1hy hypera2 hypere2 hyper\'e2 hyperi2 hypero2 hypers2 hype4r1 hyperu2 hypo1a2 hypo1e2 % missing from nb list hypo1\'e2 hypo1i2 hypo1o2 hypo1s2 hypo1u2 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%i .i4 'i4 .\^i4 '\^i4 i1algi i1arthr i1\`e2dre % ill patterns missing from nb list il2l cil3l rcil4l ucil4l vacil4l gil3l hil3l lil3l l3lion mil3l mil4let \'emil4l semil4l rmil4l armil5l capil3l papil3la papil3le papil3li papil3lom pupil3l piril3l thril3l cyril3l ibril3l pusil3l .stil3l distil3l instil3l fritil3l boutil3l vanil3lin vanil3lis vil3l avil4l chevil4l uevil4l uvil4l xil3l % end of ill patterns 1informat % missing from nb list .in1a2 'in1a2 .in2a3nit 'in2a3nit .in2augur 'in2augur .in1e2 'in1e2 .in1\'e2 'in1\'e2 .in2effab % missing from nb list 'in2effab .in2\'e3lucta 'in2\'e3lucta .in2\'e3narra 'in2\'e3narra .in2ept 'in2ept .in2er 'in2er .in2exora % missing from nb list 'in2exora .in1i2 'in1i2 .in2i3miti 'in2i3miti .in2i3q 'in2i3q .in2i3t 'in2i3t .in1o2 'in1o2 .in2o3cul 'in2o3cul .in2ond 'in2ond .in1s2tab 'in1s2tab 'inte4r3 .intera2 'intera2 .intere2 'intere2 .inter\'e2 'inter\'e2 .interi2 'interi2 .intero2 'intero2 .inte4r3 .interu2 'interu2 .inters2 'inters2 .in1u2 'in1u2 .in2uit 'in2uit .in2u3l 'in2u3l io1a2ct i1oxy i1s2tat %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%j 1j 2jk 4je. 4jes. 2jent. % mute syllable: gal\`ejent (df) 22/02/94 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%k 1ka 1k\^a 1ke 1k\'e 1k\`e 1k\^e 4ke. 4kes. 2kent. % mute syllable: jerkent (df) 22/02/94 1k2h 4kh. .kh4 1ki 1k\^i 1ko 1k\^o 1k2r 1ku 1k\^u 1ky %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%l 1la 1l\^a 1l\`a la2w3re 1le 1l\'e 1l\`e 1l\^e 4le. 4les. % words ending with -lent (df) 22/02/94 2lent. .ta3lent. iva3lent. \'equiva4lent. monova3lent. polyva3lent. re3lent. .do3lent. indo3lent. inso3lent. turbu3lent. succu3lent. f\'ecu3lent. trucu3lent. opu3lent. corpu3lent. ru3lent. sporu4lent. % 1li 1l\^i 1lo 1l\^o l1s2t 1lu 1l\^u 1ly %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%m 1ma 1m\^a .ma2c3k .macro1s2c .ma2l1a2dres .ma2l1a2dro .ma2l1ais\'e .ma2l1ap .ma2l1a2v .ma2l1en .ma2l1int .ma2l1oc .ma2l1o2d .ma2r1x % nb (jbb: ?) 1me 1m\'e 1m\`e 1m\^e .m\'e2g1oh .m\'e2sa % missing from nb list .m\'e3san % missing from nb list .m\'e2s1es .m\'e2s1i .m\'e2s1u2s .m\'eta1s2ta 4me. 4mes. % words ending with -ment (df) 22/02/94 \^a2ment. da2ment. fa2ment. amalga2ment. cla2ment. ra2ment. temp\'era3ment. ta2ment. testa3ment. qua2ment. \`e2ment. car\^e2ment. diaphrag2ment. ryth2ment. ai2ment. rai3ment. ab\^i2ment. \'eci2ment. vidi2ment. subli2ment. \'eli2ment. reli2ment. mi2ment. ani2ment. veni2ment. ri2ment. d\'etri3ment. nutri3ment. inti2ment. esti2ment. l2ment. flam2ment. gram2ment. .gem2ment. om2ment. .com3ment. \^o2ment. slalo2ment. chro2ment. to2ment. ar2ment. .sar3ment. er2ment. antifer3ment. .ser3ment. fir2ment. or2ment. as2ment. au2ment. \'ecu2ment. fu2ment. hu2ment. fichu3ment. llu2ment. plu2ment. bou2ment. bru2ment. su2ment. tu2ment. % 1mi 1m\^i .milli1am 1m2n\'emo 1m2n\`es 1m2n\'esi 1mo 1m\^o 1m\oe0 % final zero essential to terminate cs \n{1m\oeOT} % for \oe in OT1 _and_ T1 font encoding .mono1a2 .mono1e2 .mono1\'e2 .mono1i2 .mono1\"i2d\'e .mono1o2 .mono1u2 .mono1s2 mon2t3r\'eal % missing from nb list m1s2 1mu 1m\^u 1my moye2n1\^a2g %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%n 1na 1n\^a 1ne 1n\'e 1n\`e 1n\^e 4ne. 4nes. % words ending with -nent (df) 22/02/94 2nent. % fric-tionnent - syllable muette - bg 27/12/93 r\'ema3nent. imma3nent. perma3nent. .\'emi3nent. pr\'e\'emi3nent. pro\'emi3nent. sur\'emi3nent. immi3nent. conti3nent. perti3nent. absti3nent. % 1ni 1n\^i 1no 1n\^o 1n\oe0 % final zero essential to terminate cs \n{1n\oeOT} % for \oe in OT1 _and_ T1 font encoding .no2n1obs 1nu 1n\^u n3s2at. n3s2ats. n1x 1ny %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%o .o4 'o4 '\^o4 .\^o4 %'\"o2 % mjf % deleted 3/1/94 df-bg o2b3long 1octet % missing from nb list o1d2l o1\`e2dre o1ioni ombud2s3 omni1s2 o1s2tas o1s2tat o1s2t\'ero o1s2tim o1s2tom o1s2trad o1s2tratu o1s2triction .oua1ou 'oua1ou .ovi1s2c 'ovi1s2c oxy1a2 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%p 1pa 1p\^a pal\'eo1\'e2 .pa2n1a2f .pa2n1a2m\'e .pa2n1a2ra .pa2n1is .pa2n1o2ph .pa2n1opt .pa2r1a2che .pa2r1a2ch\`e .para1s2 .pa2r3h\'e 1pe 1p\'e 1p\`e 1p\^e 4pe. 4pes. % words ending with -pent (df) 22/02/94 2pent. re3pent. .ar3pent. 'ar3pent. ser3pent. % .pen2ta % pent- or penta- but never pen-ta bg 12/27/93 per3h p\'e2nul % p\'e2n1ul moved back 09/17/92 to JD def. .pe4r .per1a2 .per1e2 .per1\'e2 .per1i2 .per1o2 .per1u2 p\'e1r2\'e2q % 2r1 moved 09/17/92 to 1r2(it was a typo) .p\'eri1os .p\'eri1s2 .p\'eri2s3s .p\'eri2s3ta .p\'eri1u2 1p2h .ph4 4ph. .phalan3s2t 4phe. 4phes. 2phent. % mute syllable: triomphent (df) 22/02/94 ph2l 4phle. 4phles. 2phn photo1s2 ph2r 4phre. 4phres. 2phs 2pht 3ph2tal\'e 3ph2tis %%%% Here is an example of a pb involving phonetic and etymologic patterns 5/94 %%%% .phyto3ph2 % originaly, but wrong for phy-toph-thora 9/92 %%%% .phy2topha % for -pharmacie but wrong for phyto-biol.. 5/94 1pi 1p\^i 1p2l 4ple. 4ples. 2plent. % mute syllable: accouplent (df) 28/02/94 .pluri1a 1p2n\'e 1p2neu 1po 1p\^o po1astre poly1a2 poly1e2 poly1\'e2 poly1\`e2 poly1i2 poly1o2 poly1s2 poly1u2 .pon2tet % JD hypenated it asis 09/17/92, exception .pos2t3h .pos2t1in .pos2t1o2 .pos2t3r .post1s2 1p2r 4pre. 4pres. 2prent. % mute syllable: empourprent (df) 28/02/94 .pr\'e1a2 .pr\'e2a3la % missing from nb list .pr\'e2au .pr\'e1\'e2 .pr\'e1e2 .pr\'e1i2 .pr\'e1o2 .pr\'e1u2 .pr\'e1s2 .pro1\'e2 .pro1s2c\'e pro2s3tat .prou3d2h 1p2sych .psycho1a2n 1p2t\`er 1p2t\'er 1pu .pud1d2l 1p\^u 1py %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%q 1q 4que. 4ques. % words ending with -quent (df) 22/02/94 2quent. \'e3quent. \'elo3quent. grandilo3quent. %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%r 1ra 1r\^a radio1a2 % missing from nb list 1re 1r\'e 1r\`e 1r\^e .r\'e1a2 .r\'e2a3le .r\'e2a3lis .r\'e2a3lit .r\'e2aux .r\'e1\'e2 .r\'e1e2 .r\'e2el .r\'e2er .r\'e2\`er .r\'e1i2 .r\'e2i3fi .r\'e1o2 .re1s2 .re2s3cap .re2s3cisi % for res-cision 09/17/92 (missing from nb) .re2s3ciso % for res-cisoire 09/17/92(missing from nb) .re2s3cou .re2s3cri .re2s3pect .re2s3pir .re2s3plend .re2s3pons .re2s3quil .re2s3s .re2s3t .re3s4tab .re3s4tag .re3s4tand .re3s4tat .re3s4t\'en .re3s4t\'er .re3s4tim .re3s4tip .re3s4toc .re3s4top .re3s4tr .re4s5trein .re4s5trict .re4s5trin .re3s4tu .re3s4ty .r\'eu2 %.r\'e1u2 % pattern rejected 12/2/92 % (don't hyphenate as r\'e-union nor r\'eu-nion) .r\'e2uss .r\'etro1a2 4re. 4res. % words ending with -rent (df) 22/02/94 2rent. % es-p\`erent - syllable muette - bg 27/12/93 .pa3rent. appa3rent. transpa3rent. \'e3rent. tor3rent. cur3rent. % 1r2h 4rhe. 4rhes. 2r3heur 2r3hydr 1ri 1r\^i 1ro 1r\^o 1ru 1r\^u 1ry %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%s 1sa 1s\^a .sch4 1s2caph 1s2cl\'er 1s2cop 1s2ch e2s3ch i2s3ch\'e i2s3chia i2s3chio 4sch. 4sche. 4sches. 2schs 1se 1s\'e 1s\`e 1s\^e sesqui1a2 4se. 4ses. % words ending with -sent (df) 22/02/94 2sent. % massent - syllable muette - bg 27/12/93 ab3sent. pr\'e3sent. .res3sent. % .seu2le % jbb .sh4 1s2h 4sh. 4she. 4shes. 2shent. % mute syllable: smashent (df) 22/02/94 2shm 2s3hom 2shr 2shs 1si 1s\^i 1s2lav 1s2lov 1so 1s\^o 1s\oe0 % final zero essential to terminate cs \n{1s\oeOT} % for \oe in OT1 _and_ T1 font encoding 1s2patia 1s2perm 1s2por 1s2ph\`er 1s2ph\'er 1s2piel 1s2piros 1s2tandard 1s2tein st\'er\'eo1s2 1s2tigm 1s2tock 1s2tomos 1s2troph 1s2tructu 1s2tyle 1su 1s\^u .su2b1a2 .su3b2alt .su2b1\'e2 .su3b2\'e3r .su2b1in .su2b3limin .su2b3lin .su2b3lu sub1s2 .su2b1ur supero2 supe4r1 supers2 .su2r1a2 su3r2ah .su3r2a3t .su2r1e2 .su3r2eau .su3r2ell .su3r2et .su2r1\'e2 .su2r3h .su2r1i2m .su2r1inf .su2r1int .su2r1of .su2r1ox 1sy %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%t 1ta 1t\^a 1t\`a tachy1a2 tchin3t2 1te 1t\'e 1t\`e 1t\^e t\'el\'e1e2 t\'el\'e1i2 t\'el\'e1o2b t\'el\'e1o2p t\'el\'e1s2 4te. 4tes. % words ending with -tent (df) 22/02/94 2tent. % mentent - syllable muette - bg 27/12/93 .la3tent. .pa3tent. comp\'e3tent. \'eni3tent. m\'econ3tent. omnipo3tent. ventripo3tent. \'equipo3tent. impo3tent. mit3tent. % .th4 1t2h 4th. 4the. 4thes. thermo1s2 2t3heur 2thl % th2l was wrong for ...ath-lon (jd said 2thl) df 12/27/93 2thm 2thn th2r 4thre. 4thres. 2ths 1ti 1t\^i 1to 1t\^o 1t2r tran2s1a2 tran3s2act tran3s2ats tran2s3h tran2s1o2 tran2s3p tran2s1u2 4tre. 4tres. 2trent. % mute syllable: infiltrent (df) 28/02/94 .tri1a2c .tri1a2n .tri1a2t .tri1o2n t1t2l 1tu 1t\^u tung2s3 1ty %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%u .u4 'u4 .\^u4 '\^u4 uni1o2v uni1a2x u2s3tr %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%v 1va 1v\^a 1ve 1v\'e 1v\`e 1v\^e v\'elo1s2ki 4ve. 4ves. % words ending with -vent (df) 22/02/94 2vent. conni3vent. .sou3vent. % 1vi 1v\^i 1vo 1v\^o vol2t1amp 1v2r 4vre. 4vres. 2vrent. % mute syllable: recouvrent (df) 28/02/94 1vu 1v\^u 1vy %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%w 1wa 1we 4we. 4wes. 2went. % mute syllable: interviewent (df) 22/02/94 1wi 1wo 1wu 1w2r %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%x 2xent. % mute syllable: malaxent (df) 22/02/94 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%y .y4 'y4 y1asth y1s2tom y1algi %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%z 1za 1ze 1z\'e 1z\`e 4ze. 4zes. % words ending with -zent (df) 22/02/94 2zent. privatdo3zent. % 1zi 1zo 1zu 1zy } \endgroup \endinput %% %% End of file `frhyph.tex'. |
Added gc_lang/fr/dictionnaire/césures/hyph-fr.tex version [394d4d9505].
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 | % This file is part of hyph-utf8 package and resulted from % semi-manual conversions of hyphenation patterns into UTF-8 in June 2008. % % Source: frhyph.tex <2006-10-20> % Author: R. Bastian, D. Flipo, B. Gaulle <cesure-l at gutenberg.eu.org> % % The above mentioned file should become obsolete, % and the author of the original file should preferaby modify this file instead. % % Modificatios were needed in order to support native UTF-8 engines, % but functionality (hopefully) didn't change in any way, at least not intentionally. % This file is no longer stand-alone; at least for 8-bit engines % you probably want to use loadhyph-foo.tex (which will load this file) instead. % % Modifications were done by Jonathan Kew, Mojca Miklavec & Arthur Reutenauer % with help & support from: % - Karl Berry, who gave us free hands and all resources % - Taco Hoekwater, with useful macros % - Hans Hagen, who did the unicodifisation of patterns already long before % and helped with testing, suggestions and bug reports % - Norbert Preining, who tested & integrated patterns into TeX Live % % However, the "copyright/copyleft" owner of patterns remains the original author. % % The copyright statement of this file is thus: % % Do with this file whatever needs to be done in future for the sake of % "a better world" as long as you respect the copyright of original file. % If you're the original author of patterns or taking over a new revolution, % plese remove all of the TUG comments & credits that we added here - % you are the Queen / the King, we are only the servants. % % If you want to change this file, rather than uploading directly to CTAN, % we would be grateful if you could send it to us (http://tug.org/tex-hyphen) % or ask for credentials for SVN repository and commit it yourself; % we will then upload the whole "package" to CTAN. % % Before a new "pattern-revolution" starts, % please try to follow some guidelines if possible: % % - \lccode is *forbidden*, and I really mean it % - all the patterns should be in UTF-8 % - the only "allowed" TeX commands in this file are: \patterns, \hyphenation, % and if you really cannot do without, also \input and \message % - in particular, please no \catcode or \lccode changes, % they belong to loadhyph-foo.tex, % and no \lefthyphenmin and \righthyphenmin, % they have no influence here and belong elsewhere % - \begingroup and/or \endinput is not needed % - feel free to do whatever you want inside comments % % We know that TeX is extremely powerful, but give a stupid parser % at least a chance to read your patterns. % % For more unformation see % % http://tug.org/tex-hyphen % %------------------------------------------------------------------------------ % % French hyphenation patterns %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % This file is available for free and can used and redistributed % asis for free. Modified versions should have another name. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % \message{frhyph.tex - French hyphenation patterns (V2.12) <2002/12/11>} % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % *BEFORE* using this file *PLEASE* run checksum on it: % % checksum -v frhyph.tex % % to make sure that it hasn't been damaged. % % Then if you notice anything wrong in french hyphenation please report to % % R. Bastian, D. Flipo, B. Gaulle at the email address: % % cesure-l@gutenberg.eu.org % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% checksum = "37208 1458 3078 34821" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%% The most famous good guys who worked hard to obtain something usable. % Jacques Desarmenien, Universite de Strasbourg : % - << how to run TeX in a French environment: hyphenation, fonts, % typography. >> in Tugboat, 5 (1984) 91-102. and TeX85 conference % - << La division par ordinateur des mots francais : % application a TeX >> in TSI vol. 5 No 4, 1986 (C) AFCET- % Gauthier-Villars % Norman Buckle, UQAH (nb; many additions) % Michael Ferguson, INRS-Telecommunications (mjf) June 1988 % Justin Bur, Universite de Montreal (jbb; checked against original list) % all patterns including apostrophe missing from nb list % after that, GUTenberg and specially Daniel Flipo and Bernard Gaulle % did their best effort to improve the list of patterns. % % ----------------------------------------------------------------- % % Adaption of these patterns for % - TeX Version 3.x and MLTeX 3.x (2.x) % and % - all fonts in T1/`Cork' and/or CM/OT1 encoding % by Bernd Raichle 1996/08/28 (using ideas from `ghyph31.tex' % as of 1994-02-13 maintained by Bernd Raichle). % (An adaption for the old MLTeX 2.x exists but can not be % tested in lack of an executable.) % % ----------------------------------------------------------------- % \patterns{ %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%* 2'2 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%a .a4 'a4 .â4 'â4 ab2h % df-bg 1998/02/07 for abhorrer .ab3réa 'ab3réa ad2h % df-bg 1998/02/07 for adhèsion & co a1è2dre .ae3s4ch 'ae3s4ch 1alcool a2l1algi .amino1a2c 'amino1a2c .ana3s4tr 'ana3s4tr 1a2nesthési .anti1a2 'anti1a2 .anti1e2 'anti1e2 .anti1é2 .anti2enne 'anti2enne 'anti1é2 .anti1s2 'anti1s2 .apo2s3ta 'apo2s3ta apo2s3tr archi1é2pis .as2ta 'as2ta a2s3tro %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%b 1ba 1bâ .bai2se3main % hyphen disappeared from french 5/2/94 1be 1bé 1bè 1bê 4be. 4bes. 2bent. % mute syllable: tombent (df) 22/02/94 1bi 1bî .bi1a2c .bi1a2t % like .tri1a2t for tri-athlon bg 12/27/93 .bi1au .bio1a2 .bi2s1a2 .bi1u2 1b2l 4ble. 4bles. 2blent. % mute syllable: troublent (df) 28/02/94 1bo 1bô 1b2r 4bre. 4bres. 2brent. % mute syllable: palabrent (df) 28/02/94 1bu 1bû 1by %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%c 1ç 1ca 1câ ca3ou3t2 % for caoutchou... added 3/1/94 df-bg 1ce 1cé 1cè 1cê 4ce. 4ces. % words ending with -cent (df) 22/02/94 2cent. ja3cent. ac3cent. é3cent. munifi3cent. réti3cent. privatdo3cent. inno3cent. es3cent. acquies4cent. is3cent. immis4cent. % .ch4 1c2h 4ch. 2chb 4che. 4ches. 2chent. % mute syllable: touchent (df) 22/02/94 .chè2vre3feuille % hyphen disappeared from french 5/2/94 2chg ch2l 4chle. 4chles. chlo2r3a2c chlo2r3é2t 2chm 2chn 2chp ch2r 4chre. 4chres. 2chs 2cht 2chw 1ci 1cî .ci2s1alp 1c2k 4ck. 2ckb 4cke. 4ckes. 2ckent. % mute syllable: stockent (df) 22/02/94 2ckf 2ckg 2ck3h 2ckp 2cks 2ckt 1c2l 4cle. 4cles. 2clent. % mute syllable: encerclent (df) 28/02/94 1co 1cô co1acc co1acq co1a2d co1ap co1ar co1assoc co1assur co1au co1ax 1cœ co1é2 co1ef co1en co1ex .con4 % missing from nb list .cons4 % missing from nb list .contre1s2c .contre3maître % hyphen disappeared from french 5/2/94 co2nurb .co1o2 .co2o3lie 1c2r 4cre. 4cres. 2crent. % mute syllable: massacrent (df) 28/02/94 1cu 1cû 1cy .cul4 % -- as .con4 .cons4 (march 92) %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%d 1d' 1da 1dâ .dacryo1a2 d1d2h 1de 1dé 1dè 1dê 4de. 4des. % words ending with -dent (df) 22/02/94 2dent. déca3dent. é3dent. cci3dent. inci3dent. confi3dent. tri3dent. dissi3dent. chien3dent. .ar3dent. impu3dent. pru3dent. % .dé1a2 .dé1io .dé1o2 .dé2s % originaly in JD file %.dé2s1a2 removed 09/17/92 because wrong for the % original JD 500 words test .dé3s2a3cr .dés2a3m % .dés2a2mi introduced 09/17/92 bec. i % can't see why désamidonner ran in JD. % Moved to .dés2a3m df 12/27/93. .dé3s2a3tell .dé3s2astr .dé3s2c % 1 moved 3 due to .dé2s 09/17/92 %.dé2s1e2 removed 09/17/92 because wrong for the % original JD 500 words test .dé2s1é2 .dé3s2é3gr .dé3s2ensib .dé3s2ert .dé3s2exu %.dé2s3h removed 09/17/92 because wrong for the % original JD 500 words test .dé2s1i2 .dé3s2i3d .dé3s2i3gn .dé3s2i3li .dé3s2i3nen .dé3s2invo .dé3s2i3r .dé3s2ist %.dé2s1o2 removed 09/17/92 because wrong for the % original JD 500 words test .dé3s2o3dé .dé2s1œ .dé3s2o3l .dé3s2o3pil .dé3s2orm .dé3s2orp .dé3s2oufr .dé3s2p % 1 moved 3 due to .dé2s 09/17/92 .dé3s2t % 1 moved 3 due to .dé2s 09/17/92 .dé2s1u2n 3d2hal 3d2houd 1di 1dî di2s3cop .di1a2cé .di1a2cid .di1ald .di1a2mi .di1a2tom .di1e2n .di2s3h 2dlent. % mute syllable: jodlent (df) 28/02/94 1do 1dô 1d2r 4dre. 4dres. 2drent. % mute syllable: engendrent (df) 28/02/94 d1s2 1du 1dû 1dy .dy2s3 .dy2s1a2 .dy2s1i2 .dy2s1o2 % missing from nb list .dy2s1u2 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%e .e4 'e4 .ê4 'ê4 .é4 'é4 .è4 'è4 éd2hi % df-bg 1998/02/07 for rédhibitoire 1é2drie 1é2drique 1é2lectr 1é2lément .en1a2 'en1a2 1é2nerg e2n1i2vr .en1o2 'en1o2 épi2s3cop épi3s4cope e2s3cop .eu2r1a2 'eu2r1a2 eu1s2tat extra1 extra2c extra2i %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%f 1fa 1fâ 1fe 1fé 1fè 1fê 4fe. 4fes. 2fent. % mute syllable: agrafent chauffent (df) 22/02/94 % 1fi 1fî 1f2l 4fle. 4fles. 2flent. % mute syllable: gonflent (df) 28/02/94 1fo 1fô 1f2r 4fre. 4fres. 2frent. % mute syllable: balafrent (df) 28/02/94 f1s2 1fu 1fû 1fy %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%g 1ga 1gâ 1ge 1gé 1gè 1gê 4ge. 4ges. % words ending with -gent (df) 22/02/94 2gent. ré3gent. entre3gent. indi3gent. dili3gent. intelli3gent. indul3gent. tan3gent. rin3gent. contin3gent. .ar3gent. 'ar3gent. ser3gent. ter3gent. résur3gent. % 1g2ha 1g2he 1g2hi 1g2ho 1g2hy 1gi 1gî 1g2l 4gle. 4gles. 2glent. % mute syllable: meuglent (df) 28/02/94 1g2n 'a2g3nat % (df) 16/01/02 .a2g3nat % (df) 16/01/02 a2g3nos % (df) 16/01/02 (pattern dia2g3n deleted) co2g3niti % (df) 16/01/02 'i2g3né % (df) 16/01/02 .i2g3né % (df) 16/01/02 'i2g3ni % (df) 16/01/02 .i2g3ni % (df) 16/01/02 .ma2g3nicide % (df) 16/01/02 .ma2g3nificat % (df) 16/01/02 .ma2g3num % (df) 16/01/02 o2g3nomoni % (df) 16/01/02 o2g3nosi % (df) 16/01/02 .pro2g3nath % (df) 16/01/02 pu2g3nable % (df) 16/01/02 pu2g3nac % (df) 16/01/02 .sta2g3n .syn2g3nath % (df) 16/01/02 wa2g3n 4gne. 4gnes. 2gnent. % mute syllable: accompagnent (df) 28/02/94 1go 1gô 1g2r 4gre. 4gres. 2grent. % mute syllable: immigrent (df) 28/02/94 1gu 1gû g1s2 4gue. 4gues. % words ending with -guent (df) 22/02/94 2guent. .on3guent. 'on3guent. % 1gy %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%h 1ha 1hâ 1he 1hé 1hè 1hê hémi1é hémo1p2t 4he. 4hes. 1hi 1hî 1ho 1hô 1hu 1hû 1hy hypera2 hypere2 hyperé2 hyperi2 hypero2 hypers2 hype4r1 hyperu2 hypo1a2 hypo1e2 % missing from nb list hypo1é2 hypo1i2 hypo1o2 hypo1s2 hypo1u2 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%i .i4 'i4 .î4 'î4 i1algi i1arthr i1è2dre % ill patterns missing from nb list il2l cil3l rcil4l ucil4l vacil4l gil3l hil3l lil3l l3lion mil3l mil4let émil4l semil4l rmil4l armil5l capil3l papil3la papil3le papil3li papil3lom pupil3l piril3l thril3l cyril3l ibril3l pusil3l .stil3l distil3l instil3l fritil3l boutil3l vanil3lin vanil3lis vil3l avil4l chevil4l uevil4l uvil4l xil3l % end of ill patterns 1informat % missing from nb list .in1a2 'in1a2 .in2a3nit 'in2a3nit .in2augur 'in2augur .in1e2 'in1e2 .in1é2 'in1é2 .in2effab % missing from nb list 'in2effab .in2é3lucta 'in2é3lucta .in2é3narra 'in2é3narra .in2ept 'in2ept .in2er 'in2er .in2exora % missing from nb list 'in2exora .in1i2 'in1i2 .in2i3miti 'in2i3miti .in2i3q 'in2i3q .in2i3t 'in2i3t .in1o2 'in1o2 .in2o3cul 'in2o3cul .in2ond 'in2ond .in1s2tab 'in1s2tab 'inte4r3 .intera2 'intera2 .intere2 'intere2 .interé2 'interé2 .interi2 'interi2 .intero2 'intero2 .inte4r3 .interu2 'interu2 .inters2 'inters2 .in1u2 'in1u2 .in2uit 'in2uit .in2u3l 'in2u3l io1a2ct i1oxy i1s2tat %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%j 1j 2jk 4je. 4jes. 2jent. % mute syllable: galèjent (df) 22/02/94 %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%k 1ka 1kâ 1ke 1ké 1kè 1kê 4ke. 4kes. 2kent. % mute syllable: jerkent (df) 22/02/94 1k2h 4kh. .kh4 1ki 1kî 1ko 1kô 1k2r 1ku 1kû 1ky %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%l 1la 1lâ 1là la2w3re 1le 1lé 1lè 1lê 4le. 4les. % words ending with -lent (df) 22/02/94 2lent. .ta3lent. iva3lent. équiva4lent. monova3lent. polyva3lent. re3lent. .do3lent. indo3lent. inso3lent. turbu3lent. succu3lent. fécu3lent. trucu3lent. opu3lent. corpu3lent. ru3lent. sporu4lent. % 1li 1lî 1lo 1lô l1s2t 1lu 1lû 1ly %-------------------%-----------------------% % phonetic patterns % etymological patterns % %-------------------%-----------------------% %%m 1ma 1mâ .ma2c3k .macro1s2c .ma2l1a2dres .ma2l1a2dro .ma2l1aisé .ma2l1ap .ma2l1a2v .ma2l1en .ma2l1int .ma2l1oc .ma2l1o2d .ma2r1x % nb (jbb: ?) 1me 1mé 1mè 1mê .mé2g1oh .mé2sa % missing from nb list .mé3san % missing from nb list .mé2s1es .mé2s1i .mé2s1u2s .méta1s2ta 4me. 4mes. % words ending with -ment (df) 22/02/94 â2ment. da2ment. fa2ment. amalga2ment. cla2ment. ra2ment. tempéra3ment. ta2ment. testa3ment. qua2ment. è2ment. carê2ment. diaphrag2ment. ryth2ment. ai2ment. rai3ment. abî2ment. éci2ment. vidi2ment. subli2ment. éli2ment. reli2ment. mi2ment. ani2ment. veni2ment. ri2ment. détri3ment. nutri3ment. inti2ment. esti2ment. l2ment. flam2ment. gram2ment. .gem2ment. om2ment. .com3ment. ô2ment. slalo2ment. chro2ment. to2ment. ar2ment. .sar3ment. er2ment. antifer3ment. .ser3ment. fir2ment. or2ment. as2ment. au2ment. écu2ment. fu2ment. hu2ment. fichu3ment. llu2ment. plu2ment. bou2ment. bru2ment. su2ment. tu2ment. % 1mi 1mî .milli1am 1m2némo 1m2nès 1m2nési 1mo 1mô 1mœ |