Creative Commons - User contributions [en]

Liblicense tutorial

2007-08-09T16:49:46Z

HSAENZL: /* Command-line Interface */

== Python and GTK ==
With the release of liblicense (ll) 0.3 we've introduced the beginnings of desktop integration. With this brief guide I hope to drive further integration into other apps. While I'll be using the python bindings for simplicity, the C bindings are very similar. In this section I will show how the integration through nautilus-python is done. Here is a screenshot from nautilus.

[[Image:ll_nautilus_emblem.png]]

The first step of writing any plugin is figuring out the relevant APIs. In this case, the relevant APIs are that of liblicense and nautilus-python. The former's API is familiar to me because I wrote it but for consistencies sake the documentation is on the wiki. The nautilus-python documentation is pretty sparse as is the nautilus extension C documentation. However, I found this documentation file on the gnome svn. There are two primary integrations which I'll talk about. The first is the license emblem shown in the screenshot above. The second is a license properties tab. We'll start with the emblem because it uses the read function of liblicense.

First off to have nautilus load the plugin we place the python file in either /usr/lib/nautilus/extensions-1.0/python or ~/.nautilus/python-extensions/. Our name for the file is nautilus-liblicense.py. We'll put both aspects of the integration in this file. Next we'll import the necessary modules.

<pre>import liblicense
import urllib

import gtk
import nautilus
from liblicense.gui_gtk import *</pre>

Urllib is used to replace things such as %20 (for space) with their correct character. Gtk can be ignored for now as we'll see it in the second part. The nautilus import provides the classes which we'll subclass to provide the desired functionality. Lastly, the two liblicense imports provide us with the library functions and the gtk selector widget which we'll use later.

In order to process the files upon load we'll subclass the InfoProvider class from nautilus-python (imported as nautilus). Within this class we need to override one function, update_file_info, which takes on argument, a FileInfo object, in addition to self.

The class so far:
<pre>class LicenseInfoProvider(nautilus.InfoProvider):
def __init__(self):
pass
def update_file_info(self, f):
pass</pre>

There is nothing we need to do upon init but we'll leave it there. In a nautilus-python example they did similar. So now in the update_file_info function we'll need to read the license of the file and assign a corresponding emblem. Currently, two emblems are used, one for Creative Commons licenses and another for anything else. Here is this final code of the update_file_info function.

<pre>
def update_file_info(self, f):
if f.get_uri()[:7]=="file://":
license = liblicense.read(urllib.unquote(f.get_uri()[7:]))
if license:
if "Creative Commons" in liblicense.get_attribute(license,"http://purl.org/dc/elements/1.1/creator",False):
f.add_emblem("cc")
else:
f.add_emblem("licensed")
</pre>
The first check that is done makes sure that the argument is a local file by check that it begins with "file://". Once that is confirmed, we then read the license of the file by calling liblicense.'''read'''(''filename''). Here urllib is used to convert url encoded characters, such as %20 for a space, so that we have an accurate file path. This is all done on everything after the first seven characters of the uri which '''get_uri'''() returned.

