Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
changelog.Debian.gz	1.5 KB	-rw-r--r--
copyright	5.92 KB	-rw-r--r--
pysvn.html	3.67 KB	-rw-r--r--
pysvn_prog_guide.html	9.66 KB	-rw-r--r--
pysvn_prog_ref.html	120.63 KB	-rw-r--r--
pysvn_prog_ref.js	2.11 KB	-rw-r--r--

Code Editor : pysvn_prog_ref.html

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<!--

====================================================================
 Copyright (c) 2004-2020 Barry A. Scott.  All rights reserved.

This software is licensed as described in the file LICENSE.txt,
 which you should have received as part of this distribution.

====================================================================

-->
<head>
<meta http-equiv="Content-Type" content="text/html; utf-8" />
<title>pysvn - Programmer's reference</title>
<link rev="made" href="mailto:barry@barrys-emacs.org" />
<style type="text/css">
h1, h2, h3, h4 {color: #000099; background-color: lightskyblue}
pre     {color: #0000cc; background-color: #dddddd; position: relative; left: 40px; margin-right: 80px;
        border-style: solid; border-color: black; border-width: thin}
table   {position: relative; left: 40px; margin-right: 80px;
        border-style: solid; border-color: black; border-width: thin}
span.button {border: black 1px solid; background-color: #cccccc; cursor: default;
        padding: 4px; margin: 4px;}

</style>

<p>This programmer's reference gives complete and detailed infomation on
the pysvn API.
</p>
<p>The <a href="pysvn_prog_guide.html">pysvn Programmer's Guide</a>   
gives an tutorial introduction to the pysvn module.
</p>

<h2>pysvn features and feature testing</h2>

<p>This document covers pysvn version 1.7. Features offered by pysvn
depend on the version of SVN that is being used. Full functionality is
only available with SVN 1.6.0 or later.
</p>
<p>Click one of the buttons below to show the pysvn API as supported
by a particular version of the SVN.</p>
<div id="buttons_work" style="display: none">
<p>
<span class="button" onclick='changeDisplay( 1009000 )'>Show SVN 1.14.0 API</span>
<span class="button" onclick='changeDisplay( 1009000 )'>Show SVN 1.13.0 API</span>
<span class="button" onclick='changeDisplay( 1009000 )'>Show SVN 1.12.0 API</span>
<span class="button" onclick='changeDisplay( 1009000 )'>Show SVN 1.11.0 API</span>
<span class="button" onclick='changeDisplay( 1009000 )'>Show SVN 1.10.0 API</span>
</p>
<p>
<span class="button" onclick='changeDisplay( 1009000 )'>Show SVN 1.9.0 API</span>
<span class="button" onclick='changeDisplay( 1008000 )'>Show SVN 1.8.0 API</span>
<span class="button" onclick='changeDisplay( 1007000 )'>Show SVN 1.7.0 API</span>
<span class="button" onclick='changeDisplay( 1006000 )'>Show SVN 1.6.0 API</span>
<span class="button" onclick='changeDisplay( 1005000 )'>Show SVN 1.5.0 API</span>
</p>
<p>
<span class="button" onclick='changeDisplay( 1004000 )'>Show SVN 1.4.0 API</span>
<span class="button" onclick='changeDisplay( 1003000 )'>Show SVN 1.3.0 API</span>
<span class="button" onclick='changeDisplay( 1002000 )'>Show SVN 1.2.0 API</span>
<span class="button" onclick='changeDisplay( 1001000 )'>Show SVN 1.1.0 API</span>
</p>
<div style="margin: 4px">
<form>
<input name="visual_style" value="hilite" type="radio" checked="checked" onclick='changeVisual( "hilite")'>Hilite unsupported</input>
<input name="visual_style" value="hide" type="radio" onclick='changeVisual("hide")'>Hide unsupported</input>
</form>
</div>
</div>
<div id="buttons_broken" style="display: block">
Sorry you browser does not support the show API buttons. Try viewing this page in FireFox.
</div>
<p>
Showing the PySVN API supported by SVN <span id="version_shown">1.6.0</span>.
Unsupported parts of the API are show like: <span class="svn_example">This</span>.
</p>
<p>The recommended way to test for a feature is to use the python 
hasattr() builtin. Working out what is and is not support from the
version number information is quite complex and unnessesary. For
example to test for lock and unlock support:
</p>
<pre>
client = pysvn.Client()
if hasattr( client, 'lock' ):
    # use lock
</pre>

<h2><a name="pysvn_module">pysvn module</a></h2>

<p>The pysvn module has the following variables:
</p>

<ul>
<li>pysvn.copyright - the pysvn copyright string</li>
<li>pysvn.version - the pysvn version as a tuple,
    (major, minor, patch, build)</li>
<li>pysvn.svn_version - subversion version as a tuple
    (major, minor, micro, tag)</li>
</ul>

<p>The pysvn module has six classes:
</p>

<ul>
<li><a href="#pysvn_client">Client</a> - the subversion client interface</li>
<li><a href="#pysvn_transaction">Transaction</a> - the subversion transaction interface</li>
<li><a href="#pysvn_revision">Revision</a> - subversion revision objects</li>
<li><a href="#pysvn_clienterror">ClientError</a> - Exception class raised by client commands on error</li>
<li><a href="#pysvn_status">PysvnStatus</a> - subversion status object</li>
<li><a href="#pysvn_entry">PysvnEntry</a> - subversion entry object</li>
</ul>

<p>The following enumerations are provided:
</p>

<ul>
<li><a href="#pysvn_opt_revision_kind">opt_revision_kind</a> - kinds of Revision object</li>
<li><a href="#pysvn_wc_notify_action">wc_notify_action</a> - see Client.callback_notify</li>
<li><a href="#pysvn_wc_status_kind">wc_status_kind</a> - see Client.status()</li>
<li><a href="#pysvn_wc_schedule">wc_schedule</a> - see Client.status()</li>
<li><a href="#pysvn_wc_merge_outcome">wc_merge_outcome</a> - see Client.Merge()</li>
<li><a href="#pysvn_wc_notify_state">wc_notify_state</a> - see Client.callback_notify</li>
<li><a href="#pysvn_node_kind">node_kind</a> - see Client.status() and Client.ls()</li>
<li><a href="#pysvn_depth">depth</a> - replacement for recurse</li>
</ul>

<p>Use python builtin dir() to list all available values in an enumeration:
</p>

<pre>
    print dir( pysvn.wc_notify_action )
</pre>

<h2><a name="pysvn_client"><a href="#pysvn_module">pysvn</a>.Client - Subversion client interface</a></h2>

<p>Interface summary:
</p>

<pre>
client = pysvn.Client()
client = pysvn.Client( config_dir )
</pre>

<p>The default subversion configuration directory is used if the
config_dir is omitted or set to ''.
</p>
<p>The configuration directory is automatically created if it is
missing.
</p>
<p>A Client object can only be used on one thread at a time. If
two threads attempt to call methods of Client at the same time
one of the threads will get a pysvn.ClientError exception with
the value 'client in use on another thread'.
</p>

<table border="0" cellspacing="0" cellpadding="4" >
<tr>
<td><a href="#pysvn_client_variables">Variables</a></td>
<td bgcolor="#e0e0e0"><a href="#pysvn_client_callbacks">Callbacks</a></td>
<td><a href="#pysvn_client_methods">Methods</a></td>
</tr>
</table>

<h3><a name="pysvn_client_variables">Client variables</a></h3>

<p><a href="#pysvn_client_exception_style">exception_style</a> allows you to control the style of exception raised by pysvn.
</p>

<p><a href="#pysvn_client_commit_info_style">commit_info_style</a> allows you to control the style of commit_info returned by pysvn.
</p>

<h4><a name="pysvn_client_exception_style"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.exception_style</a></h4>
<p>exception_style is used to control how pysvn raises <a href="#pysvn_clienterror">ClientError</a>
exceptions.
</p>
<p>The default value, 0, makes pysvn raise exceptions as it did prior
to pysvn 1.1.2.
</p>
<p>exception_style can be set to 0 or 1, see <a href="#pysvn_clienterror">ClientError</a>
for details of effect of the style on the exception raised.
</p>

<h4><a name="pysvn_client_commit_info_style"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.commit_info_style</a></h4>
<p>commit_info_style is used to control how pysvn return commit information.
</p>
<p>commit_info_style can be set to 0,  1 or 2.
The default value, 0, makes pysvn return only the commit revision.
</p>

<p>When set to 1 pysvn returns a dictionary of commit information including date, author, revision and post_commit_err.
</p>

<p>When set to 2 pysvn returns a list of dictionaries of commit information including date, author, revision and post_commit_err.
</p>

<h3><a name="pysvn_client_callbacks">Client callbacks</a></h3>

<p>pysvn uses callback functions to allow for realtime feedback
and credential handling.
</p>
<p><a href="#pysvn_client_callback_cancel">callback_cancel</a> allows you to cancel a long running subversion command.
</p>
<p><a href="#pysvn_client_callback_notify">callback_notify</a> gives feedback as commands runs.
</p>
<p><a href="#pysvn_client_callback_get_log_message">callback_get_log_message</a> is called when a log message is required.
</p>
<p><a href="#pysvn_client_callback_get_login">callback_get_login</a> is called to get a username and password to access a repository.
</p>
<p><a href="#pysvn_client_callback_ssl_server_trust_prompt">callback_ssl_server_trust_prompt</a> is called when using HTTPS to a server whoes certificate needs is trust verifing.
</p>
<p><a href="#pysvn_client_callback_conflict_resolver">callback_conflict_resolver</a> is called to handle conflicts.
</p>
<p>It is possible to use the Client object without setting up any
calls backs. Make sure that all nessesary usernames, passwords and
SSL certificate information are stored in the subversion
configuration directory.
</p>

<h4><a name="pysvn_client_callback_cancel"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_cancel</a></h4>

<pre>
import pysvn

cancel_command = False
def cancel():
    return cancel_command

client = pysvn.Client()
client.callback_cancel = cancel
</pre>

<p>The callback_cancel function is called frequently during long
running commands. Return True to cause the command to cancel,
return False to allow the command to continue.
</p>

<h4><a name="pysvn_client_callback_get_log_message"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_get_log_message</a></h4>
<pre>
import pysvn

log_message = "reason for change"
def get_log_message():
    return rc, log_message

client = pysvn.Client()
client.callback_get_log_message = get_log_message
</pre>
<p>The callback_get_log_message is called when a log message is
required to complete the current command. Return the True in rc
and a log message as a string. Returning False in rc will cause
the command to be cancelled. An empty log_message is not allowed
and may cause the command to be cancelled.
</p>

<p>Unicode strings cannot be handled. If you have a unicode string,
convert it to UTF-8.
</p>

<h4><a name="pysvn_client_callback_get_login"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_get_login</a></h4>
<pre>
import pysvn

def get_login( realm, username, may_save ):
    return retcode, username, password, save

client = pysvn.Client()
client.callback_get_login = get_login
</pre>

<p>callback_get_login is called each time subversion needs a 
username and password in the realm to access a repository and
has no cached credentials.
</p>
<p>The may_save parameter is true if subversion is willing to
save the answers returned by the callback_get_login function.
</p>
<p>pysvn expect the callback_get_login to return a tuple of
four values (retcode, username, password, save).
</p>
<ul>
<li>retcode - boolean, False if no username and password are
  available. True if subversion is to use the username and password.</li>
<li>username - string, the username to use</li>
<li>password - string, the password to use</li>
<li>save - boolean, return True if you want subversion to remember
  the username and password in the configuration directory.
  return False to prevent saving the username and password.</li>
</ul>

<h4><a name="pysvn_client_callback_notify"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_notify</a></h4>
<pre>
import pysvn

def notify( event_dict ):
    return

client = pysvn.Client()
client.callback_notify = notify
</pre>

<p>The callback_notify is called as a command runs each time an
interesting event occurs. The details of the event are passed to
the callback_notify function as a dictionary.
</p>
<p>The dictionary contains the following values:
</p>
<ul>
<li>path - the path of the action refers to</li>
<li>action - the events action, one of the <a href="#pysvn_wc_notify_action">wc_notify_action</a>
  values</li>
<li>kind - the node kind, one of the pysvn.<a href="#pysvn_node_kind">node_kind</a> values</li>
<li>mime_type - the mime type</li>
<li>content_state - one of the pysvn.<a href="#pysvn_wc_notify_state">wc_notify_state</a> values</li>
<li>prop_state - one of the pysvn.<a href="#pysvn_wc_notify_state">wc_notify_state</a> values</li>
<li>revision - a Revision object</li>
</ul>

<h4><a name="pysvn_client_callback_ssl_client_cert_password_prompt"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_ssl_client_cert_password_prompt</a></h4>
<pre>
import pysvn

def ssl_client_cert_password_prompt( realm, may_save ):
    return retcode, password, save

client = pysvn.Client()
client.callback_ssl_client_cert_password_prompt = ssl_client_cert_password_prompt
</pre>

<p>callback_ssl_client_cert_password_prompt is called each time
subversion needs a password in the realm to use a client
certificate and has no cached credentials.
</p>
<p>The may_save parameter is true if subversion is willing to save
the answers returned by the callback_ssl_client_cert_password_prompt
function.
</p>
<p>pysvn expect the callback_ssl_client_cert_password_prompt to
return a tuple of three values (retcode, password, save).
</p>
<ul>
<li>retcode - boolean, False if no password is available.
True if subversion is to use password.</li>
<li>password - string, the password to use</li>
<li>save - boolean, return True if you want subversion to remember
the password in the configuration directory. return False to
prevent saving the password.</li>
</ul>

<h4><a name="pysvn_client_callback_ssl_client_cert_prompt"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_ssl_client_cert_prompt</a></h4>
<pre>
import pysvn

def ssl_client_cert_prompt( realm, may_save ):
    return retcode, certfile, may_save

client = pysvn.Client()
client.callback_ssl_client_cert_prompt = ssl_client_cert_prompt
</pre>

<p>callback_ssl_client_cert_prompt is called each time subversion
needs a client certificate.
</p>
<p>pysvn expect the callback_ssl_client_cert_prompt to return a
tuple of three values (retcode, certfile, may_save).
</p>
<ul>
<li>retcode - boolean, False if no certificate is available.
True if subversion is to use the certificate.</li>
<li>certfile - string, the certfile to use</li>
</ul>

<h4><a name="pysvn_client_callback_ssl_server_prompt"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_ssl_server_prompt</a></h4>
<pre>
import pysvn

def ssl_server_prompt( ):
    return

client = pysvn.Client()
client.callback_ssl_server_prompt = ssl_server_prompt
</pre>

<p>NOT IMPLEMENTED - what it used for?
</p>

<h4><a name="pysvn_client_callback_ssl_server_trust_prompt"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_ssl_server_trust_prompt</a></h4>
<pre>
import pysvn

def ssl_server_trust_prompt( trust_dict ):
    return retcode, accepted_failures, save

client = pysvn.Client()
client.callback_ssl_server_trust_prompt = ssl_server_trust_prompt
</pre>

<p>The callback_ssl_server_trust_prompt is called each time an
HTTPS server presents a certificate and subversion is not sure
if it should be trusted. callback_ssl_server_trust_prompt is
called with information about the certificate in trust dict.
</p>

<ul>
<li>failures - int - a bitmask of failures - [What do these
  bits mean?]</li>
<li>hostname - string - the hostname the certificate was
  presented from</li>
<li>finger_print - string - certificate finger print</li>
<li>valid_from - string - valid from this ISO8601 date</li>
<li>valid_until - string - valid util this ISO8601 date</li>
<li>issuer_dname - stirng - the issued dname</li>
<li>realm - string - the realm</li>
</ul>

<p>pysvn expect the callback_ssl_server_trust_prompt to return
a tuple of three values (retcode, accepted_failures, save).
</p>
<ul>
<li>retcode - boolean, True if the ssl server is trusted, False if not trusted.</li>
<li>accepted_failures - int, the accepted failures allowed. Typically just return trust_dict["failures"].</li>
<li>save - boolean, return True if you want subversion to remember
  the certificate in the configuration directory. return False
  to prevent saving the certificate.</li>
</ul>

<h4><a name="pysvn_client_callback_conflict_resolver"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.callback_conflict_resolver</a></h4>
<pre>
import pysvn

def conflict_resolver( conflict_description ):
    return conflict_choice, merge_file, save_merged

client = pysvn.Client()
client.callback_conflict_resolver = conflict_resolver
</pre>

<p>The callback_conflict_resolver is called each time a conflict needs resolving.
It is passed the conflict_description and must return a conflict_choice, merge_file and save_merged.
</p>

<p>The members of the conflict_description dictionary are:</p>
<ul>
<li>path - string - The path that is in conflict (for a tree conflict, it is the victim)</li>
<li>node_kind - pysvn.node_kind - The node type of the path being operated on</li>
<li>kind - pysvn.conflict_kind - the sort of conflict being described</li>
<li>property_name - string or None - The name of the property whose conflict is being described.
     (Only if kind is 'property'; else undefined.)</li>
<li>is_binary - boolean - Whether svn thinks ('my' version of) path is a 'binary' file.
    (Only if kind is 'text', else undefined.)</li>
<li>mime_type - string or None - The svn:mime-type property of ('my' version of) path</li>
<li>action - pysvn.wc_conflict_action - the action being attempted on the conflicted node or property</li>
<li>reason - pysvn.wc_conflict_reason - The state of the target node or property, relative to its merge-left
   source, that is the reason for the conflict</li>
<li>base_file - string - common ancestor of the two files being merged</li>
<li>their_file - string - their version of the file</li>
<li>my_file - string - my locally-edited version of the file</li>
<li>merged_file - string - merged version; may contain conflict markers</li>
<li>operation - pysvn.wc_operation - the operation that exposed the conflict. Used only for tree conflicts</li>
<li>src_left_version - pysvn.wc_conflict_version - Info on the "merge-left source" or "older" version of incoming change</li>
<li>src_right_version - pysvn.wc_conflict_version - Info on the "merge-right source" or "their" version of incoming change</li>
</ul>

<ul>
<li>conflict_choice is one of the pysvn.wc_conflict_choice values</li>
<li>merge_file is a file name or None</li>
<li>save_merged is True or False</li>
</ul>

<h3><a name="pysvn_client_methods">Client methods</a></h3>

<table border="0" cellspacing="0" cellpadding="5">
<tr>
<td><a href="#pysvn_client_add">add</a></td>
<td><span class="svn_1005000"><a href="#pysvn_client_add_to_changelist">add_to_changelist</a></span></td>
<td><a href="#pysvn_client_annotate">annotate</a></td>
<td><span class="svn_1007000"><a href="#pysvn_client_annotate2">annotate2</a></span></td>
<td><a href="#pysvn_client_cat">cat</a></td>
<td><a href="#pysvn_client_checkin">checkin</a></td>
</tr>
<tr bgcolor="#e0e0e0">
<td><a href="#pysvn_client_checkout">checkout</a></td>
<td><a href="#pysvn_client_cleanup">cleanup</a></td>
<td><a href="#pysvn_client_copy">copy</a></td>
<td><span class="svn_1005000"><a href="#pysvn_client_copy2">copy2</a></span></td>
<td><a href="#pysvn_client_diff">diff</a></td>
<td><span class="svn_1001000"><a href="#pysvn_client_diff_peg">diff_peg</a></span></td>
</tr>
<tr>
<td><span class="svn_1004000"><a href="#pysvn_client_diff_summarize">diff_summarize</a></span></td>
<td><span class="svn_1004000"><a href="#pysvn_client_diff_summarize_peg">diff_summarize_peg</a></span></td>
<td><a href="#pysvn_client_export">export</a></td>
<td><span class="svn_1003000"><a href="#pysvn_client_get_adm_dir">get_adm_dir</a></span></td>
<td><a href="#pysvn_client_get_auth_cache">get_auth_cache</a></td>
<td><a href="#pysvn_client_get_auto_props">get_auto_props</a></td>
</tr>
<tr bgcolor="#e0e0e0">
<td><span class="svn_1005000"><a href="#pysvn_client_get_changelist">get_changelist</a></span></td>
<td><a href="#pysvn_client_get_default_password">get_default_password</a></td>
<td><a href="#pysvn_client_get_default_username">get_default_username</a></td>
<td><a href="#pysvn_client_get_interactive">get_interactive</a></td>
<td><a href="#pysvn_client_get_store_passwords">get_store_passwords</a></td>
<td><a href="#pysvn_client_import_">import_</a></td>
</tr>
<tr>
<td><a href="#pysvn_client_info">info</a></td>
<td><span class="svn_1003000"><a href="#pysvn_client_info2">info2</a></span></td>
<td><span class="svn_1003000"><a href="#pysvn_client_is_adm_dir">is_adm_dir</a></span></td>
<td><a href="#pysvn_client_is_url">is_url</a></td>
<td><span class="svn_1004000"><a href="#pysvn_client_list">list</a></span></td>
<td><a href="#pysvn_client_log">log</a></td>
</tr>
<tr bgcolor="#e0e0e0">
<td><span class="svn_1002000"><a href="#pysvn_client_lock">lock</a></span></td>
<td><a href="#pysvn_client_ls">ls</a></td>
<td><a href="#pysvn_client_merge">merge</a></td>
<td><span class="svn_1001000"><a href="#pysvn_client_merge_peg">merge_peg</a></span></td>
<td><span class="svn_1005000"><a href="#pysvn_client_merge_peg2">merge_peg2</a></span></td>
<td><span class="svn_1005000"><a href="#pysvn_client_merge_reintegrate">merge_peg2</a></span></td>
</tr>
<tr>
<td><a href="#pysvn_client_mkdir">mkdir</a></td>
<td><a href="#pysvn_client_move">move</a></td>
<td><span class="svn_1005000"><a href="#pysvn_client_move2">move2</a></span></td>
<td><span class="svn_1007000"><a href="#pysvn_client_patch">patch</a></span></td>
<td><a href="#pysvn_client_propdel">propdel</a></td>
<td><span class="svn_1007000"><a href="#pysvn_client_propdel_local">propdel_local</a></span></td>
</tr>
<tr bgcolor="#e0e0e0">
<td><span class="svn_1005000"><a href="#pysvn_client_propdel_remote">propdel_remote</a></span></td>
<td><a href="#pysvn_client_propget">propget</a></td>
<td><a href="#pysvn_client_proplist">proplist</a></td>
<td><a href="#pysvn_client_propset">propset</a></td>
<td><span class="svn_1007000"><a href="#pysvn_client_propset_local">propset_local</a></span></td>
<td><span class="svn_1007000"><a href="#pysvn_client_propset_remote">propset_remote</a></span></td>
</tr>
<tr>
<td><a href="#pysvn_client_relocate">relocate</a></td>
<td><a href="#pysvn_client_remove">remove</a></td>
<td><span class="svn_1005000"><a href="#pysvn_client_remove_from_changelists">remove_from_changelists</a></span></td>
<td><a href="#pysvn_client_resolved">resolved</a></td>
<td><a href="#pysvn_client_revert">revert</a></td>
<td><a href="#pysvn_client_revpropdel">revpropdel</a></td>
</tr>
<tr bgcolor="#e0e0e0">
<td><a href="#pysvn_client_revpropget">revpropget</a></td>
<td><a href="#pysvn_client_revproplist">revproplist</a></td>
<td><a href="#pysvn_client_revpropset">revpropset</a></td>
<td><span class="svn_1005000"><a href="#pysvn_client_root_url_from_path">root_url_from_path</a></span></td>
<td><span class="svn_1003000"><a href="#pysvn_client_set_adm_dir">set_adm_dir</a></span></td>
<td><a href="#pysvn_client_set_auth_cache">set_auth_cache</a></td>
</tr>
<tr>
<td><a href="#pysvn_client_set_auto_props">set_auto_props</a></td>
<td><a href="#pysvn_client_set_default_password">set_default_password</a></td>
<td><a href="#pysvn_client_set_default_username">set_default_username</a></td>
<td><a href="#pysvn_client_set_interactive">set_interactive</a></td>
<td><a href="#pysvn_client_set_store_passwords">set_store_passwords</a></td>
<td><a href="#pysvn_client_status2">status2</a></td>
</tr>
<tr bgcolor="#e0e0e0">
<td><a href="#pysvn_client_status">status</a></td>
<td><a href="#pysvn_client_switch">switch</a></td>
<td><span class="svn_1002000"><a href="#pysvn_client_unlock">unlock</a></span></td>
<td><a href="#pysvn_client_update">update</a></td>
<td><span class="svn_1007000"><a href="#pysvn_client_upgrade">upgrade</a></span></td>
<td><span class="svn_1009000"><a href="#pysvn_client_vacuum">vacuum</a></span></td>
</tr>
</table>

<div class="svn_1005000">
<h4><a name="pysvn_client_add_to_changelist"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.add_to_changelist</a></h4>
<pre>
add_to_changelist( path,
                   changelist,
                   depth=QQQ,
                   changelists=[] )
</pre>
<p>
TBD
</p>

<div class="svn_1005000">
<p>depth is one of the pysvn.depth enums.
</p>
</div>

</div>

<h4><a name="pysvn_client_add"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.add</a></h4>
<pre>
add( path,
     recurse=True<span class="svn_1001000">,
     force=False</span><span class="svn_1003000">,
     ignore=False</span><span class="svn_1005000">,
     depth=None,
     add_parents=False</span><span class="svn_1007000">,
     autoprops=False</span> )
add( [path,path],
     recurse=True<span class="svn_1001000">,
     force=False</span><span class="svn_1003000">,
     ignore=True</span><span class="svn_1005000">,
     depth=None,
     add_parents=False</span><span class="svn_1007000">,
     autoprops=True</span> )
</pre>
<p>
Schedules all the files or directories specfied in the paths
for addition to the repository. Set recurse to True to recursively
add a directory's children. <span class="svn_1001000">Set force to True to force
operation to run.</span> <span class="svn_1003000">Set ignore to False to
disregard default and svn:ignore property ignores.</span>
Files are added at the next checkin.
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
<p>Set add_parents True to have subversion create missing directories.</p>
</div>
<div class="svn_1007000">
<p>Set autoprops to False to prevent subversion from applying properties automatically.</p>
</div>

<h4><a name="pysvn_client_annotate"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.annotate</a></h4>
<pre>
file_annotation = \
annotate( url_or_path,
          revision_start=pysvn.Revision( opt_revision_kind.number, 0 ),
          revision_end=pysvn.Revision( opt_revision_kind.head )<span class="svn_1002000">,
          peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span> )
 )
</pre>
<p>Return the annotation for each line in the url_or_path from
revision_start to revision_end.
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>
<p>The file_annotation is a list of dictionaries. Each dictionary
contains:
</p>
<ul>
<li>author - string - the name of the author who last wrote the line</li>
<li>date - string - the date of the last change to the line</li>
<li>line - string - the text of the line</li>
<li>number - int - the line number</li>
<li>revision - pysvn.Revision - the revision that committed the line</li>
</ul>

<div class="svn_1007000">
<h4><a name="pysvn_client_annotate2"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.annotate2</a></h4>
<pre>
file_annotation = \
annotate2( url_or_path,
           revision_start=pysvn.Revision( opt_revision_kind.number, 0 ),
           revision_end=pysvn.Revision( opt_revision_kind.head )<span class="svn_1002000">,
           peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span> )
</pre>
<p>Return the annotation for each line in the url_or_path from
revision_start to revision_end.
</p>
<p>peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</p>

<p>The file_annotation is a list of dictionaries. Each dictionary
contains:
</p>
<ul>
<li>line - string - the text of the line</li>
<li>number - int - the line number</li>
<li>revision - pysvn.Revision - the revision that committed the line</li>
<li>local_change - boolean - true if the change was made locally</li>
<li>merged_revision - pysvn.Revsion or None - None if not merged otherwise revision of the merged line</li>
<li>merged_path - string or None - path of the merged line if merged</li>
<li>local_changed - boolean - If there is no blame information for this line, revision will be
    invalid and rev_props will be None. In this case local_change
    will be True if the reason there is no annotation information is that the line
    was modified locally. In all other cases local_change will be False.</li>
<li>merged_rev_props - not implemented yet</li>
</ul>
<p>
Note: To find the author and date of the lines in the annotation use
<a href="#pysvn_client_log">log()</a>.
</p>
</div>

<h4><a name="pysvn_client_cat"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.cat</a></h4>
<pre>
file_text = \
cat( url_or_path,
     revision=pysvn.Revision( opt_revision_kind.head )<span class="svn_1002000">,
     peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span>,<span class="svn_1009000">
     expand_keywords=false,
     get_props=false</span> )

<div class="svn_1009000">
file_text, props = \
cat( url_or_path,
     revision=pysvn.Revision( opt_revision_kind.head ),
     peg_revision=pysvn.Revision( opt_revision_kind.unspecified ),
     expand_keywords=False,
     get_props=True )
</div>
</pre>
<p>
Return the contents of url_or_path for the specified revision as
a string, file_text. 
</p>
<div class="svn_1009000">
<p>
When get_props is True the props of the file are returned in a dictionary.
</p>
</div>
<div class="svn_1002000">
<p>
peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</p>
</div>

<h4><a name="pysvn_client_checkin"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.checkin</a></h4>
<pre>
revision = \
checkin( path,
        log_message,
        recurse=True<span class="svn_1002000">,
        keep_locks=False</span><span class="svn_1005000">,
        depth,
        keep_changelist,
        changelists,
        revprops</span><span class="svn_1007000">,
        commit_as_operations=False</span><span class="svn_1008000">,
        include_file_externals=False,
        include_dir_externals=False</span> )
revision = \
checkin( [path,path],
        log_message,
        recurse=True<span class="svn_1002000">,
        keep_locks=False</span><span class="svn_1005000">,
        depth,
        keep_changelist,
        changelists,
        revprops</span><span class="svn_1007000">,
        commit_as_operations=False</span><span class="svn_1008000">,
        include_file_externals=False,
        include_dir_externals=False</span> )
</pre>
<p>
checkin the files in the path_list to the repository with the
specified log_message. Set recurse to True to recursively checkin
a directory's children with the same log message. <span class="svn_1002000"> Set
keep_locks to True to prevent locks in the path being unlocked.</span>
</p>
<p>checkin returns a pysvn.Revision containing the number of the
checked in revision.
</p>

<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
<p>
changelists is an array of string changelist
names, used as a restrictive filter on items that are committed;
that is, don't commit anything unless it's a member of one of those
changelists.  After the commit completes successfully, remove
changelist associations from the targets, unless
keep_changelists is set.  If changelists is
empty or None, no changelist filtering occurs.
</p>
<p>
If not None revprop is a list holding additional,
custom revision properties to be set on the new revision.
This list cannot contain any standard Subversion properties.
</p>
</div>

<div class="svn_1007000">
<p>
If commit_as_operations is set to False, when a copy is committed
all changes below the copy are always committed at the same time
(independent of the value of depth). If commit_as_operations is
True, changes to descendants are only committed if they are itself
included via depth and targets.
</p>
</div>
<div class="svn_1008000">
<p>
If include_file_externals and/or include_dir_externals are True,
also commit all file and/or dir externals (respectively) that are reached
by recursion, except for those externals which:</p>
<ul>
<li>have a fixed revision, or</li>
<li>come from a different repository root URL (dir externals).</li>
</ul>
<p>These flags affect only recursion; externals that directly appear in
targets are always included in the commit.</p>
</div>

<h4><a name="pysvn_client_checkout"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.checkout</a></h4>
<pre>
revision = \
checkout( url,
          path,
          recurse=True,
          revision=pysvn.Revision( opt_revision_kind.head )<span class="svn_1002000">,
          peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span><span class="svn_1002000">,
          ignore_externals=False</span><span class="svn_1005000">,
          allow_unver_obstructions=False,
          depth=None</span> )
</pre>
<p>
checkout the repository at url into the location specified by path.
Set recurse to True to recursively check out a directory's children.
Specify a revision to check out a particular version of the source
tree. <span class="svn_1002000">Set ignore_externals to True to ignore externals definitions.</span>
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision url is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>

<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<p>checkout returns a pysvn.Revision containing the number of the
checked out revision.
</p>
<p>Note: Subversion seems to return 0 rather then the actual revision.
Use a notify callback and record the revision reported for the 
<a href="#pysvn_module">pysvn</a>.wc_notify_action.update_completed event.
This is what the svn command does.
</p>

<h4><a name="pysvn_client_cleanup"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.cleanup</a></h4>
<pre>
cleanup( path<span cleanup="svn_1009000">,
         fix_recorded_timestamps=True,
         clear_dav_cache=True,
         vacuum_pristines=True,
         include_externals=False</span> )
</pre>
<p>
Clean up any locks in the working copy at path. Usually such
locks are the result of a failed or interrupted operation.
</p>

<div class="svn_1009000">
<p>
If break_locks is True, existing working copy locks at or below
dir_abspath are broken, otherwise a normal write lock is obtained.
</p>
<p>If fix_recorded_timestamps is True, this function fixes recorded
timestamps for unmodified files in the working copy, reducing comparision
time on future checks.
</p>
<p>If clear_dav_cache is True, the caching of DAV information for older
mod_dav served repositories is cleared. This clearing invalidates some
cached information used for pre-HTTPv2 repositories.
</p>
<p>If vacuum_pristines is True, and dir_abspath points to the working
copy root unreferenced files in the pristine store are removed.
</p>
<p>If include_externals is True, recurse into externals and clean
them up as well.
</p>
</div>

<h4><a name="pysvn_client_copy"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.copy</a></h4>
<pre>
copy( src_url_or_path,
      dest_url_or_path,
      src_revision=pysvn.Revision( opt_revision_kind.head )
      )
</pre>
<p>
Duplicate something in working copy or repos, remembering history.
The src_revision defaults to pysvn.Revision( opt_revision_kind.head )
if the src_path is a URL otherwise to
pysvn.Revision( opt_revision_kind.working ).
</p>
<p>src_url_or_path and dest_url_or_path can each be either a
working copy (WC) path or URL:
</p>
<ul>
<li>WC -&gt; WC:   copy and schedule for addition (with history)</li>
<li>WC -&gt; URL:  immediately commit a copy of WC to URL</li>
<li>URL -&gt; WC:   check out URL into WC, schedule for addition</li>
<li>URL -&gt; URL:  complete server-side copy; used to branch and tag</li>
</ul>
<p>If the destination is a URL the <a href="#pysvn_client_callback_get_log_message">client_get_log_message</a>
callback must be implemented to return a log message.
</p>

<div class="svn_1005000">
<h4><a name="pysvn_client_copy2"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.copy2</a></h4>
<pre>
copy2( sources,
       dest_url_or_path,
       copy_as_child=False,
       make_parents=False,
       revprops<span class="svn_1006000">,
       ignore_externals=False</span><span class="svn_1009000">,
       metadata_only=False,
       pin_externals=False,
       externals_to_pin=[(path_or_url, externals_description),...]</span> )
</pre>
<p>
Duplicate something in working copy or repos, remembering history.
The src_revision defaults to pysvn.Revision( opt_revision_kind.head )
if the src_path is a URL otherwise to
pysvn.Revision( opt_revision_kind.working ).
</p>

<p>sources is a list of tuples of (url_or_path, rev), you can ommit rev by passing (url_or_path,).
TBD better docs here.</p>

<p>revprops TBD</p>

<div class="svn_1006000">
<p>set ignore_externals to True to ignore externals.
</p>
</div>

<div class="svn_1009000">
<p>
If metadata_only is True and copying a file in a working copy,
everything in the metadata is updated as if the node is moved, but the
actual disk copy operation is not performed. This feature is useful for
clients that want to keep the working copy in sync while the actual working
copy is updated by some other task.
</p>
<p>
If pin_externals is set, pin URLs in copied externals definitions
to their current revision unless they were already pinned to a
particular revision. A pinned external uses a URL which points at a
fixed revision, rather than the HEAD revision. Externals in the copy
destination are pinned to either a working copy base revision or the
HEAD revision of a repository (as of the time the copy operation is
performed), depending on the type of the copy source:
</p>
<p>
If not None, externals_to_pin restricts pinning to a subset of externals.
It is a dictionary keyed by either a local absolute path or a URL at which
an svn:externals property is set. The dictionary contains externals description
each of which corresponds to a single line of an svn:externals definition.
</p>
<p>
Externals corresponding to
these items will be pinned, other externals will not be pinned.
If externals_to_pin is None then all externals are pinned.
If pin_externals is False then externals_to_pin is ignored.
</p>
</div>

<p>src_url_or_path and dest_url_or_path can each be either a
working copy (WC) path or URL:
<ul>
<li>WC  -&gt; WC:   copy and schedule for addition (with history)</li>
<li>WC  -&gt; URL:  immediately commit a copy of WC to URL</li>
<li>URL -&gt; WC:   check out URL into WC, schedule for addition</li>
<li>URL -&gt; URL:  complete server-side copy; used to branch and tag</li>
</ul>
</p>
<p>If the destination is a URL the <a href="#pysvn_client_callback_get_log_message">client_get_log_message</a>
callback must be implemented to return a log message.
</p>
</div>

<h4><a name="pysvn_client_diff"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.diff</a></h4>
<pre>
diff_text = \
diff( tmp_path,
      url_or_path,
      revision1=pysvn.Revision( opt_revision_kind.base ),
      url_or_path2=url_or_path,
      revision2=pysvn.Revision( opt_revision_kind.working ),
      recurse=True,
      ignore_ancestry=False,
      diff_deleted=True<span class="svn_1002000">,
      ignore_content_type=False</span><span class="svn_1003000">,
      header_encoding="",
      diff_options=[]</span><span class="svn_1005000">,
      depth=depth</span>,<span class="svn_1006000">,
      relative_to_dir=None,
      changelists=None</span><span class="svn_1007000">,
      show_copies_as_adds=False,
      use_git_diff_format=False</span><span class="svn_1008000">,
      diff_added=False,
      ignore_properties=False,
      properties_only=False</span> )
</pre>
<p>
Return the differences between revision1 of url_or_path
and revision2 of url_or_path2. diff_text is a string
containing the diff output.
</p>
<p>
diff uses tmp_path to form the filename when creating any temporary
files needed. The names are formed using tmp_path + unique_string + ".tmp".
For example tmp_path=/tmp/diff_prefix will create files like
/tmp/diff_prefix.tmp and /tmp/diff_prefix1.tmp.
</p>
<p><span class="svn_1002000">Diff output will not be generated for binary files, unless
ignore_content_type is true, in which case diffs will be shown
regardless of the content types.
</span>
</p>
<p><span class="svn_1003000">Generated headers are encoded using header_encoding.</span>
</p>
<p><span class="svn_1003000">The list of diff_options strings are passed to the external
diff program that subversion uses. Typical options are
-b (ignore space changes) and -w (ignore all white space).
The exact options that work depend on the version of subversion used
and its configuration.</span>
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<div class="svn_1006000">
<p> If relative_to_dir is not None, the original_path and
 modified_path will have the relative_to_dir stripped from the
 front of the respective paths.
</p>
<p>If relative_to_dir is not
 None but relative_to_dir is not a parent path of the target,
 an error is returned.
</p>
</div>
<div class="svn_1007000">
<p>
If show_copies_as_adds is True, then copied files will not be diffed
against their copyfrom source, and will appear in the diff output
in their entirety, as if they were newly added.
</p>
<p>
If use_git_diff_format is True, then the git's extended diff format
will be used.
</p>
</div>
<div class="svn_1008000">
<p>if diff_added is True show diff of added files.</p>
<p>if ignore_properties is True then ignore diff of properties.</p>
<p>if properties_only is True then only diff properties.</p>
</div>

<div class="svn_1001000">
<h4><a name="pysvn_client_diff_peg"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.diff_peg</a></h4>
<pre>
diff_text = \
diff_peg( tmp_path,
          url_or_path,
          peg_revision=pysvn.Revision( opt_revision_kind.unspecified ),
          revision_start=pysvn.Revision( opt_revision_kind.base ),
          revision_end=pysvn.Revision( opt_revision_kind.working ),
          recurse=True,
          ignore_ancestry=False,
          diff_deleted=True<span class="svn_1002000">,
          ignore_content_type=False</span><span class="svn_1003000">,
          header_encoding="",
          diff_options=[]</span><span class="svn_1005000">,
          depth=depth</span><span class="svn_1007000">,
          show_copies_as_adds=False,
          use_git_diff_format=False</span><span class="svn_1008000">,
          diff_added=False,
          ignore_properties=False,
          properties_only=False</span> )
</pre>
<p>
return the differences between two revisions of the url_or_path.
diff_text is a string containing the diff output.
</p>
<p>
diff uses tmp_path to form the filename when creating any temporary
files needed. The names are formed using tmp_path + unique_string + ".tmp".
For example tmp_path=/tmp/diff_prefix will create files like
/tmp/diff_prefix.tmp and /tmp/diff_prefix1.tmp.
</p>
<p>
Set recurse to True to recursively diff a directory's children.
diff_text is a string containing the diff.
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>
<p>peg_revision indicates in which revision url_or_path is valid.
If peg_revision.kind is opt_revision_kind.unspecified, then it
defaults to opt_revision_kind.head for URLs or
opt_revision_kind.working for WC targets.
</p>
<p><span class="svn_1002000">Diff output will not be generated for binary files, unless
ignore_content_type is true, in which case diffs will be shown
regardless of the content types.
</span>
</p>
<p><span class="svn_1003000">Generated headers are encoded using header_encoding.</span>
</p>
<p><span class="svn_1003000">The list of diff_options strings are passed to the external
diff program that subversion uses. Typical options are
-b (ignore space changes) and -w (ignore all white space).
The exact options that work depend on the version of subversion used
and its configuration.</span>
</p>
</div>
<div class="svn_1007000">
<p>
If show_copies_as_adds is True, then copied files will not be diffed
against their copyfrom source, and will appear in the diff output
in their entirety, as if they were newly added.
</p>
<p>
If use_git_diff_format is True, then the git's extended diff format
will be used.
</p>
</div>
<div class="svn_1008000">
<p>if diff_added is True show diff of added files.</p>
<p>if ignore_properties is True then ignore diff of properties.</p>
<p>if properties_only is True then only diff properties.</p>
</div>

<div class="svn_1004000">
<h4><a name="pysvn_client_diff_summarize"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.diff_summarize</a></h4>
<pre>
summary = \
diff_summarize( url_or_path1,
                revision1=pysvn.Revision( opt_revision_kind.base ),
                url_or_path2=url_or_path,
                revision2=pysvn.Revision( opt_revision_kind.working ),
                recurse=True,
                ignore_ancestry=False<span class="svn_1005000">,
                depth=depth</span> )
</pre>
<p>
Produce a diff summary which lists the changed items between
url_or_path1 revision1 and url_or_path2 revision2 without creating text
deltas. url_or_path1 and url_or_path2 can be either working-copy paths or URLs.
</p>
<p>
The function may report false positives if ignore_ancestry is False,
since a file might have been modified between two revisions, but still
have the same contents.
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>
</div>

<div class="svn_1004000">
<h4><a name="pysvn_client_diff_summarize_peg"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.diff_summarize_peg</a></h4>
<pre>
diff_text = \
diff_summarize_peg( url_or_path,
                    peg_revision=pysvn.Revision( opt_revision_kind.unspecified ),
                    revision_start=pysvn.Revision( opt_revision_kind.base ),
                    revision_end=pysvn.Revision( opt_revision_kind.working ),
                    recurse=True,
                    ignore_ancestry=False<span class="svn_1005000">,
                    depth=depth</span> )
</pre>
<p>
Produce a diff summary which lists the changed items between the
filesystem object url_or_path in peg revision peg_revision, as it
changed between revision_start and revision_end.  url_or_path can
be either a working-copy path or URL.
</p>
<p>
If peg_revision is opt_revision_unspecified, behave
identically to svn_client_diff_summarize(), using path for both
of that function's url_or_path1 and url_or_path2 argments.
</p>
<p>
The function may report false positives if ignore_ancestry is False,
as described in the documentation for diff_summarize().
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>
</div>

<h4><a name="pysvn_client_export"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.export</a></h4>
<pre>
revision = \
export( src_url_or_path,
        dest_path,
        force=False,
        revision=pysvn.Revision()<span class="svn_1001000">,
        native_eol=None</span><span class="svn_1003000">,
        ignore_externals=False,
        recurse=True,
        peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span><span class="svn_1005000">,
        depth=depth</span><span class="svn_1007000">,
        ignore_keywords=False</span> )
</pre>
<p>Create an unversioned copy of the src_path at revision in dest_path.
<span class="svn_1003000">Set recurse to False to export a single file. Set ignore_externals to
True to ignore externals definitions.</span>
<span class="svn_1007000">
Set ignore_keywords to True to prevnet keyword replacement.
</span>
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision src_url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>
<ol>
<li>Exports a clean directory tree from the repository specified by
  URL src_url_or_path, at revision if it is given, otherwise at
  HEAD, into dest_path.</li>

<li>Exports a clean directory tree from the working copy specified
  by src_path into dest_path.  All local changes will be preserved,
  but files not under revision control will not be copied.</li>
</ol>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<p><span class="svn_1001000">native_eol parameter allows the line ending of files with
svn:eol-style property set to native to be overridden.
Use None to use the eol-style of the Operating System,
use "LF" to use "\n", "CR" to use "\r" and "CRLF" to use "\r\n".</span>
</p>
<p>export returns a pysvn.Revision containing the number of the
checked in revision.
</p>

<p>Note: The native_eol parameter is only available for svn 1.1.0
or later.
</p>

<h4><a name="pysvn_client_get_auth_cache"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_auth_cache</a></h4>
<pre>
enabled = get_auth_cache()
</pre>
<p>return true if credential caching is enabled, otherwise return
false.
</p>

<div class="svn_1003000">
<h4><a name="pysvn_client_get_adm_dir"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_adm_dir</a></h4>
<pre>
name = get_adm_dir()
</pre>
<p>Returns the name of the subverion admin directory.
</p>
</div>

<h4><a name="pysvn_client_get_auto_props"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_auto_props</a></h4>
<pre>
enabled = get_auto_props()
</pre>
<p>Returns true if svn will automatically set properties
when adding files, otherwise returns false.
</p>

<div class="svn_1005000">
<h4><a name="pysvn_client_get_changelist"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_changelist</a></h4>
<pre>
changelist_list = \
get_changelist( path,
                changelist,
                depth=depth,
                changelists=[] )
</pre>
<p>
TBD
</p>

<p>The depth is one of the pysvn.depth enums.
</p>

</div>

<h4><a name="pysvn_client_get_default_password"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_default_password</a></h4>
<pre>
password = get_default_password()
</pre>
<p>Returns None if no default is set otherwise returns the password as a string.
</p>

<h4><a name="pysvn_client_get_default_username"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_default_username</a></h4>
<pre>
username = get_default_username()
</pre>
<p>Returns None if no default is set otherwise returns the username as a string.
</p>

<h4><a name="pysvn_client_get_interactive"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_interactive</a></h4>
<pre>
enabled = get_interactive()
</pre>
<p>Returns true if svn will prompt for missing credential information, otherwise returns false.
</p>

<h4><a name="pysvn_client_get_store_passwords"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.get_store_passwords</a></h4>
<pre>
enabled = get_store_passwords()
</pre>
<p>Returns true if svn will store passwords after prompting for them, otherwise returns false.
</p>

<h4><a name="pysvn_client_import_"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.import_</a></h4>
<pre>
revision = \
import_( path,
         url,
         log_message,
         recurse=True<span class="svn_1003000">,
         ignore=False</span><span class="svn_1005000">,
         revprops</span><span class="svn_1008000">,
         autoprops=False</span> )
</pre>
<p>
Commit an unversioned file or tree into the repository.
</p>
<p>Recursively commit a copy of PATH to URL.
Parent directories are created as necessary in the repository.
<span class="svn_1003000">Set ignore to False to
disregard default and svn:ignore property ignores.</span>
</p>

<p>revprops TBD</p>

<p>import_ returns a pysvn.Revision containing the number of the
checked in revision.
</p>

<h4><a name="pysvn_client_info"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.info</a></h4>
<pre>
entry = info( path )
</pre>
<p>return information on path as a <a href="#entry">Entry</a> object.
</p>

<div class="svn_1008000">
<p>Set autoprops to False to prevent subversion from applying properties automatically.</p>
</div>

<div class="svn_1003000">
<h4><a name="pysvn_client_info2"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.info2</a></h4>
<pre>
entry_list = \
info2( url_or_path,
       revision=pysvn.Revision( opt_revision_kind.unspecified ),
       peg_revision=pysvn.Revision( opt_revision_kind.unspecified ),
       recurse=True<span class="svn_1005000">,
       depth=depth</span><span class="svn_1007000">
       fetch_excluded=False,
       fetch_actual_only=True</span> )

</pre>
<p>return information on url_or_path as a list of (path, info_dict)
tuples. To return information about a URL revision must be
opt_revision_kind.head or opt_revision_kind.number.
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<div class="svn_1007000">
<p>
If fetch_excluded is True, also also send excluded nodes in the working
copy to receiver, otherwise these are skipped.
</p>
<p>If fetch_actual_only
is True also send nodes that don't exist as versioned but are still
tree conflicted.
</p>
</div>

<p>The info_dict contains:
<ul>
<li>URL - URL or path</li>
<li>rev - pysvn.<a href="#pysvn_revision">Revision</a> or None</li>
<li>kind - kind of path</li>
<li>repos_root_URL - string</li>
<li>repos_UUID - string</li>
<li>last_changed_rev - pysvn.<a href="#pysvn_revision">Revision</a> or None</li>
<li>last_changed_date - time or None</li>
<li>last_changed_author - string or None</li>
<li>lock - None or dictionary containing:</li>
<ul>
<li>path - string</li>
<li>token - string or None</li>
<li>owner - string or None</li>
<li>comment - string or None</li>
<li>is_dav_comment - true if is DAV comment</li>
<li>creation_date - time or None</li>
</ul>
<li>wc_info - None if url_or_path is a URL; 
  otherwise a dictionary containing:</li>
<ul>
<li>schedule - pysvn.<a href="#pysvn_wc_schedule">wc_schedule</a> or None</li>
<li>copyfrom_url - string or None</li>
<li>copyfrom_rev - pysvn.<a href="#pysvn_revision">Revision</a> or None</li>
<li>text_time - time or None</li>
<li>prop_time - time or None</li>
<li>checksum - string or None</li>
<li>conflict_old - string or None</li>
<li>conflict_new - string or None</li>
<li>conflict_wrk - string or None</li>
<li>prejfile - string or None</li>
</ul>
</ul>
</p>

<p>Note: The info2 command is only available with svn 1.2.0 or later.
</p>
</div>

<div class="svn_1003000">
<h4><a name="pysvn_client_is_adm_dir"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.is_adm_dir</a></h4>
<pre>
rc = \
is_adm_dir( name )
</pre>
<p>Return True is the name is an subversion admin directory.
</p>
</div>

<div class="svn_1005000">
<h4><a name="pysvn_client_root_url_from_path"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.root_url_from_path</a></h4>
<pre>
root_url = \
    root_url_from_path( url_or_path )
</pre>
<p>Return the root URL of the repository given the url_or_path.
</p>
</div>

<h4><a name="pysvn_client_is_url"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.is_url</a></h4>
<pre>
rc = \
is_url( url )
</pre>
<p>return True if the url is a known subversion url.
</p>

<div class="svn_1004000">
<h4><a name="pysvn_client_list"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.list</a></h4>
<pre>
entries_list = \
list( url_or_path,
      peg_revision=pysvn.Revision( opt_revision_kind.unspecified ) )
      revision=pysvn.Revision( opt_revision_kind.head ),
      recurse=False,
      dirent_fields=pysvn.SVN_DIRENT_ALL,
      fetch_locks=False<span class="svn_1005000">,
      depth=depth</span><span class="svn_1008000">,
      include_externals=False</span><span class="svn_1010000">,
      patterns=[pattern, pattern]</span> )
</pre>
<span class="svn_1005000">,
      depth=depth</span>
<p>
Returns a list with a tuple of information for each file in the given
path at the provided revision.
</p>

<p>peg_revision indicates in which revision url_or_path is valid.
If peg_revision.kind is opt_revision_kind.unspecified, then it
defaults to opt_revision_kind.head for URLs or
opt_revision_kind.working for WC targets.
</p>

<div class="svn_1005000">
<p>The depth can be used in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<div class="svn_1008000">
<p>Set include_externals to True to include externals.
</p>
</div>

<div class="svn_1010000">
<p>The patterns argument allows the set of files to be returned to be filter on the server.
Provide a list if glob patterns. For example to get only python and C++ files: ["*.py", "*.cpp"]
</p>
</div>

<p>dirent_fields controls which dirent fields will return.
Use pysvn.SVN_DIRENT_ALL to return all fields. Bit-wise or
one of these values to return only the selected fields:
</p>

<ul>
<li>SVN_DIRENT_KIND - return kind field</li>
<li>SVN_DIRENT_SIZE - return size field</li>
<li>SVN_DIRENT_HAS_PROPS - return has_props field</li>
<li>SVN_DIRENT_CREATED_REV - return created_rev field</li>
<li>SVN_DIRENT_TIME - return time field</li>
<li>SVN_DIRENT_LAST_AUTHOR - return last_author field</li>
</ul>

<p>The tuple contains:
</p>
<ul>
<li>0 - PysvnList containing the dirent information</li>
<li>1 - PysvnLock containing the lock information or None</li>
<li>2 - external_parent_url - string or None</li>
<li>3 - external_target - string or None</li>
</ul>

<p>The PysvnList object contains the requested dirent fields:
</p>
<ul>
<li>created_rev - pysvn.<a href="#pysvn_revision">Revision</a> - the revision of the last change</li>
<li>has_props - bool - True if the node has properties</li>
<li>kind - node_kind - one of the pysvn.<a href="#pysvn_node_kind">node_kind</a> values</li>
<li>last_author - string - the author of the last change</li>
<li>repos_path - string - (always present) absolute path of file in the repository</li>
<li>size - long - size of file</li>
<li>time - float - the time of the last change</li>
</ul>
</div>

<p>The PysvnList object obtains the lock information:
</p>
<ul>
<li>comment - string - the lock comment</li>
<li>token - string - lock token</li>
<li>path - </li>
<li>owner - string - owner of the lock</li>
<li>expiration_date - None or int - time lock will expire</li>
<li>is_dav_comment - boolean - true is a commment from DAV</li>
<li>creation_date - int - time the lock was created</li>
</ul>

<div class="svn_1008000">
<p>
If list() was called with include_externals set to True,
external_parent_url and external_target will be set.
external_parent_url is url of the directory which has the
externals definitions. external_target is the target subdirectory of
externals definitions which is relative to the parent directory that holds
the external item.
</p>
<p>
If external_parent_url and external_target are defined, the item being
listed is part of the external described by external_parent_url and
external_target. Else, the item is not part of any external.
Moreover, we will never mix items which are part of separate
externals, and will always finish listing an external before listing
the next one.
</p>
</div>

<div class="svn_1002000">
<h4><a name="pysvn_client_lock"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.lock</a></h4>
<pre>
lock( url_or_path,
      lock_comment, 
      force=False )
</pre>
<p>
lock the url_or_path with lock_comment. Set force to True to
override any lock held by another user.
</p>
</div>

<h4><a name="pysvn_client_log"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.log</a></h4>
<pre>
log_messages = \
log( url_or_path,
     revision_start=pysvn.Revision( opt_revision_kind.head ),
     revision_end=pysvn.Revision( opt_revision_kind.number, 0 ),
     discover_changed_paths=False,
     strict_node_history=True<span class="svn_1002000">,
     limit=0</span><span class="svn_1004000">,
     peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span><span class="svn_1005000">,
     include_merged_revisions=False,
     revprops=list_of_revprop_names</span> )
</pre>
<p>
Return the log messages for the specified url_or_path between
revisions start and end. <span class="svn_1002000">Set limit to the maximum number
of log messages to be returned, 0 means return all messages.</span>
</p>
<p>If discover_changed_paths is set, the changed_paths dictionary
entry is filled with a list of changed paths.
If strict_node_history is set, log entries will not cross copies.
</p>
<div class="svn_1004000">
<p>If url_or_path no longer exists in the repos of WC then pass in a peg_revision of a revision where it did exist.</p>
</div>
<div class="svn_1005000">
<p>include_merged_revisions TBD
</p>
<p>revprops is a list of strings that name the revprops to be returned.
</p>
</div>

<p>log returns a list of log entries; each log entry is a
dictionary. The dictionary contains:
</p>
<ul>
<li>author - string - the name of the author who committed the revision</li>
<li>date - float time - the date of the commit</li>
<li>message - string - the text of the log message for the commit</li>
<li>revision - pysvn.<a href="#pysvn_revision">Revision</a> - the revision of the commit</li>
<li>changed_paths - list of dictionaries. Each dictionary contains:</li>
<ul>
<li>path - string - the path in the repository</li>
<li>action - string</li>
<li>copyfrom_path - string - if copied, the original path, else None</li>
<li>copyfrom_revision - pysvn.<a href="#pysvn_revision">Revision</a> - if copied, the revision of the original, else None</li>
</ul>
</ul>

<h4><a name="pysvn_client_ls"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.ls</a></h4>
<pre>
entries_list = \
ls( url_or_path,
    revision=pysvn.Revision( opt_revision_kind.head ),
    recurse=True<span class="svn_1002000">,
    peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span> )
</pre>
<p><span class="svn_1004000">Use the <a href="#pysvn_client_list">list</a> method in new code
as it fixes performance and ambiguity problems with the ls method.</span>
</p>
<p>
Returns a list of dictionaries for each file the given path at
the provided revision.
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>
<p>The dictionary contains:
</p>
<ul>
<li>created_rev - pysvn.<a href="#pysvn_revision">Revision</a> - the revision of the last change</li>
<li>has_props - bool - True if the node has properties</li>
<li>kind - node_kind - one of the pysvn.<a href="#pysvn_node_kind">node_kind</a> values</li>
<li>last_author - the author of the last change</li>
<li>name - string - name of the file</li>
<li>size - long - size of file</li>
<li>time - float - the time of the last change</li>
</ul>

<h4><a name="pysvn_client_merge"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.merge</a></h4>
<pre>
merge( url_or_path1,
       revision1,
       url_or_path2,
       revision2,
       local_path,
       force=False,
       recurse=True,
       notice_ancestry=False,
       dry_run=False,<span class="svn_1005000">,
       depth=depth,
       record_only=False,
       merge_options=[]</span><span class="svn_1007000">,
       allow_mixed_revisions=false</span><span class="svn_1008000">,
       ignore_mergeinfo=not notice_ancestry</span> )
</pre>
<p>Apply the differences between two sources to a working copy path.
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<p>merge_options (a list of strings),
is used to pass additional command line arguments to the merge
processes (internal or external).</p>

<p>The internal subversion diff supports the following options:
</p>

<ul>
<li>--ignore-space-change, -b</li>
<li>--ignore-all-space, -w</li>
<li>--ignore-eol-style</li>
<li>--unified, -u (for compatibility, does nothing).</li>
</ul>
<div class="svn_1007000">
<p>
If allow_mixed_revisions is False, and merge_target is a mixed-revision
working copy, raise SVN_ERR_CLIENT_MERGE_UPDATE_REQUIRED.
</p>
<p>
Because users rarely intend to merge into mixed-revision working copies,
it is recommended to set this parameter to FALSE by default unless the
user has explicitly requested a merge into a mixed-revision working copy.
</p>
</div>

<div class="svn_1008000">
<p>
If ignore_mergeinfo is true, disable merge tracking, by treating the
two sources as unrelated even if they actually have a common ancestor.
</p>
</div>

<div class="svn_1001000">
<h4><a name="pysvn_client_merge_peg"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.merge_peg</a></h4>
<pre>
merge_peg( url_or_path,
           revision1,
           revision2,
           peg_revision,
           local_path,
           recurse=True,
           notice_ancestry,
           force=False,
           dry_run=False<span class="svn_1005000">,
           depth=depth,
           record_only=False,
           merge_options=[]</span> )
</pre>
<p>Apply the differences between two sources to a working copy path.
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<p>merge_options (a list of strings),
is used to pass additional command line arguments to the merge
processes (internal or external).</p>

<p>The internal subversion diff supports the following options:
</p>

<ul>
<li>--ignore-space-change, -b</li>
<li>--ignore-all-space, -w</li>
<li>--ignore-eol-style</li>
<li>--unified, -u (for compatibility, does nothing).</li>
</ul>

</div>

<div class="svn_1005000">
<h4><a name="pysvn_client_merge_peg2"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.merge_peg2</a></h4>
<pre>
merge_peg2( sources,
            ranges_to_merge,
            peg_revision,
            tareget_wcpath,
            depth=depth,
            notice_ancestry=False,
            force=False,
            dry_run=False,
            record_only=True,
            merge_options=[]<span class="svn_1007000">,
            allow_mixed_revisions=false</span><span class="svn_1008000">,
            ignore_mergeinfo=false</span> )
</pre>
<p>Apply the differences between the ranges_to_merge in sources to a working copy path, target_wcpath.
ranges_to_merge is a list of tuples with the start and end revisions to be merged.
</p>
<p>peg_revision indicates in which revision url_or_path is valid.
If peg_revision.kind is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</p>
<p>The depth is one of the pysvn.depth enums.
</p>

<p>merge_options (a list of strings),
is used to pass additional command line arguments to the merge
processes (internal or external).</p>

<p>The internal subversion diff supports the following options:
</p>

<ul>
<li>--ignore-space-change, -b</li>
<li>--ignore-all-space, -w</li>
<li>--ignore-eol-style</li>
<li>--unified, -u (for compatibility, does nothing).</li>
</ul>

</div>
<div class="svn_1007000">
<p>
If allow_mixed_revisions is False, and merge_target is a mixed-revision
working copy, raise SVN_ERR_CLIENT_MERGE_UPDATE_REQUIRED.
</p>
<p>
Because users rarely intend to merge into mixed-revision working copies,
it is recommended to set this parameter to FALSE by default unless the
user has explicitly requested a merge into a mixed-revision working copy.
</p>
</div>
<div class="svn_1008000">
<p>
If ignore_mergeinfo is true, disable merge tracking, by treating the
two sources as unrelated even if they actually have a common ancestor.
</p>
</div>

<div class="svn_1005000">
<h4><a name="pysvn_client_merge_reintegrate"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.merge_reintegrate</a></h4>
<pre>
merge_reintegrate( url_or_path,
                   revision,
                   local_path,
                   dry_run=False,
                   merge_options=[] )
</pre>
<p>Lump-merge all of url_or_path unmerged changes into local_path.
</p>

<p>merge_options (a list of strings),
is used to pass additional command line arguments to the merge
processes (internal or external).</p>

<p>The internal subversion diff supports the following options:
</p>

<ul>
<li>--ignore-space-change, -b</li>
<li>--ignore-all-space, -w</li>
<li>--ignore-eol-style</li>
<li>--unified, -u (for compatibility, does nothing).</li>
</ul>

</div>

<h4><a name="pysvn_client_mkdir"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.mkdir</a></h4>
<pre>
mkdir( url_or_path,
       log_message<span class="svn_1005000">,
       make_parents,
       revprops</span> )
mkdir( [url_or_path,url_or_path],
       log_message<span class="svn_1005000">,
       make_parents,
       revprops</span> )
</pre>
<p>Create a new directory under revision control.
</p>

<p>url_or_path can be a list of URLs and paths
</p>

<p>make_parents and revprops TBD</p>

<p>If url_or_path is a path, each directory is scheduled for
addition upon the next commit.
</p>

<p>If url_or_path is a URL, the directories are created in the
repository via an immediate commit.
</p>

<p>In both cases, all the intermediate directories must already
exist.
</p>

<h4><a name="pysvn_client_move"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.move</a></h4>
<pre>
move( src_url_or_path,
      dest_url_or_path,
      force=False )
</pre>
<p>Move (rename) something in working copy or HEAD revision of repository.
</p>

<p>NOTE: this command is equivalent to a 'copy' and 'delete'.
</p>

<p>src_path and dest_path can both be working copy (WC) paths
or URLs:
<ul>
<li>WC  -&gt; WC:   move and schedule for addition (with history)</li>
<li>URL -&gt; URL:  complete server-side rename.</li>
</ul>
</p>

<p>If src_url_or_path is a path, each item is scheduled for deletion
upon the next commit.  Files, and directories that have not been
committed, are immediately removed from the working copy.  The
command will not remove PATHs that are, or contain, unversioned
or modified items; set force=True to override this
behaviour.
</p>

<p>If src_url_or_path is a URL, the items are deleted from the
repository via an immediate commit.
</p>

<div class="svn_1005000">
<h4><a name="pysvn_client_move2"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.move2</a></h4>
<pre>
move2( sources,
       dest_url_or_path,
       move_as_child=False,
       make_parents=False,
       revprops<span class="svn_1008000">,
       allow_mixed_revisions=False,
       metadata_only=False</span> )
</pre>
<p>
Duplicate something in working copy or repos, remembering history.
The src_revision defaults to pysvn.Revision( opt_revision_kind.head )
if the src_path is a URL otherwise to
pysvn.Revision( opt_revision_kind.working ).
</p>

<p>
If not None, revprop is a list of strings holding additional,
custom revision properties to be set on the new revision in
the event that this is a committing operation.  This table cannot
contain any standard Subversion properties.
</p>

<div class="svn_1008000">
<p>
If allow_mixed_revisions is False, SVN_ERR_WC_MIXED_REVISIONS
will be raised if the move source is a mixed-revision subtree.
</p>
<p>
If allow_mixed_revisions is True, a mixed-revision move source is
allowed but the move will degrade to a copy and a delete without local
move tracking. This parameter should be set to False except where backwards
compatibility to older versions of subversion is required.
</p>
<p>
If metadata_only is TRUE and moving a file in a working copy,
everything in the metadata is updated as if the node is moved, but the
actual disk move operation is not performed. This feature is useful for
clients that want to keep the working copy in sync while the actual working
copy is updated by some other task.
</p>
</div>

<p>src_url_or_path and dest_url_or_path can each be either a
working copy (WC) path or URL:
<ul>
<li>WC  -&gt; WC:   move and schedule for addition (with history)</li>
<li>WC  -&gt; URL:  immediately commit a move of WC to URL</li>
<li>URL -&gt; WC:   check out URL into WC, schedule for addition</li>
<li>URL -&gt; URL:  complete server-side move; used to branch and tag</li>
</ul>
</p>
<p>If the destination is a URL the <a href="#pysvn_client_callback_get_log_message">client_get_log_message</a>
callback must be implemented to return a log message.
</p>
</div>

<div class="svn_1005000">
<h4><a name="pysvn_client_patch"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.patch</a></h4>
<pre>
svn_client_patch(patch_abspath,
                 wc_dir_abspath,
                 dry_run=False,
                 strip_count=0,
                 reverse=False,
                 ignore_whitespace=False,
                 remove_tempfiles=False)
</pre>
<p>
Apply a unidiff patch that's located at absolute path
patch_abspath to the working copy directory at wc_dir_abspath.
</p>
<p>
This function makes a best-effort attempt at applying the patch.
It might skip patch targets which cannot be patched (e.g. targets
that are outside of the working copy). It will also reject hunks
which cannot be applied to a target in case the hunk's context
does not match anywhere in the patch target.
</p>
<p>
If dry_run is True, the patching process is carried out, and full
notification feedback is provided, but the working copy is not modified.
</p>
<p>
strip_count specifies how many leading path components should be
stripped from paths obtained from the patch. It is an error if a
negative strip count is passed.
</p>
<p>
If reverse is True, apply patches in reverse, deleting lines
the patch would add and adding lines the patch would delete.
</p>
<p>
If ignore_whitespace is True, allow patches to be applied if they
only differ from the target by whitespace.
</p>
<p>
If remove_tempfiles is True, lifetimes of temporary files created
during patching will be managed internally. Otherwise, the caller should
take ownership of these files, the names of which can be obtained by
passing a patch_func callback.
</p>
<p>
If notify_func is not None, invoke notify_func
 as patching progresses.
</p>
<p>
If cancel_func is not None, invoke it at various places during the operation.
</p>

</div>

<h4><a name="pysvn_client_propdel"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.propdel</a></h4>
<pre>
rev = \
propdel( prop_name,
         url_or_path,
         revision=pysvn.Revision(),
         recurse=False<span class="svn_1002000">,
         skip_checks=False</span><span class="svn_1005000">,
         depth=depth,
         base_revision_for_url=pysvn.Revision( opt_revision_kind.number, see-text ),
         revprops</span> )
</pre>
<p>Delete the property prop_name from url_or_path.
</p>
<p><span class="svn_1002000">If skip_checks is true, do no validity checking. But if 
skip_checks is false, and  propname is not a valid property for 
target, return an error, either SVN_ERR_ILLEGAL_TARGET (if the
property is not appropriate for target), or 
SVN_ERR_BAD_MIME_TYPE (if  propname is "svn:mime-type", but 
propval is not a valid mime-type).</span>
</p>
<p>
The url_or_path may only be an URL if base_revision_for_url is not
-1; in this case, the property will only be set
if it has not changed since revision base_revision_for_url.
base_revision_for_url must be -1 if url_or_path
is not an URL.</p>
<p>The src_revision defaults to
pysvn.Revision( opt_revision_kind.head ) if the src_path is a
URL otherwise to pysvn.Revision( opt_revision_kind.working ).
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
<p>revprops TBD</p>
</div>

<div class="svn_1007000">
<h4><a name="pysvn_client_propdel_local"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.propdel_local</a></h4>
<pre>
propdel_local( prop_name,
               path,
               depth=empty,
               changelist=None )
</pre>
<p>
path is either a string path or a list of path strings.
</p>
<p>
Delelte propname fromn each path in the list.
The paths must be all working copy paths.
</p>
<p>
If depth is svn_depth_empty, set the property on each member of
targets only; if svn_depth_files, set it on targets and their
file children (if any); if svn_depth_immediates, on targets and all
of their immediate children (both files and directories); if
svn_depth_infinity, on targets and everything beneath them.
</p>
<p>
changelists is an list of string changelist
names, used as a restrictive filter on items whose properties are
set; that is, don't set properties on any item unless it's a member
of one of those changelists. If changelists is empty (or
altogether None), no changelist filtering occurs.
</p>
<p>
The context cancel callback can be used to cannle propset_local.
</p>
</div>

<div class="svn_1007000">
<h4><a name="pysvn_client_propdel_remote"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.propdel_remote</a></h4>
<pre>
commit_info = \
propdel_remote( prop_name,
                prop_value,
                url,
                base_revision_for_url=pysvn.Revision( opt_revision_kind.number, 0 ), )
</pre>
<p>
Delete propname from the url.
</p>
<p>
Immediately attempt to commit the property change in the repository,
using the log message returned from the context log messages callback.
</p>
<p>
If the property has changed on url since revision
base_revision_for_url (must be opt_revision_kind.number), no
change will be made and an error will be returned.
</p>
<p>
commit_info returns the detail of the successful commit.
</p>
</div>

<h4><a name="pysvn_client_propget"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.propget</a></h4>
<pre>
prop_list = \
propget( prop_name,
         url_or_path,
         revision=pysvn.Revision(),
         recurse=False<span class="svn_1002000">,
         peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span><span class="svn_1005000">,
         depth=depth</span><span class="svn_1008000">,
         get_inherited_props=False</span> )
</pre>
<p>Returns a dictionary with keys of url_or_path and values of
the prop_name.
</p>
<div class="svn_1008000">
<p>
If get_inherited_props is True returns a tuple of two items:
</p>
<ul>
<li>0 - dictionary with keys of url_or_path and values of
the prop_name.</li>
<li>1 - dictionary with keys of url_or_path and values of
the prop_name that where inherited.</li>
</ul>
</div>
<p>The src_revision defaults to pysvn.Revision( opt_revision_kind.head )
if the url_or_path is a URL otherwise to
pysvn.Revision( opt_revision_kind.working ).
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<h4><a name="pysvn_client_proplist"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.proplist</a></h4>
<pre>
prop_list = \
proplist( url_or_path,
          revision=pysvn.Revision(),
          recurse=False<span class="svn_1002000">,
          peg_revision=pysvn.Revision( opt_revision_kind.unspecified )</span><span class="svn_1005000">,
          depth=depth</span> )
</pre>
<p>Returns a list of tuples (path, prop_dict). The prop_dict
contains the prop_names and their values if set on the path.
</p>
<p>The src_revision defaults to pysvn.Revision( opt_revision_kind.head )
if the url_or_path is a URL otherwise to
pysvn.Revision( opt_revision_kind.working ).
</p>
<p><span class="svn_1002000">peg_revision indicates in
which revision url_or_path is valid.  If peg_revision.kind
is opt_revision_kind.unspecified, then it defaults to
opt_revision_kind.head for URLs or opt_revision_kind.working for
WC targets.
</span></p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<h4><a name="pysvn_client_propset"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.propset</a></h4>
<pre>
<span class="svn_1005000">commit_info = \
</span>propset( prop_name,
         prop_value,
         url_or_path,
         revision=pysvn.Revision(),
         recurse=False<span class="svn_1002000">,
         skip_checks=False</span><span class="svn_1005000">,
         depth=depth,
         base_revision_for_url=[0 for URL, -1 for path],
         allow_unver_obstructions=False,
         revprops</span> )
</pre>
<p>Set the property prop_name to prop_value in url_or_path.
</p>
<p><span class="svn_1002000">If skip_checks is true, do no validity checking.  But if 
skip_checks is false, and  propname is not a valid property for 
target, return an error, either  SVN_ERR_ILLEGAL_TARGET (if the
property is not appropriate for  target), or 
SVN_ERR_BAD_MIME_TYPE (if  propname is "svn:mime-type", but 
propval is not a valid mime-type).</span>
</p>
<p>The revision defaults to pysvn.Revision( opt_revision_kind.head )
if the url_or_path is a URL otherwise to
pysvn.Revision( opt_revision_kind.working ).
</p>
<p>
The url_or_path may only be an URL if base_revision_for_url is not
-1; in this case, the property will only be set
if it has not changed since revision base_revision_for_url.
base_revision_for_url must be -1 if url_or_path
is not an URL.</p>

<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
<p>If allow_unver_obstructions is False then the update will abort
if there are any unversioned obstructing items.
</p>
<p>revprops TBD</p>

</div>

<div class="svn_1007000">
<h4><a name="pysvn_client_propset_local"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.propset_local</a></h4>
<pre>
propset_local( prop_name,
               prop_value,
               path,
               depth=empty,
               skip_checks=False,
               changelist=None )
</pre>
<p>
path is either a string path or a list of path strings.
</p>
<p>
Set propname to propval on each path in the list.
The paths must be all working copy paths.
</p>
<p>
If depth is svn_depth_empty, set the property on each member of
targets only; if svn_depth_files, set it on targets and their
file children (if any); if svn_depth_immediates, on targets and all
of their immediate children (both files and directories); if
svn_depth_infinity, on targets and everything beneath them.
</p>
<p>
changelists is an list of string changelist
names, used as a restrictive filter on items whose properties are
set; that is, don't set properties on any item unless it's a member
of one of those changelists. If changelists is empty (or
altogether None), no changelist filtering occurs.
</p>
<p>
If propname is an svn-controlled property (i.e. prefixed with
"svn:"), then the caller is responsible for ensuring that
the value uses LF line-endings.
</p>
<p>
If skip_checks is True, do no validity checking. But if 
skip_checks is False, and propname is not a valid property for 
targets, return an error, either SVN_ERR_ILLEGAL_TARGET (if the
property is not appropriate for targets), or
SVN_ERR_BAD_MIME_TYPE (if propname is "svn:mime-type", but 
propval is not a valid mime-type).
</p>
<p>
The context cancel callback can be used to cannle propset_local.
</p>
</div>

<div class="svn_1007000">
<h4><a name="pysvn_client_propset_remote"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.propset_remote</a></h4>
<pre>
commit_info = \
propset_remote( prop_name,
                prop_value,
                url,
                skip_checks=False,
                base_revision_for_url=0,
                revprops=None )
</pre>
<p>
Set propname to propval on url.
</p>
<p>
Immediately attempt to commit the property change in the repository,
using the log message returned from the context log messages callback.
</p>
<p>

If the property has changed on url since revision
base_revision_for_url (which must not be SVN_INVALID_REVNUM), no
change will be made and an error will be returned.
</p>
<p>
If non None, revprops is a list of tuples, (string names, string value),
holding additional, custom revision properties to be set on the new revision. This
list cannot contain any standard Subversion properties.
</p>
<p>
commit_info returns the detail of the successful commit.
</p>
<p>
If propname is an svn-controlled property (i.e. prefixed with
"svn:"), then the caller is responsible for ensuring that
the value uses LF line-endings.
</p>
<p>
If skip_checks is True, do no validity checking. But if 
skip_checks is False, and propname is not a valid property for 
url, return an error, either SVN_ERR_ILLEGAL_TARGET (if the property is
not appropriate for url), or SVN_ERR_BAD_MIME_TYPE (if propname
is "svn:mime-type", but propval is not a valid mime-type).
</p>
</div>

<h4><a name="pysvn_client_relocate"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.relocate</a></h4>
<pre>
relocate( from_url,
          to_url,
          path,
          recurse=True<span class="svn_1007000">,
          ignore_externals=True</span> )
</pre>
<p>Relocate the working copy from from_url to to_url of path.
</p>
<div class="svn_1007000">
<p>Set ignore_externals to False to work on the externals.</p>
<p>Note: recurse is ignored since subversion 1.7</p>
</div>

<h4><a name="pysvn_client_remove"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.remove</a></h4>
<pre>
remove( url_or_path_list,
        force=False<span class="svn_1005000">,
        keep_local=False,
        revprops</span> )
</pre>
<p>If url_or_path is a path, each item is scheduled for deletion
upon the next commit.  Files, and directories that have not been
committed, are immediately removed from the working copy.  The
command will not remove paths that are, or contain, unversioned
or modified items; set force=True to override this
behaviour.
</p>

<div class="svn_1005000">
<p>Set keep_local to True to prevent the local file from being delete.
</p>
<p>revprops TBD</p>
</div>

<p>If url_or_path is a URL, the items are deleted from the
repository via an immediate commit.
</p>

<div class="svn_1005000">
<h4><a name="pysvn_client_remove_from_changelists"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.remove_from_changelists</a></h4>
<pre>
remove_from_changelists( path,
                         changelist,
                         depth=pysvn.depth.infinite,
                         changelists=[] )
</pre>
<p>
TBD
</p>
</div>

<h4><a name="pysvn_client_resolved"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.resolved</a></h4>
<pre>
resolved( path,
          recurse=True<span class="svn_1005000">,
          depth=depth</span> )
</pre>
<p>Mark the conflicted file at path as resolved.
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<h4><a name="pysvn_client_revert"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.revert</a></h4>
<pre>
revert( path,
        recurse=False<span class="svn_1005000">,
        depth=depth,
        changelists=[]</span><span class="svn_1009000">,
        clear_changelists=false,
        metadata_only=false</span> )
revert( [path,path],
        recurse=False<span class="svn_1005000">,
        depth=depth,
        changelists=[]</span><span class="svn_1009000">,
        clear_changelists=false,
        metadata_only=false</span> )
</pre>
<p>Discard any changes in the working copy at path.
Set recurse to True to recursively revert a directory's children.
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div>

<h4><a name="pysvn_client_revpropdel"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.revpropdel</a></h4>
<pre>
rev = \
revpropdel( prop_name,
            url,
            revision=pysvn.Revision( opt_revision_kind.head ),
            force=False<span class="svn_1008000">,
            original_prop_value=None</span> )
</pre>
<p>
Delete the revision property prop_name from url at the revision.
</p>
<div class="svn_1008000">
<p>
If original_prop_value is specified its string value is compared to the current value of the property and
only if it matches does the revpropdel succeed.
</p>
</div>

<h4><a name="pysvn_client_revpropget"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.revpropget</a></h4>
<pre>
rev_prop = \
revpropget( prop_name,
            url,
            revision=pysvn.Revision( opt_revision_kind.head ) )
</pre>
<p>Returns a tuple (rev, prop_val) where the prop_val contains
the revision property value.
</p>

<h4><a name="pysvn_client_revproplist"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.revproplist</a></h4>
<pre>
rev_prop_dict = \
revproplist( url,
             revision=pysvn.Revision( opt_revision_kind.head ) )
</pre>
<p>Returns a tuple (revision, prop_dict) where the prop_dict
contains the revision properies and their values.
</p>

<h4><a name="pysvn_client_revpropset"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.revpropset</a></h4>
<pre>
<span class="svn_1007000">
old_prop_value = \
</span>
revpropset( prop_name,
            prop_value,
            url,
            revision=pysvn.Revision( opt_revision_kind.head ),
            force=False<span class="svn_1008000">,
            original_prop_value=None</span> )
</pre>
<p>set the revision property prop_name to prop_value in path.
<span class="svn_1007000">The old prop value is returned.</span>
</p>
<div class="svn_1008000">
<p>
If original_prop_value is specified its string value is compared to the current value of the property and
only if it matches does the revpropset succeed.
</p>
</div>

<div class="svn_1003000">
<h4><a name="pysvn_client_set_adm_dir"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.set_adm_dir</a></h4>
<pre>
set_adm_dir( name )
</pre>
<p>Set the name of the subverion admin directory. ".svn" is the normal admin dir use and "_svn" is used on Windows to work around problems with .NET.
</p>
</div>

<h4><a name="pysvn_client_set_auth_cache"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.set_auth_cache</a></h4>
<pre>
set_auth_cache( enable )
</pre>
<p>When enable is True subversion will remember authentication credentials
in the configuration directory.
</p>

<h4><a name="pysvn_client_set_auto_props"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.set_auto_props</a></h4>
<pre>
set_auto_props( enable )
</pre>
<p>When enabled, subversion will automatically set properties
when adding files; otherwise when disabled it will not.
</p>

<h4><a name="pysvn_client_set_default_password"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.set_default_password</a></h4>
<pre>
set_default_password( password )
</pre>
<p>Set the default password to be used if there is no stored password.
</p>

<h4><a name="pysvn_client_set_default_username"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.set_default_username</a></h4>
<pre>
set_default_username( username )
</pre>
<p>Set the default username to be used if there is no stored username.
</p>

<h4><a name="pysvn_client_set_interactive"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.set_interactive</a></h4>
<pre>
set_interactive( enable )
</pre>
<p>When enable is True subversion will prompt for authentication credentials
when there are no valid store credentials.
</p>

<h4><a name="pysvn_client_set_store_passwords"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.set_store_passwords</a></h4>
<pre>
set_store_passwords( enable )
</pre>
<p>When enable is True subversion will store any passwords that subversion prompted for.
</p>

<div class="svn_1008000">
<h4><a name="pysvn_client_status2"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.status2</a></h4>
<pre>
status_list = \
status2( path,
         recurse=True,
         get_all=True,
         update=False,
         ignore=False,
         ignore_externals=False,
         depth=depth,
         changelist=[],
         depth_as_sticky=False<span class="svn_1009000">,
         check_out_of_date=update,
         check_working_copy=True</span> )
</pre>
<p>If path is a directory status is returned for all files in the
directory in status_list. If path is a single file status is
returned for that single file in status_list.
Set ignore_externals to True to ignore externals definitions.
</p>
<p>The status_list is a list of <a href="#pysvn_status">PysvnStatus</a> objects. 
</p>

<p>Options:
<ul>
<li>recurse - If recurse is True, recurse fully, else do only
  immediate children.</li>

<li>get_all - If get_all is True, retrieve all entries; otherwise,
  retrieve only "interesting" entries (local mods and/or out-of-date).</li>

<li>update - If update is set, contact the repository and augment the
  status structures with information about out-of-dateness.</li>

<li>ignore - If ignore is False, the item will be added regardless of
  whether it is ignored.</li>

<li>ignore_externals - 
  If ignore_externals is False, then recurse into externals
  definitions (if any exist) after handling the main target. 
  This calls the client notification function
  with the wc_notify_action.external action before 
  handling each externals definition, and with 
  wc_notify_action.completed after each.</li>

<li>depth - can be used as in place of recurse. depth is one of the pysvn.depth enums.</li>

<li class="svn_1009000">If check_out_of_date is set, contact the repository and
  augment the status structures with information about
  out-of-dateness (with respect to revision).  Also, if
  result_rev is not NULL, set *result_rev to the actual
  revision against which the working copy was compared (
  result_rev is not meaningful unless check_out_of_date is
  True). check_out_of_date deafults to the value of update.</li>

<li class="svn_1009000">If check_working_copy is not set, do not scan the working
  copy for local modifications. This parameter will be ignored
  unless check_out_of_date is set.  When set, the status
  report will not contain any information about local changes in
  the working copy; this includes local deletions and
  replacements.</li>

</ul>
</p>
</div>

<h4><a name="pysvn_client_status"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.status</a></h4>
<pre>
status_list = \
status( path,
        recurse=True,
        get_all=True,
        update=False,
        ignore=False<span class="svn_1002000">,
        ignore_externals=False</span><span class="svn_1005000">,
        depth=depth</span> )
</pre>
<p>If path is a directory status is returned for all files in the
directory in status_list. If path is a single file status is
returned for that single file in status_list.
<span class="svn_1002000">Set ignore_externals to True to ignore externals definitions.</span>
</p>
<p>The status_list is a list of <a href="#pysvn_status">PysvnStatus</a> objects. 
</p>

<p>Options:
<ul>
<li>recurse - If recurse is True, recurse fully, else do only
  immediate children.</li>

<li>get_all - If get_all is True, retrieve all entries; otherwise,
  retrieve only "interesting" entries (local mods and/or out-of-date).</li>

<li>update - If update is set, contact the repository and augment the
  status structures with information about out-of-dateness.</li>

<li>ignore - If ignore is False, the item will be added regardless of
  whether it is ignored.</li>

<li>ignore_externals (svn 1.2.0 or later) - 
  If ignore_externals is False, then recurse into externals
  definitions (if any exist) after handling the main target. 
  This calls the client notification function
  with the wc_notify_action.external action before 
  handling each externals definition, and with 
  wc_notify_action.completed after each.</li>

<li><div class="svn_1005000">
<p>depth - can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
</div></li>
</ul>
</p>

<h4><a name="pysvn_client_switch"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.switch</a></h4>
<pre>
switch( path,
        url,
        recurse=True,
        revision=pysvn.Revision( opt_revision_kind.head )<span class="svn_1005000">,
        depth=depth,
        peg_revision=revision,
        depth_is_sticky=False,
        ignore_externals=False,
        allow_unver_obstructions=False</span><span class="svn_1007000">,
        ignore_ancestry=False </span>)
</pre>
<p>Update the working copy to a different URL.
</p>
<div class="svn_1005000">
<p>The depth can be used as in place of recurse. depth is one of the pysvn.depth enums.
</p>
<p>If depth_is_sticky is set and depth is not
svn_depth_unknown, then in addition to switching PATH, also set
its sticky ambient depth value to depth.</p>

<p>If ignore_externals is set, do not process externals definitions
as part of this operation.</p>

<p>If allow_unver_obstructions is True then the switch tolerates
existing unversioned items that obstruct added paths.  Only
obstructions of the same type (file or dir) as the added item are
tolerated.  The text of obstructing files is left as-is, effectively
treating it as a user modification after the switch.  Working
properties of obstructing items are set equal to the base properties.
</p>
<p>If allow_unver_obstructions is False then the switch will abort
if there are any unversioned obstructing items.</p>

</div>

<ol>
<li>Update the working copy to mirror a new URL. This behaviour is a
  superset of "svn update".
  Note:  this is the way to move a working copy to a new branch.</li>

<li>Reconnect the working copy when the repository URL has changed.</li>
</ol>

<div class="svn_1002000">
<h4><a name="pysvn_client_unlock"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.unlock</a></h4>
<pre>
unlock( url_or_path,
        force=False )
</pre>
<p>Unlock the url_or_path. Set force to True to unlock any lock
held by another user.
</p>
</div>

<h4><a name="pysvn_client_update"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.update</a></h4>
<pre>
revision = \
update( path,
        recurse=True,
        revision=pysvn.Revision( opt_revision_kind.head )<span class="svn_1002000">,
        ignore_externals=False</span><span class="svn_1005000">,
        depth=depth,
        depth_is_sticky=False,
        allow_unver_obstructions</span><span class="svn_1007000">,
        adds_as_modifications=False,
        make_parents=False</span> )
</pre>
<p>Update the file in the working copy at path to the specified
revision. Set recurse to True to recursively update a directory's
children. <span class="svn_1002000">Set ignore_externals to True to ignore externals definitions.</span>
</p>
<div class="svn_1005000">
<p>path can be a single path string or a list of path strings.
</p>
<p>The depth can be used in place of recurse. depth is one of the pysvn.depth enums.
Use pysvn.depth.unknown to update all files and folders in the working copy honoring the current depths.
Use pysvn.depth.infinity to upadate all files and folders adding any that are missing ignoring the current depths.
</p>
<p>
If depth_is_sticky is set and depth is not
svn_depth_unknown, then in addition to updating PATHS, also set
their sticky ambient depth value to depth.
</p>
<p>
If allow_unver_obstructions is True then the update tolerates
existing unversioned items that obstruct added paths.  Only
obstructions of the same type (file or dir) as the added item are
tolerated.  The text of obstructing files is left as-is, effectively
treating it as a user modification after the update.  Working
properties of obstructing items are set equal to the base properties.
If allow_unver_obstructions is False then the update will abort
if there are any unversioned obstructing items.
</p>
</div>
<div class="svn_1007000">
<p>
If adds_as_modification is True, a local addition at the same path
as an incoming addition of the same node kind results in a normal node
with a possible local modification, instead of a tree conflict.
</p>
<p>
If make_parents is True, create any non-existent parent
directories also by checking them out at depth=empty.
</p>
</div>

<p>update returns a pysvn.Revision containing the number of the
revision the working copy was updated to.
</p>
<p>This command is typically used to get the latest changes
from the repository.
</p>
<p>Note: updating to an older revision does not change the 
current revision. To make the current version identical to
an older revision, use a merge followed by a commit.
</p>

<div class="svn_1007000">
<h4><a name="pysvn_client_upgrade"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.upgrade</a></h4>
<pre>
upgrade( path )
</pre>
<p>Recursively upgrade a working copy from any older format to the current
 WC metadata storage format.  path is the path to the WC root.
</p>
</div>

<h2><a name="pysvn_transaction"><a href="#pysvn_module">pysvn</a>.Transaction - Subversion transaction interface</a></h2>

<p>Interface summary:
</p>

<pre>
transaction = pysvn.Transaction()
transaction = pysvn.Transaction( repos_path, transaction_name, [is_revision=False] )
</pre>

<p>The Transaction object allows you to implement hook code for
the SVN repository. The pre-commit and pre-revprop-change hooks
are the only hooks that are currently appropriate in SVN. See 
the SVN documentation for details on hook scripts.
</p>

<p>A Transaction object can only be used on one thread at a time.
If two threads attempt to call methods of Transaction at the same
time one of the threads will get a pysvn.TransactionError exception
with the value 'transaction in use on another thread'.
</p>

<p>When the optional parameter is_revision is True, than the
transaction_name parameter will be interpreted as a revision number
and all subsequent operation will be performed on this revision.
Note that the propdel and propset operations will fail than.
This option lets you use the Transation object to write post-commit
hooks with the same API than pre-commit hooks, and lets you easily test
your pre-commit hook on revisions.
</p>

<div class="svn_1009000">
<h4><a name="pysvn_client_vacuum"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_client">Client</a>.vacuum</a></h4>
<pre>
vacuum( path,
        remove_unversioned_items=False,
        remove_ignored_items=False,
        fix_recorded_timestamps=True,
        vacuum_pristines=True,
        include_externals=False )
</pre>
<p>
Clean up any locks in the working copy at path. Usually such
locks are the result of a failed or interrupted operation.
</p>

<p>
If remove_unversioned_items is True, remove unversioned items
in path after successful working copy cleanup.
</p>
<p>
If remove_ignored_items is True, remove ignored unversioned items
in path after successful working copy cleanup.
</p>

<p>
If fix_recorded_timestamps is True, this function fixes recorded
timestamps for unmodified files in the working copy, reducing comparision
time on future checks.
</p>
<p>If vacuum_pristines is True, and dir_abspath points to the working
copy root unreferenced files in the pristine store are removed.
</p>
<p>If include_externals is True, recurse into externals and clean
them up as well.
</p>

</div>

<h3><a name="pysvn_transaction_methods">Transaction methods</a></h3>

<td><a href="#pysvn_transaction_cat">cat</a></td>
<td><a href="#pysvn_transaction_changed">changed</a></td>
<td><a href="#pysvn_transaction_list">list</a></td>
<td>&#160;</td>
<td>&#160;</td>
</tr>

<tr bgcolor="#e0e0e0">
<td><a href="#pysvn_transaction_propdel">propdel</a></td>
<td><a href="#pysvn_transaction_propget">propget</a></td>
<td><a href="#pysvn_transaction_proplist">proplist</a></td>
<td><a href="#pysvn_transaction_propset">propset</a></td>
</tr>

<tr bgcolor="#e0e0e0">
<td><a href="#pysvn_transaction_revpropdel">revpropdel</a></td>
<td><a href="#pysvn_transaction_revpropget">revpropget</a></td>
<td><a href="#pysvn_transaction_revproplist">revproplist</a></td>
<td><a href="#pysvn_transaction_revpropset">revpropset</a></td>
</tr>
</table>

<h4><a name="pysvn_transaction_cat"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.cat</a></h4>
<pre>
file_text = \
cat( path )
</pre>
<p>
Return the contents of path as a string, file_text.
</p>

<h4><a name="pysvn_transaction_changed"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.changed</a></h4>
<pre>
file_text = \
changed( copy_info=False,
         base_dir="",
         low_water_mark=pysvn.Revision( opt_revision_kind.number, -1 ),
         send_deltas=False )
</pre>
<p>
Return a dict of all changes in the transaction. The keys in
the dict are the path names and the values are tuples containing
the following:
</p>

<ul>
<li>action - string - a single letter indicating the action
    'A' for add, 'R' for modify, 'D' for delete</li>
