Scribd documents on Your page ( API ) - Django / python

In Django to display your Scribd documents in your page , first you need to install scribd python package . To install it refer this link

after installing it in your views write this def (add url accordingly).

def scribd(request):
    extra_context = {}
    extra_context['formName'] = 'scribd'   
    data = []
    import scribd       
    scribd.api_key = '#Your api key'
    scribd.api_secret = '#Your secret key'
    api_user = scribd.api_user   
    all_documents = api_user.all()
    for ad in all_documents:       
        temp = []
        document = ad
        document.load()   
        attrsDict = document.get_attributes()               
        temp.append(document.get_scribd_url())
        temp.append(attrsDict['thumbnail_url'])
        temp.append(document.get_download_url())     
        data.append(temp)
       
    extra_context['data'] = data
    return render_to_response('scribd.html', extra_context,
 context_instance=RequestContext(request))

In your scribd.html file............

My Documents on scribd:

< table border='1' >  
   {% for d in data %}               
        < tr>   
            < td width='82px'><a href='{{d.0}}'
 style='color:blue;font-weight: normal;'>
Doc {{forloop.counter}}:</a></td>
            <td><img width='' src='{{d.1}}' 
alt='doc{{forloop.counter}}'/>
</td>
            <td><a href='{{d.2}}' style='color:blue;
font-weight: normal;'>
Download doc {{forloop.counter}}
</a></td>
        </tr>       
   {% endfor %}
   </table> 

Live Demo
http://coderpriyu.alwaysdata.net/scribd/


Thats it....................

Database Connection Pool Solution for Django + Mysql

The solution:

An alternative DATABASE_ENGINE for django that leverages core django mysql code with minimal overlap and sqlalchemy for connection pooling. Also, a pretty ‘DRY’ stub to mix in your own pooling if desired, or adapt to use postgres instead of mysql.

1. Install sqlalchemy library: http://www.sqlalchemy.org/download.html
I used “Latest 0.5? myself.
2. Grab: mysql_pool.tgz

3. Make mysql_pool reachable by your project
3a. Unpack in your python’s “site-packages” directory
3b. Or: unpack somewhere in your project directory, and edit the “base.py” file in mysql_pool to fix the import lines containing uw.udjango.db.engine to be the new location mysql_pool.

4. Edit your settings.py to change DATABASE_ENGINE
4a. If 3a, set to uw.udjango.db.engine.mysql_pool
4b. If 3b, set to yourproject.whatever.mysql_pool

5. Edit your settings.py to add these (required) tuning settings:

  DBPOOL_WAIT_TIMEOUT = 28800  # your mysql db’s server side inactive connection kill time

  # discernable by ’show GLOBAL variables;’ in mysql, look for ‘wait_timeout’, changeable if desired

  DBPOOL_SIZE = 20 # the maintained number of dbconnections, over this returned conns are destroyed

  DBPOOL_MAX = 100 # the max allow connections, period

  DBPOOL_INTERNAL_CONN_TIMEOUT = 10 # how long to wait for mysql to give you a connection

That should do it!

The explanation:

I’ve been reading up on the various was being proposed to make some kind of persistent connection re-use part of core django. The are a couple of options I like, especially having a core database engine choice of sqlalchemy. A lot of implications there though, and I didn’t want to tackle them all.

At first I figured I’d write my own, and stubbed out the code to do that. Since I’m using mysql, I copied it’s engine tree in django.db.backends into my project and began working on it. Quickly I realized I didn’t want to rewrite, or maintain duplicates of, the whole tree. I only cared about two calls really: self.connection = Database.connect() and self.connection.close(). Modifying those would be a way to plug in pooling of my own. Also, in the process I looked to SQLAlchemy’s pool code as an example of Python implementation, and it seemed pretty good. Eventually I’d like to add some more subtlety to the pool grow/shrink strategy.

I started riffing on the solution described on Ed Menendez’s site, and merging in some of my ideas to make it more DRY.

Basically, all the classes in mysql_pool use class naming tricks to extend-without-modification and assume the identity and characteristics of the core mysql engine. That means there is no code in mysql_pool to maintain other than the “base.py” file, and even that one is able to use the same short cut for most of its classes, the exception being DatabaseWrapper, which is updated to use SQLAlchemy’s pool.

Also, I added settings.py level control of SQLAlchemy’s QueuePool, which is the pool type mysql_pool is forced to use.

Other links of note on related topics:

Proposal: user-friendly API for multi-database support

Django: How to add Google +1 button to your website.

What is Google +1 button?

It's new Google social button. It's much similar to Facebook "Like" button. While available during one month it earned popularity that could compete with Facebook's social button. Corporation of Good knows what to do, so you probably want to have one on your website inline with Facebook's Like...

Add Google +1 button to your site:

- Open http://www.google.com/webmasters/+1/button/index.html and generate own button for your website.

Google proposes HTML code like this:

<html>
  <head>
    <title>+1 demo: Basic page</title>
    <link rel="canonical" href="http://www.example.com" />
    <script type="text/javascript" src="https://apis.google.com/js/plusone.js">
    </script>
  </head>
  <body>
    <g:plusone></g:plusone>
  </body>
</html>

It's quite simple, as you can see. And that's much pretty it. Oh no wait...

- Add some variable to your template like "google_target_url" like this:

#pass variable to template with google +1 target url
return render_to_response("template.html", 
                         {"google_target_url":google_target_url,})

Finally you can add property "href" (similar to common a href=" " pattern) to target +1 action to custom url. In general you can now generate page with multiple +1 buttons on it. For e.g.: one button under one blogpost or image...

<g:plusone href="http://www.example.com/custom_page1/" size="standard" count="false"></g:plusone>

Django - compressing CSS/JS files with django-compressor

There are 2 main usual tasks with web project's deployment and about .css and .js files.

First one - size minimization. But there are lot's of utilities helping you to compress CSS files. Delete unused spaces, comments and so on... Second one - Version control. For e. g. When you've updated the script on your deployment server, but user's browser uses old one until user manually hits 'Refresh'.

That's where Static files compressor comes in to mind.



Upon selecting among available one's found top "google" results:
- django-compress
- django-compressor
- webassets

Project uses 'django.contrib.staticfiles', so django-compress was not compatible... It does not support Django's static files gently. Webassets s a good lib. but project has a huge amount of different static. Maybe it's ok for e small project, but when you need to specify/change a 100's javascript in python module for certain templates... Nothing good comes in mind. And imho TEMPLATES... That's where thing's like those should live.

So Django-compressor was chosen using those criteria. And, to mention, project is actively developed, supported and documented. Anyway adding it to your django project is quite simple, as most good apps.

What it does, it turns this:

<script type="text/javascript" src="{{ MEDIA_URL }}public/js
/jquery-1.4.1.min.js"></script>
<script type="text/javascript" src="{{ MEDIA_URL }}banners/js/
jquery.cycle.all.js"></script>
<script type="text/javascript" src="{{ MEDIA_URL }}js/gb/greybox.js"
></script>
<script type="text/javascript">jQuery.browser.msie6 = 
jQuery.browser.msie &&  parseInt(jQuery.browser.version) 
== 6 &&  

!window["XMLHttpRequest"];
if (!jQuery.browser.msie6) {
 $(document).ready(function(){
   $("div#body_wrapper").wrap('<div id="body_wrapper_shadow_right"
><div id="body_wrapper_shadow_left">'+
'</div></div>');
 });
</script>

Into this:

<script type="text/javascript" src="/static/CACHE/js/8dd1a2872443.js" 
charset="utf-8"></script>

The install is quite simple and you need to follow this manual.
Then configure it. Basically you hava all set for it to function. Except for me having a bit wired way of storing static files. I had to remap default COMPRESS_ROOT and COMPRESS_URL variables. It's quite easily done in settings.py. And it has lot's of other settings, that I did not require.

Anyhow this is it. Now you can wrap all of your code with handy templatetags that will do all the work for you. it may look somehow like this:

{% load compress %}

{% compress css %}
<link rel="stylesheet" href="/static/css/one.css" type="text/css" 
charset="utf-8">
<style type="text/css">p { border:5px solid green;}</style>
<link rel="stylesheet" href="/static/css/two.css" type="text/css" 
charset="utf-8">
{% endcompress %}

or for .js files:

{% load compress %}

{% compress js %}
<script src="/static/js/one.js" type="text/javascript" charset="utf-8"
></script>
<script type="text/javascript" charset="utf-8">obj.value = "value"; 
</script>
{% endcompress %}

It will generate a custom .js/.css files with all of your compressed static at one file in your media/static dir that can be cashed. They will have links, like "/media/CACHE/css/105dsb963311.css"and put your newly generated script/style there. 

This is it. Use this in your projects. It economies your server's time/traffic and helps you to update scripts at all user's clients in their browsers when you deploy a new version.

Django Tips & Features before getting Started

1. Dont hardcode MEDIA_ROOT and TEMPLATE_DIRS use 

        os.path.realpath(os.path.dirname)__file__)) 

