with-statement

I would like to ensure that the class is only instantiated within a "with" statement. i.e. this one is ok: with X() as x: ... and this is not: x = X() How can I ensure such functionality? All answers so far do not provide what (I think) OP wants directly . (I think) OP wants something like this: >>> with X() as x: ... # ok >>> x = X() # ERROR Traceback (most recent call last): File "run.py", line 18, in <module> x = X() File "run.py", line 9, in __init__ raise Exception("Should only be used with `with`") Exception: Should only be used with `with` This is what I come up with, it may not be very

I'm trying to get the WITH clause to work with merge in Oracle, but for some reason I can't get it working. I'm sure it is something obvious, but I just haven't seen it. -- behold, the wonders of fake data WITH X AS ( SELECT 'moo' AS COW, 'woof' AS CAT, (SELECT MAX( DECIBELS ) FROM ANIMALIA WHERE COW = 'moo' ) AS DECIBELS FROM DUAL ) MERGE INTO ANIMALIA D USING X WHEN MATCHED THEN UPDATE SET D.COW = X.COW; EDIT I actually found out how to manage this (before I submitted the question), but I think that since it took me quite some time to find the answer, hopefully leaving this question up will

I would like to ask get some help about understanding how "with recursive" works. More precisely WHY the anchor query (the non-recursive term) isn't replicated into the sub call of the CTE. I tried my best to understand alone but I'm not sure. First of all let's take the example of PostgreSQL which is the simplest one I found (make the sum of 1 to 100) : WITH RECURSIVE t(n) AS ( VALUES (1) UNION ALL SELECT n+1 FROM t WHERE n < 100) SELECT sum(n) FROM t; My code walkthrough ( I used links below) : Evaluate the non-recursive term. For UNION [...]. Include all remaining rows in the result of the

From within an __exit__ block in a custom cursor class I want to catch an exception so I can in turn throw a more specific exception. What is the proper way to do this? class Cursor: def __enter__(self): ... def __exit__(self, ex_type, ex_val, tb): if ex_type == VagueThirdPartyError: # get new more specific error based on error code in ex_val and # return that one in its place. return False # ? else: return False Raising the specific exception within the __exit__ block seems like a hack, but maybe I'm over thinking it. The proper procedure is to raise the new exception inside of the __exit__

I know this was widely discussed, but I still can't find an answer to confirm this: is the with statement identical to calling the same code in a try - (except) -finally block, where whatever one defines in the __exit__ function of the context manager is placed in the finally block? For example -- are these 2 code snippets doing exactly the same thing? import sys from contextlib import contextmanager @contextmanager def open_input(fpath): fd = open(fpath) if fpath else sys.stdin try: yield fd finally: fd.close() with open_input("/path/to/file"): print "starting to read from file..." the same

I saw JavaScript code which begins with with . That's a bit confusing. What does it do and how can it be used correctly? with (sObj) return options[selectedIndex].value; Justin Niessner It adds to the scope of the statements contained in the block: return sObj.options[selectedIndex].value; can become: with (sObj) return options[selectedIndex].value; In your case, it doens't do a whole lot...but consider the following: var a, x, y; var r = 10; a = Math.PI * r * r; x = r * Math.cos(PI); y = r * Math.sin(PI /2); Becomes: var a, x, y; var r = 10; with (Math) { a = PI * r * r; x = r * cos(PI); y =