<li>kind - node_kind - one of the pysvn.<a href="#pysvn_node_kind">node_kind</a> values</li>
<li>text_mod - int - is != 0 if the text in this path has been modified</li>
<li>prop_mod - int - is != 0 if the properties in this path have been modified</li>
<li>copyfrom_rev - int - when path has been copied this is its copy from revision number</li>
<li>copyfrom_path - int - when path has been copied this is its copy from path</li>
</ul>

<p>
Changes will be limited to those within base_dir, and if
low_water_mark is set to something other than SVN_INVALID_REVNUM(-1)
it is assumed that the client has no knowledge of revisions prior to
low_water_mark.  Together, these two arguments define the portion of
the tree that the client is assumed to have knowledge of, and thus any
copies of data from outside that part of the tree will be sent in their
entirety, not as simple copies or deltas against a previous version.
</p>
<p>
The editor passed to this function should be aware of the fact
that, if send_deltas is False, calls to its change_dir_prop(),
change_file_prop(), and apply_textdelta() functions will not
contain meaningful data, and merely serve as indications that
properties or textual contents were changed.
</p>
<p>
If send_deltas is True, the text and property deltas for changes
will be sent, otherwise null text deltas and empty prop changes will be
used.
</p>
<p>
Note: This editor driver passes SVN_INVALID_REVNUM (-1) for all
revision parameters in the editor interface except the copyfrom
parameter of the add_file() and add_directory() editor functions.
</p>

<h4><a name="pysvn_transaction_list"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.list</a></h4>
<pre>
path_content = list( [path] )
</pre>
<p>
Return a dict of all entries in the directory 'path'. The keys in
the dict are the path names and the value contains the kind (one of
the pysvn.<a href="#pysvn_node_kind">node_kind</a> values). If 'path'
is not given the root of the repository will be examined. This is a same
as '' and '/' as path.
</p>

<h4><a name="pysvn_transaction_propdel"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.propdel</a></h4>
<pre>
propdel( prop_name,
         path )
</pre>
<p>Delete the property prop_name from path in the transaction.
</p>

<h4><a name="pysvn_transaction_propget"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.propget</a></h4>
<pre>
prop_value = \
propget( prop_name,
         path )
</pre>
<p>Returns the prop_value as a string or None if the prop_name
is not in the transaction.
</p>

<h4><a name="pysvn_transaction_proplist"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.proplist</a></h4>
<pre>
prop_dict = \
proplist( path )
</pre>
<p>Returns a prop_dict. 
The prop_dict contains the prop_names and their values if set
on the path in the transaction.
</p>

<h4><a name="pysvn_transaction_propset"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.propset</a></h4>
<pre>
propset( prop_name,
         prop_value,
         path )
</pre>
<p>Set the property prop_name to prop_value in path in the transaction.
</p>

<h4><a name="pysvn_transaction_revpropdel"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.revpropdel</a></h4>
<pre>
revpropdel( prop_name )
</pre>
<p>Delete the revision property prop_name in the transaction.
</p>

<h4><a name="pysvn_transaction_revpropget"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.revpropget</a></h4>
<pre>
prop_val = \
revpropget( prop_name )
</pre>
<p>Returns the prop_val with the revision property value or None if not set in the transaction.
</p>

<h4><a name="pysvn_transaction_revproplist"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.revproplist</a></h4>
<pre>
prop_dict = \
revproplist()
</pre>
<p>Returns a prop_dict where the prop_dict contains the revision
properies and their values in the transaction.
</p>

<h4><a name="pysvn_transaction_revpropset"><a href="#pysvn_module">pysvn</a>.<a href="#pysvn_transaction">Transaction</a>.revpropset</a></h4>
<pre>
rev = \
revpropset( prop_name,
            prop_value )
</pre>
<p>set the revision property prop_name to prop_value in path in
the transaction. The revision updated is returned.
</p>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_revision">Revision - subversion revision</a></h2>

<p>The Revision object has three member variables:
</p>

<ul>
<li>kind   - the kind of revision, its value is one of the
  <a href="#pysvn_opt_revision_kind">opt_revision_kind</a> enumerations.</li>
<li>date   - date and time when kind is opt_revision_kind.date,
  as seconds since the epoch which is compatible with python's
  time module.</li>
<li>number - revision number when kind is opt_revision_kind.number</li>
</ul>

<p>Interface summary:
</p>

<pre>
import pysvn
import time

revhead = pysvn.Revision( pysvn.opt_revision_kind.head )
revdate = pysvn.Revision( pysvn.opt_revision_kind.date, time.time() )
revnum = pysvn.Revision( pysvn.opt_revision_kind.number, 4721 )
</pre>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_clienterror">ClientError - Exception class raised by client commands on error</a></h2>

<p>ClientError exception is raised when any of the subversion
functions called by pysvn return an error.
</p>

<p>The <a href="#pysvn_client">Client</a>.<a href="#pysvn_client_exception_style">exception_style</a>
 variable controls the information stored in the ClientError object.
</p>

<h3>exception_style = 0</h3>

<p>The args property is set to a single string parameter containing
the whole error message. '\n' is used to seperate message parts.
</p>

<p>Use str() to get the string description of the exception raised
by pysvn.
</p>

<pre>
import pysvn

client = pysvn.Client()
client.exception_style = 0
try:

client.update( '.' )
except pysvn.ClientError, e:
    # convert to a string
    print str(e)
    # or access the string in args directly
    print e.args
</pre>

<h3>exception_style = 1</h3>

<p>The arg property is set to a tuple contain two values.
</p>
<p>arg[0] is set to a string parameter containing the whole error
message. '\n' is used to seperate message parts.
</p>
<p>arg[1] is set to a list of tuples containing the message string
and the error code. The error code values are defined by SVN and APR.
</p>

<pre>
import pysvn

client = pysvn.Client()
client.exception_style = 1
try:

client.update( '' )
except pysvn.ClientError, e:
    # print the whole message
    print e.args[0]
    # or process the error list
    for message, code in e.args[1]:
        print 'Code:',code,'Message:',message
</pre>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_status">PysvnStatus - subversion status object</a></h2>
<p>Each status object has the following fields:
</p>
<ul>
<li>path - string - the path name</li>
<li>entry - <a href="#pysvn_entry">PysvnEntry</a> - entry information</li>
<li>is_versioned - Boolean - true if the path is versioned</li>
<li>is_locked - Boolean - true if the path is locked</li>
<li>is_copied - Boolean - true if the path is copied</li>
<li>is_switched - Boolean - true if the path has been switched</li>
<li>prop_status - <a href="#pysvn_wc_status_kind">wc_status_kind</a> - the status of the properties
  of the path</li>
<li>text_status - <a href="#pysvn_wc_status_kind">wc_status_kind</a> - the status of the text of
  the path</li>
<li>repos_prop_status - <a href="#pysvn_wc_status_kind">wc_status_kind</a> - the repository status
  of the properties of the path</li>
<li>repos_text_status - <a href="#pysvn_wc_status_kind">wc_status_kind</a> - the repository status
  of the text of the path</li>
<li>repos_lock - dict - the repository lock
  information</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_entry">PysvnEntry - subversion entry object</a></h2>

<ul>
<li>checksum - string</li>
<li>commit_author - string</li>
<li>commit_revision - pysvn.<a href="#pysvn_revision">Revision</a></li>
<li>commit_time - time</li>
<li>conflict_new - string or None - file path</li>
<li>conflict_old - string of None - file path</li>
<li>conflict_work - string of None - file path</li>
<li>copy_from_revision - pysvn.<a href="#pysvn_revision">Revision</a> or None</li>
<li>copy_from_url - string or None</li>
<li>is_absent - boolean</li>
<li>is_copied - boolean</li>
<li>is_deleted - boolean</li>
<li>is_valid - boolean</li>
<li>kind - pysvn.<a href="#pysvn_node_kind">node_kind</a></li>
<li>name - string</li>
<li>properties_time - time</li>
<li>property_reject_file - string or None</li>
<li>repos - string</li>
<li>revision - pysvn.<a href="#pysvn_revision">Revision</a> or None</li>
<li>schedule - pysvn.<a href="#pysvn_wc_schedule">wc_schedule</a> or None</li>
<li>text_time - time</li>
<li>url - string or None</li>
<li>uuid - string or None</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_opt_revision_kind">opt_revision_kind - subversion
        revision number kind enumeration</a></h2>
<ul>
<li>unspecified - No revision information given.</li>
<li>number - revision given as number</li>
<li>date - revision given as date</li>
<li>committed - rev of most recent change</li>
<li>previous - (rev of most recent change) - 1</li>
<li>base - .svn/entries current revision</li>
<li>working - current, plus local mods</li>
<li>head - repository youngest</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_wc_notify_action">wc_notify_action - subversion notification callback action enumeration</a></h2>
<ul>
<li>add - Adding a path to revision control.</li>
<li>copy - Copying a versioned path.</li>
<li>delete - Deleting a versioned path.</li>
<li>restore - Restoring a missing path from the pristine text-base.</li>
<li>revert - Reverting a modified path.</li>
<li>failed_revert - A revert operation has failed.</li>
<li>resolved - Resolving a conflict.</li>
<li>skip - Skipping a path.</li>
<li>update_delete - Got a delete in an update.</li>
<li>update_add - Got an add in an update.</li>
<li>update_update - Got any other action in an update.</li>
<li>update_completed - The last notification in an update (including updates of externals).</li>
<li>update_external - Updating an external module.</li>
<li>status_completed - The last notification in a status (including status on externals).</li>
<li>status_external - Running status on an external module.</li>
<li>commit_modified - Committing a modification.</li> 
<li>commit_added - Committing an addition.</li>
<li>commit_deleted - Committing a deletion.</li>
<li>commit_replaced - Committing a replacement.</li>
<li>commit_postfix_txdelta - Transmitting post-fix text-delta data for a file.</li>
<li>annotate_revision - Processed a single revision's blame.</li>
<li>locked - Locking a path.</li>
<li>unlocked - Unlocking a path.</li>
<li>failed_lock - Failed to lock a path.</li>
<li>failed_unlock - Failed to unlock a path.</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_wc_status_kind">wc_status_kind - subversion status kind enumeration</a></h2>
<ul>
<li>none - does not exist</li>
<li>unversioned - is not a versioned thing in this wc</li>
<li>normal - exists, but uninteresting.</li>
<li>added - is scheduled for addition</li>
<li>missing - under v.c., but is missing</li>
<li>deleted - scheduled for deletion</li>
<li>replaced - was deleted and then re-added</li>
<li>modified - text or props have been modified</li>
<li>merged - local mods received repos mods</li>
<li>conflicted - local mods received conflicting repos mods</li>
<li>ignored - a resource marked as ignored</li>
<li>obstructed - an unversioned resource is in the way of the versioned resource</li>
<li>external - an unversioned path populated by an svn:external property</li>
<li>incomplete - a directory doesn't contain a complete entries list </li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_wc_merge_outcome">wc_merge_outcome - subversion merge outcome enumeration</a></h2>
<ul>
<li>unchanged - The working copy is (or would be) unchanged.
The changes to be merged were already present in the working copy</li>
<li>merged - The working copy has been (or would be) changed.</li>
<li>conflict - The working copy has been (or would be) changed,
but there was (or would be) a conflict</li>
<li>no_merge - No merge was performed, probably because the target
file was either absent or not under version control.</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_wc_notify_state">wc_notify_state - subversion notify callback state enumeration</a></h2>
<ul>
<li>inapplicable - inapplicable</li>
<li>unknown - Notifier doesn't know or isn't saying.</li>
<li>unchanged - The state did not change.</li>
<li>missing - The item wasn't present.</li>
<li>obstructed - An unversioned item obstructed work.</li>
<li>changed - Pristine state was modified.</li>
<li>merged - Modified state had mods merged in.</li>
<li>conflicted - Modified state got conflicting mods.</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_wc_schedule">wc_schedule - subversion status schedule enumeration</a></h2>
<ul>
<li>normal - Nothing special here</li>
<li>add - Slated for addition</li>
<li>delete - Slated for deletion</li>
<li>replace - Slated for replacement (delete + add)</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_node_kind">node_kind - subversion node kind enumeration</a></h2>
<ul>
<li>none - absent</li>
<li>file - regular file</li>
<li>dir - directory</li>
<li>unknown - something's here, but we don't know what</li>
</ul>

<h2><a href="#pysvn_module">pysvn</a>.<a name="pysvn_depth">depth - subversion depth enumeration</a></h2>
<ul>
<li>empty - Just the named directory D, no entries.  Updates will not pull in
     any files or subdirectories not already present.</li>
<li>exclude - not used yet</li>
<li>files - D + its file children, but not subdirs.  Updates will pull in any
     files not already present, but not subdirectories.</li>
<li>immediates - D + immediate children (D and its entries).  Updates will pull in
     any files or subdirectories not already present; those
     subdirectories' this_dir entries will have depth-empty.</li>
<li>infinity - D + all descendants (full recursion from D).  Updates will pull
     in any files or subdirectories not already present; those
     subdirectories' this_dir entries will have depth-infinity.
     Equivalent to the pre-1.5 default update behavior.</li>
<li>unknown - Depth undetermined or ignored</li>
</ul>

<p>Copyright &copy; 2004-2009 Barry A. Scott. All rigths reserved.</p>
<script type="text/javascript">
// expect this to fail on IE and other browsers that don't support
changeDisplay( 1009000 );
changeVisual( "hilite" );
// good we can toggle the display turn on the buttons
document.getElementById( "buttons_work" ).style.display = "block";
document.getElementById( "buttons_broken" ).style.display = "none";
</script>
</body>
</html>

${this.title}

Code Editor : pysvn_prog_ref.html