Skip to content
This repository
Browse code

Merge pull request #1 from cyplp/translation

English translation for documentation
  • Loading branch information...
commit 47f9174e95c4356f5fc9f7dd229553850871b89d 2 parents 9c5bfae + bafc751
Guillaume Camera authored March 30, 2013
165  doc/sqla_helpers.rst
Source Rendered
@@ -5,7 +5,7 @@ Installation
5 5
 
6 6
 .. rubric:: Git
7 7
 
8  
-Installation depuis le dépôt git
  8
+Installation from git
9 9
 
10 10
 .. code-block:: console
11 11
 
@@ -15,7 +15,7 @@ Installation depuis le dépôt git
15 15
 
16 16
 .. rubric:: Eggs
17 17
 
18  
-Installation depuis les archives `eggs`
  18
+Installation from pypi `eggs`
19 19
 
20 20
 .. code-block:: console
21 21
 
@@ -25,14 +25,11 @@ Installation depuis les archives `eggs`
25 25
 Getting Started
26 26
 ----------------
27 27
 
28  
-:class:`sqla_helpers.base_model.BaseModel` a pour but d'instrumenter la syntaxe d'SQLAlchemy pour
29  
-fournir à l'utiliseur final, des méthodes simplifiées permettant la récupération
30  
-d'objets en base.
  28
+The purpose :class:`sqla_helpers.base_model.BaseModel` is to implement the `SQLAlchemy` syntax with simplified methods for querying.
31 29
 
32  
-:class:`sqla_helpers.base_model.BaseModel` est une classe qui est utilisable en tant que Mixin, elle
33  
-n'hérite d'aucune classe et elle n'est pas à sous-classer.
34  
-Pour avoir accès aux méthodes dans un modèle, il faut alors déclarer une table
35  
-comme ceci:
  30
+
  31
+:class:`sqla_helpers.base_model.BaseModel` is to be use in a mixin class. this class inherits from nothing and shouldn't be inherited.
  32
+For access method from model, Table need to be implement as bellow:
36 33
 
37 34
 .. code-block:: python
38 35
 
@@ -51,12 +48,10 @@ comme ceci:
51 48
         model_id = ... # Clef étrangère sur MyModel
52 49
 
53 50
 
54  
-La classe :class:`DeclarativeBase` est la classe générée par la fonction
55  
-:func:`declarative_base` d'SQLAlchemy.
56  
-
57  
-Il est également possible d'utiliser :class:`sqla_helpers.base_model.BaseModel` comme paramètre `cls` de la fonction :func:`declarative_base`.
58  
-Et ainsi on peut se passer de l'utilisation de la classe comme Mixin.
  51
+The :class:`DeclarativeBase` class if generated by :func:`declarative_base` function from `SQLAlchemy`.
59 52
 
  53
+:class:`sqla_helpers.base_model.BaseModel` class can be use as `cls` parameter in :func:`declarative_base`
  54
+function. This prevents the mixin use of the class.
60 55
 
61 56
 .. code-block:: python
62 57
 
@@ -71,36 +66,33 @@ Et ainsi on peut se passer de l'utilisation de la classe comme Mixin.
71 66
         # ...
72 67
 
73 68
 
74  
-:class:`sqla_helpers.base_model.BaseModel` attend une manière de récupérer une session quand une requête est effectuée.
75  
-Pour ce faire, elle fait appel à la fonction stockée dans l'attribut :attr:`sqla_helpers.base_model.BaseModel.sessionmaker`.
76  
-Ainsi, lors de l'initialisation de l'application, il faut stocker un
77  
-sessionmaker dans la classe, grâce à la méthode
78  
-`sqla_helpers.base_model.BaseModel.register_sessionmaker`
  69
+:class:`sqla_helpers.base_model.BaseModel` need a to have a method for getting a session when querying is done.
  70
+For this purpose, the class use the stored function in :attr:`sqla_helpers.base_model.BaseModel.sessionmaker`.:
  71
+So a sessionmaker is need to be stored using the `sqla_helpers.base_model.BaseModel.register_sessionmaker` method
79 72
 
80 73
 .. code-block:: python
81 74
 
82  
-    # Initialisation de l'application
  75
+    # Application's initialization
83 76
     def main():
84 77
         # ...
85 78
         BaseModel.register_sessionmaker(scoped_session(sessionmaker(bind=engine)))
86 79
         # ...
87 80
 
88  
-
89  
-Pour passer une session globale, il suffit simplement que la fonction passée à :attr:`sqla_helpers.base_model.BaseModel.sessionmaker`
90  
-renvoie la référence sur la session globale
  81
+For a global session, the function set in  :attr:`sqla_helpers.base_model.BaseModel.sessionmaker` should return
  82
+a reference to a global session.
91 83
 
92 84
 .. code-block:: python
93 85
 
94 86
     from somwhere import DBSession
95 87
 
96  
-    # Initialisation de l'application
  88
+    # Application's initialization
97 89
     def main():
98 90
         # ...
99 91
         BaseModel.register_sessionmaker(lambda: DBSession)
100 92
         # ...
101 93
 
102 94
 
103  
-Cas d'utilisation simple :
  95
+Basic use case :
104 96
 
105 97
 .. code-block:: python
106 98
 
@@ -116,12 +108,11 @@ Cas d'utilisation simple :
116 108
     []
117 109
 
118 110
 
119  
-* :meth:`sqla_helpers.base_model.BaseModel.all` ramène l'ensemble des objets en base.
120  
-* :meth:`sqla_helpers.base_model.BaseModel.filter` ramène les objets correspondants aux critères donnés sous forme de liste.
121  
-* :meth:`sqla_helpers.base_model.BaseModel.get` ramène un unique élément correspond aux critères données.
  111
+* :meth:`sqla_helpers.base_model.BaseModel.all` returns all database objects
  112
+* :meth:`sqla_helpers.base_model.BaseModel.filter` returns a list of matching objects.
  113
+* :meth:`sqla_helpers.base_model.BaseModel.get` return an uniq maching object.
122 114
 
123  
-On peut bien évidemment enchaîner les critères de recherche qui seront pris en
124  
-compte avec un opérateur `&&` (ET) logique.
  115
+Querying criterions can be chained with an `&&` (logical and) operator.
125 116
 
126 117
 .. code-block:: python
127 118
 
@@ -131,81 +122,75 @@ compte avec un opérateur `&&` (ET) logique.
131 122
     [<MyOtherModel object at 0x2c19d90>]
132 123
 
133 124
 
134  
-Recherche sur critères de relation
135  
-----------------------------------
  125
+Querying for criterions on relations
  126
+------------------------------------
136 127
 
137  
-Les critères de recherche valides pour une classe sont définies par ses
138  
-attributs (Pour MyOtherModel ça sera `id`, `name`, `model_id`).
  128
+Valid quering criterions for a class ared definied by the class attributes.
  129
+IE : in case of `MyOtherModel`, criterions can be `id`, `name` and `model_id`.
139 130
 
140  
-Cela est également valable pour le relation SQLAlchemy.
  131
+This still true for a Sqlachemy relation.
141 132
 
142  
-Par exemple, on peut rechercher tous les MyModel dont le MyOtherModel a pour nom
143  
-'toto'
  133
+IE: quering all `MyModel` witch `MyOtherModel` have a name 'foo'.
144 134
 
145 135
 .. code-block:: python
146 136
 
147  
-    >>> MyModel.filter(awesome_attr__name='toto')
  137
+    >>> MyModel.filter(awesome_attr__name='foo')
148 138
     [<MyModel object at 0x2c19d90>]
149 139
 
150 140
 
151  
-On peut même rechercher suivant un objet complet.
  141
+Quering a with entire object.
152 142
 
153 143
 .. code-block:: python
154 144
 
155  
-    >>> otherModel = MyOtherModel.get(name='toto')
  145
+    >>> otherModel = MyOtherModel.get(name='foo')
156 146
     >>> MyModel.filter(awesome_attr=otherModel)
157 147
     [<MyModel object at 0x2c19d90>]
158 148
 
159 149
 
160  
-Le séparateur `__` (double underscore) permet de faire la séparation entre les
161  
-différentes entités sollicitées.
  150
+The `__` separator (double underscore) permits to split between the differents entities.
162 151
 
163  
-La recherche par les attributs des relations peut se faire en profondeur.
164  
-Imaginons que `MyOtherObject` est un attribut `other_attr` qui est en relation
165  
-avec un objet MyOtherOtherObject.
  152
