I&#39;m not sure about buildout, however, for setuptools/distribute, you specify version info with the comparison operators (like `==`, `&gt;=`, or `&lt;=`).

For example:

    install_requires = [&#39;django-pipeline==1.1.22&#39;, &#39;south&gt;=0.7&#39;]

You can add them to your `requirements.txt` file along with the version.

For example:

    django-pipeline==1.1.22
    south&gt;=0.7

and then in your `setup.py`

    import os
    from setuptools import setup
    
    with open(&#39;requirements.txt&#39;) as f:
        required = f.read().splitlines()
    
    setup(...
    install_requires=required,
    ...)

**Reading from the docs -** 

&gt; It is not considered best practice to use `install_requires` to pin
&gt; dependencies to specific versions, or to specify sub-dependencies
&gt; (i.e. dependencies of your dependencies). This is overly-restrictive,
&gt; and prevents the user from gaining the benefit of dependency
&gt; upgrades.

https://packaging.python.org/discussions/install-requires-vs-requirements/#id5

Imagine I have an JS array like this:

    var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

What I want is to split that array into N smaller arrays. For instance:

    split_list_in_n(a, 2)
    [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11]]
    
    For N = 3:
    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11]]
    
    For N = 4:
    [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]]
    
    For N = 5:
    [[1, 2, 3], [4, 5], [6, 7], [8, 9], [10, 11]]


For Python, I have this:

    def split_list_in_n(l, cols):
        &quot;&quot;&quot; Split up a list in n lists evenly size chuncks &quot;&quot;&quot;
        start = 0
        for i in xrange(cols):
            stop = start + len(l[i::cols])
            yield l[start:stop]
            start = stop

For JS, the best right solution that I could come up with is a recursive function, but I don&#39;t like it because it&#39;s complicated and ugly. This inner function returns an array like this [1, 2, 3, null, 4, 5, 6, null, 7, 8], and then I have to loop it again and split it manually. (My first attempt was returning this: [1, 2, 3, [4, 5, 6, [7, 8, 9]]], and I decided to do it with the null separator).

    function split(array, cols) {
        if (cols==1) return array;
        var size = Math.ceil(array.length / cols);
        return array.slice(0, size).concat([null]).concat(split(array.slice(size), cols-1));
    }

Here&#39;s a jsfiddle of that: http://jsfiddle.net/uduhH/

How would you do that? Thanks!

Splitting a JS array into N arrays

What I need is a way to conditionally validate fields depending on if other fields are filled in.

Ex. I have a dropdown and a date field that are related.  If none of the fields are set then the form should pass validation.  However, if one of the two fields are set but the other isn&#39;t then the validation should fire, requiring the other field to be set.

I have written custom validation classes but it seems that it is validates on single fields.  Is there a way to set up the validation that I need using the built in validators?  If not, Is there a good way to connect two fields using a custom validator?

Conditional Validation using Fluent Validation

In my `setup.py` file, I&#39;ve specified a few libraries needed to run my project:

    setup(
        # ...
        install_requires = [
            &#39;django-pipeline&#39;,
            &#39;south&#39;
        ]
    )

How can I specify required versions of these libraries? 

How can I specify library versions in setup.py?

In my <code>setup.py</code> file, I've specified a few libraries needed to run my project:
<pre><code class="hljs language-ini">setup(
 # ...
 install_requires = [
 'django-pipeline',
 'south'
 ]
)
</code></pre>
How can I specify required versions of these libraries?

When storing a bool in memcached through python-memcached I noticed that it&#39;s returned as an integer. Checking the code of the library showed me that there is a place where `isinstance(val, int)` is checked to flag the value as an integer.

So I tested it in the python shell and noticed the following:

    &gt;&gt;&gt; isinstance(True, int)
    True
    &gt;&gt;&gt; issubclass(bool, int)
    True

But why exactly is `bool` a subclass of `int`?

It kind of makes sense because a boolean basically is an int which can just take two values but it needs much less operations/space than an actual integer (no arithmetics, only a single bit of storage space)....

Why is bool a subclass of int?

I have the following recursion code, at each node I call sql query to get the nodes belong to the parent node. 

here is the error: 

    Exception RuntimeError: &#39;maximum recursion depth exceeded&#39; in &lt;bound method DictCursor.__del__ of &lt;MySQLdb.cursors.DictCursor object at 0x879768c&gt;&gt; ignored

    RuntimeError: maximum recursion depth exceeded while calling a Python object
    Exception AttributeError: &quot;&#39;DictCursor&#39; object has no attribute &#39;connection&#39;&quot; in &lt;bound method DictCursor.__del__ of &lt;MySQLdb.cursors.DictCursor object at 0x879776c&gt;&gt; ignored


