markdown-body entry-content container-lg" itemprop="text">

cc-legal-tools-app

Creative Commons (CC) Legal Tools Application. This repository contains the application that manages the license tools and public domain tools (static HTML, internationalization and localization files, etc.). It consumes and generates data in the creativecommons/cc-legal-tools-data repository.

Code of Conduct

CODE_OF_CONDUCT.md:

The Creative Commons team is committed to fostering a welcoming community. This project and all other Creative Commons open source projects are governed by our Code of Conduct. Please report unacceptable behavior to conduct@creativecommons.org per our reporting guidelines.

About

This application manages 639 legal tools (636 licenses and 3 public domain tools). The current version of the licenses is 4.0 and includes 6 licenses. They are international and are designed to operate globally, ensuring they are robust, enforceable and easily adopted worldwide. Prior versions were adapted to specific jurisdictions ("ported"). That is why there are 636 licenses.

Broadly speaking, each legal tool consists of three layers:

deed: a plain language summary of the legal tool
legalcode: the legal tool itself
rdf: metadata about the legal tool in RDF/XML format

With translations of the deed and translations of the legal code, this application manages over 30,000 documents.

Not the live site

This project is not intended to serve the legal tools directly. Instead, a command line tool can be used to save all the rendered HTML and RDF/XML pages as files. Then those files are used as part of the CreativeCommons.org site (served as static files).

Setup and Usage

Once this project's required dependencies (Docker, Git, etc.) are enabled on your system, you will be able to run the legal-tools application and generate static files.

For information on learning and installing the prerequisite technologies for this project, please see Foundational technologies — Creative Commons Open Source.

Codebases Setup

Both this repository and the creativecommons/cc-legal-tools-data project repository should be cloned side by side, resulting in a structure like the following:

creative-commons/
├── cc-legal-tools-app/     (git clone of this repository)
└── cc-legal-tools-data/    (git clone of the cc-legal-tools-data repository)

To achieve this, we recommend the following procedure:

Create and change to a container directory, such as creative-commons or cc.
```
mkdir creative-commons
cd creative-commons
```

Clone both repos using SSH or, if that does not work, HTTPS protocol.

git clone git@github.com:creativecommons/cc-legal-tools-app.git
git clone git@github.com:creativecommons/cc-legal-tools-data.git

git clone https://github.com/creativecommons/cc-legal-tools-app.git
git clone https://github.com/creativecommons/cc-legal-tools-data.git

Visit Cloning a repository - GitHub Docs for more on how to clone a GitHub repository.

Docker Prep and Initial Execution

Use the following instructions to prepare and run the project with Docker Compose.

Ensure all prerequisites and repositories are in place.
Ensure you are at the top level of the directory where you cloned this repository (where manage.py is).
```
cd cc-legal-tools-app
```
Create Django local settings file from the example file.
```
cp cc_legal_tools/settings/local.example.py cc_legal_tools/settings/local.py
```
- Update variables in new file, if necessary.
- This file is ignored by Git.
Build the containers.
```
docker compose build
```
Run the containers.
```
docker compose up
```
1. app (127.0.0.1:8005): this Django application
  - Any changes made to Python will be detected and rebuilt transparently as long as the development server is running.
2. static (127.0.0.1:8006): a static web server serving creativecommons/cc-legal-tools-data:docs/
Initialize data. Open a separate terminal tab, and in the same directory, run:
```
./bin/init_data.sh
```
1. Deletes database (which may not yet exist)
2. Initializes database
3. Performs database migrations
4. Creates supseruser (will prompt for password)
5. Loads data

Note: Once this full setup is performed, running Step 5 above will execute the application on any subsequent occasion.

Project Usage

With the prerequisites installed and built, these tools can be used to generate and manage data from the associated data repository.

Data

The legal tools metadata is in a database. The metadata tracks which legal tools exist, their translations, their ports, and their characteristics like what they permit, require, and prohibit.

~~The metadata can be downloaded by visiting the URL path: 127.0.0.1:8005/licenses/metadata.yaml~~ (currently disabled)

There are two main models (Django terminology for tables) in legal_tools/models.py:

LegalCode
Tool

