Hi Alperen,  Why do you need a class at all rather than just a module with some functions? Irit On Tuesday, October 6, 2020, 01:38:21 PM GMT+1, Alperen Keleş wrote: Hi, Please pardon me if my idea is not making sense or already exists, I'm kind of new to developing in Python but I had this idea today and I wanted to share it with you. I think a class type such as "@functionclass" may be helpful for creating functions intended to keep a list of methods in a scope.  At the moment, I achieved this via writing "@classmethod" to all my functions but I think such a decorator might help clarify intent for the reader and ease the programmers' job. My regards,Alperen_______________________________________________ Python-ideas mailing list -- python-ideas@python.org To unsubscribe send an email to python-ideas-leave@python.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://mail.python.org/archives/list/python-ideas@python.org/message/5FE6HA... Code of Conduct: http://python.org/psf/codeofconduct/

Hi Irit, In my case, the code structure is as below. I'm writing a city traffic simulator which includes roads and cars. Cars have different states, MovingCar, IdleCar, ParkingCar... A car can move between different states and it keeps the same information. My solution to this was, Having a different class that captures the generic functions for each state. Why writing a module does not work has 2 parts, they may be due to my insufficient experience with python but I'm switching between the states as their API's are executed. Something like the code sample below class AA: @classmethod def greet(cls, A_instance): print("Hello", A_instance.name) class BB: @classmethod def greet(cls, A_instance): print("Hi", A_instance.name) class A: def __init__(self, state, name): self.state = state self.name = name def greet(self): self.state.greet(self) def switchAA(self): self.state = AA def switchBB(self): self.state = BB if __name__ == "__main__": obj = A(AA, "alperen) obj.greet() obj.switchBB() obj.greet() The output is: Hello alperen Hi alperen I believe this minimal example captures the semantics that I'm working on. I thought that AA and BB classes may be classified as a special type of class. My regards, Alperen

I think the OP would be happy with a decorator they can just copy-paste. All it needs to do is go over the class dict and apply @classmethod to every “normal” function. Probably skip under names. On Tue, Oct 6, 2020 at 06:46 Ricky Teachey wrote:

cf. this relatively recent conversation on the same topic-- worth reading in entirety:

https://mail.python.org/archives/list/python-ideas@python.org/thread/TAVHEKD...

As I said in that conversation, in the past I have wanted to have module-like namespaces inside of modules because sometimes it makes organizational sense to not create a separate, very short, module file.

Summary of how that thread turned out:

There seemed to be agreement among most of the conversation participants that this would be a useful idea, and a few different syntax ideas were batted about (a decorator, totally new syntax). A few people have experimented with various ways of doing this using current python but all of the ideas anyone has come up with so far would require some kind of change to the core language to make them work. The conversation didn't go any further than that (to my knowledge).

--- Ricky.

"I've never met a Kentucky man who wasn't either thinking about going home or actually going home." - Happy Chandler

_______________________________________________ Python-ideas mailing list -- python-ideas@python.org To unsubscribe send an email to python-ideas-leave@python.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://mail.python.org/archives/list/python-ideas@python.org/message/QRZXD7... Code of Conduct: http://python.org/psf/codeofconduct/

-- --Guido (mobile)

NOTE 1: After writing this whole post, I realized that while you used @classmethod, what you seem to really want is a fully @staticmethod class -- certainly your example was a static method, and some other posters were talking about static method (i.e. "it's bad style to have unused parameters in a function") -- so this answer *may* be not quite write for your use case, but it does apply to the example given. And I'm having a hard time figuring out when one might want a fully classmethod class :-), so if that is what you intended, please post an example that actually uses the "cls" parameter. NOTE 2: maybe it was email client mangling, but your code was using two spaces for indentation (or were those tabs?), you really want to use four spaces to indent in Python -- trust me on this! Now the post: It's really hard to see what you are really working with with such a (necessarily) short example, but a couple notes: Cars have different states, MovingCar, IdleCar, ParkingCar...

A car can move between different states and it keeps the same information.

Why writing a module does not work has 2 parts, they may be due to my

insufficient experience with python but I'm switching between the states as their API's are executed.

you could use modules as namespaces in this case -- modules are objects, like everything else in Python, so you could do: in AA.py: def greet(A_instance): print("Hello", A_instance.name) BB.py: def greet(A_instance): print("Hello", A_instance.name) main_module.py: from . import AA, BB class A: def __init__(self, state, name): self.state = state self.name = name def greet(self): self.state.greet(self) def switchAA(self): self.state = AA def switchBB(self): self.state = BB and it should all work. But I agree, that doesn't "feel" right. However, a "state" to me sounds like a collection of static information -- could your state be stored as a collection of data, in a dict, or maybe a dataclass? are there actually different methods (actions) involved, that don't involve the state itself (i.e. self)? To follow your example:

class AA: @classmethod def greet(cls, A_instance): print("Hello", A_instance.name)

class BB: @classmethod def greet(cls, A_instance): print("Hi", A_instance.name)

