TapeEquilibrium Codility implementation not achieving 100%
Algorithm

Your algorithm works for input with only positive integers.
But it may not work with some input that contains negative numbers,
for example it gives incorrect result for:

[-1, 1, 1, -1, -2]


Why does it work for all positive numbers?

At any point in your loop, you basically have:


leftsum: the sum of elements on the left so far
leftnext: the next element on the left
rightsum: the sum of elements on the right so far
rightnext: the next element on the right


When you know that all remaining elements in the middle are non-negative,
then you can safely decide whether to take the left or the right,
by minimizing the difference between leftsum + leftnext and rightsum + rightnext.
This is safe, because all the remaining elements are non-negative,
therefore the difference can only shrink, or otherwise be minimal.

But when there can be negative numbers in the middle,
you don't have such knowledge,
and it can be impossible to decide which side to advance.

Consider this alternative that's simple and intuitively easy to understand,
and it's guaranteed to give correct result:


Set left to the first element
Set right to the total sum - left
Initialize mindiff to the absolute difference of left and right
Iterate from the 2nd element until the -1th: add to left and subtract from right and update mindiff (A quick tip for writing the loop: for value in A[1:-1]: ...)
return mindiff


Technique

It's strange you did from math import fabs when you don't need floating point math to solve this problem. You can use abs instead of fabs.

Instead of A.__len__() it's more natural to use len(A).