A Tool can be identified by a unit (ex. by, by-nc-sa, devnations) which is a proxy for the complete set of permissions, requirements, and prohibitions; a version (ex. 4.0, 3.0), and an optional jurisdiction for ports. So we might refer to the tool by its identifier "BY 3.0 AM" which would be the 3.0 version of the BY license terms as ported to the Armenia jurisdiction. For additional information see: Legal Tools Namespace - creativecommons/cc-legal-tools-data: CC Legal Tools Data (static HTML, language files, etc.).

There are three places legal code text could be:

Gettext files (.po and .mo) in the creativecommons/cc-legal-tools-data repository (legal tools with full translation support):
- 4.0 Licenses
- CC0
Django template (legalcode_licenses_3.0_unported.html):
- Unported 3.0 Licenses (English-only)
html field (in the LegalCode model):
- Everything else

The text that's in gettext files can be translated via Transifex at Creative Commons localization. For additional information on the Django translation domains / Transifex resources, see How the license translation is implemented, below.

Documentation:

Translation

See docs/translation.md

Generate Static Files

Generating static files updates the static files in the docs/ directory of the creativecommons/cc-legal-tools-data repository (the Data Repository, above).

Static Files Process

This process will write the HTML files in the cc-legal-tools-data clone directory under docs/. By default it doesn't commit any changes.

Ensure the Data Repository, above, is in place
Ensure Docker Compose Setup, above, is complete

Run the helper script:

./bin/publish.sh

Example output:

# Django publish                                                       19:36:20
INFO 17:36:21 Checking legal code titles
INFO 17:36:23 Purging output_dir: /home/cc/cc-legal-tools-data/docs
INFO 17:36:31 Collecting static files
66 static files copied to '/home/cc/cc-legal-tools-app/tmp/public/static', 158 unmodified.
INFO 17:36:31 Writing robots.txt
INFO 17:36:31 Copying WordPress content files
INFO 17:36:31 Copying static cc-legal-tools files
INFO 17:36:31 Copying static RDF/XML files
INFO 17:36:31 Distilling index.rdf
INFO 17:36:33 Distilling images.rdf
INFO 17:36:33 Distilling ns.html
INFO 17:36:33 Copying plaintext legal code
INFO 17:36:33 Distilling dev index
INFO 17:36:34 Distilling lists
INFO 17:36:36 Distilling Licenses 4.0 deed HTML, legal code HTML, and RDF/XML
INFO 17:36:41 Distilling Licenses 3.0 deed HTML, legal code HTML, and RDF/XML
INFO 17:37:23 Distilling Licenses 2.5 deed HTML, legal code HTML, and RDF/XML
INFO 17:37:50 Distilling Licenses 2.1 deed HTML, legal code HTML, and RDF/XML
INFO 17:37:54 Distilling Licenses 2.0 deed HTML, legal code HTML, and RDF/XML
INFO 17:38:14 Distilling Licenses 1.0 deed HTML, legal code HTML, and RDF/XML
INFO 17:38:20 Distilling Public Domain all deed HTML, legal code HTML, and RDF/XML
INFO 17:38:21 Writing Apache2 redirects configuration

(note that the laptop environment and docker environment had different timezones, CEST and UTC)

Publishing Changes to Git Repo

When the site is deployed, to enable pushing and pulling the licenses data repo with GitHub, create an SSH deploy key for the cc-legal-tools-data repo with write permissions, and put the private key file (not password protected) somewhere safe (owned by www-data if on a server), and readable only by its owner (0o400). Then in settings, make TRANSLATION_REPOSITORY_DEPLOY_KEY be the full path to that deploy key file. (not active nor current)

Publishing Dependency Documentation

Machine/metadata Layer: RDF/XML

For details and history, see docs/rdf.md.

Development

Inside the Docker container, the Python-based tooling centers around by pre-commit and Django.

See the Code of Conduct above and the Code of Conduct document for more information on participant expectations and responsibilities.

Contributing

See CONTRIBUTING.md.

Manual Setup

⚠️ This section may be helpful for maintaining the project, but should NOT be used for development. Please use the Docker Compose Setup, above.

Complete Docker Compose Setup, above

Development Environment

Install dependencies

Linux:

sudo apt-get install python3.11 python3.11-dev python3-pip

pip3 install pipenv

macOS: via Homebrew:
```
brew install pipenv python@3.11
```
Windows: install Python and then use pip to install pipenv:
```
pip install pipenv
```

Install Python environment and modules via pipenv to create a virtualenv

Linux:

pipenv install --dev --python /usr/bin/python3.11

macOS: via Homebrew:

pipenv install --dev --python /usr/local/opt/python@3.11/libexec/bin/python

Windows:

pipenv install --dev --python \User\Appdata\programs\python

Install pre-commit hooks

pipenv run pre-commit install

Run development server (127.0.0.1:8005)
```
pipenv run python manage.py runserver
```
- Any changes made to Python will be detected and rebuilt transparently as long as the development server is running.

Software Versions

These are the currently designated versions of the various dependencies:

Developer Resources

These resources are available for developing this tooling:

Python Guidelines — Creative Commons Open Source
Black: the uncompromising Python code formatter
Coverage.py: Code coverage measurement for Python
Docker
- Dockerfile reference | Docker Documentation
- Compose file version 3 reference | Docker Documentation
flake8: a python tool that glues together pep8, pyflakes, mccabe, and third-party plugins to check the style and quality of some python code.
isort: A Python utility / library to sort imports.
pre-commit: A framework for managing and maintaining multi-language pre-commit hooks.

ℹ️ The rest of the documentation assumes Docker. If you are using a manual setup, use pipenv run instead of docker compose exec app for the commands below.

Helper Scripts

Best run before every commit:

./bin/coverage.sh - Run coverage tests and report
./bin/tools.sh - Run Python code tools (isort, black, flake8)

Run as needed:

./bin/copy_theme.sh - Copy the portions of creativecommons/vocabulary-theme needed for local development
- Run after each new release of creativecommons/vocabulary-theme

Generate static files:

./bin/publish.sh - Run Django publish mangement command via Docker

Django manage via Docker:

./bin/manage.sh - Run Django management commands via Docker
- Example:
```
./bin/manage.sh -h
```

Data management:

./bin/dump_data.sh - Dump Django application data
./bin/init_data.sh - ⚠️ Initialize Django application data
./bin/load_data.sh - Load Django application data

Esoteric and dangerous:

./bin/updatemessages.sh - ⚠️ Run Django Management nofuzzy_makemessages with helpful options (ex. excluding legalcode) and compilemessages

Coverage Tests and Report

The coverage tests and report are run as part of pre-commit and as a GitHub Action. To run it manually:

Ensure the Data Repository, above, is in place
Ensure Docker Compose Setup, above, is complete

Coverage test

docker compose exec app coverage run manage.py test --noinput --keepdb

Coverage report
```
docker compose exec app coverage report
```

Commit Errors

Error Building Trees

If you encounter an error: Error building trees error from pre-commit when you commit, try adding your files (git add <FILES>) before committing them.

Frontend Dependencies

The following CC projects are used to achieve a consistent look and feel:

creativecommons/vocabulary-theme: WordPress Theme implementation of the Vocabulary design system

Licenses

Code

LICENSE: the code within this repository is licensed under the Expat/MIT license.

Legal Code text

The text of the Creative Commons public licenses (legal code) is dedicated to the public domain under the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication.

Vocabulary Theme

COPYING: All the code within Vocabulary is dedicated to the public domain under the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication.

Normalize.css

normalize.css is licensed under the Expat/MIT License.

Fonts

Accidenz Commons

Accidenz Commons by Archetypo is licensed under the Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) License.

JetBrains Mono

JetBrains Mono is licensed under the OFL-1.1 License.

Roboto Condensed

Roboto Condensed by Christian Robertson is licensed under the Apache License, Version 2.0.

Source Sans Pro

Source Sans Pro by Paul D. Hunt is licensed under the Open Font License.

Vocabulary Icons

Vocabulary Icons use icons from Font Awesome which are licensed under the Creative Commons Attribution 4.0 International (CC BY 4.0) License.

티스토리 수익 글 보기

티스토리 수익 글 보기

Uh oh!