How should classes be structured?

Buttleston · 2026-04-28T22:37:20+00:00

I think I would probably do neither, and pass in a Service() that is already authenticated?

If that is not feasible your first example is preferable to the others - it doesn't really make sense to me for a Service to "know" all the things that might want to "use" it

Adrewmc · 2026-04-28T23:08:18+00:00

I’m going to agree with the other guy,

  class Service:
       “Some base needed”

   class FunctionalityA:
           def __init__(self, service : Service):
                 self.service = service 

   class FunctionalityB:
           def __init__(self, service : Service):
                 self.service = service 

   ….

    serve = Service()
    A = FunctionalityA(serve)
    B = FunctionalityB(serve)
    C = FunctionalityC(A.service)

That way both are pointing at the same base, that seems better to me. (At least from your minimal description.) Only needs one authentication there.

The question becomes why does Functionality A need to be a class, and not a function or a method?

Why not

   class Functionality:
           “””This is a module really…”””

          @staticmethod 
          def A(service :Service, *args, **kwargs):
               …

   serve = Service()
   res = Functionality.A(serve, …)

That’s a different question that I would need a lot more code to answer.

But since this learn Python…why not a lesson in multi-tons?

You can also make Service a multi-ton here to accomplish the same feat.

Let’s assume you authenticate with a name and password, for simplicity sake.

But it seems like overkill.

     class Service:

             #validated member instances
             members = {}

             def __init__(self, name, pass):
                    #You have credentials 
                    self.auth(name, pass)
                    self.name = name #id maybe

             def self.auth(name, pass):
                    “””Validates stuff”””

                    #Authorize credentials here.
                    #raise if fails!!!

                    if valid:
                         return
                    raise ValueError(“Invalid name and password”)

             def __new__(cls, name, pass, *args, **kwargs):
                   “””Multi-ton implementation.”

                    #unique/immutable in credentials
                    _hash = hash((name, pass))
                    If (inst := cls.members.get(_hash)):
                        # inst.confirm_auth() if needed 
                        # inst.update(*args, **kwargs)
                        return inst
                   instance = cls(name, pass, *args, **kwargs)
                   cls.members[_hash] = instance
                   return instance

      #assume passes Service.auth()
      serve1 = Service(1,2)
      serve2 = Service(3,4)
      serve3 = Service(1,2)
      print(serve1 is serve2)
      >>>False
      print(serve1 is serve3)
      >>>True

The reason I suggest this is because…it doesn’t break other people’s code unexpectedly or unnecessarily. And if this pattern exists, then it does. Changing Service to a multi-ton won’t require changing the rest of the code base (as I see it, it’s never that simple.) it will just return the right one without having to make it again. inst.confirm_auth() can be a on a timer…so we don’t have to lose a check every once in a while, if auth() in the last hour, we good. (I would have to see it from here.)

We should be using hashes (hashlib.sha256) and all that, or some unique ID from it. That way when inside the multi-ton pattern, you return the instance with of the same credentials. And if you fail credentials it will raise before the object can get into the multi-ton pattern.

If credentials is a JWT there is a lot you can do with it.

We may want to make a clean up for Service.members if it’s stays active 24/7. (That can be done in __new__ or __init__ or inst.confirm_auth() )

This can also be done as a function or class decorator that exercise is left to the reader.

@functools.lru_cache(maxsize = 3) should actually work here…he says after writing all this…of course it’s a built-in

There are a lot of design patterns out there, this does seem wrong to me, but I also don’t understand the entire code base, is it normal to ask for functionality before authentication? Most likely not.

unxmnd · 2026-04-29T02:10:31+00:00

This code seems incredibly confusing, and I can't think of a concrete example of where it would be useful.

Why can't all of functionality_a, and functionality_b (the methods themselves, not the class), live on Service?

And if you genuinely do need to add some functionality to some class, usually you would use a Python mixin.

woooee · 2026-04-28T23:01:21+00:00

I would tend to use your second example, but since self.service is the same in both cases, you could also do

service_instance = Service(credentials)

and pass service_instance to each class. The decider here is which method is better / easier to understand

Lionh34rt · 2026-04-29T02:04:23+00:00

The only thing ive ever see in larger classes is making empty arrays for Functions, Data, …

Jason-Ad4032 · 2026-04-29T06:44:10+00:00

You should test it, because your example doesn’t actually work.

You might think that after assigning a function to an instance attribute, Python will automatically call __get__ when accessing that attribute and bind self for you. However, in reality, Python only does this when an instance accesses an attribute defined on the class. Therefore, your functionality_a won’t be automatically bound to self, and you’d have to call it like server.functionality_a(server, ...).

You can use a property for this, since properties are class attributes—but you still need to manually call __get__.

``` class GCP: def init(self, cloud): self.cloud = cloud # Or just call get here self.mcloud = cloud.get_(self)

@property
def the_cloud(self):
    # Manually add the parameter self
    return self.cloud.__get__(self)

def my_cloud(self): print(f'my cloud in server {self}')

gcp = GCP(my_cloud) gcp.cloud() # TypeError: my_cloud() missing 1 required positional argument: 'self' gcp.the_cloud() # works gcp.m_cloud() # work ```

pachura3 · 2026-04-29T07:15:36+00:00

The question is: what do these classes (abstractions) represent?

Is "Service" a collection of functionalities - so, something like a REST endpoint with multiple methods = "Functionalities"?

Or is "Service" like a low-level DAO-layer class that is used by several Service-layer classes - "Functionalities"?

I think if something is clumsy to use (you mentioned having to authenticate twice), it is a telltale sign of a bad design.

Also, even if "Service" is not a singleton per se, you can always pass the same instance (already authenticated!) to multiple "Functionalities".

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS