Souper

Souper הוא כלי פייתון עבור מתכנתים. הוא מציע אחסון משולב קשר יחד עם מדדים בקטלוג. הרשומות באחסון הם גנרי. ניתן לאחסן בו נתונים על תקליט אם הוא pickable המתמשך בZODB.
ניתן להשתמש Souper שימוש בכל יישום פיתון באמצעות ZODB, כגון פירמידה או פלון.
שימוש בSouper
מתן Locator
מרקים הרימו את מבטו על ידי התאמת souper.interfaces.IStorageLocator לכמה הקשר. Souper אינו מספק איתור ברירת מחדל. אז קודם כל אחת צריך להיות מסופק. הבה נניח הקשר מסוים למשל כמו dict-מתמשך:
>>> ממיישם יבוא zope.interface
>>> מממשק יבוא zope.interface
>>> מprovideAdapter יבוא zope.component
>>> מsouper.interfaces לייבא IStorageLocator
>>> מSoupData יבוא souper.soup
>>>implementer (IStorageLocator)
... StorageLocator כיתה (אובייקט):
...
... Def __init __ (עצמי, הקשר):
... Self.context = הקשר
...
... Def אחסון (עצמי, soup_name):
... אם soup_name לא בself.context:
... [Soup_name] self.context = SoupData ()
... Self.context תמורה [soup_name]
>>> ProvideAdapter (StorageLocator, מתאים את עצמו = [ממשק])
אז יש לנו לאיתור יצירת מרקים לפי שם במהירות ההבזק. עכשיו קל שלה כדי לקבל מרק לפי שם:
>>> מget_soup יבוא souper.soup
>>> מרק = get_soup ('mysoup', הקשר)
>>> מרק
<אובייקט souper.soup.Soup ב0x ...>
מתן במפעל קטלוג
בהתאם לצרכים שלך הקטלוג והאינדקסים שלה עשוי להיראות שונה משימוש במקרה להשתמש במקרה. מפעל הקטלוג הוא אחראי ליצירת קטלוג למרק. המפעל הוא כלי בשם יישום souper.interfaces.ICatalogFactory. שמו של השירות יש לאותו הדבר כמו המרק יש לי.
כאן repoze.catalog משמש ולתת למדדים לגשת לנתונים ברשומות על ידי מפתח NodeAttributeIndexer משמש. במקרים מיוחדים ניתן לכתוב indexers המותאם אישית שלה, אבל אחד ברירת המחדל הוא בסדר רוב הזמן:
>>> מsouper.interfaces לייבא ICatalogFactory
>>> מNodeAttributeIndexer יבוא souper.soup
>>> מprovideUtility יבוא zope.component
>>> מקטלוג יבוא repoze.catalog.catalog
>>> מCatalogFieldIndex יבוא repoze.catalog.indexes.field
>>> מCatalogTextIndex יבוא repoze.catalog.indexes.text
>>> מCatalogKeywordIndex יבוא repoze.catalog.indexes.keyword
>>>implementer (ICatalogFactory)
... MySoupCatalogFactory כיתה (אובייקט):
...
... Def __call __ (עצמי, הקשר = אין):
... קטלוג = קטלוגי ()
... Userindexer = NodeAttributeIndexer ("משתמש")
... קטלוג [u'user '] = CatalogFieldIndex (userindexer)
... Textindexer = NodeAttributeIndexer ('טקסט')
... קטלוג [u'text '] = CatalogTextIndex (textindexer)
... Keywordindexer = NodeAttributeIndexer ("מילות מפתח")
... קטלוג [u'keywords '] = CatalogKeywordIndex (keywordindexer)
... קטלוג תמורה
>>> ProvideUtility (MySoupCatalogFactory (), name = "mysoup")
מפעל הקטלוג משמש מרק-פנימי בלבד אבל אחד אולי כדאי לבדוק אם זה עובד מצוין:
>>> Catalogfactory = getUtility (ICatalogFactory, name = 'mysoup')
>>> Catalogfactory
<אובייקט MySoupCatalogFactory ב0x ...>
>>> קטלוג = catalogfactory ()
>>> מסודרים (catalog.items ())
[(U'keywords ', <אובייקט repoze.catalog.indexes.keyword.CatalogKeywordIndex ב0x ...>),
(U'text ', <אובייקט repoze.catalog.indexes.text.CatalogTextIndex ב0x ...>),
(U'user ', )]
הוספה רשומות
כפי שצוין לעיל souper.soup.Record הוא סוג אחד ורק של הנתונים שנוספו למרק. יש שיא תכונות המכילות את הנתונים:
>>> מget_soup יבוא souper.soup
>>> משיא יבוא souper.soup
>>> מרק = get_soup ('mysoup', הקשר)
>>> שיא = שיא ()
>>> Record.attrs ['user'] "user1 '=
>>> Record.attrs ['טקסט'] = u'foo בר באז '
>>> Record.attrs ['מילות מפתח'] = [u'1 ', u'2', u '& uuml;']
>>> Record_id = soup.add (שיא)
שיא רשאי מכיל רשומות אחרות. אבל למדד אותם אחד היית צריך אינדקסים מותאמים אישית, רשומות כך conatined בד"כ הם בעלי ערך עבור תצוגה מאוחר יותר, לא לחיפוש:
>>> שיא ['subrecord'] = שיא ()
>>> שיא attrs ['homeaddress']. ['Zip'] = '6020'
>>> שיא attrs ['homeaddress']. ['העיר'] = 'אינסברוק'
>>> Attrs ['homeaddress']. שיא ['הארץ'] = 'אוסטריה'
גישה לנתונים
גם ללא כל שאילתא שיא יכול להיות הביא לפי תעודת זהות:
>>> מget_soup יבוא souper.soup
>>> מרק = get_soup ('mysoup', הקשר)
>>> שיא = soup.get (record_id)
ניתן לגשת כל הרשומות באמצעות ניצול BTree המכל:
>>> Soup.data.keys () [0] == record_id
נכון
נתוני שאילתא
כיצד לבצע שאילתות קטלוג repoze מתועדת היטב. מיון עובד באותו מדי. שאילתות מועברות לשיטת שאילתא מרקים (המשתמש באז קטלוג repoze). הוא חוזר גנרטור:
>>> ממשוואת יבוא repoze.catalog.query
>>> [R לr בsoup.query (משוואה ('משתמש', 'user1'))]
[<שיא אובייקט 'ללא' ב...>]
>>> [R לr בsoup.query (משוואה ('משתמש', 'nonexists'))]
[]
גם כדי לקבל את גודל ערכת התוצאות לעבור with_size = True לשאילתא. הפריט הראשון חזר על ידי גנרטור הוא הגודל:
>>> [R לr בsoup.query (משוואה ('משתמש', 'user1'), with_size-נכון)]
[1, <שיא אובייקט 'ללא' ב...>]
כדי לייעל את הטיפול בתוצאה גדולה קובע אחד לא יכול להביא את השיא אבל גנרטור חוזר אובייקטים קלים משקל. רשומות הביאו על שיחה:
>>> העצלן = [l l בsoup.lazy (משוואה ('שם', 'שם'))]
>>> העצלן
<אובייקט souper.soup.LazyRecord ב...> [,
>>> עצלן [0] ()
<'ללא' שיא אובייקט ב...>
כאן הגודל מועבר כערך ראשון של geneartor גם אם with_size = True הוא עבר.
מחק שיא
כדי להסיר שיא מפיתון המרק דל משמש כאחד הייתי עושה בכל dict:
>>> Del מרק [record_id]
אינדקס מחדש
הנתונים רשומות לאחר שינו אותו צריך reindex:
>>> Record.attrs ['user'] "user1 '=
>>> Soup.reindex (= רשומות [שיא])
לפעמים אחד ייתכן שירצה אינדקס מחדש את כל הנתונים. אז reindex יש שייקרא ללא פרמטרים. זה עלול לקחת זמן מה:
>>> Soup.reindex ()
לבנות מחדש את הקטלוג
בד"כ לאחר שינוי של מפעל קטלוג נעשה - כלומר כמה מדד נוסף - לבנות מחדש של הקטלוג שהייתי צריכים. הוא מחליף את הקטלוג הנוכחי עם אחד חדש שנוצר על ידי מפעל הקטלוג וreindexes את כל הנתונים. זה עלול לקחת זמן מה:
>>> Soup.rebuild ()
איפוס (או לנקות) את המרק
כדי להסיר את כל הנתונים מהמרק והריק ולבנות מחדש את שיחת הקטלוג ברורה. שים לב: כל הנתונים הולכים לאיבוד!
>>> Soup.clear ()
הערות התקנה
על מנת להשתמש בnode.ext.zodb souper נחוץ. כגרסת בטא זו שוחררה לא היה שחרור (ייעשה בקרוב). אנא קרא pypi אם הוא שם, אחרת בבקשה להביא node.ext.zodb מGitHub

מה חדש בהודעה זו :.