Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

Loading…

Translation #1

Merged
merged 7 commits into from

2 participants

Commits on Mar 15, 2013
  1. begin translation

    Cyprien Le Pannérer authored
  2. purge before WE

    Cyprien Le Pannérer authored
Commits on Mar 24, 2013
  1. @cyplp
  2. @cyplp
  3. @cyplp
  4. @cyplp
  5. @cyplp
This page is out of date. Refresh to see the latest.
View
165 doc/sqla_helpers.rst
@@ -5,7 +5,7 @@ Installation
.. rubric:: Git
-Installation depuis le dépôt git
+Installation from git
.. code-block:: console
@@ -15,7 +15,7 @@ Installation depuis le dépôt git
.. rubric:: Eggs
-Installation depuis les archives `eggs`
+Installation from pypi `eggs`
.. code-block:: console
@@ -25,14 +25,11 @@ Installation depuis les archives `eggs`
Getting Started
----------------
-:class:`sqla_helpers.base_model.BaseModel` a pour but d'instrumenter la syntaxe d'SQLAlchemy pour
-fournir à l'utiliseur final, des méthodes simplifiées permettant la récupération
-d'objets en base.
+The purpose :class:`sqla_helpers.base_model.BaseModel` is to implement the `SQLAlchemy` syntax with simplified methods for querying.
-:class:`sqla_helpers.base_model.BaseModel` est une classe qui est utilisable en tant que Mixin, elle
-n'hérite d'aucune classe et elle n'est pas à sous-classer.
-Pour avoir accès aux méthodes dans un modèle, il faut alors déclarer une table
-comme ceci:
+
+:class:`sqla_helpers.base_model.BaseModel` is to be use in a mixin class. this class inherits from nothing and shouldn't be inherited.
+For access method from model, Table need to be implement as bellow:
.. code-block:: python
@@ -51,12 +48,10 @@ comme ceci:
model_id = ... # Clef étrangère sur MyModel
-La classe :class:`DeclarativeBase` est la classe générée par la fonction
-:func:`declarative_base` d'SQLAlchemy.
-
-Il est également possible d'utiliser :class:`sqla_helpers.base_model.BaseModel` comme paramètre `cls` de la fonction :func:`declarative_base`.
-Et ainsi on peut se passer de l'utilisation de la classe comme Mixin.
+The :class:`DeclarativeBase` class if generated by :func:`declarative_base` function from `SQLAlchemy`.
+:class:`sqla_helpers.base_model.BaseModel` class can be use as `cls` parameter in :func:`declarative_base`
+function. This prevents the mixin use of the class.
.. code-block:: python
@@ -71,36 +66,33 @@ Et ainsi on peut se passer de l'utilisation de la classe comme Mixin.
# ...
-:class:`sqla_helpers.base_model.BaseModel` attend une manière de récupérer une session quand une requête est effectuée.
-Pour ce faire, elle fait appel à la fonction stockée dans l'attribut :attr:`sqla_helpers.base_model.BaseModel.sessionmaker`.
-Ainsi, lors de l'initialisation de l'application, il faut stocker un
-sessionmaker dans la classe, grâce à la méthode
-`sqla_helpers.base_model.BaseModel.register_sessionmaker`
+:class:`sqla_helpers.base_model.BaseModel` need a to have a method for getting a session when querying is done.
+For this purpose, the class use the stored function in :attr:`sqla_helpers.base_model.BaseModel.sessionmaker`.:
+So a sessionmaker is need to be stored using the `sqla_helpers.base_model.BaseModel.register_sessionmaker` method
.. code-block:: python
- # Initialisation de l'application
+ # Application's initialization
def main():
# ...
BaseModel.register_sessionmaker(scoped_session(sessionmaker(bind=engine)))
# ...
-
-Pour passer une session globale, il suffit simplement que la fonction passée à :attr:`sqla_helpers.base_model.BaseModel.sessionmaker`
-renvoie la référence sur la session globale
+For a global session, the function set in :attr:`sqla_helpers.base_model.BaseModel.sessionmaker` should return
+a reference to a global session.
.. code-block:: python
from somwhere import DBSession
- # Initialisation de l'application
+ # Application's initialization
def main():
# ...
BaseModel.register_sessionmaker(lambda: DBSession)
# ...
-Cas d'utilisation simple :
+Basic use case :
.. code-block:: python
@@ -116,12 +108,11 @@ Cas d'utilisation simple :
[]
-* :meth:`sqla_helpers.base_model.BaseModel.all` ramène l'ensemble des objets en base.
-* :meth:`sqla_helpers.base_model.BaseModel.filter` ramène les objets correspondants aux critères donnés sous forme de liste.
-* :meth:`sqla_helpers.base_model.BaseModel.get` ramène un unique élément correspond aux critères données.
+* :meth:`sqla_helpers.base_model.BaseModel.all` returns all database objects
+* :meth:`sqla_helpers.base_model.BaseModel.filter` returns a list of matching objects.
+* :meth:`sqla_helpers.base_model.BaseModel.get` return an uniq maching object.
-On peut bien évidemment enchaîner les critères de recherche qui seront pris en
-compte avec un opérateur `&&` (ET) logique.
+Querying criterions can be chained with an `&&` (logical and) operator.
.. code-block:: python
@@ -131,81 +122,75 @@ compte avec un opérateur `&&` (ET) logique.
[<MyOtherModel object at 0x2c19d90>]
-Recherche sur critères de relation
-----------------------------------
+Querying for criterions on relations
+------------------------------------
-Les critères de recherche valides pour une classe sont définies par ses
-attributs (Pour MyOtherModel ça sera `id`, `name`, `model_id`).
+Valid quering criterions for a class ared definied by the class attributes.
+IE : in case of `MyOtherModel`, criterions can be `id`, `name` and `model_id`.
-Cela est également valable pour le relation SQLAlchemy.
+This still true for a Sqlachemy relation.
-Par exemple, on peut rechercher tous les MyModel dont le MyOtherModel a pour nom
-'toto'
+IE: quering all `MyModel` witch `MyOtherModel` have a name 'foo'.
.. code-block:: python
- >>> MyModel.filter(awesome_attr__name='toto')
+ >>> MyModel.filter(awesome_attr__name='foo')
[<MyModel object at 0x2c19d90>]
-On peut même rechercher suivant un objet complet.
+Quering a with entire object.
.. code-block:: python
- >>> otherModel = MyOtherModel.get(name='toto')
+ >>> otherModel = MyOtherModel.get(name='foo')
>>> MyModel.filter(awesome_attr=otherModel)
[<MyModel object at 0x2c19d90>]
-Le séparateur `__` (double underscore) permet de faire la séparation entre les
-différentes entités sollicitées.
+The `__` separator (double underscore) permits to split between the differents entities.
-La recherche par les attributs des relations peut se faire en profondeur.
-Imaginons que `MyOtherObject` est un attribut `other_attr` qui est en relation
-avec un objet MyOtherOtherObject.
+Quering with relation`s attributes can be recursive.
+If `MyOtherObject` have an `other_attr` attribute which is in relation with a `MyOtherOtherObject` object.
-Il est alors possible de rechercher tous les MyModel dont le MyOtherObject a un
-MyOtherOtherObject dont le nom est 'toto'.
+Quering all `MyModel` which a `MyOtherObject` has `MyOtherOtherObject` has a `name` attribute is 'foo'.
.. code-block:: python
- >>> MyModel.filter(awesome_attr__other_attr__name='toto')
+ >>> MyModel.filter(awesome_attr__other_attr__name='foo')
[<MyModel object at 0x2c19d90>]
-Des opérateurs
---------------
+Operators
+---------
-Il est possible de spécifier d'autres critères que ceux d'égalités. En séparant
-encore une fois, avec des '__' (doubles underscores) et en mettant le nom de
-l'opérateur à la fin du critère.
+Others criterions than equality can be used. These criterions sould be writen
+with the attribute name following '__' (double underscore) and name of the operator.
-Par exemple, si l'on veut tous les MyModel qui n'ont PAS pour id la valeur 2.
+IE: if all `MyModel` which `id` is different from 2 are wanted:
.. code-block:: python
>>> MyModel.filter(id__not=2)
[]
-Les opérateurs disponibles sont :
+Available operatores are:
-* 'not': Non-égal
-* 'lt': inférieur
-* 'le': Inférieur ou égal
-* 'gt': Plus grand
-* 'gte': Plus grand ou égal
-* 'in': Contenu dans (Le paramètre de recherche doit-être une liste)
-* 'like': opérateur SQL LIKE
-* 'ilike': opérateur SQL ILIKE
+* 'not': Non-equal,
+* 'lt': letter than,
+* 'le': letter or equals than,
+* 'gt': gretter than,
+* 'gte': gretter or equal than,
+* 'in': in a list,
+* 'like': SQL `LIKE` operator,
+* 'ilike': SQL `ILIKE` operator.
-Requêtes plus complexes
------------------------
+More complex quering
+--------------------
-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
-Le :class:`sqla_helpers.logical.Q` object est capable de prendre ne compte la
-syntaxe sqla_helpers.
+In the Django spirit, :mod:`sqla_helpers` provide a :class:`sqla_helpers.logical.Q` object for more complex quering.
+The :class:`sqla_helpers.logical.Q` object can use the :mod:`sqla_helpers' syntax.
.. code-block:: python
@@ -214,7 +199,8 @@ syntaxe sqla_helpers.
<sqla_helpers.logical.Q at 0x2376cd0>
-Ces objets sont transmissibles aux méthodes de recherches de la classe
+These objects are usable as criterions for query.
+
:class:`sqla_helpers.base_model.BaseModel`
.. code-block:: python
@@ -222,10 +208,9 @@ Ces objets sont transmissibles aux méthodes de recherches de la classe
>>> Treatment.get(Q(id=2))
>>> <sqlalchemy_test.models.Treatment at 0x2388690>
-L'avantage de ces objets, c'est qu'ils permettent de décrire des conditions
-logiques SQL à travers une syntaxe python.
+The purpose of these objects is to permit SQL logical conditions in a python syntax.
-Si l'on veut les traitments qui ont pour id 2 OU le status à pour nom 'KO'
+If all `Treatment` objects which have an `id` == 2 or a `Status` name == 'KO' are wanted.
.. code-block:: python
@@ -233,7 +218,7 @@ Si l'on veut les traitments qui ont pour id 2 OU le status à pour nom 'KO'
[<sqlalchemy_test.models.Treatment at 0x2388690>, <sqlalchemy_test.models.Treatment at 0x23837d0>]
-Si l'on veut tous les traitments qui n'ont pas pour id 2
+For getting, all `Treatment` objects with an `id' attribute different than 2 :
.. code-block:: python
@@ -241,7 +226,7 @@ Si l'on veut tous les traitments qui n'ont pas pour id 2
[<sqlalchemy_test.models.Treatment at 0x2383450>, <sqlalchemy_test.models.Treatment at 0x23837d0>,
<sqlalchemy_test.models.Treatment at 0x23886d0> ]
-Mais on peut également enchainer les opérations logiques
+Logical operators can be chained :
.. code-block:: python
@@ -257,14 +242,13 @@ Mais on peut également enchainer les opérations logiques
>>> [<sqlalchemy_test.models.Treatment at 0x2388690>]
-Du JSON
--------
+JSON
+----
-Souvent dans les applications web, le client et le serveur communique par l'intermédiaire du format JSON.
-Pour faciliter les opérations de chargement, :mod:`sqla_helpers` fournit des
-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.
+Often in web oriented applications, client and server exchange with JSON format.
+In a purpose of easier loading, :mod:`sqla_helpers` furnish methods for loading from a regular python dictionary or a SQLAlchemy model object.
-La méthode :meth:`sqla_helpers.base_model.BaseModel.dump` permet la génération d'un dictionnaire qui est transformable en JSON.
+The :meth:`sqla_helpers.base_model.BaseModel.dump` method permit a JSON compatible dictionnary.
.. code-block:: python
@@ -280,12 +264,11 @@ La méthode :meth:`sqla_helpers.base_model.BaseModel.dump` permet la génératio
}
-Et la méthode de classe `sqla_helpers.base_model.BaseModel.load` qui permet d'instancier des objets à partir d'un dictionnaire.
-Le passage par dictionnaire est sensé faciliter l'accès aux données en JSON ou bien générer du JSON depuis le
-dictionnaire.
+The method `sqla_helpers.base_model.BaseModel.load` can construct object from a dictionnary.
+The meaning of use a dictionnary is to facillitate access to data in JSON or generate JSON frpm dictionnary.
-Pour le chargement d'un objet, les objets sont récupérés en base si les attributs composant la clef primaire
-sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
+Objects are getting from database if primary key attributes are found on the dictionnary. Otherwise new object
+are created.
.. code-block:: python
@@ -295,7 +278,7 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
>>> t.id
7
>>> t.status.name
- 'Sacre status !'
+ 'Holy status !'
>>> t.status.id
7
>>> t = Treatment.load({'id': 7, 'name': 'hello'})
@@ -306,7 +289,7 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
{
'id': 7,
'name': u'hello',
- 'status': {'id': 7, 'name': u'Sacre status !'},
+ 'status': {'id': 7, 'name': u'Holy status !'},
'status_id': 7
}
>>> tr = Treatment.load(t.dump())
@@ -318,10 +301,10 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
{
'id': 7,
'name': u'hello',
- 'status': {'id': 7, 'name': u'Sacre status !'},
+ 'status': {'id': 7, 'name': u'Holy status !'},
'status_id': 7
}
- >>> tr = Treatment.load({'name': 'nouveau traitmente', 'status': {'name': 'nouveau status'}})
+ >>> tr = Treatment.load({'name': 'new treatment', 'status': {'name': 'new status'}})
>>> tr.id
None
>>> tr.status.id
@@ -334,7 +317,7 @@ sont trouvés dans le dictionnaire. Sinon, une nouvelle instance est créée.
8
-La classe :class:`sqla_helpers.base_model.BaseModel`
-====================================================
+:class:`sqla_helpers.base_model.BaseModel` class
+================================================
.. automodule:: sqla_helpers.base_model
View
2  setup.py
@@ -13,7 +13,7 @@
version=sqla_helpers.__version__,
author='Guillaume Camera',
author_email='camera.g@gmail.com',
- description="Fournit quelques méthodes de récupération d'objet en base autour d'SQLAlchemy",
+ description="Provides some methogs for getting objects with SQLAlchemy",
long_description=long_description,
url="https://github.com/moumoutte/sqla_helpers/",
packages=find_packages(),
View
54 sqla_helpers/base_model.py
@@ -11,8 +11,7 @@
class ClassProperty(property):
"""
- Classe qui a pour but de fournir une alternative à l'utilisation du
- decaroteur property pour un attribut de classe.
+ Class an alternative use or property decorator in class attribute.
"""
def __get__(self, cls, owner):
return self.fget.__get__(None, owner)()
@@ -20,8 +19,8 @@ def __get__(self, cls, owner):
class BaseModel(object):
"""
- Classe d'un modèle de base. Elle fournit du sucre syntaxiques pour faire de
- la récupération d'objets en base.
+ Base Model Class.
+ Provide syntatic sugar for getting object from database.
"""
process_params = classmethod(process_params)
@@ -30,8 +29,8 @@ class BaseModel(object):
@classmethod
def register_sessionmaker(cls, sessionmaker):
"""
- Enregistrement de la fonction utiliser pour créer une session.
- La fonction enregistrée ne doit prendre aucun paramètre
+ Register the function for making session.
+ This registered function mustn't have any parameters.
"""
cls.sessionmaker = staticmethod(sessionmaker)
@@ -40,11 +39,9 @@ def register_sessionmaker(cls, sessionmaker):
@classmethod
def session(cls):
"""
- Appelle :attr:`BaseModel.sessionmaker` et renvoie une session
- nouvellement construite.
+ Call :attr:`BaseModel.sessionmaker` and returns a new session.
- Ne pas oubliez de mettre en place :attr:`BaseModel.sessionmaker` dans
- l'initialisation de l'application.
+ Don't forget to call :attr:`BaseModel.sessionmaker` in application's initialization.
"""
return cls.sessionmaker()
@@ -52,10 +49,10 @@ def session(cls):
@classmethod
def search(cls, *operator, **criterion):
"""
- Effectue la recherche d'objet suivant les critères passés en arguments.
- Le retour est un objet :class:`sqlachemy.orm.query.Query`
+ Object seatch with filter pass in arguments.
+ Return a :class:`sqlachemy.orm.query.Query` object.
- Ce qui permet d'enchaîner les critères de recherches si besoin.
+ Filters can be chained.
"""
query = cls.session.query(cls)
# On maintient une liste des classes déjà jointes
@@ -76,7 +73,7 @@ def search(cls, *operator, **criterion):
@classmethod
def get(cls, *operators, **criterions):
"""
- Retourne un objet correspond aux critères donnés.
+ Return a object with criterions passed in parameters.
"""
query = cls.search(*operators, **criterions)
return query.one()
@@ -85,7 +82,7 @@ def get(cls, *operators, **criterions):
@classmethod
def all(cls):
"""
- Retourne tous les objets d'une classe contenu en base.
+ Return all objects from a same class containts in database.
"""
return cls.search().all()
@@ -93,7 +90,7 @@ def all(cls):
@classmethod
def filter(cls, *operators, **criterions):
"""
- Retourne une liste d'objets d'une classe correspond aux critères donnés.
+ Return a list of objects from a class matching criterions passed in parameters.
"""
query = cls.search(*operators, **criterions)
return query.all()
@@ -102,13 +99,10 @@ def filter(cls, *operators, **criterions):
@classmethod
def load(cls, d, hard=False):
"""
- Instancie un objet de la classe à partir d'attribut récupérer dans le
- dictionnaire fournit.
+ Return a object from class with attributes got in dictionnary's parameters.
- Si le dictionnaire fournit toutes les valeurs qui constituent la clef
- primaire de l'objet, alors l'objet est chargé depuis la base. Puis
- les valeurs indiquées dans le dictionnaire sont rentrées dans l'objet
- chargée.
+ If all values got from dictionnary form the primary key, the object is
+ loaded from database. Other values are set in the loading object.
.. code-block:: python
@@ -122,8 +116,8 @@ def load(cls, d, hard=False):
>>> Treatment.get(id=1).name
'Awesome Treatment'
- Si l'option `hard` est à True , une exception est levée si une valeur
- n'est pas trouvée dans le dictionnaire fournit.
+ If `hard` parameter is True, an axception is raised if a value isn't found
+ in parameter's dictionnary.
"""
# On détermine si on doit charger l'instance depuis la base ou non.
@@ -187,15 +181,13 @@ def load(cls, d, hard=False):
def dump(self, excludes=[], depth=2):
"""
- Retourne l'objet sous forme de dictionnaire python avec ses
- dépendances.
+ Return object as dictionnary with dependencies.
- La profondeur permet de ne pas copier les attributs trop profondéments.
- Par exemple avec une profondeur de 1, on n'ira pas chercher les objets
- en relation.
+ `Depth` limits the recursion.
- Le paramètre d'exclusion sert à exclure les attributs que l'on ne
- veut pas exporter.
+ IE : With depth set as 1, objects in relations aren't search.
+
+ `excludes` use to excludes unwanted attributes.
.. code-block:: python
View
6 sqla_helpers/loading.py
@@ -4,8 +4,10 @@
def instancied(cls):
"""
- Instancie une classe sans passer par le __init__.
- Il faudrait être un peu plus sur de la création de l'objet..
+ Return a class without use on `__init__`.
+
+
+ Need more assurance about object creation
"""
instance = cls.__new__(cls)
instance._sa_instance_state = InstanceState(instance,
View
63 sqla_helpers/logical.py
@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
"""
-Arbre de syntaxe abstraite
-==========================
+Abstract Syntatic Tree
+======================
.. autoclass:: ASTNode
:members:
@@ -23,30 +23,29 @@
class ASTNode(object):
"""
- Un nœud d'arbre représentant un opérateur logique (SQLAlchemy)
- Il contient soit un ensemble de critères soit deux autres nœud d'arbres (ses
- enfants.)
+ A tree's node represent a logic Sqlalchemy operator.
+ Contains 2 child tree of a set of criterion.
- Les critères gérés sont ceux d'écrit par la synxate de :mod:`sqla_helpers`
- >>> ast = AndASTNode(id=4, status__name='toto')
+ Handled criterions are describe in :mod:`sqla_helpers`.
- Les critères seront interprétés par la fonction process_param lors du
- parcours du sous-arbre par la fonction __call__
+ >>> ast = AndASTNode(id=4, status__name='foo')
+
+ Criterions 'll be interpreted by the `process_param` function
+ during processing of subtree by `__call__` function.
>>> ast(MyClass, [])
<sqlalchemy.sql.expression.BinaryExpression object at 0x1f04090>
- Un nœud est une feuille de l'arbre si il contient des critères. (i.e. que
- l'attribut :attr:`ASTNode.operand` n'est pas à None)
+ If a node contains criterions, the node is a leave. (meaning the :attr:`ASTNode.operand`
+ attribute is not `None`.)
- Sinon, il a des enfants et le parcours de l'arbre est un appel récursif pour
- chacun des fils.
+ If node contains children, a recursive processing of children subtree is done.
- La méthode `ASTNode.operator` est exécutée au retour de process_params ou
- bien au retour de l'appel récursif sur les fils.
+ `ASTNode.operator` metod is excecuted during the return of `process_param`
+ or during the recursive return of children.
- ASTNode est une classe abstraite qui n'implémente pas `ASTNode.operator`.
+ :class: `ASTNode` is an abstract class which doesn't implement :method: ASTNode.operator`.
"""
def operator(self, *args, **kwargs):
@@ -61,7 +60,7 @@ def __init__(self, lhs=None, rhs=None, **operand):
def __call__(self, klass, class_found):
"""
- Parcours et interprétation de chaque nœud de l'arbre.
+ Process and interprets every node.
"""
# Si l'on a des paramètres bruts, c'est que l'on est une feuille de
# l'arbre
@@ -84,7 +83,7 @@ class OrASTNode(ASTNode):
def operator(self, *args):
"""
- Exécute un OU logique sur des critères SQLAlchemy
+ Excecut a logical or on `SQLAlchemy` criterions.
"""
return or_(*args)
@@ -93,7 +92,7 @@ class AndASTNode(ASTNode):
def operator(self, *args):
"""
- Exécute un ET logique sur des critères SQLAlchemy
+ Excecut a logical and on `SQLAlchemy` criterions.
"""
return and_(*args)
@@ -114,18 +113,18 @@ def operator(self, *args):
class Q(object):
"""
- Classe représentant des opérations logiques en conservrant une
- syntaxe sqla_helpers
-
-
- Le Q object n'est là que pour récupérer la syntaxe sqla_helpers et
- implémenter des opérations (or , and, not...).
- Au fur et à mesure des opération le Q Object maintient un AST.
- Chaque opération renvoit en fait un Q object avec un AST mis à jour
- par rapport à l'objet courant et l'objet avec lequel on fait une opération
- C'est le __call__ du Q object qui fait un appel sous-jacent au __call__ de
- des nœud de l'ast. Le retour étant un opération d'SQLAlchemy que l'on peut
- passer un objet Query.
+ Class representing logical operators with sqla_helpers syntax.
+
+ Q object is only here for processing the `sqla_helpers` syntax
+ and implements opertators such as `or`, `and`, `not` ...
+
+ During operations, the :class:`Q` object maintains an AST.
+ Each operation return a :class:`Q` object with an updated AST in
+ relation the current object and the operating object.
+
+ The :method: `__call__` from :class:`Q` call the :method:`__call__`
+ from AST children. The return is an `SQLAlchemy` opertation usable in
+ a `Query` object.
"""
def __init__(self, astnode=None, **kwargs):
@@ -137,7 +136,7 @@ def __init__(self, astnode=None, **kwargs):
def __call__(self, klass, class_found):
"""
- Parcours et interprète l'arbre représenté par le Q object courant.
+ Processing and interpreting AST of current `Q` object.
"""
return self.ast(klass, class_found)
View
30 sqla_helpers/process.py
@@ -10,29 +10,26 @@
'ilike': 'ilike',
}
"""
-Dictionnaire des opérateurs applicables à un InstrumentedAttribut
-La clef représente l'opérateur dans la syntaxe :mod:`sqla_helpers` et la valeur
-est le nom de la méthode a appellé sur un objet de type. InstrumentAttribut
+Dictonnary of usasable operators to a `InstrumentedAttribut`.
+Keys are operators in :mod:`sqla_helpers` syntax and values are methods name
+called by an InstrumentAttribut object.
"""
def process_params(cls, class_found, **kwargs):
"""
- Retourne une liste de critères SQLAlchemy suivant la syntaxe sqla_helpers.
+ Returns a `SQLAlchemy` criterions list matching :mod:`sqla_helpers` syntax.
- :param:`cls` est la classe racine à partir de laquelle les attributs seront
- récupérer.
+ :param:`cls` is the root class providing attributes
- Au fur et à mesure du traitement, on stock les classes des attributs
- rencontrées dans le paramètre :param:`class_found`. Elles ne sont ajoutées
- que lorsqu'elles n'apparaissent pas dans la liste (i.e. pas de doublon dans
- la liste.)
+ During processing, found attributes are stored in :param:`class_found`
+ parameters. :param:`class_found` is a set.
- L'attribut est donc modifié au fur et à mesure du traitement (Effet de bord).
+ Attribute is updated during process.
- .. rubric:: Exemple
+ .. rubric:: Example
- Si l'on souhaite faire une recherche sur l'attribut `name` d'un objet de la
- classe Treatment, la fonction sera appellée:
+ If a quering on the attribute `name` from a `Treatment` object, the function
+ 'll be called:
.. code-block:: python
@@ -42,9 +39,8 @@ def process_params(cls, class_found, **kwargs):
>>> class_found
[]
- Dans cet exemple le paramètre :param:`class_found` n'a pas bougé puisque
- l'attribut `name` n'est pas un objet ezn relation. Mais si nous recherchions
- des traitments par status nous aurions
+ In this example, because of the attribute `name` isn't in the related object, the
+ :param:`class_found` isn't modified. In other hand a query on `status` attribute :
.. code-block:: python
Something went wrong with that request. Please try again.