[dak/master] change documentation style
---
daklib/archive.py | 389 +++++++++++++++++++++++++++-------------------
daklib/checks.py | 34 ++--
daklib/fstransactions.py | 55 ++++---
daklib/policy.py | 65 +++++----
daklib/upload.py | 200 ++++++++++++++++--------
daklib/utils.py | 34 +++--
6 files changed, 469 insertions(+), 308 deletions(-)
diff --git a/daklib/archive.py b/daklib/archive.py
index 7f6895a..29a5621 100644
--- a/daklib/archive.py
+++ b/daklib/archive.py
@@ -19,13 +19,13 @@
This module provides classes to manipulate the archive.
"""
-from .dbconn import *
+from daklib.dbconn import *
import daklib.checks as checks
from daklib.config import Config
import daklib.upload as upload
import daklib.utils as utils
-from .fstransactions import FilesystemTransaction
-from .regexes import re_changelog_versions, re_bin_only_nmu
+from daklib.fstransactions import FilesystemTransaction
+from daklib.regexes import re_changelog_versions, re_bin_only_nmu
import apt_pkg
from datetime import datetime
@@ -50,17 +50,16 @@ class ArchiveTransaction(object):
self.session = DBConn().session()
def get_file(self, hashed_file, source_name):
- """Look for file `hashed_file` in database
+ """Look for file C{hashed_file} in database
- Args:
- hashed_file (daklib.upload.HashedFile): file to look for in the database
+ @type hashed_file: L{daklib.upload.HashedFile}
+ @param hashed_file: file to look for in the database
- Raises:
- KeyError: file was not found in the database
- HashMismatchException: hash mismatch
+ @raise KeyError: file was not found in the database
+ @raise HashMismatchException: hash mismatch
- Returns:
- `daklib.dbconn.PoolFile` object for the database
+ @rtype: L{daklib.dbconn.PoolFile}
+ @return: database entry for the file
"""
poolname = os.path.join(utils.poolify(source_name), hashed_file.filename)
try:
@@ -76,8 +75,8 @@ class ArchiveTransaction(object):
Will not give an error when the file is already present.
- Returns:
- `daklib.dbconn.PoolFile` object for the new file
+ @rtype: L{daklib.dbconn.PoolFile}
+ @return: batabase object for the new file
"""
session = self.session
@@ -108,23 +107,35 @@ class ArchiveTransaction(object):
def install_binary(self, directory, binary, suite, component, allow_tainted=False, fingerprint=None, source_suites=None, extra_source_archives=None):
"""Install a binary package
- Args:
- directory (str): directory the binary package is located in
- binary (daklib.upload.Binary): binary package to install
- suite (daklib.dbconn.Suite): target suite
- component (daklib.dbconn.Component): target component
-
- Kwargs:
- allow_tainted (bool): allow to copy additional files from tainted archives
- fingerprint (daklib.dbconn.Fingerprint): optional fingerprint
- source_suites (list of daklib.dbconn.Suite or True): suites to copy
- the source from if they are not in `suite` or True to allow
- copying from any suite.
- This can also be a SQLAlchemy (sub)query object.
- extra_source_archives (list of daklib.dbconn.Archive): extra archives to copy Built-Using sources from
-
- Returns:
- `daklib.dbconn.DBBinary` object for the new package
+ @type directory: str
+ @param directory: directory the binary package is located in
+
+ @type binary: L{daklib.upload.Binary}
+ @param binary: binary package to install
+
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: target suite
+
+ @type component: L{daklib.dbconn.Component}
+ @param component: target component
+
+ @type allow_tainted: bool
+ @param allow_tainted: allow to copy additional files from tainted archives
+
+ @type fingerprint: L{daklib.dbconn.Fingerprint}
+ @param fingerprint: optional fingerprint
+
+ @type source_suites: list of L{daklib.dbconn.Suite} or C{True}
+ @param source_suites: suites to copy the source from if they are not
+ in C{suite} or C{True} to allow copying from any
+ suite.
+ This can also be a SQLAlchemy (sub)query object.
+
+ @type extra_source_archives: list of L{daklib.dbconn.Archive}
+ @param extra_source_archives: extra archives to copy Built-Using sources from
+
+ @rtype: L{daklib.dbconn.DBBinary}
+ @return: databse object for the new package
"""
session = self.session
control = binary.control
@@ -185,14 +196,18 @@ class ArchiveTransaction(object):
This is intended to be used to check that Built-Using sources exist.
- Args:
- filename (str): filename to use in error messages
- source (daklib.dbconn.DBSource): source to look for
- archive (daklib.dbconn.Archive): archive to look in
+ @type filename: str
+ @param filename: filename to use in error messages
+
+ @type source: L{daklib.dbconn.DBSource}
+ @param source: source to look for
+
+ @type archive: L{daklib.dbconn.Archive}
+ @param archive: archive to look in
- Kwargs:
- extra_archives (list of daklib.dbconn.Archive): list of archives to copy
- the source package from if it is not yet present in `archive`
+ @type extra_archives: list of L{daklib.dbconn.Archive}
+ @param extra_archives: list of archives to copy the source package from
+ if it is not yet present in C{archive}
"""
session = self.session
db_file = session.query(ArchiveFile).filter_by(file=source.poolfile, archive=archive).first()
@@ -213,7 +228,7 @@ class ArchiveTransaction(object):
self._copy_file(af.file, archive, db_file.component, allow_tainted=True)
def _add_built_using(self, db_binary, filename, control, suite, extra_archives=None):
- """Add Built-Using sources to `db_binary.extra_sources`
+ """Add Built-Using sources to C{db_binary.extra_sources}
"""
session = self.session
built_using = control.get('Built-Using', None)
@@ -235,19 +250,29 @@ class ArchiveTransaction(object):
def install_source(self, directory, source, suite, component, changed_by, allow_tainted=False, fingerprint=None):
"""Install a source package
- Args:
- directory (str): directory the source package is located in
- source (daklib.upload.Source): source package to install
- suite (daklib.dbconn.Suite): target suite
- component (daklib.dbconn.Component): target component
- changed_by (daklib.dbconn.Maintainer): person who prepared this version of the package
+ @type directory: str
+ @param directory: directory the source package is located in
+
+ @type source: L{daklib.upload.Source}
+ @param source: source package to install
+
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: target suite
+
+ @type component: L{daklib.dbconn.Component}
+ @param component: target component
- Kwargs:
- allow_tainted (bool): allow to copy additional files from tainted archives
- fingerprint (daklib.dbconn.Fingerprint): optional fingerprint
+ @type changed_by: L{daklib.dbconn.Maintainer}
+ @param changed_by: person who prepared this version of the package
- Returns:
- `daklib.dbconn.DBSource` object for the new source
+ @type allow_tainted: bool
+ @param allow_tainted: allow to copy additional files from tainted archives
+
+ @type fingerprint: L{daklib.dbconn.Fingerprint}
+ @param fingerprint: optional fingerprint
+
+ @rtype: L{daklib.dbconn.DBSource}
+ @return: database object for the new source
"""
session = self.session
archive = suite.archive
@@ -342,13 +367,17 @@ class ArchiveTransaction(object):
def _copy_file(self, db_file, archive, component, allow_tainted=False):
"""Copy a file to the given archive and component
- Args:
- db_file (daklib.dbconn.PoolFile): file to copy
- archive (daklib.dbconn.Archive): target archive
- component (daklib.dbconn.Component): target component
+ @type db_file: L{daklib.dbconn.PoolFile}
+ @param db_file: file to copy
+
+ @type archive: L{daklib.dbconn.Archive}
+ @param archive: target archive
+
+ @type component: L{daklib.dbconn.Archive}
+ @param component: target component
- Kwargs:
- allow_tainted (bool): allow to copy from tainted archives (such as NEW)
+ @type allow_tainted: bool
+ @param allow_tainted: allow to copy from tainted archives (such as NEW)
"""
session = self.session
@@ -368,14 +397,20 @@ class ArchiveTransaction(object):
def copy_binary(self, db_binary, suite, component, allow_tainted=False, extra_archives=None):
"""Copy a binary package to the given suite and component
- Args:
- db_binary (daklib.dbconn.DBBinary): binary to copy
- suite (daklib.dbconn.Suite): target suite
- component (daklib.dbconn.Component): target component
+ @type db_binary: L{daklib.dbconn.DBBinary}
+ @param db_binary: binary to copy
+
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: target suite
+
+ @type component: L{daklib.dbconn.Component}
+ @param component: target component
+
+ @type allow_tainted: bool
+ @param allow_tainted: allow to copy from tainted archives (such as NEW)
- Kwargs:
- allow_tainted (bool): allow to copy from tainted archives (such as NEW)
- extra_archives (list of daklib.dbconn.Archive): extra archives to copy Built-Using sources from
+ @type extra_archives: list of L{daklib.dbconn.Archive}
+ @param extra_archives: extra archives to copy Built-Using sources from
"""
session = self.session
archive = suite.archive
@@ -403,13 +438,17 @@ class ArchiveTransaction(object):
def copy_source(self, db_source, suite, component, allow_tainted=False):
"""Copy a source package to the given suite and component
- Args:
- db_source (daklib.dbconn.DBSource): source to copy
- suite (daklib.dbconn.Suite): target suite
- component (daklib.dbconn.Component): target component
+ @type db_source: L{daklib.dbconn.DBSource}
+ @param db_source: source to copy
- Kwargs:
- allow_tainted (bool): allow to copy from tainted archives (such as NEW)
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: target suite
+
+ @type component: L{daklib.dbconn.Component}
+ @param component: target component
+
+ @type allow_tainted: bool
+ @param allow_tainted: allow to copy from tainted archives (such as NEW)
"""
archive = suite.archive
if archive.tainted:
@@ -423,10 +462,14 @@ class ArchiveTransaction(object):
def remove_file(self, db_file, archive, component):
"""Remove a file from a given archive and component
- Args:
- db_file (daklib.dbconn.PoolFile): file to remove
- archive (daklib.dbconn.Archive): archive to remove the file from
- component (daklib.dbconn.Component): component to remove the file from
+ @type db_file: L{daklib.dbconn.PoolFile}
+ @param db_file: file to remove
+
+ @type archive: L{daklib.dbconn.Archive}
+ @param archive: archive to remove the file from
+
+ @type component: L{daklib.dbconn.Component}
+ @param component: component to remove the file from
"""
af = self.session.query(ArchiveFile).filter_by(file=db_file, archive=archive, component=component)
self.fs.unlink(af.path)
@@ -435,9 +478,11 @@ class ArchiveTransaction(object):
def remove_binary(self, binary, suite):
"""Remove a binary from a given suite and component
- Args:
- binary (daklib.dbconn.DBBinary): binary to remove
- suite (daklib.dbconn.Suite): suite to remove the package from
+ @type binary: L{daklib.dbconn.DBBinary}
+ @param binary: binary to remove
+
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: suite to remove the package from
"""
binary.suites.remove(suite)
self.session.flush()
@@ -445,13 +490,14 @@ class ArchiveTransaction(object):
def remove_source(self, source, suite):
"""Remove a source from a given suite and component
- Raises:
- ArchiveException: source package is still referenced by other
- binaries in the suite
+ @type source: L{daklib.dbconn.DBSource}
+ @param source: source to remove
+
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: suite to remove the package from
- Args:
- binary (daklib.dbconn.DBSource): source to remove
- suite (daklib.dbconn.Suite): suite to remove the package from
+ @raise ArchiveException: source package is still referenced by other
+ binaries in the suite
"""
session = self.session
@@ -490,40 +536,60 @@ class ArchiveTransaction(object):
class ArchiveUpload(object):
"""handle an upload
- This class can be used in a with-statement:
+ This class can be used in a with-statement::
with ArchiveUpload(...) as upload:
...
Doing so will automatically run any required cleanup and also rollback the
transaction if it was not committed.
-
- Attributes:
- changes (daklib.upload.Changes): upload to process
- directory (str): directory with temporary copy of files. set by `prepare`
- fingerprint (daklib.dbconn.Fingerprint): fingerprint used to sign the upload
- new (bool): upload is NEW. set by `check`
- reject_reasons (list of str): reasons why the upload cannot be accepted
- session: database session
- transaction (daklib.archive.ArchiveTransaction): transaction used to handle the upload
- warnings (list of str): warnings (NOT USED YET)
"""
def __init__(self, directory, changes, keyrings):
self.transaction = ArchiveTransaction()
+ """transaction used to handle the upload
+ @type: L{daklib.archive.ArchiveTransaction}
+ """
+
self.session = self.transaction.session
+ """database session"""
self.original_directory = directory
self.original_changes = changes
+
self.changes = None
+ """upload to process
+ @type: L{daklib.upload.Changes}
+ """
+
self.directory = None
+ """directory with temporary copy of files. set by C{prepare}
+ @type: str
+ """
+
self.keyrings = keyrings
self.fingerprint = self.session.query(Fingerprint).filter_by(fingerprint=changes.primary_fingerprint).one()
+ """fingerprint of the key used to sign the upload
+ @type: L{daklib.dbconn.Fingerprint}
+ """
self.reject_reasons = []
+ """reasons why the upload cannot by accepted
+ @type: list of str
+ """
+
self.warnings = []
+ """warnings
+ @note: Not used yet.
+ @type: list of str
+ """
+
self.final_suites = None
+
self.new = False
+ """upload is NEW. set by C{check}
+ @type: bool
+ """
self._new_queue = self.session.query(PolicyQueue).filter_by(queue_name='new').one()
self._new = self._new_queue.suite
@@ -533,9 +599,9 @@ class ArchiveUpload(object):
This copies the files involved to a temporary directory. If you use
this method directly, you have to remove the directory given by the
- `directory` attribute later on your own.
+ C{directory} attribute later on your own.
- Instead of using the method directly, you can also use a with-statement:
+ Instead of using the method directly, you can also use a with-statement::
with ArchiveUpload(...) as upload:
...
@@ -575,12 +641,12 @@ class ArchiveUpload(object):
"""Path to unpacked source
Get path to the unpacked source. This method does unpack the source
- into a temporary directory under `self.directory` if it has not
+ into a temporary directory under C{self.directory} if it has not
been done so already.
- Returns:
- String giving the path to the unpacked source directory
- or None if no source was included in the upload.
+ @rtype: str or C{None}
+ @return: string giving the path to the unpacked source directory
+ or C{None} if no source was included in the upload.
"""
assert self.directory is not None
@@ -621,8 +687,8 @@ class ArchiveUpload(object):
def _mapped_suites(self):
"""Get target suites after mappings
- Returns:
- list of daklib.dbconn.Suite giving the mapped target suites of this upload
+ @rtype: list of L{daklib.dbconn.Suite}
+ @return: list giving the mapped target suites of this upload
"""
session = self.session
@@ -641,14 +707,14 @@ class ArchiveUpload(object):
Evaluate component mappings from ComponentMappings in dak.conf for the
given component name.
- NOTE: ansgar wants to get rid of this. It's currently only used for
- the security archive
+ @todo: ansgar wants to get rid of this. It's currently only used for
+ the security archive
- Args:
- component_name (str): component name
+ @type component_name: str
+ @param component_name: component name
- Returns:
- `daklib.dbconn.Component` object
+ @rtype: L{daklib.dbconn.Component}
+ @return: component after applying maps
"""
cnf = Config()
for m in cnf.value_list("ComponentMappings"):
@@ -662,11 +728,11 @@ class ArchiveUpload(object):
"""Check if upload is NEW
An upload is NEW if it has binary or source packages that do not have
- an override in `suite` OR if it references files ONLY in a tainted
+ an override in C{suite} OR if it references files ONLY in a tainted
archive (eg. when it references files in NEW).
- Returns:
- True if the upload is NEW, False otherwise
+ @rtype: bool
+ @return: C{True} if the upload is NEW, C{False} otherwise
"""
session = self.session
@@ -714,12 +780,14 @@ class ArchiveUpload(object):
def _binary_override(self, suite, binary):
"""Get override entry for a binary
- Args:
- suite (daklib.dbconn.Suite)
- binary (daklib.upload.Binary)
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: suite to get override for
- Returns:
- daklib.dbconn.Override or None
+ @type binary: L{daklib.upload.Binary}
+ @param binary: binary to get override for
+
+ @rtype: L{daklib.dbconn.Override} or C{None}
+ @return: override for the given binary or C{None}
"""
if suite.overridesuite is not None:
suite = self.session.query(Suite).filter_by(suite_name=suite.overridesuite).one()
@@ -736,12 +804,14 @@ class ArchiveUpload(object):
def _source_override(self, suite, source):
"""Get override entry for a source
- Args:
- suite (daklib.dbconn.Suite)
- source (daklib.upload.Source)
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: suite to get override for
+
+ @type source: L{daklib.upload.Source}
+ @param source: source to get override for
- Returns:
- daklib.dbconn.Override or None
+ @rtype: L{daklib.dbconn.Override} or C{None}
+ @return: override for the given source or C{None}
"""
if suite.overridesuite is not None:
suite = self.session.query(Suite).filter_by(suite_name=suite.overridesuite).one()
@@ -759,18 +829,17 @@ class ArchiveUpload(object):
"""get component for a binary
By default this will only look at overrides to get the right component;
- if `only_overrides` is False this method will also look at the Section field.
+ if C{only_overrides} is C{False} this method will also look at the
+ Section field.
- Args:
- suite (daklib.dbconn.Suite)
- binary (daklib.upload.Binary)
+ @type suite: L{daklib.dbconn.Suite}
- Kwargs:
- only_overrides (bool): only use overrides to get the right component.
- defaults to True.
+ @type binary: L{daklib.upload.Binary}
- Returns:
- `daklib.dbconn.Component` object or None
+ @type only_overrides: bool
+ @param only_overrides: only use overrides to get the right component
+
+ @rtype: L{daklib.dbconn.Component} or C{None}
"""
override = self._binary_override(suite, binary)
if override is not None:
@@ -782,11 +851,11 @@ class ArchiveUpload(object):
def check(self, force=False):
"""run checks against the upload
- Args:
- force (bool): ignore failing forcable checks
+ @type force: bool
+ @param force: ignore failing forcable checks
- Returns:
- True if all checks passed, False otherwise
+ @rtype: bool
+ @return: C{True} if all checks passed, C{False} otherwise
"""
# XXX: needs to be better structured.
assert self.changes.valid_signature
@@ -835,23 +904,24 @@ class ArchiveUpload(object):
def _install_to_suite(self, suite, source_component_func, binary_component_func, source_suites=None, extra_source_archives=None):
"""Install upload to the given suite
- Args:
- suite (daklib.dbconn.Suite): suite to install the package into.
- This is the real suite, ie. after any redirection to NEW or a policy queue
- source_component_func: function to get the `daklib.dbconn.Component`
- for a `daklib.upload.Source` object
- binary_component_func: function to get the `daklib.dbconn.Component`
- for a `daklib.upload.Binary` object
-
- Kwargs:
- source_suites: see `daklib.archive.ArchiveTransaction.install_binary`
- extra_source_archives: see `daklib.archive.ArchiveTransaction.install_binary`
-
- Returns:
- tuple with two elements. The first is a `daklib.dbconn.DBSource`
- object for the install source or None if no source was included.
- The second is a list of `daklib.dbconn.DBBinary` objects for the
- installed binary packages.
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: suite to install the package into. This is the real suite,
+ ie. after any redirection to NEW or a policy queue
+
+ @param source_component_func: function to get the L{daklib.dbconn.Component}
+ for a L{daklib.upload.Source} object
+
+ @param binary_component_func: function to get the L{daklib.dbconn.Component}
+ for a L{daklib.upload.Binary} object
+
+ @param source_suites: see L{daklib.archive.ArchiveTransaction.install_binary}
+
+ @param extra_source_archives: see L{daklib.archive.ArchiveTransaction.install_binary}
+
+ @return: tuple with two elements. The first is a L{daklib.dbconn.DBSource}
+ object for the install source or C{None} if no source was
+ included. The second is a list of L{daklib.dbconn.DBBinary}
+ objects for the installed binary packages.
"""
# XXX: move this function to ArchiveTransaction?
@@ -934,8 +1004,8 @@ class ArchiveUpload(object):
Try to handle byhand packages automatically.
- Returns:
- list of `daklib.upload.hashed_file` for the remaining byhand packages
+ @rtype: list of L{daklib.upload.HashedFile}
+ @return: list of remaining byhand files
"""
assert len(self.reject_reasons) == 0
assert self.changes.valid_signature
@@ -982,10 +1052,11 @@ class ArchiveUpload(object):
return len(remaining) == 0
def _install_byhand(self, policy_queue_upload, hashed_file):
- """
- Args:
- policy_queue_upload (daklib.dbconn.PolicyQueueUpload): XXX
- hashed_file (daklib.upload.HashedFile): XXX
+ """install byhand file
+
+ @type policy_queue_upload: L{daklib.dbconn.PolicyQueueUpload}
+
+ @type hashed_file: L{daklib.upload.HashedFile}
"""
fs = self.transaction.fs
session = self.transaction.session
@@ -1041,10 +1112,10 @@ class ArchiveUpload(object):
def install(self):
"""install upload
- Install upload to a suite or policy queue. This method does *not*
+ Install upload to a suite or policy queue. This method does B{not}
handle uploads to NEW.
- You need to have called the `check` method before calling this method.
+ You need to have called the C{check} method before calling this method.
"""
assert len(self.reject_reasons) == 0
assert self.changes.valid_signature
@@ -1082,10 +1153,10 @@ class ArchiveUpload(object):
def install_to_new(self):
"""install upload to NEW
- Install upload to NEW. This method does *not* handle regular uploads
+ Install upload to NEW. This method does B{not} handle regular uploads
to suites or policy queues.
- You need to have called the `check` method before calling this method.
+ You need to have called the C{check} method before calling this method.
"""
# Uploads to NEW are special as we don't have overrides.
assert len(self.reject_reasons) == 0
diff --git a/daklib/checks.py b/daklib/checks.py
index 260eb18..06626fd 100644
--- a/daklib/checks.py
+++ b/daklib/checks.py
@@ -20,14 +20,14 @@
"""module provided pre-acceptance tests
-Please read the documentation for the `Check` class for the interface.
+Please read the documentation for the L{Check} class for the interface.
"""
from daklib.config import Config
-from .dbconn import *
+from daklib.dbconn import *
import daklib.dbconn as dbconn
-from .regexes import *
-from .textutils import fix_maintainer, ParseMaintError
+from daklib.regexes import *
+from daklib.textutils import fix_maintainer, ParseMaintError
import daklib.lintian as lintian
import daklib.utils as utils
@@ -48,37 +48,37 @@ class Reject(Exception):
class Check(object):
"""base class for checks
- checks are called by daklib.archive.ArchiveUpload. Failing tests should
- raise a `daklib.checks.Reject` exception including a human-readable
+ checks are called by L{daklib.archive.ArchiveUpload}. Failing tests should
+ raise a L{daklib.checks.Reject} exception including a human-readable
description why the upload should be rejected.
"""
def check(self, upload):
"""do checks
- Args:
- upload (daklib.archive.ArchiveUpload): upload to check
+ @type upload: L{daklib.archive.ArchiveUpload}
+ @param upload: upload to check
- Raises:
- daklib.checks.Reject
+ @raise daklib.checks.Reject: upload should be rejected
"""
raise NotImplemented
def per_suite_check(self, upload, suite):
"""do per-suite checks
- Args:
- upload (daklib.archive.ArchiveUpload): upload to check
- suite (daklib.dbconn.Suite): suite to check
+ @type upload: L{daklib.archive.ArchiveUpload}
+ @param upload: upload to check
- Raises:
- daklib.checks.Reject
+ @type suite: L{daklib.dbconn.Suite}
+ @param suite: suite to check
+
+ @raise daklib.checks.Reject: upload should be rejected
"""
raise NotImplemented
@property
def forcable(self):
"""allow to force ignore failing test
- True if it is acceptable to force ignoring a failing test,
- False otherwise
+ C{True} if it is acceptable to force ignoring a failing test,
+ C{False} otherwise
"""
return False
diff --git a/daklib/fstransactions.py b/daklib/fstransactions.py
index f76a4bc..33f59c8 100644
--- a/daklib/fstransactions.py
+++ b/daklib/fstransactions.py
@@ -123,16 +123,22 @@ class FilesystemTransaction(object):
self.actions = []
def copy(self, source, destination, link=True, symlink=False, mode=None):
- """copy `source` to `destination`
+ """copy C{source} to C{destination}
- Args:
- source (str): source file
- destination (str): destination file
+ @type source: str
+ @param source: source file
- Kwargs:
- link (bool): Try hardlinking, falling back to copying.
- symlink (bool): Create a symlink instead
- mode (int): Permissions to change `destination` to.
+ @type destination: str
+ @param destination: destination file
+
+ @type link: bool
+ @param link: try hardlinking, falling back to copying
+
+ @type symlink: bool
+ @param symlink: create a symlink instead of copying
+
+ @type mode: int
+ @param mode: permissions to change C{destination} to
"""
if isinstance(mode, str) or isinstance(mode, unicode):
mode = int(mode, 8)
@@ -140,37 +146,38 @@ class FilesystemTransaction(object):
self.actions.append(_FilesystemCopyAction(source, destination, link=link, symlink=symlink, mode=mode))
def move(self, source, destination, mode=None):
- """move `source` to `destination`
+ """move C{source} to C{destination}
+
+ @type source: str
+ @param source: source file
- Args:
- source (str): source file
- destination (str): destination file
+ @type destination: str
+ @param destination: destination file
- Kwargs:
- mode (int): Permissions to change `destination` to.
+ @type mode: int
+ @param mode: permissions to change C{destination} to
"""
self.copy(source, destination, link=True, mode=mode)
self.unlink(source)
def unlink(self, path):
- """unlink `path`
+ """unlink C{path}
- Args:
- path (str): file to unlink
+ @type path: str
+ @param path: file to unlink
"""
self.actions.append(_FilesystemUnlinkAction(path))
def create(self, path, mode=None):
- """create `filename` and return file handle
+ """create C{filename} and return file handle
- Args:
- filename (str): file to create
+ @type filename: str
+ @param filename: file to create
- Kwargs:
- mode (int): Permissions for the new file
+ @type mode: int
+ @param mode: permissions for the new file
- Returns:
- file handle of the new file
+ @return: file handle of the new file
"""
if isinstance(mode, str) or isinstance(mode, unicode):
mode = int(mode, 8)
diff --git a/daklib/policy.py b/daklib/policy.py
index c989f1f..78d58d6 100644
--- a/daklib/policy.py
+++ b/daklib/policy.py
@@ -29,31 +29,36 @@ import tempfile
class UploadCopy(object):
"""export a policy queue upload
- This class can be used in a with-statements:
+ This class can be used in a with-statement::
with UploadCopy(...) as copy:
...
Doing so will provide a temporary copy of the upload in the directory
- given by the `directory` attribute. The copy will be removed on leaving
+ given by the C{directory} attribute. The copy will be removed on leaving
the with-block.
-
- Args:
- upload (daklib.dbconn.PolicyQueueUpload)
"""
def __init__(self, upload):
+ """initializer
+
+ @type upload: L{daklib.dbconn.PolicyQueueUpload}
+ @param upload: upload to handle
+ """
+
self.directory = None
self.upload = upload
def export(self, directory, mode=None, symlink=True):
"""export a copy of the upload
- Args:
- directory (str)
+ @type directory: str
+ @param directory: directory to export to
- Kwargs:
- mode (int): permissions to use for the copied files
- symlink (bool): use symlinks instead of copying the files (default: True)
+ @type mode: int
+ @param mode: permissions to use for the copied files
+
+ @type symlink: bool
+ @param symlink: use symlinks instead of copying the files
"""
with FilesystemTransaction() as fs:
source = self.upload.source
@@ -103,9 +108,10 @@ class PolicyQueueUploadHandler(object):
def __init__(self, upload, session):
"""initializer
- Args:
- upload (daklib.dbconn.PolicyQueueUpload): upload to process
- session: database session
+ @type upload: L{daklib.dbconn.PolicyQueueUpload}
+ @param upload: upload to process
+
+ @param session: database session
"""
self.upload = upload
self.session = session
@@ -169,8 +175,8 @@ class PolicyQueueUploadHandler(object):
def reject(self, reason):
"""mark upload as rejected
- Args:
- reason (str): reason for the rejection
+ @type reason: str
+ @param reason: reason for the rejection
"""
fn1 = 'REJECT.{0}'.format(self._changes_prefix)
assert re_file_safe.match(fn1)
@@ -190,8 +196,8 @@ class PolicyQueueUploadHandler(object):
def get_action(self):
"""get current action
- Returns:
- string giving the current action, one of 'ACCEPT', 'ACCEPTED', 'REJECT'
+ @rtype: str
+ @return: string giving the current action, one of 'ACCEPT', 'ACCEPTED', 'REJECT'
"""
changes_prefix = self._changes_prefix
@@ -206,18 +212,19 @@ class PolicyQueueUploadHandler(object):
def missing_overrides(self, hints=None):
"""get missing override entries for the upload
- Kwargs:
- hints (list of dict): suggested hints for new overrides in the same
- format as the return value
-
- Returns:
- list of dicts with the following keys:
- package: package name
- priority: default priority (from upload)
- section: default section (from upload)
- component: default component (from upload)
- type: type of required override ('dsc', 'deb' or 'udeb')
- All values are strings.
+ @type hints: list of dict
+ @param hints: suggested hints for new overrides in the same format as
+ the return value
+
+ @return: list of dicts with the following keys:
+
+ - package: package name
+ - priority: default priority (from upload)
+ - section: default section (from upload)
+ - component: default component (from upload)
+ - type: type of required override ('dsc', 'deb' or 'udeb')
+
+ All values are strings.
"""
# TODO: use Package-List field
missing = []
diff --git a/daklib/upload.py b/daklib/upload.py
index 5c19478..b0baf8c 100644
--- a/daklib/upload.py
+++ b/daklib/upload.py
@@ -17,7 +17,7 @@
"""module to handle uploads not yet installed to the archive
This module provides classes to handle uploads not yet installed to the
-archive. Central is the `Changes` class which represents a changes file.
+archive. Central is the L{Changes} class which represents a changes file.
It provides methods to access the included binary and source packages.
"""
@@ -25,8 +25,9 @@ import apt_inst
import apt_pkg
import os
import re
-from .gpg import SignedFile
-from .regexes import *
+
+from daklib.gpg import SignedFile
+from daklib.regexes import *
class InvalidChangesException(Exception):
pass
@@ -54,35 +55,52 @@ class InvalidFilenameException(Exception):
class HashedFile(object):
"""file with checksums
-
- Attributes:
- filename (str): name of the file
- size (long): size in bytes
- md5sum (str): MD5 hash in hexdigits
- sha1sum (str): SHA1 hash in hexdigits
- sha256sum (str): SHA256 hash in hexdigits
- section (str): section or None
- priority (str): priority or None
"""
def __init__(self, filename, size, md5sum, sha1sum, sha256sum, section=None, priority=None):
self.filename = filename
+ """name of the file
+ @type: str
+ """
+
self.size = size
+ """size in bytes
+ @type: long
+ """
+
self.md5sum = md5sum
+ """MD5 hash in hexdigits
+ @type: str
+ """
+
self.sha1sum = sha1sum
+ """SHA1 hash in hexdigits
+ @type: str
+ """
+
self.sha256sum = sha256sum
+ """SHA256 hash in hexdigits
+ @type: str
+ """
+
self.section = section
+ """section or C{None}
+ @type: str or C{None}
+ """
+
self.priority = priority
+ """priority or C{None}
+ @type: str of C{None}
+ """
def check(self, directory):
"""Validate hashes
Check if size and hashes match the expected value.
- Args:
- directory (str): directory the file is located in
+ @type directory: str
+ @param directory: directory the file is located in
- Raises:
- InvalidHashException: hash mismatch
+ @raise InvalidHashException: hash mismatch
"""
path = os.path.join(directory, self.filename)
fh = open(path, 'r')
@@ -108,15 +126,17 @@ class HashedFile(object):
def parse_file_list(control, has_priority_and_section):
"""Parse Files and Checksums-* fields
- Args:
- control (dict-like): control file to take fields from
- has_priority_and_section (bool): Files include section and priority (as in .changes)
+ @type control: dict-like
+ @param control: control file to take fields from
+
+ @type has_priority_and_section: bool
+ @param has_priority_and_section: Files field include section and priority
+ (as in .changes)
- Raises:
- InvalidChangesException: missing fields or other grave errors
+ @raise InvalidChangesException: missing fields or other grave errors
- Returns:
- dictonary mapping filenames to `daklib.upload.HashedFile` objects
+ @rtype: dict
+ @return: dict mapping filenames to L{daklib.upload.HashedFile} objects
"""
entries = {}
@@ -172,32 +192,28 @@ def parse_file_list(control, has_priority_and_section):
class Changes(object):
"""Representation of a .changes file
-
- Attributes:
- architectures (list of str): list of architectures included in the upload
- binaries (list of daklib.upload.Binary): included binary packages
- binary_names (list of str): names of included binary packages
- byhand_files (list of daklib.upload.HashedFile): included byhand files
- bytes (int): total size of files included in this upload in bytes
- changes (dict-like): dict to access fields of the .changes file
- closed_bugs (list of str): list of bugs closed by this upload
- directory (str): directory the .changes is located in
- distributions (list of str): list of target distributions for the upload
- filename (str): name of the .changes file
- files (dict): dict mapping filenames to daklib.upload.HashedFile objects
- path (str): path to the .changes files
- primary_fingerprint (str): fingerprint of the PGP key used for the signature
- source (daklib.upload.Source or None): included source
- valid_signature (bool): True if the changes has a valid signature
"""
def __init__(self, directory, filename, keyrings, require_signature=True):
if not re_file_safe.match(filename):
raise InvalidChangesException('{0}: unsafe filename'.format(filename))
+
self.directory = directory
+ """directory the .changes is located in
+ @type: str
+ """
+
self.filename = filename
+ """name of the .changes file
+ @type: str
+ """
+
data = open(self.path).read()
self._signed_file = SignedFile(data, keyrings, require_signature)
self.changes = apt_pkg.TagSection(self._signed_file.contents)
+ """dict to access fields of the .changes file
+ @type: dict-like
+ """
+
self._binaries = None
self._source = None
self._files = None
@@ -206,26 +222,44 @@ class Changes(object):
@property
def path(self):
+ """path to the .changes file
+ @type: str
+ """
return os.path.join(self.directory, self.filename)
@property
def primary_fingerprint(self):
+ """fingerprint of the key used for signing the .changes file
+ @type: str
+ """
return self._signed_file.primary_fingerprint
@property
def valid_signature(self):
+ """C{True} if the .changes has a valid signature
+ @type: bool
+ """
return self._signed_file.valid
@property
def architectures(self):
+ """list of architectures included in the upload
+ @type: list of str
+ """
return self.changes['Architecture'].split()
@property
def distributions(self):
+ """list of target distributions for the upload
+ @type: list of str
+ """
return self.changes['Distribution'].split()
@property
def source(self):
+ """included source or C{None}
+ @type: L{daklib.upload.Source} or C{None}
+ """
if self._source is None:
source_files = []
for f in self.files.itervalues():
@@ -237,6 +271,9 @@ class Changes(object):
@property
def binaries(self):
+ """included binary packages
+ @type: list of L{daklib.upload.Binary}
+ """
if self._binaries is None:
binaries = []
for f in self.files.itervalues():
@@ -247,6 +284,9 @@ class Changes(object):
@property
def byhand_files(self):
+ """included byhand files
+ @type: list of L{daklib.upload.HashedFile}
+ """
byhand = []
for f in self.files.itervalues():
@@ -260,35 +300,47 @@ class Changes(object):
@property
def binary_names(self):
+ """names of included binary packages
+ @type: list of str
+ """
return self.changes['Binary'].split()
@property
def closed_bugs(self):
+ """bugs closed by this upload
+ @type: list of str
+ """
return self.changes.get('Closes', '').split()
@property
def files(self):
+ """dict mapping filenames to L{daklib.upload.HashedFile} objects
+ @type: dict
+ """
if self._files is None:
self._files = parse_file_list(self.changes, True)
return self._files
@property
def bytes(self):
+ """total size of files included in this upload in bytes
+ @type: number
+ """
count = 0
for f in self.files.itervalues():
count += f.size
return count
def __cmp__(self, other):
- """Compare two changes packages
+ """compare two changes files
We sort by source name and version first. If these are identical,
we sort changes that include source before those without source (so
that sourceful uploads get processed first), and finally fall back
to the filename (this should really never happen).
- Returns:
- -1 if self < other, 0 if self == other, 1 if self > other
+ @rtype: number
+ @return: n where n < 0 if self < other, n = 0 if self == other, n > 0 if self > other
"""
ret = cmp(self.changes.get('Source'), other.changes.get('Source'))
@@ -313,25 +365,25 @@ class Changes(object):
class Binary(object):
"""Representation of a binary package
-
- Attributes:
- component (str): component name
- control (dict-like): dict to access fields in DEBIAN/control
- hashed_file (HashedFile): HashedFile object for the .deb
"""
def __init__(self, directory, hashed_file):
self.hashed_file = hashed_file
+ """file object for the .deb
+ @type: HashedFile
+ """
path = os.path.join(directory, hashed_file.filename)
data = apt_inst.DebFile(path).control.extractdata("control")
+
self.control = apt_pkg.TagSection(data)
+ """dict to access fields in DEBIAN/control
+ @type: dict-like
+ """
@property
def source(self):
- """Get source package name and version
-
- Returns:
- tuple containing source package name and version
+ """get tuple with source package name and version
+ @type: tuple of str
"""
source = self.control.get("Source", None)
if source is None:
@@ -346,10 +398,8 @@ class Binary(object):
@property
def type(self):
- """Get package type
-
- Returns:
- String with the package type ('deb' or 'udeb')
+ """package type ('deb' or 'udeb')
+ @type: str
"""
match = re_file_binary.match(self.hashed_file.filename)
if not match:
@@ -358,6 +408,9 @@ class Binary(object):
@property
def component(self):
+ """component name
+ @type: str
+ """
fields = self.control['Section'].split('/')
if len(fields) > 1:
return fields[0]
@@ -365,18 +418,13 @@ class Binary(object):
class Source(object):
"""Representation of a source package
-
- Attributes:
- component (str): guessed component name. Might be wrong!
- dsc (dict-like): dict to access fields in the .dsc file
- hashed_files (list of daklib.upload.HashedFile): list of source files (including .dsc)
- files (dict): dictonary mapping filenames to HashedFile objects for
- additional source files (not including .dsc)
- primary_fingerprint (str): fingerprint of the PGP key used for the signature
- valid_signature (bool): True if the dsc has a valid signature
"""
def __init__(self, directory, hashed_files, keyrings, require_signature=True):
self.hashed_files = hashed_files
+ """list of source files (including the .dsc itself)
+ @type: list of L{HashedFile}
+ """
+
self._dsc_file = None
for f in hashed_files:
if re_file_dsc.match(f.filename):
@@ -388,24 +436,46 @@ class Source(object):
data = open(dsc_file_path, 'r').read()
self._signed_file = SignedFile(data, keyrings, require_signature)
self.dsc = apt_pkg.TagSection(self._signed_file.contents)
+ """dict to access fields in the .dsc file
+ @type: dict-like
+ """
+
self._files = None
@property
def files(self):
+ """dict mapping filenames to L{HashedFile} objects for additional source files
+
+ This list does not include the .dsc itself.
+
+ @type: dict
+ """
if self._files is None:
self._files = parse_file_list(self.dsc, False)
return self._files
@property
def primary_fingerprint(self):
+ """fingerprint of the key used to sign the .dsc
+ @type: str
+ """
return self._signed_file.primary_fingerprint
@property
def valid_signature(self):
+ """C{True} if the .dsc has a valid signature
+ @type: bool
+ """
return self._signed_file.valid
@property
def component(self):
+ """guessed component name
+
+ Might be wrong. Don't rely on this.
+
+ @type: str
+ """
if 'Section' not in self.dsc:
return 'main'
fields = self.dsc['Section'].split('/')
diff --git a/daklib/utils.py b/daklib/utils.py
index cd5eb79..4ee00a1 100644
--- a/daklib/utils.py
+++ b/daklib/utils.py
@@ -1550,7 +1550,6 @@ def get_packages_from_ftp(root, suite, component, architecture):
@rtype: TagFile
@return: apt_pkg class containing package data
-
"""
filename = "%s/dists/%s/%s/binary-%s/Packages.gz" % (root, suite, component, architecture)
(fd, temp_file) = temp_filename()
@@ -1576,15 +1575,20 @@ def deb_extract_control(fh):
################################################################################
def mail_addresses_for_upload(maintainer, changed_by, fingerprint):
- """Mail addresses to contact for an upload
+ """mail addresses to contact for an upload
+
+ @type maintainer: str
+ @param maintainer: Maintainer field of the .changes file
- Args:
- maintainer (str): Maintainer field of the changes file
- changed_by (str): Changed-By field of the changes file
- fingerprint (str): Fingerprint of the PGP key used to sign the upload
+ @type changed_by: str
+ @param changed_by: Changed-By field of the .changes file
- Returns:
- List of RFC 2047-encoded mail addresses to contact regarding this upload
+ @type fingerprint: str
+ @param fingerprint: fingerprint of the key used to sign the upload
+
+ @rtype: list of str
+ @return: list of RFC 2047-encoded mail addresses to contact regarding
+ this upload
"""
addresses = [maintainer]
if changed_by != maintainer:
@@ -1600,14 +1604,16 @@ def mail_addresses_for_upload(maintainer, changed_by, fingerprint):
################################################################################
def call_editor(text="", suffix=".txt"):
- """Run editor and return the result as a string
+ """run editor and return the result as a string
+
+ @type text: str
+ @param text: initial text
- Kwargs:
- text (str): initial text
- suffix (str): extension for temporary file
+ @type suffix: str
+ @param suffix: extension for temporary file
- Returns:
- string with the edited text
+ @rtype: str
+ @return: string with the edited text
"""
editor = os.environ.get('VISUAL', os.environ.get('EDITOR', 'vi'))
tmp = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
--
1.7.2.5
Reply to: