Mailman 3 July 2014 - pypy-dev

cppyy and out arguments
by Martin Matusiak Aug. 1, 2014

Aug. 1, 2014

Hi, I was reading about cppyy and I could not find a mention of what it does with out arguments. I also read through the unit tests, but I couldn't find any examples. Are they supported? I also found the section header "CPython" a little confusing on this page as the section doesn't seem to talk about cpython: pypy.readthedocs.org/en/latest/cppyy.html#cpython Martin

4 8

libdynd
by Armin Rigo Aug. 1, 2014

Aug. 1, 2014

Hi, Feedback, from Travis Oliphant at EuroPython: libdynd (https://github.com/ContinuumIO/libdynd) might be the longer-term future of NumPy, and it looks like it would be much more natural to bind to it from PyPy (via cffi). Worth a look I believe. It certainly looks to me like such a cffi binding would be much more user-friendly than numpypy, in the sense that missing functionality would be far easier to contribute back. A bientôt, Armin.

3 4

Adding support for __eq__ to RPython
by Tyler Wade July 30, 2014

July 30, 2014

Hello, While working on my GSoC project to move PyPy’s unicode implementation to utf-8, I added support for __eq__ to RPython. It was suggested on IRC that this may be controversial and I should write to the mailing list for further feedback. I’ve pushed my changes to the rpython-__eq__ branch if you’d like to look at the code itself. My reason for adding __eq__ support (along with other magic methods) is so that Utf8Str can be used as a drop-in replacement for the built-in (RPython) unicode type as much as possible. There are a number of places in where the same code is used to handle strings and unicode objects and make use of the standard operators. Needing to create a special case for Utf8Strs in every such place would be rather painful. Note that to prevent confusion, classes are prevented from defining __eq__ if the class at the root of their hierarchy does not do so also. This avoids the case where casting to common base hides the presence of a __eq__ method. I didn’t add such a check for __mul__ and __add__ since the * and + operators aren’t defined on RPython instances anyway and thus won’t silently behave differently post-translation like == could. Thoughts? Thanks, Tyler

2 1

Cross-post from python-ideas: Compressing the stack on the fly
by Ram Rachum July 28, 2014

July 28, 2014

Hi guys, I made a post on the Python-ideas mailing list that I was told might be relevant to Pypy. I've reproduced the original email below. Here is the thread on Python-ideas with all the discussion.<https://groups.google.com/forum/?fromgroups#!topic/python-ideas/hteGSNTyC_4> -------------- Hi everybody, Here's an idea I had a while ago. Now, I'm an ignoramus when it comes to how programming languages are implemented, so this idea will most likely be either (a) completely impossible or (b) trivial knowledge. I was thinking about the implementation of the factorial in Python. I was comparing in my mind 2 different solutions: The recursive one, and the one that uses a loop. Here are example implementations for them: def factorial_recursive(n): if n == 1: return 1 return n * factorial_recursive(n - 1) def factorial_loop(n): result = 1 for i in range(1, n + 1): result *= i return result I know that the recursive one is problematic, because it's putting a lot of items on the stack. In fact it's using the stack as if it was a loop variable. The stack wasn't meant to be used like that. Then the question came to me, why? Maybe the stack could be built to handle this kind of (ab)use? I read about tail-call optimization on Wikipedia. If I understand correctly, the gist of it is that the interpreter tries to recognize, on a frame-by-frame basis, which frames could be completely eliminated, and then it eliminates those. Then I read Guido's blog post explaining why he doesn't want it in Python. In that post he outlined 4 different reasons why TCO shouldn't be implemented in Python. But then I thought, maybe you could do something smarter than eliminating individual stack frames. Maybe we could create something that is to the current implementation of the stack what `xrange` is to the old-style `range`. A smart object that allows access to any of a long list of items in it, without actually having to store those items. This would solve the first argument that Guido raises in his post, which I found to be the most substantial one. What I'm saying is: Imagine the stack of the interpreter when it runs the factorial example above for n=1000. It has around 1000 items in it and it's just about to explode. But then, if you'd look at the contents of that stack, you'd see it's embarrassingly regular, a compression algorithm's wet dream. It's just the same code location over and over again, with a different value for `n`. So what I'm suggesting is an algorithm to compress that stack on the fly. An algorithm that would detect regularities in the stack and instead of saving each individual frame, save just the pattern. Then, there wouldn't be any problem with showing informative stack trace: Despite not storing every individual frame, each individual frame could still be accessed, similarly to how `xrange` allow access to each individual member without having to store each of them. Then, the stack could store a lot more items, and tasks that currently require recursion (like pickling using the standard library) will be able to handle much deeper recursions. What do you think? Ram.

2 1

wrong user mapped in the issue tracker
by Antonio Cuni July 24, 2014

July 24, 2014

Hi, I was looking at this issue: https://bitbucket.org/pypy/pypy/issue/1514/module-behaviour-incompatibility… and I noticed that pypy's user "amaury" has been mapped to bitbucket's user "amaury", which unfortunately it's another physical person. I don't know much about the migration of the issue tracker, so I don't even know if it's possible and how easy/hard is to fix it, just wanted to point out. ciao, Anto

1 0

For py3k...
by Armin Rigo July 23, 2014

July 23, 2014

Hi all, A module mentioned today in a EuroPython lightning talk: "lzma" reimplemented in cffi (compatible with the one from Python 3.3's stdlib). https://pypi.python.org/pypi/lzmaffi A bientôt, Armin.

2 1

Question about PyPy Sandboxing
by Kit Ham July 21, 2014

July 21, 2014

Hi devs, Can multiple PyPy sandboxes be executed and interacted with from C/C++? For context, I'm adding plugin support to my application. I'd like people to be able to write a python module, and call it's functions from the C/C++ in a sandboxed environment. This is for 2 reasons: 1) So that a plugin can't mess with the user's system 2) So that a plugin's access to other plugins can be controlled Cheers, Kit P.S. I'm currently using PyOtherSide in my Qt app, but I'm realising it may not be a good solution for plugins.

2 2

Support for current versions of Pypy on Heroku and Cloud Foundry platforms?
by cclauss July 18, 2014

July 18, 2014

Hi Folks, Currently Heroku only has Pypy 1.9 on an unsupported, experimental basis. https://devcenter.heroku.com/articles/python-runtimes#supported-python-runt… and https://github.com/heroku/heroku-buildpack-python/issues/139 Other Cloud Foundry-based IaaS offering (IBM BlueMix, etc.) seem to use similar buildpacks. https://github.com/cloudfoundry-community/cf-docs-contrib/wiki/Buildpacks Do any of you know of an Infrastructure as a Service provider that supports current versions of Pypy? Thanks for any pointers that you can provide. Chris Clauss

5 11

Patchpoints in LLVM
by Dimitri Vorona July 17, 2014

July 17, 2014

Hi, just wanted to link this discussion http://lists.cs.uiuc.edu/pipermail/llvmdev/2013-October/066573.html and this piece of docs http://llvm.org/docs/StackMaps.html. As far as I understand, the lack of patchpoints (i.e. a way to patch dynamically generated code) was the major burden on the way to use LLVM for code generation for PyPy. The functionality was implemented as a part of FTL, LLVM-based JavaScript compiler (http://blog.llvm.org/2014/07/ftl-webkits-llvm-based-jit.html) Regards, Dimitri.

2 1

Access the name of variable that is being assigned
by anatoly techtonik July 17, 2014

July 17, 2014

Hi, Is it possible at all to define a class in Python that can read name of variable it is assigned to on init? >>> MyObject = SomeClass() >>> print(MyObject) 'MyObject' For this to work, SomeClass __init__ needs to know what variable name is currently waiting to be assigned. But at the time __init__ is executed, MyObject is not entered global or local space yet. I know that this is possible to do on AST level, but AST is inaccessible when program is running, so what is the corresponding structure to track that? (links to source are appreciated) 1. Is it possible to do this in CPython and PyPy? 2. Is it possible to do this in generic way? 3. Is there any stack of assignments? 3.1. Is this stack accessible? Thanks. -- anatoly t.

7 11