Split class across multiple files
eric.frederich
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
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
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.
>>From an organizational standpoint, I'd like to have method
> 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
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.