class-method

Can you create a decorator inside a class that will see the classes methods and variables? The decorator here doesnt see: self.longcondition() class Foo: def __init__(self, name): self.name = name # decorator that will see the self.longcondition ??? class canRun(object): def __init__(self, f): self.f = f def __call__(self, *args): if self.longcondition(): # <-------- ??? self.f(*args) # this is supposed to be a very long condition :) def longcondition(self): return isinstance(self.name, str) @canRun # <------ def run(self, times): for i in xrange(times): print "%s. run... %s" % (i, self.name)

A little background, I essentially need to define an int wrapper type, say MyInt (among some other classes), and another generic Interval type which can accept MyInt objects as well as other types of objects. Since the types acceptable by the Interval do not fall into a neat hierarchy, I thought this would be a perfect use-case for the experimental Protocol , which in my case would require a couple of methods and a couple of @classmethod s. All the methods return a "self-type", i.e., MyInt.my_method returns a MyInt . Here is a MCVE: from dataclasses import dataclass from typing import Union,

When sending mail in Rails, usually one would do something like this: UserMailer.password_reset(user).deliver But if we look inside UserMailer we can see this: def password_reset(user) # not self.password_reset # ... end Notice that the method name is not prefixed with self . Looking at it, it seems like you need to instantiate the object first as below. How does Rails do this? UserMailer.new.password_reset(user).deliver That's a great question. In the source ( https://github.com/rails/rails/blob/master/actionmailer/lib/action_mailer/base.rb ), Rails uses method_missing to create a new

I'm have a decorator that I want to use to decorate class methods. In the following example, the @mydec decorator works fine on its own, however it does not preserve the function signature when using help() or pydoc. In order to fix this, I looked at using @decorator python-decorator package: import functools import decorator @decorator.decorator def mydec(func): @functools.wraps(func) def inner(cls, *args, **kwargs): # do some stuff return func(cls, *args, **kwargs) return inner class Foo(object): @classmethod @mydec def bar(cls, baz='test', qux=None): print (baz, qux) Foo.bar() Unfortunately

I'm using Python 3. I know about the @classmethod decorator. Also, I know that classmethods can be called from instances. class HappyClass(object): @classmethod def say_hello(): print('hello') HappyClass.say_hello() # hello HappyClass().say_hello() # hello However, I don't seem to be able to create class methods dynamically AND let them be called from instances. Let's say I want something like class SadClass(object): def __init__(self, *args, **kwargs): # create a class method say_dynamic SadClass.say_dynamic() # prints "dynamic!" SadClass().say_dynamic() # prints "dynamic!" I've played with

In the document "Objective-C Programming Language" by Apple, page 48 says: + (Rectangle *)rectangleOfColor:(NSColor *) color { self = [[Rectangle alloc] init]; // BAD [self setColor:color]; return self; } + (id)rectangleOfColor:(NSColor *)color { id newInstance = [[Rectangle alloc] init]; // GOOD [newInstance setColor:color]; return newInstance; } + (id)rectangleOfColor:(NSColor *)color { id newInstance = [[self alloc] init]; // EXCELLENT [newInstance setColor:color]; return newInstance; } One is bad, one is good, and the other is excellent. Why is that? bbum There is a fourth pattern.... (1)

I have a class with a constant defined for it. I then have a class method defined that accesses that class constant. This works fine. An example: #! /usr/bin/env ruby class NonInstantiableClass Const = "hello, world!" class << self def shout_my_constant puts Const.upcase end end end NonInstantiableClass.shout_my_constant My problem arises in attempting to move this class method out to an external module, like so: #! /usr/bin/env ruby module CommonMethods def shout_my_constant puts Const.upcase end end class NonInstantiableClass Const = "hello, world!" class << self include CommonMethods end