hardcoding will cause problem while moving from dev->test->live

2. Dont hardcode static files in templates. use MEDIA_URL

EG: 

In future if you change your cdn, you will have to change it only in the settings

To get the context variable use django context processor. Its very easy to write and this makes MEDIA_URL and any other variable you like available across all the templates 

        http://docs.djangoproject.com/en/dev/ref/templates/api/#writing-your-own-context-processors

3. Use the url function to define the urls. Dont hardcode urls. Use reverse() in views.py and {% url %} tag in templates

4. Thirdparty app django-command-extension

This app is very useful. It gives some other useful commands  like

        -> shell_plus -  extension of shell. It will autoload all enabled django  models.

-> sqldiff - gives you the sql diff between the code and the DB

        -> show_urls - displays the url routes that are defined in the project

        -> graph_models - creates a GraphViz dot file 

        -> clean_pyc - removes all the pyc files    (Eclipse helois pydev makes it very easy...)

        -> reset_db - Resets a database

5. use pdb to debug django projects

6. dont copy paste html across templates. use {% extends %}, {% include %} and other builtin templatetags. write your own custom templatetags if necessary (they are very easy to write)

          http://docs.djangoproject.com/en/dev/ref/templates/builtins/

7. understand django middleware. Use this if you want to do some something before the request is processed / after the response is generated etc. - again they are very easy to write

http://docs.djangoproject.com/en/1.1/topics/http/middleware/

8. use django forms - they are really really powerful 

9. use django test client for unit testing. It acts a dummy web browser. Its very useful to simulate GET and POST request

        http://docs.djangoproject.com/en/dev/topics/testing/#module-django.test.client

Hello world in Ruby on Rails step by step

I just started to learn ROR just because it is quite similar to Django


So, this is a step by step tutorial to getting over the first hurdle: Creating a “hello world” application in Ruby on Rails. This should work assuming you already have Rails 3 installed and running on your system:

1. $ rails hello

2. $ cd hello

3. $ rails generate controller hello

4. Open the file config/routes.rb. Almost at the bottom (line #57) is this line:
   

   # match ':controller(/:action(/:id(.:format)))'

   Remove the # in front so the line looks like:
   
   

   match ':controller(/:action(/:id(.:format)))'

5. Create a file named index.html.erb in app/views/hello containing the text ‘Hello world’.

6. $ rails server

7. Navigate to http://localhost:3000/hello in your browser and be greeted by your friendly application: “Hello world”.

PS: http://localhost:3000/ is (still) a lot prettier “Hello world”-ish page.
PPS: Note that the Rails 3 example above actually has a step more than the Rails 1 ditto. This comes from the fact that Rails 3 doesn’t build a default route for you.

The code in this article has been verified with:

• Ruby: 1.8.7
• Rails: 3.0.0.beta

Ruby on Rails on windows with mysql

     

      This is basically what I do to install on Windows XP:

• Download and install latest mysql from http://dev.mysql.com/downloads/mysql/
• Install Ruby http://rubyinstaller.org/downloads/ (check the box to update PATH)
• Install Ruby Devkit http://rubyinstaller.org/downloads/ (for example extract to C:\DevKit)
• Setup Devkit
  

  cd [MY_DEVKIT_INSTALL_DIR]
  ruby dk.rb init
  ruby dk.rb install
  

• Copy libmysql.dll from your mysql/bin install to C:\Ruby192\bin
  

  gem install rails
  gem install mysql2 -v 0.2.6
  rails new my_test_app -d mysql