isn't this method used to create the file-like object, and thus, associated with the __init__ or the __new__ dunder methods??
What the hell is gpt cooking???!
#🔒 open("file")
alpine bear
stuck hillBOT
isn't this method used to create the file-like object, and thus, associated with...
@alpine bear
Python help channel opened
tacit estuary
isn't this method used to create the file-like object, and thus, associated with...
it creates the object, but open itself doesn't have any dunders
alpine bear
it creates the object, but open itself doesn't have any dunders
how is it even possible?
tacit estuary
it returns a TextIOWrapper
alpine bear
isn't everything in the python associated w/dunde method
stuck hillBOT
!e
```py
print(dir(open))
```
:white_check_mark: Your 3.12 eval job has completed with return code 0.
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
here's the dunders of the open function
which is going to be pretty much the same signature as any function
!e
print(dir(open) == dir(len))
:white_check_mark: Your 3.12 eval job has completed with return code 0.
True
intersting
alpine bear
it creates the object, but open itself doesn't have any dunders
but wdym w/this one
tacit estuary
open is a function that returns a TextIOWrapper
that's like saying that len should have the same dunders as int
alpine bear
doesn't returning a TextIOWrapper involve using some kind of dunder to do the actrion itself?
tacit estuary
no, it's an implementation of the return keyword
alpine bear
oh
alpine bear
the logic behind the with keyword
wise wraith
https://github.com/python/cpython/blob/main/Modules/_io/_iomodule.c#L331 raw file object is created here
stuck hillBOT
Modules/_io/_iomodule.c line 331
raw = PyObject_CallFunction(RawIO_class, "OsOO",```yea, but I am trying to figure out the meaning of the method in here through the dunder off the open
with method() as object:
#__enter__
...
#__exit__```!e
import io
fake_file = io.TextIOWrapper(io.StringIO('hello'))
print(dir(fake_file))
:white_check_mark: Your 3.12 eval job has completed with return code 0.
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
method here returns a context manager
tacit estuary
yea, but I am trying to figure out the meaning of the method in here through the...
it simply calls __enter__ on context entry
and __exit__ at the end of context
!e
class Contexter:
def __enter__(self):
print("Context entered")
def __exit__(self, *args):
print("Context exited")
print("Before context")
with Contexter():
print("Inside context")
print("After context")
:white_check_mark: Your 3.12 eval job has completed with return code 0.
001 | Before context
002 | Context entered
003 | Inside context
004 | Context exited
005 | After context
follow the prints
alpine bear
!e
```py
class Contexter:
def __enter__(self):
print("Context enter...
oh wow
wise wraith
But open is a bit more like this:
class Cm:
def __enter__(self):
return self
def __exit__(self, *exc_info):
return
def method():
return Cm()
See how a function can return an instance of a context manager
So there's no method.__enter__ but it still works
tacit estuary
one of the main advantages of this is that __exit__ is called even in the event of an error
so context manager is good for doing some sort of "setup and teardown" but the teardown is always guaranteed to run
class UndoChunk:
def __init__(self, chunk_name=None):
if chunk_name is None:
self.identifier = str(uuid.uuid4())
else:
self.identifier = chunk_name
def __enter__(self):
cmds.undoInfo(openChunk=True, chunkName=self.identifier)
def __exit__(self, *args):
cmds.undoInfo(closeChunk=True, chunkName=self.identifier)
Here's a very simple example of one that I wrote for the software I work with
alpine bear
yeah, the context manager itself is chill, but the method after the with is confusing
tacit estuary
this let's me group together multiple operations as a single undo
tacit estuary
yeah, the context manager itself is chill, but the method after the with is conf...
the method after the with?
are you talking about like as f?
wise wraith
yea, but I am trying to figure out the meaning of the method in here through the...
The method from this? ^
alpine bear
are you talking about like `as f`?
no
alpine bear
The method from this? ^
yeah
wise wraith
It's not usually called a method if it's just a free floating function
alpine bear
what's the point then
tacit estuary
!e
class Contexter:
def __enter__(self):
print("Context entered!")
def __exit__(self, *args):
print("Context exited")
def make_context():
return Contexter()
with make_context():
print("Hello")
:white_check_mark: Your 3.12 eval job has completed with return code 0.
001 | Context entered!
002 | Hello
003 | Context exited
methods are class functions meant to be called with an instance
wise wraith
io.open is using the strategy pattern to return an instance of one of two different classes, either a TextIOWrapper instance or a FileIO
tacit estuary
yeah, the class it returns is different based on if you use "b" mode or not
alpine bear
okay, then how does the context manager knows what to work with? (which's __enter__ and __exit__ to call)
i've heard that the context manager itself invokes the __enter__ onto the variable that's needed to be worked with and then assigns that returned variable
tacit estuary
it ALWAYS must use an instance
so it uses enter/exit of that instance
if you try and use with on an instance without those dunders it will error
alpine bear
yea, but I am trying to figure out the meaning of the method in here through the...
so the method() must be initialiser?
wise wraith
No
tacit estuary
no, it's simply an instance
wise wraith
It's the strategy selector
tacit estuary
I think you're still confused about how open() simply returns an instance of another class
alpine bear
yes 😭
tacit estuary
!e
```py
class Contexter:
def __enter__(self):
print("Context enter...
look at my example here
wise wraith
Initialization is still happening in the classes
tacit estuary
make_context() is a function
that function returns an instance of something that implements enter/exit
make_context() doesn't have meaningful dunders
it's the thing being returned that does
alpine bear
oh, i think I got it
would this make sense :
class example:
...
objectt = example()
with objectt:
...```ohhh, so it's not the method/function but the instance itself..
tacit estuary
yes
alpine bear
that clarifies it
alpine bear
it creates the object, but open itself doesn't have any dunders
but this is strange tho
tacit estuary
how?
alpine bear
i was told that everything is done through dunders
tacit estuary
on instances, yes
alpine bear
that everything under the hood (during run time) uses dunders
tacit estuary
open is not the relevant piece here of making with work properly
alpine bear
open is not the relevant piece here of making `with` work properly
i got it, but won't the open itself use dunders to return the instance?
tacit estuary
open is no different from any other function
it just so happens to return something that implements enter/exit
alpine bear
oh god
i think I understood my confusiong :
- only the instances have the dunder methods.
- the open is the function, and thus, doesn't have any dunder methods. It literally executes its own c code or something
is this correct?
tacit estuary
it doesn't not have dunder methods
it just doesn't have anything meaningful to this operation
a function is still technically an instance
but it's an instance of a function type
wise wraith
Does it go via __call__?
tacit estuary
I'd imagine so? The exact implementation is probably C though
alpine bear
a function is still technically an instance
oh yes..
alright, it still makes sense
i appreciate your help, @tacit estuary , @wise wraith ! thank you, have a good day :)
!close
stuck hillBOT
Python help channel closed