Skip to main content

56 posts tagged with "TurboGears"

View All Tags

· One min read

tgcrud 專案 1.0 版 放一年下載竟破千了,這應該是我自己的開源專案中單一版本最好的紀錄 :p 還有 花了 20 多頁介紹它,我竟然沒再更新了 Orz. 剛剛順手丟出個 1.0.1 版,修正個使用者丟過來的小問題.

後來我把精力放到 TurboGears 2.0 上。將來 TurboGears 2.0 開發工具中所包含的 crud 功能, 就是基於 tgcrud 的經驗開發的. tgcrud 是基於 kid 模版和 turbogears.widgets , 而 crud 功能則是基於 genshi 模版,toscawidgets 跟 dbsprockets.

· 2 min read

Pagoda 是使用 TurboGears 框架撰寫的 CMS

http://www.pagodacms.org/

現在網站上僅有他們在 pycon 2007 上的 screencast

Pagoda provides a first-class plugin-based content management system
with a Web 2.0 management console that integrates instantly with existing TurboGears applications.

郵件列表中他們揭示了 Pagoda CMS 的一些特色:

  • 只需兩行程式碼就能整合進任何使用 turbogears 撰寫的應用程式
  • 專注於內容管理,而非取代整個網站
  • 使用 SQLAlchemy 和 genshi
  • 多語言內容版本 revisioned content in multiple languages
  • 友善的介面
  • 使用易於瞭解的詞彙與控制流程
  • 頁面可以有附件,也可以嵌套內容
  • 直接支持靜態內容 (如文件檔案), 亦提供 turbogears 新聞搜集,日曆,相簿,部落格等應用程式套件

預計在三月底以 MIT license 發佈.

...... 要是這些特色都能實現的話, 因為新聞搜集,相簿,部落格等都有現成的 TurboGears 應用程式,若能用這個軟體全掛在一起, 可以完全體現 TurboGears 應用程式開發的優勢. 在 Python 網頁框架的佔有率之爭中,可能會是個扮演 FF7 角色的殺手呀.

2007.12: 可惜等了 9 個月連 Preview 都沒放出來,真是 Orz. 感覺 Django 已經吃下大部分新進的 Python Web developer 了.

· 11 min read

相信在做網頁開發時不少人被表單處理困擾著, cherrypy 的網頁表單處理已經很簡單了, 而 TurboGears 更為我們帶來了 widget (網頁元件) 這個概念. 透過 widget 能簡單地完成產生表單,欄位驗證,重用表單等等仔細思考起來相當複雜的動作.

TurboGears 開發者們宣稱 widget 多麼好用,但是 widget 的說明文件卻相當缺乏.

那麼 widget 到底是什麼東西哩?

widget 是什麼

widget 用中文表達簡而言之就是 "網頁元件", TurboGears widget 的功能就是讓使用者重用所有網頁元件.

那麼網頁元件是什麼?網頁元件就是網頁的構成元素.

古代希臘先哲柏拉圖認為風,火,水,土是構成世界的四大元素。所有的物質最終都可以拆解成這四個元素.

而在網頁的世界裡,HTML, 表單 (Form), CSS, Javascript 則是網頁的四大構成元素.(註) 多數的網頁都可以由這四個元素組合產生.

Widget 表單元件

Widget 表單屬於 Widget 的一個重要分支。由以下的基本網頁元件組成:

* 表單欄位元件 (Field) — 等同於 HTML 表單欄位的基本元素, 如文字欄位 [input type="text"] 文字區塊欄位 (textarea) 等等. 用來產生基本的表單欄位.
* 表單欄位列表元件 (WidgetList) - 用來有機地組合表單欄位元件, 產生欄位列表, 提供表單元件使用.
* 表單元件(Form) — 表單欄位, 驗證資訊, 處理方式(post 或 get), 處理函式 (URI) 的集合. 可使用現有的驗證功能 validators.Schema 來做表單驗證.

除了基本的表單欄位元件,TurboGears 也透過 widget 提供了一些進階的表單欄位元件例如跳頁選單 (表單 + Javascript), 語法高亮 (HTML+CSS+Javascript), 標籤頁 (HTML+Javascript) 等元件,這些高級元件 (Rich Element) 也都是由這些網頁中最常見的基本元素所組成.

透過 widget 你可以自己建造自己的網頁元件,也可以透過 python 的擴充機制,很容易使用 easy_install 命令取得其他人共享出來的各種元件.

在使用高級元件之前,我們回到基本面上,先來看看如何用 widget 處理表單.

用 widget 產生表單欄位

你可以在互動式直譯器 (interactive interpreter) 裡試驗 TurboGears widget.

產生 TextField

>>> # TextField
>>> from turbogears.widgets import *
>>> Field = TextField(label='Main Menu')
>>> Field.render()
'<input id="widget" class="textfield" name="widget" type="text">'

產生 TextArea

>>> # TextArea
>>> Field2 = TextArea(label="Description", attrs=dict(rows=3, cols=60))
>>> Field2 = TextArea(label="Description",
... attrs=dict(rows=3, cols=60))
...
>>> Field2.render()
'<textarea rows="3" cols="60" class="textarea" name="widget" id="widget"></textarea>'
>>>

在 Python 互動式直譯器裡你可以看到用 TurboGears widget 產生一個表單欄位並不困難.

用 widget 產生跳頁選單

我們再來看如何用 widget 產生跳頁選單

跳頁選單適用於諸如 "選擇使用的語言" 等等情況, 可以在使用者選擇後自動跳至對應的網頁.

首先,我們先看看如何產生一般的網頁選單

>>> # SingleSelect Field
>>> Field3 = SingleSelectField(label="Author",
... options=[(1, "fred"), (2, "Joe")])
...
>>> Field3.render()
'<select class="singleselectfield" name="widget" id="widget"> <option value="1">fred</option><option value="2">Joe</option></select>'
>>>

到現在為止,我們可以確認產生一般網頁選單的方式與前面生成簡單文字欄位的方式完全一致.

我們接著來看看如何產生跳頁選單.

>>> # JumpMenu
>>> from turbogears.widgets import *
>>> Form = JumpMenu('Main Menu',options = [
... ('/createNewBatch', 'Create New Batch'),])
...
>>> Form.render()
'<select class="jumpmenu" onchange="TG_jumpMenu(\'parent\',this,0)" id="Main Menu" name="Main Menu"> <option value="/createNewBatch">Create New Batch</option></select>'
>>>

恩,產生跳頁選單跟產生一般網頁選單的使用方式並無二致。也同樣是這麼容易.

跳頁選單無法在 Python 互動式直譯器中完全表現, 因為在實際使用時,跳頁選單元件除了會產生這段 HTML 表單外, 嵌入 turbogears 網頁樣板時網頁元件還會自動嵌入相應的 javascript.

等你熟悉了 Turbogears 之後, 透過 widget, 即使是很複雜的 javascript 元件 (如所見即所得網頁介面編輯器), 你也不必擔心要導入哪些 Javascript library 等瑣事,透過網頁元件的分享,你可以直接透過 easy_install 命令即裝即用別人寫好的網頁元件。然後把時間用在自己網站內容的開發上.

用 widget 產生表單

前面已經講完用 widget 產生表單 "欄位" 了。然而一個表單除了基本的各個欄位之外, 還包含了一些其他元素。例如如何組織欄位,指定上傳方式 (GET/POST), 指定處理動作 (action) 等等.

TurboGears 裡已包含了數種預設表單欄位的格式。而其中最常見的就是 TableForm 了.

用 widget 組織表單欄位

可以透過 WidgetsList 來組織表單欄位.

>>> class BookFields(WidgetsList):
... title = TextField(label="Title")
... description = TextArea(label="Description")
...
>>> BookFields()
[TextField(name='title', convert=True, field_class='textfield', attrs={}, css_classes=[]), TextArea(name='description', convert=True, rows=7, cols=50, attrs={}, css_classes=[], field_class='textarea')]

我們已經組織起了兩個文字欄位,通過最後一行可以發現 WidgetsList 其實只是協助我們產生了一個表單欄位元件的列表. 接下來我們就要把這個欄位列表放進表單裡.

>>> class BookForm(TableForm):
... #name="Book"
... fields = BookFields()
... #validator = BookSchema()
... #method="post"
... submit_text = "Create"
...
>>> BookForm()
BookForm(name='form', submit_text='Create', convert=True, table_attrs={}, form_attrs={}, action=None, disabled_fields=set([]), method='post')
>>> BookForm().render()
'.form method="post" class="tableform" name="form".
......略......
./form.

基本上這產生的就是相當完整的表單了....

等等!~~想必你要大聲質疑:我的 "action" 呢???換句話說,我怎麼指定處理這個表單的 url 呢?

widget 與樣板合作

恩,好問題。你可以直接在宣告時就將 action 的值傳給 widget, 也可以在樣板 render 時再傳入。一般我習慣習慣在表單最終產生時 (樣板 render 時) 再指明.

例如這樣

在 controllers.py 中加入

model_form = BookForm() # 事先宣告好在重用時不用多次呼叫

產生實際表單頁面

@expose("template.new")
def new(self, **kw):
return dict(form = model_form)

在 "new.kid" 樣板中加入這一行

${form(action='save')}

當然有了處理這個表單的 url , 也需要在 controllers.py 中加入一個處理 "save" 這個處理表單資料的 method

@expose()
def save(self, id=None, **kw):
....

前面講起來好像花了不少篇幅,但其實看完程式後你會發現使用 widget 程式邏輯變得出乎意料之外的清晰. http://docs.turbogears.org/1.0/CRUDTemplate

用 widget 驗證表單欄位

驗證表單欄位其實只要在 TableForm 中傳入 validator 參數即可

>>> class BookForm(TableForm):
... fields = BookFields()
... validator = BookSchema()
... submit_text = "Create"
...
>>> BookForm().render()
.....略....