+Quering with relation`s attributes can be recursive.
  153
+If `MyOtherObject` have an `other_attr` attribute which is in relation with a `MyOtherOtherObject` object.
166 154
 
167  
-Il est alors possible de rechercher tous les MyModel dont le MyOtherObject a un
168  
-MyOtherOtherObject dont le nom est 'toto'.
  155
+Quering all `MyModel` which a `MyOtherObject` has `MyOtherOtherObject` has a `name` attribute is 'foo'.
169 156
 
170 157
 .. code-block:: python
171 158
 
172  
-    >>> MyModel.filter(awesome_attr__other_attr__name='toto')
  159
+    >>> MyModel.filter(awesome_attr__other_attr__name='foo')
173 160
     [<MyModel object at 0x2c19d90>]
174 161
 
175 162
 
176 163
 
177  
-Des opérateurs
178  
---------------
  164
+Operators
  165
+---------
179 166
 
180  
-Il est possible de spécifier d'autres critères que ceux d'égalités. En séparant
181  
-encore une fois, avec des '__' (doubles underscores) et en mettant le nom de
182  
-l'opérateur à la fin du critère.
  167
+Others criterions  than equality can be used. These criterions sould be writen
  168
+with the attribute name following '__' (double underscore) and name of the operator.
183 169
 
184  
-Par exemple, si l'on veut tous les MyModel qui n'ont PAS pour id la valeur 2.
  170
+IE: if all `MyModel` which `id` is different from 2 are wanted:
185 171
 
186 172
 .. code-block:: python
187 173
 
188 174
     >>> MyModel.filter(id__not=2)
189 175
     []
190 176
 
191  
-Les opérateurs disponibles sont :
  177
+Available operatores are:
192 178
 
193  
-* 'not': Non-égal
194  
-* 'lt': inférieur
195  
-* 'le': Inférieur ou égal
196  
-* 'gt': Plus grand
197  
-* 'gte': Plus grand ou égal
198  
-* 'in': Contenu dans (Le paramètre de recherche doit-être une liste)
199  
-* 'like': opérateur SQL LIKE
200  
-* 'ilike': opérateur SQL ILIKE
  179
+* 'not': Non-equal,
  180
+* 'lt': letter than,
  181
+* 'le': letter or equals than,
  182
+* 'gt': gretter than,
  183
+* 'gte': gretter or equal than,
  184
+* 'in': in a list,
  185
+* 'like': SQL `LIKE` operator,
  186
+* 'ilike': SQL `ILIKE` operator.
201 187
 
202 188
 
203  
-Requêtes plus complexes
204  
------------------------
  189
+More complex quering
  190
+--------------------
205 191
 
206  
-Toujours sur le modèle de Django, :mod:`sqla_helpers` fournit un :class:`sqla_helpers.logical.Q` object afin de pouvoir réaliser des opération un peu plus complexes
207  
-Le :class:`sqla_helpers.logical.Q` object est capable de prendre ne compte la
208  
-syntaxe sqla_helpers.
  192
+In the Django spirit, :mod:`sqla_helpers` provide a :class:`sqla_helpers.logical.Q` object for more complex quering.
  193
+The :class:`sqla_helpers.logical.Q` object can use the :mod:`sqla_helpers' syntax.
209 194
 
210 195
 .. code-block:: python
211 196
 
@@ -214,7 +199,8 @@ syntaxe sqla_helpers.
214 199
     <sqla_helpers.logical.Q at 0x2376cd0>
215 200
 
216 201
 
217  
-Ces objets sont transmissibles aux méthodes de recherches de la classe
  202
+These objects are usable as criterions for query.
  203
+
218 204
 :class:`sqla_helpers.base_model.BaseModel`
219 205
 
220 206
 .. code-block:: python
@@ -222,10 +208,9 @@ Ces objets sont transmissibles aux méthodes de recherches de la classe
222 208
     >>> Treatment.get(Q(id=2))
223 209
     >>> <sqlalchemy_test.models.Treatment at 0x2388690>
224 210
 
225  
-L'avantage de ces objets, c'est qu'ils permettent de décrire des conditions
226  
-logiques SQL à travers une syntaxe python.
  211
+The purpose of these objects is to permit SQL logical conditions in a python syntax.
227 212
 
228  
-Si l'on veut les traitments qui ont pour id 2 OU le status à pour nom 'KO'
  213
+If all `Treatment` objects which have an `id` == 2 or a `Status` name == 'KO' are wanted.
229 214
 
230 215
 .. code-block:: python
231 216
 
@@ -233,7 +218,7 @@ Si l'on veut les traitments qui ont pour id 2 OU le status à pour nom 'KO'
233 218
     [<sqlalchemy_test.models.Treatment at 0x2388690>, <sqlalchemy_test.models.Treatment at 0x23837d0>]
234 219
 
235 220
 
236  
-Si l'on veut tous les traitments qui n'ont pas pour id 2
  221
+For getting, all `Treatment` objects  with an `id' attribute different than 2 :
237 222
 
238 223
 .. code-block:: python
239 224
 
@@ -241,7 +226,7 @@ Si l'on veut tous les traitments qui n'ont pas pour id 2
241 226
     [<sqlalchemy_test.models.Treatment at 0x2383450>, <sqlalchemy_test.models.Treatment at 0x23837d0>,
242 227
       <sqlalchemy_test.models.Treatment at 0x23886d0> ]
243 228
 
244  
-Mais on peut également enchainer les opérations logiques
  229
+Logical operators can be chained :
245 230
 
246 231
 .. code-block:: python
247 232
 
@@ -257,14 +242,13 @@ Mais on peut également enchainer les opérations logiques
257 242
     >>> [<sqlalchemy_test.models.Treatment at 0x2388690>]
258 243
 
259 244
 
260  
-Du JSON
261  
--------
  245
+JSON
  246
+----
262 247
 
263  
-Souvent dans les applications web, le client et le serveur communique par l'intermédiaire du format JSON.
264  
-Pour faciliter les opérations de chargement, :mod:`sqla_helpers` fournit des
265  
-méthodes permettant de charger des objets modèles depuis un dictionnaire python ou bien de générer un dictionnaire depuis un objet modèle SQLALchemy.
  248
+Often in web oriented applications, client and server exchange with JSON format.
  249
+In a purpose of easier loading, :mod:`sqla_helpers` furnish methods for loading from a regular python dictionary or a SQLAlchemy model object.
266 250
 
267  
-La méthode :meth:`sqla_helpers.base_model.BaseModel.dump` permet la génération d'un dictionnaire qui est transformable en JSON.
  251
+The :meth:`sqla_helpers.base_model.BaseModel.dump` method permit a JSON compatible dictionnary.
268 252
 
269 253
 .. code-block:: python
270 254
 
@@ -280,12 +264,11 @@ La méthode :meth:`sqla_helpers.base_model.BaseModel.dump` permet la génératio
280 264
         }
281 265
 
282 266
 
283  
-Et la méthode de classe `sqla_helpers.base_model.BaseModel.load` qui permet d'instancier des objets à partir d'un dictionnaire.
284  
-Le passage par dictionnaire est sensé faciliter l'accès aux données en JSON ou bien générer du JSON depuis le
285  
-dictionnaire.
  267
+The method `sqla_helpers.base_model.BaseModel.load` can construct object from a dictionnary.
  268
+The meaning of use a dictionnary is to facillitate access to data in JSON or generate JSON frpm dictionnary.
286 269
 
287  
-Pour le chargement d'un objet, les objets sont récupérés en base si les attributs composant la clef primaire
288  
-sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
  270
+Objects are getting from database if primary key attributes are found on the dictionnary. Otherwise new object
  271
+are created.
289 272
 
290 273
 .. code-block:: python
291 274
 
@@ -295,7 +278,7 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
295 278
         >>> t.id
296 279
         7
297 280
         >>> t.status.name
298  
-        'Sacre status !'
  281
+        'Holy status !'
299 282
         >>> t.status.id
300 283
         7
301 284
         >>> t = Treatment.load({'id': 7, 'name': 'hello'})
@@ -306,7 +289,7 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
306 289
         {
307 290
                 'id': 7,
308 291
                 'name': u'hello',
309  
-                'status': {'id': 7, 'name': u'Sacre status !'},
  292
+                'status': {'id': 7, 'name': u'Holy status !'},
310 293
                 'status_id': 7
311 294
         }
312 295
         >>> tr = Treatment.load(t.dump())
@@ -318,10 +301,10 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
318 301
         {
319 302
                 'id': 7,
320 303
                 'name': u'hello',
321  
-                'status': {'id': 7, 'name': u'Sacre status !'},
  304
+                'status': {'id': 7, 'name': u'Holy status !'},
322 305
                 'status_id': 7
323 306
         }
324  
-        >>> tr = Treatment.load({'name': 'nouveau traitmente', 'status': {'name': 'nouveau status'}})
  307
+        >>> tr = Treatment.load({'name': 'new treatment', 'status': {'name': 'new status'}})
325 308
         >>> tr.id
326 309
         None
327 310
         >>> tr.status.id
@@ -334,7 +317,7 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
334 317
         8
335 318
 
336 319
 
337  
-La classe :class:`sqla_helpers.base_model.BaseModel`
338  
-====================================================
  320
+:class:`sqla_helpers.base_model.BaseModel` class
  321
+================================================
339 322
 
340 323
 .. automodule:: sqla_helpers.base_model
2  setup.py
@@ -13,7 +13,7 @@
13 13
     version=sqla_helpers.__version__,
14 14
     author='Guillaume Camera',
15 15
     author_email='camera.g@gmail.com',
16  
-    description="Fournit quelques méthodes de récupération d'objet en base autour d'SQLAlchemy",
  16
+    description="Provides some methogs for getting objects with SQLAlchemy",
17 17
     long_description=long_description,
18 18
     url="https://github.com/moumoutte/sqla_helpers/",
19 19
     packages=find_packages(),
54  sqla_helpers/base_model.py
@@ -11,8 +11,7 @@
11 11
 
12 12
 class ClassProperty(property):
13 13
     """
14  
-    Classe qui a pour but de fournir une alternative à l'utilisation du
15  
-    decaroteur property pour un attribut de classe.
  14
+    Class an alternative use or property decorator in class attribute.
16 15
     """
17 16
     def __get__(self, cls, owner):
18 17
         return self.fget.__get__(None, owner)()
@@ -20,8 +19,8 @@ def __get__(self, cls, owner):
20 19
 
21 20
 class BaseModel(object):
22 21
     """
23  
-    Classe d'un modèle de base. Elle fournit du sucre syntaxiques pour faire de
24  
-    la récupération d'objets en base.
  22
+    Base Model Class.
  23
+    Provide syntatic sugar for getting object from database.
25 24
     """
26 25
 
27 26
     process_params = classmethod(process_params)
@@ -30,8 +29,8 @@ class BaseModel(object):
30 29
     @classmethod
31 30
     def register_sessionmaker(cls, sessionmaker):
32 31
         """
33  
-        Enregistrement de la fonction utiliser pour créer une session.
34  
-        La fonction enregistrée ne doit prendre aucun paramètre
  32
+        Register the function for making session.
  33
+        This registered function mustn't have any parameters.
35 34
         """
36 35
         cls.sessionmaker = staticmethod(sessionmaker)
37 36
 
@@ -40,11 +39,9 @@ def register_sessionmaker(cls, sessionmaker):
40 39
     @classmethod
41 40
     def session(cls):
42 41
         """
43  
-        Appelle :attr:`BaseModel.sessionmaker` et renvoie une session
44  
-        nouvellement construite.
  42
+        Call :attr:`BaseModel.sessionmaker` and returns a new session.
45 43
 
46  
-        Ne pas oubliez de mettre en place :attr:`BaseModel.sessionmaker` dans
47  
-        l'initialisation de l'application.
  44
+        Don't forget to call  :attr:`BaseModel.sessionmaker` in application's initialization.
48 45
         """
49 46
         return cls.sessionmaker()
50 47
 
@@ -52,10 +49,10 @@ def session(cls):
52 49
     @classmethod
53 50
     def search(cls, *operator, **criterion):
54 51
         """
55  
-        Effectue la recherche d'objet suivant les critères passés en arguments.
56  
-        Le retour est un objet :class:`sqlachemy.orm.query.Query`
  52
+        Object seatch with filter pass in arguments.
  53
+        Return a :class:`sqlachemy.orm.query.Query` object.
57 54
 
58  
-        Ce qui permet d'enchaîner les critères de recherches si besoin.
  55
+        Filters can be chained.
59 56
         """
60 57
         query = cls.session.query(cls)
61 58
         # On maintient une liste des classes déjà jointes
@@ -76,7 +73,7 @@ def search(cls, *operator, **criterion):
76 73
     @classmethod
77 74
     def get(cls, *operators, **criterions):
78 75
         """
79  
-        Retourne un objet correspond aux critères donnés.
  76
+        Return a object with criterions passed in parameters.
80 77
         """
81 78
         query = cls.search(*operators, **criterions)
82 79
         return query.one()
@@ -85,7 +82,7 @@ def get(cls, *operators, **criterions):
85 82
     @classmethod
86 83
     def all(cls):
87 84
         """
88  
-        Retourne tous les objets d'une classe contenu en base.
  85
+        Return all objects from a same class containts in database.
89 86
         """
90 87
         return cls.search().all()
91 88
 
@@ -93,7 +90,7 @@ def all(cls):
93 90
     @classmethod
94 91
     def filter(cls, *operators, **criterions):
95 92
         """
96  
-        Retourne une liste d'objets d'une classe correspond aux critères donnés.
  93
+        Return a list of objects from a class matching criterions passed in parameters.
97 94
         """
98 95
         query = cls.search(*operators, **criterions)
99 96
         return query.all()
@@ -102,13 +99,10 @@ def filter(cls, *operators, **criterions):
102 99
     @classmethod
103 100
     def load(cls, d, hard=False):
104 101
         """
105  
-        Instancie un objet de la classe à partir d'attribut récupérer dans le
106  
-        dictionnaire fournit.
  102
+        Return a object from class with attributes got in dictionnary's parameters.
107 103
 
108  
-        Si le dictionnaire fournit toutes les valeurs qui constituent la clef
109  
-        primaire de l'objet, alors l'objet est chargé depuis la base. Puis
110  
-        les valeurs indiquées dans le dictionnaire sont rentrées dans l'objet
111  
-        chargée.
  104
+        If all values got from dictionnary form the primary key, the object is
  105
+        loaded from database. Other values are set in the loading object.
112 106
 
113 107
         .. code-block:: python
114 108
 
@@ -122,8 +116,8 @@ def load(cls, d, hard=False):
122 116
             >>> Treatment.get(id=1).name
123 117
             'Awesome Treatment'
124 118
 
125  
-        Si l'option `hard` est à True , une exception est levée si une valeur
126  
-        n'est pas trouvée dans le dictionnaire fournit.
  119
+        If `hard` parameter is True, an axception is raised if a value isn't found
  120
+        in parameter's dictionnary.
127 121
         """
128 122
 
129 123
         # On détermine si on doit charger l'instance depuis la base ou non.
@@ -187,15 +181,13 @@ def load(cls, d, hard=False):
187 181
 
188 182
     def dump(self, excludes=[], depth=2):
189 183
         """
190  
-        Retourne l'objet sous forme de dictionnaire python avec ses
191  
-        dépendances.
  184
+        Return object as dictionnary with dependencies.
192 185
 
193  
-        La profondeur permet de ne pas copier les attributs trop profondéments.
194  
-        Par exemple avec une profondeur de 1, on n'ira pas chercher les objets
195  
-        en relation.
  186
+        `Depth` limits the recursion.
196 187
 
197  
-        Le paramètre d'exclusion sert à exclure les attributs que l'on ne
198  
-        veut pas exporter.
  188
+        IE : With depth set as 1, objects in relations aren't search.
  189
+
  190
+        `excludes` use to excludes unwanted attributes.
199 191
 
200 192
         .. code-block:: python
201 193
 
6  sqla_helpers/loading.py
@@ -4,8 +4,10 @@
4 4
 
5 5
 def instancied(cls):
6 6
     """
7  
-    Instancie une classe sans passer par le __init__.
8  
-    Il faudrait être un peu plus sur de la création de l'objet..
  7
+    Return a class without use on `__init__`.
  8
+
  9
+
  10
+    Need more assurance about object creation
9 11
     """
10 12
     instance = cls.__new__(cls)
11 13
     instance._sa_instance_state = InstanceState(instance,
63  sqla_helpers/logical.py
... ...
@@ -1,8 +1,8 @@
1 1
 # -*- coding: utf-8 -*-
2 2
 
3 3
 """
4  
-Arbre de syntaxe abstraite
5  
-==========================
  4
+Abstract Syntatic Tree
  5
+======================
6 6
 
7 7
 .. autoclass:: ASTNode
8 8
     :members:
@@ -23,30 +23,29 @@
23 23
 
24 24
 class ASTNode(object):
25 25
     """
26  
-    Un nœud d'arbre représentant un opérateur logique (SQLAlchemy)
27  
-    Il contient soit un ensemble de critères soit deux autres nœud d'arbres (ses
28  
-    enfants.)
  26
+    A tree's node represent a logic Sqlalchemy operator.
  27
+    Contains 2 child tree of a set of  criterion.
29 28
 
30  
-    Les critères gérés sont ceux d'écrit par la synxate de :mod:`sqla_helpers`
31 29
 
32  
-        >>> ast = AndASTNode(id=4, status__name='toto')
  30
+    Handled criterions are describe in  :mod:`sqla_helpers`.
33 31
 
34  
-    Les critères seront interprétés par la fonction process_param lors du
35  
-    parcours du sous-arbre par la fonction __call__
  32
+        >>> ast = AndASTNode(id=4, status__name='foo')
  33
+
  34
+    Criterions 'll be interpreted by the `process_param` function
  35
+    during processing of subtree by `__call__` function.
36 36
 
37 37
         >>> ast(MyClass, [])
38 38
         <sqlalchemy.sql.expression.BinaryExpression object at 0x1f04090>
39 39
 
40  
-    Un nœud est une feuille de l'arbre si il contient des critères. (i.e. que
41  
-    l'attribut :attr:`ASTNode.operand` n'est pas à None)
  40
+    If a node contains criterions, the node is a leave. (meaning the :attr:`ASTNode.operand`
  41
+    attribute is not `None`.)
42 42
 
43  
-    Sinon, il a des enfants et le parcours de l'arbre est un appel récursif pour
44  
-    chacun des fils.
  43
+    If node contains children, a recursive processing of children subtree is done.
45 44
 
46  
-    La méthode `ASTNode.operator` est exécutée au retour de process_params ou
47  
-    bien au retour de l'appel récursif sur les fils.
  45
+    `ASTNode.operator` metod is excecuted during the return of `process_param`
  46
+    or during the recursive return of children.
48 47
 
49  
-    ASTNode est une classe abstraite qui n'implémente pas `ASTNode.operator`.
  48
+    :class: `ASTNode` is an abstract class which doesn't implement :method: ASTNode.operator`.
50 49
     """
51 50
 
52 51
     def operator(self, *args, **kwargs):
@@ -61,7 +60,7 @@ def __init__(self, lhs=None, rhs=None, **operand):
61 60
 
62 61
     def __call__(self, klass, class_found):
63 62
         """