After the license is read we check that it is not null. If its not then we use liblicense.'''get_attribute''' to get the creator of the license to check if it is Creative Commons or not. We use python's keyword '''in''' because '''get_attribute''' returns a list of values. The arguments for '''get_attribute''' are the license uri, the desired attributes uri (the predicate in RDF terms) and finally a boolean toggling the locale awareness of the processing. Once all of this is done we add the corresponding emblem using the FileInfo object's '''add_emblem''' function which takes the emblem keyword. Upon install of liblicense these two icons are added. The keyword is taken from the filename (emblem-''keyword''.{png,svg}) not the .icon file. That explains all of the first part. If you have further questions visit #cc on irc.freenode.net or email cc-devel@lists.ibiblio.org.

The second part of this section and of the nautilus liblicense integration is the properties tab. Through this tab one can see the exact license the file is currently under and they can also modify the license. This is done by utilizing the packaged LicenseChooser liblicense gtk widget. Lets have a look.

First lets set up the nautilus API for a property page:
<pre>class LicensePropertyPage(nautilus.PropertyPageProvider):
def __init__(self):
pass

def get_property_pages(self, files):
pass
</pre>
Again, similar to the first section we're subclassing a nautilus class. And again, we need to subclass one function. This time we need to subclass the '''get_property_pages''' method. This method takes in a list of '''FileInfo''' objects and returns a sequence of '''PropertyPage'''s.

Alright, lets get started. While the first iteration of this integration only supported a single file, we'll jump straight to the multiple file version.
<pre>def get_property_pages(self, files):
self.files = files

self.files = filter(lambda f: f.get_uri_scheme() == 'file' and not f.is_directory(),self.files)
self.files = map(lambda f: urllib.unquote(f.get_uri()[7:]),self.files)

if len(self.files)==0:
return
</pre>
In this first bit we do some python wizardry. First we store the files list in the object itself, we'll need it later. Now we '''filter''' out the files with a different uri scheme and those which are directories. This leaves us with a list of '''FileInfo''' objects which have uris in the "file:///path/filename.ext" form. So to get a list of files in the liblicense form we use '''map''' and '''urllib.unquote''' like we did in the previous part. Finally, before we continue, we make sure we have not filtered out all of the selected items.

Now that we have a list of relevant files we need to do one of two things, if there is only one file selected we start the license chooser displaying the appropriate license or we display no license if multiple files are selected. '''get_property_pages''' continued:
<pre>self.property_label = gtk.Label('License')
self.property_label.show()

if len(files) == 1:
license = liblicense.read(self.files[0])
if license==None:
license = liblicense.get_default()
else:
license = None
self.box = LicenseWidget(license)
</pre>
First, we create the label for the property tab. After this we see how many files we are dealing with. If its one, we call read on the first and only element of the list and proceed to check whether it exists (in other words, is ''None'' or not). When the license is ''None'' we default to the system default license. If there is multiple files we simply set the license to ''None''. Finally, we create the '''LicenseWidget''' (which is a subclass of '''gtk.HBox''') passing the desired starting license uri in.

The last task we must complete is to write the license to the selected file(s) when the properties window is closed. To do this we attach a callback to the destroy signal of the '''LicenseWidget'''.
<pre> self.box.connect("destroy",self.license_chosen)
self.box.show()

return nautilus.PropertyPage("NautilusPython::license",
self.property_label, self.box),
</pre>

The above should be self explanatory. We simply use the PyGTK widget method '''connect''' to attach a method to the signal. Then we return a sequence (note the ending comma) of '''PropertyPage'''s created in the return statement. I copied this from the nautilus-python example and assume the arguments are an identifier, a label and a widget to be packed in the tab.

Lastly, the callback method is pretty simple.
<pre> def license_chosen(self, widget):
license = self.box.get_license()
if license:
for f in self.files:
liblicense.write(f,license)
</pre>

Like all GTK callbacks the first argument is the widget which emitted the signal along with self. Upon receiving this signal we get the current license of the widget by calling the '''LicenseWidget''''s get_license method which returns the uri for the selected license or ''None'' if no license is selected. Then we check to see if a license was selected and if so iterate through the selected files writing the license info to each one. This writing is done using the liblicense '''write''' method which takes the file path and the license uri. It utilizes liblicense modules which write to a variety of different file formats.

Well, thats the end of the liblicense nautilus integration. The entire file can be seen at [http://cctools.svn.sourceforge.net/viewvc/cctools/liblicense/trunk/src/gnome/nautilus-liblicense.py?revision=6398&view=markup Liblicense svn browse].

--[[User:Scott Shawcroft|Scott Shawcroft]] 17:03, 29 July 2007 (EDT)

== License Chooser ==

Liblicense aims to make integration of license selection into applications seamless. The license chooser API allows for selecting licenses based on what the license permits, requires, and/or prohibits. For example, the license chooser API makes an excellent backend to the following:

[[Image:Kde_properties.png]]

=== Graphical License Chooser ===

I'll start with a simple example that uses the Python bindings:

<pre>
from liblicense import LicenseChooser

attributes = ["http://creativecommons.org/ns#Distribution",
"http://creativecommons.org/ns#DerivativeWorks",
"http://creativecommons.org/ns#Attribution",
"http://creativecommons.org/ns#Notice"]
chooser = LicenseChooser(None,attributes)
chooser.get_licenses(permits=(1 << 0) | (1 << 1), requires=0, prohibits=0)
>>> ['http://creativecommons.org/licenses/publicdomain/']
</pre>

LicenseChooser takes two arguments:
* The first is a string representing the jurisdiction of licenses to return. In this case, we specify '''None''' to only return Unported licenses. For example, "us" or "uk" would be acceptable input, for United States and United Kingdom licenses, respectively.
* The second is a list of attributes to search on. Note: this is not Creative Commons specific -- you may specify any attributes in this list.

Now that we have a LicenseChooser, we can query it for licenses based on flags. There's a bit of voodoo here, but I hope that you can follow by example. Let's start with this:

<pre>(1 << 0) | (1 << 1)</pre>

These are the '''permits''' flags from the above example. What this says is that we want licenses that permit the 0th and 1st attribute in the '''attributes''' list -- in other words, licenses that permit Distribution and DerivativeWorks. Flags we don't care about (in this example, '''requires''' and '''prohibits'''), we set to zero. Alternatively, they can be left out altogether.

Because we also specified the Attribution and Notice attributes, the above query will return licenses that do not permit, require, or prohibit these attributes. This particular query returns one license: Public Domain.

==== PyGTK Widget ====
Now that we have the basics for how the LicenseChooser works, we are going to build the following license selection widget using PyGTK. Because it is included with Liblicense, I'll only explain the relevant parts of the code. The full source is available here: [http://cctools.svn.sourceforge.net/viewvc/cctools/liblicense/trunk/src/gnome/gui_gtk.py.in?revision=6398&view=markup http://cctools.svn.sourceforge.net/viewvc/cctools/liblicense/trunk/src/gnome/gui_gtk.py.in].

My hope is that this short tutorial will help in creating license choosers using other graphical toolkits and other languages.

[[Image:GTK_LicenseChooser.png]]

First off, I'll assume you've built the above GUI. You should have something like the following:

<pre>
import gtk
import gobject
import liblicense

class LicenseWidget(gtk.VBox):
__gsignals__ = {"changed":(gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,(gobject.TYPE_STRING,))}
def __init__(self):
# Build your GUI here
</pre>

You should have 5 gtk.CheckButton's.
* self.ash: Allow Sharing
* self.ar : Allow Remixing
* self.pcw: Prohibit Commercial Works
* self.sa : Require Share-Alike
* self.by : Require Attribution

And 2 gtk.Entry's.
* self.uri : Displays the URI of the matching license
* self.license : Displays the name of the matching license

Note that you could use any attributes and any number of attributes you would like. These 5 fit well with Creative Commons licenses.

We will also create the license chooser in '''__init__'''.

<pre>
attributes = ["http://creativecommons.org/ns#Attribution",
"http://creativecommons.org/ns#Distribution",
"http://creativecommons.org/ns#DerivativeWorks",
"http://creativecommons.org/ns#CommercialUse",
"http://creativecommons.org/ns#ShareAlike"]
self.ll_chooser = liblicense.LicenseChooser(None,attributes)
</pre>
Now let's connect the five buttons up.

<pre>
self.by.connect("toggled",self.checkbox_toggled,0)
self.ash.connect("toggled",self.checkbox_toggled,1)
self.ar.connect("toggled",self.checkbox_toggled,2)
self.pcw.connect("toggled",self.checkbox_toggled,3)
self.sa.connect("toggled",self.checkbox_toggled,4)
</pre>

Here's what we'll do when a checkbox is clicked.

<pre>
def checkbox_toggled(self,button,flag):
self.update_license()

def update_license(self):
licenses = self.ll_chooser.get_licenses(
permits=(self.ash.get_active()<<1) | (self.ar.get_active()<<2),
requires=(self.by.get_active()<<0) | (self.sa.get_active()<<4),
prohibits=(self.pcw.get_active()<<3))

if licenses:
uri = licenses[0]
self.emit("changed",uri)
self.uri.set_text(uri)
v = liblicense.get_version(uri)
self.license.set_text("%s - %d.%d.%d" % (liblicense.get_name(u), v[0], v[1], v[2]))
else:
self.uri.set_text("")
self.license.set_text("none")
</pre>

I'll break this down.

<pre>
licenses = self.ll_chooser.get_licenses(
permits=(self.ash.get_active()<<1) | (self.ar.get_active()<<2),
requires=(self.by.get_active()<<0) | (self.sa.get_active()<<4),
prohibits=(self.pcw.get_active()<<3))
</pre>

Here are those voodoo flags again. The important thing to realize is that the above numbers correspond to the index in the '''attributes''' array. If get_active() returns False, then that component drops out of the expression and is effectively ignored. Otherwise, the correct bit is set.

<pre>
if licenses:
uri = licenses[0]
self.emit("changed",uri)
self.uri.set_text(uri)
v = liblicense.get_version(uri)
self.license.set_text("%s - %d.%d.%d" % (liblicense.get_name(u), v[0], v[1], v[2]))
</pre>

A license matched, so we'll use liblicense to get the name and version of the license to display, along with the URI. Note that the LicenseChooser returned a list of licenses. For simplicity, we'll only display the first in the list. We'll also emit the "changed" signal so that the application is notified of the license change.

<pre>
else:
self.uri.set_text("")
self.license.set_text("none")
</pre>

No license matched so we do a bit of cleanup.

And that's about it. I won't cover the details of jurisdiction at the moment, but this can easily be accomplished by creating a new LicenseChooser with the appropriate jurisdiction whenever a new jurisdiction is selected.

=== C bindings ===

Here is a complete, standalone example using the C bindings. Integration into applications follows similarly to the Python bindings above.

<pre>
#include <liblicense.h>
#include <stdio.h>

int main() {
ll_init();

char *attributes[] = {
"http://creativecommons.org/ns#Distribution",
"http://creativecommons.org/ns#CommercialUse",
"http://creativecommons.org/ns#DerivativeWorks",
"http://creativecommons.org/ns#ShareAlike",
"http://creativecommons.org/ns#Attribution",
NULL
};
ll_license_chooser_t *chooser = ll_new_license_chooser(NULL,attributes);

int permits, requires, prohibits;

//permits Distribution(0) and DerivativeWorks(2)
permits = (1 << 0) | (1 << 2);

//requires ShareAlike(3) and Attribution(4)
requires = (1 << 3) | (1 << 4);

//prohibits CommericalUse(1)
prohibits = (1 << 1);

const ll_license_list_t *licenses = ll_get_licenses_from_flags(chooser,permits,requires,prohibits);
while (licenses) {
printf("%s\n",licenses->license);
licenses = licenses->next;
}

ll_free_license_chooser(chooser);
ll_stop();

return 0;
}
</pre>

== Command-line Interface ==
[[Incomplete]]
<nowiki>Insert non-formatted text here</nowiki>HSAENZL EN WEB[[Image:Example.jpg]]YAHOO[[Image:Example.jpg]]HSAENZ
== Headline text ==[[Media:Example.ogg]]

Talk:Content Directories

2007-08-06T22:27:23Z

HSAENZL:

<math>Insert formula here</math>== how much content is needed for inclusion and how to promote a CC site?? ==

I started an [http://saponaceo.us open soapmaking wiki] in which all content is Creative Commons licensed. So far I've had difficulty (and resistance) promoting it among the soapmaking community through Yahoo! groups. I went about promoting it the wrong way, but there's no help from google or other search engines, even when you try really hard to find a free soapmaking content site. Try as you might, it just doesn't have the 'pagerank' to be useful. I think I might just continue to put content into it myself, and if it doesn't take off, I'll turn what I have at that point into a book and sell it. But this of course defeats the purpose of CC licensed info. If anyone can help, please help me. People's response to me so far is that I have something to gain from hosting and trying to promote the site. I'm not even running ads. I work as a web developer. This is supposed to be a build it and they will come type of thing. I have one other moderator. There seems to be a trust disconnect. Maybe there's just not enough information there yet. Please reply to mchrisneglia . at . yahoo.com. [http://mchrisneglia.info or find me here]

simuze and promocioname need to be re-added

openphoto.net?<math>Insert formula here</math>HECTOR^+LOPEZ

== agnula libre music has been down for months ==[[Image:Example.jpg]]GOOGLE

----

== wow, I have to say I love creative commons in theory ==
...practice not so much. I made an album, it went out of print thanks to Tower Records so I decided that I wanted to give it away, its a christmas record, but not a sucky one so I t seemed in keeping with the spirt. I gave it a creative commons license. So that it could live new exciting lives as soundtracks or samples or what have you. I wanted to list it so that it could be searchable within CC. Almost two hours later I have yet to find a place to put anything. Now if i had remixed my music, there are forty places to do that. but where can you give something, thats not remixed? it seems like a simple content directory would be so much more useful. uggh sorry I know this isn't the ranting space, that is probably hid under some obscure sub menu three levels down,

so heres the deal if someone wants to list this somewhere cool
its a christmas record: Snaildartha : the story of Jerry the Christmas Snail-which is more a less a retelling of the life of Buddha...only through a Holiday snail.. and its Soul Jazz.

Currently it lives here Snaildartha[http://www.alliedchemical.com/~snaildartha]

If someone doesn't want to list it somewhere, thats fine too,

==Agnula Libre Music==
* Main URL: http://muzik.agnula.org/
* CC-only portal: almost everything is CC-licensed (some EFF OAL)
* CC-only feed: ?
* Formats: audio
* Size and scope of CC-licensed collection: ?
* Notes:

Removed this from the article. [[User:Mike Linksvayer|Mike Linksvayer]] 21:00, 3 July 2006 (UTC)

I would like to ad a new section for this but I don't know how..

CcHost File Access

2007-08-06T22:16:44Z

HSAENZL: /* ccHost Permissions Policy */

== Information regarding UNIX file permission and ccHost==

Setting file permissions in the most efficient and secure way can be tricky with
a content management system such as ccHost on a UNIX system.

There are many (i.e. many, many) UNIX configurations for running Apache and PHP
and this document does not pretend to cover all. It is a compendium of issues
encountered by various ccHost installations under some popular scenarios. If
there are security issues on your server with ccHost or you would like to avoid
them, hopefully this document will arm you with enough information to ask your
system administrator the right questions.

If you 'own' the server and have super-user (root) access then these problems
are probably moot because you have the rights to do whatever you want with the
directories and files created by ccHost. However, depending on whether you run PHP
in CGI mode or not, these issues could very well be a big problem.

On the other hand if you are using a company server or a
web hosting service, especially
on a 'shared server', then chances are you do not have such
access rights and that's where the issues begin.

In either case the thing to understand is that on a UNIX
system: Whoever creates a file or directory on UNIX typically has full
(or enough) access rights to that file or directory to do what
ever they like.'''

