Split class across multiple files

[eric.frederich]

I have a class which holds a connection to a server and a bunch of
services.
In this class I have methods that need to work with that connection
and services.

Right now there are about 50 methods some of which can be quite long.
From an organizational standpoint, I'd like to have method
implementations in their own files.

Is this possible? It is recommended? Should I just stop worrying
about it and have a 5,000 line class?

 

[Diez B. Roggisch]

I have a class which holds a connection to a server and a bunch of
services.
In this class I have methods that need to work with that connection
and services.

Right now there are about 50 methods some of which can be quite long.
From an organizational standpoint, I'd like to have method
implementations in their own files.

Is this possible? It is recommended? Should I just stop worrying
about it and have a 5,000 line class?

It is pretty easy to do, as python allows multiple inheritance. Just
group together methods into a class, and create one that inherits from all.

However, I'd say something that even splitted up is essentially one
class with 5000 lines cries for a huge refactoring. Of course this
depends on the use-case, but I for once don't have a single such beast.
Looks like a god-object to me...

http://en.wikipedia.org/wiki/God_object

Diez

 

[Carl Banks]

I have a class which holds a connection to a server and a bunch of
services.
In this class I have methods that need to work with that connection
and services.

Right now there are about 50 methods some of which can be quite long.
From an organizational standpoint, I'd like to have method
implementations in their own files.

Is this possible?

Yes, define all your different methods in separate classes in separate
files. Then subclasses all of those separate classes into one big
class.

It is recommended?

Debateable. Personally, I have no problem using inheritance for
purely mechanical reasons. Others might. (In my case, it was a
separation into general and customized behavior. I wanted to define
generic behavior in one package, and specialized behavior in another,
but there was no internal logical difference between specialized and
generic methods.) However....

Should I just stop worrying
about it and have a 5,000 line class?

Five thousand lines is pushing the comfort level of how big a class
ought to be. I suggest instead of worrying about how to mechanically
split off methods into different files, you should consider whether
there's a way to refactor that one big class into smaller ones. Then
the problem you have goes away.


Carl Banks

 

[eric.frederich]

Yeah... it does seem like a God Object.
My reasoning for putting them all into one big class is that the class
has references to all the required resources, connections, and
services.
The other option would be to have a simple object called Session which
did nothing but login and hold those references.
The problem then is that I'd have 50 methods all of which would need
to take that session object as an argument.
That is what I was trying to avoid, having a ton of methods all taking
the same first parameter.
In most cases there would only be one session.

Perhaps I could do a singleton approach and have each of these methods
implicitly use the single session object unless called with a session=
keyword argument.

How does this look?.....


# Begin Session.py

class Session():

def __init__(self, host=None, username=None, password=None):
if host and username and password:
self.login(host, username, password)

def login(self, host, username, password):
self.host = host
self.username = username
self.password = password

self.connection = Something.login(host, username,
password)
self.someService = SomeService.getService(connection)
self.anotherService = AnotherService.getService(connection)

def logout(self):
return self.connection.logout()


defaultSession = Session()


# Begin MyLibrary.py

from session import defaultSession

def doSomethig(x, y, z, session=defaultSession):

return session.someService.doSomething(x, y, z)

def anotherFunction(x, y, session=defaultSession):
ret = 0
for item in session.anotherService.getStuff(x):
if session.someService.foo(item, y):
session.anotherService.bar(item, x)
ret += 1
return ret

 

[Terry Reedy]

I have a class which holds a connection to a server and a bunch of
services.
In this class I have methods that need to work with that connection
and services.

Right now there are about 50 methods some of which can be quite long.
implementations in their own files.

Is this possible?

A method is just function that is a class attribute.


from somemethod import somemethod # has def somemethod

class Huge:
somemethod = somemethod

# or

class Huge:
defs
...

Huge.somemethod = somemethod

It is recommended? Should I just stop worrying
about it and have a 5,000 line class?

I suspect some refactoring would be useful.

 

[Lie Ryan]

I have a class which holds a connection to a server and a bunch of
services.
In this class I have methods that need to work with that connection
and services.

Right now there are about 50 methods some of which can be quite long.
From an organizational standpoint, I'd like to have method
implementations in their own files.

Is this possible? It is recommended? Should I just stop worrying
about it and have a 5,000 line class?

If you're not joking about the 5000 lines estimation, then with 50
methods, each method would be ~100 lines? That stinks of huge refactoring.