64  
-        Parcours et interprétation de chaque nœud de l'arbre.
  63
+        Process and interprets every node.
65 64
         """
66 65
         # Si l'on a des paramètres bruts, c'est que l'on est une feuille de
67 66
         # l'arbre
@@ -84,7 +83,7 @@ class OrASTNode(ASTNode):
84 83
 
85 84
     def operator(self, *args):
86 85
         """
87  
-        Exécute un OU logique sur des critères SQLAlchemy
  86
+        Excecut a logical or on `SQLAlchemy` criterions.
88 87
         """
89 88
         return or_(*args)
90 89
 
@@ -93,7 +92,7 @@ class AndASTNode(ASTNode):
93 92
 
94 93
     def operator(self, *args):
95 94
         """
96  
-        Exécute un ET logique sur des critères SQLAlchemy
  95
+        Excecut a logical and on `SQLAlchemy` criterions.
97 96
         """
98 97
         return and_(*args)
99 98
 
@@ -114,18 +113,18 @@ def operator(self, *args):
114 113
 
115 114
 class Q(object):
116 115
     """
117  
-    Classe représentant des opérations logiques en conservrant une
118  
-    syntaxe sqla_helpers
119  
-
120  
-
121  
-    Le Q object n'est là que pour récupérer la syntaxe sqla_helpers et
122  
-    implémenter des opérations (or , and, not...).
123  
-    Au fur et à mesure des opération le Q Object maintient un AST.
124  
-    Chaque opération renvoit en fait un Q object avec un AST mis à jour
125  
-    par rapport à l'objet courant et l'objet avec lequel on fait une opération
126  
-    C'est le __call__ du Q object qui fait un appel sous-jacent au __call__ de
127  
-    des nœud de l'ast. Le retour étant un opération d'SQLAlchemy que l'on peut
128  
-    passer un objet Query.
  116