=== You are not nobody===

When you sign on to your web server via a terminal application (i.e.
shell) or transfer files via FTP you are operating as
whoever you logged in as. When you copy the ccHost installation
onto your server (or unzip them directly there) the directories
you create and files you copy into them are under your jurisdiction
and UNIX considers you the 'user' (you 'own' them).

When ccHost is running on a UNIX server it is considered
a PHP browser application running in an instance of Apache. Your
server administrator has set up all PHP applications like ccHost
to run, not as you, but as a special user, usually called 'nobody'
and UNIX considers 'nobody' to be the user who owns the directory
and files.

The main point is: These are two very distinctly different identities and the directories
and files created by ccHost are owned by this 'nobody' account, not you.

Evidence can be seen when you list out the directories in your ccHost
installation:
<pre>
drwxrwxr-x 5 victor wgroup 4096 Jul 15 01:41 cctools
drwxrwxr-x 5 nobody wgroup 4096 Jul 17 02:09 contests
</pre>

The first directory 'cctools' created by me during FTP install. The second directory 'contests' was created by ccHost when I said 'Create Contest' and is therefore owned by another user.

=== What ccHost Requires (IMPORTANT)===

For 3.1 installations and later: The path configuration screen (Global Settings/Paths) will let you know exactly which directories require write access from script. These include 'people', 'constests', your log directory and my_files/temp. These last two depend on where you specified their locations during installation. NOTE: ''Your installation will not work properly until my_files/temp is writable to script.''