你可以使用 formencode 模組所提供的 "Schema" 完成任何複雜的表單驗證程序. 從比較基本的輸入字數長短 / 類型驗證,到多欄位密碼確認等都可以簡單地達成. (Turbogears 將 formencode 的 Schema 包裝成 validators.Schema)

>>> from turbogears import validators
>>> class BookSchema(validators.Schema):
... title = validators.String(not_empty=True, max=30)
... description = validators.String()
...
>>> BookSchema()
<bookschema object="" 114="" chained_validators="[]" fields="{'description':" title="" pre_validators="[]">
>>>

上一節中我們在 controllers.py 裡定義了

model_form = BookForm()

現在我們在做表單驗證時也可以用的上.

用法是簡單地在 "save" 這個 method 上加上 @validate (model_form) 裝飾。表示要使用 model_form 表單元件所附的表單驗證元件.

而要順便將輸入錯誤的訊息產生在表單上的話,只要再加入 @error_handler (new) 裝飾, 表示如果有錯誤就跳轉到 new 這個 method (我們的表單頁) 處理.

@validate(model_form)
@error_handler(new)
@expose()
def save(self, id=None, **kw):
....

widget 還可以幹什麼

widget 可以讓你用最 Pythonic 的方式表現網頁表單,也可以簡化提供不同 AJAX 函式庫的支援.

你覺得網頁元件能幹什麼,Turbogears widget 就可以幫助你幹什麼.

怎麼知道有哪些 widget

Turbogears 的網頁工具箱 toolbox 中有網頁元件瀏覽器 (widget browser). 使用 $tg-admin toolbox 命令啟動網頁工具箱就會看到網頁元件瀏覽器. 在網頁元件瀏覽器中你可以找到所有內建與外掛的網頁元件.

外掛的網頁元件 (widget plugin) 可以在 cogbin (http://www.turbogears.org/cogbin/) 找到.

註:嚴格說來,"表單" 其實是屬於 HTML 的一部分. 所以也可以說網頁的三大基本組成元素是 HTML, CSS, Javascript.

TurboGears widget 實現表單的方式也是組合這三大基本組成元素.

然而因為表單的使用與其他 HTML 元素的使用有較大差別. 在說明時獨立出來更易於理解.

· One min read

TurboGears 的開發哲學有三:

1. Keep simple things simple and complex things possible 讓簡單的事情維持簡單,並讓複雜的事情變得可辦到

2. Give defaults while you give choices 提供選擇時一並提供預設值.

3. Give choices while the one obvious way depends 當莫衷一是時就提供選擇.

· 7 min read

楔子

自從聽說了敏捷方法 (Agile programming) 後,一直很想試試這種 "測試先行" 的開發方式. 但是在 python 上前後試過 unitest, doctest, 都不夠 "簡單到會想常常拿來用" 的程度,

今天拿了一份原型寫得差不多的程式,試著寫些測試例子 (test case) 後用 nose 測試工具來測試看看,想不到 nose 還蠻容易使用的.

三步驟使用 nose 開始測試

  1. 安裝或更新 nose

# easy_install -U nose

沒用過 easy_install ? 你該開始試著用了!

  1. 撰寫測試例子 (test case)

打開一個新的資料夾,我們統一在這個新資料夾裡寫主程式與測試例子

將要測試的內容寫入 something.py 這個檔案[註 1]:

> class Hello(object):
> def __init__(self):
> self.template = "hello world"
>
> def render(self):
> return self.template

nose 測試工具識別測試例子的條件,是判斷找到的這個類別或方法的名稱是不是以 "test" 或 "Test" 開頭。如果是的話就當成是測試例子. nose 會自動搜尋子目錄下所有符合的測試例子,並自動開始測試.

因此我們第一個範例程式用的測試例子只要是函式名稱用 'test' 開頭來命名就可以囉,我們命名一個檔案 testsomething.py (這個檔案名稱以 test 開頭與識別測試例子的條件並無關聯,只是慣例上放測試的例子的檔名都會加上 test 字樣), 並在裡面寫下:

testsomething.py:

>
> def test_Hello():
> abc = Hello()
> assert "hello" in abc.render()
>
> def test_foreign():
> abc = Hello()
> assert "bonjour" not in abc.render()

assert 是 nose 用來判斷測試結果的語法。主要有這兩種:

  • assert 片段 in "結果"

  • assert 片段 not in "結果" 對照上面範例,可以得知上面兩者的意思就是:

  • 測試結果 "hello" 字串應該在 abc.render () 回應的結果裡

  • 測試結果 "bonjour" 字串應該不會在 abc.render () 回應的結果裡如果上面任一種情況不符合 assert 敘述,這個測試用例就會回報失敗.

  1. 開始測試

切換到檔案在的檔案目錄下,輸入

# nosetests

結果應該類似這個樣子:

> D:\path\pyfile>nosetests
> ......
> ----------------------------------------------------------------------
> Ran 1 tests in 0.020s
>

OK 那麼如果我們改動了 something.py 中 self.template 變數的內容,在內容裡加上了 "bonjour" 字樣,會發生什麼事情呢?

有測試工具的好處就是我們只要單純地再次運行 nosetests 命令就好了,不用花腦力去判斷或思考:) 我們查看訊息時會看到類似以下的訊息:

> 2, in runTest
> self.testFunc()
> File "D:\path\pyfile\testsomething.py", line 90, in test_Hello
> assert "bonjour" not in abc.render()
> AssertionError
> -----------------
> Ran 1 tests in 0.030s
>
> FAILED (failures=1, errors=1)
>

上面的報告提醒我們有一件錯誤: "bonjour" 字串原本不應該出現在 abc.render () 回應結果中的,但結果中竟然出現了!

所以如果我們的測試用例寫的好,就可以肯定我們剛剛改動 something.py 時出了些問題。測試這件事確實有效!

較好的約定

我們已經知道,只要類別或方法的名稱是以 "test" 或 "Test" 開頭。就會被 nose 當成是測試例子,所以其實在一個小程式中,我們大可把測試例子跟主程式放在同一個檔案裡.

但是當你都還不很確定你在幹什麼的時候,我建議還是將測試例子跟主程式分開。這麼做除了程式不容易搞混之外,在切換檔案時,還可以順便切換撰寫程式與撰寫測試例子時的不同 MindSet.

測試驅動

那麼如果我們想改寫 hello 函式,好讓它可以用法語 "bonjour" 打招呼,我們該怎麼辦? 記得 "測試先行", 考慮加上一個新的測試例子,而不影響原本的功能吧!

加入的測試例子:

>
> def test_bonjour():
> abc = Hello('bonjour')
> assert "bonjour" in abc.render()

接著要做的就是再跑一次 nosetests, 看到這個新的例子跟我們報告錯誤了. OK, 那就開始修改 hello 函式吧![註 2]

其他的測試

nose 支援的測試的方式琳瑯滿目,可以使用 "nosetests -h" 命令來查看支援的項目.

例如另外一個常用的測試方式是使用 doctest: nosetests --with-doctest

那麼 doctest 是什麼樣的測試方式? 又該怎麼使用 doctest 呢?嘿嘿,4 月 OSDC.tw 07 再開講囉:D

我知道這個工具已經快半年了,到今天才有時間,勇氣真的下去嘗試. 讓我白白錯過這樣好用的工具這麼久,應該怪在 nose 太少文件可以參考的頭上吧? 乾脆自己來寫個 "三步驟使用 nose 開始測試" 的簡易文件好了.

註 1: 這篇文章不講怎麼寫 python 程式,這部份請自理:P 註 2: 同註 1, 建議妳逛逛 www.python.org.tw 可以看到更多參考資料

· 2 min read

前幾個禮拜看到 limodou 的 Openbook platform 後弄的 TurboGears 製作書站 screencast (示範影片)

第一個影片裡示範了如何使用 TurboGears 建立一個專案,與如何啟動開發用網頁伺服器. 並展示了如何透過修改模板快速訂製頁面。這個 screencast 中完全使用 TurboGears 預設的 CSS style.

1st. is a quickstart demo with hello world template version (6.5MB)

第二個影片裡示範了如何使用 TurboGears 工具箱 (Toolbox) 中的模型設計工具 (Model Designer)和資料編輯工具 (Catwalk) 來建置 TurboGears 動態內容網站

2nd is Model Designer with Catwalk (7.7MB)

第三個影片中使用到我寫的 TurboGears tgcrud 擴充模組,透過 tgcrud 擴充模組可以很容易地產生類似 Rails 的 scaffold 介面架構。但與 scaffold 不同的是所有 code 都是 implicit 的,更加容易修改.

3rd. is tgcrud, the TG's scaffold (5.2 MB)

感謝 Elvelind Grandin 協助上傳至 TurboGears 網頁空間.

· One min read

晚上剛看到在 TurboGears 的說明文件寫作文件中加上了張圖

這張圖上的口號是:

Onward, Documentation Writers! DID YOU CONTRIBUTE SOMETHING TODAY?

可以翻譯成:

前進吧,(寫手) 同志們 你今天為 (TurboGears 的文件) 革命事業貢獻了些什麼嗎?

TurboGears 用這麼有趣的圖 (萬里大長征) 來徵求貢獻文件,真是很 KUSO 呀...

PS: 這週末 (2/10) 有近期的第二次 TurboGears Doc Sprint 喔.

· 5 min read

好久前使用 Ultra Dev (Dreamweaver 4 網頁編輯器時代的東西) 寫 ASP 網頁時,那時其中一個超方便的功能就是在與伺服器繫結後,選擇一個 "產生詳細頁面" 的 Widget 元件,稍稍做點設定 Dreamweaver 就幫我產生一個包含資料庫表單內容的頁面。用同樣類似的方法就能完成製作新增,刪除網頁等事情。製作一套動態網頁也不用花太久時間.