+    Class representing logical operators with sqla_helpers syntax.
  117
+
  118
+    Q object is only here for processing the `sqla_helpers` syntax
  119
+    and implements opertators such as `or`, `and`, `not` ...
  120
+
  121
+    During operations, the :class:`Q` object maintains an AST.
  122
+    Each operation return a :class:`Q` object with an updated AST in
  123
+    relation the current object and the operating object.
  124
+
  125
+    The :method: `__call__` from :class:`Q` call the :method:`__call__`
  126
+    from AST children. The return is an `SQLAlchemy` opertation usable in
  127
+    a `Query` object.
129 128
     """
130 129
 
131 130
     def __init__(self, astnode=None, **kwargs):
@@ -137,7 +136,7 @@ def __init__(self, astnode=None, **kwargs):
137 136
 
138 137
     def __call__(self, klass, class_found):
139 138
         """
140  
-        Parcours et interprète l'arbre représenté par le Q object courant.
  139
+        Processing and interpreting AST of current `Q` object.
141 140
         """
142 141
         return self.ast(klass, class_found)
143 142
 
30  sqla_helpers/process.py
@@ -10,29 +10,26 @@
10 10
     'ilike': 'ilike',
11 11
 }
12 12
 """
13  
-Dictionnaire des opérateurs applicables à un InstrumentedAttribut
14  
-La clef représente l'opérateur dans la syntaxe :mod:`sqla_helpers` et la valeur
15  
-est le nom de la méthode a appellé sur un objet de type. InstrumentAttribut
  13