For installations previous to 3.1: In order to install properly, ccHost (or more precisely the PHP account ccHost is running as) must have write permissions in the root directory of the ccHost installation, in a directory under it called '''cclib/phptal/phptal_cache''' and where ever you told the installation to put log files to. Specifically and in UNIX parlance this means full permission: Read, Write and Execute. The '''people''' directory is normally created by ccHost the first time something is uploaded and the '''contests''' directory is normally created the first time something is uploaded into a contest. If these directories already exist then ccHost will only need permissions in them, '''cclib/phptal/phptal_cache''' and your logfile directory -- not the root. Instructions for how to set these up (and whether you even have to) are covered below.

=== Case 1: You and ccHost are the same user===

In the best case scenario, some web hosters make all of this go away by
simply having PHP applications run under the same account as your login account.
There is no 'nobody' account to contend with and ccHost is, in fact, running as you
so permission to create directories in the main directory or write files to
the phptal_cache directory is given. So if you ask your system administrator
'Do PHP apps run under my user's account?' and if the answer is 'Yes' then you
can skip down the ccHost policy section because none of
this applies to your ccHost installation.

=== Case 2: You and ccHost are in the same group===

The next question you have to ask is whether your account and PHP account
is in the same group. You can see in the listing first mentioned
above that this is case:
<pre>
drwxrwxr-x 5 victor wgroup 4096 ....
drwxrwxr-x 5 nobody wgroup 4096 ....
</pre>
This is important because while you may not be the same user as
the PHP account, UNIX has another level of security called group before
getting to the global space (the rest of the world).
If this is the case then you should consider restricting the directories that need writing access to only owner and group.

The way to traditionally do this is to run the chmod command as such:

chmod 775 folder

Or, for all files under the folder recursively:

chmod -R 775 folder

And/or, just to give the group full read (r), write (w) and execute (x) privileges:

chmod -R g+rwx folder

=== Case 3: You and ccHost are not in the same group===

If your personal UNIX login account and your PHP account are not even in the
same group then you may still have an out:

Some web hosting companies provide you with a secure browser based
interface that allows you to bridge difference in user rights by giving you
behind-the-scenes circumvention to ownership issues in your space
on the server. When the ccHost
documentation prescribes things like 'setting write permissions on a
directory' you should use this secure web interface provided by your
web hoster to perform the action. When you need to make changes to the
files, use this interface. That way it won't matter if the
'nobody' account or your account created the directory or file,
you can make the needed change.

If your personal UNIX login account and your PHP account are not in the same group and you haven't a secure web interface, then your system administrator or web hosting service has left you with no choice to make the necessary directories available for writing to global users (a.k.a. other). You should keep the ccHost default access permission at 777.

== Headline text ==
== ccHost Permissions Policy==
ccHost 3.0 will use 0777 as the default for creating files. This is so new installations can get quickly off the ground and running. If you wish to change this policy go to 'Manage Site' and then 'Global Settings.'
<math>Insert formula here</math>[[Image:Example.jpg]]
--[[User:HSAENZL|HSAENZL]] 18:16, 6 August 2007 (EDT)<math>Insert formula here</math>^7E/e''Italic text''hectorlopez

----
[[Link title]]bienvinido

CCWiki talk:Administrators

2007-08-06T20:00:42Z

HSAENZL: New page: [http://www.example.com link title] hector '''Bold text'''deseo feliz <page><math>Insert formula here</math>7^+e[goto] --~~~~ == Headline text == pagedihector^web<math>Insert formula here<...

[http://www.example.com link title] hector
'''Bold text'''deseo feliz <page><math>Insert formula here</math>7^+e[goto]
--[[User:HSAENZL|HSAENZL]] 16:00, 6 August 2007 (EDT)
== Headline text ==
pagedihector^web<math>Insert formula here</math>87^e+a
[http://www.example.com link title]
== Headline text ==