Method that I call to get sql results:

    def returnCategoryQuery(query, variables={}):
        cursor = db.cursor(cursors.DictCursor);
        catResults = [];
        try:
            cursor.execute(query, variables);
            for categoryRow in cursor.fetchall():
                catResults.append(categoryRow[&#39;cl_to&#39;]);
            return catResults;
        except Exception, e:
            traceback.print_exc();

I actually don&#39;t have any issue with the above method but I put it anyways to give proper overview of the question.
 
Recursion Code:

    def leaves(first, path=[]):
        if first:
            for elem in first:
                if elem.lower() != &#39;someString&#39;.lower():
                    if elem not in path:
                        queryVariable = {&#39;title&#39;: elem}
                        for sublist in leaves(returnCategoryQuery(categoryQuery, variables=queryVariable)):
                            path.append(sublist)
                            yield sublist
                        yield elem


Calling the recursive function 

    for key, value in idTitleDictionary.iteritems():
        for startCategory in value[0]:
            print startCategory + &quot; ==== Start Category&quot;;
            categoryResults = [];
            try:
                categoryRow = &quot;&quot;;
                baseCategoryTree[startCategory] = [];
                #print categoryQuery % {&#39;title&#39;: startCategory};
                cursor.execute(categoryQuery, {&#39;title&#39;: startCategory});
                done = False;
                while not done:
                    categoryRow = cursor.fetchone();
                    if not categoryRow:
                        done = True;
                        continue;
                    rowValue = categoryRow[&#39;cl_to&#39;];
                    categoryResults.append(rowValue);
            except Exception, e:
                traceback.print_exc();
            try:
                print &quot;Printing depth &quot; + str(depth);
                baseCategoryTree[startCategory].append(leaves(categoryResults))
            except Exception, e:
                traceback.print_exc();

Code to print the dictionary, 

    print &quot;---Printing-------&quot;
    for key, value in baseCategoryTree.iteritems():
        print key,
        for elem in value[0]:
            print elem + &#39;,&#39;;
        raw_input(&quot;Press Enter to continue...&quot;)
        print

If the recursion is too deep I should be getting the error when I call my recursion function, but when I get this error when I print the dictionary.

Python: Maximum recursion depth exceeded

I am trying to understand if it makes sense to take the content of a list and append it to another list.

I have the first list created through a loop function, that will get specific lines out of a file and will save them in a list.

Then a second list is used to save these lines, and start a new cycle over another file.

My idea was to get the list once that the for cycle is done, dump it into the second list, then start a new cycle, dump the content of the first list again into the second but appending it, so the second list will be the sum of all the smaller list files created in my loop. The list has to be appended only if certain conditions met. 

It looks like something similar to this:

    # This is done for each log in my directory, i have a loop running
    for logs in mydir:
    
        for line in mylog:
            #...if the conditions are met
            list1.append(line)
        
        for item in list1:
            if &quot;string&quot; in item: #if somewhere in the list1 i have a match for a string
                list2.append(list1) # append every line in list1 to list2
                del list1 [:] # delete the content of the list1
                break
            else:
                del list1 [:] # delete the list content and start all over

Does this makes sense or should I go for a different route?

I need something efficient that would not take up too many cycles, since the list of logs is long and each text file is pretty big; so I thought that the lists would fit the purpose.

Take the content of a list and append it to another list

I am using [mock][1] with Python and was wondering which of those two approaches is better (read: more pythonic). 

**Method one**:  Just create a mock object and use that. The code looks like:

    def test_one (self):
        mock = Mock()
        mock.method.return_value = True 
        self.sut.something(mock) # This should called mock.method and checks the result. 
        self.assertTrue(mock.method.called)

**Method two**:  Use patch to create a mock.  The code looks like:

    @patch(&quot;MyClass&quot;)
    def test_two (self, mock):
        instance = mock.return_value
        instance.method.return_value = True
        self.sut.something(instance) # This should called mock.method and checks the result. 
        self.assertTrue(instance.method.called)

Both methods do the same thing.  I am unsure of the differences. 

Could anyone enlighten me?


  [1]: http://www.voidspace.org.uk/python/mock/index.html

Mocking a class: Mock() or patch()?

Suppose I have a class with a constructor (or other function) that takes a variable number of arguments and then sets them as class attributes conditionally.

I could set them manually, but it seems that variable parameters are common enough in python that there should be a common idiom for doing this.  But I&#39;m not sure how to do this dynamically.

I have an example using eval, but that&#39;s hardly safe.  I want to know the proper way to do this -- maybe with lambda?

    class Foo:
        def setAllManually(self, a=None, b=None, c=None):
            if a!=None: 
                self.a = a
            if b!=None:
                self.b = b
            if c!=None:
                self.c = c
        def setAllWithEval(self, **kwargs):
            for key in **kwargs:
                if kwargs[param] != None
                    eval(&quot;self.&quot; + key + &quot;=&quot; + kwargs[param])

Content Type	Original Author	Original Content on Stackoverflow
Question	Naftuli Kay	View Question on Stackoverflow
Solution 1 - Python	Adam Wagner	View Answer on Stackoverflow
Solution 2 - Python	Gal Bracha	View Answer on Stackoverflow

How can I specify library versions in setup.py?

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Conditional Validation using Fluent Validation

Splitting a JS array into N arrays

Attributions