+Dictonnary of usasable operators to a `InstrumentedAttribut`.
  14
+Keys are operators in :mod:`sqla_helpers` syntax and values are methods name
  15
+called by an InstrumentAttribut object.
16 16
 """
17 17
 
18 18
 def process_params(cls, class_found, **kwargs):
19 19
     """
20  
-    Retourne une liste de critères SQLAlchemy suivant la syntaxe sqla_helpers.
  20
+    Returns a `SQLAlchemy` criterions list matching :mod:`sqla_helpers` syntax.
21 21
 
22  
-    :param:`cls` est la classe racine à partir de laquelle les attributs seront
23  
-    récupérer.
  22
+    :param:`cls` is the root class providing attributes
24 23
 
25  
-    Au fur et à mesure du traitement, on stock les classes des attributs
26  
-    rencontrées dans le paramètre :param:`class_found`. Elles ne sont ajoutées
27  
-    que lorsqu'elles n'apparaissent pas dans la liste (i.e. pas de doublon dans
28  
-    la liste.)
  24
+    During processing, found attributes are stored  in :param:`class_found`
  25
+    parameters. :param:`class_found` is a set.
29 26
 
30  
-    L'attribut est donc modifié au fur et à mesure du traitement (Effet de bord).
  27
+    Attribute is updated during process.
31 28
 
32  
-    .. rubric:: Exemple
  29
+    .. rubric:: Example
33 30
 
34  
-    Si l'on souhaite faire une recherche sur l'attribut `name` d'un objet de la
35  
-    classe Treatment, la fonction sera appellée:
  31
+    If a quering on the attribute `name` from a `Treatment` object, the function
  32
+    'll be called:
36 33
 
37 34
     .. code-block:: python
38 35
 
@@ -42,9 +39,8 @@ def process_params(cls, class_found, **kwargs):
42 39
         >>> class_found
43 40
         []
44 41
 
45  
-    Dans cet exemple le paramètre :param:`class_found` n'a pas bougé puisque
46  
-    l'attribut `name` n'est pas un objet ezn relation. Mais si nous recherchions
47  
-    des traitments par status nous aurions
  42
+    In this example, because of the attribute `name` isn't in the related object, the
  43
+    :param:`class_found` isn't modified. In other hand a query on `status` attribute :
48 44
 
49 45
     .. code-block:: python
50 46
 

0 notes on commit 47f9174

Please sign in to comment.
Something went wrong with that request. Please try again.