上禮拜回頭去試試 Ruby On Rails 時覺得 ROR 有得分的一大優點是鷹架產生器 (scaffold).

scaffold 有什麼功能呢?scaffold 可以根據 RoR 的 ORM (Active Record) 來產生對應的 Controller/Template 程式碼,達到能基本的資料建立 / 修改 / 檢視 / 刪除 (Create/Read/Update/Delete, CRUD) 的目的。而且即使在產生出來 scaffold 後再變更資料庫欄位,產生出來的程式仍然可以正確判斷內容。使用感覺頗類似 Django 的 admin 介面或 TurboGears 的 Catwalk / DataController, 但是就可修改性而言我覺得這種作法稍勝一籌.

只是要拿 ROR 的 scaffold 繼續修改也很容易碰上問題. 因為它為了要能自動對應資料庫的改變來反應到 scaffold 介面上,所以產生出來的 code 除了基本大框架可見之外,裡面的內容都被包在不可見的單一函式裡. 要做任何修改時還是得自己大量改寫 scaffold 產生的內容 (不過還是比全自己寫來的快)

要搭一個漂亮的鷹架要多久呢? 我使用 TurboGears 來重現 scaffold 的各種列表增刪修改介面,為了取得最高的重用性,再用 widgets 改寫一遍,運用 TurboGears 現成的 Widget 已經能幫忙處理新增 / 修改表單的生成。弄好這個 CRUD 介面已花了 3 小時,而且還不像 Rails 一樣會自動去抓變動的欄位.

(3 小時?有人開始撇嘴了....)

寫這個介面當然是有目的的. 接下來在開發環境中,我試著將這個 CRUD 介面做成了 TurboGears 的樣板。並透過 tg-admin 加入一個 crud 命令。使用

tg-admin crud [model class name][controller name]

這樣的語法來產生一個包含了 controller 和 template 的資料夾

例如 model 中已經定義了一個 BookMark class, 只要在專案資料夾中輸入

$tg-admin crud BookMark admin

就會在專案資料夾中新增一個 admin 資料夾,在 controller 中使用

from admin import admin 就可以將處理 BookMark 資料的介面導入到網站中.

以後每次要做的只是簡單地修改表單欄位 (Form field) 定義和 list/show 樣板想要顯示的欄位就可以有完整的 CRUD 介面了。整個過程只要幾分鐘 (預設還會自動套用專案預設的 CSS, 啥都不改就蠻漂亮滴 XD).

目前 tg-admin crud 的做法和 ROR 的 Scaffold 最大的不同在於整份產生的介面不管是 controller 或 template 的程式都是明確的,沒有需要修改時就得重寫的黑盒子.

接下來應該是進一步降低要修改的地方,透過 widget 來將重複設定 (無論是 controller/template) 都減到最低程度。達到足夠成熟度再公開.

目前的 crud 樣板在這,已經可以運用了 CRUD Template

· 2 min read

WhatWhat Status is a web application for tracking the status of projects across an organization. It's opensource and able to download from here.

I found this project from the TurboGears book. WhatWhatStatus' default setting is for protegres and MySQL, but not for SQLite. I'd like to share my steps to use SQLite database with WhatWhat Status.

1. check out the source from svn

svn co http://cleverdevil.org/svn/optio/whatwhat/trunk

2. install textile with easy_install command

$ easy_install textile

3. config the dev.cfg file to use sqlite database

enter the whatwhat status folder, edit dev.cfg:

[global]

# WHATWHAT SPECIFIC

whatwhat.uploaddir = '%(current_dir_uri)s/whatwhat/static/files'

# DATABASE

sqlobject.dburi="sqlite://%(current_dir_uri)s/devdata.sqlite"

4. create database by tg-admin sql sql command

$ tg-admin sql sql (or tg-admin sql create)

5. add default user with catwalk

5.1 first you need to start the TurboGears toolbox

$ tg-admin toolbox

5.2. choose the catwalk in browser

5.3 select "Person" in catwalk left side menu

5.4 click "Add Person" button on top of the page

5.5 enter the following informations:

displayname: any name
email: any email
userid: admin
password:21232f297a57a5a743894a0e4a801fc3

Note that the password field is crypted, the verbose password we typed means "admin".

6. Start whatwhat status

run

$ whatwhat-start.py

enter the username/password as "admin", "admin", then click login.

all done!

· 2 min read

快下班的時候接到一通電話,聲音甜美的天瓏小姐打來提醒我上次訂的 TurboGears 書已經到貨囉. 晚上馬上殺到天瓏去敗了一本,在附近的漢堡王就看了起來.

總的來說感覺很不賴,和網路上的教學文章切入的方向不盡相同,書中採用了好幾種方法來寫 Hello World, 好讓程式 / 網頁開發者都能找到切入點.

比較令我驚訝的是在書中第四章就開始講使用版本控制來管理程式,並講解 TurboGears 對測試先行(先寫測試再開始開發的方法)的支援;書中有大概 80 多頁 (全書 450 頁左右) 講的是 AJAX 函式庫 (Mochikit) 的支援,這都是網站教學文章裡最缺乏的.

另外一個插曲是我在天瓏附近的簡體書店裡看到 DH 的 Agile Ruby on Rails 簡體中文版,定價 65 元 (4), 跟手上的這本 $50 元 (30) 比起來實在夠便宜呀 Orz

· 2 min read

EasyEclipse for python

People who are used to Microsoft VisualStudio or Java IDE usually criticize that python has no good IDE to cooperate with,

I think pydev is one of good python IDE, which is based on eclipse platform. But since you try to install it, it's pretty annoying to set the eclipse and pydev run properly.

Now EasyEclipse project provide an easy install pack of Eclipse for python, it contains:

  • eclipse platform itself,

  • pydev(eclipse python support),

  • Subclipse(eclipse SVN GUI),

  • and several useful plugins installed by default.It really ease the installation and configuration of Eclipse for python.

Pydev with Turbogears

Besides that, Pydev developer recently wrote an article for Configuring Pydev to work with Turbogears

It sounds like a right time to try for pydev + TurboGears.

So I searched and installed the Eclipse for python and EasyEclipse Web tools editors for eclipse HTML/CSS editor and an Internal Web Browser.

The result? It's not much too say.... pretty good:D

Start Up

First create a pydev project, it will assign a workspace for the project. Open the console, change path to the workspace folder. Use tg-admin tool to create a TurboGears projects named "projectname" within the pydev project workspace folder.

Now the project folder will shown on eclipse Navigator panel. (you may need use right click menu-> refresh) click the start-_projectname.py tap F9, then the web server will run.

You can use the "Open Web Browser" icon which is near with the search icon to open the internal Web Browser. Type http://localhost:8080 to see the welcome page :)

Sounds good?

Configurations

Here are a little configuration tips you may intrested...

Assign the python interpretor

1. open window/preference, select pydev/interpreter-python, click top right "Add" button to select the python.exe path (windows default is C:\python24\pythonw.exe). The proper library and key words will automatically load for you to use.

Template Association

2. select General/Editors/File Association, click top right "new" button to add "*.kid" file style for kid template. Press the second "Add" button to assign the associate editors to HTML Editor(default) and Internal Web Browser.

I also found a WYSIWYG HTML editor EasyEclipse eZingBuilder, but I can't get the kid page present correctly now.

more tips are welcome

· One min read

The Zen of TurboGears, by Fred Lin

Keep simple things simple and complex things possible Give defaults while you give choices Give choices while the one obvious way depends

Make it work Make it right Make it fast

Pythonic is better than domain specific Easy configuration is clear than convention Integration counts Batteries included rocks Flexibility flow ideas into each part of code

keep data in Model and seperated logic from Template Widgets are one honking great idea -- let's do more of those!

· One min read

I wrote a doc in TurboGears doc site: Wrap AJAX operation in Widgets, which demonstrates how to use the widget to do basic AJAX operation as Rails 'link_to_remote' helper.

The RemoteLink widget works differ from Rails 'link_to_remote' helper. It's simple, pure python(while you use it) and fully 'optional'! 'Optional' means if you remove the widget, your site still functional. Thanks to the mochikit cool functions :-)

· 7 min read

許多人以為 TurboGears 能跟 DjangoRuby on Rails 比較的地方只是因為一個分散組件,一個集中開發.

但 TurboGears 好用的地方並不是在它堆砌了許多開源的 python web 專案 (如不曾成功過的 subway), 而是真正提出了一個整合這些 python web 開發資源的方法。並提供相當具有 python 風格 (pythonic) 的使用方式.

1. Decorator 形式的 Dispatcher

TurboGears 的多數的秘密存在於 Decorator (用 "@" 符號開頭的敘述) 中. Decorator 是 python 2.4 後才引入的特性, 適度使用可以讓程式碼更清晰.

TurboGears 基本的網頁型態是這樣:

>
> @expose()
> def index():
> return

基本的 pyhton method 加上 @expose() 這個 decorator 敘述, 讓 server 知道這個函式是 public to web 的.

需要登入認證功能,就再加一個 @identity 敘述

> #auth_admin_required = identity.in_group("admin")
> @identity.require(auth_admin)
> @expose()
> def index():
> return

如此被裝飾到的網頁就有了認證功能.

同樣形式的還有

@paginate # 分頁功能 @validate # 表單驗證功能 @error_handler #錯誤處理功能 @exception_handeler #例外處理功能

等特殊功能.

@validate 表單驗證的功能除了驗證表單參數, 還負責將參數從字串轉換成 python native 格式,可以對網頁傳過來的參數直接用 python 做處理.

@error_handler 和 @exception_handeler 被用來對應表單驗證功能 讓我們可在同一個函式裡處理錯誤,或另外定義函式做錯誤處理

>
> @error_handler("index")
> def ex_report():
> return "exception"

2. 一個函式,多重輸出

很多人知道 TurboGears 在樣板選擇上的多樣性, 但是卻沒有挖掘到在 TurboGears 的神奇之處. 在 TurboGears 中使用同一個函式,就可以針對不同需求,輸出多種期望的格式.

>
> # 使用網頁樣板產生網頁介面
> @expose(template = "hello.welcome")
> # 產生 JSON 格式介面供 AJAX 程式調用
> @expose("json")
> #使用不同的樣板引擎, 產生RSS格式介面
> @expose(template = "genshitext:hello.hoho", as_format="RSS/XML")
> def show(self, **kw):
> return dict(name = 'foo', url = 'boo')

這是因為 TurboGears 回傳使用 python 特殊的 "字典 (dict)" 形式, 而不是一般常見的字串形式 (當然 TurboGears 同樣也可以直接輸出字串).

當使用者要求網頁的時候,web server 決定好對應的 method 運行後, method 輸出字典型式的返回值到 decorator. 再根據 @expose decorator 的判斷條件, 取用適當的樣板配合字典來生成適當的介面.

原本需要自行將樣板與內容 "串連 (serialize)" 的工作,TurboGears 都幫忙我們完成, 讓我們只要專注在程式邏輯上即可.

要從別的 method 調用這個函式不同的輸出也很容易, 只要在返回值裡加上一個 "tg_format" 參數即可手動指定輸出格式.

>
> @expose()
> def rss():
> return rss(tg_format = "RSS/XML")

3. 簡單設定

通常在 TurboGears 中要讓一個資料庫程式運作, 只要在 dev.cfg 裡指定好對應的資料庫路徑 (dburi), 就可以開始資料庫網站的開發. TurboGears 自會幫忙處理初始化的動作,並且提供相應工具.

要改換整個網站的預設樣板引擎,同樣也是一行設定搞定.

tg.defaultview = "genshi"

程式裡往往會有些可以讓使用者修改預設運行設定的地方, 如在程式裡要取得預設的模板引擎,可以使用

> config.get("tg.defaultview")

來取得預設的模板引擎。取得其他設定值也是使用同樣的方法.

TurboGears 開發的應用程式在發佈 / 安裝上相當容易. 使用易用的 setuptools python 套件發佈功能, 安裝時能自動抓取使用到的 python modules.

4. 高擴展性

TurboGears 框架是個組合框架 (meta framework), 因此設計之初就把高擴展性視為重要目標. 只要在 console 中使用 tg-admin info 命令就可以一窺 TurboGears 擴展的面目。你會驚訝地發現其實 TurboGears 大多數的功能都是透過擴展實現.

TurboGears 使用的擴展方式是透過 python setuptools 的 entrypoint, 撰寫自己的擴展並不需要改動 TurboGears 的原始碼. 安裝擴展也可以透過 easy_install 命令自動從 python cheese shop 下載組件.

5. 與 Python 社群互利

TurboGears 並不是一個只取不予的開發框架, 一方面 TurboGears 降低了試用各 python web modules 的難度, 使得各專案能吸引更多使用者,也加快了各專案的成熟度;

另外一方面,除了多數 python modules 都可配合 TurboGears 使用之外, TurboGears 框架中所開發出來的工具也都盡量朝能獨立於框架外使用的方向邁進.

近期的成果是 ToscaWidgets, 將 TurboGears 中方便重用的 widgets 獨立出來, 可在 pylons, web.py 等框架和工具上使用.

TurboGears 在組合框架上,不只是達到功能上的滿足,還達到與 python 語言使用上的一致性. 充分使用各種 python 語言的特性與工具,沒有過多的 Magic. 這是許多追趕的組合框架應該思考的.

PS: 對 Open Source Project 來說,一個好的文件網站也很重要

· One min read

拿到一個現成的資料庫,最快速的就是直接存取啦.

TurboGears 中除了預先定義 schema 外,也可以直接使用 SQLAlchemy 中的 SqlSoup 模組來直接存取資料庫.

之前我有寫過英文版的,今天 trace 一下 sqlsoup 後發現還有更簡單的方法:直接取用 metadata.

1. 修改 dev.cfg 中的 sqlalchemy.dburi , 指到對應的資料庫

2. 在 your project/model.py 中,寫下

from turbogears.database import metadata from sqlalchemy.ext.sqlsoup import SqlSoup

soup = SqlSoup(metadata)

3. 使用 shell 存取資料

$ tg-admin shell

poll = soup.poll.select() print poll

· 2 min read

Purpose

Have an exist database and want migrate to TurboGears? Or you've been using TurboGears SQLObject model and want to migrate to SQLAlchemy?

Solution

TurboGears newly support SQLAlchemy 0.2 module(>0.9a6), it provide a slick solution: SqlSoup !

What SqlSoup does?

SqlSoup inspects your database and reflects its contents to class, no model definitions are necessary!

What does that mean?

It means you only need to specify a uri for database, and call SqlSoup to do the rest.

What's the Benifits?

SqlSoup maps database tables to classes automatically. I'm not sure how efficient it is, but at least you can use SqlSoup by following ways:

  • To use existing Database design tools to design my database
  • To use SqlSoup in design phase, and code to SQLAlchemy class when the databse is settled down.
  • To painless migrate SQLObject generated database to SQLAlchemyTest Code

Try the test code, it is thin.

in model.py

1 from sqlalchemy.ext.sqlsoup import SqlSoup

2 uri = "sqlite://%(current_dir_uri)s/devdata.sqlite" 3 soup = SqlSoup(uri)

Explain

line 1 import SqlSoup from sqlalchemy module,

line 2 specify the uri link to the database (I believe it can be improved)

line 3 the real code calling SqlSoup connect to uri

line 4 and line 5 shows I call the table "poll" from database

if you can't execute is , maybe you should install sqlalchemy first

$ easy_install sqlalchemy

or try the TurboGears way:

1 from turbogears import config 2 from sqlalchemy.ext.sqlsoup import SqlSoup

3 uri = config.get('sqlalchemy.dburi') 4 soup = SqlSoup(uri) All you need to do is specify the dburi for sqlsoup.

Let's test what we got

poll = soup.poll.select() print poll

Reference

That's all you need in TurboGears. To get further usage , you can refer to Introducing SqlSoup

ps: Actually TurboGears has done nothing particularly to support SqlSoup, I just use it as other modules.

· 2 min read

TurboEntity 照著 'SimpleBlog Part II' 中的範例改寫後,獲得以下程式碼 (model.py):

>
> from turboentity import *
> from docutils.core import publish_parts
>
> class Post(Entity):
> class turboentity:
> tablename = "posts"
>
> title = Column(Unicode(50))
> content = Column(Unicode)
> post_date = Column(DateTime, default=datetime.now())
> is_published = Column(Boolean, default=False)
> comments = OneToMany('Comment',backref='posts')
>
> @property
> def html_content(self):
> return publish_parts(self.content,writer_name="html")["html_body"]
>
> class Comment(Entity):
> class turboentity:
> tablename = "comments"
>
> author_name = Column(Unicode(255), nullable=False)
> author_email = Column(Unicode(255), nullable=False)
> author_url = Column(String(255))
> comment_date = Column(DateTime, default=datetime.now())
> content = Column(Unicode)
> post = ManyToOne("Post",backref='comments')
>

要表示 post-comments 關係只需分別在兩個類別中宣告 OneToMany - ManyToOne 即可,真是方便呀.

另外當定義好 TurboEntity 類別後,物件自動可以用傳值的方式輸入內容,不需一個個各別指定喔.

例如一般的寫法是這樣子:

p = Post.get (1) # 取得條目 c = Comment () # 新建一條評論 c.post = p # 這條評論屬於 p 條目 c.author_name = "CommentDude1" # 這條目的作者是 c.author_email = "[email protected]" # 這條目作者的郵件信箱是 c.content = "Great post! Keep them coming!" # 這條目的內容 c.flush () 可以直接改成 p = Post.get (1) c = Comment (post=post, author_name="Bob", author_email="[email protected]", content="Bob loves this site.", author_url="http://bob.example.com/") c.flush()

TurboEntity改寫的程式和原本 Tutorial 相比,可以看出它好用的地方.

· 4 min read

明天公司補放國父誕辰紀念日,所以有空到 Google 翻翻最近有沒什麼有趣的文章。我找到了一篇 TurboGears vs Rails. 文章名稱夠聳動,雖然這篇文章有點舊了 (用的是 0.9 的預覽版 TurboGears, 或稱為未進化型態版本 XD), 不過裡面對 TurboGears 和 Rails 的特性確實抓得頗準:

The Pythonic way is "explicit over implicit". Everything is out for show: you know what modules are imported, you know what methods are exposed, you know what columns are defined and so on. It may take more keystrokes but the extra code let's you know what is happening when things go wrong. python 語言的風格是 '直率的比含糊的好'. 所以所有的過程都可以被檢視:妳曉得如何導入使用的模組,函式怎麼對應到網址上,妳也曉得資料物件如何定義等等。妳可能需要多打一些字 (註:事實上不多), 但是這些額外的程式碼能讓妳在發生錯誤時更容易地知道自己的程式到底發生了什麼事.

The the Rails way is the opposite: take the burden off the developer, don't bother them with the petty details that get in the way and add to the line noise. Rails 的寫作方式則相反:把讓開發者困擾的因子都去除掉,不要在開發中用細節來干擾程式碼.

事實上去年 5 月底時,我在看過 OnLamp 網站上的 Ruby On Rails 教學後,相當驚訝現在網頁開發的進步 (之前有一年沒寫動態網頁了). 所以我也趁等待完成論文前的時間歔空寫了篇 Ruby On Rails 教學。不過在 7 , 8 月 Django, TurboGears 這些 Python 框架相繼出現後,我發現除了可以使用熟悉的 Python 語言風格來寫程式之外,以後也可以透過網頁介面來使用大量的 Python 模組實在非常吸引我。而當 TurboGears 框架出現 ToolBox 這神奇的工具箱後,我開始漸漸投入了 TurboGears 開發的行列.

能展現自我特點的是創意而不是程式碼 在我的觀念裡,能展現自我特點的是創意而不是程式碼 (也許因為我不是個天才程式設計師吧 XD). Rails 也是個相當吸引人的框架 (差不多靠一己之力拉拔 Ruby 語言 XD). 但是 python 的 "應該會有一個 -- 最適當的一個的方式來實現" 哲學比較接近我的想法。在閱讀其他人的 TurboGears 專案時只要不用到太進階的 Python 語言功能,基本上都非常易於閱讀與修改. (例如目前 TurboGears 最進階的教學文件: SQLalchemy 版的 SimpleBlog, 花一些時間就可以改寫成 TurboEntity 版 SimpleBlog 之一, 之二)

· One min read

After watching Mark Ramm's TurboGears One Page Reference,

I made a huge MindMap to track my understanding of TurboGears svn version, I think this MindMap will help others as well.

Here are parts of them (that I've tracked):

TurboGears Excuable Commands

TurboGears Controller Conventions

TurboGears SQLObject Usage

TurboGears Controller Decorators

TurboGears Controller Validators (Formencode API)

and related Cherrypy API

Notice that a part of notes in these MindMaps are based on Mark Ramm's One Page Reference.

And it's even better if someone intrest to make a more fancy quickreference based on those early works.

· 2 min read

今天到天瓏書局預定了 11/9 號出版的 "Rapid Web Applications with TurboGears".

其實這本書早在 9 月多時主要作者 Mark Ramm 透過封閉的 TurboGearsBook group 提供各章節草稿時我就看過了.

參與 TurboGearsBook Group 的要求就是在享受預覽草稿的權利同時也要扮演 Reviewer/Editor 的角色提出意見.

在書籍不是 OpenSource 的情況下,這種兼顧社群與提昇質量的方式還蠻值得參考的.

當時內容還不太完整,不過已經勾勒出大部分的輪廓了。由於 TurboGears 是個整合許多 Python 模組的框架,因此裡面除了框架本身內容,實際範例外,還專章提到了諸如 TurboGear 如何的使用 CherryPy, SQLObject, SQLAlchemy, Formencode 等模組.

另外測試的部份除了講到 nosetests 與 TurboGears 為方便 Model, Controller, Viewer 各層測試而加入的 testutils 測試函式庫外,還提到 Selenium, Mechanize 等使用者經驗測試部份. 算是我相當期待的一本書.

· 2 min read

這幾天 TurboEntity 這個類似 ActiveMapper 的模組一出現馬上獲得不小的關注. 因為它可以用幾乎與 SQLObject 數量相當的程式碼來定義 ORM, 又能完全繼承 SQLAlchemy 的效能和彈性.

Lee McFadden 從上上週開始在他的 Blog 上連載了 3 篇 'SimpleBlog' 系列文章,引導如何使用 SQLAlchemy + TurboGears 製作簡單的 Blog 系統. 他採用了接近基本 SQLAlchemy 的設定方式,因此程式碼有點多.

我用 TurboEntity 照著 'SimpleBlog Part I' 中的範例改寫後,獲得以下程式碼 (model.py):

>
> from turboentity import *
> from docutils.core import publish_parts
>
> class Post(Entity):
> title = Column(Unicode(50))
> content = Column(Unicode)
> post_date = Column(DateTime, default=datetime.now())
> is_published = Column(Boolean, default=False)
>
> @property
> def html_content(self):
> return publish_parts(self.content,writer_name="html")["html_body"]
>

在其它部份保持不變的情形下,拿來跟原文比較可以發現使用 TurboEntity 寫的定義 ORM 程式,就程式碼行數上實在不輸 SQLObject. 難能可貴地是同樣能保持很高的可讀性.

TurboEntity 網站上還有使用 TurboEntity 版本做 TurboGears Identity Model 的例子,看來轉換到從 SQLObject 轉換到 SQLAlchemy 已經不再是太令人躊躇的事了.

· 2 min read

I decide to start a new track of TurboGears Tutorial (In English), which is light weight enough so it will be easy to follow.

Why not start this tutorial on TurboGears Documentation Site ?

It just because I feel more comfortable with blogger's editor, and I'll feel less guilty if I mess these tutorial up :-D

Oops, 5 seconds passed, let's go back to the topic.

Start a new project

To start a new project (new site) with TurboGears, you'd use "tg-admin quickstart" command for it. The syntax is:

$ tg-admin quickstart [projectname] Let's create a "TurboHello" (sound's powerful, isn't it? :-D) project for example:

$ tg-admin quickstart TurboHello The console will prompt some choices. Feel free to press "enter" button (let defaults) and proceed to the next step.

Start the web server

The 'TurboHello' folder was created by your console. After the project was created, enter the 'TurboHello' folder, and you could start the TurboGears development web server with following command:

$ ./start-TurboHello.py

The web server is running, browse http://localhost:8080/ to see the project welcome page:

Pretty and easy, right?

The project structure

While entering the 'TurboHello' folder, you'll see the project skeleton laid there. Those files can be categorized for 4 purposes:

The document was merged to http://docs.turbogears.org/1.0/GettingStarted/BigPicture

TurboGears followed MVC design pattern (search if you don't know that), which seperate the web application design into three different roles, to build the default quickstart project. TurboGears also offer you the flexibility to 'not use the MVC' as well (will be shown in next minutes).

We'd always focus on part 4: "the Development part" in TurboGears.

· One min read

終於收到 TurboGears 官方文件網站的管理權限,可以修改首頁了. 這幾天重新整理了 TurboGears 的官方文件,讓整個學習流程變得更清楚了.

TurboGears 安裝早已變得很簡單, 裝好 python 後,只要抓下 tgsetup.py 後執行就會自動安裝. 不用管是否已安裝了 setuptools 模組或 easy_install 命令.

新使用者可以關注 "教程 (Tutorials)", "使用導覽 (Getting Started Guide)", "安裝 (Installation)" 三個部份.

一些特別的主題如 cookie, session, 傳送 Email, 註冊新使用者等等都被歸類在 "Solving specific problems" 中.

· 2 min read

TurboGears 在進入 1.0b 版本後吸引了許多新的使用者, 為了讓安裝 Python 跟 TurboGears 再更簡易. TurboGears 開發者 Kevin 釋出了新的簡單安裝工具 tgsetup.py, 將 SetupTools 與 TurboGears 的安裝步驟合而為一,讓安裝 TurboGears 的過程更簡單. 只需兩個步驟就能安裝好 TurboGears:

1. 安裝 Python

Linux 使用者: 一般說來,你的 Linux 發行版本 (Distribution) 裡早已預裝了 Python, 並且偷偷用在了一些內附的程式中。你可以輸入

$whereis python 來查看它的存在. 如果你是 Ubuntu 的使用者,你需要再安裝幾個必備的套件 $ sudo apt-get install gcc libc6-dev python2.4-dev

Windows 使用者: 到 www.python.org 下載 python 2.4 安裝檔,接著只要按 "下一步" 按鈕就能安裝成功. 安裝成功後需要設定環境變數。進入 "控制台"->"系統"->"進階"->"環境變數", 並選擇 "編輯" path 變數. 在 path 變數前端加入

C:\Python24\Scripts; (安裝路徑 \Scripts) 敘述.

其他平台使用者: 請參考 www.python.org 網站

2. 安裝 TurboGears

各平台使用者都可以從 www.turbogears.org/download/ 下載 tgsetup.py 檔案。在命令列輸入

python tgsetup.py

Windows 使用者可以直接在命令列輸入

tgsetup.py

tgsetup.py 會自動從網路上下載相關的檔案來安裝 TurboGears.

· One min read

TurboGears 1.0 b1 發佈囉!

在看到這個訊息後我把剛寫好的 TurboJinja 插件也順便發佈了.

和 TurboDjago 模板插件一樣,TurboJinja 可以讓你在 TurboGears 上用 Django 的 template, 只是用 TurboJinja 的話不需要先安裝 Django.

http://docs.turbogears.org/1.0/DjangoTemplating

TurboGears 的 API 在最近這的三個月中幾乎沒有改動, 1.0b1 發佈後,現在 TurboGears 的文件也很齊全了, 正是學習的好時機:-)

· 2 min read

Lots of people use Django template for Pyhton Web Framework(As Django project shares).

And if we want to make people feel comfortable to try TurboGears (and then migrate to tg hopefully), first thing we can do is making django template system available on TurboGears.

Its easy because many template plugins (and their source codes) are available for TurboGears, I use a couple hours to read the template plugins doc and make the TurboDjango template plugin.

You can try the django template in minutes. Here is the step by step guide:

Install By SetupTools

$ easy_install TurboDjango

How to Make it just Work?

Step 1. Quickstart

Use tg-admin tool to create a project

$ tg-admin quickstart tgdj

The project name is "tgdj"

Step 2. Edit Controller

Edit tgdj/tgdj/controller.py, add following method in "Root" class.

@expose(template = "django:tgdj.templates.djpage") def page(self): return dict(name="TurboGears") "djpage" is django template name

Step 3. Edit Template

Edit tgdj/tgdj/templates/djpage.html

[h1]Hello, {{name}}[/h1]

The template has "html" file suffix

Step 4. Check Result

In tgdj, start develop server by typing

$ start-tgdj

Then surf http://localhost:8080/page, you'll see

Hello, TurboGears

The Release is available here.

To Django Users: You can migrate your database with SQLAlchemy's SqlSoup

· One min read

利用 TurboDjango Template Plugin, 可以在 TurboGears, Buffet, 或 CherryPy 裡如此這般調用 Django 模板:

在 controller.py 裡

{{{
@expose(template = "django:dem.templates.djpage")
def page(self):
return dict(name="TurboGears")

<div id="qhide_141663" style="display: block;" class="qt">}}}

用 "template" 參數指定樣板時加一個 "django:" 前綴, 或是在設定檔 app.cfg 中將預設的 tg.defaultview = "kid" 改成 tg.defaultview = "django" 就可以在全站使用 django 模板.

djpage 是模板名稱,return dict 後面給的參數群是要傳給模板的參數.

在 djpage.html 裡


[h1]Hello, {{name}}[/h1]
<div id="qhide_141664" style="display: block;" class="qt">}}}

djpage 是模板名稱,html 是檔名

網頁 http://localhost:8080/page 的輸出結果是

"

Hello, {{name}}

"

· 2 min read

Continue to my previous article, here is a configuration using eclipse external tools to start web server without open start-proj.py

Here is a list of the current functionality:

External Tools:

  • Start Server

  • Start ToolboxAccessibility:

  • Auto Completion Configure Eclipse to Launch developer server

  • Select Run -> External Tools -> External Tools

  • Select "Program" from the configuration tree Select New to create a new program Enter “Start Server” as the name Enter C:\Python24\pythonw.exe for the Location For the Working Directory, use ${project_loc}

  • Enter start-${project_name}.py for the Arguments

  • Select the refresh tab and check Refresh Resources Upon Completion

  • Select the Common tab

        *   Find the section for **Display in Favorites Menu**
    * Check **External Tools **option**

    * Select Apply** Configure Eclipse to Launch ToolBox

  • Select Run -> External Tools -> External Tools

  • Select "Program" from the configuration tree Select New to create a new program Enter “Start ToolBox” as the name Enter C:\Python24\Scripts\tg-admin.exe for the Location For the Working Directory, use ${project_loc}

  • Enter toolbox** for the Arguments**

  • Select the Common tab

        *   Find the section for **Display in Favorites Menu**
    * Check **External Tools **option**

    * Select Apply**

Auto-completion

  • Select your project in Navigator panel
  • Select Properties on Right click menu.
  • Select pyDev - PYTHONPATH Select Add source folder to add project path in Project Source Folder. it will bring project code-completion and code-analysis.
  • Select Add source folder to add turbogears path in External Source Folder.

it will bring turbogears code-completion PS: I get idea from the rails article, but for mine, you'd have eclipse & pydev installed, I recommand you try EasyEclipse for Python.

· 2 min read

NOTICE: This Article is updated for 0.9w3

I recently update my TurboGears PlotKit widget. This version(0.9w3, 0.9 is origin lib's version, w means 'widget')

To get these widgets, easy_install them :

$easy_install plotkit

Then, you can Check the demo in TurboGears toolbox :D

How to try it? Well, it's extremely simple.

For a fresh quickstart site,

In controllers.py:

from plotkit import EasyPlot

class Root(controllers.RootController):
@expose(template="wgtest.templates.welcome")
def index(self):
setA = [[0,0], [1,2], [2,3], [3,7], [4,8], [5,6]]
setB = [[0,0], [1,1], [2,4], [3,8], [4,7], [5,20]]
setC = [[0,1], [1,3], [2,5], [3,5], [4,3], [5,2]]
return dict(ep= EasyPlot(id="diag",
style="line",
width="300",
height="300",
data=[setA, setB, setC]))

In welcome.kid:

${ep.display()}

add this script into html "body".

Explain:

from plotkit import EasyPlot

First of all, import the proper widget. (origin PlotKit widget is still availbe)

return dict(ep= EasyPlot(...))

return the "ep" diagram instance to template

${ep.display()}

display the diagram in template

Parameters:

id: (diag) The Diagram's Identifer (Element ID)

style: (line) The diagram could be plot as a "line", "pie", or "bar"diagram.

width, height : (400, 400)

The diagram's size

data : Datasets is structured with [[x,y],[x1,y1],....]

option : options of both Layout and Renderer (dictionary style), need be a string

The origin example is here.


History 0.9w3 07/04/2006: more flexible EasyPlot dataset 0.9w2 : fix bugs and add a EasyPlot() widget to plot a diagram within the code.

The svn repository is in Sourceforge, you can share your TurboGears widget there, too.

known limit: current widget's option param suppor is not very OO, you need pass the dictionary in string format (can't recognize "v", "label")

· One min read

習慣用微軟 VisualStudio 或用 Java 的人用了 python 語言, 通常會挑剔 python 語言沒什麼好用的 IDE 來搭配.

現在 EasyEclipse 有提供包好的 eclipse + pydev (eclipse 平台上的 python 語言支援 -) + Subclipse (eclipse 平台上的圖形化 SVN 版本控制工具) http://www.easyeclipse.org/site/distributions/python.html

簡化了 eclipse 平台安裝設定上的繁瑣,拿來做 python 程式開發其實還蠻不賴的,

· 3 min read

補充一點心得:

如果你的網頁應用服務主要關注在 AJAX 應用,大部分動作都用 javascript 在客戶端完成,

只有 data 部分需要後端提供。那麼 TurboGears 是非常適用的選擇.

1. 可以先用一般 serverside 開發方式寫函式和建立網頁應用服務原型 (prototype),

來測試你的網頁應用服務該有的功能.

@expose (format = ".template.pages") #資料以樣版格式顯示 def method (self): .... return dict {data=data} 因為 TurboGears 中從傳入 serverside 的表單資料處理一致,

所以在 serverside 寫的 code 完全可以繼續使用,

不必為了支持 AJAX 重寫,很好的達到不重複自己 (DRY) 的效果.

2.import javascript library , 將資料改以 JSON 格式傳到網頁

from turbogears import mochikit ... @expose (format = ".template.pages") #資料以樣版格式顯示 @expose (format = "JSON") #資料以 JSON 格式顯示 def method (self): .... return dict {data=data, scripty = mochikit} #在網頁上

TurboGears 預先包好 mochikit, scriptaculous, plotkit 等 javascript 庫,

使用時可以用程式呼叫,預設可用 JSON 格式傳輸,

預設 mochikit 庫提供相應資料處理支援.

3. 在 client 端用 javascript 處理 DOM 物件.

因為在開發的第一步時已經能將所需的資料,傳輸內容等都處理好了,

能確信資料傳輸的正確性。所以開發 javascript 時,可以專注在網頁內資料處理的部分.

在這時遇到 bug 的話也可以很放心地將可能的問題點縮小到單純網頁內資料處理的範圍,

因而 AJAX 開發時最麻煩的交叉 debug 也變得更容易.

因此如果你的網頁應用服務主要關注在 AJAX 應用,那麼 TurboGears 是非常適合的選擇.

· 2 min read
<table border="1" cellpadding="0" cellspacing="0" bordercolor="#E1E1E1">
<tbody>
<tr>
<td colspan="4" nowrap="nowrap"><span class="style1">TurboGears Widgets </span></td>
</tr>
<tr>
<td colspan="2" nowrap="nowrap" class="style1">Form Elements</td>
<td colspan="2" nowrap="nowrap" class="style1">HTML Imports</td>
</tr>
<tr>
<td> 1 </td>
<td> Button </td>
<td>1</td>
<td>CSS Link </td>
</tr>
<tr>
<td> 2 </td>
<td> Calendar </td>
<td>2</td>
<td>CSS Source </td>
</tr>
<tr>
<td> 3 </td>
<td> Calendar with time </td>
<td>3</td>
<td>JS Link</td>
</tr>
<tr>
<td> 4 </td>
<td>CheckBox</td>
<td>4</td>
<td>JS Source </td>
</tr>
<tr>
<td> 5 </td>
<td> File Field </td>
<td>5</td>
<td>Localizable JS Link</td>
</tr>
<tr>
<td> 6 </td>
<td> Hidden Field </td>
<td colspan="2" nowrap="nowrap" class="style1">Form Components</td>
</tr>
<tr>
<td> 7 </td>
<td> Image Button </td>
<td>1</td>
<td>CheckBox List </td>
</tr>
<tr>
<td> 8 </td>
<td> Label </td>
<td>2</td>
<td>FieldSet</td>
</tr>
<tr>
<td> 9 </td>
<td> Multiple Select Field </td>
<td>3</td>
<td>RadioButton List </td>
</tr>
<tr>
<td> 10 </td>
<td> Password Field </td>
<td>4</td>
<td>Repeating FieldSet</td>
</tr>
<tr>
<td> 11 </td>
<td> Reset Button </td>
<td colspan="2" class="style1">Table / Form</td>
</tr>
<tr>
<td> 12 </td>
<td> Single Select Field </td>
<td>1</td>
<td>DataGrid</td>
</tr>
<tr>
<td> 13 </td>
<td> Submit Button </td>
<td>2</td>
<td>List Form </td>
</tr>
<tr>
<td> 14 </td>
<td> Text Area </td>
<td>3</td>
<td>Table Form</td>
</tr>
<tr>
<td> 15 </td>
<td> Text Field </td>
<td colspan="2" class="style1">AJAX</td>
</tr>
<tr>
<td colspan="2" class="style1">Form UI</td>
<td>1</td>
<td>AJAX Form</td>
</tr>
<tr>
<td> 1</td>
<td> Jump Menu</td>
<td>2</td>
<td>Ajax Grid</td>
</tr>
<tr>
<td>2</td>
<td>Syntax Highlighter</td>
<td>3</td>
<td>Ajax remote function</td>
</tr>
<tr>
<td>3</td>
<td>Tabber</td>
<td>4</td>
<td>Auto Complete</td>
</tr>
<tr>
<td colspan="4">Find more widgets in [TurboGears Cogbin](http://www.turbogears.org/cogbin/)</td>
</tr>
</tbody>
</table>

· 5 min read

很難用簡短言語表述這種互動開發的經驗。真的要稍微描述的話,那是一種不管你想要怎麼進行下一個開發步驟時,TurboGears 都幫你準備好了各種基本工具的感覺.

在學習 TurboGears 之後,我用 TurboGears 框架試做了一個網路模擬架構產生器,發現使用 TurboGears 寫操作到表單的網頁應用程式實在超方便.

很難用簡短言語表述這種互動開發的經驗。真的要稍微描述的話,那是一種不管你想要怎麼進行下一個開發步驟時,TurboGears 都幫你準備好了各種基本工具的感覺.

(以下不包含程式碼).

設計考量

產生器程式裡使用到大量小塊的表單,用上 AJAX 技術可以大幅縮短來來回回修改的時間,增進使用者經驗.

採用 ' 內容為中心 ' 的開發方式,controller 中盡量只返回與內容有關的資料。所有內容展示都在樣版跟 javascript 中產生.

開發之初就可以預見程式中將會出現相對大量的 Javascript 程式碼,我盡量採用 AJAX in Action 中提到將程式碼跟網頁分離的方式實做,將 Javascript 用 import 的方式包含進網頁.

原型階段 在 protocontroller.py 中新增一個方法函式,在其中手動建立一個列表 (預見將來將改成從資料庫中讀出), 返回列表到網頁,作為剛開始要傳入網頁的資料.

建立一個剛剛的方法函式所用到的樣版 (template), 在樣版中建立一個表單,來讓使用者選擇傳入的資料。並提供一個給使用者互動用的按鈕.

使用者按下互動用的按鈕後,利用 mochikit (TurboGears 內建的 javascript 函式庫) 提供的 DOM 處理參數,由使用者選擇的選項來動態創建進一步的表單與第二個互動用的按鈕.

使用者填好相關資訊,按下第二個互動用的按鈕。傳回資料到另一個方法函式, 取得下一個頁面.

exception: 使用者修改原來的選擇,按下互動用的按鈕後,利用 mochikit 提供的 DOM 處理函式更新原本動態產生的內容.

AJAX 網頁 使用 mochikit 提供的非同步 (Async) 處理函式,從伺服器取回資訊.

感想 AJAX 非同步處理部分需要 server /client 一起配合才行,因此對一個網頁框架而言,不是單純加上一個 AJAX 函式庫,這個框架就可以說是支援 AJAX. TurboGears 在這點上合格了!

開發時很妙的地方是 Turbogears 處理表單參數 (POST) 跟網頁參數 (GET) 的方式是一致的,所以原本 controller 中寫好的程式根本不怎麼需要修改.

Turbogears 返回的資料除了給樣版用之外,要回傳 JSON 格式只要在 uri 後加上 '?tg_format=json' 即可,也不必做額外處理.

javascript 很多語法跟 c 和 python 相似,mochikit 函式庫更是借用了很多 python 的使用方式,因此實際寫起來 client/server side 程式,轉換間並不感到太過突兀.

到目前使用上還沒發現 TurboGears 沒有 url mapping 有什麼壞處,要用 url mapping 的話再裝 routes 不遲.

· One min read

TurboGears 裡集成了 nose 作為測試工具. nose 支持 unitest /doctest, 可以對資料庫處理 (Model), 生成的頁面 (View), cherrypy 輸出結果 (Controller) 作測試.

搭配 selenium4gears 直接測試網頁介面的能力,讓 TurboGears 擁有了完整的測試方法.

TurboGears 可以直接集成成熟的現成 python 套件,這是使用 TurboGears 的好處.

· One min read

網路上許多 Ajax 套件,例如 Dojo, Rico, 提供了比 TurboGears 預設的 mochikit 更多視覺上或是功能上的便利.

要讓 TurboGears 框架支援更多這些 Ajax 函式庫超容易。只要將解壓縮後的函式庫放到 Turbogears/static/js 資料夾下。然後在要使用時在 html 中以 script type="text/javascript" src = "/tg_js/script.js" 路徑加入即可

例如要用 Dojo 的 WYSIWYG 網頁編輯器功能,

先在 html body 中加入

div class="dojo-Editor" some content /div

然後再在 title 中加入 dojo 連結

script type="text/javascript" src="/tg_js/dojo/dojo.js

並呼叫載入要使用的 dojo-Editor 功能:

script type="text/javascript" dojo.require("dojo.widget.Editor"); /script

· 2 min read

I wonder to know the reason why people here choose TurboGears? I'd like to share mine.

1. Python Battery Included With TurboGears I can apply >5000 python modules on my web application natually. "Battery Included" facilitate me focusing on my major job to getting things done.

ex: Wiki20: "docutils" module is helpful for wiki syntax TurboBlog: PIL "ImageFonts" module is helpful for blog anti-spam stuff.

2. Flexibility from Prototpying to Merchandising In small app or prototyping stage, I just want to see something work first. TurboGears give me the flexibility to do most of my web programming by only edit controller.py. I can adopt Template, ORM, AJAX.... latter if I really need them. I don't want to take care of "framework" stuff such as admin controll, templating, url mapping, or database reference at first (which Django did).

ex: I've written some short tutorials to teach myself turbogears' features without template. (in chinese). http://gasolinfred.pbwiki.com/%5BTurboGearsInMinutes

3. Easy to start, Plenty for Learn Model Designer , CatWalk, help me leave from the first headache of database backend web programming. http://trac.turbogears.org/turbogears/wiki/QuickPrototyping

And after learning how "controllers" and "expose" works (I think its the minimum set of turbogears core), I can construct a workable web app and enhance it during my learning curve.

· 2 min read

2006/30/7 Since may people may come from 42, I suggest you to download the full instruction at TurboGears Trac, you'll see full instruction to make it.

This article is motivate by the framework comparison screencast performed by Sean Kelly. I found this screencast from TurboGears group. the screencast compare J2EE , Rails ,Zope ,TurboGears ,and Django. TurboGears did fairly well. but Sean Kelly wasn't using the latest version(~0.9) during his tests.Thus I try to re-imlement the demo by using bunch of exciting new features (Model Designer, CatWalk, DataController...) introduced in the latest TurboGears version.

Origin version in ScreenCast

The screencast implement page like this, there is a add only interface, no editing.

And it cost 2 python source files 49 lines of code, 2 page of templates, 53 lines of code, not a hundred lines of code.

Re-Implement version with latest svn(#885)

Its time catch up with Sean Kelly's demo in latest TurboGears version. The re-implement with latest Turbogears svn like this. TurboGears > 0.9 provide autogenerate Editor(Catwalk) in Admin Panel(Toolbox)

We can get another running mode editor(much usefull for real app) with DataController by several lines of code.

the re-implement version cost 2 python source files (now Turbogears config file is in python) 6 lines of code, 0 page of templates, not a ten lines of code. The re-implement version also include a full-functional database-relation editor.

Turbogears automatically generate pages for you both in admin and practice perspective. In Turbogears you can customize DataController and other widgets' looking and feel to fit your layout style.

· One min read

根據 Sean Kelly 的 framework comparison screencast 的影片演示, 他比較了 J2EE, Rails, Zope, TurboGears, and Django 幾個框架. TurboGears 在其中得到了不錯的評價,然而他所使用的 TurboGears 版本還沒引入網頁自動生成資料庫編輯介面 (CRUD) 等 0.9 版新加入,可以大大減少初期開發時間的功能. 因此我利用他的 Time Tracker 例子和資料模型寫了篇用上 TurboGears 0.9 新功能的教學文章 (英文), 貼在 TurboGears Trac 裡,可以前去下載.

QuickPrototyping: Making a Time Tracker in TurboGears http://trac.turbogears.org/turbogears/wiki/QuickPrototyping

· 2 min read

在 TurboGears 中可以用 "@validate ()" 裝飾方法來處理輸入表單參數的轉值與驗證。使用的好處是除了會自動確認型態的正確性之外,還會將字串轉換成目標型態.

例如拿前一個網頁加法器作例子,原來例子中加總結果必須先將字串轉換成目標型態,因此計算式如下 SUM = (int (A)+int (B)) 我們可以使用 "@validate ()" 來預先先確認輸入資料,並將資料轉換成預期的資料型態. 範例如下:

from turbogears.validators import *
@expose(inputform ="add")
@validate(validators=dict(A=validators.Int(),B=validators.Int()))
def calcit(self,A=0,B=0, SUM=0):
template = """
&lt;form name="add" method="post" action="/calcit"&gt;
&lt;input name="A" type="text" value="%d"/&gt; + &lt;input name="B" type="text" value="%d"/&gt;
&lt;input type="submit" value="=" /> &lt;input name="SUM" type="text" value="%d"/&gt;
&lt;/form&gt;
"""
SUM = A + B
return template%(A,B,SUM)

@validate(validators=dict(A=Int(),B=Int())) @validate(validators={"A":Int()}, "B":Int())

現在例子中由於已經預先將字串轉換成目標型態,因此可以直接加總 SUM = A + B

這讓程式碼可讀性更進一步增加了.

總結

validate ()" 方法除了可以幫忙我們判斷回傳值型態外,同時也會將回傳值從傳回的字串型態轉換成指定型態供我們處理

除了這些簡單值的字串轉換外,在 TurboGears 中做 email 地址確認時,甚至還能選擇確認 email 主機是否真正存在喔;)

· 4 min read

TurboGears 中可以使用從模板生成網頁 (Templating) 的方式,可以更好地將控制邏輯與操作介面分開,來達到程式碼與網頁分離的需求。讓程式與網頁更易於維護.

使用 TurboGears 中的預設模板,可以用所見即所得 (WYSIWYG) 網頁編輯器來編輯網頁外觀. 並在回傳時用字典 (dict) 形式傳回變數,降低程式碼與網頁之間的直接關聯性.

讓我們用模板功能取代將網頁用字串存在 controllers 中的方式:

1. 建立控制邏輯 (Add Logic)

0 from turbogears import controllers
1 from turbogears import expose
2 class Root(controllers.RootController):
3 @expose(template=".templates.filename")
4 def webpage(self):
5 return dict()

透過在 @expose () 方法中加入 template=".templates.filename" 宣告來指定要使用的模板名稱.

return 型態必須是字典型態。裡面傳回的內容則可以動態被填入模板中

2. 建立模板

我們建立 "filename.kid" 的模板. 模板名稱要跟 controllers 中 @expose (template=".templates.filename") 的 filename 相符

3. 模板宣告

模板要使用 XHTML 格式來撰寫.

從 HTML 轉換到 XHTML 的主要差別在於 XHTML 對網頁語法有較嚴格規定

  • 在 html 標籤內加上 <html xmlns:py="http://purl.org/kid/ns#"/> 宣告,表示這是一個 TurboGears 的模板,在執行的時候 TurboGears 才能正確地將自行設定的變數替換成適當的值

  • 所有的標籤要對稱,單一的標籤要以 / 作結尾。例如 <br> 變成 <br/>, <input> 變成 <input/>

結論

前幾分鐘裡的範例都是在 Controller 中將網頁用一個 "template" 字串來表示,直接將網頁內容存在 python 程式裡。然後用傳回值 (return) 的方式將 "template" 字串轉換成網頁顯示出來. 用這種方法寫網頁程式,好處是我們只需要將網頁程式當作一般程式來處理就行了,不需要了解太多複雜的動態網頁技巧,利用這樣的方法,我們需要仔細處理插入變數的類別,並在回傳時注意變數的安排順序,好正確地將字串中的變數替換成我們期望的樣子. 我們很快地就發現這樣將網頁內容嵌在程式碼裡的寫作方式,隨著漸漸增加的功能方法,與要求更複雜的內容呈現時,程式碼就變得越來越難以維護.

我們應該要擁有方便的工具,可以用任意順序傳回我們想要顯示的內容,並在實際的網頁上重複運用這些資訊。最好還可以用一般的所見即所得 (WYSIWYG) 網頁編輯器來編輯網頁外觀,

· One min read

Selenium is a test tool for web applications. Selenium tests run directly in a browser, just as real users do

Selenium 是網頁程式測試工具,可以跨平台跨瀏覽器模擬各種使用者可能的操作. 主要的兩個功能是:

  • 瀏覽器相容性測試 (Browser compatability testing)
  • 系統功能測試 (System functional testing)

Selenium 在內頁框 (iframe) 中,使用 JavaScript 自動化引擎來模擬使用者操作網頁的動作, 可以安裝 IDE (firefox 插件) 來使用 selenium, 或是在 TurboGears 中也可以使用 Selenium , 看看 Selenium4TurboGears 的介紹影片吧

· 3 min read

最近生活中都是在寫 Code, 鑽研 boa web server 處理的流程, 打開 Dreamweaver 也越來越少使用 Design View, 感覺自己越來越有軟體工程師的樣子.

這陣子寫的 "一分鐘 TurboGears" 系列,前數篇原本是在春節期間用英文寫成的,後來才決定先用最熟悉的中文來寫.

現在的網頁框架幾乎全部都套用 MVC 模式,將資料模型 (Model), 展示頁面 (View,Template) 分離,以控制邏輯 (Control logic) 來溝通兩者以呈現出設計者的思想。這樣的方式讓架構跟維護都變得更清楚更容易.

然而,在寫動態網頁原型的階段時,一定要一次就套用上 MVC 嗎? 我們在網頁程式早期做的頁面,有幾頁能不做大修改就能留用到最後呢? 我們什麼時候能一次就將資料庫欄位,互相間的關聯性一次設計好呢? 起碼對我來講,這兩個假設都是不可能的.

設計 MVC 程式一般理想的流程是:

設計資料庫欄位 -> 產生資料庫 -> 寫樣板 -> 寫控制邏輯以填入資料 -> 展示

但是在實做上

設計資料庫欄位 -> 產生資料庫 -> 寫樣板 -> 寫控制邏輯 -> 發現問題 -> 修改資料庫欄位 -> 重新產生資料庫

我在 Modeling 時發現,在早期設計階段修改欄位的需求很頻繁,(常有些是 paper design 時沒想到的) 碰到這樣的問題時,除了 update 資料庫,若與資料庫不相容時還得將資料庫刪除,再重新產生.

設計 MVC 程式在第一關就遇到 Modeling 問題,接下來當然很難繼續學下去.

有了方便的網頁程式框架,與動態網頁幾乎可忽略的編譯與重新載入時間的特性,我們當然可以用靈活 (agile) 編程的方式來寫我們的網頁程式.

我想最快速動態資料庫網頁 prototyping 的方法,也許就是像目前的範例這樣子先將 model, view 放一邊,純寫程式碼先掌握正確的控制邏輯吧.

· 3 min read

TurboGears 網頁階層的有兩類,第一類是用 "參數" 來對應網頁階層,第二類是用物件樹結構 (即類別實體) 來對應網頁階層.

  1. 參數對應結構

例如 http://localhost:8080/calcit/4/8 "4", "8" 會被分別當成 calcit 方法的第一,第二個參數傳入,作用等同於 http://localhost:8080/calcit?A=4&B=5

如果 calcit 方法不存在,即連結資料夾名稱沒有對應到方法的話,就會被當成參數傳到最近物件的 default () 中當作參數 (在本例為 TurboGears 預設建立的 Root 物件).

  1. 物件樹結構

另外三種情形都是用物件樹結構的 "類別實體"(instance) 來對應網頁階層。可以實現超過一層的網頁. TurboGears 中會自動建立 Root 類別的實體,我們可以建立其他的類別,然後在 Root 類別中建立其他相關類別的實體.(恩... 要把這個概念寫成文字真不容易) 範例如下:

CASE1: controllers.py 內

在 controllers.py 內編寫多個類別 (class)

0  from turbogears import controllers,expose
1
2 class Subfolder(controllers.RootController):
3 @expose()
4 def index(self):
5 return "I am B"
6 @expose()
7 def C(self):
8 return "I am C"
9
10 class Root(controllers.RootController):
11 @expose()
12 def index(self):
13 return "I am Root"
14 @expose()
15 def A(self):
16 return "I am A"
17 B = Subfolder()

我們在 2~8 行編寫了一個類別,在 Root 類別內第 17 行建立該類別的實體,最後我們會得到像下面的網頁階層樹

   Root
/ A B
C

網頁 localhost/ 跟網頁 localhost/B 的文字是由各自類別的 index () 方法來處理.

CASE2: controllers.py 外 (同目錄):

將 Subfolder 類別存成 subfolder.py , 保存在與 controllers.py 同目錄下. subfolder.py 內容如下:

0  from turbogears import controllers,expose
1
2 class Subfolder(controllers.RootController):
3 @expose()
4 def index(self):
5 return "I am B"
6 @expose()
7 def C(self):
8 return "I am C"

TurboGears 可以從 controllers.py 內調用同目錄下的其他類別

from subfolder import Subfolder
from turbogears import controllers,expose
class Root(controllers.RootController):
@expose()
def index(self):
return "Root"
@expose()
def A(self):
return "I am A"

B = Subfolder()

"from subfolder import Subfolder" 前面小寫的 "subfolder" 是檔名 (subfolder.py), 後面的 Subfolder 是類別名

CASE3: 子目錄下 (子系統)

TurboGears 也可以從 controllers.py 內調用子目錄下的其他類別 (待補)

· One min read

說到網路模擬,大家在試過各種模擬網路工具之後,都會覺得模擬網路比起實際架設其實並不是容易的事情,

網路模擬 Scenario 主要都是由 4 個部分構成:點,線,面,時間

因為網路通訊本身就由 Physical/MAC, IP, Network, Application 等層構成, 就 Physical/MAC 來簡分就有無線,有線之別,IP, Network 層裡又有多樣的協定, 總合起來先天網路通訊本模擬上就有極高的複雜度.

先由網路模擬 Scenario 來說. 在 ns2 上是在 tcl 檔中定義,在 omnet++ 上是在 ned 檔與 omnetpp.ini 檔中定義

· 2 min read

Digest from here :

In a mixed simulation involving wired and wireless nodes its necessary : 1. to turn on hierarchical routing 2. to create separate domains for wired and wireless nodes. There may be multiple wired and wireless domains to simulate multiple networks. 3. to have one base-station node in every wireless domain, thru which the wireless nodes may communicate with nodes outside their domain.

we need to use hierarchical routing in order to route packets between wireless and wired domains

  • the routing information for wired nodes are based on connectivity of the topology
  • use base-stations which act as gateways between wired and wireless domains

#Number of domains in this topology is 2 (one for the wired nodes and one for the wireless) AddrParams set domainnum 2

#Number of clusters in each of these domains #which indicates the first domain (wired) to have 1 clusters and #the second (wireless) to have 5 cluster. AddrParams set clusternum {1 5}

#the number of nodes in each of these clusters AddrParams set nodesnum {1 1 3 1 1 1}

心得: 在 mobiwan 中,bs 可以當 rt 用, 因此 bs 也有路由功能

每個 bs 都可以當 HA, 因此 mobiwan 裡不必指定 HA, mobile attach 上的那個點就自動做 HA.

所以 set mobile_ [create-mobile 1.4.1 1.4.0 1000 200 0 0 0.01] 表示 mobile 會把 1.4.0 這節點當作 HA

create-mobile 來自 proc-mipv6-config.tcl 啟動 def_mobile_config 來處理

base-station: create-base-station 啟動 def_bs_config 來處理 讓 bs 可以處理 wired&wireless 的重點是 #have wired routing mechanism turned on -wiredRouting ON 開啟 MIPv6 功能 -mipv6 ON

router: def_transit_config -mipv6 ON -mipagent CN

NS2 上的 RO 即是把 CN 當作 HA, 接收 BU, 然後作 tunnel 欲啟動 RO , 則在檔案最前頭宣告: Agent/MIPv6/MN set rtopti 1 ; # 0 if routing optimization OFF