2007-04-28T12:22:11 <dreimark> moin
2007-04-28T12:27:31 <neagulm> hello dreimark
2007-04-28T12:28:58 <dreimark> hi neagulm
2007-04-28T12:36:15 <dreimark> neagulm: johill tells yesterday thats dspam uses n-categories classifier, do you know what they use?
2007-04-28T12:38:23 <neagulm> dreimark, No but I have read DSpam authors book and I believe that they use Bayesian classification... :)
2007-04-28T12:38:44 <neagulm> dreimark, I will have a look today at their system
2007-04-28T12:41:50 <dreimark> :)
2007-04-28T12:47:07 <grzyw> :)
2007-04-28T12:59:52 <xorAxAx> Balbinka == the cute one?
2007-04-28T13:06:07 <neagulm> dreimark, Is there a standard way to change the action menu or I must hack ThemeBase.actionsMenu ?
2007-04-28T13:08:22 <grzyw> xorAxAx: may be. I rarely use this account.
2007-04-28T13:08:58 <xorAxAx> grzyw: or what does it mean? :)
2007-04-28T13:09:03 <xorAxAx> i dont speak polish
2007-04-28T13:09:50 <grzyw> It's a name. There was a show for children with a Balbinka goose a long time ago.
2007-04-28T13:09:53 <grzyw> ;-)
2007-04-28T13:10:13 <grzyw> Now, shopping I go. bbl.
2007-04-28T13:10:19 <xorAxAx> ah
2007-04-28T13:48:48 <dreimark> neagulm: change for translation or order, its that routine
2007-04-28T13:49:32 <dreimark> neagulm: if its only to be visible in the Actions menu, you need to write the first letter of your action in Uppercase
2007-04-28T13:53:56 <dreimark> ThomasWaldmann: May be we should move the actionsMenu definition menu and title to multiconfig.
2007-04-28T13:55:43 <dreimark> navibar, editbar is already there defined
2007-04-28T15:01:44 <neagulm> i need to leave... bbl
2007-04-28T15:18:32 <dreimark> bbl2
2007-04-28T18:57:24 <dreimark> moin
2007-04-28T19:26:50 <dreimark> [ [ Anchor () ] ] is broken in 1.6
2007-04-28T20:34:41 <ThomasWaldmann> moin
2007-04-28T20:44:44 <lanius> hi ThomasWaldmann
2007-04-28T20:54:56 <ThomasWaldmann> dreimark: yeah, until we need a completely new system in 1.7 X)
2007-04-28T20:55:57 <ThomasWaldmann> dreimark: if you do it, please not '__separator__', but rather '----'
2007-04-28T21:02:25 <lanius> ThomasWaldmann: further commends on the interfaces?
2007-04-28T21:05:07 <ThomasWaldmann> s/lastRevision/currentRevision/
2007-04-28T21:06:55 <ThomasWaldmann> s/'current'/-1/ maybe?
2007-04-28T21:07:21 <ThomasWaldmann> (to be pythonic, or 0 to be compatible with current code semantics)
2007-04-28T21:08:41 <ThomasWaldmann> hmmm, no, forget that, as it is a dict, not a list
2007-04-28T21:11:23 <ThomasWaldmann> did you go through the irc logs of recently and /TwInput to check if you processed all ideas we already talked about?
2007-04-28T21:12:09 <lanius> don't understand what's your preference now, 0 or -1
2007-04-28T21:12:15 <lanius> or current
2007-04-28T21:12:55 <ThomasWaldmann> as it is a dict, we don't have list semantics, so -1 makes no sense
2007-04-28T21:13:45 <lanius> so 0 or current
2007-04-28T21:14:24 <xorAxAx> lanius: the method names are not PEP8
2007-04-28T21:14:28 <xorAxAx> please read PEP8
2007-04-28T21:15:34 <ThomasWaldmann> i guess 0 is better
2007-04-28T21:15:42 <lanius> xorAxAx: ok, will change that
2007-04-28T21:15:45 <xorAxAx> lanius: and i cannot see the necessary file-like interface
2007-04-28T21:15:53 <ThomasWaldmann> shorter to type, current code uses 0 for current
2007-04-28T21:15:54 <xorAxAx> in order to have streams instead of strings
2007-04-28T21:16:02 <xorAxAx> hmm, ah
2007-04-28T21:16:35 <xorAxAx> lanius: what is def getData(name, revision, start = 0, end = -1):?
2007-04-28T21:16:37 <xorAxAx> (start, end)
2007-04-28T21:16:43 <ThomasWaldmann> when returning the keys, there should be no 0 though, but the list of real revs
2007-04-28T21:17:27 <ThomasWaldmann> (and sorted, beginning with latest)
2007-04-28T21:18:12 <lanius> beginning with the latest?
2007-04-28T21:18:13 <ThomasWaldmann> and when accessing item[currentrevno] it of course should return the same as when doing item[0]
2007-04-28T21:18:43 <ThomasWaldmann> latest = highest rev
2007-04-28T21:18:51 <lanius> but last in list
2007-04-28T21:18:57 <lanius> no?
2007-04-28T21:19:10 <ThomasWaldmann> [10, 9, ..., 1]
2007-04-28T21:19:14 <lanius> ok
2007-04-28T21:19:28 <lanius> xorAxAx: i tried to do a file like interface, but i'm not sure how you exactly want it to be
2007-04-28T21:21:07 <xorAxAx> lanius: i was just confused, ignore that problem :)
2007-04-28T21:21:18 <lanius> ok, cool
2007-04-28T21:21:34 <xorAxAx> so what is start/end? :)
2007-04-28T21:21:44 <lanius> about the metadata stuff, like i explained yesterday, i think that we will always read all metadata but only set specified keys
2007-04-28T21:21:53 <lanius> the byte postition in the stream
2007-04-28T21:22:46 <xorAxAx> and whats the return value? a string?
2007-04-28T21:22:55 <xorAxAx> thats not a file-like interface :)
2007-04-28T21:23:04 <lanius> the bytes
2007-04-28T21:24:01 <xorAxAx> well, and setdata still seems to accept a full string
2007-04-28T21:24:04 <xorAxAx> not file-like :-)
2007-04-28T21:24:18 <lanius> or bytes, where is the difference in python?
2007-04-28T21:24:21 <xorAxAx> and you talked about dynamic indexes
2007-04-28T21:24:27 <xorAxAx> hmm?
2007-04-28T21:24:35 <xorAxAx> bytes are stored as str-objects
2007-04-28T21:24:48 <lanius> so, i don't know how you want it to be
2007-04-28T21:24:53 <lanius> dynamic indexes at what point?
2007-04-28T21:25:19 <xorAxAx> lanius: you talked about the backend optimising for particular backend storage optimisations
2007-04-28T21:25:30 <xorAxAx> lanius: well, imagine that somebody is uploiading a 4 GB ppt file
2007-04-28T21:25:40 <xorAxAx> and the server only has 32 MB RAM
2007-04-28T21:25:51 <xorAxAx> using the current API, thats not possible :-)
2007-04-28T21:26:03 <xorAxAx> s/optimisations/access patterns/
2007-04-28T21:26:16 <lanius> two different things now, right
2007-04-28T21:26:26 <lanius> the dynamic indexes are not yet in
2007-04-28T21:27:11 <lanius> yes i see, so it would be enough to add a start attribute to the set_data function?
2007-04-28T21:27:52 <ThomasWaldmann> xorAxAx: sure, you just need some xx GB swap :-P
2007-04-28T21:27:52 <lanius> hmm
2007-04-28T21:27:53 <xorAxAx> lanius: thats not easily implementable
2007-04-28T21:28:10 <xorAxAx> lanius: the easiest thing is if there is a file-like object that is returned by the backend
2007-04-28T21:28:28 <xorAxAx> that can be written to or read from
2007-04-28T21:28:42 <lanius> but that just adds another layer since the file-like object must use the backend again
2007-04-28T21:28:56 <xorAxAx> no, there is no layer
2007-04-28T21:29:09 <xorAxAx> the backend will provide the implementation
2007-04-28T21:29:17 <xorAxAx> and moin will provide an abstract base class
2007-04-28T21:29:35 <lanius> so the backend must implemente two classes
2007-04-28T21:29:39 <xorAxAx> write(data, pos=None) is stupid because it might be O(n^2) and no dbapi is suited for that
2007-04-28T21:29:50 <xorAxAx> at least, yes
2007-04-28T21:29:59 <xorAxAx> thats not really a limit or sign of cleanliness
2007-04-28T21:30:48 <lanius> ok, i think i understand now
2007-04-28T21:30:53 <lanius> what about the Data interface?
2007-04-28T21:31:31 <xorAxAx> ItemCollection.__setitem__ is violating the dict protocol
2007-04-28T21:31:56 <xorAxAx> because it is a container, you should not have to call setitem again to save anything as a user
2007-04-28T21:32:47 * xorAxAx checks the data interface
2007-04-28T21:33:29 <lanius> but do we always want to save the changes when they occur?
2007-04-28T21:33:54 <xorAxAx> you are missing tell, close and write
2007-04-28T21:34:01 <xorAxAx> no, saving must occur implicit
2007-04-28T21:34:16 <xorAxAx> either via a minimal UOW pattern or with save() methods on the particular object
2007-04-28T21:34:30 <lanius> how would the uow pattern work here
2007-04-28T21:34:42 <xorAxAx> well, we already talked about it :)
2007-04-28T21:34:52 <lanius> then i didn't understand correctly
2007-04-28T21:35:09 <xorAxAx> and you basically would have a session that stores all tracked objects. this session then can check for the modification state
2007-04-28T21:35:15 <xorAxAx> on the flush call
2007-04-28T21:35:32 <xorAxAx> because the data model is trivial, this checking and flushing is simple as well
2007-04-28T21:35:35 <lanius> that's what the itemcollection is, isn't it?
2007-04-28T21:35:39 <xorAxAx> no need to calculate feedback arcs etc.
2007-04-28T21:35:51 <lanius> write is there, why would we need close
2007-04-28T21:36:07 <xorAxAx> lanius: then as said above, setitem on the collection doesnt make sense for updating
2007-04-28T21:36:31 <xorAxAx> lanius: because the file should be closed explicitly to free resources explicitly
2007-04-28T21:36:59 <xorAxAx> esp. for some backends, this is essential
2007-04-28T21:37:22 <xorAxAx> like a db that has a cursor opened on the blob
2007-04-28T21:37:35 <lanius> so the save function will be added to the ItemCollection
2007-04-28T21:37:49 <xorAxAx> yes
2007-04-28T21:38:22 <xorAxAx> besides that, it sounds nice. maybe you can come up with an idea to realise the index stuff, keep the discussed use cases in mind
2007-04-28T21:40:01 <lanius> don't understand the close stuff yet
2007-04-28T21:40:51 <xorAxAx> ok
2007-04-28T21:41:17 <xorAxAx> now imagine that there is a storage backend that maps the file accesses to blob fields in a RDBMS
2007-04-28T21:41:46 <lanius> yes
2007-04-28T21:41:47 <xorAxAx> and this RDBMS mandates that the cursor that is used to read the field is closed before closing the connection (which would happen at the end of th request)
2007-04-28T21:42:15 <xorAxAx> the cursor would be owned by the file-like proxy object
2007-04-28T21:42:21 <xorAxAx> and some moin code would read() from it
2007-04-28T21:42:33 <xorAxAx> now, if the file is not closed, the db client will crash
2007-04-28T21:42:37 <xorAxAx> when do you want to close it?
2007-04-28T21:43:03 <lanius> after the read?
2007-04-28T21:43:38 <xorAxAx> there will be a lot of reads
2007-04-28T21:43:46 <xorAxAx> the file size is 4 GB, remember? :)
2007-04-28T21:44:02 <xorAxAx> and you will likely read in 4 kB chunks (i mean, moin currently does that)
2007-04-28T21:44:25 <lanius> ok
2007-04-28T21:44:37 <lanius> so the proxy interface will be essentially the same as the Data interface?
2007-04-28T21:45:38 <xorAxAx> well, yes, the backend will have to instantiate a proxy class and the result will be that interface, yes. you can still call it data. but i would differentiate between a class for writing and one for reading
2007-04-28T21:46:04 <xorAxAx> because it might make more sense to offer two methods that return a proxy object for read and one for write operations
2007-04-28T21:46:08 <xorAxAx> just to ease the implementation
2007-04-28T21:47:19 <lanius> on both levels?
2007-04-28T21:47:48 <xorAxAx> IMHO just passing the object is fine
2007-04-28T21:48:12 <xorAxAx> with some property on item that does an object.read()
2007-04-28T21:48:34 <lanius> on revision
2007-04-28T21:48:41 <xorAxAx> indeed
2007-04-28T21:49:10 <lanius> so the properties will be split on the Revision level to data_reader and data_writer ?
2007-04-28T21:49:38 <xorAxAx> yeah
2007-04-28T21:51:03 <xorAxAx> what do you think about that?
2007-04-28T21:51:17 <lanius> wouldn't an open("r" | "w" | "a") on the data object be as good
2007-04-28T21:52:07 <xorAxAx> btw, the writer shouldnt get seek and tell
2007-04-28T21:52:10 <xorAxAx> hmm
2007-04-28T21:52:28 <xorAxAx> well, think about an RDBMS as a backend
2007-04-28T21:54:12 * lanius is thinking
2007-04-28T21:54:27 <xorAxAx> how would you handle it if the caller would throw read() and write() calls at you interleavedly? :)
2007-04-28T21:54:55 <xorAxAx> s/would thro/thre/
2007-04-28T21:55:40 <lanius> should not be possible, you can only open for "r" or for "w", and you have the same problem with two objects, don't you
2007-04-28T21:56:28 <xorAxAx> well, the modification would hit the backend storage after a collection.save/flush()
2007-04-28T21:57:22 <lanius> yes, don't see the difference
2007-04-28T21:57:40 <dreimark> ThomasWaldmann: is there an answer from google belonging to not coding before end of may
2007-04-28T21:59:00 <dreimark> xorAxAx:?
2007-04-28T21:59:30 <xorAxAx> dreimark: yes
2007-04-28T21:59:50 <dreimark> and what is it?
2007-04-28T21:59:52 <xorAxAx> dreimark: students may not be judged from what they are doing before the end of may, but what they are doing does not matter
2007-04-28T22:00:13 <xorAxAx> lanius: which problems would i have in my case?
2007-04-28T22:00:40 <lanius> i don't see a problen in any of both situations
2007-04-28T22:00:54 <lanius> if we would add the open() call
2007-04-28T22:03:07 <xorAxAx> you mean at open time, the caller would decide?
2007-04-28T22:03:11 <xorAxAx> thats ok as well
2007-04-28T22:03:44 <lanius> yes, that's what i mean
2007-04-28T22:04:50 <lanius> but how does the 4gb file work when we only save the changes on the flush
2007-04-28T22:05:05 <lanius> we would need to open the file, write 4kb, close it, flush, open it again ...
2007-04-28T22:05:05 <lanius> ?
2007-04-28T22:06:03 <xorAxAx> no
2007-04-28T22:06:18 <xorAxAx> the proxy would need to create a temporary file
2007-04-28T22:07:14 <lanius> yeah
2007-04-28T22:07:31 <lanius> what's still missing is the handling of more then one data part
2007-04-28T22:08:02 <xorAxAx> you mean for twikidraw?
2007-04-28T22:08:20 <lanius> yeah
2007-04-28T22:08:25 <xorAxAx> i think twikidraw would be fine with the actual drawing in the metadata and the image in the data part
2007-04-28T22:08:47 <lanius> thomas had something about it in his TwInput, but i'm not sure about it
2007-04-28T22:09:16 <xorAxAx> i think designing it to handle this case is not very useful - i cant think of other use cases
2007-04-28T22:10:14 <lanius> what about editing only parts of a page, what's possible in mediawiki e.g. so different people can edit one page at the same time
2007-04-28T22:10:59 <xorAxAx> thats orthogonal to storage
2007-04-28T22:11:17 <xorAxAx> the merging code will operate on chunks of pages
2007-04-28T22:11:23 <xorAxAx> in those cases
2007-04-28T22:11:42 <lanius> makes sense
2007-04-28T22:12:22 <lanius> your ok with the metadata stuff?
2007-04-28T22:13:09 <xorAxAx> moin also uses soft edit locks that are some kind of metadata ... it might make sense to think about where to store such page data (metadata?)
2007-04-28T22:13:12 <xorAxAx> lanius: yes, looks fine
2007-04-28T22:13:58 <lanius> also that you only get the metadata in one chunk?
2007-04-28T22:15:02 <xorAxAx> well
2007-04-28T22:15:06 <ThomasWaldmann> lanius: StorageBackend.hasItem() needs more precise definition (or the additional flag mentioned on TwInput)
2007-04-28T22:15:42 <xorAxAx> lanius: how is that bound to the interface, besides in the doc string?
2007-04-28T22:16:09 <lanius> it returns a dict and does not have a key as attribute
2007-04-28T22:16:21 <lanius> ThomasWaldmann: what does include_deleted do
2007-04-28T22:17:02 <ThomasWaldmann> an item has 3 states for moin: does not exist at all, does exist, but is "deleted", exists and has a nondeleted current revision
2007-04-28T22:17:37 <lanius> what is the second case used for
2007-04-28T22:18:21 <ThomasWaldmann> well, for page list or just showing the item, you dont want deleted items
2007-04-28T22:18:29 <dreimark> neagulm: I will be tommorrow quite late here
2007-04-28T22:18:36 <lanius> why do you have deleted items?
2007-04-28T22:18:36 <xorAxAx> lanius: can you elaborate? i dont understand "not have a key"
2007-04-28T22:18:46 <ThomasWaldmann> dreimark: you are writing in red
2007-04-28T22:19:17 <lanius> xorAxAx: if you only want to query one metadata value you must say which one e.g. get_metadata("Frontpage", 0, "ACL")
2007-04-28T22:19:47 <lanius> xorAxAx: but you can only do get_metadata("Frontpage", 0)
2007-04-28T22:19:56 <xorAxAx> lanius: ah
2007-04-28T22:19:59 <ThomasWaldmann> deleted = has old revs, but not a current one
2007-04-28T22:20:21 <xorAxAx> lanius: well, you could add a key=None
2007-04-28T22:20:21 <lanius> why would you not have a current one
2007-04-28T22:20:27 <xorAxAx> lanius: or add a new method
2007-04-28T22:20:37 <dreimark> ThomasWaldmann: I prefer green, but all others seems to like to use red for separating messages
2007-04-28T22:20:39 <lanius> yes it could, but i argued that it is not needed
2007-04-28T22:20:57 <lanius> s/it/i/
2007-04-28T22:21:29 * ThomasWaldmann prefers no colour except the highlighting my client does
2007-04-28T22:21:31 <xorAxAx> lanius: imagine some part of the moin enterprise framework 3.4 storing 1 MB of metadata
2007-04-28T22:21:38 <xorAxAx> :-)
2007-04-28T22:22:36 <dreimark> ThomasWaldmann: so I should switch the client ;) [20:54] was in red from you too
2007-04-28T22:22:39 <xorAxAx> ok, we can argue that it should not be done like that
2007-04-28T22:23:12 <lanius> in the end i don't care, i just wan't a more or less final interface definition
2007-04-28T22:24:37 <xorAxAx> i think its ok
2007-04-28T22:25:15 <lanius> should revision point to a default of 0 which means current?
2007-04-28T22:25:34 <xorAxAx> no, that should be wiped out :)
2007-04-28T22:25:42 <xorAxAx> in-band signalling of revision numbers
2007-04-28T22:25:47 <lanius> ?
2007-04-28T22:26:14 <xorAxAx> well
2007-04-28T22:26:17 * neagulm wonders why his hg account is not working
2007-04-28T22:26:31 <xorAxAx> in-band signalling == its transmitted together with the regular data
2007-04-28T22:27:02 <xorAxAx> some is_current property would be much better
2007-04-28T22:27:39 <lanius> in the Backend?
2007-04-28T22:27:46 <ThomasWaldmann> xorAxAx: we need some way to just get the current rev
2007-04-28T22:27:46 <ThomasWaldmann> (without knowing the revno before)
2007-04-28T22:28:01 <lanius> yes, that would be possible
2007-04-28T22:28:01 <xorAxAx> and for loading a revision, you would use [-1]
2007-04-28T22:28:01 <xorAxAx> (python slicing)
2007-04-28T22:28:12 <xorAxAx> ThomasWaldmann: [-1]
2007-04-28T22:28:17 <ThomasWaldmann> xorAxAx: it is a dict, not a list
2007-04-28T22:28:25 <xorAxAx> why is it a dict?
2007-04-28T22:28:28 <lanius> and it's the backend not the itemcollection
2007-04-28T22:28:46 <xorAxAx> what are we talking about?
2007-04-28T22:29:04 <dreimark> neagulm: .hg/hgrc changed to default-push = ssh://hg@hg.thinkmo.de/moin/1.7-classify-mneagul
2007-04-28T22:29:05 <lanius> if the revision attributes in the backend should point to a default value of 0 which means current
2007-04-28T22:29:21 <xorAxAx> what kind of revision attributes?
2007-04-28T22:29:43 <lanius> everywhere where revision is mentionend in the StorageBackend
2007-04-28T22:29:55 <lanius> not attribute, parameter
2007-04-28T22:29:59 <xorAxAx> ah!
2007-04-28T22:30:05 <xorAxAx> well, None would be appropriate there
2007-04-28T22:30:08 <xorAxAx> or a constant
2007-04-28T22:30:17 <xorAxAx> anything would be better that is not a positive integer
2007-04-28T22:30:56 <lanius> since there is no revision 0 we could use 0?
2007-04-28T22:32:10 <xorAxAx> well, i would prefer something else
2007-04-28T22:33:37 <xorAxAx> its not very pythonic
2007-04-28T22:33:42 <lanius> ThomasWaldmann: i still don't understand why there can be an item with a non current revision
2007-04-28T22:33:43 <xorAxAx> explicit is better than implicit
2007-04-28T22:34:09 <xorAxAx> lanius: i think thats an implementation detail of the current storage system, IMHO it should not go into this design
2007-04-28T22:34:18 <ThomasWaldmann> lanius: look at data_dir in your local test wiki after deleting a page
2007-04-28T22:34:32 <xorAxAx> lanius: currently, an item is deleted if the pointer points to a non-existing revision
2007-04-28T22:34:41 <xorAxAx> lanius: in the new model, it would be a meta-data key
2007-04-28T22:34:52 <xorAxAx> lanius: btw, you need to standardise common meta-data keys
2007-04-28T22:35:07 <xorAxAx> grzyw: ping
2007-04-28T22:35:26 <lanius> xorAxAx: but not on a higher level
2007-04-28T22:35:37 <xorAxAx> lanius: hmm?
2007-04-28T22:35:44 <lanius> the common meta-data keys
2007-04-28T22:35:55 <xorAxAx> on the metadata class level
2007-04-28T22:36:04 <lanius> examples..
2007-04-28T22:36:14 <xorAxAx> deleted, mimetype, author, modification data
2007-04-28T22:36:18 <xorAxAx> s/a$/e/
2007-04-28T22:36:32 <xorAxAx> maybe even change comment
2007-04-28T22:36:36 <lanius> the storage layer does not care about them
2007-04-28T22:36:49 <xorAxAx> Item is part of the storage layer and it should care
2007-04-28T22:37:13 <xorAxAx> (the storage layer should have a notion of deleted objects ...)
2007-04-28T22:37:21 <xorAxAx> (and of authorship)
2007-04-28T22:37:39 <xorAxAx> no need to put a layer on top of it just because you can solve it "internally"
2007-04-28T22:37:40 <lanius> but this stuff is above the item
2007-04-28T22:37:43 <xorAxAx> why?
2007-04-28T22:37:58 <xorAxAx> its not at all
2007-04-28T22:38:17 <lanius> because the item does not know about any authors or mimetypes
2007-04-28T22:38:27 <xorAxAx> well, it should
2007-04-28T22:38:47 <xorAxAx> like a file system knows about the creator of a file
2007-04-28T22:38:57 <xorAxAx> and the last modification date
2007-04-28T22:38:57 <lanius> and a deleted page is deleted, isn't it
2007-04-28T22:39:04 <ThomasWaldmann> xorAxAx: in short: everything in edit-log now
2007-04-28T22:39:12 <xorAxAx> yeah, how do you map it to the storage, lanius?
2007-04-28T22:39:15 <xorAxAx> ThomasWaldmann: hmm?
2007-04-28T22:39:23 <ThomasWaldmann> meta-data keys
2007-04-28T22:39:31 <xorAxAx> i dont understand you
2007-04-28T22:39:57 <ThomasWaldmann> (22:36) < xorAxAx> deleted, mimetype, author, modification data
2007-04-28T22:39:57 <ThomasWaldmann> (22:36) < xorAxAx> s/a$/e/
2007-04-28T22:39:57 <ThomasWaldmann> (22:36) < xorAxAx> maybe even change comment
2007-04-28T22:39:58 <xorAxAx> lanius: if a page is deleted in a wiki, you can still revert it to the old revision
2007-04-28T22:40:19 <xorAxAx> ThomasWaldmann: what is "edit-log" in this context?
2007-04-28T22:40:48 <lanius> a page or a revision?
2007-04-28T22:40:48 <ThomasWaldmann> local edit-log of 1.5 storage
2007-04-28T22:41:05 <xorAxAx> lanius: a page can be deleted, a revision can just be purged
2007-04-28T22:41:18 <xorAxAx> ThomasWaldmann: ah, yeah, right, i was thinking about that set of attributes
2007-04-28T22:41:31 <lanius> and if i delete a page it's gone
2007-04-28T22:41:35 <xorAxAx> no
2007-04-28T22:41:48 <xorAxAx> like in svn - if you delete a file, its just gone superficially
2007-04-28T22:41:54 <xorAxAx> you can always recall an old version
2007-04-28T22:42:04 <lanius> must it be possible to really delete a page?
2007-04-28T22:42:15 <xorAxAx> yes, thomas already talked about that
2007-04-28T22:42:20 <xorAxAx> and called it "purging"
2007-04-28T22:42:43 <xorAxAx> (i hope that you had been taking notes in the last few hours, otherwise you might repose questions a few times again)
2007-04-28T22:44:24 <lanius> so we need a include_deleted as thomas proposed?
2007-04-28T22:44:51 <ThomasWaldmann> lanius: either that or find a even cleaner way
2007-04-28T22:45:00 <lanius> i just thoguth xorAxAx argued against it
2007-04-28T22:47:23 <xorAxAx> well
2007-04-28T22:47:32 <xorAxAx> deleted should be some kind of metadata
2007-04-28T22:47:49 <xorAxAx> and you should be able to select the result set on the lowest level (backend) not to lose speed
2007-04-28T22:48:01 <xorAxAx> thats 2 requirements
2007-04-28T22:48:12 <xorAxAx> that are a bit unrelated
2007-04-28T22:49:00 <lanius> and where would the user request a list of all pages or a list of all pages including deleted
2007-04-28T22:49:03 <xorAxAx> but the second one should be solvable together with the index ideas
2007-04-28T22:50:02 <xorAxAx> lanius: that would be some kind of itemcollection method
2007-04-28T22:50:09 <xorAxAx> or keys parameter
2007-04-28T22:50:22 <lanius> i don't think keys is allowed to have a paramter
2007-04-28T22:50:39 <xorAxAx> why not? if they have defaults, nobody should notice it
2007-04-28T22:51:08 <lanius> that's an argument
2007-04-28T22:53:15 <xorAxAx> even though its not very pythonic to overload it
2007-04-28T22:53:36 <xorAxAx> list_pages(**query_clauses) might make more snese
2007-04-28T22:53:39 <xorAxAx> sense
2007-04-28T22:55:02 <xorAxAx> flowhase: ping
2007-04-28T22:57:38 <lanius> ok, did we miss anything, i will add the index/filter stuff, update the data stuff and take a look at metadata definition
2007-04-28T22:58:26 <xorAxAx> no idea, my garbage collector is very aggressive :-)
2007-04-28T22:59:24 <lanius> ok, that means i will add those things and we'll talk again
2007-04-28T22:59:29 <ThomasWaldmann> lanius: you should look over the irc logs, wiki pages and existing code
2007-04-28T22:59:51 <lanius> that's what i did
2007-04-28T22:59:59 <xorAxAx> cool
2007-04-28T23:00:11 <lanius> still, a lot of things only come up in discussion
2007-04-28T23:00:56 <lanius> there are many ways to do things and we have to decide on one way
2007-04-28T23:01:08 <ThomasWaldmann> e.g. look at the new filesystem storage layout and check whether it would work well with your model
2007-04-28T23:01:46 <ThomasWaldmann> well := much faster as 1.5 storage is now
2007-04-28T23:01:54 <lanius> i see no problems
2007-04-28T23:04:26 <dreimark> gn all
2007-04-28T23:14:13 <ThomasWaldmann> lanius: what exactly does lastRevision() return?
2007-04-28T23:17:12 <xorAxAx> lanius: dont forget PEP8 :-)
2007-04-28T23:17:21 <ThomasWaldmann> if current_revision() returns the revno int, the new fs storage might be a bit inefficient except if internally caches
2007-04-28T23:18:05 <ThomasWaldmann> maybe just returning the current revision object might be better
2007-04-28T23:20:37 <ThomasWaldmann> for fs storage it will otherwise have to open the current folder, read the metadata just to find out the current revno
2007-04-28T23:21:18 <ThomasWaldmann> then, in a second/third call, you would have to get the meta/data for that revision (again)
2007-04-28T23:21:52 <ThomasWaldmann> and if it doesnt keep internal state, it would have to find out again that this is current rev and not an old revision
2007-04-28T23:23:01 <ThomasWaldmann> lanius: still there? :
2007-04-28T23:29:58 <xorAxAx> yeah, it makes sense if it returns the current revision (and it shouldnt be a method but a property)
2007-04-28T23:33:21 <ThomasWaldmann> lanius: if name == 0 || name = currev: <- don't let your friends code C :-P
2007-04-28T23:33:45 <ThomasWaldmann> (and even in C it would be wrong :)
2007-04-28T23:35:32 <lanius> the StorageBackend does not return any item it just returns plain data
2007-04-28T23:36:07 <ThomasWaldmann> well, you have to solve the above usage case efficiently
2007-04-28T23:36:19 <ThomasWaldmann> we get the current stuff very often
2007-04-28T23:36:47 <lanius> it wouldn't change anything since all the stuff is loaded lazily
2007-04-28T23:37:21 <ThomasWaldmann> ok, describe how i get the current metadata efficiently
2007-04-28T23:38:04 <ThomasWaldmann> (with fs backend as proposed)
2007-04-28T23:38:16 <lanius> get_metadata("Page", revision = 0)
2007-04-28T23:39:49 <ThomasWaldmann> ah, so it doesnt use the current_revision() call
2007-04-28T23:40:00 <lanius> yeah, i think i will remove it again
2007-04-28T23:40:32 <lanius> don't know if it is still needed
2007-04-28T23:42:29 <ThomasWaldmann> the file stuff for data on the backend is still missing
2007-04-28T23:42:35 <lanius> yes
2007-04-28T23:43:30 <ThomasWaldmann> 61 def get_data(self, name, revision, start = 0, end = -1): <- this is not pep8
2007-04-28T23:43:51 <ThomasWaldmann> (the blanks)
2007-04-28T23:44:05 <lanius> it will be removed anyway
2007-04-28T23:50:59 <lanius> ok, will go to bed now
2007-04-28T23:51:02 <lanius> cu
2007-04-28T23:51:30 <ThomasWaldmann> gn :) MoinMoin: MoinMoinChat/Logs/moin-dev/2007-04-28 (last edited 2007-10-29 19:16:48 by localhost)