the difference between these is the content of the message, so you could write: from dataclasses import dataclass @dataclass class State(): greeting: str AA = State(greeting="Hello") BB = State(greeting="Hi") class A: def __init__(self, state, name): self.state = state self.name = name def greet(self): print(self.state.greeting, self.name) def switchAA(self): self.state = AA def switchBB(self): self.state = BB if __name__ == "__main__": obj = A(AA, "alperen") obj.greet() obj.switchBB() obj.greet() BTW: part of how I got to this solution is the DRY principle (Don't Repeat Yourself): I looked at your AA and BB greet() methods, and it took me a second to see what was different about them. They were repeated code: the only difference was one string. You really don't need/want different classes (or different methods) if the logic is the same. But another way to do this, particularly if there IS some different logic in your different State classes, would be to forget static methods, and have the state stored in class attributes, and the logic in the methods: class State: def greet(self, A_instance): print(self.greeting, A_instance.name) class AA: greeting = "Hello" class BB: greeting = "Hi" It seems odd to have a subclass that only specifies a class attribute or two, but if you really want to use classes in this way, it will accomplish what you want. All that being said, an "all_static" decorator, as suggested by Guido and prototyped by Eric could be a reasonable way to create a collection of methods in one namespace, if indeed, they are different methods. -CHB PS: A reminder about this list -- it's really a better idea for folks fairly new to the language to start on another forum (e.g. tutor@python.org, stack overflow, etc) and ask: "how to I accomplish this"? and see what you get for answers, before you post an idea to ideas for a new language feature. -- Christopher Barker, PhD Python Language Consulting - Teaching - Scientific Software Development - Desktop GUI and Web Development - wxPython, numpy, scipy, Cython

On Tue, Oct 6, 2020 at 9:49 PM Random832 wrote:

On Tue, Oct 6, 2020, at 02:50, Alperen Keleş wrote:

...

I think a class type such as "@functionclass" may be helpful for creating functions intended to keep a list of methods in a scope.

At the moment, I achieved this via writing "@classmethod" to all my functions but I think such a decorator might help clarify intent for the reader and ease the programmers' job.

I think new syntax would be better than a decorator (or a metaclass, which for some reason never seems to get suggested for these things),

I think maybe discussion of the general namespace idea might be a little off topic for this read (per Guido's comments). However the metaclass below-- or something like it-- could still help with the problem? It was actually my attempt at a general namespace object in the previous namespace thread. It seemed to work ok, and it should work in this use case: import types class namespace(type): def __new__(mcls, name, bases, dct): if bases: raise TypeError("this is a namespace, not a class.") mod = types.ModuleType(dct.pop("__qualname__"), dct.pop("__doc__",None)) mod.__dict__.update(dct) return mod class ns(metaclass=namespace): class Desc: def __get__(self, obj, cls): return None d = Desc() if __name__=="__main__": assert ns.d # success: descriptor protocol broken as expected But there are probably deficiencies I have not uncovered. --- Ricky. "I've never met a Kentucky man who wasn't either thinking about going home or actually going home." - Happy Chandler

In Python 3 you can do this without any decorators. The following works and produces the same output: class AA: def greet(A_instance): print("Hello", A_instance.name) class BB: def greet(A_instance): print("Hi", A_instance.name) class A: def __init__(self, state, name): self.state = state self.name = name def greet(self): self.state.greet(self) def switchAA(self): self.state = AA def switchBB(self): self.state = BB if __name__ == "__main__": obj = A(AA, "alperen") obj.greet() obj.switchBB() obj.greet() -- Greg

On 7/10/20 2:45 pm, Random832 wrote:

I think the feature should allow for the functions to directly access each other from the namespace's scope without requiring an attribute lookup.

That got me thinking, and I came up with this: def submodule(f): return type(f.__name__, (), f()) @submodule def Stuff(): def f1(): print("First function") f2() def f2(): print("Second function") return locals() Stuff.f1() The only ugly part is the need for the 'return locals()', but that could probably be alleviated with a bit of bytecode hacking. -- Greg

New improved version: def submodule(f): co = f.__code__ i = len(co.co_consts) b = bytes([0x64, i, 0x83, 0x0, 0x53, 0x0]) f.__code__ = co.replace( co_consts = co.co_consts + (locals,), co_code = co.co_code[:-4] + b ) return type(f.__name__, (), f()) @submodule def Stuff(): def f1(): print("First function") f2() def f2(): print("Second function") Stuff.f1() -- Greg

On Wed, Oct 7, 2020 at 12:06 AM Random832 wrote:

I think a metaclass [well, "pseudo-metaclass", to use a term I made up for a metaclass that is not a subclass of type and/or does not return an instance of type] would be better in this case because the resulting object should not be a type.

but a class decorator can return, well, anything. See the example I posted having it create a module object. I really don't know that that's a good idea, but yeah, if what you want is a essentially a namespace, then you really don't want a type. Maybe just an instance of object would work though. -CHB

The reason I wanted different syntax was because I wanted to change how the functions inside are compiled [to allow nonlocal accesses to refer to the namespace's scope], though I think making them globals and a custom dict subclass [possibly ChainMap, haven't checked if it does everything I want] for globals makes this workable as a metaclass or decorator - either one can take all of the functions and replace them with a new function with different globals and the original function's code object.

...

...

namespace Foo: x=1 def bar(): pass def baz() return bar() + x

That could be done with a function and a function decorator. "Proof left as an exercise for the reader." :-)

---

Python-ideas mailing list -- python-ideas@python.org To unsubscribe send an email to python-ideas-leave@python.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://mail.python.org/archives/list/python-ideas@python.org/message/2HWZUS... Code of Conduct: http://python.org/psf/codeofconduct/

-- Christopher Barker, PhD Python Language Consulting - Teaching - Scientific Software Development - Desktop GUI and Web Development - wxPython, numpy, scipy, Cython